@babel/standalone
Version:
Standalone build of Babel for use in non-Node.js environments.
1,395 lines (1,369 loc) • 5.19 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$1; }
});
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 _regeneratorRuntime() {
_regeneratorRuntime = function () {
return e;
};
var t,
e = {},
r = Object.prototype,
n = r.hasOwnProperty,
o = Object.defineProperty || function (t, e, r) {
t[e] = r.value;
},
i = "function" == typeof Symbol ? Symbol : {},
a = i.iterator || "@@iterator",
c = i.asyncIterator || "@@asyncIterator",
u = i.toStringTag || "@@toStringTag";
function define(t, e, r) {
return Object.defineProperty(t, e, {
value: r,
enumerable: !0,
configurable: !0,
writable: !0
}), t[e];
}
try {
define({}, "");
} catch (t) {
define = function (t, e, r) {
return t[e] = r;
};
}
function wrap(t, e, r, n) {
var i = e && e.prototype instanceof Generator ? e : Generator,
a = Object.create(i.prototype),
c = new Context(n || []);
return o(a, "_invoke", {
value: makeInvokeMethod(t, r, c)
}), a;
}
function tryCatch(t, e, r) {
try {
return {
type: "normal",
arg: t.call(e, r)
};
} catch (t) {
return {
type: "throw",
arg: t
};
}
}
e.wrap = wrap;
var h = "suspendedStart",
l = "suspendedYield",
f = "executing",
s = "completed",
y = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var p = {};
define(p, a, function () {
return this;
});
var d = Object.getPrototypeOf,
v = d && d(d(values([])));
v && v !== r && n.call(v, a) && (p = v);
var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
function defineIteratorMethods(t) {
["next", "throw", "return"].forEach(function (e) {
define(t, e, function (t) {
return this._invoke(e, t);
});
});
}
function AsyncIterator(t, e) {
function invoke(r, o, i, a) {
var c = tryCatch(t[r], t, o);
if ("throw" !== c.type) {
var u = c.arg,
h = u.value;
return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
invoke("next", t, i, a);
}, function (t) {
invoke("throw", t, i, a);
}) : e.resolve(h).then(function (t) {
u.value = t, i(u);
}, function (t) {
return invoke("throw", t, i, a);
});
}
a(c.arg);
}
var r;
o(this, "_invoke", {
value: function (t, n) {
function callInvokeWithMethodAndArg() {
return new e(function (e, r) {
invoke(t, n, e, r);
});
}
return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
}
});
}
function makeInvokeMethod(e, r, n) {
var o = h;
return function (i, a) {
if (o === f) throw Error("Generator is already running");
if (o === s) {
if ("throw" === i) throw a;
return {
value: t,
done: !0
};
}
for (n.method = i, n.arg = a;;) {
var c = n.delegate;
if (c) {
var u = maybeInvokeDelegate(c, n);
if (u) {
if (u === y) continue;
return u;
}
}
if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
if (o === h) throw o = s, n.arg;
n.dispatchException(n.arg);
} else "return" === n.method && n.abrupt("return", n.arg);
o = f;
var p = tryCatch(e, r, n);
if ("normal" === p.type) {
if (o = n.done ? s : l, p.arg === y) continue;
return {
value: p.arg,
done: n.done
};
}
"throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
}
};
}
function maybeInvokeDelegate(e, r) {
var n = r.method,
o = e.iterator[n];
if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
var i = tryCatch(o, e.iterator, r.arg);
if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
var a = i.arg;
return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
}
function pushTryEntry(t) {
var e = {
tryLoc: t[0]
};
1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
}
function resetTryEntry(t) {
var e = t.completion || {};
e.type = "normal", delete e.arg, t.completion = e;
}
function Context(t) {
this.tryEntries = [{
tryLoc: "root"
}], t.forEach(pushTryEntry, this), this.reset(!0);
}
function values(e) {
if (e || "" === e) {
var r = e[a];
if (r) return r.call(e);
if ("function" == typeof e.next) return e;
if (!isNaN(e.length)) {
var o = -1,
i = function next() {
for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
return next.value = t, next.done = !0, next;
};
return i.next = i;
}
}
throw new TypeError(typeof e + " is not iterable");
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
value: GeneratorFunctionPrototype,
configurable: !0
}), o(GeneratorFunctionPrototype, "constructor", {
value: GeneratorFunction,
configurable: !0
}), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
var e = "function" == typeof t && t.constructor;
return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
}, e.mark = function (t) {
return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
}, e.awrap = function (t) {
return {
__await: t
};
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
return this;
}), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
void 0 === i && (i = Promise);
var a = new AsyncIterator(wrap(t, r, n, o), i);
return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
return t.done ? t.value : a.next();
});
}, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
return this;
}), define(g, "toString", function () {
return "[object Generator]";
}), e.keys = function (t) {
var e = Object(t),
r = [];
for (var n in e) r.push(n);
return r.reverse(), function next() {
for (; r.length;) {
var t = r.pop();
if (t in e) return next.value = t, next.done = !1, next;
}
return next.done = !0, next;
};
}, e.values = values, Context.prototype = {
constructor: Context,
reset: function (e) {
if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
},
stop: function () {
this.done = !0;
var t = this.tryEntries[0].completion;
if ("throw" === t.type) throw t.arg;
return this.rval;
},
dispatchException: function (e) {
if (this.done) throw e;
var r = this;
function handle(n, o) {
return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
}
for (var o = this.tryEntries.length - 1; o >= 0; --o) {
var i = this.tryEntries[o],
a = i.completion;
if ("root" === i.tryLoc) return handle("end");
if (i.tryLoc <= this.prev) {
var c = n.call(i, "catchLoc"),
u = n.call(i, "finallyLoc");
if (c && u) {
if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
} else if (c) {
if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
} else {
if (!u) throw Error("try statement without catch or finally");
if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
}
}
}
},
abrupt: function (t, e) {
for (var r = this.tryEntries.length - 1; r >= 0; --r) {
var o = this.tryEntries[r];
if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
var i = o;
break;
}
}
i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
var a = i ? i.completion : {};
return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
},
complete: function (t, e) {
if ("throw" === t.type) throw t.arg;
return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
},
finish: function (t) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var r = this.tryEntries[e];
if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
}
},
catch: function (t) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var r = this.tryEntries[e];
if (r.tryLoc === t) {
var n = r.completion;
if ("throw" === n.type) {
var o = n.arg;
resetTryEntry(r);
}
return o;
}
}
throw Error("illegal catch attempt");
},
delegateYield: function (e, r, n) {
return this.delegate = {
iterator: values(e),
resultName: r,
nextLoc: n
}, "next" === this.method && (this.arg = t), y;
}
}, e;
}
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$3 = 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$1 = 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$3,
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$1,
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) {
if (prefix === void 0) {
prefix = "";
}
if (warnings.has(oldName)) return;
warnings.add(oldName);
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$3(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$4(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);