@babel/standalone
Version:
Standalone build of Babel for use in non-Node.js environments.
1,341 lines (1,335 loc) • 4.44 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 _babelCore = {
__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; },
get parseAsync () { return parseAsync; },
get parseSync () { return parseSync; },
get resolvePlugin () { return resolvePlugin; },
get resolvePreset () { return resolvePreset; },
get template () { return template; },
get tokTypes () { return tokTypes; },
get transform () { return transform$2; },
get transformAsync () { return transformAsync$1; },
get transformFile () { return transformFile; },
get transformFileAsync () { return transformFileAsync; },
get transformFileSync () { return transformFileSync; },
get transformFromAst () { return transformFromAst$1; },
get transformFromAstAsync () { return transformFromAstAsync$1; },
get transformFromAstSync () { return transformFromAstSync; },
get transformSync () { return transformSync; },
get traverse () { return traverse; },
get types () { return t; },
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 _assertClassBrand(e, t, n) {
if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
throw new TypeError("Private element is not present on this object");
}
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 _checkPrivateRedeclaration(e, t) {
if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
}
function _classPrivateFieldGet2(s, a) {
return s.get(_assertClassBrand(s, a));
}
function _classPrivateFieldInitSpec(e, t, a) {
_checkPrivateRedeclaration(e, t), t.set(e, a);
}
function _classPrivateFieldSet2(s, a, r) {
return s.set(_assertClassBrand(s, a), r), r;
}
function _classPrivateMethodInitSpec(e, a) {
_checkPrivateRedeclaration(e, a), a.add(e);
}
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 || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
}
}
function _createClass(e, r, t) {
return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
writable: false
}), 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: true
} : {
done: false,
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 _defineProperty(e, r, t) {
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
value: t,
enumerable: true,
configurable: true,
writable: true
}) : e[r] = t, e;
}
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: true,
configurable: true
}
}), Object.defineProperty(t, "prototype", {
writable: false
}), 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 = true,
o = false;
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 = true, 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 = false,
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) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = 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 = true, 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), true), 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) {
function o(r, n) {
_regeneratorDefine(e, r, function (e) {
return this._invoke(r, n, e);
});
}
r ? i ? i(e, r, {
value: n,
enumerable: !t,
configurable: !t,
writable: !t
}) : e[r] = n : (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" === r ? String : Number)(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: false,
writable: true,
configurable: true
}
}), _setPrototypeOf(Wrapper, t);
}, _wrapNativeSuper(t);
}
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$1(node, opts) {
if (!node) return false;
if (node.type !== "ArrayExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isAssignmentExpression$1(node, opts) {
if (!node) return false;
if (node.type !== "AssignmentExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isBinaryExpression(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$2(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$5(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$1(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$c(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$4(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$5(node, opts) {
if (!node) return false;
if (node.type !== "MemberExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isNewExpression$2(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$1(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$1(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$1(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 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(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 isImportExpression(node, opts) {
if (!node) return false;
if (node.type !== "ImportExpression") 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$2(node, opts) {
if (!node) return false;
if (node.type !== "OptionalMemberExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isOptionalCallExpression$1(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 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$1(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 isBigIntLiteralTypeAnnotation(node, opts) {
if (!node) return false;
if (node.type !== "BigIntLiteralTypeAnnotation") 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);
}
function isTypeParameterInstantiation(node, opts) {
if (!node) return false;
if (node.type !== "TypeParameterInstantiation") return false;
return opts == null || shallowEqual(node, opts);
}
function isUnionTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "UnionTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isVariance(node, opts) {
if (!node) return false;
if (node.type !== "Variance") return false;
return opts == null || shallowEqual(node, opts);
}
function isVoidTypeAnnotation$1(node, opts) {
if (!node) return false;
if (node.type !== "VoidTypeAnnotation") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumDeclaration(node, opts) {
if (!node) return false;
if (node.type !== "EnumDeclaration") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumBooleanBody(node, opts) {
if (!node) return false;
if (node.type !== "EnumBooleanBody") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumNumberBody(node, opts) {
if (!node) return false;
if (node.type !== "EnumNumberBody") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumStringBody(node, opts) {
if (!node) return false;
if (node.type !== "EnumStringBody") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumSymbolBody(node, opts) {
if (!node) return false;
if (node.type !== "EnumSymbolBody") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumBooleanMember(node, opts) {
if (!node) return false;
if (node.type !== "EnumBooleanMember") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumNumberMember(node, opts) {
if (!node) return false;
if (node.type !== "EnumNumberMember") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumStringMember(node, opts) {
if (!node) return false;
if (node.type !== "EnumStringMember") return false;
return opts == null || shallowEqual(node, opts);
}
function isEnumDefaultedMember(node, opts) {
if (!node) return false;
if (node.type !== "EnumDefaultedMember") return false;
return opts == null || shallowEqual(node, opts);
}
function isIndexedAccessType(node, opts) {
if (!node) return false;
if (node.type !== "IndexedAccessType") return false;
return opts == null || shallowEqual(node, opts);
}
function isOptionalIndexedAccessType(node, opts) {
if (!node) return false;
if (node.type !== "OptionalIndexedAccessType") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXAttribute(node, opts) {
if (!node) return false;
if (node.type !== "JSXAttribute") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXClosingElement(node, opts) {
if (!node) return false;
if (node.type !== "JSXClosingElement") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXElement(node, opts) {
if (!node) return false;
if (node.type !== "JSXElement") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXEmptyExpression(node, opts) {
if (!node) return false;
if (node.type !== "JSXEmptyExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXExpressionContainer$1(node, opts) {
if (!node) return false;
if (node.type !== "JSXExpressionContainer") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXSpreadChild(node, opts) {
if (!node) return false;
if (node.type !== "JSXSpreadChild") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXIdentifier$3(node, opts) {
if (!node) return false;
if (node.type !== "JSXIdentifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXMemberExpression$2(node, opts) {
if (!node) return false;
if (node.type !== "JSXMemberExpression") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXNamespacedName$1(node, opts) {
if (!node) return false;
if (node.type !== "JSXNamespacedName") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXOpeningElement(node, opts) {
if (!node) return false;
if (node.type !== "JSXOpeningElement") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXSpreadAttribute$1(node, opts) {
if (!node) return false;
if (node.type !== "JSXSpreadAttribute") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXText(node, opts) {
if (!node) return false;
if (node.type !== "JSXText") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXFragment(node, opts) {
if (!node) return false;
if (node.type !== "JSXFragment") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXOpeningFragment(node, opts) {
if (!node) return false;
if (node.type !== "JSXOpeningFragment") return false;
return opts == null || shallowEqual(node, opts);
}
function isJSXClosingFragment(node, opts) {
if (!node) return false;
if (node.type !== "JSXClosingFragment") return false;
return opts == null || shallowEqual(node, opts);
}
function isPlaceholder$1(node, opts) {
if (!node) return false;
if (node.type !== "Placeholder") return false;
return opts == null || shallowEqual(node, opts);
}
function isV8IntrinsicIdentifier(node, opts) {
if (!node) return false;
if (node.type !== "V8IntrinsicIdentifier") return false;
return opts == null || shallowEqual(node, opts);
}
function isArgumentPlaceholder(node, opts) {
if (!node) return false;
if (node.type !== "ArgumentPlaceholder") return false;
return opts == null || shallowEqual(node, opts);
}
function isBindExpression(node, opts) {
if (!node) return false;
if (node.type !== "BindExpression") 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 isDecorator(node, opts) {
if (!node) return false;
if (node.type !== "Decorator") return false;
return opts == null || shallowEqual(node, opts);
}
function isDoExpression(node, opts) {