@babel/standalone
Version:
Standalone build of Babel for use in non-Node.js environments.
1,385 lines (1,360 loc) • 5.22 MB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Babel = {}));
})(this, (function (exports) { 'use strict';
var NodePath_context = /*#__PURE__*/Object.freeze({
__proto__: null,
get _call () { return _call; },
get _getQueueContexts () { return _getQueueContexts; },
get _resyncKey () { return _resyncKey; },
get _resyncList () { return _resyncList; },
get _resyncParent () { return _resyncParent; },
get _resyncRemoved () { return _resyncRemoved; },
get call () { return call; },
get isDenylisted () { return isDenylisted; },
get popContext () { return popContext; },
get pushContext () { return pushContext; },
get requeue () { return requeue; },
get requeueComputedKeyAndDecorators () { return requeueComputedKeyAndDecorators; },
get resync () { return resync; },
get setContext () { return setContext; },
get setKey () { return setKey; },
get setScope () { return setScope; },
get setup () { return setup; },
get skip () { return skip; },
get skipKey () { return skipKey; },
get stop () { return stop; },
get visit () { return visit; }
});
var _babel = /*#__PURE__*/Object.freeze({
__proto__: null,
get DEFAULT_EXTENSIONS () { return DEFAULT_EXTENSIONS; },
get File () { return File; },
get buildExternalHelpers () { return babelBuildExternalHelpers; },
get createConfigItem () { return createConfigItem; },
get createConfigItemAsync () { return createConfigItemAsync; },
get createConfigItemSync () { return createConfigItemSync; },
get getEnv () { return getEnv; },
get loadOptions () { return loadOptions; },
get loadOptionsAsync () { return loadOptionsAsync; },
get loadOptionsSync () { return loadOptionsSync; },
get loadPartialConfig () { return loadPartialConfig; },
get loadPartialConfigAsync () { return loadPartialConfigAsync; },
get loadPartialConfigSync () { return loadPartialConfigSync; },
get parse () { return parse$1; },
get parseAsync () { return parseAsync; },
get parseSync () { return parseSync; },
get resolvePlugin () { return resolvePlugin; },
get resolvePreset () { return resolvePreset; },
get template () { return template$2; },
get tokTypes () { return tokTypes; },
get transform () { return transform$3; },
get transformAsync () { return transformAsync; },
get transformFile () { return transformFile; },
get transformFileAsync () { return transformFileAsync; },
get transformFileSync () { return transformFileSync; },
get transformFromAst () { return transformFromAst$1; },
get transformFromAstAsync () { return transformFromAstAsync; },
get transformFromAstSync () { return transformFromAstSync; },
get transformSync () { return transformSync; },
get traverse () { return traverse; },
get types () { return t$4; },
get version () { return version$1; }
});
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _arrayWithHoles(r) {
if (Array.isArray(r)) return r;
}
function _arrayWithoutHoles(r) {
if (Array.isArray(r)) return _arrayLikeToArray(r);
}
function asyncGeneratorStep(n, t, e, r, o, a, c) {
try {
var i = n[a](c),
u = i.value;
} catch (n) {
return void e(n);
}
i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator(n) {
return function () {
var t = this,
e = arguments;
return new Promise(function (r, o) {
var a = n.apply(t, e);
function _next(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
}
function _throw(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
}
_next(void 0);
});
};
}
function _construct(t, e, r) {
if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
var o = [null];
o.push.apply(o, e);
var p = new (t.bind.apply(t, o))();
return r && _setPrototypeOf(p, r.prototype), p;
}
function _defineProperties(e, r) {
for (var t = 0; t < r.length; t++) {
var o = r[t];
o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
}
}
function _createClass(e, r, t) {
return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
writable: !1
}), e;
}
function _createForOfIteratorHelperLoose(r, e) {
var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (t) return (t = t.call(r)).next.bind(t);
if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
t && (r = t);
var o = 0;
return function () {
return o >= r.length ? {
done: !0
} : {
done: !1,
value: r[o++]
};
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _getPrototypeOf(t) {
return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
}, _getPrototypeOf(t);
}
function _inherits(t, e) {
if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
t.prototype = Object.create(e && e.prototype, {
constructor: {
value: t,
writable: !0,
configurable: !0
}
}), Object.defineProperty(t, "prototype", {
writable: !1
}), e && _setPrototypeOf(t, e);
}
function _isNativeFunction(t) {
try {
return -1 !== Function.toString.call(t).indexOf("[native code]");
} catch (n) {
return "function" == typeof t;
}
}
function _isNativeReflectConstruct() {
try {
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
} catch (t) {}
return (_isNativeReflectConstruct = function () {
return !!t;
})();
}
function _iterableToArray(r) {
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _iterableToArrayLimit(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e,
n,
i,
u,
a = [],
f = !0,
o = !1;
try {
if (i = (t = t.call(r)).next, 0 === l) {
if (Object(t) !== t) return;
f = !1;
} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
} catch (r) {
o = !0, n = r;
} finally {
try {
if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _objectWithoutProperties(e, t) {
if (null == e) return {};
var o,
r,
i = _objectWithoutPropertiesLoose(e, t);
if (Object.getOwnPropertySymbols) {
var n = Object.getOwnPropertySymbols(e);
for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
}
return i;
}
function _objectWithoutPropertiesLoose(r, e) {
if (null == r) return {};
var t = {};
for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
if (-1 !== e.indexOf(n)) continue;
t[n] = r[n];
}
return t;
}
function _regenerator() {
/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
var e,
t,
r = "function" == typeof Symbol ? Symbol : {},
n = r.iterator || "@@iterator",
o = r.toStringTag || "@@toStringTag";
function i(r, n, o, i) {
var c = n && n.prototype instanceof Generator ? n : Generator,
u = Object.create(c.prototype);
return _regeneratorDefine(u, "_invoke", function (r, n, o) {
var i,
c,
u,
f = 0,
p = o || [],
y = !1,
G = {
p: 0,
n: 0,
v: e,
a: d,
f: d.bind(e, 4),
d: function (t, r) {
return i = t, c = 0, u = e, G.n = r, a;
}
};
function d(r, n) {
for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
var o,
i = p[t],
d = G.p,
l = i[2];
r > 3 ? (o = l === n) && (c = i[4] || 3, u = i[5] === e ? i[3] : i[5], i[4] = 3, i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
}
if (o || r > 1) return a;
throw y = !0, n;
}
return function (o, p, l) {
if (f > 1) throw TypeError("Generator is already running");
for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
try {
if (f = 2, i) {
if (c || (o = "next"), t = i[o]) {
if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
if (!t.done) return t;
u = t.value, c < 2 && (c = 0);
} else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
i = e;
} else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
} catch (t) {
i = e, c = 1, u = t;
} finally {
f = 1;
}
}
return {
value: t,
done: y
};
};
}(r, o, i), !0), u;
}
var a = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
t = Object.getPrototypeOf;
var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
return this;
}), t),
u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
function f(e) {
return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
return this;
}), _regeneratorDefine(u, "toString", function () {
return "[object Generator]";
}), (_regenerator = function () {
return {
w: i,
m: f
};
})();
}
function _regeneratorDefine(e, r, n, t) {
var i = Object.defineProperty;
try {
i({}, "", {});
} catch (e) {
i = 0;
}
_regeneratorDefine = function (e, r, n, t) {
if (r) i ? i(e, r, {
value: n,
enumerable: !t,
configurable: !t,
writable: !t
}) : e[r] = n;else {
function o(r, n) {
_regeneratorDefine(e, r, function (e) {
return this._invoke(r, n, e);
});
}
o("next", 0), o("throw", 1), o("return", 2);
}
}, _regeneratorDefine(e, r, n, t);
}
function _regeneratorValues(e) {
if (null != e) {
var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
r = 0;
if (t) return t.call(e);
if ("function" == typeof e.next) return e;
if (!isNaN(e.length)) return {
next: function () {
return e && r >= e.length && (e = void 0), {
value: e && e[r++],
done: !e
};
}
};
}
throw new TypeError(typeof e + " is not iterable");
}
function _setPrototypeOf(t, e) {
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
return t.__proto__ = e, t;
}, _setPrototypeOf(t, e);
}
function _slicedToArray(r, e) {
return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _taggedTemplateLiteralLoose(e, t) {
return t || (t = e.slice(0)), e.raw = t, e;
}
function _toConsumableArray(r) {
return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r);
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (String )(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
}
}
function _wrapNativeSuper(t) {
var r = "function" == typeof Map ? new Map() : void 0;
return _wrapNativeSuper = function (t) {
if (null === t || !_isNativeFunction(t)) return t;
if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
if (void 0 !== r) {
if (r.has(t)) return r.get(t);
r.set(t, Wrapper);
}
function Wrapper() {
return _construct(t, arguments, _getPrototypeOf(this).constructor);
}
return Wrapper.prototype = Object.create(t.prototype, {
constructor: {
value: Wrapper,
enumerable: !1,
writable: !0,
configurable: !0
}
}), _setPrototypeOf(Wrapper, t);
}, _wrapNativeSuper(t);
}
var global$1 = (typeof global !== "undefined" ? global :
typeof self !== "undefined" ? self :
typeof window !== "undefined" ? window : {});
// shim for using process in browser
// based off https://github.com/defunctzombie/node-process/blob/master/browser.js
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
throw new Error('clearTimeout has not been defined');
}
var cachedSetTimeout = defaultSetTimout;
var cachedClearTimeout = defaultClearTimeout;
if (typeof global$1.setTimeout === 'function') {
cachedSetTimeout = setTimeout;
}
if (typeof global$1.clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
}
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
//normal enviroments in sane situations
return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout(fun, 0);
} catch(e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout.call(null, fun, 0);
} catch(e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout(marker);
} catch (e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedClearTimeout.call(null, marker);
} catch (e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
function nextTick(fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
}
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
var title = 'browser';
var platform = 'browser';
var browser$2 = true;
var env$1 = {};
var argv = [];
var version$2 = ''; // empty string to avoid regexp issues
var versions$2 = {};
var release = {};
var config$1 = {};
function noop$2() {}
var on = noop$2;
var addListener = noop$2;
var once$1 = noop$2;
var off = noop$2;
var removeListener = noop$2;
var removeAllListeners = noop$2;
var emit = noop$2;
function binding(name) {
throw new Error('process.binding is not supported');
}
function cwd () { return '/' }
function chdir (dir) {
throw new Error('process.chdir is not supported');
}function umask() { return 0; }
// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
var performance = global$1.performance || {};
var performanceNow =
performance.now ||
performance.mozNow ||
performance.msNow ||
performance.oNow ||
performance.webkitNow ||
function(){ return (new Date()).getTime() };
// generate timestamp or delta
// see http://nodejs.org/api/process.html#process_process_hrtime
function hrtime(previousTimestamp){
var clocktime = performanceNow.call(performance)*1e-3;
var seconds = Math.floor(clocktime);
var nanoseconds = Math.floor((clocktime%1)*1e9);
if (previousTimestamp) {
seconds = seconds - previousTimestamp[0];
nanoseconds = nanoseconds - previousTimestamp[1];
if (nanoseconds<0) {
seconds--;
nanoseconds += 1e9;
}
}
return [seconds,nanoseconds]
}
var startTime = new Date();
function uptime() {
var currentTime = new Date();
var dif = currentTime - startTime;
return dif / 1000;
}
var browser$1$1 = {
nextTick: nextTick,
title: title,
browser: browser$2,
env: env$1,
argv: argv,
version: version$2,
versions: versions$2,
on: on,
addListener: addListener,
once: once$1,
off: off,
removeListener: removeListener,
removeAllListeners: removeAllListeners,
emit: emit,
binding: binding,
cwd: cwd,
chdir: chdir,
umask: umask,
hrtime: hrtime,
platform: platform,
release: release,
config: config$1,
uptime: uptime
};
function shallowEqual(actual, expected) {
var keys = Object.keys(expected);
for (var _i = 0, _keys = keys; _i < _keys.length; _i++) {
var key = _keys[_i];
if (actual[key] !== expected[key]) {
return false;
}
}
return true;
}
var warnings = new Set();
function deprecationWarning$1(oldName, newName, prefix, cacheKey) {
if (prefix === void 0) {
prefix = "";
}
if (cacheKey === void 0) {
cacheKey = oldName;
}
if (warnings.has(cacheKey)) return;
warnings.add(cacheKey);
var _captureShortStackTra = captureShortStackTrace(1, 2),
internal = _captureShortStackTra.internal,
trace = _captureShortStackTra.trace;
if (internal) {
return;
}
console.warn(prefix + "`" + oldName + "` has been deprecated, please migrate to `" + newName + "`\n" + trace);
}
function captureShortStackTrace(skip, length) {
var stackTraceLimit = Error.stackTraceLimit,
prepareStackTrace = Error.prepareStackTrace;
var stackTrace;
Error.stackTraceLimit = 1 + skip + length;
Error.prepareStackTrace = function (err, stack) {
stackTrace = stack;
};
new Error().stack;
Error.stackTraceLimit = stackTraceLimit;
Error.prepareStackTrace = prepareStackTrace;
if (!stackTrace) return {
internal: false,
trace: ""
};
var shortStackTrace = stackTrace.slice(1 + skip, 1 + skip + length);
return {
internal: /[\\/]@babel[\\/]/.test(shortStackTrace[1].getFileName()),
trace: shortStackTrace.map(function (frame) {
return " at " + frame;
}).join("\n")
};
}
function isArrayExpression$2(node, opts) {
if (!node) return false;
if (node.type !== "ArrayExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isAssignmentExpression$2(node, opts) {
if (!node) return false;
if (node.type !== "AssignmentExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isBinaryExpression$1(node, opts) {
if (!node) return false;
if (node.type !== "BinaryExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isInterpreterDirective(node, opts) {
if (!node) return false;
if (node.type !== "InterpreterDirective") return false;
return opts == null || shallowEqual(node, opts);
}
function isDirective(node, opts) {
if (!node) return false;
if (node.type !== "Directive") return false;
return opts == null || shallowEqual(node, opts);
}
function isDirectiveLiteral(node, opts) {
if (!node) return false;
if (node.type !== "DirectiveLiteral") return false;
return opts == null || shallowEqual(node, opts);
}
function isBlockStatement$3(node, opts) {
if (!node) return false;
if (node.type !== "BlockStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isBreakStatement(node, opts) {
if (!node) return false;
if (node.type !== "BreakStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isCallExpression$8(node, opts) {
if (!node) return false;
if (node.type !== "CallExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isCatchClause(node, opts) {
if (!node) return false;
if (node.type !== "CatchClause") return false;
return opts == null || shallowEqual(node, opts);
}
function isConditionalExpression(node, opts) {
if (!node) return false;
if (node.type !== "ConditionalExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isContinueStatement(node, opts) {
if (!node) return false;
if (node.type !== "ContinueStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isDebuggerStatement(node, opts) {
if (!node) return false;
if (node.type !== "DebuggerStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isDoWhileStatement(node, opts) {
if (!node) return false;
if (node.type !== "DoWhileStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isEmptyStatement$1(node, opts) {
if (!node) return false;
if (node.type !== "EmptyStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isExpressionStatement$2(node, opts) {
if (!node) return false;
if (node.type !== "ExpressionStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isFile(node, opts) {
if (!node) return false;
if (node.type !== "File") return false;
return opts == null || shallowEqual(node, opts);
}
function isForInStatement(node, opts) {
if (!node) return false;
if (node.type !== "ForInStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isForStatement$2(node, opts) {
if (!node) return false;
if (node.type !== "ForStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isFunctionDeclaration$2(node, opts) {
if (!node) return false;
if (node.type !== "FunctionDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isFunctionExpression(node, opts) {
if (!node) return false;
if (node.type !== "FunctionExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isIdentifier$e(node, opts) {
if (!node) return false;
if (node.type !== "Identifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isIfStatement$2(node, opts) {
if (!node) return false;
if (node.type !== "IfStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isLabeledStatement(node, opts) {
if (!node) return false;
if (node.type !== "LabeledStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isStringLiteral$5(node, opts) {
if (!node) return false;
if (node.type !== "StringLiteral") return false;
return opts == null || shallowEqual(node, opts);
}
function isNumericLiteral(node, opts) {
if (!node) return false;
if (node.type !== "NumericLiteral") return false;
return opts == null || shallowEqual(node, opts);
}
function isNullLiteral$1(node, opts) {
if (!node) return false;
if (node.type !== "NullLiteral") return false;
return opts == null || shallowEqual(node, opts);
}
function isBooleanLiteral(node, opts) {
if (!node) return false;
if (node.type !== "BooleanLiteral") return false;
return opts == null || shallowEqual(node, opts);
}
function isRegExpLiteral$1(node, opts) {
if (!node) return false;
if (node.type !== "RegExpLiteral") return false;
return opts == null || shallowEqual(node, opts);
}
function isLogicalExpression(node, opts) {
if (!node) return false;
if (node.type !== "LogicalExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isMemberExpression$7(node, opts) {
if (!node) return false;
if (node.type !== "MemberExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isNewExpression$3(node, opts) {
if (!node) return false;
if (node.type !== "NewExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isProgram$1(node, opts) {
if (!node) return false;
if (node.type !== "Program") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectExpression$3(node, opts) {
if (!node) return false;
if (node.type !== "ObjectExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectMethod(node, opts) {
if (!node) return false;
if (node.type !== "ObjectMethod") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectProperty$2(node, opts) {
if (!node) return false;
if (node.type !== "ObjectProperty") return false;
return opts == null || shallowEqual(node, opts);
}
function isRestElement$2(node, opts) {
if (!node) return false;
if (node.type !== "RestElement") return false;
return opts == null || shallowEqual(node, opts);
}
function isReturnStatement(node, opts) {
if (!node) return false;
if (node.type !== "ReturnStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isSequenceExpression$1(node, opts) {
if (!node) return false;
if (node.type !== "SequenceExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isParenthesizedExpression$2(node, opts) {
if (!node) return false;
if (node.type !== "ParenthesizedExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isSwitchCase(node, opts) {
if (!node) return false;
if (node.type !== "SwitchCase") return false;
return opts == null || shallowEqual(node, opts);
}
function isSwitchStatement(node, opts) {
if (!node) return false;
if (node.type !== "SwitchStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isThisExpression$2(node, opts) {
if (!node) return false;
if (node.type !== "ThisExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isThrowStatement(node, opts) {
if (!node) return false;
if (node.type !== "ThrowStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isTryStatement(node, opts) {
if (!node) return false;
if (node.type !== "TryStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isUnaryExpression$1(node, opts) {
if (!node) return false;
if (node.type !== "UnaryExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isUpdateExpression$1(node, opts) {
if (!node) return false;
if (node.type !== "UpdateExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isVariableDeclaration$3(node, opts) {
if (!node) return false;
if (node.type !== "VariableDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isVariableDeclarator(node, opts) {
if (!node) return false;
if (node.type !== "VariableDeclarator") return false;
return opts == null || shallowEqual(node, opts);
}
function isWhileStatement(node, opts) {
if (!node) return false;
if (node.type !== "WhileStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isWithStatement(node, opts) {
if (!node) return false;
if (node.type !== "WithStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isAssignmentPattern$3(node, opts) {
if (!node) return false;
if (node.type !== "AssignmentPattern") return false;
return opts == null || shallowEqual(node, opts);
}
function isArrayPattern(node, opts) {
if (!node) return false;
if (node.type !== "ArrayPattern") return false;
return opts == null || shallowEqual(node, opts);
}
function isArrowFunctionExpression(node, opts) {
if (!node) return false;
if (node.type !== "ArrowFunctionExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassBody$2(node, opts) {
if (!node) return false;
if (node.type !== "ClassBody") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassExpression(node, opts) {
if (!node) return false;
if (node.type !== "ClassExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassDeclaration$2(node, opts) {
if (!node) return false;
if (node.type !== "ClassDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isExportAllDeclaration$1(node, opts) {
if (!node) return false;
if (node.type !== "ExportAllDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isExportDefaultDeclaration$2(node, opts) {
if (!node) return false;
if (node.type !== "ExportDefaultDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isExportNamedDeclaration$3(node, opts) {
if (!node) return false;
if (node.type !== "ExportNamedDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isExportSpecifier(node, opts) {
if (!node) return false;
if (node.type !== "ExportSpecifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isForOfStatement$2(node, opts) {
if (!node) return false;
if (node.type !== "ForOfStatement") return false;
return opts == null || shallowEqual(node, opts);
}
function isImportDeclaration$3(node, opts) {
if (!node) return false;
if (node.type !== "ImportDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isImportDefaultSpecifier$1(node, opts) {
if (!node) return false;
if (node.type !== "ImportDefaultSpecifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isImportNamespaceSpecifier$1(node, opts) {
if (!node) return false;
if (node.type !== "ImportNamespaceSpecifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isImportSpecifier$1(node, opts) {
if (!node) return false;
if (node.type !== "ImportSpecifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isImportExpression(node, opts) {
if (!node) return false;
if (node.type !== "ImportExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isMetaProperty$1(node, opts) {
if (!node) return false;
if (node.type !== "MetaProperty") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassMethod(node, opts) {
if (!node) return false;
if (node.type !== "ClassMethod") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectPattern$1(node, opts) {
if (!node) return false;
if (node.type !== "ObjectPattern") return false;
return opts == null || shallowEqual(node, opts);
}
function isSpreadElement$1(node, opts) {
if (!node) return false;
if (node.type !== "SpreadElement") return false;
return opts == null || shallowEqual(node, opts);
}
function isSuper$2(node, opts) {
if (!node) return false;
if (node.type !== "Super") return false;
return opts == null || shallowEqual(node, opts);
}
function isTaggedTemplateExpression$1(node, opts) {
if (!node) return false;
if (node.type !== "TaggedTemplateExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isTemplateElement(node, opts) {
if (!node) return false;
if (node.type !== "TemplateElement") return false;
return opts == null || shallowEqual(node, opts);
}
function isTemplateLiteral$1(node, opts) {
if (!node) return false;
if (node.type !== "TemplateLiteral") return false;
return opts == null || shallowEqual(node, opts);
}
function isYieldExpression$1(node, opts) {
if (!node) return false;
if (node.type !== "YieldExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isAwaitExpression(node, opts) {
if (!node) return false;
if (node.type !== "AwaitExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isImport(node, opts) {
if (!node) return false;
if (node.type !== "Import") return false;
return opts == null || shallowEqual(node, opts);
}
function isBigIntLiteral(node, opts) {
if (!node) return false;
if (node.type !== "BigIntLiteral") return false;
return opts == null || shallowEqual(node, opts);
}
function isExportNamespaceSpecifier$1(node, opts) {
if (!node) return false;
if (node.type !== "ExportNamespaceSpecifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isOptionalMemberExpression$3(node, opts) {
if (!node) return false;
if (node.type !== "OptionalMemberExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isOptionalCallExpression$2(node, opts) {
if (!node) return false;
if (node.type !== "OptionalCallExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassProperty(node, opts) {
if (!node) return false;
if (node.type !== "ClassProperty") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassAccessorProperty(node, opts) {
if (!node) return false;
if (node.type !== "ClassAccessorProperty") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassPrivateProperty(node, opts) {
if (!node) return false;
if (node.type !== "ClassPrivateProperty") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassPrivateMethod(node, opts) {
if (!node) return false;
if (node.type !== "ClassPrivateMethod") return false;
return opts == null || shallowEqual(node, opts);
}
function isPrivateName$2(node, opts) {
if (!node) return false;
if (node.type !== "PrivateName") return false;
return opts == null || shallowEqual(node, opts);
}
function isStaticBlock(node, opts) {
if (!node) return false;
if (node.type !== "StaticBlock") return false;
return opts == null || shallowEqual(node, opts);
}
function isImportAttribute(node, opts) {
if (!node) return false;
if (node.type !== "ImportAttribute") return false;
return opts == null || shallowEqual(node, opts);
}
function isAnyTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "AnyTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isArrayTypeAnnotation$2(node, opts) {
if (!node) return false;
if (node.type !== "ArrayTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isBooleanTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "BooleanTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isBooleanLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "BooleanLiteralTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isNullLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "NullLiteralTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isClassImplements(node, opts) {
if (!node) return false;
if (node.type !== "ClassImplements") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareClass(node, opts) {
if (!node) return false;
if (node.type !== "DeclareClass") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareFunction(node, opts) {
if (!node) return false;
if (node.type !== "DeclareFunction") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareInterface(node, opts) {
if (!node) return false;
if (node.type !== "DeclareInterface") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareModule(node, opts) {
if (!node) return false;
if (node.type !== "DeclareModule") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareModuleExports(node, opts) {
if (!node) return false;
if (node.type !== "DeclareModuleExports") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareTypeAlias(node, opts) {
if (!node) return false;
if (node.type !== "DeclareTypeAlias") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareOpaqueType(node, opts) {
if (!node) return false;
if (node.type !== "DeclareOpaqueType") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareVariable(node, opts) {
if (!node) return false;
if (node.type !== "DeclareVariable") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareExportDeclaration$1(node, opts) {
if (!node) return false;
if (node.type !== "DeclareExportDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclareExportAllDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "DeclareExportAllDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isDeclaredPredicate(node, opts) {
if (!node) return false;
if (node.type !== "DeclaredPredicate") return false;
return opts == null || shallowEqual(node, opts);
}
function isExistsTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "ExistsTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isFunctionTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "FunctionTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isFunctionTypeParam(node, opts) {
if (!node) return false;
if (node.type !== "FunctionTypeParam") return false;
return opts == null || shallowEqual(node, opts);
}
function isGenericTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "GenericTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isInferredPredicate(node, opts) {
if (!node) return false;
if (node.type !== "InferredPredicate") return false;
return opts == null || shallowEqual(node, opts);
}
function isInterfaceExtends(node, opts) {
if (!node) return false;
if (node.type !== "InterfaceExtends") return false;
return opts == null || shallowEqual(node, opts);
}
function isInterfaceDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "InterfaceDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isInterfaceTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "InterfaceTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isIntersectionTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "IntersectionTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isMixedTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "MixedTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isEmptyTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "EmptyTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isNullableTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "NullableTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isNumberLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "NumberLiteralTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isNumberTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "NumberTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectTypeInternalSlot(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeInternalSlot") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectTypeCallProperty(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeCallProperty") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectTypeIndexer(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeIndexer") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectTypeProperty(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeProperty") return false;
return opts == null || shallowEqual(node, opts);
}
function isObjectTypeSpreadProperty(node, opts) {
if (!node) return false;
if (node.type !== "ObjectTypeSpreadProperty") return false;
return opts == null || shallowEqual(node, opts);
}
function isOpaqueType(node, opts) {
if (!node) return false;
if (node.type !== "OpaqueType") return false;
return opts == null || shallowEqual(node, opts);
}
function isQualifiedTypeIdentifier(node, opts) {
if (!node) return false;
if (node.type !== "QualifiedTypeIdentifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isStringLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "StringLiteralTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isStringTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "StringTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isSymbolTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "SymbolTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isThisTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "ThisTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isTupleTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "TupleTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isTypeofTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "TypeofTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isTypeAlias(node, opts) {
if (!node) return false;
if (node.type !== "TypeAlias") return false;
return opts == null || shallowEqual(node, opts);
}
function isTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "TypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isTypeCastExpression$1(node, opts) {
if (!node) return false;
if (node.type !== "TypeCastExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isTypeParameter(node, opts) {
if (!node) return false;
if (node.type !== "TypeParameter") return false;
return opts == null || shallowEqual(node, opts);
}
function isTypeParameterDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "TypeParameterDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
fu