5351 lines
195 KiB
JavaScript
5351 lines
195 KiB
JavaScript
this.google = this.google || {};
|
||
this.google.maps = this.google.maps || {};
|
||
this.google.maps.plugins = this.google.maps.plugins || {};
|
||
this.google.maps.plugins.loader = (function (exports) {
|
||
'use strict';
|
||
|
||
function _regeneratorRuntime() {
|
||
_regeneratorRuntime = function () {
|
||
return exports;
|
||
};
|
||
var exports = {},
|
||
Op = Object.prototype,
|
||
hasOwn = Op.hasOwnProperty,
|
||
defineProperty = Object.defineProperty || function (obj, key, desc) {
|
||
obj[key] = desc.value;
|
||
},
|
||
$Symbol = "function" == typeof Symbol ? Symbol : {},
|
||
iteratorSymbol = $Symbol.iterator || "@@iterator",
|
||
asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
|
||
toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
|
||
function define(obj, key, value) {
|
||
return Object.defineProperty(obj, key, {
|
||
value: value,
|
||
enumerable: !0,
|
||
configurable: !0,
|
||
writable: !0
|
||
}), obj[key];
|
||
}
|
||
try {
|
||
define({}, "");
|
||
} catch (err) {
|
||
define = function (obj, key, value) {
|
||
return obj[key] = value;
|
||
};
|
||
}
|
||
function wrap(innerFn, outerFn, self, tryLocsList) {
|
||
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
|
||
generator = Object.create(protoGenerator.prototype),
|
||
context = new Context(tryLocsList || []);
|
||
return defineProperty(generator, "_invoke", {
|
||
value: makeInvokeMethod(innerFn, self, context)
|
||
}), generator;
|
||
}
|
||
function tryCatch(fn, obj, arg) {
|
||
try {
|
||
return {
|
||
type: "normal",
|
||
arg: fn.call(obj, arg)
|
||
};
|
||
} catch (err) {
|
||
return {
|
||
type: "throw",
|
||
arg: err
|
||
};
|
||
}
|
||
}
|
||
exports.wrap = wrap;
|
||
var ContinueSentinel = {};
|
||
function Generator() {}
|
||
function GeneratorFunction() {}
|
||
function GeneratorFunctionPrototype() {}
|
||
var IteratorPrototype = {};
|
||
define(IteratorPrototype, iteratorSymbol, function () {
|
||
return this;
|
||
});
|
||
var getProto = Object.getPrototypeOf,
|
||
NativeIteratorPrototype = getProto && getProto(getProto(values([])));
|
||
NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
|
||
var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
|
||
function defineIteratorMethods(prototype) {
|
||
["next", "throw", "return"].forEach(function (method) {
|
||
define(prototype, method, function (arg) {
|
||
return this._invoke(method, arg);
|
||
});
|
||
});
|
||
}
|
||
function AsyncIterator(generator, PromiseImpl) {
|
||
function invoke(method, arg, resolve, reject) {
|
||
var record = tryCatch(generator[method], generator, arg);
|
||
if ("throw" !== record.type) {
|
||
var result = record.arg,
|
||
value = result.value;
|
||
return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
|
||
invoke("next", value, resolve, reject);
|
||
}, function (err) {
|
||
invoke("throw", err, resolve, reject);
|
||
}) : PromiseImpl.resolve(value).then(function (unwrapped) {
|
||
result.value = unwrapped, resolve(result);
|
||
}, function (error) {
|
||
return invoke("throw", error, resolve, reject);
|
||
});
|
||
}
|
||
reject(record.arg);
|
||
}
|
||
var previousPromise;
|
||
defineProperty(this, "_invoke", {
|
||
value: function (method, arg) {
|
||
function callInvokeWithMethodAndArg() {
|
||
return new PromiseImpl(function (resolve, reject) {
|
||
invoke(method, arg, resolve, reject);
|
||
});
|
||
}
|
||
return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
|
||
}
|
||
});
|
||
}
|
||
function makeInvokeMethod(innerFn, self, context) {
|
||
var state = "suspendedStart";
|
||
return function (method, arg) {
|
||
if ("executing" === state) throw new Error("Generator is already running");
|
||
if ("completed" === state) {
|
||
if ("throw" === method) throw arg;
|
||
return doneResult();
|
||
}
|
||
for (context.method = method, context.arg = arg;;) {
|
||
var delegate = context.delegate;
|
||
if (delegate) {
|
||
var delegateResult = maybeInvokeDelegate(delegate, context);
|
||
if (delegateResult) {
|
||
if (delegateResult === ContinueSentinel) continue;
|
||
return delegateResult;
|
||
}
|
||
}
|
||
if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
|
||
if ("suspendedStart" === state) throw state = "completed", context.arg;
|
||
context.dispatchException(context.arg);
|
||
} else "return" === context.method && context.abrupt("return", context.arg);
|
||
state = "executing";
|
||
var record = tryCatch(innerFn, self, context);
|
||
if ("normal" === record.type) {
|
||
if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
|
||
return {
|
||
value: record.arg,
|
||
done: context.done
|
||
};
|
||
}
|
||
"throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
|
||
}
|
||
};
|
||
}
|
||
function maybeInvokeDelegate(delegate, context) {
|
||
var methodName = context.method,
|
||
method = delegate.iterator[methodName];
|
||
if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
|
||
var record = tryCatch(method, delegate.iterator, context.arg);
|
||
if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
|
||
var info = record.arg;
|
||
return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
|
||
}
|
||
function pushTryEntry(locs) {
|
||
var entry = {
|
||
tryLoc: locs[0]
|
||
};
|
||
1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
|
||
}
|
||
function resetTryEntry(entry) {
|
||
var record = entry.completion || {};
|
||
record.type = "normal", delete record.arg, entry.completion = record;
|
||
}
|
||
function Context(tryLocsList) {
|
||
this.tryEntries = [{
|
||
tryLoc: "root"
|
||
}], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
|
||
}
|
||
function values(iterable) {
|
||
if (iterable) {
|
||
var iteratorMethod = iterable[iteratorSymbol];
|
||
if (iteratorMethod) return iteratorMethod.call(iterable);
|
||
if ("function" == typeof iterable.next) return iterable;
|
||
if (!isNaN(iterable.length)) {
|
||
var i = -1,
|
||
next = function next() {
|
||
for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
|
||
return next.value = undefined, next.done = !0, next;
|
||
};
|
||
return next.next = next;
|
||
}
|
||
}
|
||
return {
|
||
next: doneResult
|
||
};
|
||
}
|
||
function doneResult() {
|
||
return {
|
||
value: undefined,
|
||
done: !0
|
||
};
|
||
}
|
||
return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
|
||
value: GeneratorFunctionPrototype,
|
||
configurable: !0
|
||
}), defineProperty(GeneratorFunctionPrototype, "constructor", {
|
||
value: GeneratorFunction,
|
||
configurable: !0
|
||
}), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
|
||
var ctor = "function" == typeof genFun && genFun.constructor;
|
||
return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
|
||
}, exports.mark = function (genFun) {
|
||
return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
|
||
}, exports.awrap = function (arg) {
|
||
return {
|
||
__await: arg
|
||
};
|
||
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
|
||
return this;
|
||
}), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
|
||
void 0 === PromiseImpl && (PromiseImpl = Promise);
|
||
var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
|
||
return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
|
||
return result.done ? result.value : iter.next();
|
||
});
|
||
}, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
|
||
return this;
|
||
}), define(Gp, "toString", function () {
|
||
return "[object Generator]";
|
||
}), exports.keys = function (val) {
|
||
var object = Object(val),
|
||
keys = [];
|
||
for (var key in object) keys.push(key);
|
||
return keys.reverse(), function next() {
|
||
for (; keys.length;) {
|
||
var key = keys.pop();
|
||
if (key in object) return next.value = key, next.done = !1, next;
|
||
}
|
||
return next.done = !0, next;
|
||
};
|
||
}, exports.values = values, Context.prototype = {
|
||
constructor: Context,
|
||
reset: function (skipTempReset) {
|
||
if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
|
||
},
|
||
stop: function () {
|
||
this.done = !0;
|
||
var rootRecord = this.tryEntries[0].completion;
|
||
if ("throw" === rootRecord.type) throw rootRecord.arg;
|
||
return this.rval;
|
||
},
|
||
dispatchException: function (exception) {
|
||
if (this.done) throw exception;
|
||
var context = this;
|
||
function handle(loc, caught) {
|
||
return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
|
||
}
|
||
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
|
||
var entry = this.tryEntries[i],
|
||
record = entry.completion;
|
||
if ("root" === entry.tryLoc) return handle("end");
|
||
if (entry.tryLoc <= this.prev) {
|
||
var hasCatch = hasOwn.call(entry, "catchLoc"),
|
||
hasFinally = hasOwn.call(entry, "finallyLoc");
|
||
if (hasCatch && hasFinally) {
|
||
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
|
||
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
|
||
} else if (hasCatch) {
|
||
if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
|
||
} else {
|
||
if (!hasFinally) throw new Error("try statement without catch or finally");
|
||
if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
|
||
}
|
||
}
|
||
}
|
||
},
|
||
abrupt: function (type, arg) {
|
||
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
|
||
var entry = this.tryEntries[i];
|
||
if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
|
||
var finallyEntry = entry;
|
||
break;
|
||
}
|
||
}
|
||
finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
|
||
var record = finallyEntry ? finallyEntry.completion : {};
|
||
return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
|
||
},
|
||
complete: function (record, afterLoc) {
|
||
if ("throw" === record.type) throw record.arg;
|
||
return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
|
||
},
|
||
finish: function (finallyLoc) {
|
||
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
|
||
var entry = this.tryEntries[i];
|
||
if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
|
||
}
|
||
},
|
||
catch: function (tryLoc) {
|
||
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
|
||
var entry = this.tryEntries[i];
|
||
if (entry.tryLoc === tryLoc) {
|
||
var record = entry.completion;
|
||
if ("throw" === record.type) {
|
||
var thrown = record.arg;
|
||
resetTryEntry(entry);
|
||
}
|
||
return thrown;
|
||
}
|
||
}
|
||
throw new Error("illegal catch attempt");
|
||
},
|
||
delegateYield: function (iterable, resultName, nextLoc) {
|
||
return this.delegate = {
|
||
iterator: values(iterable),
|
||
resultName: resultName,
|
||
nextLoc: nextLoc
|
||
}, "next" === this.method && (this.arg = undefined), ContinueSentinel;
|
||
}
|
||
}, exports;
|
||
}
|
||
function _classCallCheck(instance, Constructor) {
|
||
if (!(instance instanceof Constructor)) {
|
||
throw new TypeError("Cannot call a class as a function");
|
||
}
|
||
}
|
||
function _defineProperties(target, props) {
|
||
for (var i = 0; i < props.length; i++) {
|
||
var descriptor = props[i];
|
||
descriptor.enumerable = descriptor.enumerable || false;
|
||
descriptor.configurable = true;
|
||
if ("value" in descriptor) descriptor.writable = true;
|
||
Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
|
||
}
|
||
}
|
||
function _createClass(Constructor, protoProps, staticProps) {
|
||
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
|
||
if (staticProps) _defineProperties(Constructor, staticProps);
|
||
Object.defineProperty(Constructor, "prototype", {
|
||
writable: false
|
||
});
|
||
return Constructor;
|
||
}
|
||
function _toConsumableArray(arr) {
|
||
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
|
||
}
|
||
function _arrayWithoutHoles(arr) {
|
||
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
|
||
}
|
||
function _iterableToArray(iter) {
|
||
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
|
||
}
|
||
function _unsupportedIterableToArray(o, minLen) {
|
||
if (!o) return;
|
||
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
|
||
var n = Object.prototype.toString.call(o).slice(8, -1);
|
||
if (n === "Object" && o.constructor) n = o.constructor.name;
|
||
if (n === "Map" || n === "Set") return Array.from(o);
|
||
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
|
||
}
|
||
function _arrayLikeToArray(arr, len) {
|
||
if (len == null || len > arr.length) len = arr.length;
|
||
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
|
||
return arr2;
|
||
}
|
||
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 _toPrimitive(input, hint) {
|
||
if (typeof input !== "object" || input === null) return input;
|
||
var prim = input[Symbol.toPrimitive];
|
||
if (prim !== undefined) {
|
||
var res = prim.call(input, hint || "default");
|
||
if (typeof res !== "object") return res;
|
||
throw new TypeError("@@toPrimitive must return a primitive value.");
|
||
}
|
||
return (hint === "string" ? String : Number)(input);
|
||
}
|
||
function _toPropertyKey(arg) {
|
||
var key = _toPrimitive(arg, "string");
|
||
return typeof key === "symbol" ? key : String(key);
|
||
}
|
||
|
||
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
||
|
||
var check = function (it) {
|
||
return it && it.Math == Math && it;
|
||
};
|
||
|
||
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
|
||
var global$n =
|
||
// eslint-disable-next-line es/no-global-this -- safe
|
||
check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) ||
|
||
// eslint-disable-next-line no-restricted-globals -- safe
|
||
check(typeof self == 'object' && self) || check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
|
||
// eslint-disable-next-line no-new-func -- fallback
|
||
function () {
|
||
return this;
|
||
}() || commonjsGlobal || Function('return this')();
|
||
|
||
var objectGetOwnPropertyDescriptor = {};
|
||
|
||
var fails$r = function (exec) {
|
||
try {
|
||
return !!exec();
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
};
|
||
|
||
var fails$q = fails$r;
|
||
|
||
// Detect IE8's incomplete defineProperty implementation
|
||
var descriptors = !fails$q(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty({}, 1, {
|
||
get: function () {
|
||
return 7;
|
||
}
|
||
})[1] != 7;
|
||
});
|
||
|
||
var fails$p = fails$r;
|
||
var functionBindNative = !fails$p(function () {
|
||
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
||
var test = function () {/* empty */}.bind();
|
||
// eslint-disable-next-line no-prototype-builtins -- safe
|
||
return typeof test != 'function' || test.hasOwnProperty('prototype');
|
||
});
|
||
|
||
var NATIVE_BIND$3 = functionBindNative;
|
||
var call$i = Function.prototype.call;
|
||
var functionCall = NATIVE_BIND$3 ? call$i.bind(call$i) : function () {
|
||
return call$i.apply(call$i, arguments);
|
||
};
|
||
|
||
var objectPropertyIsEnumerable = {};
|
||
|
||
var $propertyIsEnumerable = {}.propertyIsEnumerable;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor;
|
||
|
||
// Nashorn ~ JDK8 bug
|
||
var NASHORN_BUG = getOwnPropertyDescriptor$3 && !$propertyIsEnumerable.call({
|
||
1: 2
|
||
}, 1);
|
||
|
||
// `Object.prototype.propertyIsEnumerable` method implementation
|
||
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
|
||
objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
|
||
var descriptor = getOwnPropertyDescriptor$3(this, V);
|
||
return !!descriptor && descriptor.enumerable;
|
||
} : $propertyIsEnumerable;
|
||
|
||
var createPropertyDescriptor$5 = function (bitmap, value) {
|
||
return {
|
||
enumerable: !(bitmap & 1),
|
||
configurable: !(bitmap & 2),
|
||
writable: !(bitmap & 4),
|
||
value: value
|
||
};
|
||
};
|
||
|
||
var NATIVE_BIND$2 = functionBindNative;
|
||
var FunctionPrototype$2 = Function.prototype;
|
||
var call$h = FunctionPrototype$2.call;
|
||
var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$2.bind.bind(call$h, call$h);
|
||
var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function (fn) {
|
||
return function () {
|
||
return call$h.apply(fn, arguments);
|
||
};
|
||
};
|
||
|
||
var uncurryThis$o = functionUncurryThis;
|
||
var toString$8 = uncurryThis$o({}.toString);
|
||
var stringSlice$6 = uncurryThis$o(''.slice);
|
||
var classofRaw$2 = function (it) {
|
||
return stringSlice$6(toString$8(it), 8, -1);
|
||
};
|
||
|
||
var uncurryThis$n = functionUncurryThis;
|
||
var fails$o = fails$r;
|
||
var classof$c = classofRaw$2;
|
||
var $Object$4 = Object;
|
||
var split$1 = uncurryThis$n(''.split);
|
||
|
||
// fallback for non-array-like ES3 and non-enumerable old V8 strings
|
||
var indexedObject = fails$o(function () {
|
||
// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
|
||
// eslint-disable-next-line no-prototype-builtins -- safe
|
||
return !$Object$4('z').propertyIsEnumerable(0);
|
||
}) ? function (it) {
|
||
return classof$c(it) == 'String' ? split$1(it, '') : $Object$4(it);
|
||
} : $Object$4;
|
||
|
||
// we can't use just `it == null` since of `document.all` special case
|
||
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
|
||
var isNullOrUndefined$7 = function (it) {
|
||
return it === null || it === undefined;
|
||
};
|
||
|
||
var isNullOrUndefined$6 = isNullOrUndefined$7;
|
||
var $TypeError$e = TypeError;
|
||
|
||
// `RequireObjectCoercible` abstract operation
|
||
// https://tc39.es/ecma262/#sec-requireobjectcoercible
|
||
var requireObjectCoercible$4 = function (it) {
|
||
if (isNullOrUndefined$6(it)) throw $TypeError$e("Can't call method on " + it);
|
||
return it;
|
||
};
|
||
|
||
// toObject with fallback for non-array-like ES3 strings
|
||
var IndexedObject$1 = indexedObject;
|
||
var requireObjectCoercible$3 = requireObjectCoercible$4;
|
||
var toIndexedObject$6 = function (it) {
|
||
return IndexedObject$1(requireObjectCoercible$3(it));
|
||
};
|
||
|
||
var documentAll$2 = typeof document == 'object' && document.all;
|
||
|
||
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
|
||
// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
|
||
var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined;
|
||
var documentAll_1 = {
|
||
all: documentAll$2,
|
||
IS_HTMLDDA: IS_HTMLDDA
|
||
};
|
||
|
||
var $documentAll$1 = documentAll_1;
|
||
var documentAll$1 = $documentAll$1.all;
|
||
|
||
// `IsCallable` abstract operation
|
||
// https://tc39.es/ecma262/#sec-iscallable
|
||
var isCallable$r = $documentAll$1.IS_HTMLDDA ? function (argument) {
|
||
return typeof argument == 'function' || argument === documentAll$1;
|
||
} : function (argument) {
|
||
return typeof argument == 'function';
|
||
};
|
||
|
||
var isCallable$q = isCallable$r;
|
||
var $documentAll = documentAll_1;
|
||
var documentAll = $documentAll.all;
|
||
var isObject$f = $documentAll.IS_HTMLDDA ? function (it) {
|
||
return typeof it == 'object' ? it !== null : isCallable$q(it) || it === documentAll;
|
||
} : function (it) {
|
||
return typeof it == 'object' ? it !== null : isCallable$q(it);
|
||
};
|
||
|
||
var global$m = global$n;
|
||
var isCallable$p = isCallable$r;
|
||
var aFunction = function (argument) {
|
||
return isCallable$p(argument) ? argument : undefined;
|
||
};
|
||
var getBuiltIn$8 = function (namespace, method) {
|
||
return arguments.length < 2 ? aFunction(global$m[namespace]) : global$m[namespace] && global$m[namespace][method];
|
||
};
|
||
|
||
var uncurryThis$m = functionUncurryThis;
|
||
var objectIsPrototypeOf = uncurryThis$m({}.isPrototypeOf);
|
||
|
||
var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
|
||
|
||
var global$l = global$n;
|
||
var userAgent$3 = engineUserAgent;
|
||
var process$4 = global$l.process;
|
||
var Deno$1 = global$l.Deno;
|
||
var versions = process$4 && process$4.versions || Deno$1 && Deno$1.version;
|
||
var v8 = versions && versions.v8;
|
||
var match, version;
|
||
if (v8) {
|
||
match = v8.split('.');
|
||
// in old Chrome, versions of V8 isn't V8 = Chrome / 10
|
||
// but their correct versions are not interesting for us
|
||
version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
|
||
}
|
||
|
||
// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
|
||
// so check `userAgent` even if `.v8` exists, but 0
|
||
if (!version && userAgent$3) {
|
||
match = userAgent$3.match(/Edge\/(\d+)/);
|
||
if (!match || match[1] >= 74) {
|
||
match = userAgent$3.match(/Chrome\/(\d+)/);
|
||
if (match) version = +match[1];
|
||
}
|
||
}
|
||
var engineV8Version = version;
|
||
|
||
/* eslint-disable es/no-symbol -- required for testing */
|
||
var V8_VERSION$3 = engineV8Version;
|
||
var fails$n = fails$r;
|
||
var global$k = global$n;
|
||
var $String$6 = global$k.String;
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
|
||
var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$n(function () {
|
||
var symbol = Symbol();
|
||
// Chrome 38 Symbol has incorrect toString conversion
|
||
// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
|
||
// nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
|
||
// of course, fail.
|
||
return !$String$6(symbol) || !(Object(symbol) instanceof Symbol) ||
|
||
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
|
||
!Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41;
|
||
});
|
||
|
||
/* eslint-disable es/no-symbol -- required for testing */
|
||
var NATIVE_SYMBOL$2 = symbolConstructorDetection;
|
||
var useSymbolAsUid = NATIVE_SYMBOL$2 && !Symbol.sham && typeof Symbol.iterator == 'symbol';
|
||
|
||
var getBuiltIn$7 = getBuiltIn$8;
|
||
var isCallable$o = isCallable$r;
|
||
var isPrototypeOf$2 = objectIsPrototypeOf;
|
||
var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
|
||
var $Object$3 = Object;
|
||
var isSymbol$3 = USE_SYMBOL_AS_UID$1 ? function (it) {
|
||
return typeof it == 'symbol';
|
||
} : function (it) {
|
||
var $Symbol = getBuiltIn$7('Symbol');
|
||
return isCallable$o($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it));
|
||
};
|
||
|
||
var $String$5 = String;
|
||
var tryToString$4 = function (argument) {
|
||
try {
|
||
return $String$5(argument);
|
||
} catch (error) {
|
||
return 'Object';
|
||
}
|
||
};
|
||
|
||
var isCallable$n = isCallable$r;
|
||
var tryToString$3 = tryToString$4;
|
||
var $TypeError$d = TypeError;
|
||
|
||
// `Assert: IsCallable(argument) is true`
|
||
var aCallable$8 = function (argument) {
|
||
if (isCallable$n(argument)) return argument;
|
||
throw $TypeError$d(tryToString$3(argument) + ' is not a function');
|
||
};
|
||
|
||
var aCallable$7 = aCallable$8;
|
||
var isNullOrUndefined$5 = isNullOrUndefined$7;
|
||
|
||
// `GetMethod` abstract operation
|
||
// https://tc39.es/ecma262/#sec-getmethod
|
||
var getMethod$4 = function (V, P) {
|
||
var func = V[P];
|
||
return isNullOrUndefined$5(func) ? undefined : aCallable$7(func);
|
||
};
|
||
|
||
var call$g = functionCall;
|
||
var isCallable$m = isCallable$r;
|
||
var isObject$e = isObject$f;
|
||
var $TypeError$c = TypeError;
|
||
|
||
// `OrdinaryToPrimitive` abstract operation
|
||
// https://tc39.es/ecma262/#sec-ordinarytoprimitive
|
||
var ordinaryToPrimitive$1 = function (input, pref) {
|
||
var fn, val;
|
||
if (pref === 'string' && isCallable$m(fn = input.toString) && !isObject$e(val = call$g(fn, input))) return val;
|
||
if (isCallable$m(fn = input.valueOf) && !isObject$e(val = call$g(fn, input))) return val;
|
||
if (pref !== 'string' && isCallable$m(fn = input.toString) && !isObject$e(val = call$g(fn, input))) return val;
|
||
throw $TypeError$c("Can't convert object to primitive value");
|
||
};
|
||
|
||
var shared$4 = {exports: {}};
|
||
|
||
var isPure = false;
|
||
|
||
var global$j = global$n;
|
||
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var defineProperty$6 = Object.defineProperty;
|
||
var defineGlobalProperty$3 = function (key, value) {
|
||
try {
|
||
defineProperty$6(global$j, key, {
|
||
value: value,
|
||
configurable: true,
|
||
writable: true
|
||
});
|
||
} catch (error) {
|
||
global$j[key] = value;
|
||
}
|
||
return value;
|
||
};
|
||
|
||
var global$i = global$n;
|
||
var defineGlobalProperty$2 = defineGlobalProperty$3;
|
||
var SHARED = '__core-js_shared__';
|
||
var store$3 = global$i[SHARED] || defineGlobalProperty$2(SHARED, {});
|
||
var sharedStore = store$3;
|
||
|
||
var store$2 = sharedStore;
|
||
(shared$4.exports = function (key, value) {
|
||
return store$2[key] || (store$2[key] = value !== undefined ? value : {});
|
||
})('versions', []).push({
|
||
version: '3.30.2',
|
||
mode: 'global',
|
||
copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',
|
||
license: 'https://github.com/zloirock/core-js/blob/v3.30.2/LICENSE',
|
||
source: 'https://github.com/zloirock/core-js'
|
||
});
|
||
|
||
var requireObjectCoercible$2 = requireObjectCoercible$4;
|
||
var $Object$2 = Object;
|
||
|
||
// `ToObject` abstract operation
|
||
// https://tc39.es/ecma262/#sec-toobject
|
||
var toObject$6 = function (argument) {
|
||
return $Object$2(requireObjectCoercible$2(argument));
|
||
};
|
||
|
||
var uncurryThis$l = functionUncurryThis;
|
||
var toObject$5 = toObject$6;
|
||
var hasOwnProperty = uncurryThis$l({}.hasOwnProperty);
|
||
|
||
// `HasOwnProperty` abstract operation
|
||
// https://tc39.es/ecma262/#sec-hasownproperty
|
||
// eslint-disable-next-line es/no-object-hasown -- safe
|
||
var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
|
||
return hasOwnProperty(toObject$5(it), key);
|
||
};
|
||
|
||
var uncurryThis$k = functionUncurryThis;
|
||
var id$1 = 0;
|
||
var postfix = Math.random();
|
||
var toString$7 = uncurryThis$k(1.0.toString);
|
||
var uid$3 = function (key) {
|
||
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$7(++id$1 + postfix, 36);
|
||
};
|
||
|
||
var global$h = global$n;
|
||
var shared$3 = shared$4.exports;
|
||
var hasOwn$b = hasOwnProperty_1;
|
||
var uid$2 = uid$3;
|
||
var NATIVE_SYMBOL$1 = symbolConstructorDetection;
|
||
var USE_SYMBOL_AS_UID = useSymbolAsUid;
|
||
var Symbol$1 = global$h.Symbol;
|
||
var WellKnownSymbolsStore = shared$3('wks');
|
||
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$2;
|
||
var wellKnownSymbol$l = function (name) {
|
||
if (!hasOwn$b(WellKnownSymbolsStore, name)) {
|
||
WellKnownSymbolsStore[name] = NATIVE_SYMBOL$1 && hasOwn$b(Symbol$1, name) ? Symbol$1[name] : createWellKnownSymbol('Symbol.' + name);
|
||
}
|
||
return WellKnownSymbolsStore[name];
|
||
};
|
||
|
||
var call$f = functionCall;
|
||
var isObject$d = isObject$f;
|
||
var isSymbol$2 = isSymbol$3;
|
||
var getMethod$3 = getMethod$4;
|
||
var ordinaryToPrimitive = ordinaryToPrimitive$1;
|
||
var wellKnownSymbol$k = wellKnownSymbol$l;
|
||
var $TypeError$b = TypeError;
|
||
var TO_PRIMITIVE = wellKnownSymbol$k('toPrimitive');
|
||
|
||
// `ToPrimitive` abstract operation
|
||
// https://tc39.es/ecma262/#sec-toprimitive
|
||
var toPrimitive$1 = function (input, pref) {
|
||
if (!isObject$d(input) || isSymbol$2(input)) return input;
|
||
var exoticToPrim = getMethod$3(input, TO_PRIMITIVE);
|
||
var result;
|
||
if (exoticToPrim) {
|
||
if (pref === undefined) pref = 'default';
|
||
result = call$f(exoticToPrim, input, pref);
|
||
if (!isObject$d(result) || isSymbol$2(result)) return result;
|
||
throw $TypeError$b("Can't convert object to primitive value");
|
||
}
|
||
if (pref === undefined) pref = 'number';
|
||
return ordinaryToPrimitive(input, pref);
|
||
};
|
||
|
||
var toPrimitive = toPrimitive$1;
|
||
var isSymbol$1 = isSymbol$3;
|
||
|
||
// `ToPropertyKey` abstract operation
|
||
// https://tc39.es/ecma262/#sec-topropertykey
|
||
var toPropertyKey$3 = function (argument) {
|
||
var key = toPrimitive(argument, 'string');
|
||
return isSymbol$1(key) ? key : key + '';
|
||
};
|
||
|
||
var global$g = global$n;
|
||
var isObject$c = isObject$f;
|
||
var document$3 = global$g.document;
|
||
// typeof document.createElement is 'object' in old IE
|
||
var EXISTS$1 = isObject$c(document$3) && isObject$c(document$3.createElement);
|
||
var documentCreateElement$2 = function (it) {
|
||
return EXISTS$1 ? document$3.createElement(it) : {};
|
||
};
|
||
|
||
var DESCRIPTORS$c = descriptors;
|
||
var fails$m = fails$r;
|
||
var createElement$1 = documentCreateElement$2;
|
||
|
||
// Thanks to IE8 for its funny defineProperty
|
||
var ie8DomDefine = !DESCRIPTORS$c && !fails$m(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty(createElement$1('div'), 'a', {
|
||
get: function () {
|
||
return 7;
|
||
}
|
||
}).a != 7;
|
||
});
|
||
|
||
var DESCRIPTORS$b = descriptors;
|
||
var call$e = functionCall;
|
||
var propertyIsEnumerableModule = objectPropertyIsEnumerable;
|
||
var createPropertyDescriptor$4 = createPropertyDescriptor$5;
|
||
var toIndexedObject$5 = toIndexedObject$6;
|
||
var toPropertyKey$2 = toPropertyKey$3;
|
||
var hasOwn$a = hasOwnProperty_1;
|
||
var IE8_DOM_DEFINE$1 = ie8DomDefine;
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
|
||
|
||
// `Object.getOwnPropertyDescriptor` method
|
||
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
|
||
objectGetOwnPropertyDescriptor.f = DESCRIPTORS$b ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
|
||
O = toIndexedObject$5(O);
|
||
P = toPropertyKey$2(P);
|
||
if (IE8_DOM_DEFINE$1) try {
|
||
return $getOwnPropertyDescriptor$1(O, P);
|
||
} catch (error) {/* empty */}
|
||
if (hasOwn$a(O, P)) return createPropertyDescriptor$4(!call$e(propertyIsEnumerableModule.f, O, P), O[P]);
|
||
};
|
||
|
||
var objectDefineProperty = {};
|
||
|
||
var DESCRIPTORS$a = descriptors;
|
||
var fails$l = fails$r;
|
||
|
||
// V8 ~ Chrome 36-
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
|
||
var v8PrototypeDefineBug = DESCRIPTORS$a && fails$l(function () {
|
||
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
||
return Object.defineProperty(function () {/* empty */}, 'prototype', {
|
||
value: 42,
|
||
writable: false
|
||
}).prototype != 42;
|
||
});
|
||
|
||
var isObject$b = isObject$f;
|
||
var $String$4 = String;
|
||
var $TypeError$a = TypeError;
|
||
|
||
// `Assert: Type(argument) is Object`
|
||
var anObject$e = function (argument) {
|
||
if (isObject$b(argument)) return argument;
|
||
throw $TypeError$a($String$4(argument) + ' is not an object');
|
||
};
|
||
|
||
var DESCRIPTORS$9 = descriptors;
|
||
var IE8_DOM_DEFINE = ie8DomDefine;
|
||
var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
|
||
var anObject$d = anObject$e;
|
||
var toPropertyKey$1 = toPropertyKey$3;
|
||
var $TypeError$9 = TypeError;
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var $defineProperty = Object.defineProperty;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
var ENUMERABLE = 'enumerable';
|
||
var CONFIGURABLE$1 = 'configurable';
|
||
var WRITABLE = 'writable';
|
||
|
||
// `Object.defineProperty` method
|
||
// https://tc39.es/ecma262/#sec-object.defineproperty
|
||
objectDefineProperty.f = DESCRIPTORS$9 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
|
||
anObject$d(O);
|
||
P = toPropertyKey$1(P);
|
||
anObject$d(Attributes);
|
||
if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
|
||
var current = $getOwnPropertyDescriptor(O, P);
|
||
if (current && current[WRITABLE]) {
|
||
O[P] = Attributes.value;
|
||
Attributes = {
|
||
configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
|
||
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
|
||
writable: false
|
||
};
|
||
}
|
||
}
|
||
return $defineProperty(O, P, Attributes);
|
||
} : $defineProperty : function defineProperty(O, P, Attributes) {
|
||
anObject$d(O);
|
||
P = toPropertyKey$1(P);
|
||
anObject$d(Attributes);
|
||
if (IE8_DOM_DEFINE) try {
|
||
return $defineProperty(O, P, Attributes);
|
||
} catch (error) {/* empty */}
|
||
if ('get' in Attributes || 'set' in Attributes) throw $TypeError$9('Accessors not supported');
|
||
if ('value' in Attributes) O[P] = Attributes.value;
|
||
return O;
|
||
};
|
||
|
||
var DESCRIPTORS$8 = descriptors;
|
||
var definePropertyModule$4 = objectDefineProperty;
|
||
var createPropertyDescriptor$3 = createPropertyDescriptor$5;
|
||
var createNonEnumerableProperty$6 = DESCRIPTORS$8 ? function (object, key, value) {
|
||
return definePropertyModule$4.f(object, key, createPropertyDescriptor$3(1, value));
|
||
} : function (object, key, value) {
|
||
object[key] = value;
|
||
return object;
|
||
};
|
||
|
||
var makeBuiltIn$3 = {exports: {}};
|
||
|
||
var DESCRIPTORS$7 = descriptors;
|
||
var hasOwn$9 = hasOwnProperty_1;
|
||
var FunctionPrototype$1 = Function.prototype;
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getDescriptor = DESCRIPTORS$7 && Object.getOwnPropertyDescriptor;
|
||
var EXISTS = hasOwn$9(FunctionPrototype$1, 'name');
|
||
// additional protection from minified / mangled / dropped function names
|
||
var PROPER = EXISTS && function something() {/* empty */}.name === 'something';
|
||
var CONFIGURABLE = EXISTS && (!DESCRIPTORS$7 || DESCRIPTORS$7 && getDescriptor(FunctionPrototype$1, 'name').configurable);
|
||
var functionName = {
|
||
EXISTS: EXISTS,
|
||
PROPER: PROPER,
|
||
CONFIGURABLE: CONFIGURABLE
|
||
};
|
||
|
||
var uncurryThis$j = functionUncurryThis;
|
||
var isCallable$l = isCallable$r;
|
||
var store$1 = sharedStore;
|
||
var functionToString = uncurryThis$j(Function.toString);
|
||
|
||
// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
|
||
if (!isCallable$l(store$1.inspectSource)) {
|
||
store$1.inspectSource = function (it) {
|
||
return functionToString(it);
|
||
};
|
||
}
|
||
var inspectSource$3 = store$1.inspectSource;
|
||
|
||
var global$f = global$n;
|
||
var isCallable$k = isCallable$r;
|
||
var WeakMap$1 = global$f.WeakMap;
|
||
var weakMapBasicDetection = isCallable$k(WeakMap$1) && /native code/.test(String(WeakMap$1));
|
||
|
||
var shared$2 = shared$4.exports;
|
||
var uid$1 = uid$3;
|
||
var keys = shared$2('keys');
|
||
var sharedKey$3 = function (key) {
|
||
return keys[key] || (keys[key] = uid$1(key));
|
||
};
|
||
|
||
var hiddenKeys$5 = {};
|
||
|
||
var NATIVE_WEAK_MAP = weakMapBasicDetection;
|
||
var global$e = global$n;
|
||
var isObject$a = isObject$f;
|
||
var createNonEnumerableProperty$5 = createNonEnumerableProperty$6;
|
||
var hasOwn$8 = hasOwnProperty_1;
|
||
var shared$1 = sharedStore;
|
||
var sharedKey$2 = sharedKey$3;
|
||
var hiddenKeys$4 = hiddenKeys$5;
|
||
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
|
||
var TypeError$3 = global$e.TypeError;
|
||
var WeakMap = global$e.WeakMap;
|
||
var set$1, get, has;
|
||
var enforce = function (it) {
|
||
return has(it) ? get(it) : set$1(it, {});
|
||
};
|
||
var getterFor = function (TYPE) {
|
||
return function (it) {
|
||
var state;
|
||
if (!isObject$a(it) || (state = get(it)).type !== TYPE) {
|
||
throw TypeError$3('Incompatible receiver, ' + TYPE + ' required');
|
||
}
|
||
return state;
|
||
};
|
||
};
|
||
if (NATIVE_WEAK_MAP || shared$1.state) {
|
||
var store = shared$1.state || (shared$1.state = new WeakMap());
|
||
/* eslint-disable no-self-assign -- prototype methods protection */
|
||
store.get = store.get;
|
||
store.has = store.has;
|
||
store.set = store.set;
|
||
/* eslint-enable no-self-assign -- prototype methods protection */
|
||
set$1 = function (it, metadata) {
|
||
if (store.has(it)) throw TypeError$3(OBJECT_ALREADY_INITIALIZED);
|
||
metadata.facade = it;
|
||
store.set(it, metadata);
|
||
return metadata;
|
||
};
|
||
get = function (it) {
|
||
return store.get(it) || {};
|
||
};
|
||
has = function (it) {
|
||
return store.has(it);
|
||
};
|
||
} else {
|
||
var STATE = sharedKey$2('state');
|
||
hiddenKeys$4[STATE] = true;
|
||
set$1 = function (it, metadata) {
|
||
if (hasOwn$8(it, STATE)) throw TypeError$3(OBJECT_ALREADY_INITIALIZED);
|
||
metadata.facade = it;
|
||
createNonEnumerableProperty$5(it, STATE, metadata);
|
||
return metadata;
|
||
};
|
||
get = function (it) {
|
||
return hasOwn$8(it, STATE) ? it[STATE] : {};
|
||
};
|
||
has = function (it) {
|
||
return hasOwn$8(it, STATE);
|
||
};
|
||
}
|
||
var internalState = {
|
||
set: set$1,
|
||
get: get,
|
||
has: has,
|
||
enforce: enforce,
|
||
getterFor: getterFor
|
||
};
|
||
|
||
var uncurryThis$i = functionUncurryThis;
|
||
var fails$k = fails$r;
|
||
var isCallable$j = isCallable$r;
|
||
var hasOwn$7 = hasOwnProperty_1;
|
||
var DESCRIPTORS$6 = descriptors;
|
||
var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE;
|
||
var inspectSource$2 = inspectSource$3;
|
||
var InternalStateModule$5 = internalState;
|
||
var enforceInternalState = InternalStateModule$5.enforce;
|
||
var getInternalState$3 = InternalStateModule$5.get;
|
||
var $String$3 = String;
|
||
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
||
var defineProperty$5 = Object.defineProperty;
|
||
var stringSlice$5 = uncurryThis$i(''.slice);
|
||
var replace$4 = uncurryThis$i(''.replace);
|
||
var join$1 = uncurryThis$i([].join);
|
||
var CONFIGURABLE_LENGTH = DESCRIPTORS$6 && !fails$k(function () {
|
||
return defineProperty$5(function () {/* empty */}, 'length', {
|
||
value: 8
|
||
}).length !== 8;
|
||
});
|
||
var TEMPLATE = String(String).split('String');
|
||
var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) {
|
||
if (stringSlice$5($String$3(name), 0, 7) === 'Symbol(') {
|
||
name = '[' + replace$4($String$3(name), /^Symbol\(([^)]*)\)/, '$1') + ']';
|
||
}
|
||
if (options && options.getter) name = 'get ' + name;
|
||
if (options && options.setter) name = 'set ' + name;
|
||
if (!hasOwn$7(value, 'name') || CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name) {
|
||
if (DESCRIPTORS$6) defineProperty$5(value, 'name', {
|
||
value: name,
|
||
configurable: true
|
||
});else value.name = name;
|
||
}
|
||
if (CONFIGURABLE_LENGTH && options && hasOwn$7(options, 'arity') && value.length !== options.arity) {
|
||
defineProperty$5(value, 'length', {
|
||
value: options.arity
|
||
});
|
||
}
|
||
try {
|
||
if (options && hasOwn$7(options, 'constructor') && options.constructor) {
|
||
if (DESCRIPTORS$6) defineProperty$5(value, 'prototype', {
|
||
writable: false
|
||
});
|
||
// in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
|
||
} else if (value.prototype) value.prototype = undefined;
|
||
} catch (error) {/* empty */}
|
||
var state = enforceInternalState(value);
|
||
if (!hasOwn$7(state, 'source')) {
|
||
state.source = join$1(TEMPLATE, typeof name == 'string' ? name : '');
|
||
}
|
||
return value;
|
||
};
|
||
|
||
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
|
||
// eslint-disable-next-line no-extend-native -- required
|
||
Function.prototype.toString = makeBuiltIn$2(function toString() {
|
||
return isCallable$j(this) && getInternalState$3(this).source || inspectSource$2(this);
|
||
}, 'toString');
|
||
|
||
var isCallable$i = isCallable$r;
|
||
var definePropertyModule$3 = objectDefineProperty;
|
||
var makeBuiltIn$1 = makeBuiltIn$3.exports;
|
||
var defineGlobalProperty$1 = defineGlobalProperty$3;
|
||
var defineBuiltIn$a = function (O, key, value, options) {
|
||
if (!options) options = {};
|
||
var simple = options.enumerable;
|
||
var name = options.name !== undefined ? options.name : key;
|
||
if (isCallable$i(value)) makeBuiltIn$1(value, name, options);
|
||
if (options.global) {
|
||
if (simple) O[key] = value;else defineGlobalProperty$1(key, value);
|
||
} else {
|
||
try {
|
||
if (!options.unsafe) delete O[key];else if (O[key]) simple = true;
|
||
} catch (error) {/* empty */}
|
||
if (simple) O[key] = value;else definePropertyModule$3.f(O, key, {
|
||
value: value,
|
||
enumerable: false,
|
||
configurable: !options.nonConfigurable,
|
||
writable: !options.nonWritable
|
||
});
|
||
}
|
||
return O;
|
||
};
|
||
|
||
var objectGetOwnPropertyNames = {};
|
||
|
||
var ceil = Math.ceil;
|
||
var floor$2 = Math.floor;
|
||
|
||
// `Math.trunc` method
|
||
// https://tc39.es/ecma262/#sec-math.trunc
|
||
// eslint-disable-next-line es/no-math-trunc -- safe
|
||
var mathTrunc = Math.trunc || function trunc(x) {
|
||
var n = +x;
|
||
return (n > 0 ? floor$2 : ceil)(n);
|
||
};
|
||
|
||
var trunc = mathTrunc;
|
||
|
||
// `ToIntegerOrInfinity` abstract operation
|
||
// https://tc39.es/ecma262/#sec-tointegerorinfinity
|
||
var toIntegerOrInfinity$4 = function (argument) {
|
||
var number = +argument;
|
||
// eslint-disable-next-line no-self-compare -- NaN check
|
||
return number !== number || number === 0 ? 0 : trunc(number);
|
||
};
|
||
|
||
var toIntegerOrInfinity$3 = toIntegerOrInfinity$4;
|
||
var max$2 = Math.max;
|
||
var min$2 = Math.min;
|
||
|
||
// Helper for a popular repeating case of the spec:
|
||
// Let integer be ? ToInteger(index).
|
||
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
|
||
var toAbsoluteIndex$2 = function (index, length) {
|
||
var integer = toIntegerOrInfinity$3(index);
|
||
return integer < 0 ? max$2(integer + length, 0) : min$2(integer, length);
|
||
};
|
||
|
||
var toIntegerOrInfinity$2 = toIntegerOrInfinity$4;
|
||
var min$1 = Math.min;
|
||
|
||
// `ToLength` abstract operation
|
||
// https://tc39.es/ecma262/#sec-tolength
|
||
var toLength$2 = function (argument) {
|
||
return argument > 0 ? min$1(toIntegerOrInfinity$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
|
||
};
|
||
|
||
var toLength$1 = toLength$2;
|
||
|
||
// `LengthOfArrayLike` abstract operation
|
||
// https://tc39.es/ecma262/#sec-lengthofarraylike
|
||
var lengthOfArrayLike$5 = function (obj) {
|
||
return toLength$1(obj.length);
|
||
};
|
||
|
||
var toIndexedObject$4 = toIndexedObject$6;
|
||
var toAbsoluteIndex$1 = toAbsoluteIndex$2;
|
||
var lengthOfArrayLike$4 = lengthOfArrayLike$5;
|
||
|
||
// `Array.prototype.{ indexOf, includes }` methods implementation
|
||
var createMethod$2 = function (IS_INCLUDES) {
|
||
return function ($this, el, fromIndex) {
|
||
var O = toIndexedObject$4($this);
|
||
var length = lengthOfArrayLike$4(O);
|
||
var index = toAbsoluteIndex$1(fromIndex, length);
|
||
var value;
|
||
// Array#includes uses SameValueZero equality algorithm
|
||
// eslint-disable-next-line no-self-compare -- NaN check
|
||
if (IS_INCLUDES && el != el) while (length > index) {
|
||
value = O[index++];
|
||
// eslint-disable-next-line no-self-compare -- NaN check
|
||
if (value != value) return true;
|
||
// Array#indexOf ignores holes, Array#includes - not
|
||
} else for (; length > index; index++) {
|
||
if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
|
||
}
|
||
return !IS_INCLUDES && -1;
|
||
};
|
||
};
|
||
var arrayIncludes = {
|
||
// `Array.prototype.includes` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.includes
|
||
includes: createMethod$2(true),
|
||
// `Array.prototype.indexOf` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.indexof
|
||
indexOf: createMethod$2(false)
|
||
};
|
||
|
||
var uncurryThis$h = functionUncurryThis;
|
||
var hasOwn$6 = hasOwnProperty_1;
|
||
var toIndexedObject$3 = toIndexedObject$6;
|
||
var indexOf$1 = arrayIncludes.indexOf;
|
||
var hiddenKeys$3 = hiddenKeys$5;
|
||
var push$4 = uncurryThis$h([].push);
|
||
var objectKeysInternal = function (object, names) {
|
||
var O = toIndexedObject$3(object);
|
||
var i = 0;
|
||
var result = [];
|
||
var key;
|
||
for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$4(result, key);
|
||
// Don't enum bug & hidden keys
|
||
while (names.length > i) if (hasOwn$6(O, key = names[i++])) {
|
||
~indexOf$1(result, key) || push$4(result, key);
|
||
}
|
||
return result;
|
||
};
|
||
|
||
// IE8- don't enum bug keys
|
||
var enumBugKeys$3 = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
|
||
|
||
var internalObjectKeys$1 = objectKeysInternal;
|
||
var enumBugKeys$2 = enumBugKeys$3;
|
||
var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype');
|
||
|
||
// `Object.getOwnPropertyNames` method
|
||
// https://tc39.es/ecma262/#sec-object.getownpropertynames
|
||
// eslint-disable-next-line es/no-object-getownpropertynames -- safe
|
||
objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
|
||
return internalObjectKeys$1(O, hiddenKeys$2);
|
||
};
|
||
|
||
var objectGetOwnPropertySymbols = {};
|
||
|
||
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
|
||
objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
|
||
|
||
var getBuiltIn$6 = getBuiltIn$8;
|
||
var uncurryThis$g = functionUncurryThis;
|
||
var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames;
|
||
var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
|
||
var anObject$c = anObject$e;
|
||
var concat$1 = uncurryThis$g([].concat);
|
||
|
||
// all object keys, includes non-enumerable and symbols
|
||
var ownKeys$1 = getBuiltIn$6('Reflect', 'ownKeys') || function ownKeys(it) {
|
||
var keys = getOwnPropertyNamesModule$1.f(anObject$c(it));
|
||
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
||
return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys;
|
||
};
|
||
|
||
var hasOwn$5 = hasOwnProperty_1;
|
||
var ownKeys = ownKeys$1;
|
||
var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
|
||
var definePropertyModule$2 = objectDefineProperty;
|
||
var copyConstructorProperties$1 = function (target, source, exceptions) {
|
||
var keys = ownKeys(source);
|
||
var defineProperty = definePropertyModule$2.f;
|
||
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
||
for (var i = 0; i < keys.length; i++) {
|
||
var key = keys[i];
|
||
if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) {
|
||
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
||
}
|
||
}
|
||
};
|
||
|
||
var fails$j = fails$r;
|
||
var isCallable$h = isCallable$r;
|
||
var replacement = /#|\.prototype\./;
|
||
var isForced$3 = function (feature, detection) {
|
||
var value = data[normalize(feature)];
|
||
return value == POLYFILL ? true : value == NATIVE ? false : isCallable$h(detection) ? fails$j(detection) : !!detection;
|
||
};
|
||
var normalize = isForced$3.normalize = function (string) {
|
||
return String(string).replace(replacement, '.').toLowerCase();
|
||
};
|
||
var data = isForced$3.data = {};
|
||
var NATIVE = isForced$3.NATIVE = 'N';
|
||
var POLYFILL = isForced$3.POLYFILL = 'P';
|
||
var isForced_1 = isForced$3;
|
||
|
||
var global$d = global$n;
|
||
var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f;
|
||
var createNonEnumerableProperty$4 = createNonEnumerableProperty$6;
|
||
var defineBuiltIn$9 = defineBuiltIn$a;
|
||
var defineGlobalProperty = defineGlobalProperty$3;
|
||
var copyConstructorProperties = copyConstructorProperties$1;
|
||
var isForced$2 = isForced_1;
|
||
|
||
/*
|
||
options.target - name of the target object
|
||
options.global - target is the global object
|
||
options.stat - export as static methods of target
|
||
options.proto - export as prototype methods of target
|
||
options.real - real prototype method for the `pure` version
|
||
options.forced - export even if the native feature is available
|
||
options.bind - bind methods to the target, required for the `pure` version
|
||
options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
|
||
options.unsafe - use the simple assignment of property instead of delete + defineProperty
|
||
options.sham - add a flag to not completely full polyfills
|
||
options.enumerable - export as enumerable property
|
||
options.dontCallGetSet - prevent calling a getter on target
|
||
options.name - the .name of the function if it does not match the key
|
||
*/
|
||
var _export = function (options, source) {
|
||
var TARGET = options.target;
|
||
var GLOBAL = options.global;
|
||
var STATIC = options.stat;
|
||
var FORCED, target, key, targetProperty, sourceProperty, descriptor;
|
||
if (GLOBAL) {
|
||
target = global$d;
|
||
} else if (STATIC) {
|
||
target = global$d[TARGET] || defineGlobalProperty(TARGET, {});
|
||
} else {
|
||
target = (global$d[TARGET] || {}).prototype;
|
||
}
|
||
if (target) for (key in source) {
|
||
sourceProperty = source[key];
|
||
if (options.dontCallGetSet) {
|
||
descriptor = getOwnPropertyDescriptor$2(target, key);
|
||
targetProperty = descriptor && descriptor.value;
|
||
} else targetProperty = target[key];
|
||
FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
|
||
// contained in target
|
||
if (!FORCED && targetProperty !== undefined) {
|
||
if (typeof sourceProperty == typeof targetProperty) continue;
|
||
copyConstructorProperties(sourceProperty, targetProperty);
|
||
}
|
||
// add a flag to not completely full polyfills
|
||
if (options.sham || targetProperty && targetProperty.sham) {
|
||
createNonEnumerableProperty$4(sourceProperty, 'sham', true);
|
||
}
|
||
defineBuiltIn$9(target, key, sourceProperty, options);
|
||
}
|
||
};
|
||
|
||
var classof$b = classofRaw$2;
|
||
|
||
// `IsArray` abstract operation
|
||
// https://tc39.es/ecma262/#sec-isarray
|
||
// eslint-disable-next-line es/no-array-isarray -- safe
|
||
var isArray$3 = Array.isArray || function isArray(argument) {
|
||
return classof$b(argument) == 'Array';
|
||
};
|
||
|
||
var $TypeError$8 = TypeError;
|
||
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
|
||
|
||
var doesNotExceedSafeInteger$1 = function (it) {
|
||
if (it > MAX_SAFE_INTEGER) throw $TypeError$8('Maximum allowed index exceeded');
|
||
return it;
|
||
};
|
||
|
||
var toPropertyKey = toPropertyKey$3;
|
||
var definePropertyModule$1 = objectDefineProperty;
|
||
var createPropertyDescriptor$2 = createPropertyDescriptor$5;
|
||
var createProperty$2 = function (object, key, value) {
|
||
var propertyKey = toPropertyKey(key);
|
||
if (propertyKey in object) definePropertyModule$1.f(object, propertyKey, createPropertyDescriptor$2(0, value));else object[propertyKey] = value;
|
||
};
|
||
|
||
var wellKnownSymbol$j = wellKnownSymbol$l;
|
||
var TO_STRING_TAG$3 = wellKnownSymbol$j('toStringTag');
|
||
var test = {};
|
||
test[TO_STRING_TAG$3] = 'z';
|
||
var toStringTagSupport = String(test) === '[object z]';
|
||
|
||
var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport;
|
||
var isCallable$g = isCallable$r;
|
||
var classofRaw$1 = classofRaw$2;
|
||
var wellKnownSymbol$i = wellKnownSymbol$l;
|
||
var TO_STRING_TAG$2 = wellKnownSymbol$i('toStringTag');
|
||
var $Object$1 = Object;
|
||
|
||
// ES3 wrong here
|
||
var CORRECT_ARGUMENTS = classofRaw$1(function () {
|
||
return arguments;
|
||
}()) == 'Arguments';
|
||
|
||
// fallback for IE11 Script Access Denied error
|
||
var tryGet = function (it, key) {
|
||
try {
|
||
return it[key];
|
||
} catch (error) {/* empty */}
|
||
};
|
||
|
||
// getting tag from ES6+ `Object.prototype.toString`
|
||
var classof$a = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) {
|
||
var O, tag, result;
|
||
return it === undefined ? 'Undefined' : it === null ? 'Null'
|
||
// @@toStringTag case
|
||
: typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$2)) == 'string' ? tag
|
||
// builtinTag case
|
||
: CORRECT_ARGUMENTS ? classofRaw$1(O)
|
||
// ES3 arguments fallback
|
||
: (result = classofRaw$1(O)) == 'Object' && isCallable$g(O.callee) ? 'Arguments' : result;
|
||
};
|
||
|
||
var uncurryThis$f = functionUncurryThis;
|
||
var fails$i = fails$r;
|
||
var isCallable$f = isCallable$r;
|
||
var classof$9 = classof$a;
|
||
var getBuiltIn$5 = getBuiltIn$8;
|
||
var inspectSource$1 = inspectSource$3;
|
||
var noop = function () {/* empty */};
|
||
var empty = [];
|
||
var construct = getBuiltIn$5('Reflect', 'construct');
|
||
var constructorRegExp = /^\s*(?:class|function)\b/;
|
||
var exec$2 = uncurryThis$f(constructorRegExp.exec);
|
||
var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
|
||
var isConstructorModern = function isConstructor(argument) {
|
||
if (!isCallable$f(argument)) return false;
|
||
try {
|
||
construct(noop, empty, argument);
|
||
return true;
|
||
} catch (error) {
|
||
return false;
|
||
}
|
||
};
|
||
var isConstructorLegacy = function isConstructor(argument) {
|
||
if (!isCallable$f(argument)) return false;
|
||
switch (classof$9(argument)) {
|
||
case 'AsyncFunction':
|
||
case 'GeneratorFunction':
|
||
case 'AsyncGeneratorFunction':
|
||
return false;
|
||
}
|
||
try {
|
||
// we can't check .prototype since constructors produced by .bind haven't it
|
||
// `Function#toString` throws on some built-it function in some legacy engines
|
||
// (for example, `DOMQuad` and similar in FF41-)
|
||
return INCORRECT_TO_STRING || !!exec$2(constructorRegExp, inspectSource$1(argument));
|
||
} catch (error) {
|
||
return true;
|
||
}
|
||
};
|
||
isConstructorLegacy.sham = true;
|
||
|
||
// `IsConstructor` abstract operation
|
||
// https://tc39.es/ecma262/#sec-isconstructor
|
||
var isConstructor$2 = !construct || fails$i(function () {
|
||
var called;
|
||
return isConstructorModern(isConstructorModern.call) || !isConstructorModern(Object) || !isConstructorModern(function () {
|
||
called = true;
|
||
}) || called;
|
||
}) ? isConstructorLegacy : isConstructorModern;
|
||
|
||
var isArray$2 = isArray$3;
|
||
var isConstructor$1 = isConstructor$2;
|
||
var isObject$9 = isObject$f;
|
||
var wellKnownSymbol$h = wellKnownSymbol$l;
|
||
var SPECIES$5 = wellKnownSymbol$h('species');
|
||
var $Array$1 = Array;
|
||
|
||
// a part of `ArraySpeciesCreate` abstract operation
|
||
// https://tc39.es/ecma262/#sec-arrayspeciescreate
|
||
var arraySpeciesConstructor$1 = function (originalArray) {
|
||
var C;
|
||
if (isArray$2(originalArray)) {
|
||
C = originalArray.constructor;
|
||
// cross-realm fallback
|
||
if (isConstructor$1(C) && (C === $Array$1 || isArray$2(C.prototype))) C = undefined;else if (isObject$9(C)) {
|
||
C = C[SPECIES$5];
|
||
if (C === null) C = undefined;
|
||
}
|
||
}
|
||
return C === undefined ? $Array$1 : C;
|
||
};
|
||
|
||
var arraySpeciesConstructor = arraySpeciesConstructor$1;
|
||
|
||
// `ArraySpeciesCreate` abstract operation
|
||
// https://tc39.es/ecma262/#sec-arrayspeciescreate
|
||
var arraySpeciesCreate$2 = function (originalArray, length) {
|
||
return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
|
||
};
|
||
|
||
var fails$h = fails$r;
|
||
var wellKnownSymbol$g = wellKnownSymbol$l;
|
||
var V8_VERSION$2 = engineV8Version;
|
||
var SPECIES$4 = wellKnownSymbol$g('species');
|
||
var arrayMethodHasSpeciesSupport$2 = function (METHOD_NAME) {
|
||
// We can't use this feature detection in V8 since it causes
|
||
// deoptimization and serious performance degradation
|
||
// https://github.com/zloirock/core-js/issues/677
|
||
return V8_VERSION$2 >= 51 || !fails$h(function () {
|
||
var array = [];
|
||
var constructor = array.constructor = {};
|
||
constructor[SPECIES$4] = function () {
|
||
return {
|
||
foo: 1
|
||
};
|
||
};
|
||
return array[METHOD_NAME](Boolean).foo !== 1;
|
||
});
|
||
};
|
||
|
||
var $$e = _export;
|
||
var fails$g = fails$r;
|
||
var isArray$1 = isArray$3;
|
||
var isObject$8 = isObject$f;
|
||
var toObject$4 = toObject$6;
|
||
var lengthOfArrayLike$3 = lengthOfArrayLike$5;
|
||
var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1;
|
||
var createProperty$1 = createProperty$2;
|
||
var arraySpeciesCreate$1 = arraySpeciesCreate$2;
|
||
var arrayMethodHasSpeciesSupport$1 = arrayMethodHasSpeciesSupport$2;
|
||
var wellKnownSymbol$f = wellKnownSymbol$l;
|
||
var V8_VERSION$1 = engineV8Version;
|
||
var IS_CONCAT_SPREADABLE = wellKnownSymbol$f('isConcatSpreadable');
|
||
|
||
// We can't use this feature detection in V8 since it causes
|
||
// deoptimization and serious performance degradation
|
||
// https://github.com/zloirock/core-js/issues/679
|
||
var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION$1 >= 51 || !fails$g(function () {
|
||
var array = [];
|
||
array[IS_CONCAT_SPREADABLE] = false;
|
||
return array.concat()[0] !== array;
|
||
});
|
||
var isConcatSpreadable = function (O) {
|
||
if (!isObject$8(O)) return false;
|
||
var spreadable = O[IS_CONCAT_SPREADABLE];
|
||
return spreadable !== undefined ? !!spreadable : isArray$1(O);
|
||
};
|
||
var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport$1('concat');
|
||
|
||
// `Array.prototype.concat` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.concat
|
||
// with adding support of @@isConcatSpreadable and @@species
|
||
$$e({
|
||
target: 'Array',
|
||
proto: true,
|
||
arity: 1,
|
||
forced: FORCED
|
||
}, {
|
||
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
||
concat: function concat(arg) {
|
||
var O = toObject$4(this);
|
||
var A = arraySpeciesCreate$1(O, 0);
|
||
var n = 0;
|
||
var i, k, length, len, E;
|
||
for (i = -1, length = arguments.length; i < length; i++) {
|
||
E = i === -1 ? O : arguments[i];
|
||
if (isConcatSpreadable(E)) {
|
||
len = lengthOfArrayLike$3(E);
|
||
doesNotExceedSafeInteger(n + len);
|
||
for (k = 0; k < len; k++, n++) if (k in E) createProperty$1(A, n, E[k]);
|
||
} else {
|
||
doesNotExceedSafeInteger(n + 1);
|
||
createProperty$1(A, n++, E);
|
||
}
|
||
}
|
||
A.length = n;
|
||
return A;
|
||
}
|
||
});
|
||
|
||
var NATIVE_BIND$1 = functionBindNative;
|
||
var FunctionPrototype = Function.prototype;
|
||
var apply$3 = FunctionPrototype.apply;
|
||
var call$d = FunctionPrototype.call;
|
||
|
||
// eslint-disable-next-line es/no-reflect -- safe
|
||
var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$d.bind(apply$3) : function () {
|
||
return call$d.apply(apply$3, arguments);
|
||
});
|
||
|
||
var uncurryThis$e = functionUncurryThis;
|
||
var arraySlice$4 = uncurryThis$e([].slice);
|
||
|
||
var classof$8 = classof$a;
|
||
var $String$2 = String;
|
||
var toString$6 = function (argument) {
|
||
if (classof$8(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
|
||
return $String$2(argument);
|
||
};
|
||
|
||
var uncurryThis$d = functionUncurryThis;
|
||
var isArray = isArray$3;
|
||
var isCallable$e = isCallable$r;
|
||
var classof$7 = classofRaw$2;
|
||
var toString$5 = toString$6;
|
||
var push$3 = uncurryThis$d([].push);
|
||
var getJsonReplacerFunction = function (replacer) {
|
||
if (isCallable$e(replacer)) return replacer;
|
||
if (!isArray(replacer)) return;
|
||
var rawLength = replacer.length;
|
||
var keys = [];
|
||
for (var i = 0; i < rawLength; i++) {
|
||
var element = replacer[i];
|
||
if (typeof element == 'string') push$3(keys, element);else if (typeof element == 'number' || classof$7(element) == 'Number' || classof$7(element) == 'String') push$3(keys, toString$5(element));
|
||
}
|
||
var keysLength = keys.length;
|
||
var root = true;
|
||
return function (key, value) {
|
||
if (root) {
|
||
root = false;
|
||
return value;
|
||
}
|
||
if (isArray(this)) return value;
|
||
for (var j = 0; j < keysLength; j++) if (keys[j] === key) return value;
|
||
};
|
||
};
|
||
|
||
var $$d = _export;
|
||
var getBuiltIn$4 = getBuiltIn$8;
|
||
var apply$2 = functionApply;
|
||
var call$c = functionCall;
|
||
var uncurryThis$c = functionUncurryThis;
|
||
var fails$f = fails$r;
|
||
var isCallable$d = isCallable$r;
|
||
var isSymbol = isSymbol$3;
|
||
var arraySlice$3 = arraySlice$4;
|
||
var getReplacerFunction = getJsonReplacerFunction;
|
||
var NATIVE_SYMBOL = symbolConstructorDetection;
|
||
var $String$1 = String;
|
||
var $stringify = getBuiltIn$4('JSON', 'stringify');
|
||
var exec$1 = uncurryThis$c(/./.exec);
|
||
var charAt$6 = uncurryThis$c(''.charAt);
|
||
var charCodeAt$1 = uncurryThis$c(''.charCodeAt);
|
||
var replace$3 = uncurryThis$c(''.replace);
|
||
var numberToString = uncurryThis$c(1.0.toString);
|
||
var tester = /[\uD800-\uDFFF]/g;
|
||
var low = /^[\uD800-\uDBFF]$/;
|
||
var hi = /^[\uDC00-\uDFFF]$/;
|
||
var WRONG_SYMBOLS_CONVERSION = !NATIVE_SYMBOL || fails$f(function () {
|
||
var symbol = getBuiltIn$4('Symbol')();
|
||
// MS Edge converts symbol values to JSON as {}
|
||
return $stringify([symbol]) != '[null]'
|
||
// WebKit converts symbol values to JSON as null
|
||
|| $stringify({
|
||
a: symbol
|
||
}) != '{}'
|
||
// V8 throws on boxed symbols
|
||
|| $stringify(Object(symbol)) != '{}';
|
||
});
|
||
|
||
// https://github.com/tc39/proposal-well-formed-stringify
|
||
var ILL_FORMED_UNICODE = fails$f(function () {
|
||
return $stringify('\uDF06\uD834') !== '"\\udf06\\ud834"' || $stringify('\uDEAD') !== '"\\udead"';
|
||
});
|
||
var stringifyWithSymbolsFix = function (it, replacer) {
|
||
var args = arraySlice$3(arguments);
|
||
var $replacer = getReplacerFunction(replacer);
|
||
if (!isCallable$d($replacer) && (it === undefined || isSymbol(it))) return; // IE8 returns string on undefined
|
||
args[1] = function (key, value) {
|
||
// some old implementations (like WebKit) could pass numbers as keys
|
||
if (isCallable$d($replacer)) value = call$c($replacer, this, $String$1(key), value);
|
||
if (!isSymbol(value)) return value;
|
||
};
|
||
return apply$2($stringify, null, args);
|
||
};
|
||
var fixIllFormed = function (match, offset, string) {
|
||
var prev = charAt$6(string, offset - 1);
|
||
var next = charAt$6(string, offset + 1);
|
||
if (exec$1(low, match) && !exec$1(hi, next) || exec$1(hi, match) && !exec$1(low, prev)) {
|
||
return '\\u' + numberToString(charCodeAt$1(match, 0), 16);
|
||
}
|
||
return match;
|
||
};
|
||
if ($stringify) {
|
||
// `JSON.stringify` method
|
||
// https://tc39.es/ecma262/#sec-json.stringify
|
||
$$d({
|
||
target: 'JSON',
|
||
stat: true,
|
||
arity: 3,
|
||
forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE
|
||
}, {
|
||
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
||
stringify: function stringify(it, replacer, space) {
|
||
var args = arraySlice$3(arguments);
|
||
var result = apply$2(WRONG_SYMBOLS_CONVERSION ? stringifyWithSymbolsFix : $stringify, null, args);
|
||
return ILL_FORMED_UNICODE && typeof result == 'string' ? replace$3(result, tester, fixIllFormed) : result;
|
||
}
|
||
});
|
||
}
|
||
|
||
var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport;
|
||
var classof$6 = classof$a;
|
||
|
||
// `Object.prototype.toString` method implementation
|
||
// https://tc39.es/ecma262/#sec-object.prototype.tostring
|
||
var objectToString = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() {
|
||
return '[object ' + classof$6(this) + ']';
|
||
};
|
||
|
||
var TO_STRING_TAG_SUPPORT = toStringTagSupport;
|
||
var defineBuiltIn$8 = defineBuiltIn$a;
|
||
var toString$4 = objectToString;
|
||
|
||
// `Object.prototype.toString` method
|
||
// https://tc39.es/ecma262/#sec-object.prototype.tostring
|
||
if (!TO_STRING_TAG_SUPPORT) {
|
||
defineBuiltIn$8(Object.prototype, 'toString', toString$4, {
|
||
unsafe: true
|
||
});
|
||
}
|
||
|
||
var classof$5 = classofRaw$2;
|
||
var engineIsNode = typeof process != 'undefined' && classof$5(process) == 'process';
|
||
|
||
var uncurryThis$b = functionUncurryThis;
|
||
var aCallable$6 = aCallable$8;
|
||
var functionUncurryThisAccessor = function (object, key, method) {
|
||
try {
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
return uncurryThis$b(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method]));
|
||
} catch (error) {/* empty */}
|
||
};
|
||
|
||
var isCallable$c = isCallable$r;
|
||
var $String = String;
|
||
var $TypeError$7 = TypeError;
|
||
var aPossiblePrototype$1 = function (argument) {
|
||
if (typeof argument == 'object' || isCallable$c(argument)) return argument;
|
||
throw $TypeError$7("Can't set " + $String(argument) + ' as a prototype');
|
||
};
|
||
|
||
/* eslint-disable no-proto -- safe */
|
||
var uncurryThisAccessor = functionUncurryThisAccessor;
|
||
var anObject$b = anObject$e;
|
||
var aPossiblePrototype = aPossiblePrototype$1;
|
||
|
||
// `Object.setPrototypeOf` method
|
||
// https://tc39.es/ecma262/#sec-object.setprototypeof
|
||
// Works with __proto__ only. Old v8 can't work with null proto objects.
|
||
// eslint-disable-next-line es/no-object-setprototypeof -- safe
|
||
var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
|
||
var CORRECT_SETTER = false;
|
||
var test = {};
|
||
var setter;
|
||
try {
|
||
setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');
|
||
setter(test, []);
|
||
CORRECT_SETTER = test instanceof Array;
|
||
} catch (error) {/* empty */}
|
||
return function setPrototypeOf(O, proto) {
|
||
anObject$b(O);
|
||
aPossiblePrototype(proto);
|
||
if (CORRECT_SETTER) setter(O, proto);else O.__proto__ = proto;
|
||
return O;
|
||
};
|
||
}() : undefined);
|
||
|
||
var defineProperty$4 = objectDefineProperty.f;
|
||
var hasOwn$4 = hasOwnProperty_1;
|
||
var wellKnownSymbol$e = wellKnownSymbol$l;
|
||
var TO_STRING_TAG$1 = wellKnownSymbol$e('toStringTag');
|
||
var setToStringTag$5 = function (target, TAG, STATIC) {
|
||
if (target && !STATIC) target = target.prototype;
|
||
if (target && !hasOwn$4(target, TO_STRING_TAG$1)) {
|
||
defineProperty$4(target, TO_STRING_TAG$1, {
|
||
configurable: true,
|
||
value: TAG
|
||
});
|
||
}
|
||
};
|
||
|
||
var makeBuiltIn = makeBuiltIn$3.exports;
|
||
var defineProperty$3 = objectDefineProperty;
|
||
var defineBuiltInAccessor$3 = function (target, name, descriptor) {
|
||
if (descriptor.get) makeBuiltIn(descriptor.get, name, {
|
||
getter: true
|
||
});
|
||
if (descriptor.set) makeBuiltIn(descriptor.set, name, {
|
||
setter: true
|
||
});
|
||
return defineProperty$3.f(target, name, descriptor);
|
||
};
|
||
|
||
var getBuiltIn$3 = getBuiltIn$8;
|
||
var defineBuiltInAccessor$2 = defineBuiltInAccessor$3;
|
||
var wellKnownSymbol$d = wellKnownSymbol$l;
|
||
var DESCRIPTORS$5 = descriptors;
|
||
var SPECIES$3 = wellKnownSymbol$d('species');
|
||
var setSpecies$2 = function (CONSTRUCTOR_NAME) {
|
||
var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
|
||
if (DESCRIPTORS$5 && Constructor && !Constructor[SPECIES$3]) {
|
||
defineBuiltInAccessor$2(Constructor, SPECIES$3, {
|
||
configurable: true,
|
||
get: function () {
|
||
return this;
|
||
}
|
||
});
|
||
}
|
||
};
|
||
|
||
var isPrototypeOf$1 = objectIsPrototypeOf;
|
||
var $TypeError$6 = TypeError;
|
||
var anInstance$4 = function (it, Prototype) {
|
||
if (isPrototypeOf$1(Prototype, it)) return it;
|
||
throw $TypeError$6('Incorrect invocation');
|
||
};
|
||
|
||
var isConstructor = isConstructor$2;
|
||
var tryToString$2 = tryToString$4;
|
||
var $TypeError$5 = TypeError;
|
||
|
||
// `Assert: IsConstructor(argument) is true`
|
||
var aConstructor$1 = function (argument) {
|
||
if (isConstructor(argument)) return argument;
|
||
throw $TypeError$5(tryToString$2(argument) + ' is not a constructor');
|
||
};
|
||
|
||
var anObject$a = anObject$e;
|
||
var aConstructor = aConstructor$1;
|
||
var isNullOrUndefined$4 = isNullOrUndefined$7;
|
||
var wellKnownSymbol$c = wellKnownSymbol$l;
|
||
var SPECIES$2 = wellKnownSymbol$c('species');
|
||
|
||
// `SpeciesConstructor` abstract operation
|
||
// https://tc39.es/ecma262/#sec-speciesconstructor
|
||
var speciesConstructor$1 = function (O, defaultConstructor) {
|
||
var C = anObject$a(O).constructor;
|
||
var S;
|
||
return C === undefined || isNullOrUndefined$4(S = anObject$a(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S);
|
||
};
|
||
|
||
var classofRaw = classofRaw$2;
|
||
var uncurryThis$a = functionUncurryThis;
|
||
var functionUncurryThisClause = function (fn) {
|
||
// Nashorn bug:
|
||
// https://github.com/zloirock/core-js/issues/1128
|
||
// https://github.com/zloirock/core-js/issues/1130
|
||
if (classofRaw(fn) === 'Function') return uncurryThis$a(fn);
|
||
};
|
||
|
||
var uncurryThis$9 = functionUncurryThisClause;
|
||
var aCallable$5 = aCallable$8;
|
||
var NATIVE_BIND = functionBindNative;
|
||
var bind$7 = uncurryThis$9(uncurryThis$9.bind);
|
||
|
||
// optional / simple context binding
|
||
var functionBindContext = function (fn, that) {
|
||
aCallable$5(fn);
|
||
return that === undefined ? fn : NATIVE_BIND ? bind$7(fn, that) : function /* ...args */
|
||
() {
|
||
return fn.apply(that, arguments);
|
||
};
|
||
};
|
||
|
||
var getBuiltIn$2 = getBuiltIn$8;
|
||
var html$2 = getBuiltIn$2('document', 'documentElement');
|
||
|
||
var $TypeError$4 = TypeError;
|
||
var validateArgumentsLength$2 = function (passed, required) {
|
||
if (passed < required) throw $TypeError$4('Not enough arguments');
|
||
return passed;
|
||
};
|
||
|
||
var userAgent$2 = engineUserAgent;
|
||
|
||
// eslint-disable-next-line redos/no-vulnerable -- safe
|
||
var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
|
||
|
||
var global$c = global$n;
|
||
var apply$1 = functionApply;
|
||
var bind$6 = functionBindContext;
|
||
var isCallable$b = isCallable$r;
|
||
var hasOwn$3 = hasOwnProperty_1;
|
||
var fails$e = fails$r;
|
||
var html$1 = html$2;
|
||
var arraySlice$2 = arraySlice$4;
|
||
var createElement = documentCreateElement$2;
|
||
var validateArgumentsLength$1 = validateArgumentsLength$2;
|
||
var IS_IOS$1 = engineIsIos;
|
||
var IS_NODE$3 = engineIsNode;
|
||
var set = global$c.setImmediate;
|
||
var clear = global$c.clearImmediate;
|
||
var process$3 = global$c.process;
|
||
var Dispatch = global$c.Dispatch;
|
||
var Function$1 = global$c.Function;
|
||
var MessageChannel = global$c.MessageChannel;
|
||
var String$1 = global$c.String;
|
||
var counter = 0;
|
||
var queue$2 = {};
|
||
var ONREADYSTATECHANGE = 'onreadystatechange';
|
||
var $location, defer, channel, port;
|
||
fails$e(function () {
|
||
// Deno throws a ReferenceError on `location` access without `--location` flag
|
||
$location = global$c.location;
|
||
});
|
||
var run = function (id) {
|
||
if (hasOwn$3(queue$2, id)) {
|
||
var fn = queue$2[id];
|
||
delete queue$2[id];
|
||
fn();
|
||
}
|
||
};
|
||
var runner = function (id) {
|
||
return function () {
|
||
run(id);
|
||
};
|
||
};
|
||
var eventListener = function (event) {
|
||
run(event.data);
|
||
};
|
||
var globalPostMessageDefer = function (id) {
|
||
// old engines have not location.origin
|
||
global$c.postMessage(String$1(id), $location.protocol + '//' + $location.host);
|
||
};
|
||
|
||
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
|
||
if (!set || !clear) {
|
||
set = function setImmediate(handler) {
|
||
validateArgumentsLength$1(arguments.length, 1);
|
||
var fn = isCallable$b(handler) ? handler : Function$1(handler);
|
||
var args = arraySlice$2(arguments, 1);
|
||
queue$2[++counter] = function () {
|
||
apply$1(fn, undefined, args);
|
||
};
|
||
defer(counter);
|
||
return counter;
|
||
};
|
||
clear = function clearImmediate(id) {
|
||
delete queue$2[id];
|
||
};
|
||
// Node.js 0.8-
|
||
if (IS_NODE$3) {
|
||
defer = function (id) {
|
||
process$3.nextTick(runner(id));
|
||
};
|
||
// Sphere (JS game engine) Dispatch API
|
||
} else if (Dispatch && Dispatch.now) {
|
||
defer = function (id) {
|
||
Dispatch.now(runner(id));
|
||
};
|
||
// Browsers with MessageChannel, includes WebWorkers
|
||
// except iOS - https://github.com/zloirock/core-js/issues/624
|
||
} else if (MessageChannel && !IS_IOS$1) {
|
||
channel = new MessageChannel();
|
||
port = channel.port2;
|
||
channel.port1.onmessage = eventListener;
|
||
defer = bind$6(port.postMessage, port);
|
||
// Browsers with postMessage, skip WebWorkers
|
||
// IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
|
||
} else if (global$c.addEventListener && isCallable$b(global$c.postMessage) && !global$c.importScripts && $location && $location.protocol !== 'file:' && !fails$e(globalPostMessageDefer)) {
|
||
defer = globalPostMessageDefer;
|
||
global$c.addEventListener('message', eventListener, false);
|
||
// IE8-
|
||
} else if (ONREADYSTATECHANGE in createElement('script')) {
|
||
defer = function (id) {
|
||
html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
|
||
html$1.removeChild(this);
|
||
run(id);
|
||
};
|
||
};
|
||
// Rest old browsers
|
||
} else {
|
||
defer = function (id) {
|
||
setTimeout(runner(id), 0);
|
||
};
|
||
}
|
||
}
|
||
var task$1 = {
|
||
set: set,
|
||
clear: clear
|
||
};
|
||
|
||
var Queue$2 = function () {
|
||
this.head = null;
|
||
this.tail = null;
|
||
};
|
||
Queue$2.prototype = {
|
||
add: function (item) {
|
||
var entry = {
|
||
item: item,
|
||
next: null
|
||
};
|
||
var tail = this.tail;
|
||
if (tail) tail.next = entry;else this.head = entry;
|
||
this.tail = entry;
|
||
},
|
||
get: function () {
|
||
var entry = this.head;
|
||
if (entry) {
|
||
var next = this.head = entry.next;
|
||
if (next === null) this.tail = null;
|
||
return entry.item;
|
||
}
|
||
}
|
||
};
|
||
var queue$1 = Queue$2;
|
||
|
||
var userAgent$1 = engineUserAgent;
|
||
var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined';
|
||
|
||
var userAgent = engineUserAgent;
|
||
var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
|
||
|
||
var global$b = global$n;
|
||
var bind$5 = functionBindContext;
|
||
var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f;
|
||
var macrotask = task$1.set;
|
||
var Queue$1 = queue$1;
|
||
var IS_IOS = engineIsIos;
|
||
var IS_IOS_PEBBLE = engineIsIosPebble;
|
||
var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
|
||
var IS_NODE$2 = engineIsNode;
|
||
var MutationObserver = global$b.MutationObserver || global$b.WebKitMutationObserver;
|
||
var document$2 = global$b.document;
|
||
var process$2 = global$b.process;
|
||
var Promise$1 = global$b.Promise;
|
||
// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
|
||
var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$b, 'queueMicrotask');
|
||
var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
|
||
var notify$1, toggle, node, promise, then;
|
||
|
||
// modern engines have queueMicrotask method
|
||
if (!microtask$1) {
|
||
var queue = new Queue$1();
|
||
var flush = function () {
|
||
var parent, fn;
|
||
if (IS_NODE$2 && (parent = process$2.domain)) parent.exit();
|
||
while (fn = queue.get()) try {
|
||
fn();
|
||
} catch (error) {
|
||
if (queue.head) notify$1();
|
||
throw error;
|
||
}
|
||
if (parent) parent.enter();
|
||
};
|
||
|
||
// browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
|
||
// also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
|
||
if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
|
||
toggle = true;
|
||
node = document$2.createTextNode('');
|
||
new MutationObserver(flush).observe(node, {
|
||
characterData: true
|
||
});
|
||
notify$1 = function () {
|
||
node.data = toggle = !toggle;
|
||
};
|
||
// environments with maybe non-completely correct, but existent Promise
|
||
} else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) {
|
||
// Promise.resolve without an argument throws an error in LG WebOS 2
|
||
promise = Promise$1.resolve(undefined);
|
||
// workaround of WebKit ~ iOS Safari 10.1 bug
|
||
promise.constructor = Promise$1;
|
||
then = bind$5(promise.then, promise);
|
||
notify$1 = function () {
|
||
then(flush);
|
||
};
|
||
// Node.js without promises
|
||
} else if (IS_NODE$2) {
|
||
notify$1 = function () {
|
||
process$2.nextTick(flush);
|
||
};
|
||
// for other environments - macrotask based on:
|
||
// - setImmediate
|
||
// - MessageChannel
|
||
// - window.postMessage
|
||
// - onreadystatechange
|
||
// - setTimeout
|
||
} else {
|
||
// `webpack` dev server bug on IE global methods - use bind(fn, global)
|
||
macrotask = bind$5(macrotask, global$b);
|
||
notify$1 = function () {
|
||
macrotask(flush);
|
||
};
|
||
}
|
||
microtask$1 = function (fn) {
|
||
if (!queue.head) notify$1();
|
||
queue.add(fn);
|
||
};
|
||
}
|
||
var microtask_1 = microtask$1;
|
||
|
||
var hostReportErrors$1 = function (a, b) {
|
||
try {
|
||
// eslint-disable-next-line no-console -- safe
|
||
arguments.length == 1 ? console.error(a) : console.error(a, b);
|
||
} catch (error) {/* empty */}
|
||
};
|
||
|
||
var perform$3 = function (exec) {
|
||
try {
|
||
return {
|
||
error: false,
|
||
value: exec()
|
||
};
|
||
} catch (error) {
|
||
return {
|
||
error: true,
|
||
value: error
|
||
};
|
||
}
|
||
};
|
||
|
||
var global$a = global$n;
|
||
var promiseNativeConstructor = global$a.Promise;
|
||
|
||
/* global Deno -- Deno case */
|
||
var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
|
||
|
||
var IS_DENO$1 = engineIsDeno;
|
||
var IS_NODE$1 = engineIsNode;
|
||
var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 && typeof window == 'object' && typeof document == 'object';
|
||
|
||
var global$9 = global$n;
|
||
var NativePromiseConstructor$3 = promiseNativeConstructor;
|
||
var isCallable$a = isCallable$r;
|
||
var isForced$1 = isForced_1;
|
||
var inspectSource = inspectSource$3;
|
||
var wellKnownSymbol$b = wellKnownSymbol$l;
|
||
var IS_BROWSER = engineIsBrowser;
|
||
var IS_DENO = engineIsDeno;
|
||
var V8_VERSION = engineV8Version;
|
||
NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype;
|
||
var SPECIES$1 = wellKnownSymbol$b('species');
|
||
var SUBCLASSING = false;
|
||
var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$a(global$9.PromiseRejectionEvent);
|
||
var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () {
|
||
var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3);
|
||
var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3);
|
||
// V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
|
||
// https://bugs.chromium.org/p/chromium/issues/detail?id=830565
|
||
// We can't detect it synchronously, so just check versions
|
||
if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
|
||
// We can't use @@species feature detection in V8 since it causes
|
||
// deoptimization and performance degradation
|
||
// https://github.com/zloirock/core-js/issues/679
|
||
if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
|
||
// Detect correctness of subclassing with @@species support
|
||
var promise = new NativePromiseConstructor$3(function (resolve) {
|
||
resolve(1);
|
||
});
|
||
var FakePromise = function (exec) {
|
||
exec(function () {/* empty */}, function () {/* empty */});
|
||
};
|
||
var constructor = promise.constructor = {};
|
||
constructor[SPECIES$1] = FakePromise;
|
||
SUBCLASSING = promise.then(function () {/* empty */}) instanceof FakePromise;
|
||
if (!SUBCLASSING) return true;
|
||
// Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
|
||
}
|
||
return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1;
|
||
});
|
||
var promiseConstructorDetection = {
|
||
CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5,
|
||
REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1,
|
||
SUBCLASSING: SUBCLASSING
|
||
};
|
||
|
||
var newPromiseCapability$2 = {};
|
||
|
||
var aCallable$4 = aCallable$8;
|
||
var $TypeError$3 = TypeError;
|
||
var PromiseCapability = function (C) {
|
||
var resolve, reject;
|
||
this.promise = new C(function ($$resolve, $$reject) {
|
||
if (resolve !== undefined || reject !== undefined) throw $TypeError$3('Bad Promise constructor');
|
||
resolve = $$resolve;
|
||
reject = $$reject;
|
||
});
|
||
this.resolve = aCallable$4(resolve);
|
||
this.reject = aCallable$4(reject);
|
||
};
|
||
|
||
// `NewPromiseCapability` abstract operation
|
||
// https://tc39.es/ecma262/#sec-newpromisecapability
|
||
newPromiseCapability$2.f = function (C) {
|
||
return new PromiseCapability(C);
|
||
};
|
||
|
||
var $$c = _export;
|
||
var IS_NODE = engineIsNode;
|
||
var global$8 = global$n;
|
||
var call$b = functionCall;
|
||
var defineBuiltIn$7 = defineBuiltIn$a;
|
||
var setPrototypeOf$2 = objectSetPrototypeOf;
|
||
var setToStringTag$4 = setToStringTag$5;
|
||
var setSpecies$1 = setSpecies$2;
|
||
var aCallable$3 = aCallable$8;
|
||
var isCallable$9 = isCallable$r;
|
||
var isObject$7 = isObject$f;
|
||
var anInstance$3 = anInstance$4;
|
||
var speciesConstructor = speciesConstructor$1;
|
||
var task = task$1.set;
|
||
var microtask = microtask_1;
|
||
var hostReportErrors = hostReportErrors$1;
|
||
var perform$2 = perform$3;
|
||
var Queue = queue$1;
|
||
var InternalStateModule$4 = internalState;
|
||
var NativePromiseConstructor$2 = promiseNativeConstructor;
|
||
var PromiseConstructorDetection = promiseConstructorDetection;
|
||
var newPromiseCapabilityModule$3 = newPromiseCapability$2;
|
||
var PROMISE = 'Promise';
|
||
var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR;
|
||
var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
|
||
var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
|
||
var getInternalPromiseState = InternalStateModule$4.getterFor(PROMISE);
|
||
var setInternalState$4 = InternalStateModule$4.set;
|
||
var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype;
|
||
var PromiseConstructor = NativePromiseConstructor$2;
|
||
var PromisePrototype = NativePromisePrototype$1;
|
||
var TypeError$2 = global$8.TypeError;
|
||
var document$1 = global$8.document;
|
||
var process$1 = global$8.process;
|
||
var newPromiseCapability$1 = newPromiseCapabilityModule$3.f;
|
||
var newGenericPromiseCapability = newPromiseCapability$1;
|
||
var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$8.dispatchEvent);
|
||
var UNHANDLED_REJECTION = 'unhandledrejection';
|
||
var REJECTION_HANDLED = 'rejectionhandled';
|
||
var PENDING = 0;
|
||
var FULFILLED = 1;
|
||
var REJECTED = 2;
|
||
var HANDLED = 1;
|
||
var UNHANDLED = 2;
|
||
var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
|
||
|
||
// helpers
|
||
var isThenable = function (it) {
|
||
var then;
|
||
return isObject$7(it) && isCallable$9(then = it.then) ? then : false;
|
||
};
|
||
var callReaction = function (reaction, state) {
|
||
var value = state.value;
|
||
var ok = state.state == FULFILLED;
|
||
var handler = ok ? reaction.ok : reaction.fail;
|
||
var resolve = reaction.resolve;
|
||
var reject = reaction.reject;
|
||
var domain = reaction.domain;
|
||
var result, then, exited;
|
||
try {
|
||
if (handler) {
|
||
if (!ok) {
|
||
if (state.rejection === UNHANDLED) onHandleUnhandled(state);
|
||
state.rejection = HANDLED;
|
||
}
|
||
if (handler === true) result = value;else {
|
||
if (domain) domain.enter();
|
||
result = handler(value); // can throw
|
||
if (domain) {
|
||
domain.exit();
|
||
exited = true;
|
||
}
|
||
}
|
||
if (result === reaction.promise) {
|
||
reject(TypeError$2('Promise-chain cycle'));
|
||
} else if (then = isThenable(result)) {
|
||
call$b(then, result, resolve, reject);
|
||
} else resolve(result);
|
||
} else reject(value);
|
||
} catch (error) {
|
||
if (domain && !exited) domain.exit();
|
||
reject(error);
|
||
}
|
||
};
|
||
var notify = function (state, isReject) {
|
||
if (state.notified) return;
|
||
state.notified = true;
|
||
microtask(function () {
|
||
var reactions = state.reactions;
|
||
var reaction;
|
||
while (reaction = reactions.get()) {
|
||
callReaction(reaction, state);
|
||
}
|
||
state.notified = false;
|
||
if (isReject && !state.rejection) onUnhandled(state);
|
||
});
|
||
};
|
||
var dispatchEvent = function (name, promise, reason) {
|
||
var event, handler;
|
||
if (DISPATCH_EVENT) {
|
||
event = document$1.createEvent('Event');
|
||
event.promise = promise;
|
||
event.reason = reason;
|
||
event.initEvent(name, false, true);
|
||
global$8.dispatchEvent(event);
|
||
} else event = {
|
||
promise: promise,
|
||
reason: reason
|
||
};
|
||
if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$8['on' + name])) handler(event);else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
|
||
};
|
||
var onUnhandled = function (state) {
|
||
call$b(task, global$8, function () {
|
||
var promise = state.facade;
|
||
var value = state.value;
|
||
var IS_UNHANDLED = isUnhandled(state);
|
||
var result;
|
||
if (IS_UNHANDLED) {
|
||
result = perform$2(function () {
|
||
if (IS_NODE) {
|
||
process$1.emit('unhandledRejection', value, promise);
|
||
} else dispatchEvent(UNHANDLED_REJECTION, promise, value);
|
||
});
|
||
// Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
|
||
state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
|
||
if (result.error) throw result.value;
|
||
}
|
||
});
|
||
};
|
||
var isUnhandled = function (state) {
|
||
return state.rejection !== HANDLED && !state.parent;
|
||
};
|
||
var onHandleUnhandled = function (state) {
|
||
call$b(task, global$8, function () {
|
||
var promise = state.facade;
|
||
if (IS_NODE) {
|
||
process$1.emit('rejectionHandled', promise);
|
||
} else dispatchEvent(REJECTION_HANDLED, promise, state.value);
|
||
});
|
||
};
|
||
var bind$4 = function (fn, state, unwrap) {
|
||
return function (value) {
|
||
fn(state, value, unwrap);
|
||
};
|
||
};
|
||
var internalReject = function (state, value, unwrap) {
|
||
if (state.done) return;
|
||
state.done = true;
|
||
if (unwrap) state = unwrap;
|
||
state.value = value;
|
||
state.state = REJECTED;
|
||
notify(state, true);
|
||
};
|
||
var internalResolve = function (state, value, unwrap) {
|
||
if (state.done) return;
|
||
state.done = true;
|
||
if (unwrap) state = unwrap;
|
||
try {
|
||
if (state.facade === value) throw TypeError$2("Promise can't be resolved itself");
|
||
var then = isThenable(value);
|
||
if (then) {
|
||
microtask(function () {
|
||
var wrapper = {
|
||
done: false
|
||
};
|
||
try {
|
||
call$b(then, value, bind$4(internalResolve, wrapper, state), bind$4(internalReject, wrapper, state));
|
||
} catch (error) {
|
||
internalReject(wrapper, error, state);
|
||
}
|
||
});
|
||
} else {
|
||
state.value = value;
|
||
state.state = FULFILLED;
|
||
notify(state, false);
|
||
}
|
||
} catch (error) {
|
||
internalReject({
|
||
done: false
|
||
}, error, state);
|
||
}
|
||
};
|
||
|
||
// constructor polyfill
|
||
if (FORCED_PROMISE_CONSTRUCTOR$4) {
|
||
// 25.4.3.1 Promise(executor)
|
||
PromiseConstructor = function Promise(executor) {
|
||
anInstance$3(this, PromisePrototype);
|
||
aCallable$3(executor);
|
||
call$b(Internal, this);
|
||
var state = getInternalPromiseState(this);
|
||
try {
|
||
executor(bind$4(internalResolve, state), bind$4(internalReject, state));
|
||
} catch (error) {
|
||
internalReject(state, error);
|
||
}
|
||
};
|
||
PromisePrototype = PromiseConstructor.prototype;
|
||
|
||
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
||
Internal = function Promise(executor) {
|
||
setInternalState$4(this, {
|
||
type: PROMISE,
|
||
done: false,
|
||
notified: false,
|
||
parent: false,
|
||
reactions: new Queue(),
|
||
rejection: false,
|
||
state: PENDING,
|
||
value: undefined
|
||
});
|
||
};
|
||
|
||
// `Promise.prototype.then` method
|
||
// https://tc39.es/ecma262/#sec-promise.prototype.then
|
||
Internal.prototype = defineBuiltIn$7(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
|
||
var state = getInternalPromiseState(this);
|
||
var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor));
|
||
state.parent = true;
|
||
reaction.ok = isCallable$9(onFulfilled) ? onFulfilled : true;
|
||
reaction.fail = isCallable$9(onRejected) && onRejected;
|
||
reaction.domain = IS_NODE ? process$1.domain : undefined;
|
||
if (state.state == PENDING) state.reactions.add(reaction);else microtask(function () {
|
||
callReaction(reaction, state);
|
||
});
|
||
return reaction.promise;
|
||
});
|
||
OwnPromiseCapability = function () {
|
||
var promise = new Internal();
|
||
var state = getInternalPromiseState(promise);
|
||
this.promise = promise;
|
||
this.resolve = bind$4(internalResolve, state);
|
||
this.reject = bind$4(internalReject, state);
|
||
};
|
||
newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) {
|
||
return C === PromiseConstructor || C === PromiseWrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C);
|
||
};
|
||
if (isCallable$9(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) {
|
||
nativeThen = NativePromisePrototype$1.then;
|
||
if (!NATIVE_PROMISE_SUBCLASSING) {
|
||
// make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
|
||
defineBuiltIn$7(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) {
|
||
var that = this;
|
||
return new PromiseConstructor(function (resolve, reject) {
|
||
call$b(nativeThen, that, resolve, reject);
|
||
}).then(onFulfilled, onRejected);
|
||
// https://github.com/zloirock/core-js/issues/640
|
||
}, {
|
||
unsafe: true
|
||
});
|
||
}
|
||
|
||
// make `.constructor === Promise` work for native promise-based APIs
|
||
try {
|
||
delete NativePromisePrototype$1.constructor;
|
||
} catch (error) {/* empty */}
|
||
|
||
// make `instanceof Promise` work for native promise-based APIs
|
||
if (setPrototypeOf$2) {
|
||
setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype);
|
||
}
|
||
}
|
||
}
|
||
$$c({
|
||
global: true,
|
||
constructor: true,
|
||
wrap: true,
|
||
forced: FORCED_PROMISE_CONSTRUCTOR$4
|
||
}, {
|
||
Promise: PromiseConstructor
|
||
});
|
||
setToStringTag$4(PromiseConstructor, PROMISE, false);
|
||
setSpecies$1(PROMISE);
|
||
|
||
var iterators = {};
|
||
|
||
var wellKnownSymbol$a = wellKnownSymbol$l;
|
||
var Iterators$4 = iterators;
|
||
var ITERATOR$7 = wellKnownSymbol$a('iterator');
|
||
var ArrayPrototype$1 = Array.prototype;
|
||
|
||
// check on default Array iterator
|
||
var isArrayIteratorMethod$1 = function (it) {
|
||
return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$7] === it);
|
||
};
|
||
|
||
var classof$4 = classof$a;
|
||
var getMethod$2 = getMethod$4;
|
||
var isNullOrUndefined$3 = isNullOrUndefined$7;
|
||
var Iterators$3 = iterators;
|
||
var wellKnownSymbol$9 = wellKnownSymbol$l;
|
||
var ITERATOR$6 = wellKnownSymbol$9('iterator');
|
||
var getIteratorMethod$3 = function (it) {
|
||
if (!isNullOrUndefined$3(it)) return getMethod$2(it, ITERATOR$6) || getMethod$2(it, '@@iterator') || Iterators$3[classof$4(it)];
|
||
};
|
||
|
||
var call$a = functionCall;
|
||
var aCallable$2 = aCallable$8;
|
||
var anObject$9 = anObject$e;
|
||
var tryToString$1 = tryToString$4;
|
||
var getIteratorMethod$2 = getIteratorMethod$3;
|
||
var $TypeError$2 = TypeError;
|
||
var getIterator$2 = function (argument, usingIterator) {
|
||
var iteratorMethod = arguments.length < 2 ? getIteratorMethod$2(argument) : usingIterator;
|
||
if (aCallable$2(iteratorMethod)) return anObject$9(call$a(iteratorMethod, argument));
|
||
throw $TypeError$2(tryToString$1(argument) + ' is not iterable');
|
||
};
|
||
|
||
var call$9 = functionCall;
|
||
var anObject$8 = anObject$e;
|
||
var getMethod$1 = getMethod$4;
|
||
var iteratorClose$1 = function (iterator, kind, value) {
|
||
var innerResult, innerError;
|
||
anObject$8(iterator);
|
||
try {
|
||
innerResult = getMethod$1(iterator, 'return');
|
||
if (!innerResult) {
|
||
if (kind === 'throw') throw value;
|
||
return value;
|
||
}
|
||
innerResult = call$9(innerResult, iterator);
|
||
} catch (error) {
|
||
innerError = true;
|
||
innerResult = error;
|
||
}
|
||
if (kind === 'throw') throw value;
|
||
if (innerError) throw innerResult;
|
||
anObject$8(innerResult);
|
||
return value;
|
||
};
|
||
|
||
var bind$3 = functionBindContext;
|
||
var call$8 = functionCall;
|
||
var anObject$7 = anObject$e;
|
||
var tryToString = tryToString$4;
|
||
var isArrayIteratorMethod = isArrayIteratorMethod$1;
|
||
var lengthOfArrayLike$2 = lengthOfArrayLike$5;
|
||
var isPrototypeOf = objectIsPrototypeOf;
|
||
var getIterator$1 = getIterator$2;
|
||
var getIteratorMethod$1 = getIteratorMethod$3;
|
||
var iteratorClose = iteratorClose$1;
|
||
var $TypeError$1 = TypeError;
|
||
var Result = function (stopped, result) {
|
||
this.stopped = stopped;
|
||
this.result = result;
|
||
};
|
||
var ResultPrototype = Result.prototype;
|
||
var iterate$4 = function (iterable, unboundFunction, options) {
|
||
var that = options && options.that;
|
||
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
|
||
var IS_RECORD = !!(options && options.IS_RECORD);
|
||
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
|
||
var INTERRUPTED = !!(options && options.INTERRUPTED);
|
||
var fn = bind$3(unboundFunction, that);
|
||
var iterator, iterFn, index, length, result, next, step;
|
||
var stop = function (condition) {
|
||
if (iterator) iteratorClose(iterator, 'normal', condition);
|
||
return new Result(true, condition);
|
||
};
|
||
var callFn = function (value) {
|
||
if (AS_ENTRIES) {
|
||
anObject$7(value);
|
||
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
|
||
}
|
||
return INTERRUPTED ? fn(value, stop) : fn(value);
|
||
};
|
||
if (IS_RECORD) {
|
||
iterator = iterable.iterator;
|
||
} else if (IS_ITERATOR) {
|
||
iterator = iterable;
|
||
} else {
|
||
iterFn = getIteratorMethod$1(iterable);
|
||
if (!iterFn) throw $TypeError$1(tryToString(iterable) + ' is not iterable');
|
||
// optimisation for array iterators
|
||
if (isArrayIteratorMethod(iterFn)) {
|
||
for (index = 0, length = lengthOfArrayLike$2(iterable); length > index; index++) {
|
||
result = callFn(iterable[index]);
|
||
if (result && isPrototypeOf(ResultPrototype, result)) return result;
|
||
}
|
||
return new Result(false);
|
||
}
|
||
iterator = getIterator$1(iterable, iterFn);
|
||
}
|
||
next = IS_RECORD ? iterable.next : iterator.next;
|
||
while (!(step = call$8(next, iterator)).done) {
|
||
try {
|
||
result = callFn(step.value);
|
||
} catch (error) {
|
||
iteratorClose(iterator, 'throw', error);
|
||
}
|
||
if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
|
||
}
|
||
return new Result(false);
|
||
};
|
||
|
||
var wellKnownSymbol$8 = wellKnownSymbol$l;
|
||
var ITERATOR$5 = wellKnownSymbol$8('iterator');
|
||
var SAFE_CLOSING = false;
|
||
try {
|
||
var called = 0;
|
||
var iteratorWithReturn = {
|
||
next: function () {
|
||
return {
|
||
done: !!called++
|
||
};
|
||
},
|
||
'return': function () {
|
||
SAFE_CLOSING = true;
|
||
}
|
||
};
|
||
iteratorWithReturn[ITERATOR$5] = function () {
|
||
return this;
|
||
};
|
||
// eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
|
||
Array.from(iteratorWithReturn, function () {
|
||
throw 2;
|
||
});
|
||
} catch (error) {/* empty */}
|
||
var checkCorrectnessOfIteration$2 = function (exec, SKIP_CLOSING) {
|
||
if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
|
||
var ITERATION_SUPPORT = false;
|
||
try {
|
||
var object = {};
|
||
object[ITERATOR$5] = function () {
|
||
return {
|
||
next: function () {
|
||
return {
|
||
done: ITERATION_SUPPORT = true
|
||
};
|
||
}
|
||
};
|
||
};
|
||
exec(object);
|
||
} catch (error) {/* empty */}
|
||
return ITERATION_SUPPORT;
|
||
};
|
||
|
||
var NativePromiseConstructor$1 = promiseNativeConstructor;
|
||
var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$2;
|
||
var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR;
|
||
var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$1(function (iterable) {
|
||
NativePromiseConstructor$1.all(iterable).then(undefined, function () {/* empty */});
|
||
});
|
||
|
||
var $$b = _export;
|
||
var call$7 = functionCall;
|
||
var aCallable$1 = aCallable$8;
|
||
var newPromiseCapabilityModule$2 = newPromiseCapability$2;
|
||
var perform$1 = perform$3;
|
||
var iterate$3 = iterate$4;
|
||
var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration;
|
||
|
||
// `Promise.all` method
|
||
// https://tc39.es/ecma262/#sec-promise.all
|
||
$$b({
|
||
target: 'Promise',
|
||
stat: true,
|
||
forced: PROMISE_STATICS_INCORRECT_ITERATION$1
|
||
}, {
|
||
all: function all(iterable) {
|
||
var C = this;
|
||
var capability = newPromiseCapabilityModule$2.f(C);
|
||
var resolve = capability.resolve;
|
||
var reject = capability.reject;
|
||
var result = perform$1(function () {
|
||
var $promiseResolve = aCallable$1(C.resolve);
|
||
var values = [];
|
||
var counter = 0;
|
||
var remaining = 1;
|
||
iterate$3(iterable, function (promise) {
|
||
var index = counter++;
|
||
var alreadyCalled = false;
|
||
remaining++;
|
||
call$7($promiseResolve, C, promise).then(function (value) {
|
||
if (alreadyCalled) return;
|
||
alreadyCalled = true;
|
||
values[index] = value;
|
||
--remaining || resolve(values);
|
||
}, reject);
|
||
});
|
||
--remaining || resolve(values);
|
||
});
|
||
if (result.error) reject(result.value);
|
||
return capability.promise;
|
||
}
|
||
});
|
||
|
||
var $$a = _export;
|
||
var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
|
||
var NativePromiseConstructor = promiseNativeConstructor;
|
||
var getBuiltIn$1 = getBuiltIn$8;
|
||
var isCallable$8 = isCallable$r;
|
||
var defineBuiltIn$6 = defineBuiltIn$a;
|
||
var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
|
||
|
||
// `Promise.prototype.catch` method
|
||
// https://tc39.es/ecma262/#sec-promise.prototype.catch
|
||
$$a({
|
||
target: 'Promise',
|
||
proto: true,
|
||
forced: FORCED_PROMISE_CONSTRUCTOR$2,
|
||
real: true
|
||
}, {
|
||
'catch': function (onRejected) {
|
||
return this.then(undefined, onRejected);
|
||
}
|
||
});
|
||
|
||
// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
|
||
if (isCallable$8(NativePromiseConstructor)) {
|
||
var method = getBuiltIn$1('Promise').prototype['catch'];
|
||
if (NativePromisePrototype['catch'] !== method) {
|
||
defineBuiltIn$6(NativePromisePrototype, 'catch', method, {
|
||
unsafe: true
|
||
});
|
||
}
|
||
}
|
||
|
||
var $$9 = _export;
|
||
var call$6 = functionCall;
|
||
var aCallable = aCallable$8;
|
||
var newPromiseCapabilityModule$1 = newPromiseCapability$2;
|
||
var perform = perform$3;
|
||
var iterate$2 = iterate$4;
|
||
var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration;
|
||
|
||
// `Promise.race` method
|
||
// https://tc39.es/ecma262/#sec-promise.race
|
||
$$9({
|
||
target: 'Promise',
|
||
stat: true,
|
||
forced: PROMISE_STATICS_INCORRECT_ITERATION
|
||
}, {
|
||
race: function race(iterable) {
|
||
var C = this;
|
||
var capability = newPromiseCapabilityModule$1.f(C);
|
||
var reject = capability.reject;
|
||
var result = perform(function () {
|
||
var $promiseResolve = aCallable(C.resolve);
|
||
iterate$2(iterable, function (promise) {
|
||
call$6($promiseResolve, C, promise).then(capability.resolve, reject);
|
||
});
|
||
});
|
||
if (result.error) reject(result.value);
|
||
return capability.promise;
|
||
}
|
||
});
|
||
|
||
var $$8 = _export;
|
||
var call$5 = functionCall;
|
||
var newPromiseCapabilityModule = newPromiseCapability$2;
|
||
var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
|
||
|
||
// `Promise.reject` method
|
||
// https://tc39.es/ecma262/#sec-promise.reject
|
||
$$8({
|
||
target: 'Promise',
|
||
stat: true,
|
||
forced: FORCED_PROMISE_CONSTRUCTOR$1
|
||
}, {
|
||
reject: function reject(r) {
|
||
var capability = newPromiseCapabilityModule.f(this);
|
||
call$5(capability.reject, undefined, r);
|
||
return capability.promise;
|
||
}
|
||
});
|
||
|
||
var anObject$6 = anObject$e;
|
||
var isObject$6 = isObject$f;
|
||
var newPromiseCapability = newPromiseCapability$2;
|
||
var promiseResolve$1 = function (C, x) {
|
||
anObject$6(C);
|
||
if (isObject$6(x) && x.constructor === C) return x;
|
||
var promiseCapability = newPromiseCapability.f(C);
|
||
var resolve = promiseCapability.resolve;
|
||
resolve(x);
|
||
return promiseCapability.promise;
|
||
};
|
||
|
||
var $$7 = _export;
|
||
var getBuiltIn = getBuiltIn$8;
|
||
var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR;
|
||
var promiseResolve = promiseResolve$1;
|
||
getBuiltIn('Promise');
|
||
|
||
// `Promise.resolve` method
|
||
// https://tc39.es/ecma262/#sec-promise.resolve
|
||
$$7({
|
||
target: 'Promise',
|
||
stat: true,
|
||
forced: FORCED_PROMISE_CONSTRUCTOR
|
||
}, {
|
||
resolve: function resolve(x) {
|
||
return promiseResolve(this, x);
|
||
}
|
||
});
|
||
|
||
// iterable DOM collections
|
||
// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
|
||
var domIterables = {
|
||
CSSRuleList: 0,
|
||
CSSStyleDeclaration: 0,
|
||
CSSValueList: 0,
|
||
ClientRectList: 0,
|
||
DOMRectList: 0,
|
||
DOMStringList: 0,
|
||
DOMTokenList: 1,
|
||
DataTransferItemList: 0,
|
||
FileList: 0,
|
||
HTMLAllCollection: 0,
|
||
HTMLCollection: 0,
|
||
HTMLFormElement: 0,
|
||
HTMLSelectElement: 0,
|
||
MediaList: 0,
|
||
MimeTypeArray: 0,
|
||
NamedNodeMap: 0,
|
||
NodeList: 1,
|
||
PaintRequestList: 0,
|
||
Plugin: 0,
|
||
PluginArray: 0,
|
||
SVGLengthList: 0,
|
||
SVGNumberList: 0,
|
||
SVGPathSegList: 0,
|
||
SVGPointList: 0,
|
||
SVGStringList: 0,
|
||
SVGTransformList: 0,
|
||
SourceBufferList: 0,
|
||
StyleSheetList: 0,
|
||
TextTrackCueList: 0,
|
||
TextTrackList: 0,
|
||
TouchList: 0
|
||
};
|
||
|
||
// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
|
||
var documentCreateElement$1 = documentCreateElement$2;
|
||
var classList = documentCreateElement$1('span').classList;
|
||
var DOMTokenListPrototype$2 = classList && classList.constructor && classList.constructor.prototype;
|
||
var domTokenListPrototype = DOMTokenListPrototype$2 === Object.prototype ? undefined : DOMTokenListPrototype$2;
|
||
|
||
var bind$2 = functionBindContext;
|
||
var uncurryThis$8 = functionUncurryThis;
|
||
var IndexedObject = indexedObject;
|
||
var toObject$3 = toObject$6;
|
||
var lengthOfArrayLike$1 = lengthOfArrayLike$5;
|
||
var arraySpeciesCreate = arraySpeciesCreate$2;
|
||
var push$2 = uncurryThis$8([].push);
|
||
|
||
// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
|
||
var createMethod$1 = function (TYPE) {
|
||
var IS_MAP = TYPE == 1;
|
||
var IS_FILTER = TYPE == 2;
|
||
var IS_SOME = TYPE == 3;
|
||
var IS_EVERY = TYPE == 4;
|
||
var IS_FIND_INDEX = TYPE == 6;
|
||
var IS_FILTER_REJECT = TYPE == 7;
|
||
var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
|
||
return function ($this, callbackfn, that, specificCreate) {
|
||
var O = toObject$3($this);
|
||
var self = IndexedObject(O);
|
||
var boundFunction = bind$2(callbackfn, that);
|
||
var length = lengthOfArrayLike$1(self);
|
||
var index = 0;
|
||
var create = specificCreate || arraySpeciesCreate;
|
||
var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
|
||
var value, result;
|
||
for (; length > index; index++) if (NO_HOLES || index in self) {
|
||
value = self[index];
|
||
result = boundFunction(value, index, O);
|
||
if (TYPE) {
|
||
if (IS_MAP) target[index] = result; // map
|
||
else if (result) switch (TYPE) {
|
||
case 3:
|
||
return true;
|
||
// some
|
||
case 5:
|
||
return value;
|
||
// find
|
||
case 6:
|
||
return index;
|
||
// findIndex
|
||
case 2:
|
||
push$2(target, value);
|
||
// filter
|
||
} else switch (TYPE) {
|
||
case 4:
|
||
return false;
|
||
// every
|
||
case 7:
|
||
push$2(target, value);
|
||
// filterReject
|
||
}
|
||
}
|
||
}
|
||
|
||
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
|
||
};
|
||
};
|
||
var arrayIteration = {
|
||
// `Array.prototype.forEach` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.foreach
|
||
forEach: createMethod$1(0),
|
||
// `Array.prototype.map` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.map
|
||
map: createMethod$1(1),
|
||
// `Array.prototype.filter` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.filter
|
||
filter: createMethod$1(2),
|
||
// `Array.prototype.some` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.some
|
||
some: createMethod$1(3),
|
||
// `Array.prototype.every` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.every
|
||
every: createMethod$1(4),
|
||
// `Array.prototype.find` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.find
|
||
find: createMethod$1(5),
|
||
// `Array.prototype.findIndex` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.findIndex
|
||
findIndex: createMethod$1(6),
|
||
// `Array.prototype.filterReject` method
|
||
// https://github.com/tc39/proposal-array-filtering
|
||
filterReject: createMethod$1(7)
|
||
};
|
||
|
||
var fails$d = fails$r;
|
||
var arrayMethodIsStrict$1 = function (METHOD_NAME, argument) {
|
||
var method = [][METHOD_NAME];
|
||
return !!method && fails$d(function () {
|
||
// eslint-disable-next-line no-useless-call -- required for testing
|
||
method.call(null, argument || function () {
|
||
return 1;
|
||
}, 1);
|
||
});
|
||
};
|
||
|
||
var $forEach = arrayIteration.forEach;
|
||
var arrayMethodIsStrict = arrayMethodIsStrict$1;
|
||
var STRICT_METHOD = arrayMethodIsStrict('forEach');
|
||
|
||
// `Array.prototype.forEach` method implementation
|
||
// https://tc39.es/ecma262/#sec-array.prototype.foreach
|
||
var arrayForEach = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {
|
||
return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
|
||
// eslint-disable-next-line es/no-array-prototype-foreach -- safe
|
||
} : [].forEach;
|
||
|
||
var global$7 = global$n;
|
||
var DOMIterables$1 = domIterables;
|
||
var DOMTokenListPrototype$1 = domTokenListPrototype;
|
||
var forEach = arrayForEach;
|
||
var createNonEnumerableProperty$3 = createNonEnumerableProperty$6;
|
||
var handlePrototype$1 = function (CollectionPrototype) {
|
||
// some Chrome versions have non-configurable methods on DOMTokenList
|
||
if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {
|
||
createNonEnumerableProperty$3(CollectionPrototype, 'forEach', forEach);
|
||
} catch (error) {
|
||
CollectionPrototype.forEach = forEach;
|
||
}
|
||
};
|
||
for (var COLLECTION_NAME$1 in DOMIterables$1) {
|
||
if (DOMIterables$1[COLLECTION_NAME$1]) {
|
||
handlePrototype$1(global$7[COLLECTION_NAME$1] && global$7[COLLECTION_NAME$1].prototype);
|
||
}
|
||
}
|
||
handlePrototype$1(DOMTokenListPrototype$1);
|
||
|
||
var internalObjectKeys = objectKeysInternal;
|
||
var enumBugKeys$1 = enumBugKeys$3;
|
||
|
||
// `Object.keys` method
|
||
// https://tc39.es/ecma262/#sec-object.keys
|
||
// eslint-disable-next-line es/no-object-keys -- safe
|
||
var objectKeys$1 = Object.keys || function keys(O) {
|
||
return internalObjectKeys(O, enumBugKeys$1);
|
||
};
|
||
|
||
var $$6 = _export;
|
||
var toObject$2 = toObject$6;
|
||
var nativeKeys = objectKeys$1;
|
||
var fails$c = fails$r;
|
||
var FAILS_ON_PRIMITIVES$1 = fails$c(function () {
|
||
nativeKeys(1);
|
||
});
|
||
|
||
// `Object.keys` method
|
||
// https://tc39.es/ecma262/#sec-object.keys
|
||
$$6({
|
||
target: 'Object',
|
||
stat: true,
|
||
forced: FAILS_ON_PRIMITIVES$1
|
||
}, {
|
||
keys: function keys(it) {
|
||
return nativeKeys(toObject$2(it));
|
||
}
|
||
});
|
||
|
||
var objectDefineProperties = {};
|
||
|
||
var DESCRIPTORS$4 = descriptors;
|
||
var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
|
||
var definePropertyModule = objectDefineProperty;
|
||
var anObject$5 = anObject$e;
|
||
var toIndexedObject$2 = toIndexedObject$6;
|
||
var objectKeys = objectKeys$1;
|
||
|
||
// `Object.defineProperties` method
|
||
// https://tc39.es/ecma262/#sec-object.defineproperties
|
||
// eslint-disable-next-line es/no-object-defineproperties -- safe
|
||
objectDefineProperties.f = DESCRIPTORS$4 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
|
||
anObject$5(O);
|
||
var props = toIndexedObject$2(Properties);
|
||
var keys = objectKeys(Properties);
|
||
var length = keys.length;
|
||
var index = 0;
|
||
var key;
|
||
while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
|
||
return O;
|
||
};
|
||
|
||
/* global ActiveXObject -- old IE, WSH */
|
||
var anObject$4 = anObject$e;
|
||
var definePropertiesModule = objectDefineProperties;
|
||
var enumBugKeys = enumBugKeys$3;
|
||
var hiddenKeys$1 = hiddenKeys$5;
|
||
var html = html$2;
|
||
var documentCreateElement = documentCreateElement$2;
|
||
var sharedKey$1 = sharedKey$3;
|
||
var GT = '>';
|
||
var LT = '<';
|
||
var PROTOTYPE = 'prototype';
|
||
var SCRIPT = 'script';
|
||
var IE_PROTO$1 = sharedKey$1('IE_PROTO');
|
||
var EmptyConstructor = function () {/* empty */};
|
||
var scriptTag = function (content) {
|
||
return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
|
||
};
|
||
|
||
// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
|
||
var NullProtoObjectViaActiveX = function (activeXDocument) {
|
||
activeXDocument.write(scriptTag(''));
|
||
activeXDocument.close();
|
||
var temp = activeXDocument.parentWindow.Object;
|
||
activeXDocument = null; // avoid memory leak
|
||
return temp;
|
||
};
|
||
|
||
// Create object with fake `null` prototype: use iframe Object with cleared prototype
|
||
var NullProtoObjectViaIFrame = function () {
|
||
// Thrash, waste and sodomy: IE GC bug
|
||
var iframe = documentCreateElement('iframe');
|
||
var JS = 'java' + SCRIPT + ':';
|
||
var iframeDocument;
|
||
iframe.style.display = 'none';
|
||
html.appendChild(iframe);
|
||
// https://github.com/zloirock/core-js/issues/475
|
||
iframe.src = String(JS);
|
||
iframeDocument = iframe.contentWindow.document;
|
||
iframeDocument.open();
|
||
iframeDocument.write(scriptTag('document.F=Object'));
|
||
iframeDocument.close();
|
||
return iframeDocument.F;
|
||
};
|
||
|
||
// Check for document.domain and active x support
|
||
// No need to use active x approach when document.domain is not set
|
||
// see https://github.com/es-shims/es5-shim/issues/150
|
||
// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
|
||
// avoid IE GC bug
|
||
var activeXDocument;
|
||
var NullProtoObject = function () {
|
||
try {
|
||
activeXDocument = new ActiveXObject('htmlfile');
|
||
} catch (error) {/* ignore */}
|
||
NullProtoObject = typeof document != 'undefined' ? document.domain && activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) // old IE
|
||
: NullProtoObjectViaIFrame() : NullProtoObjectViaActiveX(activeXDocument); // WSH
|
||
var length = enumBugKeys.length;
|
||
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
|
||
return NullProtoObject();
|
||
};
|
||
hiddenKeys$1[IE_PROTO$1] = true;
|
||
|
||
// `Object.create` method
|
||
// https://tc39.es/ecma262/#sec-object.create
|
||
// eslint-disable-next-line es/no-object-create -- safe
|
||
var objectCreate = Object.create || function create(O, Properties) {
|
||
var result;
|
||
if (O !== null) {
|
||
EmptyConstructor[PROTOTYPE] = anObject$4(O);
|
||
result = new EmptyConstructor();
|
||
EmptyConstructor[PROTOTYPE] = null;
|
||
// add "__proto__" for Object.getPrototypeOf polyfill
|
||
result[IE_PROTO$1] = O;
|
||
} else result = NullProtoObject();
|
||
return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
|
||
};
|
||
|
||
var wellKnownSymbol$7 = wellKnownSymbol$l;
|
||
var create$4 = objectCreate;
|
||
var defineProperty$2 = objectDefineProperty.f;
|
||
var UNSCOPABLES = wellKnownSymbol$7('unscopables');
|
||
var ArrayPrototype = Array.prototype;
|
||
|
||
// Array.prototype[@@unscopables]
|
||
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
||
if (ArrayPrototype[UNSCOPABLES] == undefined) {
|
||
defineProperty$2(ArrayPrototype, UNSCOPABLES, {
|
||
configurable: true,
|
||
value: create$4(null)
|
||
});
|
||
}
|
||
|
||
// add a key to Array.prototype[@@unscopables]
|
||
var addToUnscopables$1 = function (key) {
|
||
ArrayPrototype[UNSCOPABLES][key] = true;
|
||
};
|
||
|
||
var fails$b = fails$r;
|
||
var correctPrototypeGetter = !fails$b(function () {
|
||
function F() {/* empty */}
|
||
F.prototype.constructor = null;
|
||
// eslint-disable-next-line es/no-object-getprototypeof -- required for testing
|
||
return Object.getPrototypeOf(new F()) !== F.prototype;
|
||
});
|
||
|
||
var hasOwn$2 = hasOwnProperty_1;
|
||
var isCallable$7 = isCallable$r;
|
||
var toObject$1 = toObject$6;
|
||
var sharedKey = sharedKey$3;
|
||
var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
|
||
var IE_PROTO = sharedKey('IE_PROTO');
|
||
var $Object = Object;
|
||
var ObjectPrototype = $Object.prototype;
|
||
|
||
// `Object.getPrototypeOf` method
|
||
// https://tc39.es/ecma262/#sec-object.getprototypeof
|
||
// eslint-disable-next-line es/no-object-getprototypeof -- safe
|
||
var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
|
||
var object = toObject$1(O);
|
||
if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO];
|
||
var constructor = object.constructor;
|
||
if (isCallable$7(constructor) && object instanceof constructor) {
|
||
return constructor.prototype;
|
||
}
|
||
return object instanceof $Object ? ObjectPrototype : null;
|
||
};
|
||
|
||
var fails$a = fails$r;
|
||
var isCallable$6 = isCallable$r;
|
||
var isObject$5 = isObject$f;
|
||
var getPrototypeOf$1 = objectGetPrototypeOf;
|
||
var defineBuiltIn$5 = defineBuiltIn$a;
|
||
var wellKnownSymbol$6 = wellKnownSymbol$l;
|
||
var ITERATOR$4 = wellKnownSymbol$6('iterator');
|
||
var BUGGY_SAFARI_ITERATORS$1 = false;
|
||
|
||
// `%IteratorPrototype%` object
|
||
// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
|
||
var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator;
|
||
|
||
/* eslint-disable es/no-array-prototype-keys -- safe */
|
||
if ([].keys) {
|
||
arrayIterator = [].keys();
|
||
// Safari 8 has buggy iterators w/o `next`
|
||
if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true;else {
|
||
PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator));
|
||
if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype;
|
||
}
|
||
}
|
||
var NEW_ITERATOR_PROTOTYPE = !isObject$5(IteratorPrototype$2) || fails$a(function () {
|
||
var test = {};
|
||
// FF44- legacy iterators case
|
||
return IteratorPrototype$2[ITERATOR$4].call(test) !== test;
|
||
});
|
||
if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
|
||
|
||
// `%IteratorPrototype%[@@iterator]()` method
|
||
// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
|
||
if (!isCallable$6(IteratorPrototype$2[ITERATOR$4])) {
|
||
defineBuiltIn$5(IteratorPrototype$2, ITERATOR$4, function () {
|
||
return this;
|
||
});
|
||
}
|
||
var iteratorsCore = {
|
||
IteratorPrototype: IteratorPrototype$2,
|
||
BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1
|
||
};
|
||
|
||
var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
|
||
var create$3 = objectCreate;
|
||
var createPropertyDescriptor$1 = createPropertyDescriptor$5;
|
||
var setToStringTag$3 = setToStringTag$5;
|
||
var Iterators$2 = iterators;
|
||
var returnThis$1 = function () {
|
||
return this;
|
||
};
|
||
var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
|
||
var TO_STRING_TAG = NAME + ' Iterator';
|
||
IteratorConstructor.prototype = create$3(IteratorPrototype$1, {
|
||
next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next)
|
||
});
|
||
setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false);
|
||
Iterators$2[TO_STRING_TAG] = returnThis$1;
|
||
return IteratorConstructor;
|
||
};
|
||
|
||
var $$5 = _export;
|
||
var call$4 = functionCall;
|
||
var FunctionName = functionName;
|
||
var isCallable$5 = isCallable$r;
|
||
var createIteratorConstructor$1 = iteratorCreateConstructor;
|
||
var getPrototypeOf = objectGetPrototypeOf;
|
||
var setPrototypeOf$1 = objectSetPrototypeOf;
|
||
var setToStringTag$2 = setToStringTag$5;
|
||
var createNonEnumerableProperty$2 = createNonEnumerableProperty$6;
|
||
var defineBuiltIn$4 = defineBuiltIn$a;
|
||
var wellKnownSymbol$5 = wellKnownSymbol$l;
|
||
var Iterators$1 = iterators;
|
||
var IteratorsCore = iteratorsCore;
|
||
var PROPER_FUNCTION_NAME = FunctionName.PROPER;
|
||
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
|
||
var IteratorPrototype = IteratorsCore.IteratorPrototype;
|
||
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
|
||
var ITERATOR$3 = wellKnownSymbol$5('iterator');
|
||
var KEYS = 'keys';
|
||
var VALUES = 'values';
|
||
var ENTRIES = 'entries';
|
||
var returnThis = function () {
|
||
return this;
|
||
};
|
||
var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
|
||
createIteratorConstructor$1(IteratorConstructor, NAME, next);
|
||
var getIterationMethod = function (KIND) {
|
||
if (KIND === DEFAULT && defaultIterator) return defaultIterator;
|
||
if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
|
||
switch (KIND) {
|
||
case KEYS:
|
||
return function keys() {
|
||
return new IteratorConstructor(this, KIND);
|
||
};
|
||
case VALUES:
|
||
return function values() {
|
||
return new IteratorConstructor(this, KIND);
|
||
};
|
||
case ENTRIES:
|
||
return function entries() {
|
||
return new IteratorConstructor(this, KIND);
|
||
};
|
||
}
|
||
return function () {
|
||
return new IteratorConstructor(this);
|
||
};
|
||
};
|
||
var TO_STRING_TAG = NAME + ' Iterator';
|
||
var INCORRECT_VALUES_NAME = false;
|
||
var IterablePrototype = Iterable.prototype;
|
||
var nativeIterator = IterablePrototype[ITERATOR$3] || IterablePrototype['@@iterator'] || DEFAULT && IterablePrototype[DEFAULT];
|
||
var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
|
||
var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
|
||
var CurrentIteratorPrototype, methods, KEY;
|
||
|
||
// fix native
|
||
if (anyNativeIterator) {
|
||
CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
|
||
if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
|
||
if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
|
||
if (setPrototypeOf$1) {
|
||
setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype);
|
||
} else if (!isCallable$5(CurrentIteratorPrototype[ITERATOR$3])) {
|
||
defineBuiltIn$4(CurrentIteratorPrototype, ITERATOR$3, returnThis);
|
||
}
|
||
}
|
||
// Set @@toStringTag to native iterators
|
||
setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true);
|
||
}
|
||
}
|
||
|
||
// fix Array.prototype.{ values, @@iterator }.name in V8 / FF
|
||
if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
|
||
if (CONFIGURABLE_FUNCTION_NAME) {
|
||
createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES);
|
||
} else {
|
||
INCORRECT_VALUES_NAME = true;
|
||
defaultIterator = function values() {
|
||
return call$4(nativeIterator, this);
|
||
};
|
||
}
|
||
}
|
||
|
||
// export additional methods
|
||
if (DEFAULT) {
|
||
methods = {
|
||
values: getIterationMethod(VALUES),
|
||
keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
|
||
entries: getIterationMethod(ENTRIES)
|
||
};
|
||
if (FORCED) for (KEY in methods) {
|
||
if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
|
||
defineBuiltIn$4(IterablePrototype, KEY, methods[KEY]);
|
||
}
|
||
} else $$5({
|
||
target: NAME,
|
||
proto: true,
|
||
forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME
|
||
}, methods);
|
||
}
|
||
|
||
// define iterator
|
||
if (IterablePrototype[ITERATOR$3] !== defaultIterator) {
|
||
defineBuiltIn$4(IterablePrototype, ITERATOR$3, defaultIterator, {
|
||
name: DEFAULT
|
||
});
|
||
}
|
||
Iterators$1[NAME] = defaultIterator;
|
||
return methods;
|
||
};
|
||
|
||
// `CreateIterResultObject` abstract operation
|
||
// https://tc39.es/ecma262/#sec-createiterresultobject
|
||
var createIterResultObject$3 = function (value, done) {
|
||
return {
|
||
value: value,
|
||
done: done
|
||
};
|
||
};
|
||
|
||
var toIndexedObject$1 = toIndexedObject$6;
|
||
var addToUnscopables = addToUnscopables$1;
|
||
var Iterators = iterators;
|
||
var InternalStateModule$3 = internalState;
|
||
var defineProperty$1 = objectDefineProperty.f;
|
||
var defineIterator$2 = iteratorDefine;
|
||
var createIterResultObject$2 = createIterResultObject$3;
|
||
var DESCRIPTORS$3 = descriptors;
|
||
var ARRAY_ITERATOR = 'Array Iterator';
|
||
var setInternalState$3 = InternalStateModule$3.set;
|
||
var getInternalState$2 = InternalStateModule$3.getterFor(ARRAY_ITERATOR);
|
||
|
||
// `Array.prototype.entries` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.entries
|
||
// `Array.prototype.keys` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.keys
|
||
// `Array.prototype.values` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.values
|
||
// `Array.prototype[@@iterator]` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
|
||
// `CreateArrayIterator` internal method
|
||
// https://tc39.es/ecma262/#sec-createarrayiterator
|
||
var es_array_iterator = defineIterator$2(Array, 'Array', function (iterated, kind) {
|
||
setInternalState$3(this, {
|
||
type: ARRAY_ITERATOR,
|
||
target: toIndexedObject$1(iterated),
|
||
// target
|
||
index: 0,
|
||
// next index
|
||
kind: kind // kind
|
||
});
|
||
// `%ArrayIteratorPrototype%.next` method
|
||
// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
|
||
}, function () {
|
||
var state = getInternalState$2(this);
|
||
var target = state.target;
|
||
var kind = state.kind;
|
||
var index = state.index++;
|
||
if (!target || index >= target.length) {
|
||
state.target = undefined;
|
||
return createIterResultObject$2(undefined, true);
|
||
}
|
||
if (kind == 'keys') return createIterResultObject$2(index, false);
|
||
if (kind == 'values') return createIterResultObject$2(target[index], false);
|
||
return createIterResultObject$2([index, target[index]], false);
|
||
}, 'values');
|
||
|
||
// argumentsList[@@iterator] is %ArrayProto_values%
|
||
// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
|
||
// https://tc39.es/ecma262/#sec-createmappedargumentsobject
|
||
var values = Iterators.Arguments = Iterators.Array;
|
||
|
||
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
||
addToUnscopables('keys');
|
||
addToUnscopables('values');
|
||
addToUnscopables('entries');
|
||
|
||
// V8 ~ Chrome 45- bug
|
||
if (DESCRIPTORS$3 && values.name !== 'values') try {
|
||
defineProperty$1(values, 'name', {
|
||
value: 'values'
|
||
});
|
||
} catch (error) {/* empty */}
|
||
|
||
var internalMetadata = {exports: {}};
|
||
|
||
var objectGetOwnPropertyNamesExternal = {};
|
||
|
||
var toAbsoluteIndex = toAbsoluteIndex$2;
|
||
var lengthOfArrayLike = lengthOfArrayLike$5;
|
||
var createProperty = createProperty$2;
|
||
var $Array = Array;
|
||
var max$1 = Math.max;
|
||
var arraySliceSimple = function (O, start, end) {
|
||
var length = lengthOfArrayLike(O);
|
||
var k = toAbsoluteIndex(start, length);
|
||
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
|
||
var result = $Array(max$1(fin - k, 0));
|
||
for (var n = 0; k < fin; k++, n++) createProperty(result, n, O[k]);
|
||
result.length = n;
|
||
return result;
|
||
};
|
||
|
||
/* eslint-disable es/no-object-getownpropertynames -- safe */
|
||
var classof$3 = classofRaw$2;
|
||
var toIndexedObject = toIndexedObject$6;
|
||
var $getOwnPropertyNames = objectGetOwnPropertyNames.f;
|
||
var arraySlice$1 = arraySliceSimple;
|
||
var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
|
||
var getWindowNames = function (it) {
|
||
try {
|
||
return $getOwnPropertyNames(it);
|
||
} catch (error) {
|
||
return arraySlice$1(windowNames);
|
||
}
|
||
};
|
||
|
||
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
|
||
objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) {
|
||
return windowNames && classof$3(it) == 'Window' ? getWindowNames(it) : $getOwnPropertyNames(toIndexedObject(it));
|
||
};
|
||
|
||
// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it
|
||
var fails$9 = fails$r;
|
||
var arrayBufferNonExtensible = fails$9(function () {
|
||
if (typeof ArrayBuffer == 'function') {
|
||
var buffer = new ArrayBuffer(8);
|
||
// eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe
|
||
if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', {
|
||
value: 8
|
||
});
|
||
}
|
||
});
|
||
|
||
var fails$8 = fails$r;
|
||
var isObject$4 = isObject$f;
|
||
var classof$2 = classofRaw$2;
|
||
var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible;
|
||
|
||
// eslint-disable-next-line es/no-object-isextensible -- safe
|
||
var $isExtensible = Object.isExtensible;
|
||
var FAILS_ON_PRIMITIVES = fails$8(function () {
|
||
$isExtensible(1);
|
||
});
|
||
|
||
// `Object.isExtensible` method
|
||
// https://tc39.es/ecma262/#sec-object.isextensible
|
||
var objectIsExtensible = FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE ? function isExtensible(it) {
|
||
if (!isObject$4(it)) return false;
|
||
if (ARRAY_BUFFER_NON_EXTENSIBLE && classof$2(it) == 'ArrayBuffer') return false;
|
||
return $isExtensible ? $isExtensible(it) : true;
|
||
} : $isExtensible;
|
||
|
||
var fails$7 = fails$r;
|
||
var freezing = !fails$7(function () {
|
||
// eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing
|
||
return Object.isExtensible(Object.preventExtensions({}));
|
||
});
|
||
|
||
var $$4 = _export;
|
||
var uncurryThis$7 = functionUncurryThis;
|
||
var hiddenKeys = hiddenKeys$5;
|
||
var isObject$3 = isObject$f;
|
||
var hasOwn$1 = hasOwnProperty_1;
|
||
var defineProperty = objectDefineProperty.f;
|
||
var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
|
||
var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal;
|
||
var isExtensible = objectIsExtensible;
|
||
var uid = uid$3;
|
||
var FREEZING = freezing;
|
||
var REQUIRED = false;
|
||
var METADATA = uid('meta');
|
||
var id = 0;
|
||
var setMetadata = function (it) {
|
||
defineProperty(it, METADATA, {
|
||
value: {
|
||
objectID: 'O' + id++,
|
||
// object ID
|
||
weakData: {} // weak collections IDs
|
||
}
|
||
});
|
||
};
|
||
|
||
var fastKey$1 = function (it, create) {
|
||
// return a primitive with prefix
|
||
if (!isObject$3(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
|
||
if (!hasOwn$1(it, METADATA)) {
|
||
// can't set metadata to uncaught frozen object
|
||
if (!isExtensible(it)) return 'F';
|
||
// not necessary to add metadata
|
||
if (!create) return 'E';
|
||
// add missing metadata
|
||
setMetadata(it);
|
||
// return object ID
|
||
}
|
||
return it[METADATA].objectID;
|
||
};
|
||
var getWeakData = function (it, create) {
|
||
if (!hasOwn$1(it, METADATA)) {
|
||
// can't set metadata to uncaught frozen object
|
||
if (!isExtensible(it)) return true;
|
||
// not necessary to add metadata
|
||
if (!create) return false;
|
||
// add missing metadata
|
||
setMetadata(it);
|
||
// return the store of weak collections IDs
|
||
}
|
||
return it[METADATA].weakData;
|
||
};
|
||
|
||
// add metadata on freeze-family methods calling
|
||
var onFreeze = function (it) {
|
||
if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it);
|
||
return it;
|
||
};
|
||
var enable = function () {
|
||
meta.enable = function () {/* empty */};
|
||
REQUIRED = true;
|
||
var getOwnPropertyNames = getOwnPropertyNamesModule.f;
|
||
var splice = uncurryThis$7([].splice);
|
||
var test = {};
|
||
test[METADATA] = 1;
|
||
|
||
// prevent exposing of metadata key
|
||
if (getOwnPropertyNames(test).length) {
|
||
getOwnPropertyNamesModule.f = function (it) {
|
||
var result = getOwnPropertyNames(it);
|
||
for (var i = 0, length = result.length; i < length; i++) {
|
||
if (result[i] === METADATA) {
|
||
splice(result, i, 1);
|
||
break;
|
||
}
|
||
}
|
||
return result;
|
||
};
|
||
$$4({
|
||
target: 'Object',
|
||
stat: true,
|
||
forced: true
|
||
}, {
|
||
getOwnPropertyNames: getOwnPropertyNamesExternalModule.f
|
||
});
|
||
}
|
||
};
|
||
var meta = internalMetadata.exports = {
|
||
enable: enable,
|
||
fastKey: fastKey$1,
|
||
getWeakData: getWeakData,
|
||
onFreeze: onFreeze
|
||
};
|
||
hiddenKeys[METADATA] = true;
|
||
|
||
var isCallable$4 = isCallable$r;
|
||
var isObject$2 = isObject$f;
|
||
var setPrototypeOf = objectSetPrototypeOf;
|
||
|
||
// makes subclassing work correct for wrapped built-ins
|
||
var inheritIfRequired$1 = function ($this, dummy, Wrapper) {
|
||
var NewTarget, NewTargetPrototype;
|
||
if (
|
||
// it can work only with native `setPrototypeOf`
|
||
setPrototypeOf &&
|
||
// we haven't completely correct pre-ES6 way for getting `new.target`, so use this
|
||
isCallable$4(NewTarget = dummy.constructor) && NewTarget !== Wrapper && isObject$2(NewTargetPrototype = NewTarget.prototype) && NewTargetPrototype !== Wrapper.prototype) setPrototypeOf($this, NewTargetPrototype);
|
||
return $this;
|
||
};
|
||
|
||
var $$3 = _export;
|
||
var global$6 = global$n;
|
||
var uncurryThis$6 = functionUncurryThis;
|
||
var isForced = isForced_1;
|
||
var defineBuiltIn$3 = defineBuiltIn$a;
|
||
var InternalMetadataModule = internalMetadata.exports;
|
||
var iterate$1 = iterate$4;
|
||
var anInstance$2 = anInstance$4;
|
||
var isCallable$3 = isCallable$r;
|
||
var isNullOrUndefined$2 = isNullOrUndefined$7;
|
||
var isObject$1 = isObject$f;
|
||
var fails$6 = fails$r;
|
||
var checkCorrectnessOfIteration = checkCorrectnessOfIteration$2;
|
||
var setToStringTag$1 = setToStringTag$5;
|
||
var inheritIfRequired = inheritIfRequired$1;
|
||
var collection$1 = function (CONSTRUCTOR_NAME, wrapper, common) {
|
||
var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;
|
||
var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;
|
||
var ADDER = IS_MAP ? 'set' : 'add';
|
||
var NativeConstructor = global$6[CONSTRUCTOR_NAME];
|
||
var NativePrototype = NativeConstructor && NativeConstructor.prototype;
|
||
var Constructor = NativeConstructor;
|
||
var exported = {};
|
||
var fixMethod = function (KEY) {
|
||
var uncurriedNativeMethod = uncurryThis$6(NativePrototype[KEY]);
|
||
defineBuiltIn$3(NativePrototype, KEY, KEY == 'add' ? function add(value) {
|
||
uncurriedNativeMethod(this, value === 0 ? 0 : value);
|
||
return this;
|
||
} : KEY == 'delete' ? function (key) {
|
||
return IS_WEAK && !isObject$1(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);
|
||
} : KEY == 'get' ? function get(key) {
|
||
return IS_WEAK && !isObject$1(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);
|
||
} : KEY == 'has' ? function has(key) {
|
||
return IS_WEAK && !isObject$1(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);
|
||
} : function set(key, value) {
|
||
uncurriedNativeMethod(this, key === 0 ? 0 : key, value);
|
||
return this;
|
||
});
|
||
};
|
||
var REPLACE = isForced(CONSTRUCTOR_NAME, !isCallable$3(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails$6(function () {
|
||
new NativeConstructor().entries().next();
|
||
})));
|
||
if (REPLACE) {
|
||
// create collection constructor
|
||
Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);
|
||
InternalMetadataModule.enable();
|
||
} else if (isForced(CONSTRUCTOR_NAME, true)) {
|
||
var instance = new Constructor();
|
||
// early implementations not supports chaining
|
||
var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
|
||
// V8 ~ Chromium 40- weak-collections throws on primitives, but should return false
|
||
var THROWS_ON_PRIMITIVES = fails$6(function () {
|
||
instance.has(1);
|
||
});
|
||
// most early implementations doesn't supports iterables, most modern - not close it correctly
|
||
// eslint-disable-next-line no-new -- required for testing
|
||
var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) {
|
||
new NativeConstructor(iterable);
|
||
});
|
||
// for early implementations -0 and +0 not the same
|
||
var BUGGY_ZERO = !IS_WEAK && fails$6(function () {
|
||
// V8 ~ Chromium 42- fails only with 5+ elements
|
||
var $instance = new NativeConstructor();
|
||
var index = 5;
|
||
while (index--) $instance[ADDER](index, index);
|
||
return !$instance.has(-0);
|
||
});
|
||
if (!ACCEPT_ITERABLES) {
|
||
Constructor = wrapper(function (dummy, iterable) {
|
||
anInstance$2(dummy, NativePrototype);
|
||
var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);
|
||
if (!isNullOrUndefined$2(iterable)) iterate$1(iterable, that[ADDER], {
|
||
that: that,
|
||
AS_ENTRIES: IS_MAP
|
||
});
|
||
return that;
|
||
});
|
||
Constructor.prototype = NativePrototype;
|
||
NativePrototype.constructor = Constructor;
|
||
}
|
||
if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
|
||
fixMethod('delete');
|
||
fixMethod('has');
|
||
IS_MAP && fixMethod('get');
|
||
}
|
||
if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
|
||
|
||
// weak collections should not contains .clear method
|
||
if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;
|
||
}
|
||
exported[CONSTRUCTOR_NAME] = Constructor;
|
||
$$3({
|
||
global: true,
|
||
constructor: true,
|
||
forced: Constructor != NativeConstructor
|
||
}, exported);
|
||
setToStringTag$1(Constructor, CONSTRUCTOR_NAME);
|
||
if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);
|
||
return Constructor;
|
||
};
|
||
|
||
var defineBuiltIn$2 = defineBuiltIn$a;
|
||
var defineBuiltIns$2 = function (target, src, options) {
|
||
for (var key in src) defineBuiltIn$2(target, key, src[key], options);
|
||
return target;
|
||
};
|
||
|
||
var create$2 = objectCreate;
|
||
var defineBuiltInAccessor$1 = defineBuiltInAccessor$3;
|
||
var defineBuiltIns$1 = defineBuiltIns$2;
|
||
var bind$1 = functionBindContext;
|
||
var anInstance$1 = anInstance$4;
|
||
var isNullOrUndefined$1 = isNullOrUndefined$7;
|
||
var iterate = iterate$4;
|
||
var defineIterator$1 = iteratorDefine;
|
||
var createIterResultObject$1 = createIterResultObject$3;
|
||
var setSpecies = setSpecies$2;
|
||
var DESCRIPTORS$2 = descriptors;
|
||
var fastKey = internalMetadata.exports.fastKey;
|
||
var InternalStateModule$2 = internalState;
|
||
var setInternalState$2 = InternalStateModule$2.set;
|
||
var internalStateGetterFor = InternalStateModule$2.getterFor;
|
||
var collectionStrong$1 = {
|
||
getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
|
||
var Constructor = wrapper(function (that, iterable) {
|
||
anInstance$1(that, Prototype);
|
||
setInternalState$2(that, {
|
||
type: CONSTRUCTOR_NAME,
|
||
index: create$2(null),
|
||
first: undefined,
|
||
last: undefined,
|
||
size: 0
|
||
});
|
||
if (!DESCRIPTORS$2) that.size = 0;
|
||
if (!isNullOrUndefined$1(iterable)) iterate(iterable, that[ADDER], {
|
||
that: that,
|
||
AS_ENTRIES: IS_MAP
|
||
});
|
||
});
|
||
var Prototype = Constructor.prototype;
|
||
var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
|
||
var define = function (that, key, value) {
|
||
var state = getInternalState(that);
|
||
var entry = getEntry(that, key);
|
||
var previous, index;
|
||
// change existing entry
|
||
if (entry) {
|
||
entry.value = value;
|
||
// create new entry
|
||
} else {
|
||
state.last = entry = {
|
||
index: index = fastKey(key, true),
|
||
key: key,
|
||
value: value,
|
||
previous: previous = state.last,
|
||
next: undefined,
|
||
removed: false
|
||
};
|
||
if (!state.first) state.first = entry;
|
||
if (previous) previous.next = entry;
|
||
if (DESCRIPTORS$2) state.size++;else that.size++;
|
||
// add to index
|
||
if (index !== 'F') state.index[index] = entry;
|
||
}
|
||
return that;
|
||
};
|
||
var getEntry = function (that, key) {
|
||
var state = getInternalState(that);
|
||
// fast case
|
||
var index = fastKey(key);
|
||
var entry;
|
||
if (index !== 'F') return state.index[index];
|
||
// frozen object case
|
||
for (entry = state.first; entry; entry = entry.next) {
|
||
if (entry.key == key) return entry;
|
||
}
|
||
};
|
||
defineBuiltIns$1(Prototype, {
|
||
// `{ Map, Set }.prototype.clear()` methods
|
||
// https://tc39.es/ecma262/#sec-map.prototype.clear
|
||
// https://tc39.es/ecma262/#sec-set.prototype.clear
|
||
clear: function clear() {
|
||
var that = this;
|
||
var state = getInternalState(that);
|
||
var data = state.index;
|
||
var entry = state.first;
|
||
while (entry) {
|
||
entry.removed = true;
|
||
if (entry.previous) entry.previous = entry.previous.next = undefined;
|
||
delete data[entry.index];
|
||
entry = entry.next;
|
||
}
|
||
state.first = state.last = undefined;
|
||
if (DESCRIPTORS$2) state.size = 0;else that.size = 0;
|
||
},
|
||
// `{ Map, Set }.prototype.delete(key)` methods
|
||
// https://tc39.es/ecma262/#sec-map.prototype.delete
|
||
// https://tc39.es/ecma262/#sec-set.prototype.delete
|
||
'delete': function (key) {
|
||
var that = this;
|
||
var state = getInternalState(that);
|
||
var entry = getEntry(that, key);
|
||
if (entry) {
|
||
var next = entry.next;
|
||
var prev = entry.previous;
|
||
delete state.index[entry.index];
|
||
entry.removed = true;
|
||
if (prev) prev.next = next;
|
||
if (next) next.previous = prev;
|
||
if (state.first == entry) state.first = next;
|
||
if (state.last == entry) state.last = prev;
|
||
if (DESCRIPTORS$2) state.size--;else that.size--;
|
||
}
|
||
return !!entry;
|
||
},
|
||
// `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods
|
||
// https://tc39.es/ecma262/#sec-map.prototype.foreach
|
||
// https://tc39.es/ecma262/#sec-set.prototype.foreach
|
||
forEach: function forEach(callbackfn /* , that = undefined */) {
|
||
var state = getInternalState(this);
|
||
var boundFunction = bind$1(callbackfn, arguments.length > 1 ? arguments[1] : undefined);
|
||
var entry;
|
||
while (entry = entry ? entry.next : state.first) {
|
||
boundFunction(entry.value, entry.key, this);
|
||
// revert to the last existing entry
|
||
while (entry && entry.removed) entry = entry.previous;
|
||
}
|
||
},
|
||
// `{ Map, Set}.prototype.has(key)` methods
|
||
// https://tc39.es/ecma262/#sec-map.prototype.has
|
||
// https://tc39.es/ecma262/#sec-set.prototype.has
|
||
has: function has(key) {
|
||
return !!getEntry(this, key);
|
||
}
|
||
});
|
||
defineBuiltIns$1(Prototype, IS_MAP ? {
|
||
// `Map.prototype.get(key)` method
|
||
// https://tc39.es/ecma262/#sec-map.prototype.get
|
||
get: function get(key) {
|
||
var entry = getEntry(this, key);
|
||
return entry && entry.value;
|
||
},
|
||
// `Map.prototype.set(key, value)` method
|
||
// https://tc39.es/ecma262/#sec-map.prototype.set
|
||
set: function set(key, value) {
|
||
return define(this, key === 0 ? 0 : key, value);
|
||
}
|
||
} : {
|
||
// `Set.prototype.add(value)` method
|
||
// https://tc39.es/ecma262/#sec-set.prototype.add
|
||
add: function add(value) {
|
||
return define(this, value = value === 0 ? 0 : value, value);
|
||
}
|
||
});
|
||
if (DESCRIPTORS$2) defineBuiltInAccessor$1(Prototype, 'size', {
|
||
configurable: true,
|
||
get: function () {
|
||
return getInternalState(this).size;
|
||
}
|
||
});
|
||
return Constructor;
|
||
},
|
||
setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {
|
||
var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';
|
||
var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);
|
||
var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);
|
||
// `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods
|
||
// https://tc39.es/ecma262/#sec-map.prototype.entries
|
||
// https://tc39.es/ecma262/#sec-map.prototype.keys
|
||
// https://tc39.es/ecma262/#sec-map.prototype.values
|
||
// https://tc39.es/ecma262/#sec-map.prototype-@@iterator
|
||
// https://tc39.es/ecma262/#sec-set.prototype.entries
|
||
// https://tc39.es/ecma262/#sec-set.prototype.keys
|
||
// https://tc39.es/ecma262/#sec-set.prototype.values
|
||
// https://tc39.es/ecma262/#sec-set.prototype-@@iterator
|
||
defineIterator$1(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {
|
||
setInternalState$2(this, {
|
||
type: ITERATOR_NAME,
|
||
target: iterated,
|
||
state: getInternalCollectionState(iterated),
|
||
kind: kind,
|
||
last: undefined
|
||
});
|
||
}, function () {
|
||
var state = getInternalIteratorState(this);
|
||
var kind = state.kind;
|
||
var entry = state.last;
|
||
// revert to the last existing entry
|
||
while (entry && entry.removed) entry = entry.previous;
|
||
// get next entry
|
||
if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {
|
||
// or finish the iteration
|
||
state.target = undefined;
|
||
return createIterResultObject$1(undefined, true);
|
||
}
|
||
// return step by kind
|
||
if (kind == 'keys') return createIterResultObject$1(entry.key, false);
|
||
if (kind == 'values') return createIterResultObject$1(entry.value, false);
|
||
return createIterResultObject$1([entry.key, entry.value], false);
|
||
}, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
|
||
|
||
// `{ Map, Set }.prototype[@@species]` accessors
|
||
// https://tc39.es/ecma262/#sec-get-map-@@species
|
||
// https://tc39.es/ecma262/#sec-get-set-@@species
|
||
setSpecies(CONSTRUCTOR_NAME);
|
||
}
|
||
};
|
||
|
||
var collection = collection$1;
|
||
var collectionStrong = collectionStrong$1;
|
||
|
||
// `Set` constructor
|
||
// https://tc39.es/ecma262/#sec-set-objects
|
||
collection('Set', function (init) {
|
||
return function Set() {
|
||
return init(this, arguments.length ? arguments[0] : undefined);
|
||
};
|
||
}, collectionStrong);
|
||
|
||
var uncurryThis$5 = functionUncurryThis;
|
||
var toIntegerOrInfinity$1 = toIntegerOrInfinity$4;
|
||
var toString$3 = toString$6;
|
||
var requireObjectCoercible$1 = requireObjectCoercible$4;
|
||
var charAt$5 = uncurryThis$5(''.charAt);
|
||
var charCodeAt = uncurryThis$5(''.charCodeAt);
|
||
var stringSlice$4 = uncurryThis$5(''.slice);
|
||
var createMethod = function (CONVERT_TO_STRING) {
|
||
return function ($this, pos) {
|
||
var S = toString$3(requireObjectCoercible$1($this));
|
||
var position = toIntegerOrInfinity$1(pos);
|
||
var size = S.length;
|
||
var first, second;
|
||
if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
|
||
first = charCodeAt(S, position);
|
||
return first < 0xD800 || first > 0xDBFF || position + 1 === size || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF ? CONVERT_TO_STRING ? charAt$5(S, position) : first : CONVERT_TO_STRING ? stringSlice$4(S, position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
|
||
};
|
||
};
|
||
var stringMultibyte = {
|
||
// `String.prototype.codePointAt` method
|
||
// https://tc39.es/ecma262/#sec-string.prototype.codepointat
|
||
codeAt: createMethod(false),
|
||
// `String.prototype.at` method
|
||
// https://github.com/mathiasbynens/String.prototype.at
|
||
charAt: createMethod(true)
|
||
};
|
||
|
||
var charAt$4 = stringMultibyte.charAt;
|
||
var toString$2 = toString$6;
|
||
var InternalStateModule$1 = internalState;
|
||
var defineIterator = iteratorDefine;
|
||
var createIterResultObject = createIterResultObject$3;
|
||
var STRING_ITERATOR = 'String Iterator';
|
||
var setInternalState$1 = InternalStateModule$1.set;
|
||
var getInternalState$1 = InternalStateModule$1.getterFor(STRING_ITERATOR);
|
||
|
||
// `String.prototype[@@iterator]` method
|
||
// https://tc39.es/ecma262/#sec-string.prototype-@@iterator
|
||
defineIterator(String, 'String', function (iterated) {
|
||
setInternalState$1(this, {
|
||
type: STRING_ITERATOR,
|
||
string: toString$2(iterated),
|
||
index: 0
|
||
});
|
||
// `%StringIteratorPrototype%.next` method
|
||
// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next
|
||
}, function next() {
|
||
var state = getInternalState$1(this);
|
||
var string = state.string;
|
||
var index = state.index;
|
||
var point;
|
||
if (index >= string.length) return createIterResultObject(undefined, true);
|
||
point = charAt$4(string, index);
|
||
state.index += point.length;
|
||
return createIterResultObject(point, false);
|
||
});
|
||
|
||
var global$5 = global$n;
|
||
var DOMIterables = domIterables;
|
||
var DOMTokenListPrototype = domTokenListPrototype;
|
||
var ArrayIteratorMethods = es_array_iterator;
|
||
var createNonEnumerableProperty$1 = createNonEnumerableProperty$6;
|
||
var wellKnownSymbol$4 = wellKnownSymbol$l;
|
||
var ITERATOR$2 = wellKnownSymbol$4('iterator');
|
||
var TO_STRING_TAG = wellKnownSymbol$4('toStringTag');
|
||
var ArrayValues = ArrayIteratorMethods.values;
|
||
var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
|
||
if (CollectionPrototype) {
|
||
// some Chrome versions have non-configurable methods on DOMTokenList
|
||
if (CollectionPrototype[ITERATOR$2] !== ArrayValues) try {
|
||
createNonEnumerableProperty$1(CollectionPrototype, ITERATOR$2, ArrayValues);
|
||
} catch (error) {
|
||
CollectionPrototype[ITERATOR$2] = ArrayValues;
|
||
}
|
||
if (!CollectionPrototype[TO_STRING_TAG]) {
|
||
createNonEnumerableProperty$1(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
|
||
}
|
||
if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
|
||
// some Chrome versions have non-configurable methods on DOMTokenList
|
||
if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
|
||
createNonEnumerableProperty$1(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
|
||
} catch (error) {
|
||
CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
|
||
}
|
||
}
|
||
}
|
||
};
|
||
for (var COLLECTION_NAME in DOMIterables) {
|
||
handlePrototype(global$5[COLLECTION_NAME] && global$5[COLLECTION_NAME].prototype, COLLECTION_NAME);
|
||
}
|
||
handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
|
||
|
||
var fails$5 = fails$r;
|
||
var wellKnownSymbol$3 = wellKnownSymbol$l;
|
||
var DESCRIPTORS$1 = descriptors;
|
||
var IS_PURE = isPure;
|
||
var ITERATOR$1 = wellKnownSymbol$3('iterator');
|
||
var urlConstructorDetection = !fails$5(function () {
|
||
// eslint-disable-next-line unicorn/relative-url-style -- required for testing
|
||
var url = new URL('b?a=1&b=2&c=3', 'http://a');
|
||
var searchParams = url.searchParams;
|
||
var result = '';
|
||
url.pathname = 'c%20d';
|
||
searchParams.forEach(function (value, key) {
|
||
searchParams['delete']('b');
|
||
result += key + value;
|
||
});
|
||
return IS_PURE && !url.toJSON || !searchParams.size && (IS_PURE || !DESCRIPTORS$1) || !searchParams.sort || url.href !== 'http://a/c%20d?a=1&c=3' || searchParams.get('c') !== '3' || String(new URLSearchParams('?a=1')) !== 'a=1' || !searchParams[ITERATOR$1]
|
||
// throws in Edge
|
||
|| new URL('https://a@b').username !== 'a' || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
|
||
// not punycoded in Edge
|
||
|| new URL('http://тест').host !== 'xn--e1aybc'
|
||
// not escaped in Chrome 62-
|
||
|| new URL('http://a#б').hash !== '#%D0%B1'
|
||
// fails in Chrome 66-
|
||
|| result !== 'a1c3'
|
||
// throws in Safari
|
||
|| new URL('http://x', undefined).host !== 'x';
|
||
});
|
||
|
||
var arraySlice = arraySliceSimple;
|
||
var floor$1 = Math.floor;
|
||
var mergeSort = function (array, comparefn) {
|
||
var length = array.length;
|
||
var middle = floor$1(length / 2);
|
||
return length < 8 ? insertionSort(array, comparefn) : merge(array, mergeSort(arraySlice(array, 0, middle), comparefn), mergeSort(arraySlice(array, middle), comparefn), comparefn);
|
||
};
|
||
var insertionSort = function (array, comparefn) {
|
||
var length = array.length;
|
||
var i = 1;
|
||
var element, j;
|
||
while (i < length) {
|
||
j = i;
|
||
element = array[i];
|
||
while (j && comparefn(array[j - 1], element) > 0) {
|
||
array[j] = array[--j];
|
||
}
|
||
if (j !== i++) array[j] = element;
|
||
}
|
||
return array;
|
||
};
|
||
var merge = function (array, left, right, comparefn) {
|
||
var llength = left.length;
|
||
var rlength = right.length;
|
||
var lindex = 0;
|
||
var rindex = 0;
|
||
while (lindex < llength || rindex < rlength) {
|
||
array[lindex + rindex] = lindex < llength && rindex < rlength ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] : lindex < llength ? left[lindex++] : right[rindex++];
|
||
}
|
||
return array;
|
||
};
|
||
var arraySort$1 = mergeSort;
|
||
|
||
// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
|
||
|
||
var $$2 = _export;
|
||
var global$4 = global$n;
|
||
var call$3 = functionCall;
|
||
var uncurryThis$4 = functionUncurryThis;
|
||
var DESCRIPTORS = descriptors;
|
||
var USE_NATIVE_URL = urlConstructorDetection;
|
||
var defineBuiltIn$1 = defineBuiltIn$a;
|
||
var defineBuiltInAccessor = defineBuiltInAccessor$3;
|
||
var defineBuiltIns = defineBuiltIns$2;
|
||
var setToStringTag = setToStringTag$5;
|
||
var createIteratorConstructor = iteratorCreateConstructor;
|
||
var InternalStateModule = internalState;
|
||
var anInstance = anInstance$4;
|
||
var isCallable$2 = isCallable$r;
|
||
var hasOwn = hasOwnProperty_1;
|
||
var bind = functionBindContext;
|
||
var classof$1 = classof$a;
|
||
var anObject$3 = anObject$e;
|
||
var isObject = isObject$f;
|
||
var $toString = toString$6;
|
||
var create$1 = objectCreate;
|
||
var createPropertyDescriptor = createPropertyDescriptor$5;
|
||
var getIterator = getIterator$2;
|
||
var getIteratorMethod = getIteratorMethod$3;
|
||
var validateArgumentsLength = validateArgumentsLength$2;
|
||
var wellKnownSymbol$2 = wellKnownSymbol$l;
|
||
var arraySort = arraySort$1;
|
||
var ITERATOR = wellKnownSymbol$2('iterator');
|
||
var URL_SEARCH_PARAMS = 'URLSearchParams';
|
||
var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
|
||
var setInternalState = InternalStateModule.set;
|
||
var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
|
||
var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
|
||
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
||
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
||
|
||
// Avoid NodeJS experimental warning
|
||
var safeGetBuiltIn = function (name) {
|
||
if (!DESCRIPTORS) return global$4[name];
|
||
var descriptor = getOwnPropertyDescriptor(global$4, name);
|
||
return descriptor && descriptor.value;
|
||
};
|
||
var nativeFetch = safeGetBuiltIn('fetch');
|
||
var NativeRequest = safeGetBuiltIn('Request');
|
||
var Headers = safeGetBuiltIn('Headers');
|
||
var RequestPrototype = NativeRequest && NativeRequest.prototype;
|
||
var HeadersPrototype = Headers && Headers.prototype;
|
||
var RegExp$1 = global$4.RegExp;
|
||
var TypeError$1 = global$4.TypeError;
|
||
var decodeURIComponent = global$4.decodeURIComponent;
|
||
var encodeURIComponent = global$4.encodeURIComponent;
|
||
var charAt$3 = uncurryThis$4(''.charAt);
|
||
var join = uncurryThis$4([].join);
|
||
var push$1 = uncurryThis$4([].push);
|
||
var replace$2 = uncurryThis$4(''.replace);
|
||
var shift = uncurryThis$4([].shift);
|
||
var splice = uncurryThis$4([].splice);
|
||
var split = uncurryThis$4(''.split);
|
||
var stringSlice$3 = uncurryThis$4(''.slice);
|
||
var plus = /\+/g;
|
||
var sequences = Array(4);
|
||
var percentSequence = function (bytes) {
|
||
return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp$1('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
|
||
};
|
||
var percentDecode = function (sequence) {
|
||
try {
|
||
return decodeURIComponent(sequence);
|
||
} catch (error) {
|
||
return sequence;
|
||
}
|
||
};
|
||
var deserialize = function (it) {
|
||
var result = replace$2(it, plus, ' ');
|
||
var bytes = 4;
|
||
try {
|
||
return decodeURIComponent(result);
|
||
} catch (error) {
|
||
while (bytes) {
|
||
result = replace$2(result, percentSequence(bytes--), percentDecode);
|
||
}
|
||
return result;
|
||
}
|
||
};
|
||
var find = /[!'()~]|%20/g;
|
||
var replacements = {
|
||
'!': '%21',
|
||
"'": '%27',
|
||
'(': '%28',
|
||
')': '%29',
|
||
'~': '%7E',
|
||
'%20': '+'
|
||
};
|
||
var replacer = function (match) {
|
||
return replacements[match];
|
||
};
|
||
var serialize = function (it) {
|
||
return replace$2(encodeURIComponent(it), find, replacer);
|
||
};
|
||
var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
|
||
setInternalState(this, {
|
||
type: URL_SEARCH_PARAMS_ITERATOR,
|
||
iterator: getIterator(getInternalParamsState(params).entries),
|
||
kind: kind
|
||
});
|
||
}, 'Iterator', function next() {
|
||
var state = getInternalIteratorState(this);
|
||
var kind = state.kind;
|
||
var step = state.iterator.next();
|
||
var entry = step.value;
|
||
if (!step.done) {
|
||
step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];
|
||
}
|
||
return step;
|
||
}, true);
|
||
var URLSearchParamsState = function (init) {
|
||
this.entries = [];
|
||
this.url = null;
|
||
if (init !== undefined) {
|
||
if (isObject(init)) this.parseObject(init);else this.parseQuery(typeof init == 'string' ? charAt$3(init, 0) === '?' ? stringSlice$3(init, 1) : init : $toString(init));
|
||
}
|
||
};
|
||
URLSearchParamsState.prototype = {
|
||
type: URL_SEARCH_PARAMS,
|
||
bindURL: function (url) {
|
||
this.url = url;
|
||
this.update();
|
||
},
|
||
parseObject: function (object) {
|
||
var iteratorMethod = getIteratorMethod(object);
|
||
var iterator, next, step, entryIterator, entryNext, first, second;
|
||
if (iteratorMethod) {
|
||
iterator = getIterator(object, iteratorMethod);
|
||
next = iterator.next;
|
||
while (!(step = call$3(next, iterator)).done) {
|
||
entryIterator = getIterator(anObject$3(step.value));
|
||
entryNext = entryIterator.next;
|
||
if ((first = call$3(entryNext, entryIterator)).done || (second = call$3(entryNext, entryIterator)).done || !call$3(entryNext, entryIterator).done) throw TypeError$1('Expected sequence with length 2');
|
||
push$1(this.entries, {
|
||
key: $toString(first.value),
|
||
value: $toString(second.value)
|
||
});
|
||
}
|
||
} else for (var key in object) if (hasOwn(object, key)) {
|
||
push$1(this.entries, {
|
||
key: key,
|
||
value: $toString(object[key])
|
||
});
|
||
}
|
||
},
|
||
parseQuery: function (query) {
|
||
if (query) {
|
||
var attributes = split(query, '&');
|
||
var index = 0;
|
||
var attribute, entry;
|
||
while (index < attributes.length) {
|
||
attribute = attributes[index++];
|
||
if (attribute.length) {
|
||
entry = split(attribute, '=');
|
||
push$1(this.entries, {
|
||
key: deserialize(shift(entry)),
|
||
value: deserialize(join(entry, '='))
|
||
});
|
||
}
|
||
}
|
||
}
|
||
},
|
||
serialize: function () {
|
||
var entries = this.entries;
|
||
var result = [];
|
||
var index = 0;
|
||
var entry;
|
||
while (index < entries.length) {
|
||
entry = entries[index++];
|
||
push$1(result, serialize(entry.key) + '=' + serialize(entry.value));
|
||
}
|
||
return join(result, '&');
|
||
},
|
||
update: function () {
|
||
this.entries.length = 0;
|
||
this.parseQuery(this.url.query);
|
||
},
|
||
updateURL: function () {
|
||
if (this.url) this.url.update();
|
||
}
|
||
};
|
||
|
||
// `URLSearchParams` constructor
|
||
// https://url.spec.whatwg.org/#interface-urlsearchparams
|
||
var URLSearchParamsConstructor = function URLSearchParams( /* init */
|
||
) {
|
||
anInstance(this, URLSearchParamsPrototype);
|
||
var init = arguments.length > 0 ? arguments[0] : undefined;
|
||
var state = setInternalState(this, new URLSearchParamsState(init));
|
||
if (!DESCRIPTORS) this.length = state.entries.length;
|
||
};
|
||
var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
|
||
defineBuiltIns(URLSearchParamsPrototype, {
|
||
// `URLSearchParams.prototype.append` method
|
||
// https://url.spec.whatwg.org/#dom-urlsearchparams-append
|
||
append: function append(name, value) {
|
||
validateArgumentsLength(arguments.length, 2);
|
||
var state = getInternalParamsState(this);
|
||
push$1(state.entries, {
|
||
key: $toString(name),
|
||
value: $toString(value)
|
||
});
|
||
if (!DESCRIPTORS) this.length++;
|
||
state.updateURL();
|
||
},
|
||
// `URLSearchParams.prototype.delete` method
|
||
// https://url.spec.whatwg.org/#dom-urlsearchparams-delete
|
||
'delete': function (name) {
|
||
validateArgumentsLength(arguments.length, 1);
|
||
var state = getInternalParamsState(this);
|
||
var entries = state.entries;
|
||
var key = $toString(name);
|
||
var index = 0;
|
||
while (index < entries.length) {
|
||
if (entries[index].key === key) splice(entries, index, 1);else index++;
|
||
}
|
||
if (!DESCRIPTORS) this.length = entries.length;
|
||
state.updateURL();
|
||
},
|
||
// `URLSearchParams.prototype.get` method
|
||
// https://url.spec.whatwg.org/#dom-urlsearchparams-get
|
||
get: function get(name) {
|
||
validateArgumentsLength(arguments.length, 1);
|
||
var entries = getInternalParamsState(this).entries;
|
||
var key = $toString(name);
|
||
var index = 0;
|
||
for (; index < entries.length; index++) {
|
||
if (entries[index].key === key) return entries[index].value;
|
||
}
|
||
return null;
|
||
},
|
||
// `URLSearchParams.prototype.getAll` method
|
||
// https://url.spec.whatwg.org/#dom-urlsearchparams-getall
|
||
getAll: function getAll(name) {
|
||
validateArgumentsLength(arguments.length, 1);
|
||
var entries = getInternalParamsState(this).entries;
|
||
var key = $toString(name);
|
||
var result = [];
|
||
var index = 0;
|
||
for (; index < entries.length; index++) {
|
||
if (entries[index].key === key) push$1(result, entries[index].value);
|
||
}
|
||
return result;
|
||
},
|
||
// `URLSearchParams.prototype.has` method
|
||
// https://url.spec.whatwg.org/#dom-urlsearchparams-has
|
||
has: function has(name) {
|
||
validateArgumentsLength(arguments.length, 1);
|
||
var entries = getInternalParamsState(this).entries;
|
||
var key = $toString(name);
|
||
var index = 0;
|
||
while (index < entries.length) {
|
||
if (entries[index++].key === key) return true;
|
||
}
|
||
return false;
|
||
},
|
||
// `URLSearchParams.prototype.set` method
|
||
// https://url.spec.whatwg.org/#dom-urlsearchparams-set
|
||
set: function set(name, value) {
|
||
validateArgumentsLength(arguments.length, 1);
|
||
var state = getInternalParamsState(this);
|
||
var entries = state.entries;
|
||
var found = false;
|
||
var key = $toString(name);
|
||
var val = $toString(value);
|
||
var index = 0;
|
||
var entry;
|
||
for (; index < entries.length; index++) {
|
||
entry = entries[index];
|
||
if (entry.key === key) {
|
||
if (found) splice(entries, index--, 1);else {
|
||
found = true;
|
||
entry.value = val;
|
||
}
|
||
}
|
||
}
|
||
if (!found) push$1(entries, {
|
||
key: key,
|
||
value: val
|
||
});
|
||
if (!DESCRIPTORS) this.length = entries.length;
|
||
state.updateURL();
|
||
},
|
||
// `URLSearchParams.prototype.sort` method
|
||
// https://url.spec.whatwg.org/#dom-urlsearchparams-sort
|
||
sort: function sort() {
|
||
var state = getInternalParamsState(this);
|
||
arraySort(state.entries, function (a, b) {
|
||
return a.key > b.key ? 1 : -1;
|
||
});
|
||
state.updateURL();
|
||
},
|
||
// `URLSearchParams.prototype.forEach` method
|
||
forEach: function forEach(callback /* , thisArg */) {
|
||
var entries = getInternalParamsState(this).entries;
|
||
var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined);
|
||
var index = 0;
|
||
var entry;
|
||
while (index < entries.length) {
|
||
entry = entries[index++];
|
||
boundFunction(entry.value, entry.key, this);
|
||
}
|
||
},
|
||
// `URLSearchParams.prototype.keys` method
|
||
keys: function keys() {
|
||
return new URLSearchParamsIterator(this, 'keys');
|
||
},
|
||
// `URLSearchParams.prototype.values` method
|
||
values: function values() {
|
||
return new URLSearchParamsIterator(this, 'values');
|
||
},
|
||
// `URLSearchParams.prototype.entries` method
|
||
entries: function entries() {
|
||
return new URLSearchParamsIterator(this, 'entries');
|
||
}
|
||
}, {
|
||
enumerable: true
|
||
});
|
||
|
||
// `URLSearchParams.prototype[@@iterator]` method
|
||
defineBuiltIn$1(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries, {
|
||
name: 'entries'
|
||
});
|
||
|
||
// `URLSearchParams.prototype.toString` method
|
||
// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
|
||
defineBuiltIn$1(URLSearchParamsPrototype, 'toString', function toString() {
|
||
return getInternalParamsState(this).serialize();
|
||
}, {
|
||
enumerable: true
|
||
});
|
||
|
||
// `URLSearchParams.prototype.size` getter
|
||
// https://github.com/whatwg/url/pull/734
|
||
if (DESCRIPTORS) defineBuiltInAccessor(URLSearchParamsPrototype, 'size', {
|
||
get: function size() {
|
||
return getInternalParamsState(this).entries.length;
|
||
},
|
||
configurable: true,
|
||
enumerable: true
|
||
});
|
||
setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
|
||
$$2({
|
||
global: true,
|
||
constructor: true,
|
||
forced: !USE_NATIVE_URL
|
||
}, {
|
||
URLSearchParams: URLSearchParamsConstructor
|
||
});
|
||
|
||
// Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`
|
||
if (!USE_NATIVE_URL && isCallable$2(Headers)) {
|
||
var headersHas = uncurryThis$4(HeadersPrototype.has);
|
||
var headersSet = uncurryThis$4(HeadersPrototype.set);
|
||
var wrapRequestOptions = function (init) {
|
||
if (isObject(init)) {
|
||
var body = init.body;
|
||
var headers;
|
||
if (classof$1(body) === URL_SEARCH_PARAMS) {
|
||
headers = init.headers ? new Headers(init.headers) : new Headers();
|
||
if (!headersHas(headers, 'content-type')) {
|
||
headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
|
||
}
|
||
return create$1(init, {
|
||
body: createPropertyDescriptor(0, $toString(body)),
|
||
headers: createPropertyDescriptor(0, headers)
|
||
});
|
||
}
|
||
}
|
||
return init;
|
||
};
|
||
if (isCallable$2(nativeFetch)) {
|
||
$$2({
|
||
global: true,
|
||
enumerable: true,
|
||
dontCallGetSet: true,
|
||
forced: true
|
||
}, {
|
||
fetch: function fetch(input /* , init */) {
|
||
return nativeFetch(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
|
||
}
|
||
});
|
||
}
|
||
if (isCallable$2(NativeRequest)) {
|
||
var RequestConstructor = function Request(input /* , init */) {
|
||
anInstance(this, RequestPrototype);
|
||
return new NativeRequest(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
|
||
};
|
||
RequestPrototype.constructor = RequestConstructor;
|
||
RequestConstructor.prototype = RequestPrototype;
|
||
$$2({
|
||
global: true,
|
||
constructor: true,
|
||
dontCallGetSet: true,
|
||
forced: true
|
||
}, {
|
||
Request: RequestConstructor
|
||
});
|
||
}
|
||
}
|
||
|
||
var anObject$2 = anObject$e;
|
||
|
||
// `RegExp.prototype.flags` getter implementation
|
||
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
|
||
var regexpFlags$1 = function () {
|
||
var that = anObject$2(this);
|
||
var result = '';
|
||
if (that.hasIndices) result += 'd';
|
||
if (that.global) result += 'g';
|
||
if (that.ignoreCase) result += 'i';
|
||
if (that.multiline) result += 'm';
|
||
if (that.dotAll) result += 's';
|
||
if (that.unicode) result += 'u';
|
||
if (that.unicodeSets) result += 'v';
|
||
if (that.sticky) result += 'y';
|
||
return result;
|
||
};
|
||
|
||
var fails$4 = fails$r;
|
||
var global$3 = global$n;
|
||
|
||
// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
|
||
var $RegExp$2 = global$3.RegExp;
|
||
var UNSUPPORTED_Y$1 = fails$4(function () {
|
||
var re = $RegExp$2('a', 'y');
|
||
re.lastIndex = 2;
|
||
return re.exec('abcd') != null;
|
||
});
|
||
|
||
// UC Browser bug
|
||
// https://github.com/zloirock/core-js/issues/1008
|
||
var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$4(function () {
|
||
return !$RegExp$2('a', 'y').sticky;
|
||
});
|
||
var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () {
|
||
// https://bugzilla.mozilla.org/show_bug.cgi?id=773687
|
||
var re = $RegExp$2('^r', 'gy');
|
||
re.lastIndex = 2;
|
||
return re.exec('str') != null;
|
||
});
|
||
var regexpStickyHelpers = {
|
||
BROKEN_CARET: BROKEN_CARET,
|
||
MISSED_STICKY: MISSED_STICKY,
|
||
UNSUPPORTED_Y: UNSUPPORTED_Y$1
|
||
};
|
||
|
||
var fails$3 = fails$r;
|
||
var global$2 = global$n;
|
||
|
||
// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
|
||
var $RegExp$1 = global$2.RegExp;
|
||
var regexpUnsupportedDotAll = fails$3(function () {
|
||
var re = $RegExp$1('.', 's');
|
||
return !(re.dotAll && re.exec('\n') && re.flags === 's');
|
||
});
|
||
|
||
var fails$2 = fails$r;
|
||
var global$1 = global$n;
|
||
|
||
// babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
|
||
var $RegExp = global$1.RegExp;
|
||
var regexpUnsupportedNcg = fails$2(function () {
|
||
var re = $RegExp('(?<a>b)', 'g');
|
||
return re.exec('b').groups.a !== 'b' || 'b'.replace(re, '$<a>c') !== 'bc';
|
||
});
|
||
|
||
/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
|
||
/* eslint-disable regexp/no-useless-quantifier -- testing */
|
||
var call$2 = functionCall;
|
||
var uncurryThis$3 = functionUncurryThis;
|
||
var toString$1 = toString$6;
|
||
var regexpFlags = regexpFlags$1;
|
||
var stickyHelpers = regexpStickyHelpers;
|
||
var shared = shared$4.exports;
|
||
var create = objectCreate;
|
||
var getInternalState = internalState.get;
|
||
var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll;
|
||
var UNSUPPORTED_NCG = regexpUnsupportedNcg;
|
||
var nativeReplace = shared('native-string-replace', String.prototype.replace);
|
||
var nativeExec = RegExp.prototype.exec;
|
||
var patchedExec = nativeExec;
|
||
var charAt$2 = uncurryThis$3(''.charAt);
|
||
var indexOf = uncurryThis$3(''.indexOf);
|
||
var replace$1 = uncurryThis$3(''.replace);
|
||
var stringSlice$2 = uncurryThis$3(''.slice);
|
||
var UPDATES_LAST_INDEX_WRONG = function () {
|
||
var re1 = /a/;
|
||
var re2 = /b*/g;
|
||
call$2(nativeExec, re1, 'a');
|
||
call$2(nativeExec, re2, 'a');
|
||
return re1.lastIndex !== 0 || re2.lastIndex !== 0;
|
||
}();
|
||
var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
|
||
|
||
// nonparticipating capturing group, copied from es5-shim's String#split patch.
|
||
var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
|
||
var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
|
||
if (PATCH) {
|
||
patchedExec = function exec(string) {
|
||
var re = this;
|
||
var state = getInternalState(re);
|
||
var str = toString$1(string);
|
||
var raw = state.raw;
|
||
var result, reCopy, lastIndex, match, i, object, group;
|
||
if (raw) {
|
||
raw.lastIndex = re.lastIndex;
|
||
result = call$2(patchedExec, raw, str);
|
||
re.lastIndex = raw.lastIndex;
|
||
return result;
|
||
}
|
||
var groups = state.groups;
|
||
var sticky = UNSUPPORTED_Y && re.sticky;
|
||
var flags = call$2(regexpFlags, re);
|
||
var source = re.source;
|
||
var charsAdded = 0;
|
||
var strCopy = str;
|
||
if (sticky) {
|
||
flags = replace$1(flags, 'y', '');
|
||
if (indexOf(flags, 'g') === -1) {
|
||
flags += 'g';
|
||
}
|
||
strCopy = stringSlice$2(str, re.lastIndex);
|
||
// Support anchored sticky behavior.
|
||
if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$2(str, re.lastIndex - 1) !== '\n')) {
|
||
source = '(?: ' + source + ')';
|
||
strCopy = ' ' + strCopy;
|
||
charsAdded++;
|
||
}
|
||
// ^(? + rx + ) is needed, in combination with some str slicing, to
|
||
// simulate the 'y' flag.
|
||
reCopy = new RegExp('^(?:' + source + ')', flags);
|
||
}
|
||
if (NPCG_INCLUDED) {
|
||
reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
|
||
}
|
||
if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
|
||
match = call$2(nativeExec, sticky ? reCopy : re, strCopy);
|
||
if (sticky) {
|
||
if (match) {
|
||
match.input = stringSlice$2(match.input, charsAdded);
|
||
match[0] = stringSlice$2(match[0], charsAdded);
|
||
match.index = re.lastIndex;
|
||
re.lastIndex += match[0].length;
|
||
} else re.lastIndex = 0;
|
||
} else if (UPDATES_LAST_INDEX_WRONG && match) {
|
||
re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
|
||
}
|
||
if (NPCG_INCLUDED && match && match.length > 1) {
|
||
// Fix browsers whose `exec` methods don't consistently return `undefined`
|
||
// for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
|
||
call$2(nativeReplace, match[0], reCopy, function () {
|
||
for (i = 1; i < arguments.length - 2; i++) {
|
||
if (arguments[i] === undefined) match[i] = undefined;
|
||
}
|
||
});
|
||
}
|
||
if (match && groups) {
|
||
match.groups = object = create(null);
|
||
for (i = 0; i < groups.length; i++) {
|
||
group = groups[i];
|
||
object[group[0]] = match[group[1]];
|
||
}
|
||
}
|
||
return match;
|
||
};
|
||
}
|
||
var regexpExec$2 = patchedExec;
|
||
|
||
var $$1 = _export;
|
||
var exec = regexpExec$2;
|
||
|
||
// `RegExp.prototype.exec` method
|
||
// https://tc39.es/ecma262/#sec-regexp.prototype.exec
|
||
$$1({
|
||
target: 'RegExp',
|
||
proto: true,
|
||
forced: /./.exec !== exec
|
||
}, {
|
||
exec: exec
|
||
});
|
||
|
||
// TODO: Remove from `core-js@4` since it's moved to entry points
|
||
|
||
var uncurryThis$2 = functionUncurryThisClause;
|
||
var defineBuiltIn = defineBuiltIn$a;
|
||
var regexpExec$1 = regexpExec$2;
|
||
var fails$1 = fails$r;
|
||
var wellKnownSymbol$1 = wellKnownSymbol$l;
|
||
var createNonEnumerableProperty = createNonEnumerableProperty$6;
|
||
var SPECIES = wellKnownSymbol$1('species');
|
||
var RegExpPrototype = RegExp.prototype;
|
||
var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
|
||
var SYMBOL = wellKnownSymbol$1(KEY);
|
||
var DELEGATES_TO_SYMBOL = !fails$1(function () {
|
||
// String methods call symbol-named RegEp methods
|
||
var O = {};
|
||
O[SYMBOL] = function () {
|
||
return 7;
|
||
};
|
||
return ''[KEY](O) != 7;
|
||
});
|
||
var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$1(function () {
|
||
// Symbol-named RegExp methods call .exec
|
||
var execCalled = false;
|
||
var re = /a/;
|
||
if (KEY === 'split') {
|
||
// We can't use real regex here since it causes deoptimization
|
||
// and serious performance degradation in V8
|
||
// https://github.com/zloirock/core-js/issues/306
|
||
re = {};
|
||
// RegExp[@@split] doesn't call the regex's exec method, but first creates
|
||
// a new one. We need to return the patched regex when creating the new one.
|
||
re.constructor = {};
|
||
re.constructor[SPECIES] = function () {
|
||
return re;
|
||
};
|
||
re.flags = '';
|
||
re[SYMBOL] = /./[SYMBOL];
|
||
}
|
||
re.exec = function () {
|
||
execCalled = true;
|
||
return null;
|
||
};
|
||
re[SYMBOL]('');
|
||
return !execCalled;
|
||
});
|
||
if (!DELEGATES_TO_SYMBOL || !DELEGATES_TO_EXEC || FORCED) {
|
||
var uncurriedNativeRegExpMethod = uncurryThis$2(/./[SYMBOL]);
|
||
var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
|
||
var uncurriedNativeMethod = uncurryThis$2(nativeMethod);
|
||
var $exec = regexp.exec;
|
||
if ($exec === regexpExec$1 || $exec === RegExpPrototype.exec) {
|
||
if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
|
||
// The native String method already delegates to @@method (this
|
||
// polyfilled function), leasing to infinite recursion.
|
||
// We avoid it by directly calling the native @@method method.
|
||
return {
|
||
done: true,
|
||
value: uncurriedNativeRegExpMethod(regexp, str, arg2)
|
||
};
|
||
}
|
||
return {
|
||
done: true,
|
||
value: uncurriedNativeMethod(str, regexp, arg2)
|
||
};
|
||
}
|
||
return {
|
||
done: false
|
||
};
|
||
});
|
||
defineBuiltIn(String.prototype, KEY, methods[0]);
|
||
defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]);
|
||
}
|
||
if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
|
||
};
|
||
|
||
var charAt$1 = stringMultibyte.charAt;
|
||
|
||
// `AdvanceStringIndex` abstract operation
|
||
// https://tc39.es/ecma262/#sec-advancestringindex
|
||
var advanceStringIndex$1 = function (S, index, unicode) {
|
||
return index + (unicode ? charAt$1(S, index).length : 1);
|
||
};
|
||
|
||
var uncurryThis$1 = functionUncurryThis;
|
||
var toObject = toObject$6;
|
||
var floor = Math.floor;
|
||
var charAt = uncurryThis$1(''.charAt);
|
||
var replace = uncurryThis$1(''.replace);
|
||
var stringSlice$1 = uncurryThis$1(''.slice);
|
||
// eslint-disable-next-line redos/no-vulnerable -- safe
|
||
var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
|
||
var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
|
||
|
||
// `GetSubstitution` abstract operation
|
||
// https://tc39.es/ecma262/#sec-getsubstitution
|
||
var getSubstitution$1 = function (matched, str, position, captures, namedCaptures, replacement) {
|
||
var tailPos = position + matched.length;
|
||
var m = captures.length;
|
||
var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
|
||
if (namedCaptures !== undefined) {
|
||
namedCaptures = toObject(namedCaptures);
|
||
symbols = SUBSTITUTION_SYMBOLS;
|
||
}
|
||
return replace(replacement, symbols, function (match, ch) {
|
||
var capture;
|
||
switch (charAt(ch, 0)) {
|
||
case '$':
|
||
return '$';
|
||
case '&':
|
||
return matched;
|
||
case '`':
|
||
return stringSlice$1(str, 0, position);
|
||
case "'":
|
||
return stringSlice$1(str, tailPos);
|
||
case '<':
|
||
capture = namedCaptures[stringSlice$1(ch, 1, -1)];
|
||
break;
|
||
default:
|
||
// \d\d?
|
||
var n = +ch;
|
||
if (n === 0) return match;
|
||
if (n > m) {
|
||
var f = floor(n / 10);
|
||
if (f === 0) return match;
|
||
if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);
|
||
return match;
|
||
}
|
||
capture = captures[n - 1];
|
||
}
|
||
return capture === undefined ? '' : capture;
|
||
});
|
||
};
|
||
|
||
var call$1 = functionCall;
|
||
var anObject$1 = anObject$e;
|
||
var isCallable$1 = isCallable$r;
|
||
var classof = classofRaw$2;
|
||
var regexpExec = regexpExec$2;
|
||
var $TypeError = TypeError;
|
||
|
||
// `RegExpExec` abstract operation
|
||
// https://tc39.es/ecma262/#sec-regexpexec
|
||
var regexpExecAbstract = function (R, S) {
|
||
var exec = R.exec;
|
||
if (isCallable$1(exec)) {
|
||
var result = call$1(exec, R, S);
|
||
if (result !== null) anObject$1(result);
|
||
return result;
|
||
}
|
||
if (classof(R) === 'RegExp') return call$1(regexpExec, R, S);
|
||
throw $TypeError('RegExp#exec called on incompatible receiver');
|
||
};
|
||
|
||
var apply = functionApply;
|
||
var call = functionCall;
|
||
var uncurryThis = functionUncurryThis;
|
||
var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic;
|
||
var fails = fails$r;
|
||
var anObject = anObject$e;
|
||
var isCallable = isCallable$r;
|
||
var isNullOrUndefined = isNullOrUndefined$7;
|
||
var toIntegerOrInfinity = toIntegerOrInfinity$4;
|
||
var toLength = toLength$2;
|
||
var toString = toString$6;
|
||
var requireObjectCoercible = requireObjectCoercible$4;
|
||
var advanceStringIndex = advanceStringIndex$1;
|
||
var getMethod = getMethod$4;
|
||
var getSubstitution = getSubstitution$1;
|
||
var regExpExec = regexpExecAbstract;
|
||
var wellKnownSymbol = wellKnownSymbol$l;
|
||
var REPLACE = wellKnownSymbol('replace');
|
||
var max = Math.max;
|
||
var min = Math.min;
|
||
var concat = uncurryThis([].concat);
|
||
var push = uncurryThis([].push);
|
||
var stringIndexOf = uncurryThis(''.indexOf);
|
||
var stringSlice = uncurryThis(''.slice);
|
||
var maybeToString = function (it) {
|
||
return it === undefined ? it : String(it);
|
||
};
|
||
|
||
// IE <= 11 replaces $0 with the whole match, as if it was $&
|
||
// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
|
||
var REPLACE_KEEPS_$0 = function () {
|
||
// eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
|
||
return 'a'.replace(/./, '$0') === '$0';
|
||
}();
|
||
|
||
// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
|
||
var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = function () {
|
||
if (/./[REPLACE]) {
|
||
return /./[REPLACE]('a', '$0') === '';
|
||
}
|
||
return false;
|
||
}();
|
||
var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
|
||
var re = /./;
|
||
re.exec = function () {
|
||
var result = [];
|
||
result.groups = {
|
||
a: '7'
|
||
};
|
||
return result;
|
||
};
|
||
// eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive
|
||
return ''.replace(re, '$<a>') !== '7';
|
||
});
|
||
|
||
// @@replace logic
|
||
fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
|
||
var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
|
||
return [
|
||
// `String.prototype.replace` method
|
||
// https://tc39.es/ecma262/#sec-string.prototype.replace
|
||
function replace(searchValue, replaceValue) {
|
||
var O = requireObjectCoercible(this);
|
||
var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE);
|
||
return replacer ? call(replacer, searchValue, O, replaceValue) : call(nativeReplace, toString(O), searchValue, replaceValue);
|
||
},
|
||
// `RegExp.prototype[@@replace]` method
|
||
// https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
|
||
function (string, replaceValue) {
|
||
var rx = anObject(this);
|
||
var S = toString(string);
|
||
if (typeof replaceValue == 'string' && stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 && stringIndexOf(replaceValue, '$<') === -1) {
|
||
var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
|
||
if (res.done) return res.value;
|
||
}
|
||
var functionalReplace = isCallable(replaceValue);
|
||
if (!functionalReplace) replaceValue = toString(replaceValue);
|
||
var global = rx.global;
|
||
if (global) {
|
||
var fullUnicode = rx.unicode;
|
||
rx.lastIndex = 0;
|
||
}
|
||
var results = [];
|
||
while (true) {
|
||
var result = regExpExec(rx, S);
|
||
if (result === null) break;
|
||
push(results, result);
|
||
if (!global) break;
|
||
var matchStr = toString(result[0]);
|
||
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
|
||
}
|
||
var accumulatedResult = '';
|
||
var nextSourcePosition = 0;
|
||
for (var i = 0; i < results.length; i++) {
|
||
result = results[i];
|
||
var matched = toString(result[0]);
|
||
var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
|
||
var captures = [];
|
||
// NOTE: This is equivalent to
|
||
// captures = result.slice(1).map(maybeToString)
|
||
// but for some reason `nativeSlice.call(result, 1, result.length)` (called in
|
||
// the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
|
||
// causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
|
||
for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
|
||
var namedCaptures = result.groups;
|
||
if (functionalReplace) {
|
||
var replacerArgs = concat([matched], captures, position, S);
|
||
if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
|
||
var replacement = toString(apply(replaceValue, undefined, replacerArgs));
|
||
} else {
|
||
replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
|
||
}
|
||
if (position >= nextSourcePosition) {
|
||
accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
|
||
nextSourcePosition = position + matched.length;
|
||
}
|
||
}
|
||
return accumulatedResult + stringSlice(S, nextSourcePosition);
|
||
}];
|
||
}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
|
||
|
||
var $ = _export;
|
||
var $map = arrayIteration.map;
|
||
var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$2;
|
||
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');
|
||
|
||
// `Array.prototype.map` method
|
||
// https://tc39.es/ecma262/#sec-array.prototype.map
|
||
// with adding support of @@species
|
||
$({
|
||
target: 'Array',
|
||
proto: true,
|
||
forced: !HAS_SPECIES_SUPPORT
|
||
}, {
|
||
map: function map(callbackfn /* , thisArg */) {
|
||
return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
|
||
}
|
||
});
|
||
|
||
/*! *****************************************************************************
|
||
Copyright (c) Microsoft Corporation.
|
||
|
||
Permission to use, copy, modify, and/or distribute this software for any
|
||
purpose with or without fee is hereby granted.
|
||
|
||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||
PERFORMANCE OF THIS SOFTWARE.
|
||
***************************************************************************** */
|
||
function __awaiter(thisArg, _arguments, P, generator) {
|
||
function adopt(value) {
|
||
return value instanceof P ? value : new P(function (resolve) {
|
||
resolve(value);
|
||
});
|
||
}
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) {
|
||
try {
|
||
step(generator.next(value));
|
||
} catch (e) {
|
||
reject(e);
|
||
}
|
||
}
|
||
function rejected(value) {
|
||
try {
|
||
step(generator["throw"](value));
|
||
} catch (e) {
|
||
reject(e);
|
||
}
|
||
}
|
||
function step(result) {
|
||
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
|
||
}
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
}
|
||
|
||
// do not edit .js files directly - edit src/index.jst
|
||
|
||
var fastDeepEqual = function equal(a, b) {
|
||
if (a === b) return true;
|
||
if (a && b && typeof a == 'object' && typeof b == 'object') {
|
||
if (a.constructor !== b.constructor) return false;
|
||
var length, i, keys;
|
||
if (Array.isArray(a)) {
|
||
length = a.length;
|
||
if (length != b.length) return false;
|
||
for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
|
||
return true;
|
||
}
|
||
if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
|
||
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
|
||
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
|
||
keys = Object.keys(a);
|
||
length = keys.length;
|
||
if (length !== Object.keys(b).length) return false;
|
||
for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
|
||
for (i = length; i-- !== 0;) {
|
||
var key = keys[i];
|
||
if (!equal(a[key], b[key])) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// true if both NaN, false otherwise
|
||
return a !== a && b !== b;
|
||
};
|
||
|
||
var DEFAULT_ID = "__googleMapsScriptId";
|
||
/**
|
||
* The status of the [[Loader]].
|
||
*/
|
||
exports.LoaderStatus = void 0;
|
||
(function (LoaderStatus) {
|
||
LoaderStatus[LoaderStatus["INITIALIZED"] = 0] = "INITIALIZED";
|
||
LoaderStatus[LoaderStatus["LOADING"] = 1] = "LOADING";
|
||
LoaderStatus[LoaderStatus["SUCCESS"] = 2] = "SUCCESS";
|
||
LoaderStatus[LoaderStatus["FAILURE"] = 3] = "FAILURE";
|
||
})(exports.LoaderStatus || (exports.LoaderStatus = {}));
|
||
/**
|
||
* [[Loader]] makes it easier to add Google Maps JavaScript API to your application
|
||
* dynamically using
|
||
* [Promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
|
||
* It works by dynamically creating and appending a script node to the the
|
||
* document head and wrapping the callback function so as to return a promise.
|
||
*
|
||
* ```
|
||
* const loader = new Loader({
|
||
* apiKey: "",
|
||
* version: "weekly",
|
||
* libraries: ["places"]
|
||
* });
|
||
*
|
||
* loader.load().then((google) => {
|
||
* const map = new google.maps.Map(...)
|
||
* })
|
||
* ```
|
||
*/
|
||
var Loader = /*#__PURE__*/function () {
|
||
/**
|
||
* Creates an instance of Loader using [[LoaderOptions]]. No defaults are set
|
||
* using this library, instead the defaults are set by the Google Maps
|
||
* JavaScript API server.
|
||
*
|
||
* ```
|
||
* const loader = Loader({apiKey, version: 'weekly', libraries: ['places']});
|
||
* ```
|
||
*/
|
||
function Loader(_ref) {
|
||
var apiKey = _ref.apiKey,
|
||
authReferrerPolicy = _ref.authReferrerPolicy,
|
||
channel = _ref.channel,
|
||
client = _ref.client,
|
||
_ref$id = _ref.id,
|
||
id = _ref$id === void 0 ? DEFAULT_ID : _ref$id,
|
||
language = _ref.language,
|
||
_ref$libraries = _ref.libraries,
|
||
libraries = _ref$libraries === void 0 ? [] : _ref$libraries,
|
||
mapIds = _ref.mapIds,
|
||
nonce = _ref.nonce,
|
||
region = _ref.region,
|
||
_ref$retries = _ref.retries,
|
||
retries = _ref$retries === void 0 ? 3 : _ref$retries,
|
||
_ref$url = _ref.url,
|
||
url = _ref$url === void 0 ? "https://maps.googleapis.com/maps/api/js" : _ref$url,
|
||
version = _ref.version;
|
||
_classCallCheck(this, Loader);
|
||
this.callbacks = [];
|
||
this.done = false;
|
||
this.loading = false;
|
||
this.errors = [];
|
||
this.apiKey = apiKey;
|
||
this.authReferrerPolicy = authReferrerPolicy;
|
||
this.channel = channel;
|
||
this.client = client;
|
||
this.id = id || DEFAULT_ID; // Do not allow empty string
|
||
this.language = language;
|
||
this.libraries = libraries;
|
||
this.mapIds = mapIds;
|
||
this.nonce = nonce;
|
||
this.region = region;
|
||
this.retries = retries;
|
||
this.url = url;
|
||
this.version = version;
|
||
if (Loader.instance) {
|
||
if (!fastDeepEqual(this.options, Loader.instance.options)) {
|
||
throw new Error("Loader must not be called again with different options. ".concat(JSON.stringify(this.options), " !== ").concat(JSON.stringify(Loader.instance.options)));
|
||
}
|
||
return Loader.instance;
|
||
}
|
||
Loader.instance = this;
|
||
}
|
||
_createClass(Loader, [{
|
||
key: "options",
|
||
get: function get() {
|
||
return {
|
||
version: this.version,
|
||
apiKey: this.apiKey,
|
||
channel: this.channel,
|
||
client: this.client,
|
||
id: this.id,
|
||
libraries: this.libraries,
|
||
language: this.language,
|
||
region: this.region,
|
||
mapIds: this.mapIds,
|
||
nonce: this.nonce,
|
||
url: this.url,
|
||
authReferrerPolicy: this.authReferrerPolicy
|
||
};
|
||
}
|
||
}, {
|
||
key: "status",
|
||
get: function get() {
|
||
if (this.errors.length) {
|
||
return exports.LoaderStatus.FAILURE;
|
||
}
|
||
if (this.done) {
|
||
return exports.LoaderStatus.SUCCESS;
|
||
}
|
||
if (this.loading) {
|
||
return exports.LoaderStatus.LOADING;
|
||
}
|
||
return exports.LoaderStatus.INITIALIZED;
|
||
}
|
||
}, {
|
||
key: "failed",
|
||
get: function get() {
|
||
return this.done && !this.loading && this.errors.length >= this.retries + 1;
|
||
}
|
||
/**
|
||
* CreateUrl returns the Google Maps JavaScript API script url given the [[LoaderOptions]].
|
||
*
|
||
* @ignore
|
||
* @deprecated
|
||
*/
|
||
}, {
|
||
key: "createUrl",
|
||
value: function createUrl() {
|
||
var url = this.url;
|
||
url += "?callback=__googleMapsCallback";
|
||
if (this.apiKey) {
|
||
url += "&key=".concat(this.apiKey);
|
||
}
|
||
if (this.channel) {
|
||
url += "&channel=".concat(this.channel);
|
||
}
|
||
if (this.client) {
|
||
url += "&client=".concat(this.client);
|
||
}
|
||
if (this.libraries.length > 0) {
|
||
url += "&libraries=".concat(this.libraries.join(","));
|
||
}
|
||
if (this.language) {
|
||
url += "&language=".concat(this.language);
|
||
}
|
||
if (this.region) {
|
||
url += "®ion=".concat(this.region);
|
||
}
|
||
if (this.version) {
|
||
url += "&v=".concat(this.version);
|
||
}
|
||
if (this.mapIds) {
|
||
url += "&map_ids=".concat(this.mapIds.join(","));
|
||
}
|
||
if (this.authReferrerPolicy) {
|
||
url += "&auth_referrer_policy=".concat(this.authReferrerPolicy);
|
||
}
|
||
return url;
|
||
}
|
||
}, {
|
||
key: "deleteScript",
|
||
value: function deleteScript() {
|
||
var script = document.getElementById(this.id);
|
||
if (script) {
|
||
script.remove();
|
||
}
|
||
}
|
||
/**
|
||
* Load the Google Maps JavaScript API script and return a Promise.
|
||
* @deprecated, use importLibrary() instead.
|
||
*/
|
||
}, {
|
||
key: "load",
|
||
value: function load() {
|
||
return this.loadPromise();
|
||
}
|
||
/**
|
||
* Load the Google Maps JavaScript API script and return a Promise.
|
||
*
|
||
* @ignore
|
||
* @deprecated, use importLibrary() instead.
|
||
*/
|
||
}, {
|
||
key: "loadPromise",
|
||
value: function loadPromise() {
|
||
var _this = this;
|
||
return new Promise(function (resolve, reject) {
|
||
_this.loadCallback(function (err) {
|
||
if (!err) {
|
||
resolve(window.google);
|
||
} else {
|
||
reject(err.error);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
}, {
|
||
key: "importLibrary",
|
||
value: function importLibrary(name) {
|
||
this.execute();
|
||
return google.maps.importLibrary(name);
|
||
}
|
||
/**
|
||
* Load the Google Maps JavaScript API script with a callback.
|
||
* @deprecated, use importLibrary() instead.
|
||
*/
|
||
}, {
|
||
key: "loadCallback",
|
||
value: function loadCallback(fn) {
|
||
this.callbacks.push(fn);
|
||
this.execute();
|
||
}
|
||
/**
|
||
* Set the script on document.
|
||
*/
|
||
}, {
|
||
key: "setScript",
|
||
value: function setScript() {
|
||
var _this2 = this;
|
||
var _a, _b;
|
||
if (document.getElementById(this.id)) {
|
||
// TODO wrap onerror callback for cases where the script was loaded elsewhere
|
||
this.callback();
|
||
return;
|
||
}
|
||
var params = {
|
||
key: this.apiKey,
|
||
channel: this.channel,
|
||
client: this.client,
|
||
libraries: this.libraries.length && this.libraries,
|
||
v: this.version,
|
||
mapIds: this.mapIds,
|
||
language: this.language,
|
||
region: this.region,
|
||
authReferrerPolicy: this.authReferrerPolicy
|
||
};
|
||
// keep the URL minimal:
|
||
Object.keys(params).forEach(
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
function (key) {
|
||
return !params[key] && delete params[key];
|
||
});
|
||
if (!((_b = (_a = window === null || window === void 0 ? void 0 : window.google) === null || _a === void 0 ? void 0 : _a.maps) === null || _b === void 0 ? void 0 : _b.importLibrary)) {
|
||
// tweaked copy of https://developers.google.com/maps/documentation/javascript/load-maps-js-api#dynamic-library-import
|
||
// which also sets the base url, the id, and the nonce
|
||
/* eslint-disable */
|
||
(function (g) {
|
||
// @ts-ignore
|
||
var h,
|
||
a,
|
||
k,
|
||
p = "The Google Maps JavaScript API",
|
||
c = "google",
|
||
l = "importLibrary",
|
||
q = "__ib__",
|
||
m = document,
|
||
b = window;
|
||
// @ts-ignore
|
||
b = b[c] || (b[c] = {});
|
||
// @ts-ignore
|
||
var d = b.maps || (b.maps = {}),
|
||
r = new Set(),
|
||
e = new URLSearchParams(),
|
||
u = function u() {
|
||
return (
|
||
// @ts-ignore
|
||
h || (h = new Promise(function (f, n) {
|
||
return __awaiter(_this2, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
|
||
var _a;
|
||
return _regeneratorRuntime().wrap(function _callee$(_context) {
|
||
while (1) switch (_context.prev = _context.next) {
|
||
case 0:
|
||
_context.next = 2;
|
||
return a = m.createElement("script");
|
||
case 2:
|
||
a.id = this.id;
|
||
e.set("libraries", _toConsumableArray(r) + "");
|
||
// @ts-ignore
|
||
for (k in g) e.set(k.replace(/[A-Z]/g, function (t) {
|
||
return "_" + t[0].toLowerCase();
|
||
}), g[k]);
|
||
e.set("callback", c + ".maps." + q);
|
||
a.src = this.url + "?" + e;
|
||
d[q] = f;
|
||
a.onerror = function () {
|
||
return h = n(Error(p + " could not load."));
|
||
};
|
||
// @ts-ignore
|
||
a.nonce = this.nonce || ((_a = m.querySelector("script[nonce]")) === null || _a === void 0 ? void 0 : _a.nonce) || "";
|
||
m.head.append(a);
|
||
case 11:
|
||
case "end":
|
||
return _context.stop();
|
||
}
|
||
}, _callee, this);
|
||
}));
|
||
}))
|
||
);
|
||
};
|
||
// @ts-ignore
|
||
d[l] ? console.warn(p + " only loads once. Ignoring:", g) : d[l] = function (f) {
|
||
for (var _len = arguments.length, n = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||
n[_key - 1] = arguments[_key];
|
||
}
|
||
return r.add(f) && u().then(function () {
|
||
return d[l].apply(d, [f].concat(n));
|
||
});
|
||
};
|
||
})(params);
|
||
/* eslint-enable */
|
||
}
|
||
// While most libraries populate the global namespace when loaded via bootstrap params,
|
||
// this is not the case for "marker" when used with the inline bootstrap loader
|
||
// (and maybe others in the future). So ensure there is an importLibrary for each:
|
||
var libraryPromises = this.libraries.map(function (library) {
|
||
return _this2.importLibrary(library);
|
||
});
|
||
// ensure at least one library, to kick off loading...
|
||
if (!libraryPromises.length) {
|
||
libraryPromises.push(this.importLibrary("core"));
|
||
}
|
||
Promise.all(libraryPromises).then(function () {
|
||
return _this2.callback();
|
||
}, function (error) {
|
||
var event = new ErrorEvent("error", {
|
||
error: error
|
||
}); // for backwards compat
|
||
_this2.loadErrorCallback(event);
|
||
});
|
||
}
|
||
/**
|
||
* Reset the loader state.
|
||
*/
|
||
}, {
|
||
key: "reset",
|
||
value: function reset() {
|
||
this.deleteScript();
|
||
this.done = false;
|
||
this.loading = false;
|
||
this.errors = [];
|
||
this.onerrorEvent = null;
|
||
}
|
||
}, {
|
||
key: "resetIfRetryingFailed",
|
||
value: function resetIfRetryingFailed() {
|
||
if (this.failed) {
|
||
this.reset();
|
||
}
|
||
}
|
||
}, {
|
||
key: "loadErrorCallback",
|
||
value: function loadErrorCallback(e) {
|
||
var _this3 = this;
|
||
this.errors.push(e);
|
||
if (this.errors.length <= this.retries) {
|
||
var delay = this.errors.length * Math.pow(2, this.errors.length);
|
||
console.error("Failed to load Google Maps script, retrying in ".concat(delay, " ms."));
|
||
setTimeout(function () {
|
||
_this3.deleteScript();
|
||
_this3.setScript();
|
||
}, delay);
|
||
} else {
|
||
this.onerrorEvent = e;
|
||
this.callback();
|
||
}
|
||
}
|
||
}, {
|
||
key: "callback",
|
||
value: function callback() {
|
||
var _this4 = this;
|
||
this.done = true;
|
||
this.loading = false;
|
||
this.callbacks.forEach(function (cb) {
|
||
cb(_this4.onerrorEvent);
|
||
});
|
||
this.callbacks = [];
|
||
}
|
||
}, {
|
||
key: "execute",
|
||
value: function execute() {
|
||
this.resetIfRetryingFailed();
|
||
if (this.done) {
|
||
this.callback();
|
||
} else {
|
||
// short circuit and warn if google.maps is already loaded
|
||
if (window.google && window.google.maps && window.google.maps.version) {
|
||
console.warn("Google Maps already loaded outside @googlemaps/js-api-loader." + "This may result in undesirable behavior as options and script parameters may not match.");
|
||
this.callback();
|
||
return;
|
||
}
|
||
if (this.loading) ; else {
|
||
this.loading = true;
|
||
this.setScript();
|
||
}
|
||
}
|
||
}
|
||
}]);
|
||
return Loader;
|
||
}();
|
||
|
||
exports.DEFAULT_ID = DEFAULT_ID;
|
||
exports.Loader = Loader;
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
return exports;
|
||
|
||
})({});
|