5712 lines
189 KiB
JavaScript
5712 lines
189 KiB
JavaScript
(function () {
|
|
'use strict';
|
|
|
|
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
|
|
|
var es_array_push = {};
|
|
|
|
var globalThis_1;
|
|
var hasRequiredGlobalThis;
|
|
|
|
function requireGlobalThis () {
|
|
if (hasRequiredGlobalThis) return globalThis_1;
|
|
hasRequiredGlobalThis = 1;
|
|
var check = function (it) {
|
|
return it && it.Math === Math && it;
|
|
};
|
|
|
|
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
|
|
globalThis_1 =
|
|
// 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) ||
|
|
check(typeof globalThis_1 == 'object' && globalThis_1) ||
|
|
// eslint-disable-next-line no-new-func -- fallback
|
|
(function () { return this; })() || Function('return this')();
|
|
return globalThis_1;
|
|
}
|
|
|
|
var objectGetOwnPropertyDescriptor = {};
|
|
|
|
var fails;
|
|
var hasRequiredFails;
|
|
|
|
function requireFails () {
|
|
if (hasRequiredFails) return fails;
|
|
hasRequiredFails = 1;
|
|
fails = function (exec) {
|
|
try {
|
|
return !!exec();
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
return fails;
|
|
}
|
|
|
|
var descriptors;
|
|
var hasRequiredDescriptors;
|
|
|
|
function requireDescriptors () {
|
|
if (hasRequiredDescriptors) return descriptors;
|
|
hasRequiredDescriptors = 1;
|
|
var fails = requireFails();
|
|
|
|
// Detect IE8's incomplete defineProperty implementation
|
|
descriptors = !fails(function () {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
|
|
});
|
|
return descriptors;
|
|
}
|
|
|
|
var functionBindNative;
|
|
var hasRequiredFunctionBindNative;
|
|
|
|
function requireFunctionBindNative () {
|
|
if (hasRequiredFunctionBindNative) return functionBindNative;
|
|
hasRequiredFunctionBindNative = 1;
|
|
var fails = requireFails();
|
|
|
|
functionBindNative = !fails(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');
|
|
});
|
|
return functionBindNative;
|
|
}
|
|
|
|
var functionCall;
|
|
var hasRequiredFunctionCall;
|
|
|
|
function requireFunctionCall () {
|
|
if (hasRequiredFunctionCall) return functionCall;
|
|
hasRequiredFunctionCall = 1;
|
|
var NATIVE_BIND = requireFunctionBindNative();
|
|
|
|
var call = Function.prototype.call;
|
|
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
|
functionCall = NATIVE_BIND ? call.bind(call) : function () {
|
|
return call.apply(call, arguments);
|
|
};
|
|
return functionCall;
|
|
}
|
|
|
|
var objectPropertyIsEnumerable = {};
|
|
|
|
var hasRequiredObjectPropertyIsEnumerable;
|
|
|
|
function requireObjectPropertyIsEnumerable () {
|
|
if (hasRequiredObjectPropertyIsEnumerable) return objectPropertyIsEnumerable;
|
|
hasRequiredObjectPropertyIsEnumerable = 1;
|
|
var $propertyIsEnumerable = {}.propertyIsEnumerable;
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
|
// Nashorn ~ JDK8 bug
|
|
var NASHORN_BUG = getOwnPropertyDescriptor && !$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(this, V);
|
|
return !!descriptor && descriptor.enumerable;
|
|
} : $propertyIsEnumerable;
|
|
return objectPropertyIsEnumerable;
|
|
}
|
|
|
|
var createPropertyDescriptor;
|
|
var hasRequiredCreatePropertyDescriptor;
|
|
|
|
function requireCreatePropertyDescriptor () {
|
|
if (hasRequiredCreatePropertyDescriptor) return createPropertyDescriptor;
|
|
hasRequiredCreatePropertyDescriptor = 1;
|
|
createPropertyDescriptor = function (bitmap, value) {
|
|
return {
|
|
enumerable: !(bitmap & 1),
|
|
configurable: !(bitmap & 2),
|
|
writable: !(bitmap & 4),
|
|
value: value
|
|
};
|
|
};
|
|
return createPropertyDescriptor;
|
|
}
|
|
|
|
var functionUncurryThis;
|
|
var hasRequiredFunctionUncurryThis;
|
|
|
|
function requireFunctionUncurryThis () {
|
|
if (hasRequiredFunctionUncurryThis) return functionUncurryThis;
|
|
hasRequiredFunctionUncurryThis = 1;
|
|
var NATIVE_BIND = requireFunctionBindNative();
|
|
|
|
var FunctionPrototype = Function.prototype;
|
|
var call = FunctionPrototype.call;
|
|
// eslint-disable-next-line es/no-function-prototype-bind -- safe
|
|
var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
|
|
|
|
functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
|
|
return function () {
|
|
return call.apply(fn, arguments);
|
|
};
|
|
};
|
|
return functionUncurryThis;
|
|
}
|
|
|
|
var classofRaw;
|
|
var hasRequiredClassofRaw;
|
|
|
|
function requireClassofRaw () {
|
|
if (hasRequiredClassofRaw) return classofRaw;
|
|
hasRequiredClassofRaw = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
var toString = uncurryThis({}.toString);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
|
|
classofRaw = function (it) {
|
|
return stringSlice(toString(it), 8, -1);
|
|
};
|
|
return classofRaw;
|
|
}
|
|
|
|
var indexedObject;
|
|
var hasRequiredIndexedObject;
|
|
|
|
function requireIndexedObject () {
|
|
if (hasRequiredIndexedObject) return indexedObject;
|
|
hasRequiredIndexedObject = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var fails = requireFails();
|
|
var classof = requireClassofRaw();
|
|
|
|
var $Object = Object;
|
|
var split = uncurryThis(''.split);
|
|
|
|
// fallback for non-array-like ES3 and non-enumerable old V8 strings
|
|
indexedObject = fails(function () {
|
|
// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
|
|
// eslint-disable-next-line no-prototype-builtins -- safe
|
|
return !$Object('z').propertyIsEnumerable(0);
|
|
}) ? function (it) {
|
|
return classof(it) === 'String' ? split(it, '') : $Object(it);
|
|
} : $Object;
|
|
return indexedObject;
|
|
}
|
|
|
|
var isNullOrUndefined;
|
|
var hasRequiredIsNullOrUndefined;
|
|
|
|
function requireIsNullOrUndefined () {
|
|
if (hasRequiredIsNullOrUndefined) return isNullOrUndefined;
|
|
hasRequiredIsNullOrUndefined = 1;
|
|
// we can't use just `it == null` since of `document.all` special case
|
|
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
|
|
isNullOrUndefined = function (it) {
|
|
return it === null || it === undefined;
|
|
};
|
|
return isNullOrUndefined;
|
|
}
|
|
|
|
var requireObjectCoercible;
|
|
var hasRequiredRequireObjectCoercible;
|
|
|
|
function requireRequireObjectCoercible () {
|
|
if (hasRequiredRequireObjectCoercible) return requireObjectCoercible;
|
|
hasRequiredRequireObjectCoercible = 1;
|
|
var isNullOrUndefined = requireIsNullOrUndefined();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `RequireObjectCoercible` abstract operation
|
|
// https://tc39.es/ecma262/#sec-requireobjectcoercible
|
|
requireObjectCoercible = function (it) {
|
|
if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
|
|
return it;
|
|
};
|
|
return requireObjectCoercible;
|
|
}
|
|
|
|
var toIndexedObject;
|
|
var hasRequiredToIndexedObject;
|
|
|
|
function requireToIndexedObject () {
|
|
if (hasRequiredToIndexedObject) return toIndexedObject;
|
|
hasRequiredToIndexedObject = 1;
|
|
// toObject with fallback for non-array-like ES3 strings
|
|
var IndexedObject = requireIndexedObject();
|
|
var requireObjectCoercible = requireRequireObjectCoercible();
|
|
|
|
toIndexedObject = function (it) {
|
|
return IndexedObject(requireObjectCoercible(it));
|
|
};
|
|
return toIndexedObject;
|
|
}
|
|
|
|
var isCallable;
|
|
var hasRequiredIsCallable;
|
|
|
|
function requireIsCallable () {
|
|
if (hasRequiredIsCallable) return isCallable;
|
|
hasRequiredIsCallable = 1;
|
|
// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
|
|
var documentAll = typeof document == 'object' && document.all;
|
|
|
|
// `IsCallable` abstract operation
|
|
// https://tc39.es/ecma262/#sec-iscallable
|
|
// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
|
|
isCallable = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
|
|
return typeof argument == 'function' || argument === documentAll;
|
|
} : function (argument) {
|
|
return typeof argument == 'function';
|
|
};
|
|
return isCallable;
|
|
}
|
|
|
|
var isObject;
|
|
var hasRequiredIsObject;
|
|
|
|
function requireIsObject () {
|
|
if (hasRequiredIsObject) return isObject;
|
|
hasRequiredIsObject = 1;
|
|
var isCallable = requireIsCallable();
|
|
|
|
isObject = function (it) {
|
|
return typeof it == 'object' ? it !== null : isCallable(it);
|
|
};
|
|
return isObject;
|
|
}
|
|
|
|
var getBuiltIn;
|
|
var hasRequiredGetBuiltIn;
|
|
|
|
function requireGetBuiltIn () {
|
|
if (hasRequiredGetBuiltIn) return getBuiltIn;
|
|
hasRequiredGetBuiltIn = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var isCallable = requireIsCallable();
|
|
|
|
var aFunction = function (argument) {
|
|
return isCallable(argument) ? argument : undefined;
|
|
};
|
|
|
|
getBuiltIn = function (namespace, method) {
|
|
return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
|
|
};
|
|
return getBuiltIn;
|
|
}
|
|
|
|
var objectIsPrototypeOf;
|
|
var hasRequiredObjectIsPrototypeOf;
|
|
|
|
function requireObjectIsPrototypeOf () {
|
|
if (hasRequiredObjectIsPrototypeOf) return objectIsPrototypeOf;
|
|
hasRequiredObjectIsPrototypeOf = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
objectIsPrototypeOf = uncurryThis({}.isPrototypeOf);
|
|
return objectIsPrototypeOf;
|
|
}
|
|
|
|
var environmentUserAgent;
|
|
var hasRequiredEnvironmentUserAgent;
|
|
|
|
function requireEnvironmentUserAgent () {
|
|
if (hasRequiredEnvironmentUserAgent) return environmentUserAgent;
|
|
hasRequiredEnvironmentUserAgent = 1;
|
|
var globalThis = requireGlobalThis();
|
|
|
|
var navigator = globalThis.navigator;
|
|
var userAgent = navigator && navigator.userAgent;
|
|
|
|
environmentUserAgent = userAgent ? String(userAgent) : '';
|
|
return environmentUserAgent;
|
|
}
|
|
|
|
var environmentV8Version;
|
|
var hasRequiredEnvironmentV8Version;
|
|
|
|
function requireEnvironmentV8Version () {
|
|
if (hasRequiredEnvironmentV8Version) return environmentV8Version;
|
|
hasRequiredEnvironmentV8Version = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var userAgent = requireEnvironmentUserAgent();
|
|
|
|
var process = globalThis.process;
|
|
var Deno = globalThis.Deno;
|
|
var versions = process && process.versions || Deno && Deno.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) {
|
|
match = userAgent.match(/Edge\/(\d+)/);
|
|
if (!match || match[1] >= 74) {
|
|
match = userAgent.match(/Chrome\/(\d+)/);
|
|
if (match) version = +match[1];
|
|
}
|
|
}
|
|
|
|
environmentV8Version = version;
|
|
return environmentV8Version;
|
|
}
|
|
|
|
var symbolConstructorDetection;
|
|
var hasRequiredSymbolConstructorDetection;
|
|
|
|
function requireSymbolConstructorDetection () {
|
|
if (hasRequiredSymbolConstructorDetection) return symbolConstructorDetection;
|
|
hasRequiredSymbolConstructorDetection = 1;
|
|
/* eslint-disable es/no-symbol -- required for testing */
|
|
var V8_VERSION = requireEnvironmentV8Version();
|
|
var fails = requireFails();
|
|
var globalThis = requireGlobalThis();
|
|
|
|
var $String = globalThis.String;
|
|
|
|
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
|
|
symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails(function () {
|
|
var symbol = Symbol('symbol detection');
|
|
// 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(symbol) || !(Object(symbol) instanceof Symbol) ||
|
|
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
|
|
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
|
|
});
|
|
return symbolConstructorDetection;
|
|
}
|
|
|
|
var useSymbolAsUid;
|
|
var hasRequiredUseSymbolAsUid;
|
|
|
|
function requireUseSymbolAsUid () {
|
|
if (hasRequiredUseSymbolAsUid) return useSymbolAsUid;
|
|
hasRequiredUseSymbolAsUid = 1;
|
|
/* eslint-disable es/no-symbol -- required for testing */
|
|
var NATIVE_SYMBOL = requireSymbolConstructorDetection();
|
|
|
|
useSymbolAsUid = NATIVE_SYMBOL &&
|
|
!Symbol.sham &&
|
|
typeof Symbol.iterator == 'symbol';
|
|
return useSymbolAsUid;
|
|
}
|
|
|
|
var isSymbol;
|
|
var hasRequiredIsSymbol;
|
|
|
|
function requireIsSymbol () {
|
|
if (hasRequiredIsSymbol) return isSymbol;
|
|
hasRequiredIsSymbol = 1;
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
var isCallable = requireIsCallable();
|
|
var isPrototypeOf = requireObjectIsPrototypeOf();
|
|
var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
|
|
|
|
var $Object = Object;
|
|
|
|
isSymbol = USE_SYMBOL_AS_UID ? function (it) {
|
|
return typeof it == 'symbol';
|
|
} : function (it) {
|
|
var $Symbol = getBuiltIn('Symbol');
|
|
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
|
|
};
|
|
return isSymbol;
|
|
}
|
|
|
|
var tryToString;
|
|
var hasRequiredTryToString;
|
|
|
|
function requireTryToString () {
|
|
if (hasRequiredTryToString) return tryToString;
|
|
hasRequiredTryToString = 1;
|
|
var $String = String;
|
|
|
|
tryToString = function (argument) {
|
|
try {
|
|
return $String(argument);
|
|
} catch (error) {
|
|
return 'Object';
|
|
}
|
|
};
|
|
return tryToString;
|
|
}
|
|
|
|
var aCallable;
|
|
var hasRequiredACallable;
|
|
|
|
function requireACallable () {
|
|
if (hasRequiredACallable) return aCallable;
|
|
hasRequiredACallable = 1;
|
|
var isCallable = requireIsCallable();
|
|
var tryToString = requireTryToString();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `Assert: IsCallable(argument) is true`
|
|
aCallable = function (argument) {
|
|
if (isCallable(argument)) return argument;
|
|
throw new $TypeError(tryToString(argument) + ' is not a function');
|
|
};
|
|
return aCallable;
|
|
}
|
|
|
|
var getMethod;
|
|
var hasRequiredGetMethod;
|
|
|
|
function requireGetMethod () {
|
|
if (hasRequiredGetMethod) return getMethod;
|
|
hasRequiredGetMethod = 1;
|
|
var aCallable = requireACallable();
|
|
var isNullOrUndefined = requireIsNullOrUndefined();
|
|
|
|
// `GetMethod` abstract operation
|
|
// https://tc39.es/ecma262/#sec-getmethod
|
|
getMethod = function (V, P) {
|
|
var func = V[P];
|
|
return isNullOrUndefined(func) ? undefined : aCallable(func);
|
|
};
|
|
return getMethod;
|
|
}
|
|
|
|
var ordinaryToPrimitive;
|
|
var hasRequiredOrdinaryToPrimitive;
|
|
|
|
function requireOrdinaryToPrimitive () {
|
|
if (hasRequiredOrdinaryToPrimitive) return ordinaryToPrimitive;
|
|
hasRequiredOrdinaryToPrimitive = 1;
|
|
var call = requireFunctionCall();
|
|
var isCallable = requireIsCallable();
|
|
var isObject = requireIsObject();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `OrdinaryToPrimitive` abstract operation
|
|
// https://tc39.es/ecma262/#sec-ordinarytoprimitive
|
|
ordinaryToPrimitive = function (input, pref) {
|
|
var fn, val;
|
|
if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
|
|
if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
|
|
if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
|
|
throw new $TypeError("Can't convert object to primitive value");
|
|
};
|
|
return ordinaryToPrimitive;
|
|
}
|
|
|
|
var sharedStore = {exports: {}};
|
|
|
|
var isPure;
|
|
var hasRequiredIsPure;
|
|
|
|
function requireIsPure () {
|
|
if (hasRequiredIsPure) return isPure;
|
|
hasRequiredIsPure = 1;
|
|
isPure = false;
|
|
return isPure;
|
|
}
|
|
|
|
var defineGlobalProperty;
|
|
var hasRequiredDefineGlobalProperty;
|
|
|
|
function requireDefineGlobalProperty () {
|
|
if (hasRequiredDefineGlobalProperty) return defineGlobalProperty;
|
|
hasRequiredDefineGlobalProperty = 1;
|
|
var globalThis = requireGlobalThis();
|
|
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
var defineProperty = Object.defineProperty;
|
|
|
|
defineGlobalProperty = function (key, value) {
|
|
try {
|
|
defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
|
|
} catch (error) {
|
|
globalThis[key] = value;
|
|
} return value;
|
|
};
|
|
return defineGlobalProperty;
|
|
}
|
|
|
|
var hasRequiredSharedStore;
|
|
|
|
function requireSharedStore () {
|
|
if (hasRequiredSharedStore) return sharedStore.exports;
|
|
hasRequiredSharedStore = 1;
|
|
var IS_PURE = requireIsPure();
|
|
var globalThis = requireGlobalThis();
|
|
var defineGlobalProperty = requireDefineGlobalProperty();
|
|
|
|
var SHARED = '__core-js_shared__';
|
|
var store = sharedStore.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
|
|
|
|
(store.versions || (store.versions = [])).push({
|
|
version: '3.40.0',
|
|
mode: IS_PURE ? 'pure' : 'global',
|
|
copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
|
|
license: 'https://github.com/zloirock/core-js/blob/v3.40.0/LICENSE',
|
|
source: 'https://github.com/zloirock/core-js'
|
|
});
|
|
return sharedStore.exports;
|
|
}
|
|
|
|
var shared;
|
|
var hasRequiredShared;
|
|
|
|
function requireShared () {
|
|
if (hasRequiredShared) return shared;
|
|
hasRequiredShared = 1;
|
|
var store = requireSharedStore();
|
|
|
|
shared = function (key, value) {
|
|
return store[key] || (store[key] = value || {});
|
|
};
|
|
return shared;
|
|
}
|
|
|
|
var toObject;
|
|
var hasRequiredToObject;
|
|
|
|
function requireToObject () {
|
|
if (hasRequiredToObject) return toObject;
|
|
hasRequiredToObject = 1;
|
|
var requireObjectCoercible = requireRequireObjectCoercible();
|
|
|
|
var $Object = Object;
|
|
|
|
// `ToObject` abstract operation
|
|
// https://tc39.es/ecma262/#sec-toobject
|
|
toObject = function (argument) {
|
|
return $Object(requireObjectCoercible(argument));
|
|
};
|
|
return toObject;
|
|
}
|
|
|
|
var hasOwnProperty_1;
|
|
var hasRequiredHasOwnProperty;
|
|
|
|
function requireHasOwnProperty () {
|
|
if (hasRequiredHasOwnProperty) return hasOwnProperty_1;
|
|
hasRequiredHasOwnProperty = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var toObject = requireToObject();
|
|
|
|
var hasOwnProperty = uncurryThis({}.hasOwnProperty);
|
|
|
|
// `HasOwnProperty` abstract operation
|
|
// https://tc39.es/ecma262/#sec-hasownproperty
|
|
// eslint-disable-next-line es/no-object-hasown -- safe
|
|
hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
|
|
return hasOwnProperty(toObject(it), key);
|
|
};
|
|
return hasOwnProperty_1;
|
|
}
|
|
|
|
var uid;
|
|
var hasRequiredUid;
|
|
|
|
function requireUid () {
|
|
if (hasRequiredUid) return uid;
|
|
hasRequiredUid = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
var id = 0;
|
|
var postfix = Math.random();
|
|
var toString = uncurryThis(1.0.toString);
|
|
|
|
uid = function (key) {
|
|
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
|
|
};
|
|
return uid;
|
|
}
|
|
|
|
var wellKnownSymbol;
|
|
var hasRequiredWellKnownSymbol;
|
|
|
|
function requireWellKnownSymbol () {
|
|
if (hasRequiredWellKnownSymbol) return wellKnownSymbol;
|
|
hasRequiredWellKnownSymbol = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var shared = requireShared();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var uid = requireUid();
|
|
var NATIVE_SYMBOL = requireSymbolConstructorDetection();
|
|
var USE_SYMBOL_AS_UID = requireUseSymbolAsUid();
|
|
|
|
var Symbol = globalThis.Symbol;
|
|
var WellKnownSymbolsStore = shared('wks');
|
|
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
|
|
|
|
wellKnownSymbol = function (name) {
|
|
if (!hasOwn(WellKnownSymbolsStore, name)) {
|
|
WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
|
|
? Symbol[name]
|
|
: createWellKnownSymbol('Symbol.' + name);
|
|
} return WellKnownSymbolsStore[name];
|
|
};
|
|
return wellKnownSymbol;
|
|
}
|
|
|
|
var toPrimitive;
|
|
var hasRequiredToPrimitive;
|
|
|
|
function requireToPrimitive () {
|
|
if (hasRequiredToPrimitive) return toPrimitive;
|
|
hasRequiredToPrimitive = 1;
|
|
var call = requireFunctionCall();
|
|
var isObject = requireIsObject();
|
|
var isSymbol = requireIsSymbol();
|
|
var getMethod = requireGetMethod();
|
|
var ordinaryToPrimitive = requireOrdinaryToPrimitive();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
|
|
var $TypeError = TypeError;
|
|
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
|
|
|
|
// `ToPrimitive` abstract operation
|
|
// https://tc39.es/ecma262/#sec-toprimitive
|
|
toPrimitive = function (input, pref) {
|
|
if (!isObject(input) || isSymbol(input)) return input;
|
|
var exoticToPrim = getMethod(input, TO_PRIMITIVE);
|
|
var result;
|
|
if (exoticToPrim) {
|
|
if (pref === undefined) pref = 'default';
|
|
result = call(exoticToPrim, input, pref);
|
|
if (!isObject(result) || isSymbol(result)) return result;
|
|
throw new $TypeError("Can't convert object to primitive value");
|
|
}
|
|
if (pref === undefined) pref = 'number';
|
|
return ordinaryToPrimitive(input, pref);
|
|
};
|
|
return toPrimitive;
|
|
}
|
|
|
|
var toPropertyKey;
|
|
var hasRequiredToPropertyKey;
|
|
|
|
function requireToPropertyKey () {
|
|
if (hasRequiredToPropertyKey) return toPropertyKey;
|
|
hasRequiredToPropertyKey = 1;
|
|
var toPrimitive = requireToPrimitive();
|
|
var isSymbol = requireIsSymbol();
|
|
|
|
// `ToPropertyKey` abstract operation
|
|
// https://tc39.es/ecma262/#sec-topropertykey
|
|
toPropertyKey = function (argument) {
|
|
var key = toPrimitive(argument, 'string');
|
|
return isSymbol(key) ? key : key + '';
|
|
};
|
|
return toPropertyKey;
|
|
}
|
|
|
|
var documentCreateElement;
|
|
var hasRequiredDocumentCreateElement;
|
|
|
|
function requireDocumentCreateElement () {
|
|
if (hasRequiredDocumentCreateElement) return documentCreateElement;
|
|
hasRequiredDocumentCreateElement = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var isObject = requireIsObject();
|
|
|
|
var document = globalThis.document;
|
|
// typeof document.createElement is 'object' in old IE
|
|
var EXISTS = isObject(document) && isObject(document.createElement);
|
|
|
|
documentCreateElement = function (it) {
|
|
return EXISTS ? document.createElement(it) : {};
|
|
};
|
|
return documentCreateElement;
|
|
}
|
|
|
|
var ie8DomDefine;
|
|
var hasRequiredIe8DomDefine;
|
|
|
|
function requireIe8DomDefine () {
|
|
if (hasRequiredIe8DomDefine) return ie8DomDefine;
|
|
hasRequiredIe8DomDefine = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var fails = requireFails();
|
|
var createElement = requireDocumentCreateElement();
|
|
|
|
// Thanks to IE8 for its funny defineProperty
|
|
ie8DomDefine = !DESCRIPTORS && !fails(function () {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
return Object.defineProperty(createElement('div'), 'a', {
|
|
get: function () { return 7; }
|
|
}).a !== 7;
|
|
});
|
|
return ie8DomDefine;
|
|
}
|
|
|
|
var hasRequiredObjectGetOwnPropertyDescriptor;
|
|
|
|
function requireObjectGetOwnPropertyDescriptor () {
|
|
if (hasRequiredObjectGetOwnPropertyDescriptor) return objectGetOwnPropertyDescriptor;
|
|
hasRequiredObjectGetOwnPropertyDescriptor = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var call = requireFunctionCall();
|
|
var propertyIsEnumerableModule = requireObjectPropertyIsEnumerable();
|
|
var createPropertyDescriptor = requireCreatePropertyDescriptor();
|
|
var toIndexedObject = requireToIndexedObject();
|
|
var toPropertyKey = requireToPropertyKey();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var IE8_DOM_DEFINE = requireIe8DomDefine();
|
|
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
|
// `Object.getOwnPropertyDescriptor` method
|
|
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
|
|
objectGetOwnPropertyDescriptor.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
|
|
O = toIndexedObject(O);
|
|
P = toPropertyKey(P);
|
|
if (IE8_DOM_DEFINE) try {
|
|
return $getOwnPropertyDescriptor(O, P);
|
|
} catch (error) { /* empty */ }
|
|
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
|
|
};
|
|
return objectGetOwnPropertyDescriptor;
|
|
}
|
|
|
|
var objectDefineProperty = {};
|
|
|
|
var v8PrototypeDefineBug;
|
|
var hasRequiredV8PrototypeDefineBug;
|
|
|
|
function requireV8PrototypeDefineBug () {
|
|
if (hasRequiredV8PrototypeDefineBug) return v8PrototypeDefineBug;
|
|
hasRequiredV8PrototypeDefineBug = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var fails = requireFails();
|
|
|
|
// V8 ~ Chrome 36-
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
|
|
v8PrototypeDefineBug = DESCRIPTORS && fails(function () {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
|
|
return Object.defineProperty(function () { /* empty */ }, 'prototype', {
|
|
value: 42,
|
|
writable: false
|
|
}).prototype !== 42;
|
|
});
|
|
return v8PrototypeDefineBug;
|
|
}
|
|
|
|
var anObject;
|
|
var hasRequiredAnObject;
|
|
|
|
function requireAnObject () {
|
|
if (hasRequiredAnObject) return anObject;
|
|
hasRequiredAnObject = 1;
|
|
var isObject = requireIsObject();
|
|
|
|
var $String = String;
|
|
var $TypeError = TypeError;
|
|
|
|
// `Assert: Type(argument) is Object`
|
|
anObject = function (argument) {
|
|
if (isObject(argument)) return argument;
|
|
throw new $TypeError($String(argument) + ' is not an object');
|
|
};
|
|
return anObject;
|
|
}
|
|
|
|
var hasRequiredObjectDefineProperty;
|
|
|
|
function requireObjectDefineProperty () {
|
|
if (hasRequiredObjectDefineProperty) return objectDefineProperty;
|
|
hasRequiredObjectDefineProperty = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var IE8_DOM_DEFINE = requireIe8DomDefine();
|
|
var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
|
|
var anObject = requireAnObject();
|
|
var toPropertyKey = requireToPropertyKey();
|
|
|
|
var $TypeError = 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 = 'configurable';
|
|
var WRITABLE = 'writable';
|
|
|
|
// `Object.defineProperty` method
|
|
// https://tc39.es/ecma262/#sec-object.defineproperty
|
|
objectDefineProperty.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
|
|
anObject(O);
|
|
P = toPropertyKey(P);
|
|
anObject(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 in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
|
|
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
|
|
writable: false
|
|
};
|
|
}
|
|
} return $defineProperty(O, P, Attributes);
|
|
} : $defineProperty : function defineProperty(O, P, Attributes) {
|
|
anObject(O);
|
|
P = toPropertyKey(P);
|
|
anObject(Attributes);
|
|
if (IE8_DOM_DEFINE) try {
|
|
return $defineProperty(O, P, Attributes);
|
|
} catch (error) { /* empty */ }
|
|
if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
|
|
if ('value' in Attributes) O[P] = Attributes.value;
|
|
return O;
|
|
};
|
|
return objectDefineProperty;
|
|
}
|
|
|
|
var createNonEnumerableProperty;
|
|
var hasRequiredCreateNonEnumerableProperty;
|
|
|
|
function requireCreateNonEnumerableProperty () {
|
|
if (hasRequiredCreateNonEnumerableProperty) return createNonEnumerableProperty;
|
|
hasRequiredCreateNonEnumerableProperty = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var definePropertyModule = requireObjectDefineProperty();
|
|
var createPropertyDescriptor = requireCreatePropertyDescriptor();
|
|
|
|
createNonEnumerableProperty = DESCRIPTORS ? function (object, key, value) {
|
|
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
|
|
} : function (object, key, value) {
|
|
object[key] = value;
|
|
return object;
|
|
};
|
|
return createNonEnumerableProperty;
|
|
}
|
|
|
|
var makeBuiltIn = {exports: {}};
|
|
|
|
var functionName;
|
|
var hasRequiredFunctionName;
|
|
|
|
function requireFunctionName () {
|
|
if (hasRequiredFunctionName) return functionName;
|
|
hasRequiredFunctionName = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var hasOwn = requireHasOwnProperty();
|
|
|
|
var FunctionPrototype = Function.prototype;
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
|
|
|
|
var EXISTS = hasOwn(FunctionPrototype, 'name');
|
|
// additional protection from minified / mangled / dropped function names
|
|
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
|
|
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
|
|
|
|
functionName = {
|
|
EXISTS: EXISTS,
|
|
PROPER: PROPER,
|
|
CONFIGURABLE: CONFIGURABLE
|
|
};
|
|
return functionName;
|
|
}
|
|
|
|
var inspectSource;
|
|
var hasRequiredInspectSource;
|
|
|
|
function requireInspectSource () {
|
|
if (hasRequiredInspectSource) return inspectSource;
|
|
hasRequiredInspectSource = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var isCallable = requireIsCallable();
|
|
var store = requireSharedStore();
|
|
|
|
var functionToString = uncurryThis(Function.toString);
|
|
|
|
// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
|
|
if (!isCallable(store.inspectSource)) {
|
|
store.inspectSource = function (it) {
|
|
return functionToString(it);
|
|
};
|
|
}
|
|
|
|
inspectSource = store.inspectSource;
|
|
return inspectSource;
|
|
}
|
|
|
|
var weakMapBasicDetection;
|
|
var hasRequiredWeakMapBasicDetection;
|
|
|
|
function requireWeakMapBasicDetection () {
|
|
if (hasRequiredWeakMapBasicDetection) return weakMapBasicDetection;
|
|
hasRequiredWeakMapBasicDetection = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var isCallable = requireIsCallable();
|
|
|
|
var WeakMap = globalThis.WeakMap;
|
|
|
|
weakMapBasicDetection = isCallable(WeakMap) && /native code/.test(String(WeakMap));
|
|
return weakMapBasicDetection;
|
|
}
|
|
|
|
var sharedKey;
|
|
var hasRequiredSharedKey;
|
|
|
|
function requireSharedKey () {
|
|
if (hasRequiredSharedKey) return sharedKey;
|
|
hasRequiredSharedKey = 1;
|
|
var shared = requireShared();
|
|
var uid = requireUid();
|
|
|
|
var keys = shared('keys');
|
|
|
|
sharedKey = function (key) {
|
|
return keys[key] || (keys[key] = uid(key));
|
|
};
|
|
return sharedKey;
|
|
}
|
|
|
|
var hiddenKeys;
|
|
var hasRequiredHiddenKeys;
|
|
|
|
function requireHiddenKeys () {
|
|
if (hasRequiredHiddenKeys) return hiddenKeys;
|
|
hasRequiredHiddenKeys = 1;
|
|
hiddenKeys = {};
|
|
return hiddenKeys;
|
|
}
|
|
|
|
var internalState;
|
|
var hasRequiredInternalState;
|
|
|
|
function requireInternalState () {
|
|
if (hasRequiredInternalState) return internalState;
|
|
hasRequiredInternalState = 1;
|
|
var NATIVE_WEAK_MAP = requireWeakMapBasicDetection();
|
|
var globalThis = requireGlobalThis();
|
|
var isObject = requireIsObject();
|
|
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var shared = requireSharedStore();
|
|
var sharedKey = requireSharedKey();
|
|
var hiddenKeys = requireHiddenKeys();
|
|
|
|
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
|
|
var TypeError = globalThis.TypeError;
|
|
var WeakMap = globalThis.WeakMap;
|
|
var set, get, has;
|
|
|
|
var enforce = function (it) {
|
|
return has(it) ? get(it) : set(it, {});
|
|
};
|
|
|
|
var getterFor = function (TYPE) {
|
|
return function (it) {
|
|
var state;
|
|
if (!isObject(it) || (state = get(it)).type !== TYPE) {
|
|
throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
|
|
} return state;
|
|
};
|
|
};
|
|
|
|
if (NATIVE_WEAK_MAP || shared.state) {
|
|
var store = shared.state || (shared.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 = function (it, metadata) {
|
|
if (store.has(it)) throw new TypeError(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('state');
|
|
hiddenKeys[STATE] = true;
|
|
set = function (it, metadata) {
|
|
if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
|
|
metadata.facade = it;
|
|
createNonEnumerableProperty(it, STATE, metadata);
|
|
return metadata;
|
|
};
|
|
get = function (it) {
|
|
return hasOwn(it, STATE) ? it[STATE] : {};
|
|
};
|
|
has = function (it) {
|
|
return hasOwn(it, STATE);
|
|
};
|
|
}
|
|
|
|
internalState = {
|
|
set: set,
|
|
get: get,
|
|
has: has,
|
|
enforce: enforce,
|
|
getterFor: getterFor
|
|
};
|
|
return internalState;
|
|
}
|
|
|
|
var hasRequiredMakeBuiltIn;
|
|
|
|
function requireMakeBuiltIn () {
|
|
if (hasRequiredMakeBuiltIn) return makeBuiltIn.exports;
|
|
hasRequiredMakeBuiltIn = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var fails = requireFails();
|
|
var isCallable = requireIsCallable();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var CONFIGURABLE_FUNCTION_NAME = requireFunctionName().CONFIGURABLE;
|
|
var inspectSource = requireInspectSource();
|
|
var InternalStateModule = requireInternalState();
|
|
|
|
var enforceInternalState = InternalStateModule.enforce;
|
|
var getInternalState = InternalStateModule.get;
|
|
var $String = String;
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
var defineProperty = Object.defineProperty;
|
|
var stringSlice = uncurryThis(''.slice);
|
|
var replace = uncurryThis(''.replace);
|
|
var join = uncurryThis([].join);
|
|
|
|
var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
|
|
return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
|
|
});
|
|
|
|
var TEMPLATE = String(String).split('String');
|
|
|
|
var makeBuiltIn$1 = makeBuiltIn.exports = function (value, name, options) {
|
|
if (stringSlice($String(name), 0, 7) === 'Symbol(') {
|
|
name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
|
|
}
|
|
if (options && options.getter) name = 'get ' + name;
|
|
if (options && options.setter) name = 'set ' + name;
|
|
if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
|
|
if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
|
|
else value.name = name;
|
|
}
|
|
if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
|
|
defineProperty(value, 'length', { value: options.arity });
|
|
}
|
|
try {
|
|
if (options && hasOwn(options, 'constructor') && options.constructor) {
|
|
if (DESCRIPTORS) defineProperty(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(state, 'source')) {
|
|
state.source = join(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$1(function toString() {
|
|
return isCallable(this) && getInternalState(this).source || inspectSource(this);
|
|
}, 'toString');
|
|
return makeBuiltIn.exports;
|
|
}
|
|
|
|
var defineBuiltIn;
|
|
var hasRequiredDefineBuiltIn;
|
|
|
|
function requireDefineBuiltIn () {
|
|
if (hasRequiredDefineBuiltIn) return defineBuiltIn;
|
|
hasRequiredDefineBuiltIn = 1;
|
|
var isCallable = requireIsCallable();
|
|
var definePropertyModule = requireObjectDefineProperty();
|
|
var makeBuiltIn = requireMakeBuiltIn();
|
|
var defineGlobalProperty = requireDefineGlobalProperty();
|
|
|
|
defineBuiltIn = function (O, key, value, options) {
|
|
if (!options) options = {};
|
|
var simple = options.enumerable;
|
|
var name = options.name !== undefined ? options.name : key;
|
|
if (isCallable(value)) makeBuiltIn(value, name, options);
|
|
if (options.global) {
|
|
if (simple) O[key] = value;
|
|
else defineGlobalProperty(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.f(O, key, {
|
|
value: value,
|
|
enumerable: false,
|
|
configurable: !options.nonConfigurable,
|
|
writable: !options.nonWritable
|
|
});
|
|
} return O;
|
|
};
|
|
return defineBuiltIn;
|
|
}
|
|
|
|
var objectGetOwnPropertyNames = {};
|
|
|
|
var mathTrunc;
|
|
var hasRequiredMathTrunc;
|
|
|
|
function requireMathTrunc () {
|
|
if (hasRequiredMathTrunc) return mathTrunc;
|
|
hasRequiredMathTrunc = 1;
|
|
var ceil = Math.ceil;
|
|
var floor = Math.floor;
|
|
|
|
// `Math.trunc` method
|
|
// https://tc39.es/ecma262/#sec-math.trunc
|
|
// eslint-disable-next-line es/no-math-trunc -- safe
|
|
mathTrunc = Math.trunc || function trunc(x) {
|
|
var n = +x;
|
|
return (n > 0 ? floor : ceil)(n);
|
|
};
|
|
return mathTrunc;
|
|
}
|
|
|
|
var toIntegerOrInfinity;
|
|
var hasRequiredToIntegerOrInfinity;
|
|
|
|
function requireToIntegerOrInfinity () {
|
|
if (hasRequiredToIntegerOrInfinity) return toIntegerOrInfinity;
|
|
hasRequiredToIntegerOrInfinity = 1;
|
|
var trunc = requireMathTrunc();
|
|
|
|
// `ToIntegerOrInfinity` abstract operation
|
|
// https://tc39.es/ecma262/#sec-tointegerorinfinity
|
|
toIntegerOrInfinity = function (argument) {
|
|
var number = +argument;
|
|
// eslint-disable-next-line no-self-compare -- NaN check
|
|
return number !== number || number === 0 ? 0 : trunc(number);
|
|
};
|
|
return toIntegerOrInfinity;
|
|
}
|
|
|
|
var toAbsoluteIndex;
|
|
var hasRequiredToAbsoluteIndex;
|
|
|
|
function requireToAbsoluteIndex () {
|
|
if (hasRequiredToAbsoluteIndex) return toAbsoluteIndex;
|
|
hasRequiredToAbsoluteIndex = 1;
|
|
var toIntegerOrInfinity = requireToIntegerOrInfinity();
|
|
|
|
var max = Math.max;
|
|
var min = 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).
|
|
toAbsoluteIndex = function (index, length) {
|
|
var integer = toIntegerOrInfinity(index);
|
|
return integer < 0 ? max(integer + length, 0) : min(integer, length);
|
|
};
|
|
return toAbsoluteIndex;
|
|
}
|
|
|
|
var toLength;
|
|
var hasRequiredToLength;
|
|
|
|
function requireToLength () {
|
|
if (hasRequiredToLength) return toLength;
|
|
hasRequiredToLength = 1;
|
|
var toIntegerOrInfinity = requireToIntegerOrInfinity();
|
|
|
|
var min = Math.min;
|
|
|
|
// `ToLength` abstract operation
|
|
// https://tc39.es/ecma262/#sec-tolength
|
|
toLength = function (argument) {
|
|
var len = toIntegerOrInfinity(argument);
|
|
return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
|
|
};
|
|
return toLength;
|
|
}
|
|
|
|
var lengthOfArrayLike;
|
|
var hasRequiredLengthOfArrayLike;
|
|
|
|
function requireLengthOfArrayLike () {
|
|
if (hasRequiredLengthOfArrayLike) return lengthOfArrayLike;
|
|
hasRequiredLengthOfArrayLike = 1;
|
|
var toLength = requireToLength();
|
|
|
|
// `LengthOfArrayLike` abstract operation
|
|
// https://tc39.es/ecma262/#sec-lengthofarraylike
|
|
lengthOfArrayLike = function (obj) {
|
|
return toLength(obj.length);
|
|
};
|
|
return lengthOfArrayLike;
|
|
}
|
|
|
|
var arrayIncludes;
|
|
var hasRequiredArrayIncludes;
|
|
|
|
function requireArrayIncludes () {
|
|
if (hasRequiredArrayIncludes) return arrayIncludes;
|
|
hasRequiredArrayIncludes = 1;
|
|
var toIndexedObject = requireToIndexedObject();
|
|
var toAbsoluteIndex = requireToAbsoluteIndex();
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
|
|
// `Array.prototype.{ indexOf, includes }` methods implementation
|
|
var createMethod = function (IS_INCLUDES) {
|
|
return function ($this, el, fromIndex) {
|
|
var O = toIndexedObject($this);
|
|
var length = lengthOfArrayLike(O);
|
|
if (length === 0) return !IS_INCLUDES && -1;
|
|
var index = toAbsoluteIndex(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;
|
|
};
|
|
};
|
|
|
|
arrayIncludes = {
|
|
// `Array.prototype.includes` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.includes
|
|
includes: createMethod(true),
|
|
// `Array.prototype.indexOf` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.indexof
|
|
indexOf: createMethod(false)
|
|
};
|
|
return arrayIncludes;
|
|
}
|
|
|
|
var objectKeysInternal;
|
|
var hasRequiredObjectKeysInternal;
|
|
|
|
function requireObjectKeysInternal () {
|
|
if (hasRequiredObjectKeysInternal) return objectKeysInternal;
|
|
hasRequiredObjectKeysInternal = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var toIndexedObject = requireToIndexedObject();
|
|
var indexOf = requireArrayIncludes().indexOf;
|
|
var hiddenKeys = requireHiddenKeys();
|
|
|
|
var push = uncurryThis([].push);
|
|
|
|
objectKeysInternal = function (object, names) {
|
|
var O = toIndexedObject(object);
|
|
var i = 0;
|
|
var result = [];
|
|
var key;
|
|
for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
|
|
// Don't enum bug & hidden keys
|
|
while (names.length > i) if (hasOwn(O, key = names[i++])) {
|
|
~indexOf(result, key) || push(result, key);
|
|
}
|
|
return result;
|
|
};
|
|
return objectKeysInternal;
|
|
}
|
|
|
|
var enumBugKeys;
|
|
var hasRequiredEnumBugKeys;
|
|
|
|
function requireEnumBugKeys () {
|
|
if (hasRequiredEnumBugKeys) return enumBugKeys;
|
|
hasRequiredEnumBugKeys = 1;
|
|
// IE8- don't enum bug keys
|
|
enumBugKeys = [
|
|
'constructor',
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'toLocaleString',
|
|
'toString',
|
|
'valueOf'
|
|
];
|
|
return enumBugKeys;
|
|
}
|
|
|
|
var hasRequiredObjectGetOwnPropertyNames;
|
|
|
|
function requireObjectGetOwnPropertyNames () {
|
|
if (hasRequiredObjectGetOwnPropertyNames) return objectGetOwnPropertyNames;
|
|
hasRequiredObjectGetOwnPropertyNames = 1;
|
|
var internalObjectKeys = requireObjectKeysInternal();
|
|
var enumBugKeys = requireEnumBugKeys();
|
|
|
|
var hiddenKeys = enumBugKeys.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(O, hiddenKeys);
|
|
};
|
|
return objectGetOwnPropertyNames;
|
|
}
|
|
|
|
var objectGetOwnPropertySymbols = {};
|
|
|
|
var hasRequiredObjectGetOwnPropertySymbols;
|
|
|
|
function requireObjectGetOwnPropertySymbols () {
|
|
if (hasRequiredObjectGetOwnPropertySymbols) return objectGetOwnPropertySymbols;
|
|
hasRequiredObjectGetOwnPropertySymbols = 1;
|
|
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
|
|
objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
|
|
return objectGetOwnPropertySymbols;
|
|
}
|
|
|
|
var ownKeys;
|
|
var hasRequiredOwnKeys;
|
|
|
|
function requireOwnKeys () {
|
|
if (hasRequiredOwnKeys) return ownKeys;
|
|
hasRequiredOwnKeys = 1;
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var getOwnPropertyNamesModule = requireObjectGetOwnPropertyNames();
|
|
var getOwnPropertySymbolsModule = requireObjectGetOwnPropertySymbols();
|
|
var anObject = requireAnObject();
|
|
|
|
var concat = uncurryThis([].concat);
|
|
|
|
// all object keys, includes non-enumerable and symbols
|
|
ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
|
|
var keys = getOwnPropertyNamesModule.f(anObject(it));
|
|
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
|
|
};
|
|
return ownKeys;
|
|
}
|
|
|
|
var copyConstructorProperties;
|
|
var hasRequiredCopyConstructorProperties;
|
|
|
|
function requireCopyConstructorProperties () {
|
|
if (hasRequiredCopyConstructorProperties) return copyConstructorProperties;
|
|
hasRequiredCopyConstructorProperties = 1;
|
|
var hasOwn = requireHasOwnProperty();
|
|
var ownKeys = requireOwnKeys();
|
|
var getOwnPropertyDescriptorModule = requireObjectGetOwnPropertyDescriptor();
|
|
var definePropertyModule = requireObjectDefineProperty();
|
|
|
|
copyConstructorProperties = function (target, source, exceptions) {
|
|
var keys = ownKeys(source);
|
|
var defineProperty = definePropertyModule.f;
|
|
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
|
|
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
|
}
|
|
}
|
|
};
|
|
return copyConstructorProperties;
|
|
}
|
|
|
|
var isForced_1;
|
|
var hasRequiredIsForced;
|
|
|
|
function requireIsForced () {
|
|
if (hasRequiredIsForced) return isForced_1;
|
|
hasRequiredIsForced = 1;
|
|
var fails = requireFails();
|
|
var isCallable = requireIsCallable();
|
|
|
|
var replacement = /#|\.prototype\./;
|
|
|
|
var isForced = function (feature, detection) {
|
|
var value = data[normalize(feature)];
|
|
return value === POLYFILL ? true
|
|
: value === NATIVE ? false
|
|
: isCallable(detection) ? fails(detection)
|
|
: !!detection;
|
|
};
|
|
|
|
var normalize = isForced.normalize = function (string) {
|
|
return String(string).replace(replacement, '.').toLowerCase();
|
|
};
|
|
|
|
var data = isForced.data = {};
|
|
var NATIVE = isForced.NATIVE = 'N';
|
|
var POLYFILL = isForced.POLYFILL = 'P';
|
|
|
|
isForced_1 = isForced;
|
|
return isForced_1;
|
|
}
|
|
|
|
var _export;
|
|
var hasRequired_export;
|
|
|
|
function require_export () {
|
|
if (hasRequired_export) return _export;
|
|
hasRequired_export = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
|
|
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
var defineGlobalProperty = requireDefineGlobalProperty();
|
|
var copyConstructorProperties = requireCopyConstructorProperties();
|
|
var isForced = requireIsForced();
|
|
|
|
/*
|
|
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
|
|
*/
|
|
_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 = globalThis;
|
|
} else if (STATIC) {
|
|
target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
|
|
} else {
|
|
target = globalThis[TARGET] && globalThis[TARGET].prototype;
|
|
}
|
|
if (target) for (key in source) {
|
|
sourceProperty = source[key];
|
|
if (options.dontCallGetSet) {
|
|
descriptor = getOwnPropertyDescriptor(target, key);
|
|
targetProperty = descriptor && descriptor.value;
|
|
} else targetProperty = target[key];
|
|
FORCED = isForced(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(sourceProperty, 'sham', true);
|
|
}
|
|
defineBuiltIn(target, key, sourceProperty, options);
|
|
}
|
|
};
|
|
return _export;
|
|
}
|
|
|
|
var isArray;
|
|
var hasRequiredIsArray;
|
|
|
|
function requireIsArray () {
|
|
if (hasRequiredIsArray) return isArray;
|
|
hasRequiredIsArray = 1;
|
|
var classof = requireClassofRaw();
|
|
|
|
// `IsArray` abstract operation
|
|
// https://tc39.es/ecma262/#sec-isarray
|
|
// eslint-disable-next-line es/no-array-isarray -- safe
|
|
isArray = Array.isArray || function isArray(argument) {
|
|
return classof(argument) === 'Array';
|
|
};
|
|
return isArray;
|
|
}
|
|
|
|
var arraySetLength;
|
|
var hasRequiredArraySetLength;
|
|
|
|
function requireArraySetLength () {
|
|
if (hasRequiredArraySetLength) return arraySetLength;
|
|
hasRequiredArraySetLength = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var isArray = requireIsArray();
|
|
|
|
var $TypeError = TypeError;
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
|
// Safari < 13 does not throw an error in this case
|
|
var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
|
|
// makes no sense without proper strict mode support
|
|
if (this !== undefined) return true;
|
|
try {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
Object.defineProperty([], 'length', { writable: false }).length = 1;
|
|
} catch (error) {
|
|
return error instanceof TypeError;
|
|
}
|
|
}();
|
|
|
|
arraySetLength = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
|
|
if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
|
|
throw new $TypeError('Cannot set read only .length');
|
|
} return O.length = length;
|
|
} : function (O, length) {
|
|
return O.length = length;
|
|
};
|
|
return arraySetLength;
|
|
}
|
|
|
|
var doesNotExceedSafeInteger;
|
|
var hasRequiredDoesNotExceedSafeInteger;
|
|
|
|
function requireDoesNotExceedSafeInteger () {
|
|
if (hasRequiredDoesNotExceedSafeInteger) return doesNotExceedSafeInteger;
|
|
hasRequiredDoesNotExceedSafeInteger = 1;
|
|
var $TypeError = TypeError;
|
|
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
|
|
|
|
doesNotExceedSafeInteger = function (it) {
|
|
if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
|
|
return it;
|
|
};
|
|
return doesNotExceedSafeInteger;
|
|
}
|
|
|
|
var hasRequiredEs_array_push;
|
|
|
|
function requireEs_array_push () {
|
|
if (hasRequiredEs_array_push) return es_array_push;
|
|
hasRequiredEs_array_push = 1;
|
|
var $ = require_export();
|
|
var toObject = requireToObject();
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
var setArrayLength = requireArraySetLength();
|
|
var doesNotExceedSafeInteger = requireDoesNotExceedSafeInteger();
|
|
var fails = requireFails();
|
|
|
|
var INCORRECT_TO_LENGTH = fails(function () {
|
|
return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
|
|
});
|
|
|
|
// V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=12681
|
|
var properErrorOnNonWritableLength = function () {
|
|
try {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
Object.defineProperty([], 'length', { writable: false }).push();
|
|
} catch (error) {
|
|
return error instanceof TypeError;
|
|
}
|
|
};
|
|
|
|
var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();
|
|
|
|
// `Array.prototype.push` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.push
|
|
$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
|
|
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
push: function push(item) {
|
|
var O = toObject(this);
|
|
var len = lengthOfArrayLike(O);
|
|
var argCount = arguments.length;
|
|
doesNotExceedSafeInteger(len + argCount);
|
|
for (var i = 0; i < argCount; i++) {
|
|
O[len] = arguments[i];
|
|
len++;
|
|
}
|
|
setArrayLength(O, len);
|
|
return len;
|
|
}
|
|
});
|
|
return es_array_push;
|
|
}
|
|
|
|
requireEs_array_push();
|
|
|
|
var es_array_toReversed = {};
|
|
|
|
var arrayToReversed;
|
|
var hasRequiredArrayToReversed;
|
|
|
|
function requireArrayToReversed () {
|
|
if (hasRequiredArrayToReversed) return arrayToReversed;
|
|
hasRequiredArrayToReversed = 1;
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
|
|
// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.toReversed
|
|
// https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.toReversed
|
|
arrayToReversed = function (O, C) {
|
|
var len = lengthOfArrayLike(O);
|
|
var A = new C(len);
|
|
var k = 0;
|
|
for (; k < len; k++) A[k] = O[len - k - 1];
|
|
return A;
|
|
};
|
|
return arrayToReversed;
|
|
}
|
|
|
|
var objectDefineProperties = {};
|
|
|
|
var objectKeys;
|
|
var hasRequiredObjectKeys;
|
|
|
|
function requireObjectKeys () {
|
|
if (hasRequiredObjectKeys) return objectKeys;
|
|
hasRequiredObjectKeys = 1;
|
|
var internalObjectKeys = requireObjectKeysInternal();
|
|
var enumBugKeys = requireEnumBugKeys();
|
|
|
|
// `Object.keys` method
|
|
// https://tc39.es/ecma262/#sec-object.keys
|
|
// eslint-disable-next-line es/no-object-keys -- safe
|
|
objectKeys = Object.keys || function keys(O) {
|
|
return internalObjectKeys(O, enumBugKeys);
|
|
};
|
|
return objectKeys;
|
|
}
|
|
|
|
var hasRequiredObjectDefineProperties;
|
|
|
|
function requireObjectDefineProperties () {
|
|
if (hasRequiredObjectDefineProperties) return objectDefineProperties;
|
|
hasRequiredObjectDefineProperties = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
|
|
var definePropertyModule = requireObjectDefineProperty();
|
|
var anObject = requireAnObject();
|
|
var toIndexedObject = requireToIndexedObject();
|
|
var objectKeys = requireObjectKeys();
|
|
|
|
// `Object.defineProperties` method
|
|
// https://tc39.es/ecma262/#sec-object.defineproperties
|
|
// eslint-disable-next-line es/no-object-defineproperties -- safe
|
|
objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
|
|
anObject(O);
|
|
var props = toIndexedObject(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;
|
|
};
|
|
return objectDefineProperties;
|
|
}
|
|
|
|
var html;
|
|
var hasRequiredHtml;
|
|
|
|
function requireHtml () {
|
|
if (hasRequiredHtml) return html;
|
|
hasRequiredHtml = 1;
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
|
|
html = getBuiltIn('document', 'documentElement');
|
|
return html;
|
|
}
|
|
|
|
var objectCreate;
|
|
var hasRequiredObjectCreate;
|
|
|
|
function requireObjectCreate () {
|
|
if (hasRequiredObjectCreate) return objectCreate;
|
|
hasRequiredObjectCreate = 1;
|
|
/* global ActiveXObject -- old IE, WSH */
|
|
var anObject = requireAnObject();
|
|
var definePropertiesModule = requireObjectDefineProperties();
|
|
var enumBugKeys = requireEnumBugKeys();
|
|
var hiddenKeys = requireHiddenKeys();
|
|
var html = requireHtml();
|
|
var documentCreateElement = requireDocumentCreateElement();
|
|
var sharedKey = requireSharedKey();
|
|
|
|
var GT = '>';
|
|
var LT = '<';
|
|
var PROTOTYPE = 'prototype';
|
|
var SCRIPT = 'script';
|
|
var IE_PROTO = sharedKey('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;
|
|
// eslint-disable-next-line no-useless-assignment -- avoid memory leak
|
|
activeXDocument = null;
|
|
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[IE_PROTO] = true;
|
|
|
|
// `Object.create` method
|
|
// https://tc39.es/ecma262/#sec-object.create
|
|
// eslint-disable-next-line es/no-object-create -- safe
|
|
objectCreate = Object.create || function create(O, Properties) {
|
|
var result;
|
|
if (O !== null) {
|
|
EmptyConstructor[PROTOTYPE] = anObject(O);
|
|
result = new EmptyConstructor();
|
|
EmptyConstructor[PROTOTYPE] = null;
|
|
// add "__proto__" for Object.getPrototypeOf polyfill
|
|
result[IE_PROTO] = O;
|
|
} else result = NullProtoObject();
|
|
return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
|
|
};
|
|
return objectCreate;
|
|
}
|
|
|
|
var addToUnscopables;
|
|
var hasRequiredAddToUnscopables;
|
|
|
|
function requireAddToUnscopables () {
|
|
if (hasRequiredAddToUnscopables) return addToUnscopables;
|
|
hasRequiredAddToUnscopables = 1;
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var create = requireObjectCreate();
|
|
var defineProperty = requireObjectDefineProperty().f;
|
|
|
|
var UNSCOPABLES = wellKnownSymbol('unscopables');
|
|
var ArrayPrototype = Array.prototype;
|
|
|
|
// Array.prototype[@@unscopables]
|
|
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
|
|
if (ArrayPrototype[UNSCOPABLES] === undefined) {
|
|
defineProperty(ArrayPrototype, UNSCOPABLES, {
|
|
configurable: true,
|
|
value: create(null)
|
|
});
|
|
}
|
|
|
|
// add a key to Array.prototype[@@unscopables]
|
|
addToUnscopables = function (key) {
|
|
ArrayPrototype[UNSCOPABLES][key] = true;
|
|
};
|
|
return addToUnscopables;
|
|
}
|
|
|
|
var hasRequiredEs_array_toReversed;
|
|
|
|
function requireEs_array_toReversed () {
|
|
if (hasRequiredEs_array_toReversed) return es_array_toReversed;
|
|
hasRequiredEs_array_toReversed = 1;
|
|
var $ = require_export();
|
|
var arrayToReversed = requireArrayToReversed();
|
|
var toIndexedObject = requireToIndexedObject();
|
|
var addToUnscopables = requireAddToUnscopables();
|
|
|
|
var $Array = Array;
|
|
|
|
// `Array.prototype.toReversed` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.toreversed
|
|
$({ target: 'Array', proto: true }, {
|
|
toReversed: function toReversed() {
|
|
return arrayToReversed(toIndexedObject(this), $Array);
|
|
}
|
|
});
|
|
|
|
addToUnscopables('toReversed');
|
|
return es_array_toReversed;
|
|
}
|
|
|
|
requireEs_array_toReversed();
|
|
|
|
var es_array_toSorted = {};
|
|
|
|
var arrayFromConstructorAndList;
|
|
var hasRequiredArrayFromConstructorAndList;
|
|
|
|
function requireArrayFromConstructorAndList () {
|
|
if (hasRequiredArrayFromConstructorAndList) return arrayFromConstructorAndList;
|
|
hasRequiredArrayFromConstructorAndList = 1;
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
|
|
arrayFromConstructorAndList = function (Constructor, list, $length) {
|
|
var index = 0;
|
|
var length = arguments.length > 2 ? $length : lengthOfArrayLike(list);
|
|
var result = new Constructor(length);
|
|
while (length > index) result[index] = list[index++];
|
|
return result;
|
|
};
|
|
return arrayFromConstructorAndList;
|
|
}
|
|
|
|
var getBuiltInPrototypeMethod;
|
|
var hasRequiredGetBuiltInPrototypeMethod;
|
|
|
|
function requireGetBuiltInPrototypeMethod () {
|
|
if (hasRequiredGetBuiltInPrototypeMethod) return getBuiltInPrototypeMethod;
|
|
hasRequiredGetBuiltInPrototypeMethod = 1;
|
|
var globalThis = requireGlobalThis();
|
|
|
|
getBuiltInPrototypeMethod = function (CONSTRUCTOR, METHOD) {
|
|
var Constructor = globalThis[CONSTRUCTOR];
|
|
var Prototype = Constructor && Constructor.prototype;
|
|
return Prototype && Prototype[METHOD];
|
|
};
|
|
return getBuiltInPrototypeMethod;
|
|
}
|
|
|
|
var hasRequiredEs_array_toSorted;
|
|
|
|
function requireEs_array_toSorted () {
|
|
if (hasRequiredEs_array_toSorted) return es_array_toSorted;
|
|
hasRequiredEs_array_toSorted = 1;
|
|
var $ = require_export();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var aCallable = requireACallable();
|
|
var toIndexedObject = requireToIndexedObject();
|
|
var arrayFromConstructorAndList = requireArrayFromConstructorAndList();
|
|
var getBuiltInPrototypeMethod = requireGetBuiltInPrototypeMethod();
|
|
var addToUnscopables = requireAddToUnscopables();
|
|
|
|
var $Array = Array;
|
|
var sort = uncurryThis(getBuiltInPrototypeMethod('Array', 'sort'));
|
|
|
|
// `Array.prototype.toSorted` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.tosorted
|
|
$({ target: 'Array', proto: true }, {
|
|
toSorted: function toSorted(compareFn) {
|
|
if (compareFn !== undefined) aCallable(compareFn);
|
|
var O = toIndexedObject(this);
|
|
var A = arrayFromConstructorAndList($Array, O);
|
|
return sort(A, compareFn);
|
|
}
|
|
});
|
|
|
|
addToUnscopables('toSorted');
|
|
return es_array_toSorted;
|
|
}
|
|
|
|
requireEs_array_toSorted();
|
|
|
|
var es_array_toSpliced = {};
|
|
|
|
var hasRequiredEs_array_toSpliced;
|
|
|
|
function requireEs_array_toSpliced () {
|
|
if (hasRequiredEs_array_toSpliced) return es_array_toSpliced;
|
|
hasRequiredEs_array_toSpliced = 1;
|
|
var $ = require_export();
|
|
var addToUnscopables = requireAddToUnscopables();
|
|
var doesNotExceedSafeInteger = requireDoesNotExceedSafeInteger();
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
var toAbsoluteIndex = requireToAbsoluteIndex();
|
|
var toIndexedObject = requireToIndexedObject();
|
|
var toIntegerOrInfinity = requireToIntegerOrInfinity();
|
|
|
|
var $Array = Array;
|
|
var max = Math.max;
|
|
var min = Math.min;
|
|
|
|
// `Array.prototype.toSpliced` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.tospliced
|
|
$({ target: 'Array', proto: true }, {
|
|
toSpliced: function toSpliced(start, deleteCount /* , ...items */) {
|
|
var O = toIndexedObject(this);
|
|
var len = lengthOfArrayLike(O);
|
|
var actualStart = toAbsoluteIndex(start, len);
|
|
var argumentsLength = arguments.length;
|
|
var k = 0;
|
|
var insertCount, actualDeleteCount, newLen, A;
|
|
if (argumentsLength === 0) {
|
|
insertCount = actualDeleteCount = 0;
|
|
} else if (argumentsLength === 1) {
|
|
insertCount = 0;
|
|
actualDeleteCount = len - actualStart;
|
|
} else {
|
|
insertCount = argumentsLength - 2;
|
|
actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart);
|
|
}
|
|
newLen = doesNotExceedSafeInteger(len + insertCount - actualDeleteCount);
|
|
A = $Array(newLen);
|
|
|
|
for (; k < actualStart; k++) A[k] = O[k];
|
|
for (; k < actualStart + insertCount; k++) A[k] = arguments[k - actualStart + 2];
|
|
for (; k < newLen; k++) A[k] = O[k + actualDeleteCount - insertCount];
|
|
|
|
return A;
|
|
}
|
|
});
|
|
|
|
addToUnscopables('toSpliced');
|
|
return es_array_toSpliced;
|
|
}
|
|
|
|
requireEs_array_toSpliced();
|
|
|
|
var es_array_unshift = {};
|
|
|
|
var deletePropertyOrThrow;
|
|
var hasRequiredDeletePropertyOrThrow;
|
|
|
|
function requireDeletePropertyOrThrow () {
|
|
if (hasRequiredDeletePropertyOrThrow) return deletePropertyOrThrow;
|
|
hasRequiredDeletePropertyOrThrow = 1;
|
|
var tryToString = requireTryToString();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
deletePropertyOrThrow = function (O, P) {
|
|
if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
|
|
};
|
|
return deletePropertyOrThrow;
|
|
}
|
|
|
|
var hasRequiredEs_array_unshift;
|
|
|
|
function requireEs_array_unshift () {
|
|
if (hasRequiredEs_array_unshift) return es_array_unshift;
|
|
hasRequiredEs_array_unshift = 1;
|
|
var $ = require_export();
|
|
var toObject = requireToObject();
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
var setArrayLength = requireArraySetLength();
|
|
var deletePropertyOrThrow = requireDeletePropertyOrThrow();
|
|
var doesNotExceedSafeInteger = requireDoesNotExceedSafeInteger();
|
|
|
|
// IE8-
|
|
var INCORRECT_RESULT = [].unshift(0) !== 1;
|
|
|
|
// V8 ~ Chrome < 71 and Safari <= 15.4, FF < 23 throws InternalError
|
|
var properErrorOnNonWritableLength = function () {
|
|
try {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
Object.defineProperty([], 'length', { writable: false }).unshift();
|
|
} catch (error) {
|
|
return error instanceof TypeError;
|
|
}
|
|
};
|
|
|
|
var FORCED = INCORRECT_RESULT || !properErrorOnNonWritableLength();
|
|
|
|
// `Array.prototype.unshift` method
|
|
// https://tc39.es/ecma262/#sec-array.prototype.unshift
|
|
$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
|
|
// eslint-disable-next-line no-unused-vars -- required for `.length`
|
|
unshift: function unshift(item) {
|
|
var O = toObject(this);
|
|
var len = lengthOfArrayLike(O);
|
|
var argCount = arguments.length;
|
|
if (argCount) {
|
|
doesNotExceedSafeInteger(len + argCount);
|
|
var k = len;
|
|
while (k--) {
|
|
var to = k + argCount;
|
|
if (k in O) O[to] = O[k];
|
|
else deletePropertyOrThrow(O, to);
|
|
}
|
|
for (var j = 0; j < argCount; j++) {
|
|
O[j] = arguments[j];
|
|
}
|
|
} return setArrayLength(O, len + argCount);
|
|
}
|
|
});
|
|
return es_array_unshift;
|
|
}
|
|
|
|
requireEs_array_unshift();
|
|
|
|
var es_arrayBuffer_detached = {};
|
|
|
|
var defineBuiltInAccessor;
|
|
var hasRequiredDefineBuiltInAccessor;
|
|
|
|
function requireDefineBuiltInAccessor () {
|
|
if (hasRequiredDefineBuiltInAccessor) return defineBuiltInAccessor;
|
|
hasRequiredDefineBuiltInAccessor = 1;
|
|
var makeBuiltIn = requireMakeBuiltIn();
|
|
var defineProperty = requireObjectDefineProperty();
|
|
|
|
defineBuiltInAccessor = function (target, name, descriptor) {
|
|
if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
|
|
if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
|
|
return defineProperty.f(target, name, descriptor);
|
|
};
|
|
return defineBuiltInAccessor;
|
|
}
|
|
|
|
var arrayBufferBasicDetection;
|
|
var hasRequiredArrayBufferBasicDetection;
|
|
|
|
function requireArrayBufferBasicDetection () {
|
|
if (hasRequiredArrayBufferBasicDetection) return arrayBufferBasicDetection;
|
|
hasRequiredArrayBufferBasicDetection = 1;
|
|
// eslint-disable-next-line es/no-typed-arrays -- safe
|
|
arrayBufferBasicDetection = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';
|
|
return arrayBufferBasicDetection;
|
|
}
|
|
|
|
var functionUncurryThisAccessor;
|
|
var hasRequiredFunctionUncurryThisAccessor;
|
|
|
|
function requireFunctionUncurryThisAccessor () {
|
|
if (hasRequiredFunctionUncurryThisAccessor) return functionUncurryThisAccessor;
|
|
hasRequiredFunctionUncurryThisAccessor = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var aCallable = requireACallable();
|
|
|
|
functionUncurryThisAccessor = function (object, key, method) {
|
|
try {
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));
|
|
} catch (error) { /* empty */ }
|
|
};
|
|
return functionUncurryThisAccessor;
|
|
}
|
|
|
|
var arrayBufferByteLength;
|
|
var hasRequiredArrayBufferByteLength;
|
|
|
|
function requireArrayBufferByteLength () {
|
|
if (hasRequiredArrayBufferByteLength) return arrayBufferByteLength;
|
|
hasRequiredArrayBufferByteLength = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var uncurryThisAccessor = requireFunctionUncurryThisAccessor();
|
|
var classof = requireClassofRaw();
|
|
|
|
var ArrayBuffer = globalThis.ArrayBuffer;
|
|
var TypeError = globalThis.TypeError;
|
|
|
|
// Includes
|
|
// - Perform ? RequireInternalSlot(O, [[ArrayBufferData]]).
|
|
// - If IsSharedArrayBuffer(O) is true, throw a TypeError exception.
|
|
arrayBufferByteLength = ArrayBuffer && uncurryThisAccessor(ArrayBuffer.prototype, 'byteLength', 'get') || function (O) {
|
|
if (classof(O) !== 'ArrayBuffer') throw new TypeError('ArrayBuffer expected');
|
|
return O.byteLength;
|
|
};
|
|
return arrayBufferByteLength;
|
|
}
|
|
|
|
var arrayBufferIsDetached;
|
|
var hasRequiredArrayBufferIsDetached;
|
|
|
|
function requireArrayBufferIsDetached () {
|
|
if (hasRequiredArrayBufferIsDetached) return arrayBufferIsDetached;
|
|
hasRequiredArrayBufferIsDetached = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var NATIVE_ARRAY_BUFFER = requireArrayBufferBasicDetection();
|
|
var arrayBufferByteLength = requireArrayBufferByteLength();
|
|
|
|
var DataView = globalThis.DataView;
|
|
|
|
arrayBufferIsDetached = function (O) {
|
|
if (!NATIVE_ARRAY_BUFFER || arrayBufferByteLength(O) !== 0) return false;
|
|
try {
|
|
// eslint-disable-next-line no-new -- thrower
|
|
new DataView(O);
|
|
return false;
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
return arrayBufferIsDetached;
|
|
}
|
|
|
|
var hasRequiredEs_arrayBuffer_detached;
|
|
|
|
function requireEs_arrayBuffer_detached () {
|
|
if (hasRequiredEs_arrayBuffer_detached) return es_arrayBuffer_detached;
|
|
hasRequiredEs_arrayBuffer_detached = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var defineBuiltInAccessor = requireDefineBuiltInAccessor();
|
|
var isDetached = requireArrayBufferIsDetached();
|
|
|
|
var ArrayBufferPrototype = ArrayBuffer.prototype;
|
|
|
|
// `ArrayBuffer.prototype.detached` getter
|
|
// https://tc39.es/ecma262/#sec-get-arraybuffer.prototype.detached
|
|
if (DESCRIPTORS && !('detached' in ArrayBufferPrototype)) {
|
|
defineBuiltInAccessor(ArrayBufferPrototype, 'detached', {
|
|
configurable: true,
|
|
get: function detached() {
|
|
return isDetached(this);
|
|
}
|
|
});
|
|
}
|
|
return es_arrayBuffer_detached;
|
|
}
|
|
|
|
requireEs_arrayBuffer_detached();
|
|
|
|
var es_arrayBuffer_transfer = {};
|
|
|
|
var toIndex;
|
|
var hasRequiredToIndex;
|
|
|
|
function requireToIndex () {
|
|
if (hasRequiredToIndex) return toIndex;
|
|
hasRequiredToIndex = 1;
|
|
var toIntegerOrInfinity = requireToIntegerOrInfinity();
|
|
var toLength = requireToLength();
|
|
|
|
var $RangeError = RangeError;
|
|
|
|
// `ToIndex` abstract operation
|
|
// https://tc39.es/ecma262/#sec-toindex
|
|
toIndex = function (it) {
|
|
if (it === undefined) return 0;
|
|
var number = toIntegerOrInfinity(it);
|
|
var length = toLength(number);
|
|
if (number !== length) throw new $RangeError('Wrong length or index');
|
|
return length;
|
|
};
|
|
return toIndex;
|
|
}
|
|
|
|
var arrayBufferNotDetached;
|
|
var hasRequiredArrayBufferNotDetached;
|
|
|
|
function requireArrayBufferNotDetached () {
|
|
if (hasRequiredArrayBufferNotDetached) return arrayBufferNotDetached;
|
|
hasRequiredArrayBufferNotDetached = 1;
|
|
var isDetached = requireArrayBufferIsDetached();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
arrayBufferNotDetached = function (it) {
|
|
if (isDetached(it)) throw new $TypeError('ArrayBuffer is detached');
|
|
return it;
|
|
};
|
|
return arrayBufferNotDetached;
|
|
}
|
|
|
|
var environment;
|
|
var hasRequiredEnvironment;
|
|
|
|
function requireEnvironment () {
|
|
if (hasRequiredEnvironment) return environment;
|
|
hasRequiredEnvironment = 1;
|
|
/* global Bun, Deno -- detection */
|
|
var globalThis = requireGlobalThis();
|
|
var userAgent = requireEnvironmentUserAgent();
|
|
var classof = requireClassofRaw();
|
|
|
|
var userAgentStartsWith = function (string) {
|
|
return userAgent.slice(0, string.length) === string;
|
|
};
|
|
|
|
environment = (function () {
|
|
if (userAgentStartsWith('Bun/')) return 'BUN';
|
|
if (userAgentStartsWith('Cloudflare-Workers')) return 'CLOUDFLARE';
|
|
if (userAgentStartsWith('Deno/')) return 'DENO';
|
|
if (userAgentStartsWith('Node.js/')) return 'NODE';
|
|
if (globalThis.Bun && typeof Bun.version == 'string') return 'BUN';
|
|
if (globalThis.Deno && typeof Deno.version == 'object') return 'DENO';
|
|
if (classof(globalThis.process) === 'process') return 'NODE';
|
|
if (globalThis.window && globalThis.document) return 'BROWSER';
|
|
return 'REST';
|
|
})();
|
|
return environment;
|
|
}
|
|
|
|
var environmentIsNode;
|
|
var hasRequiredEnvironmentIsNode;
|
|
|
|
function requireEnvironmentIsNode () {
|
|
if (hasRequiredEnvironmentIsNode) return environmentIsNode;
|
|
hasRequiredEnvironmentIsNode = 1;
|
|
var ENVIRONMENT = requireEnvironment();
|
|
|
|
environmentIsNode = ENVIRONMENT === 'NODE';
|
|
return environmentIsNode;
|
|
}
|
|
|
|
var getBuiltInNodeModule;
|
|
var hasRequiredGetBuiltInNodeModule;
|
|
|
|
function requireGetBuiltInNodeModule () {
|
|
if (hasRequiredGetBuiltInNodeModule) return getBuiltInNodeModule;
|
|
hasRequiredGetBuiltInNodeModule = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var IS_NODE = requireEnvironmentIsNode();
|
|
|
|
getBuiltInNodeModule = function (name) {
|
|
if (IS_NODE) {
|
|
try {
|
|
return globalThis.process.getBuiltinModule(name);
|
|
} catch (error) { /* empty */ }
|
|
try {
|
|
// eslint-disable-next-line no-new-func -- safe
|
|
return Function('return require("' + name + '")')();
|
|
} catch (error) { /* empty */ }
|
|
}
|
|
};
|
|
return getBuiltInNodeModule;
|
|
}
|
|
|
|
var structuredCloneProperTransfer;
|
|
var hasRequiredStructuredCloneProperTransfer;
|
|
|
|
function requireStructuredCloneProperTransfer () {
|
|
if (hasRequiredStructuredCloneProperTransfer) return structuredCloneProperTransfer;
|
|
hasRequiredStructuredCloneProperTransfer = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var fails = requireFails();
|
|
var V8 = requireEnvironmentV8Version();
|
|
var ENVIRONMENT = requireEnvironment();
|
|
|
|
var structuredClone = globalThis.structuredClone;
|
|
|
|
structuredCloneProperTransfer = !!structuredClone && !fails(function () {
|
|
// prevent V8 ArrayBufferDetaching protector cell invalidation and performance degradation
|
|
// https://github.com/zloirock/core-js/issues/679
|
|
if ((ENVIRONMENT === 'DENO' && V8 > 92) || (ENVIRONMENT === 'NODE' && V8 > 94) || (ENVIRONMENT === 'BROWSER' && V8 > 97)) return false;
|
|
var buffer = new ArrayBuffer(8);
|
|
var clone = structuredClone(buffer, { transfer: [buffer] });
|
|
return buffer.byteLength !== 0 || clone.byteLength !== 8;
|
|
});
|
|
return structuredCloneProperTransfer;
|
|
}
|
|
|
|
var detachTransferable;
|
|
var hasRequiredDetachTransferable;
|
|
|
|
function requireDetachTransferable () {
|
|
if (hasRequiredDetachTransferable) return detachTransferable;
|
|
hasRequiredDetachTransferable = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var getBuiltInNodeModule = requireGetBuiltInNodeModule();
|
|
var PROPER_STRUCTURED_CLONE_TRANSFER = requireStructuredCloneProperTransfer();
|
|
|
|
var structuredClone = globalThis.structuredClone;
|
|
var $ArrayBuffer = globalThis.ArrayBuffer;
|
|
var $MessageChannel = globalThis.MessageChannel;
|
|
var detach = false;
|
|
var WorkerThreads, channel, buffer, $detach;
|
|
|
|
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
|
detach = function (transferable) {
|
|
structuredClone(transferable, { transfer: [transferable] });
|
|
};
|
|
} else if ($ArrayBuffer) try {
|
|
if (!$MessageChannel) {
|
|
WorkerThreads = getBuiltInNodeModule('worker_threads');
|
|
if (WorkerThreads) $MessageChannel = WorkerThreads.MessageChannel;
|
|
}
|
|
|
|
if ($MessageChannel) {
|
|
channel = new $MessageChannel();
|
|
buffer = new $ArrayBuffer(2);
|
|
|
|
$detach = function (transferable) {
|
|
channel.port1.postMessage(null, [transferable]);
|
|
};
|
|
|
|
if (buffer.byteLength === 2) {
|
|
$detach(buffer);
|
|
if (buffer.byteLength === 0) detach = $detach;
|
|
}
|
|
}
|
|
} catch (error) { /* empty */ }
|
|
|
|
detachTransferable = detach;
|
|
return detachTransferable;
|
|
}
|
|
|
|
var arrayBufferTransfer;
|
|
var hasRequiredArrayBufferTransfer;
|
|
|
|
function requireArrayBufferTransfer () {
|
|
if (hasRequiredArrayBufferTransfer) return arrayBufferTransfer;
|
|
hasRequiredArrayBufferTransfer = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var uncurryThisAccessor = requireFunctionUncurryThisAccessor();
|
|
var toIndex = requireToIndex();
|
|
var notDetached = requireArrayBufferNotDetached();
|
|
var arrayBufferByteLength = requireArrayBufferByteLength();
|
|
var detachTransferable = requireDetachTransferable();
|
|
var PROPER_STRUCTURED_CLONE_TRANSFER = requireStructuredCloneProperTransfer();
|
|
|
|
var structuredClone = globalThis.structuredClone;
|
|
var ArrayBuffer = globalThis.ArrayBuffer;
|
|
var DataView = globalThis.DataView;
|
|
var min = Math.min;
|
|
var ArrayBufferPrototype = ArrayBuffer.prototype;
|
|
var DataViewPrototype = DataView.prototype;
|
|
var slice = uncurryThis(ArrayBufferPrototype.slice);
|
|
var isResizable = uncurryThisAccessor(ArrayBufferPrototype, 'resizable', 'get');
|
|
var maxByteLength = uncurryThisAccessor(ArrayBufferPrototype, 'maxByteLength', 'get');
|
|
var getInt8 = uncurryThis(DataViewPrototype.getInt8);
|
|
var setInt8 = uncurryThis(DataViewPrototype.setInt8);
|
|
|
|
arrayBufferTransfer = (PROPER_STRUCTURED_CLONE_TRANSFER || detachTransferable) && function (arrayBuffer, newLength, preserveResizability) {
|
|
var byteLength = arrayBufferByteLength(arrayBuffer);
|
|
var newByteLength = newLength === undefined ? byteLength : toIndex(newLength);
|
|
var fixedLength = !isResizable || !isResizable(arrayBuffer);
|
|
var newBuffer;
|
|
notDetached(arrayBuffer);
|
|
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
|
arrayBuffer = structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
|
|
if (byteLength === newByteLength && (preserveResizability || fixedLength)) return arrayBuffer;
|
|
}
|
|
if (byteLength >= newByteLength && (!preserveResizability || fixedLength)) {
|
|
newBuffer = slice(arrayBuffer, 0, newByteLength);
|
|
} else {
|
|
var options = preserveResizability && !fixedLength && maxByteLength ? { maxByteLength: maxByteLength(arrayBuffer) } : undefined;
|
|
newBuffer = new ArrayBuffer(newByteLength, options);
|
|
var a = new DataView(arrayBuffer);
|
|
var b = new DataView(newBuffer);
|
|
var copyLength = min(newByteLength, byteLength);
|
|
for (var i = 0; i < copyLength; i++) setInt8(b, i, getInt8(a, i));
|
|
}
|
|
if (!PROPER_STRUCTURED_CLONE_TRANSFER) detachTransferable(arrayBuffer);
|
|
return newBuffer;
|
|
};
|
|
return arrayBufferTransfer;
|
|
}
|
|
|
|
var hasRequiredEs_arrayBuffer_transfer;
|
|
|
|
function requireEs_arrayBuffer_transfer () {
|
|
if (hasRequiredEs_arrayBuffer_transfer) return es_arrayBuffer_transfer;
|
|
hasRequiredEs_arrayBuffer_transfer = 1;
|
|
var $ = require_export();
|
|
var $transfer = requireArrayBufferTransfer();
|
|
|
|
// `ArrayBuffer.prototype.transfer` method
|
|
// https://tc39.es/proposal-arraybuffer-transfer/#sec-arraybuffer.prototype.transfer
|
|
if ($transfer) $({ target: 'ArrayBuffer', proto: true }, {
|
|
transfer: function transfer() {
|
|
return $transfer(this, arguments.length ? arguments[0] : undefined, true);
|
|
}
|
|
});
|
|
return es_arrayBuffer_transfer;
|
|
}
|
|
|
|
requireEs_arrayBuffer_transfer();
|
|
|
|
var es_arrayBuffer_transferToFixedLength = {};
|
|
|
|
var hasRequiredEs_arrayBuffer_transferToFixedLength;
|
|
|
|
function requireEs_arrayBuffer_transferToFixedLength () {
|
|
if (hasRequiredEs_arrayBuffer_transferToFixedLength) return es_arrayBuffer_transferToFixedLength;
|
|
hasRequiredEs_arrayBuffer_transferToFixedLength = 1;
|
|
var $ = require_export();
|
|
var $transfer = requireArrayBufferTransfer();
|
|
|
|
// `ArrayBuffer.prototype.transferToFixedLength` method
|
|
// https://tc39.es/proposal-arraybuffer-transfer/#sec-arraybuffer.prototype.transfertofixedlength
|
|
if ($transfer) $({ target: 'ArrayBuffer', proto: true }, {
|
|
transferToFixedLength: function transferToFixedLength() {
|
|
return $transfer(this, arguments.length ? arguments[0] : undefined, false);
|
|
}
|
|
});
|
|
return es_arrayBuffer_transferToFixedLength;
|
|
}
|
|
|
|
requireEs_arrayBuffer_transferToFixedLength();
|
|
|
|
var es_iterator_constructor = {};
|
|
|
|
var anInstance;
|
|
var hasRequiredAnInstance;
|
|
|
|
function requireAnInstance () {
|
|
if (hasRequiredAnInstance) return anInstance;
|
|
hasRequiredAnInstance = 1;
|
|
var isPrototypeOf = requireObjectIsPrototypeOf();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
anInstance = function (it, Prototype) {
|
|
if (isPrototypeOf(Prototype, it)) return it;
|
|
throw new $TypeError('Incorrect invocation');
|
|
};
|
|
return anInstance;
|
|
}
|
|
|
|
var correctPrototypeGetter;
|
|
var hasRequiredCorrectPrototypeGetter;
|
|
|
|
function requireCorrectPrototypeGetter () {
|
|
if (hasRequiredCorrectPrototypeGetter) return correctPrototypeGetter;
|
|
hasRequiredCorrectPrototypeGetter = 1;
|
|
var fails = requireFails();
|
|
|
|
correctPrototypeGetter = !fails(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;
|
|
});
|
|
return correctPrototypeGetter;
|
|
}
|
|
|
|
var objectGetPrototypeOf;
|
|
var hasRequiredObjectGetPrototypeOf;
|
|
|
|
function requireObjectGetPrototypeOf () {
|
|
if (hasRequiredObjectGetPrototypeOf) return objectGetPrototypeOf;
|
|
hasRequiredObjectGetPrototypeOf = 1;
|
|
var hasOwn = requireHasOwnProperty();
|
|
var isCallable = requireIsCallable();
|
|
var toObject = requireToObject();
|
|
var sharedKey = requireSharedKey();
|
|
var CORRECT_PROTOTYPE_GETTER = requireCorrectPrototypeGetter();
|
|
|
|
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
|
|
objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
|
|
var object = toObject(O);
|
|
if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
|
|
var constructor = object.constructor;
|
|
if (isCallable(constructor) && object instanceof constructor) {
|
|
return constructor.prototype;
|
|
} return object instanceof $Object ? ObjectPrototype : null;
|
|
};
|
|
return objectGetPrototypeOf;
|
|
}
|
|
|
|
var createProperty;
|
|
var hasRequiredCreateProperty;
|
|
|
|
function requireCreateProperty () {
|
|
if (hasRequiredCreateProperty) return createProperty;
|
|
hasRequiredCreateProperty = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var definePropertyModule = requireObjectDefineProperty();
|
|
var createPropertyDescriptor = requireCreatePropertyDescriptor();
|
|
|
|
createProperty = function (object, key, value) {
|
|
if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
|
|
else object[key] = value;
|
|
};
|
|
return createProperty;
|
|
}
|
|
|
|
var iteratorsCore;
|
|
var hasRequiredIteratorsCore;
|
|
|
|
function requireIteratorsCore () {
|
|
if (hasRequiredIteratorsCore) return iteratorsCore;
|
|
hasRequiredIteratorsCore = 1;
|
|
var fails = requireFails();
|
|
var isCallable = requireIsCallable();
|
|
var isObject = requireIsObject();
|
|
var create = requireObjectCreate();
|
|
var getPrototypeOf = requireObjectGetPrototypeOf();
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var BUGGY_SAFARI_ITERATORS = false;
|
|
|
|
// `%IteratorPrototype%` object
|
|
// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
|
|
var IteratorPrototype, 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 = true;
|
|
else {
|
|
PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
|
|
if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
|
|
}
|
|
}
|
|
|
|
var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {
|
|
var test = {};
|
|
// FF44- legacy iterators case
|
|
return IteratorPrototype[ITERATOR].call(test) !== test;
|
|
});
|
|
|
|
if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
|
|
else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
|
|
|
|
// `%IteratorPrototype%[@@iterator]()` method
|
|
// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
|
|
if (!isCallable(IteratorPrototype[ITERATOR])) {
|
|
defineBuiltIn(IteratorPrototype, ITERATOR, function () {
|
|
return this;
|
|
});
|
|
}
|
|
|
|
iteratorsCore = {
|
|
IteratorPrototype: IteratorPrototype,
|
|
BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
|
|
};
|
|
return iteratorsCore;
|
|
}
|
|
|
|
var hasRequiredEs_iterator_constructor;
|
|
|
|
function requireEs_iterator_constructor () {
|
|
if (hasRequiredEs_iterator_constructor) return es_iterator_constructor;
|
|
hasRequiredEs_iterator_constructor = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var anInstance = requireAnInstance();
|
|
var anObject = requireAnObject();
|
|
var isCallable = requireIsCallable();
|
|
var getPrototypeOf = requireObjectGetPrototypeOf();
|
|
var defineBuiltInAccessor = requireDefineBuiltInAccessor();
|
|
var createProperty = requireCreateProperty();
|
|
var fails = requireFails();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var IteratorPrototype = requireIteratorsCore().IteratorPrototype;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var CONSTRUCTOR = 'constructor';
|
|
var ITERATOR = 'Iterator';
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
|
|
var $TypeError = TypeError;
|
|
var NativeIterator = globalThis[ITERATOR];
|
|
|
|
// FF56- have non-standard global helper `Iterator`
|
|
var FORCED = IS_PURE
|
|
|| !isCallable(NativeIterator)
|
|
|| NativeIterator.prototype !== IteratorPrototype
|
|
// FF44- non-standard `Iterator` passes previous tests
|
|
|| !fails(function () { NativeIterator({}); });
|
|
|
|
var IteratorConstructor = function Iterator() {
|
|
anInstance(this, IteratorPrototype);
|
|
if (getPrototypeOf(this) === IteratorPrototype) throw new $TypeError('Abstract class Iterator not directly constructable');
|
|
};
|
|
|
|
var defineIteratorPrototypeAccessor = function (key, value) {
|
|
if (DESCRIPTORS) {
|
|
defineBuiltInAccessor(IteratorPrototype, key, {
|
|
configurable: true,
|
|
get: function () {
|
|
return value;
|
|
},
|
|
set: function (replacement) {
|
|
anObject(this);
|
|
if (this === IteratorPrototype) throw new $TypeError("You can't redefine this property");
|
|
if (hasOwn(this, key)) this[key] = replacement;
|
|
else createProperty(this, key, replacement);
|
|
}
|
|
});
|
|
} else IteratorPrototype[key] = value;
|
|
};
|
|
|
|
if (!hasOwn(IteratorPrototype, TO_STRING_TAG)) defineIteratorPrototypeAccessor(TO_STRING_TAG, ITERATOR);
|
|
|
|
if (FORCED || !hasOwn(IteratorPrototype, CONSTRUCTOR) || IteratorPrototype[CONSTRUCTOR] === Object) {
|
|
defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor);
|
|
}
|
|
|
|
IteratorConstructor.prototype = IteratorPrototype;
|
|
|
|
// `Iterator` constructor
|
|
// https://tc39.es/ecma262/#sec-iterator
|
|
$({ global: true, constructor: true, forced: FORCED }, {
|
|
Iterator: IteratorConstructor
|
|
});
|
|
return es_iterator_constructor;
|
|
}
|
|
|
|
requireEs_iterator_constructor();
|
|
|
|
var es_iterator_drop = {};
|
|
|
|
var getIteratorDirect;
|
|
var hasRequiredGetIteratorDirect;
|
|
|
|
function requireGetIteratorDirect () {
|
|
if (hasRequiredGetIteratorDirect) return getIteratorDirect;
|
|
hasRequiredGetIteratorDirect = 1;
|
|
// `GetIteratorDirect(obj)` abstract operation
|
|
// https://tc39.es/proposal-iterator-helpers/#sec-getiteratordirect
|
|
getIteratorDirect = function (obj) {
|
|
return {
|
|
iterator: obj,
|
|
next: obj.next,
|
|
done: false
|
|
};
|
|
};
|
|
return getIteratorDirect;
|
|
}
|
|
|
|
var notANan;
|
|
var hasRequiredNotANan;
|
|
|
|
function requireNotANan () {
|
|
if (hasRequiredNotANan) return notANan;
|
|
hasRequiredNotANan = 1;
|
|
var $RangeError = RangeError;
|
|
|
|
notANan = function (it) {
|
|
// eslint-disable-next-line no-self-compare -- NaN check
|
|
if (it === it) return it;
|
|
throw new $RangeError('NaN is not allowed');
|
|
};
|
|
return notANan;
|
|
}
|
|
|
|
var toPositiveInteger;
|
|
var hasRequiredToPositiveInteger;
|
|
|
|
function requireToPositiveInteger () {
|
|
if (hasRequiredToPositiveInteger) return toPositiveInteger;
|
|
hasRequiredToPositiveInteger = 1;
|
|
var toIntegerOrInfinity = requireToIntegerOrInfinity();
|
|
|
|
var $RangeError = RangeError;
|
|
|
|
toPositiveInteger = function (it) {
|
|
var result = toIntegerOrInfinity(it);
|
|
if (result < 0) throw new $RangeError("The argument can't be less than 0");
|
|
return result;
|
|
};
|
|
return toPositiveInteger;
|
|
}
|
|
|
|
var defineBuiltIns;
|
|
var hasRequiredDefineBuiltIns;
|
|
|
|
function requireDefineBuiltIns () {
|
|
if (hasRequiredDefineBuiltIns) return defineBuiltIns;
|
|
hasRequiredDefineBuiltIns = 1;
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
|
|
defineBuiltIns = function (target, src, options) {
|
|
for (var key in src) defineBuiltIn(target, key, src[key], options);
|
|
return target;
|
|
};
|
|
return defineBuiltIns;
|
|
}
|
|
|
|
var createIterResultObject;
|
|
var hasRequiredCreateIterResultObject;
|
|
|
|
function requireCreateIterResultObject () {
|
|
if (hasRequiredCreateIterResultObject) return createIterResultObject;
|
|
hasRequiredCreateIterResultObject = 1;
|
|
// `CreateIterResultObject` abstract operation
|
|
// https://tc39.es/ecma262/#sec-createiterresultobject
|
|
createIterResultObject = function (value, done) {
|
|
return { value: value, done: done };
|
|
};
|
|
return createIterResultObject;
|
|
}
|
|
|
|
var iteratorClose;
|
|
var hasRequiredIteratorClose;
|
|
|
|
function requireIteratorClose () {
|
|
if (hasRequiredIteratorClose) return iteratorClose;
|
|
hasRequiredIteratorClose = 1;
|
|
var call = requireFunctionCall();
|
|
var anObject = requireAnObject();
|
|
var getMethod = requireGetMethod();
|
|
|
|
iteratorClose = function (iterator, kind, value) {
|
|
var innerResult, innerError;
|
|
anObject(iterator);
|
|
try {
|
|
innerResult = getMethod(iterator, 'return');
|
|
if (!innerResult) {
|
|
if (kind === 'throw') throw value;
|
|
return value;
|
|
}
|
|
innerResult = call(innerResult, iterator);
|
|
} catch (error) {
|
|
innerError = true;
|
|
innerResult = error;
|
|
}
|
|
if (kind === 'throw') throw value;
|
|
if (innerError) throw innerResult;
|
|
anObject(innerResult);
|
|
return value;
|
|
};
|
|
return iteratorClose;
|
|
}
|
|
|
|
var iteratorCreateProxy;
|
|
var hasRequiredIteratorCreateProxy;
|
|
|
|
function requireIteratorCreateProxy () {
|
|
if (hasRequiredIteratorCreateProxy) return iteratorCreateProxy;
|
|
hasRequiredIteratorCreateProxy = 1;
|
|
var call = requireFunctionCall();
|
|
var create = requireObjectCreate();
|
|
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
|
|
var defineBuiltIns = requireDefineBuiltIns();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var InternalStateModule = requireInternalState();
|
|
var getMethod = requireGetMethod();
|
|
var IteratorPrototype = requireIteratorsCore().IteratorPrototype;
|
|
var createIterResultObject = requireCreateIterResultObject();
|
|
var iteratorClose = requireIteratorClose();
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
var ITERATOR_HELPER = 'IteratorHelper';
|
|
var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
|
|
var setInternalState = InternalStateModule.set;
|
|
|
|
var createIteratorProxyPrototype = function (IS_ITERATOR) {
|
|
var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
|
|
|
|
return defineBuiltIns(create(IteratorPrototype), {
|
|
next: function next() {
|
|
var state = getInternalState(this);
|
|
// for simplification:
|
|
// for `%WrapForValidIteratorPrototype%.next` or with `state.returnHandlerResult` our `nextHandler` returns `IterResultObject`
|
|
// for `%IteratorHelperPrototype%.next` - just a value
|
|
if (IS_ITERATOR) return state.nextHandler();
|
|
if (state.done) return createIterResultObject(undefined, true);
|
|
try {
|
|
var result = state.nextHandler();
|
|
return state.returnHandlerResult ? result : createIterResultObject(result, state.done);
|
|
} catch (error) {
|
|
state.done = true;
|
|
throw error;
|
|
}
|
|
},
|
|
'return': function () {
|
|
var state = getInternalState(this);
|
|
var iterator = state.iterator;
|
|
state.done = true;
|
|
if (IS_ITERATOR) {
|
|
var returnMethod = getMethod(iterator, 'return');
|
|
return returnMethod ? call(returnMethod, iterator) : createIterResultObject(undefined, true);
|
|
}
|
|
if (state.inner) try {
|
|
iteratorClose(state.inner.iterator, 'normal');
|
|
} catch (error) {
|
|
return iteratorClose(iterator, 'throw', error);
|
|
}
|
|
if (iterator) iteratorClose(iterator, 'normal');
|
|
return createIterResultObject(undefined, true);
|
|
}
|
|
});
|
|
};
|
|
|
|
var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
|
|
var IteratorHelperPrototype = createIteratorProxyPrototype(false);
|
|
|
|
createNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper');
|
|
|
|
iteratorCreateProxy = function (nextHandler, IS_ITERATOR, RETURN_HANDLER_RESULT) {
|
|
var IteratorProxy = function Iterator(record, state) {
|
|
if (state) {
|
|
state.iterator = record.iterator;
|
|
state.next = record.next;
|
|
} else state = record;
|
|
state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
|
|
state.returnHandlerResult = !!RETURN_HANDLER_RESULT;
|
|
state.nextHandler = nextHandler;
|
|
state.counter = 0;
|
|
state.done = false;
|
|
setInternalState(this, state);
|
|
};
|
|
|
|
IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
|
|
|
|
return IteratorProxy;
|
|
};
|
|
return iteratorCreateProxy;
|
|
}
|
|
|
|
var hasRequiredEs_iterator_drop;
|
|
|
|
function requireEs_iterator_drop () {
|
|
if (hasRequiredEs_iterator_drop) return es_iterator_drop;
|
|
hasRequiredEs_iterator_drop = 1;
|
|
var $ = require_export();
|
|
var call = requireFunctionCall();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
var notANaN = requireNotANan();
|
|
var toPositiveInteger = requireToPositiveInteger();
|
|
var createIteratorProxy = requireIteratorCreateProxy();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var IteratorProxy = createIteratorProxy(function () {
|
|
var iterator = this.iterator;
|
|
var next = this.next;
|
|
var result, done;
|
|
while (this.remaining) {
|
|
this.remaining--;
|
|
result = anObject(call(next, iterator));
|
|
done = this.done = !!result.done;
|
|
if (done) return;
|
|
}
|
|
result = anObject(call(next, iterator));
|
|
done = this.done = !!result.done;
|
|
if (!done) return result.value;
|
|
});
|
|
|
|
// `Iterator.prototype.drop` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.drop
|
|
$({ target: 'Iterator', proto: true, real: true, forced: IS_PURE }, {
|
|
drop: function drop(limit) {
|
|
anObject(this);
|
|
var remaining = toPositiveInteger(notANaN(+limit));
|
|
return new IteratorProxy(getIteratorDirect(this), {
|
|
remaining: remaining
|
|
});
|
|
}
|
|
});
|
|
return es_iterator_drop;
|
|
}
|
|
|
|
requireEs_iterator_drop();
|
|
|
|
var es_iterator_every = {};
|
|
|
|
var functionUncurryThisClause;
|
|
var hasRequiredFunctionUncurryThisClause;
|
|
|
|
function requireFunctionUncurryThisClause () {
|
|
if (hasRequiredFunctionUncurryThisClause) return functionUncurryThisClause;
|
|
hasRequiredFunctionUncurryThisClause = 1;
|
|
var classofRaw = requireClassofRaw();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
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(fn);
|
|
};
|
|
return functionUncurryThisClause;
|
|
}
|
|
|
|
var functionBindContext;
|
|
var hasRequiredFunctionBindContext;
|
|
|
|
function requireFunctionBindContext () {
|
|
if (hasRequiredFunctionBindContext) return functionBindContext;
|
|
hasRequiredFunctionBindContext = 1;
|
|
var uncurryThis = requireFunctionUncurryThisClause();
|
|
var aCallable = requireACallable();
|
|
var NATIVE_BIND = requireFunctionBindNative();
|
|
|
|
var bind = uncurryThis(uncurryThis.bind);
|
|
|
|
// optional / simple context binding
|
|
functionBindContext = function (fn, that) {
|
|
aCallable(fn);
|
|
return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
|
|
return fn.apply(that, arguments);
|
|
};
|
|
};
|
|
return functionBindContext;
|
|
}
|
|
|
|
var iterators;
|
|
var hasRequiredIterators;
|
|
|
|
function requireIterators () {
|
|
if (hasRequiredIterators) return iterators;
|
|
hasRequiredIterators = 1;
|
|
iterators = {};
|
|
return iterators;
|
|
}
|
|
|
|
var isArrayIteratorMethod;
|
|
var hasRequiredIsArrayIteratorMethod;
|
|
|
|
function requireIsArrayIteratorMethod () {
|
|
if (hasRequiredIsArrayIteratorMethod) return isArrayIteratorMethod;
|
|
hasRequiredIsArrayIteratorMethod = 1;
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var Iterators = requireIterators();
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var ArrayPrototype = Array.prototype;
|
|
|
|
// check on default Array iterator
|
|
isArrayIteratorMethod = function (it) {
|
|
return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
|
|
};
|
|
return isArrayIteratorMethod;
|
|
}
|
|
|
|
var toStringTagSupport;
|
|
var hasRequiredToStringTagSupport;
|
|
|
|
function requireToStringTagSupport () {
|
|
if (hasRequiredToStringTagSupport) return toStringTagSupport;
|
|
hasRequiredToStringTagSupport = 1;
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
var test = {};
|
|
|
|
test[TO_STRING_TAG] = 'z';
|
|
|
|
toStringTagSupport = String(test) === '[object z]';
|
|
return toStringTagSupport;
|
|
}
|
|
|
|
var classof;
|
|
var hasRequiredClassof;
|
|
|
|
function requireClassof () {
|
|
if (hasRequiredClassof) return classof;
|
|
hasRequiredClassof = 1;
|
|
var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
|
|
var isCallable = requireIsCallable();
|
|
var classofRaw = requireClassofRaw();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
var $Object = Object;
|
|
|
|
// ES3 wrong here
|
|
var CORRECT_ARGUMENTS = classofRaw(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`
|
|
classof = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
|
|
var O, tag, result;
|
|
return it === undefined ? 'Undefined' : it === null ? 'Null'
|
|
// @@toStringTag case
|
|
: typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
|
|
// builtinTag case
|
|
: CORRECT_ARGUMENTS ? classofRaw(O)
|
|
// ES3 arguments fallback
|
|
: (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
|
|
};
|
|
return classof;
|
|
}
|
|
|
|
var getIteratorMethod;
|
|
var hasRequiredGetIteratorMethod;
|
|
|
|
function requireGetIteratorMethod () {
|
|
if (hasRequiredGetIteratorMethod) return getIteratorMethod;
|
|
hasRequiredGetIteratorMethod = 1;
|
|
var classof = requireClassof();
|
|
var getMethod = requireGetMethod();
|
|
var isNullOrUndefined = requireIsNullOrUndefined();
|
|
var Iterators = requireIterators();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
|
|
getIteratorMethod = function (it) {
|
|
if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
|
|
|| getMethod(it, '@@iterator')
|
|
|| Iterators[classof(it)];
|
|
};
|
|
return getIteratorMethod;
|
|
}
|
|
|
|
var getIterator;
|
|
var hasRequiredGetIterator;
|
|
|
|
function requireGetIterator () {
|
|
if (hasRequiredGetIterator) return getIterator;
|
|
hasRequiredGetIterator = 1;
|
|
var call = requireFunctionCall();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var tryToString = requireTryToString();
|
|
var getIteratorMethod = requireGetIteratorMethod();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
getIterator = function (argument, usingIterator) {
|
|
var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
|
|
if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
|
|
throw new $TypeError(tryToString(argument) + ' is not iterable');
|
|
};
|
|
return getIterator;
|
|
}
|
|
|
|
var iterate;
|
|
var hasRequiredIterate;
|
|
|
|
function requireIterate () {
|
|
if (hasRequiredIterate) return iterate;
|
|
hasRequiredIterate = 1;
|
|
var bind = requireFunctionBindContext();
|
|
var call = requireFunctionCall();
|
|
var anObject = requireAnObject();
|
|
var tryToString = requireTryToString();
|
|
var isArrayIteratorMethod = requireIsArrayIteratorMethod();
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
var isPrototypeOf = requireObjectIsPrototypeOf();
|
|
var getIterator = requireGetIterator();
|
|
var getIteratorMethod = requireGetIteratorMethod();
|
|
var iteratorClose = requireIteratorClose();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
var Result = function (stopped, result) {
|
|
this.stopped = stopped;
|
|
this.result = result;
|
|
};
|
|
|
|
var ResultPrototype = Result.prototype;
|
|
|
|
iterate = 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(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(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(iterable);
|
|
if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
|
|
// optimisation for array iterators
|
|
if (isArrayIteratorMethod(iterFn)) {
|
|
for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
|
|
result = callFn(iterable[index]);
|
|
if (result && isPrototypeOf(ResultPrototype, result)) return result;
|
|
} return new Result(false);
|
|
}
|
|
iterator = getIterator(iterable, iterFn);
|
|
}
|
|
|
|
next = IS_RECORD ? iterable.next : iterator.next;
|
|
while (!(step = call(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);
|
|
};
|
|
return iterate;
|
|
}
|
|
|
|
var hasRequiredEs_iterator_every;
|
|
|
|
function requireEs_iterator_every () {
|
|
if (hasRequiredEs_iterator_every) return es_iterator_every;
|
|
hasRequiredEs_iterator_every = 1;
|
|
var $ = require_export();
|
|
var iterate = requireIterate();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
|
|
// `Iterator.prototype.every` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.every
|
|
$({ target: 'Iterator', proto: true, real: true }, {
|
|
every: function every(predicate) {
|
|
anObject(this);
|
|
aCallable(predicate);
|
|
var record = getIteratorDirect(this);
|
|
var counter = 0;
|
|
return !iterate(record, function (value, stop) {
|
|
if (!predicate(value, counter++)) return stop();
|
|
}, { IS_RECORD: true, INTERRUPTED: true }).stopped;
|
|
}
|
|
});
|
|
return es_iterator_every;
|
|
}
|
|
|
|
requireEs_iterator_every();
|
|
|
|
var es_iterator_filter = {};
|
|
|
|
var callWithSafeIterationClosing;
|
|
var hasRequiredCallWithSafeIterationClosing;
|
|
|
|
function requireCallWithSafeIterationClosing () {
|
|
if (hasRequiredCallWithSafeIterationClosing) return callWithSafeIterationClosing;
|
|
hasRequiredCallWithSafeIterationClosing = 1;
|
|
var anObject = requireAnObject();
|
|
var iteratorClose = requireIteratorClose();
|
|
|
|
// call something on iterator step with safe closing on error
|
|
callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) {
|
|
try {
|
|
return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
|
|
} catch (error) {
|
|
iteratorClose(iterator, 'throw', error);
|
|
}
|
|
};
|
|
return callWithSafeIterationClosing;
|
|
}
|
|
|
|
var hasRequiredEs_iterator_filter;
|
|
|
|
function requireEs_iterator_filter () {
|
|
if (hasRequiredEs_iterator_filter) return es_iterator_filter;
|
|
hasRequiredEs_iterator_filter = 1;
|
|
var $ = require_export();
|
|
var call = requireFunctionCall();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
var createIteratorProxy = requireIteratorCreateProxy();
|
|
var callWithSafeIterationClosing = requireCallWithSafeIterationClosing();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var IteratorProxy = createIteratorProxy(function () {
|
|
var iterator = this.iterator;
|
|
var predicate = this.predicate;
|
|
var next = this.next;
|
|
var result, done, value;
|
|
while (true) {
|
|
result = anObject(call(next, iterator));
|
|
done = this.done = !!result.done;
|
|
if (done) return;
|
|
value = result.value;
|
|
if (callWithSafeIterationClosing(iterator, predicate, [value, this.counter++], true)) return value;
|
|
}
|
|
});
|
|
|
|
// `Iterator.prototype.filter` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.filter
|
|
$({ target: 'Iterator', proto: true, real: true, forced: IS_PURE }, {
|
|
filter: function filter(predicate) {
|
|
anObject(this);
|
|
aCallable(predicate);
|
|
return new IteratorProxy(getIteratorDirect(this), {
|
|
predicate: predicate
|
|
});
|
|
}
|
|
});
|
|
return es_iterator_filter;
|
|
}
|
|
|
|
requireEs_iterator_filter();
|
|
|
|
var es_iterator_find = {};
|
|
|
|
var hasRequiredEs_iterator_find;
|
|
|
|
function requireEs_iterator_find () {
|
|
if (hasRequiredEs_iterator_find) return es_iterator_find;
|
|
hasRequiredEs_iterator_find = 1;
|
|
var $ = require_export();
|
|
var iterate = requireIterate();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
|
|
// `Iterator.prototype.find` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.find
|
|
$({ target: 'Iterator', proto: true, real: true }, {
|
|
find: function find(predicate) {
|
|
anObject(this);
|
|
aCallable(predicate);
|
|
var record = getIteratorDirect(this);
|
|
var counter = 0;
|
|
return iterate(record, function (value, stop) {
|
|
if (predicate(value, counter++)) return stop(value);
|
|
}, { IS_RECORD: true, INTERRUPTED: true }).result;
|
|
}
|
|
});
|
|
return es_iterator_find;
|
|
}
|
|
|
|
requireEs_iterator_find();
|
|
|
|
var es_iterator_flatMap = {};
|
|
|
|
var getIteratorFlattenable;
|
|
var hasRequiredGetIteratorFlattenable;
|
|
|
|
function requireGetIteratorFlattenable () {
|
|
if (hasRequiredGetIteratorFlattenable) return getIteratorFlattenable;
|
|
hasRequiredGetIteratorFlattenable = 1;
|
|
var call = requireFunctionCall();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
var getIteratorMethod = requireGetIteratorMethod();
|
|
|
|
getIteratorFlattenable = function (obj, stringHandling) {
|
|
if (!stringHandling || typeof obj !== 'string') anObject(obj);
|
|
var method = getIteratorMethod(obj);
|
|
return getIteratorDirect(anObject(method !== undefined ? call(method, obj) : obj));
|
|
};
|
|
return getIteratorFlattenable;
|
|
}
|
|
|
|
var hasRequiredEs_iterator_flatMap;
|
|
|
|
function requireEs_iterator_flatMap () {
|
|
if (hasRequiredEs_iterator_flatMap) return es_iterator_flatMap;
|
|
hasRequiredEs_iterator_flatMap = 1;
|
|
var $ = require_export();
|
|
var call = requireFunctionCall();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
var getIteratorFlattenable = requireGetIteratorFlattenable();
|
|
var createIteratorProxy = requireIteratorCreateProxy();
|
|
var iteratorClose = requireIteratorClose();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var IteratorProxy = createIteratorProxy(function () {
|
|
var iterator = this.iterator;
|
|
var mapper = this.mapper;
|
|
var result, inner;
|
|
|
|
while (true) {
|
|
if (inner = this.inner) try {
|
|
result = anObject(call(inner.next, inner.iterator));
|
|
if (!result.done) return result.value;
|
|
this.inner = null;
|
|
} catch (error) { iteratorClose(iterator, 'throw', error); }
|
|
|
|
result = anObject(call(this.next, iterator));
|
|
|
|
if (this.done = !!result.done) return;
|
|
|
|
try {
|
|
this.inner = getIteratorFlattenable(mapper(result.value, this.counter++), false);
|
|
} catch (error) { iteratorClose(iterator, 'throw', error); }
|
|
}
|
|
});
|
|
|
|
// `Iterator.prototype.flatMap` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.flatmap
|
|
$({ target: 'Iterator', proto: true, real: true, forced: IS_PURE }, {
|
|
flatMap: function flatMap(mapper) {
|
|
anObject(this);
|
|
aCallable(mapper);
|
|
return new IteratorProxy(getIteratorDirect(this), {
|
|
mapper: mapper,
|
|
inner: null
|
|
});
|
|
}
|
|
});
|
|
return es_iterator_flatMap;
|
|
}
|
|
|
|
requireEs_iterator_flatMap();
|
|
|
|
var es_iterator_forEach = {};
|
|
|
|
var hasRequiredEs_iterator_forEach;
|
|
|
|
function requireEs_iterator_forEach () {
|
|
if (hasRequiredEs_iterator_forEach) return es_iterator_forEach;
|
|
hasRequiredEs_iterator_forEach = 1;
|
|
var $ = require_export();
|
|
var iterate = requireIterate();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
|
|
// `Iterator.prototype.forEach` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.foreach
|
|
$({ target: 'Iterator', proto: true, real: true }, {
|
|
forEach: function forEach(fn) {
|
|
anObject(this);
|
|
aCallable(fn);
|
|
var record = getIteratorDirect(this);
|
|
var counter = 0;
|
|
iterate(record, function (value) {
|
|
fn(value, counter++);
|
|
}, { IS_RECORD: true });
|
|
}
|
|
});
|
|
return es_iterator_forEach;
|
|
}
|
|
|
|
requireEs_iterator_forEach();
|
|
|
|
var es_iterator_map = {};
|
|
|
|
var iteratorMap;
|
|
var hasRequiredIteratorMap;
|
|
|
|
function requireIteratorMap () {
|
|
if (hasRequiredIteratorMap) return iteratorMap;
|
|
hasRequiredIteratorMap = 1;
|
|
var call = requireFunctionCall();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
var createIteratorProxy = requireIteratorCreateProxy();
|
|
var callWithSafeIterationClosing = requireCallWithSafeIterationClosing();
|
|
|
|
var IteratorProxy = createIteratorProxy(function () {
|
|
var iterator = this.iterator;
|
|
var result = anObject(call(this.next, iterator));
|
|
var done = this.done = !!result.done;
|
|
if (!done) return callWithSafeIterationClosing(iterator, this.mapper, [result.value, this.counter++], true);
|
|
});
|
|
|
|
// `Iterator.prototype.map` method
|
|
// https://github.com/tc39/proposal-iterator-helpers
|
|
iteratorMap = function map(mapper) {
|
|
anObject(this);
|
|
aCallable(mapper);
|
|
return new IteratorProxy(getIteratorDirect(this), {
|
|
mapper: mapper
|
|
});
|
|
};
|
|
return iteratorMap;
|
|
}
|
|
|
|
var hasRequiredEs_iterator_map;
|
|
|
|
function requireEs_iterator_map () {
|
|
if (hasRequiredEs_iterator_map) return es_iterator_map;
|
|
hasRequiredEs_iterator_map = 1;
|
|
var $ = require_export();
|
|
var map = requireIteratorMap();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
// `Iterator.prototype.map` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.map
|
|
$({ target: 'Iterator', proto: true, real: true, forced: IS_PURE }, {
|
|
map: map
|
|
});
|
|
return es_iterator_map;
|
|
}
|
|
|
|
requireEs_iterator_map();
|
|
|
|
var es_iterator_reduce = {};
|
|
|
|
var hasRequiredEs_iterator_reduce;
|
|
|
|
function requireEs_iterator_reduce () {
|
|
if (hasRequiredEs_iterator_reduce) return es_iterator_reduce;
|
|
hasRequiredEs_iterator_reduce = 1;
|
|
var $ = require_export();
|
|
var iterate = requireIterate();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `Iterator.prototype.reduce` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.reduce
|
|
$({ target: 'Iterator', proto: true, real: true }, {
|
|
reduce: function reduce(reducer /* , initialValue */) {
|
|
anObject(this);
|
|
aCallable(reducer);
|
|
var record = getIteratorDirect(this);
|
|
var noInitial = arguments.length < 2;
|
|
var accumulator = noInitial ? undefined : arguments[1];
|
|
var counter = 0;
|
|
iterate(record, function (value) {
|
|
if (noInitial) {
|
|
noInitial = false;
|
|
accumulator = value;
|
|
} else {
|
|
accumulator = reducer(accumulator, value, counter);
|
|
}
|
|
counter++;
|
|
}, { IS_RECORD: true });
|
|
if (noInitial) throw new $TypeError('Reduce of empty iterator with no initial value');
|
|
return accumulator;
|
|
}
|
|
});
|
|
return es_iterator_reduce;
|
|
}
|
|
|
|
requireEs_iterator_reduce();
|
|
|
|
var es_iterator_some = {};
|
|
|
|
var hasRequiredEs_iterator_some;
|
|
|
|
function requireEs_iterator_some () {
|
|
if (hasRequiredEs_iterator_some) return es_iterator_some;
|
|
hasRequiredEs_iterator_some = 1;
|
|
var $ = require_export();
|
|
var iterate = requireIterate();
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
|
|
// `Iterator.prototype.some` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.some
|
|
$({ target: 'Iterator', proto: true, real: true }, {
|
|
some: function some(predicate) {
|
|
anObject(this);
|
|
aCallable(predicate);
|
|
var record = getIteratorDirect(this);
|
|
var counter = 0;
|
|
return iterate(record, function (value, stop) {
|
|
if (predicate(value, counter++)) return stop();
|
|
}, { IS_RECORD: true, INTERRUPTED: true }).stopped;
|
|
}
|
|
});
|
|
return es_iterator_some;
|
|
}
|
|
|
|
requireEs_iterator_some();
|
|
|
|
var es_iterator_toArray = {};
|
|
|
|
var hasRequiredEs_iterator_toArray;
|
|
|
|
function requireEs_iterator_toArray () {
|
|
if (hasRequiredEs_iterator_toArray) return es_iterator_toArray;
|
|
hasRequiredEs_iterator_toArray = 1;
|
|
var $ = require_export();
|
|
var anObject = requireAnObject();
|
|
var iterate = requireIterate();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
|
|
var push = [].push;
|
|
|
|
// `Iterator.prototype.toArray` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.toarray
|
|
$({ target: 'Iterator', proto: true, real: true }, {
|
|
toArray: function toArray() {
|
|
var result = [];
|
|
iterate(getIteratorDirect(anObject(this)), push, { that: result, IS_RECORD: true });
|
|
return result;
|
|
}
|
|
});
|
|
return es_iterator_toArray;
|
|
}
|
|
|
|
requireEs_iterator_toArray();
|
|
|
|
var es_regexp_flags = {};
|
|
|
|
var regexpFlags;
|
|
var hasRequiredRegexpFlags;
|
|
|
|
function requireRegexpFlags () {
|
|
if (hasRequiredRegexpFlags) return regexpFlags;
|
|
hasRequiredRegexpFlags = 1;
|
|
var anObject = requireAnObject();
|
|
|
|
// `RegExp.prototype.flags` getter implementation
|
|
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
|
|
regexpFlags = function () {
|
|
var that = anObject(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;
|
|
};
|
|
return regexpFlags;
|
|
}
|
|
|
|
var hasRequiredEs_regexp_flags;
|
|
|
|
function requireEs_regexp_flags () {
|
|
if (hasRequiredEs_regexp_flags) return es_regexp_flags;
|
|
hasRequiredEs_regexp_flags = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var defineBuiltInAccessor = requireDefineBuiltInAccessor();
|
|
var regExpFlags = requireRegexpFlags();
|
|
var fails = requireFails();
|
|
|
|
// babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
|
|
var RegExp = globalThis.RegExp;
|
|
var RegExpPrototype = RegExp.prototype;
|
|
|
|
var FORCED = DESCRIPTORS && fails(function () {
|
|
var INDICES_SUPPORT = true;
|
|
try {
|
|
RegExp('.', 'd');
|
|
} catch (error) {
|
|
INDICES_SUPPORT = false;
|
|
}
|
|
|
|
var O = {};
|
|
// modern V8 bug
|
|
var calls = '';
|
|
var expected = INDICES_SUPPORT ? 'dgimsy' : 'gimsy';
|
|
|
|
var addGetter = function (key, chr) {
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
Object.defineProperty(O, key, { get: function () {
|
|
calls += chr;
|
|
return true;
|
|
} });
|
|
};
|
|
|
|
var pairs = {
|
|
dotAll: 's',
|
|
global: 'g',
|
|
ignoreCase: 'i',
|
|
multiline: 'm',
|
|
sticky: 'y'
|
|
};
|
|
|
|
if (INDICES_SUPPORT) pairs.hasIndices = 'd';
|
|
|
|
for (var key in pairs) addGetter(key, pairs[key]);
|
|
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var result = Object.getOwnPropertyDescriptor(RegExpPrototype, 'flags').get.call(O);
|
|
|
|
return result !== expected || calls !== expected;
|
|
});
|
|
|
|
// `RegExp.prototype.flags` getter
|
|
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
|
|
if (FORCED) defineBuiltInAccessor(RegExpPrototype, 'flags', {
|
|
configurable: true,
|
|
get: regExpFlags
|
|
});
|
|
return es_regexp_flags;
|
|
}
|
|
|
|
requireEs_regexp_flags();
|
|
|
|
var es_set_difference_v2 = {};
|
|
|
|
var setHelpers;
|
|
var hasRequiredSetHelpers;
|
|
|
|
function requireSetHelpers () {
|
|
if (hasRequiredSetHelpers) return setHelpers;
|
|
hasRequiredSetHelpers = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
// eslint-disable-next-line es/no-set -- safe
|
|
var SetPrototype = Set.prototype;
|
|
|
|
setHelpers = {
|
|
// eslint-disable-next-line es/no-set -- safe
|
|
Set: Set,
|
|
add: uncurryThis(SetPrototype.add),
|
|
has: uncurryThis(SetPrototype.has),
|
|
remove: uncurryThis(SetPrototype['delete']),
|
|
proto: SetPrototype
|
|
};
|
|
return setHelpers;
|
|
}
|
|
|
|
var aSet;
|
|
var hasRequiredASet;
|
|
|
|
function requireASet () {
|
|
if (hasRequiredASet) return aSet;
|
|
hasRequiredASet = 1;
|
|
var has = requireSetHelpers().has;
|
|
|
|
// Perform ? RequireInternalSlot(M, [[SetData]])
|
|
aSet = function (it) {
|
|
has(it);
|
|
return it;
|
|
};
|
|
return aSet;
|
|
}
|
|
|
|
var iterateSimple;
|
|
var hasRequiredIterateSimple;
|
|
|
|
function requireIterateSimple () {
|
|
if (hasRequiredIterateSimple) return iterateSimple;
|
|
hasRequiredIterateSimple = 1;
|
|
var call = requireFunctionCall();
|
|
|
|
iterateSimple = function (record, fn, ITERATOR_INSTEAD_OF_RECORD) {
|
|
var iterator = ITERATOR_INSTEAD_OF_RECORD ? record : record.iterator;
|
|
var next = record.next;
|
|
var step, result;
|
|
while (!(step = call(next, iterator)).done) {
|
|
result = fn(step.value);
|
|
if (result !== undefined) return result;
|
|
}
|
|
};
|
|
return iterateSimple;
|
|
}
|
|
|
|
var setIterate;
|
|
var hasRequiredSetIterate;
|
|
|
|
function requireSetIterate () {
|
|
if (hasRequiredSetIterate) return setIterate;
|
|
hasRequiredSetIterate = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var iterateSimple = requireIterateSimple();
|
|
var SetHelpers = requireSetHelpers();
|
|
|
|
var Set = SetHelpers.Set;
|
|
var SetPrototype = SetHelpers.proto;
|
|
var forEach = uncurryThis(SetPrototype.forEach);
|
|
var keys = uncurryThis(SetPrototype.keys);
|
|
var next = keys(new Set()).next;
|
|
|
|
setIterate = function (set, fn, interruptible) {
|
|
return interruptible ? iterateSimple({ iterator: keys(set), next: next }, fn) : forEach(set, fn);
|
|
};
|
|
return setIterate;
|
|
}
|
|
|
|
var setClone;
|
|
var hasRequiredSetClone;
|
|
|
|
function requireSetClone () {
|
|
if (hasRequiredSetClone) return setClone;
|
|
hasRequiredSetClone = 1;
|
|
var SetHelpers = requireSetHelpers();
|
|
var iterate = requireSetIterate();
|
|
|
|
var Set = SetHelpers.Set;
|
|
var add = SetHelpers.add;
|
|
|
|
setClone = function (set) {
|
|
var result = new Set();
|
|
iterate(set, function (it) {
|
|
add(result, it);
|
|
});
|
|
return result;
|
|
};
|
|
return setClone;
|
|
}
|
|
|
|
var setSize;
|
|
var hasRequiredSetSize;
|
|
|
|
function requireSetSize () {
|
|
if (hasRequiredSetSize) return setSize;
|
|
hasRequiredSetSize = 1;
|
|
var uncurryThisAccessor = requireFunctionUncurryThisAccessor();
|
|
var SetHelpers = requireSetHelpers();
|
|
|
|
setSize = uncurryThisAccessor(SetHelpers.proto, 'size', 'get') || function (set) {
|
|
return set.size;
|
|
};
|
|
return setSize;
|
|
}
|
|
|
|
var getSetRecord;
|
|
var hasRequiredGetSetRecord;
|
|
|
|
function requireGetSetRecord () {
|
|
if (hasRequiredGetSetRecord) return getSetRecord;
|
|
hasRequiredGetSetRecord = 1;
|
|
var aCallable = requireACallable();
|
|
var anObject = requireAnObject();
|
|
var call = requireFunctionCall();
|
|
var toIntegerOrInfinity = requireToIntegerOrInfinity();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
|
|
var INVALID_SIZE = 'Invalid size';
|
|
var $RangeError = RangeError;
|
|
var $TypeError = TypeError;
|
|
var max = Math.max;
|
|
|
|
var SetRecord = function (set, intSize) {
|
|
this.set = set;
|
|
this.size = max(intSize, 0);
|
|
this.has = aCallable(set.has);
|
|
this.keys = aCallable(set.keys);
|
|
};
|
|
|
|
SetRecord.prototype = {
|
|
getIterator: function () {
|
|
return getIteratorDirect(anObject(call(this.keys, this.set)));
|
|
},
|
|
includes: function (it) {
|
|
return call(this.has, this.set, it);
|
|
}
|
|
};
|
|
|
|
// `GetSetRecord` abstract operation
|
|
// https://tc39.es/proposal-set-methods/#sec-getsetrecord
|
|
getSetRecord = function (obj) {
|
|
anObject(obj);
|
|
var numSize = +obj.size;
|
|
// NOTE: If size is undefined, then numSize will be NaN
|
|
// eslint-disable-next-line no-self-compare -- NaN check
|
|
if (numSize !== numSize) throw new $TypeError(INVALID_SIZE);
|
|
var intSize = toIntegerOrInfinity(numSize);
|
|
if (intSize < 0) throw new $RangeError(INVALID_SIZE);
|
|
return new SetRecord(obj, intSize);
|
|
};
|
|
return getSetRecord;
|
|
}
|
|
|
|
var setDifference;
|
|
var hasRequiredSetDifference;
|
|
|
|
function requireSetDifference () {
|
|
if (hasRequiredSetDifference) return setDifference;
|
|
hasRequiredSetDifference = 1;
|
|
var aSet = requireASet();
|
|
var SetHelpers = requireSetHelpers();
|
|
var clone = requireSetClone();
|
|
var size = requireSetSize();
|
|
var getSetRecord = requireGetSetRecord();
|
|
var iterateSet = requireSetIterate();
|
|
var iterateSimple = requireIterateSimple();
|
|
|
|
var has = SetHelpers.has;
|
|
var remove = SetHelpers.remove;
|
|
|
|
// `Set.prototype.difference` method
|
|
// https://github.com/tc39/proposal-set-methods
|
|
setDifference = function difference(other) {
|
|
var O = aSet(this);
|
|
var otherRec = getSetRecord(other);
|
|
var result = clone(O);
|
|
if (size(O) <= otherRec.size) iterateSet(O, function (e) {
|
|
if (otherRec.includes(e)) remove(result, e);
|
|
});
|
|
else iterateSimple(otherRec.getIterator(), function (e) {
|
|
if (has(O, e)) remove(result, e);
|
|
});
|
|
return result;
|
|
};
|
|
return setDifference;
|
|
}
|
|
|
|
var setMethodAcceptSetLike;
|
|
var hasRequiredSetMethodAcceptSetLike;
|
|
|
|
function requireSetMethodAcceptSetLike () {
|
|
if (hasRequiredSetMethodAcceptSetLike) return setMethodAcceptSetLike;
|
|
hasRequiredSetMethodAcceptSetLike = 1;
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
|
|
var createSetLike = function (size) {
|
|
return {
|
|
size: size,
|
|
has: function () {
|
|
return false;
|
|
},
|
|
keys: function () {
|
|
return {
|
|
next: function () {
|
|
return { done: true };
|
|
}
|
|
};
|
|
}
|
|
};
|
|
};
|
|
|
|
var createSetLikeWithInfinitySize = function (size) {
|
|
return {
|
|
size: size,
|
|
has: function () {
|
|
return true;
|
|
},
|
|
keys: function () {
|
|
throw new Error('e');
|
|
}
|
|
};
|
|
};
|
|
|
|
setMethodAcceptSetLike = function (name, callback) {
|
|
var Set = getBuiltIn('Set');
|
|
try {
|
|
new Set()[name](createSetLike(0));
|
|
try {
|
|
// late spec change, early WebKit ~ Safari 17.0 beta implementation does not pass it
|
|
// https://github.com/tc39/proposal-set-methods/pull/88
|
|
new Set()[name](createSetLike(-1));
|
|
return false;
|
|
} catch (error2) {
|
|
if (!callback) return true;
|
|
// early V8 implementation bug
|
|
// https://issues.chromium.org/issues/351332634
|
|
try {
|
|
new Set()[name](createSetLikeWithInfinitySize(-Infinity));
|
|
return false;
|
|
} catch (error) {
|
|
var set = new Set();
|
|
set.add(1);
|
|
set.add(2);
|
|
return callback(set[name](createSetLikeWithInfinitySize(Infinity)));
|
|
}
|
|
}
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
};
|
|
return setMethodAcceptSetLike;
|
|
}
|
|
|
|
var hasRequiredEs_set_difference_v2;
|
|
|
|
function requireEs_set_difference_v2 () {
|
|
if (hasRequiredEs_set_difference_v2) return es_set_difference_v2;
|
|
hasRequiredEs_set_difference_v2 = 1;
|
|
var $ = require_export();
|
|
var difference = requireSetDifference();
|
|
var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
|
|
|
|
var INCORRECT = !setMethodAcceptSetLike('difference', function (result) {
|
|
return result.size === 0;
|
|
});
|
|
|
|
// `Set.prototype.difference` method
|
|
// https://tc39.es/ecma262/#sec-set.prototype.difference
|
|
$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
|
|
difference: difference
|
|
});
|
|
return es_set_difference_v2;
|
|
}
|
|
|
|
requireEs_set_difference_v2();
|
|
|
|
var es_set_intersection_v2 = {};
|
|
|
|
var setIntersection;
|
|
var hasRequiredSetIntersection;
|
|
|
|
function requireSetIntersection () {
|
|
if (hasRequiredSetIntersection) return setIntersection;
|
|
hasRequiredSetIntersection = 1;
|
|
var aSet = requireASet();
|
|
var SetHelpers = requireSetHelpers();
|
|
var size = requireSetSize();
|
|
var getSetRecord = requireGetSetRecord();
|
|
var iterateSet = requireSetIterate();
|
|
var iterateSimple = requireIterateSimple();
|
|
|
|
var Set = SetHelpers.Set;
|
|
var add = SetHelpers.add;
|
|
var has = SetHelpers.has;
|
|
|
|
// `Set.prototype.intersection` method
|
|
// https://github.com/tc39/proposal-set-methods
|
|
setIntersection = function intersection(other) {
|
|
var O = aSet(this);
|
|
var otherRec = getSetRecord(other);
|
|
var result = new Set();
|
|
|
|
if (size(O) > otherRec.size) {
|
|
iterateSimple(otherRec.getIterator(), function (e) {
|
|
if (has(O, e)) add(result, e);
|
|
});
|
|
} else {
|
|
iterateSet(O, function (e) {
|
|
if (otherRec.includes(e)) add(result, e);
|
|
});
|
|
}
|
|
|
|
return result;
|
|
};
|
|
return setIntersection;
|
|
}
|
|
|
|
var hasRequiredEs_set_intersection_v2;
|
|
|
|
function requireEs_set_intersection_v2 () {
|
|
if (hasRequiredEs_set_intersection_v2) return es_set_intersection_v2;
|
|
hasRequiredEs_set_intersection_v2 = 1;
|
|
var $ = require_export();
|
|
var fails = requireFails();
|
|
var intersection = requireSetIntersection();
|
|
var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
|
|
|
|
var INCORRECT = !setMethodAcceptSetLike('intersection', function (result) {
|
|
return result.size === 2 && result.has(1) && result.has(2);
|
|
}) || fails(function () {
|
|
// eslint-disable-next-line es/no-array-from, es/no-set, es/no-set-prototype-intersection -- testing
|
|
return String(Array.from(new Set([1, 2, 3]).intersection(new Set([3, 2])))) !== '3,2';
|
|
});
|
|
|
|
// `Set.prototype.intersection` method
|
|
// https://tc39.es/ecma262/#sec-set.prototype.intersection
|
|
$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
|
|
intersection: intersection
|
|
});
|
|
return es_set_intersection_v2;
|
|
}
|
|
|
|
requireEs_set_intersection_v2();
|
|
|
|
var es_set_isDisjointFrom_v2 = {};
|
|
|
|
var setIsDisjointFrom;
|
|
var hasRequiredSetIsDisjointFrom;
|
|
|
|
function requireSetIsDisjointFrom () {
|
|
if (hasRequiredSetIsDisjointFrom) return setIsDisjointFrom;
|
|
hasRequiredSetIsDisjointFrom = 1;
|
|
var aSet = requireASet();
|
|
var has = requireSetHelpers().has;
|
|
var size = requireSetSize();
|
|
var getSetRecord = requireGetSetRecord();
|
|
var iterateSet = requireSetIterate();
|
|
var iterateSimple = requireIterateSimple();
|
|
var iteratorClose = requireIteratorClose();
|
|
|
|
// `Set.prototype.isDisjointFrom` method
|
|
// https://tc39.github.io/proposal-set-methods/#Set.prototype.isDisjointFrom
|
|
setIsDisjointFrom = function isDisjointFrom(other) {
|
|
var O = aSet(this);
|
|
var otherRec = getSetRecord(other);
|
|
if (size(O) <= otherRec.size) return iterateSet(O, function (e) {
|
|
if (otherRec.includes(e)) return false;
|
|
}, true) !== false;
|
|
var iterator = otherRec.getIterator();
|
|
return iterateSimple(iterator, function (e) {
|
|
if (has(O, e)) return iteratorClose(iterator, 'normal', false);
|
|
}) !== false;
|
|
};
|
|
return setIsDisjointFrom;
|
|
}
|
|
|
|
var hasRequiredEs_set_isDisjointFrom_v2;
|
|
|
|
function requireEs_set_isDisjointFrom_v2 () {
|
|
if (hasRequiredEs_set_isDisjointFrom_v2) return es_set_isDisjointFrom_v2;
|
|
hasRequiredEs_set_isDisjointFrom_v2 = 1;
|
|
var $ = require_export();
|
|
var isDisjointFrom = requireSetIsDisjointFrom();
|
|
var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
|
|
|
|
var INCORRECT = !setMethodAcceptSetLike('isDisjointFrom', function (result) {
|
|
return !result;
|
|
});
|
|
|
|
// `Set.prototype.isDisjointFrom` method
|
|
// https://tc39.es/ecma262/#sec-set.prototype.isdisjointfrom
|
|
$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
|
|
isDisjointFrom: isDisjointFrom
|
|
});
|
|
return es_set_isDisjointFrom_v2;
|
|
}
|
|
|
|
requireEs_set_isDisjointFrom_v2();
|
|
|
|
var es_set_isSubsetOf_v2 = {};
|
|
|
|
var setIsSubsetOf;
|
|
var hasRequiredSetIsSubsetOf;
|
|
|
|
function requireSetIsSubsetOf () {
|
|
if (hasRequiredSetIsSubsetOf) return setIsSubsetOf;
|
|
hasRequiredSetIsSubsetOf = 1;
|
|
var aSet = requireASet();
|
|
var size = requireSetSize();
|
|
var iterate = requireSetIterate();
|
|
var getSetRecord = requireGetSetRecord();
|
|
|
|
// `Set.prototype.isSubsetOf` method
|
|
// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSubsetOf
|
|
setIsSubsetOf = function isSubsetOf(other) {
|
|
var O = aSet(this);
|
|
var otherRec = getSetRecord(other);
|
|
if (size(O) > otherRec.size) return false;
|
|
return iterate(O, function (e) {
|
|
if (!otherRec.includes(e)) return false;
|
|
}, true) !== false;
|
|
};
|
|
return setIsSubsetOf;
|
|
}
|
|
|
|
var hasRequiredEs_set_isSubsetOf_v2;
|
|
|
|
function requireEs_set_isSubsetOf_v2 () {
|
|
if (hasRequiredEs_set_isSubsetOf_v2) return es_set_isSubsetOf_v2;
|
|
hasRequiredEs_set_isSubsetOf_v2 = 1;
|
|
var $ = require_export();
|
|
var isSubsetOf = requireSetIsSubsetOf();
|
|
var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
|
|
|
|
var INCORRECT = !setMethodAcceptSetLike('isSubsetOf', function (result) {
|
|
return result;
|
|
});
|
|
|
|
// `Set.prototype.isSubsetOf` method
|
|
// https://tc39.es/ecma262/#sec-set.prototype.issubsetof
|
|
$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
|
|
isSubsetOf: isSubsetOf
|
|
});
|
|
return es_set_isSubsetOf_v2;
|
|
}
|
|
|
|
requireEs_set_isSubsetOf_v2();
|
|
|
|
var es_set_isSupersetOf_v2 = {};
|
|
|
|
var setIsSupersetOf;
|
|
var hasRequiredSetIsSupersetOf;
|
|
|
|
function requireSetIsSupersetOf () {
|
|
if (hasRequiredSetIsSupersetOf) return setIsSupersetOf;
|
|
hasRequiredSetIsSupersetOf = 1;
|
|
var aSet = requireASet();
|
|
var has = requireSetHelpers().has;
|
|
var size = requireSetSize();
|
|
var getSetRecord = requireGetSetRecord();
|
|
var iterateSimple = requireIterateSimple();
|
|
var iteratorClose = requireIteratorClose();
|
|
|
|
// `Set.prototype.isSupersetOf` method
|
|
// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSupersetOf
|
|
setIsSupersetOf = function isSupersetOf(other) {
|
|
var O = aSet(this);
|
|
var otherRec = getSetRecord(other);
|
|
if (size(O) < otherRec.size) return false;
|
|
var iterator = otherRec.getIterator();
|
|
return iterateSimple(iterator, function (e) {
|
|
if (!has(O, e)) return iteratorClose(iterator, 'normal', false);
|
|
}) !== false;
|
|
};
|
|
return setIsSupersetOf;
|
|
}
|
|
|
|
var hasRequiredEs_set_isSupersetOf_v2;
|
|
|
|
function requireEs_set_isSupersetOf_v2 () {
|
|
if (hasRequiredEs_set_isSupersetOf_v2) return es_set_isSupersetOf_v2;
|
|
hasRequiredEs_set_isSupersetOf_v2 = 1;
|
|
var $ = require_export();
|
|
var isSupersetOf = requireSetIsSupersetOf();
|
|
var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
|
|
|
|
var INCORRECT = !setMethodAcceptSetLike('isSupersetOf', function (result) {
|
|
return !result;
|
|
});
|
|
|
|
// `Set.prototype.isSupersetOf` method
|
|
// https://tc39.es/ecma262/#sec-set.prototype.issupersetof
|
|
$({ target: 'Set', proto: true, real: true, forced: INCORRECT }, {
|
|
isSupersetOf: isSupersetOf
|
|
});
|
|
return es_set_isSupersetOf_v2;
|
|
}
|
|
|
|
requireEs_set_isSupersetOf_v2();
|
|
|
|
var es_set_symmetricDifference_v2 = {};
|
|
|
|
var setSymmetricDifference;
|
|
var hasRequiredSetSymmetricDifference;
|
|
|
|
function requireSetSymmetricDifference () {
|
|
if (hasRequiredSetSymmetricDifference) return setSymmetricDifference;
|
|
hasRequiredSetSymmetricDifference = 1;
|
|
var aSet = requireASet();
|
|
var SetHelpers = requireSetHelpers();
|
|
var clone = requireSetClone();
|
|
var getSetRecord = requireGetSetRecord();
|
|
var iterateSimple = requireIterateSimple();
|
|
|
|
var add = SetHelpers.add;
|
|
var has = SetHelpers.has;
|
|
var remove = SetHelpers.remove;
|
|
|
|
// `Set.prototype.symmetricDifference` method
|
|
// https://github.com/tc39/proposal-set-methods
|
|
setSymmetricDifference = function symmetricDifference(other) {
|
|
var O = aSet(this);
|
|
var keysIter = getSetRecord(other).getIterator();
|
|
var result = clone(O);
|
|
iterateSimple(keysIter, function (e) {
|
|
if (has(O, e)) remove(result, e);
|
|
else add(result, e);
|
|
});
|
|
return result;
|
|
};
|
|
return setSymmetricDifference;
|
|
}
|
|
|
|
var hasRequiredEs_set_symmetricDifference_v2;
|
|
|
|
function requireEs_set_symmetricDifference_v2 () {
|
|
if (hasRequiredEs_set_symmetricDifference_v2) return es_set_symmetricDifference_v2;
|
|
hasRequiredEs_set_symmetricDifference_v2 = 1;
|
|
var $ = require_export();
|
|
var symmetricDifference = requireSetSymmetricDifference();
|
|
var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
|
|
|
|
// `Set.prototype.symmetricDifference` method
|
|
// https://tc39.es/ecma262/#sec-set.prototype.symmetricdifference
|
|
$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('symmetricDifference') }, {
|
|
symmetricDifference: symmetricDifference
|
|
});
|
|
return es_set_symmetricDifference_v2;
|
|
}
|
|
|
|
requireEs_set_symmetricDifference_v2();
|
|
|
|
var es_set_union_v2 = {};
|
|
|
|
var setUnion;
|
|
var hasRequiredSetUnion;
|
|
|
|
function requireSetUnion () {
|
|
if (hasRequiredSetUnion) return setUnion;
|
|
hasRequiredSetUnion = 1;
|
|
var aSet = requireASet();
|
|
var add = requireSetHelpers().add;
|
|
var clone = requireSetClone();
|
|
var getSetRecord = requireGetSetRecord();
|
|
var iterateSimple = requireIterateSimple();
|
|
|
|
// `Set.prototype.union` method
|
|
// https://github.com/tc39/proposal-set-methods
|
|
setUnion = function union(other) {
|
|
var O = aSet(this);
|
|
var keysIter = getSetRecord(other).getIterator();
|
|
var result = clone(O);
|
|
iterateSimple(keysIter, function (it) {
|
|
add(result, it);
|
|
});
|
|
return result;
|
|
};
|
|
return setUnion;
|
|
}
|
|
|
|
var hasRequiredEs_set_union_v2;
|
|
|
|
function requireEs_set_union_v2 () {
|
|
if (hasRequiredEs_set_union_v2) return es_set_union_v2;
|
|
hasRequiredEs_set_union_v2 = 1;
|
|
var $ = require_export();
|
|
var union = requireSetUnion();
|
|
var setMethodAcceptSetLike = requireSetMethodAcceptSetLike();
|
|
|
|
// `Set.prototype.union` method
|
|
// https://tc39.es/ecma262/#sec-set.prototype.union
|
|
$({ target: 'Set', proto: true, real: true, forced: !setMethodAcceptSetLike('union') }, {
|
|
union: union
|
|
});
|
|
return es_set_union_v2;
|
|
}
|
|
|
|
requireEs_set_union_v2();
|
|
|
|
var es_typedArray_toReversed = {};
|
|
|
|
var isPossiblePrototype;
|
|
var hasRequiredIsPossiblePrototype;
|
|
|
|
function requireIsPossiblePrototype () {
|
|
if (hasRequiredIsPossiblePrototype) return isPossiblePrototype;
|
|
hasRequiredIsPossiblePrototype = 1;
|
|
var isObject = requireIsObject();
|
|
|
|
isPossiblePrototype = function (argument) {
|
|
return isObject(argument) || argument === null;
|
|
};
|
|
return isPossiblePrototype;
|
|
}
|
|
|
|
var aPossiblePrototype;
|
|
var hasRequiredAPossiblePrototype;
|
|
|
|
function requireAPossiblePrototype () {
|
|
if (hasRequiredAPossiblePrototype) return aPossiblePrototype;
|
|
hasRequiredAPossiblePrototype = 1;
|
|
var isPossiblePrototype = requireIsPossiblePrototype();
|
|
|
|
var $String = String;
|
|
var $TypeError = TypeError;
|
|
|
|
aPossiblePrototype = function (argument) {
|
|
if (isPossiblePrototype(argument)) return argument;
|
|
throw new $TypeError("Can't set " + $String(argument) + ' as a prototype');
|
|
};
|
|
return aPossiblePrototype;
|
|
}
|
|
|
|
var objectSetPrototypeOf;
|
|
var hasRequiredObjectSetPrototypeOf;
|
|
|
|
function requireObjectSetPrototypeOf () {
|
|
if (hasRequiredObjectSetPrototypeOf) return objectSetPrototypeOf;
|
|
hasRequiredObjectSetPrototypeOf = 1;
|
|
/* eslint-disable no-proto -- safe */
|
|
var uncurryThisAccessor = requireFunctionUncurryThisAccessor();
|
|
var isObject = requireIsObject();
|
|
var requireObjectCoercible = requireRequireObjectCoercible();
|
|
var aPossiblePrototype = requireAPossiblePrototype();
|
|
|
|
// `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
|
|
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) {
|
|
requireObjectCoercible(O);
|
|
aPossiblePrototype(proto);
|
|
if (!isObject(O)) return O;
|
|
if (CORRECT_SETTER) setter(O, proto);
|
|
else O.__proto__ = proto;
|
|
return O;
|
|
};
|
|
}() : undefined);
|
|
return objectSetPrototypeOf;
|
|
}
|
|
|
|
var arrayBufferViewCore;
|
|
var hasRequiredArrayBufferViewCore;
|
|
|
|
function requireArrayBufferViewCore () {
|
|
if (hasRequiredArrayBufferViewCore) return arrayBufferViewCore;
|
|
hasRequiredArrayBufferViewCore = 1;
|
|
var NATIVE_ARRAY_BUFFER = requireArrayBufferBasicDetection();
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var globalThis = requireGlobalThis();
|
|
var isCallable = requireIsCallable();
|
|
var isObject = requireIsObject();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var classof = requireClassof();
|
|
var tryToString = requireTryToString();
|
|
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
var defineBuiltInAccessor = requireDefineBuiltInAccessor();
|
|
var isPrototypeOf = requireObjectIsPrototypeOf();
|
|
var getPrototypeOf = requireObjectGetPrototypeOf();
|
|
var setPrototypeOf = requireObjectSetPrototypeOf();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var uid = requireUid();
|
|
var InternalStateModule = requireInternalState();
|
|
|
|
var enforceInternalState = InternalStateModule.enforce;
|
|
var getInternalState = InternalStateModule.get;
|
|
var Int8Array = globalThis.Int8Array;
|
|
var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
|
|
var Uint8ClampedArray = globalThis.Uint8ClampedArray;
|
|
var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
|
|
var TypedArray = Int8Array && getPrototypeOf(Int8Array);
|
|
var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
|
|
var ObjectPrototype = Object.prototype;
|
|
var TypeError = globalThis.TypeError;
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
|
|
var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';
|
|
// Fixing native typed arrays in Opera Presto crashes the browser, see #595
|
|
var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(globalThis.opera) !== 'Opera';
|
|
var TYPED_ARRAY_TAG_REQUIRED = false;
|
|
var NAME, Constructor, Prototype;
|
|
|
|
var TypedArrayConstructorsList = {
|
|
Int8Array: 1,
|
|
Uint8Array: 1,
|
|
Uint8ClampedArray: 1,
|
|
Int16Array: 2,
|
|
Uint16Array: 2,
|
|
Int32Array: 4,
|
|
Uint32Array: 4,
|
|
Float32Array: 4,
|
|
Float64Array: 8
|
|
};
|
|
|
|
var BigIntArrayConstructorsList = {
|
|
BigInt64Array: 8,
|
|
BigUint64Array: 8
|
|
};
|
|
|
|
var isView = function isView(it) {
|
|
if (!isObject(it)) return false;
|
|
var klass = classof(it);
|
|
return klass === 'DataView'
|
|
|| hasOwn(TypedArrayConstructorsList, klass)
|
|
|| hasOwn(BigIntArrayConstructorsList, klass);
|
|
};
|
|
|
|
var getTypedArrayConstructor = function (it) {
|
|
var proto = getPrototypeOf(it);
|
|
if (!isObject(proto)) return;
|
|
var state = getInternalState(proto);
|
|
return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto);
|
|
};
|
|
|
|
var isTypedArray = function (it) {
|
|
if (!isObject(it)) return false;
|
|
var klass = classof(it);
|
|
return hasOwn(TypedArrayConstructorsList, klass)
|
|
|| hasOwn(BigIntArrayConstructorsList, klass);
|
|
};
|
|
|
|
var aTypedArray = function (it) {
|
|
if (isTypedArray(it)) return it;
|
|
throw new TypeError('Target is not a typed array');
|
|
};
|
|
|
|
var aTypedArrayConstructor = function (C) {
|
|
if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
|
|
throw new TypeError(tryToString(C) + ' is not a typed array constructor');
|
|
};
|
|
|
|
var exportTypedArrayMethod = function (KEY, property, forced, options) {
|
|
if (!DESCRIPTORS) return;
|
|
if (forced) for (var ARRAY in TypedArrayConstructorsList) {
|
|
var TypedArrayConstructor = globalThis[ARRAY];
|
|
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
|
|
delete TypedArrayConstructor.prototype[KEY];
|
|
} catch (error) {
|
|
// old WebKit bug - some methods are non-configurable
|
|
try {
|
|
TypedArrayConstructor.prototype[KEY] = property;
|
|
} catch (error2) { /* empty */ }
|
|
}
|
|
}
|
|
if (!TypedArrayPrototype[KEY] || forced) {
|
|
defineBuiltIn(TypedArrayPrototype, KEY, forced ? property
|
|
: NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
|
|
}
|
|
};
|
|
|
|
var exportTypedArrayStaticMethod = function (KEY, property, forced) {
|
|
var ARRAY, TypedArrayConstructor;
|
|
if (!DESCRIPTORS) return;
|
|
if (setPrototypeOf) {
|
|
if (forced) for (ARRAY in TypedArrayConstructorsList) {
|
|
TypedArrayConstructor = globalThis[ARRAY];
|
|
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
|
|
delete TypedArrayConstructor[KEY];
|
|
} catch (error) { /* empty */ }
|
|
}
|
|
if (!TypedArray[KEY] || forced) {
|
|
// V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
|
|
try {
|
|
return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
|
|
} catch (error) { /* empty */ }
|
|
} else return;
|
|
}
|
|
for (ARRAY in TypedArrayConstructorsList) {
|
|
TypedArrayConstructor = globalThis[ARRAY];
|
|
if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
|
|
defineBuiltIn(TypedArrayConstructor, KEY, property);
|
|
}
|
|
}
|
|
};
|
|
|
|
for (NAME in TypedArrayConstructorsList) {
|
|
Constructor = globalThis[NAME];
|
|
Prototype = Constructor && Constructor.prototype;
|
|
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
|
|
else NATIVE_ARRAY_BUFFER_VIEWS = false;
|
|
}
|
|
|
|
for (NAME in BigIntArrayConstructorsList) {
|
|
Constructor = globalThis[NAME];
|
|
Prototype = Constructor && Constructor.prototype;
|
|
if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
|
|
}
|
|
|
|
// WebKit bug - typed arrays constructors prototype is Object.prototype
|
|
if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
|
|
// eslint-disable-next-line no-shadow -- safe
|
|
TypedArray = function TypedArray() {
|
|
throw new TypeError('Incorrect invocation');
|
|
};
|
|
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
|
|
if (globalThis[NAME]) setPrototypeOf(globalThis[NAME], TypedArray);
|
|
}
|
|
}
|
|
|
|
if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
|
|
TypedArrayPrototype = TypedArray.prototype;
|
|
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
|
|
if (globalThis[NAME]) setPrototypeOf(globalThis[NAME].prototype, TypedArrayPrototype);
|
|
}
|
|
}
|
|
|
|
// WebKit bug - one more object in Uint8ClampedArray prototype chain
|
|
if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
|
|
setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
|
|
}
|
|
|
|
if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
|
|
TYPED_ARRAY_TAG_REQUIRED = true;
|
|
defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, {
|
|
configurable: true,
|
|
get: function () {
|
|
return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
|
|
}
|
|
});
|
|
for (NAME in TypedArrayConstructorsList) if (globalThis[NAME]) {
|
|
createNonEnumerableProperty(globalThis[NAME], TYPED_ARRAY_TAG, NAME);
|
|
}
|
|
}
|
|
|
|
arrayBufferViewCore = {
|
|
NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
|
|
TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
|
|
aTypedArray: aTypedArray,
|
|
aTypedArrayConstructor: aTypedArrayConstructor,
|
|
exportTypedArrayMethod: exportTypedArrayMethod,
|
|
exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
|
|
getTypedArrayConstructor: getTypedArrayConstructor,
|
|
isView: isView,
|
|
isTypedArray: isTypedArray,
|
|
TypedArray: TypedArray,
|
|
TypedArrayPrototype: TypedArrayPrototype
|
|
};
|
|
return arrayBufferViewCore;
|
|
}
|
|
|
|
var hasRequiredEs_typedArray_toReversed;
|
|
|
|
function requireEs_typedArray_toReversed () {
|
|
if (hasRequiredEs_typedArray_toReversed) return es_typedArray_toReversed;
|
|
hasRequiredEs_typedArray_toReversed = 1;
|
|
var arrayToReversed = requireArrayToReversed();
|
|
var ArrayBufferViewCore = requireArrayBufferViewCore();
|
|
|
|
var aTypedArray = ArrayBufferViewCore.aTypedArray;
|
|
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
|
|
var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
|
|
|
|
// `%TypedArray%.prototype.toReversed` method
|
|
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.toreversed
|
|
exportTypedArrayMethod('toReversed', function toReversed() {
|
|
return arrayToReversed(aTypedArray(this), getTypedArrayConstructor(this));
|
|
});
|
|
return es_typedArray_toReversed;
|
|
}
|
|
|
|
requireEs_typedArray_toReversed();
|
|
|
|
var es_typedArray_toSorted = {};
|
|
|
|
var hasRequiredEs_typedArray_toSorted;
|
|
|
|
function requireEs_typedArray_toSorted () {
|
|
if (hasRequiredEs_typedArray_toSorted) return es_typedArray_toSorted;
|
|
hasRequiredEs_typedArray_toSorted = 1;
|
|
var ArrayBufferViewCore = requireArrayBufferViewCore();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var aCallable = requireACallable();
|
|
var arrayFromConstructorAndList = requireArrayFromConstructorAndList();
|
|
|
|
var aTypedArray = ArrayBufferViewCore.aTypedArray;
|
|
var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
|
|
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
|
|
var sort = uncurryThis(ArrayBufferViewCore.TypedArrayPrototype.sort);
|
|
|
|
// `%TypedArray%.prototype.toSorted` method
|
|
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tosorted
|
|
exportTypedArrayMethod('toSorted', function toSorted(compareFn) {
|
|
if (compareFn !== undefined) aCallable(compareFn);
|
|
var O = aTypedArray(this);
|
|
var A = arrayFromConstructorAndList(getTypedArrayConstructor(O), O);
|
|
return sort(A, compareFn);
|
|
});
|
|
return es_typedArray_toSorted;
|
|
}
|
|
|
|
requireEs_typedArray_toSorted();
|
|
|
|
var es_typedArray_with = {};
|
|
|
|
var arrayWith;
|
|
var hasRequiredArrayWith;
|
|
|
|
function requireArrayWith () {
|
|
if (hasRequiredArrayWith) return arrayWith;
|
|
hasRequiredArrayWith = 1;
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
var toIntegerOrInfinity = requireToIntegerOrInfinity();
|
|
|
|
var $RangeError = RangeError;
|
|
|
|
// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.with
|
|
// https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.with
|
|
arrayWith = function (O, C, index, value) {
|
|
var len = lengthOfArrayLike(O);
|
|
var relativeIndex = toIntegerOrInfinity(index);
|
|
var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex;
|
|
if (actualIndex >= len || actualIndex < 0) throw new $RangeError('Incorrect index');
|
|
var A = new C(len);
|
|
var k = 0;
|
|
for (; k < len; k++) A[k] = k === actualIndex ? value : O[k];
|
|
return A;
|
|
};
|
|
return arrayWith;
|
|
}
|
|
|
|
var isBigIntArray;
|
|
var hasRequiredIsBigIntArray;
|
|
|
|
function requireIsBigIntArray () {
|
|
if (hasRequiredIsBigIntArray) return isBigIntArray;
|
|
hasRequiredIsBigIntArray = 1;
|
|
var classof = requireClassof();
|
|
|
|
isBigIntArray = function (it) {
|
|
var klass = classof(it);
|
|
return klass === 'BigInt64Array' || klass === 'BigUint64Array';
|
|
};
|
|
return isBigIntArray;
|
|
}
|
|
|
|
var toBigInt;
|
|
var hasRequiredToBigInt;
|
|
|
|
function requireToBigInt () {
|
|
if (hasRequiredToBigInt) return toBigInt;
|
|
hasRequiredToBigInt = 1;
|
|
var toPrimitive = requireToPrimitive();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// `ToBigInt` abstract operation
|
|
// https://tc39.es/ecma262/#sec-tobigint
|
|
toBigInt = function (argument) {
|
|
var prim = toPrimitive(argument, 'number');
|
|
if (typeof prim == 'number') throw new $TypeError("Can't convert number to bigint");
|
|
// eslint-disable-next-line es/no-bigint -- safe
|
|
return BigInt(prim);
|
|
};
|
|
return toBigInt;
|
|
}
|
|
|
|
var hasRequiredEs_typedArray_with;
|
|
|
|
function requireEs_typedArray_with () {
|
|
if (hasRequiredEs_typedArray_with) return es_typedArray_with;
|
|
hasRequiredEs_typedArray_with = 1;
|
|
var arrayWith = requireArrayWith();
|
|
var ArrayBufferViewCore = requireArrayBufferViewCore();
|
|
var isBigIntArray = requireIsBigIntArray();
|
|
var toIntegerOrInfinity = requireToIntegerOrInfinity();
|
|
var toBigInt = requireToBigInt();
|
|
|
|
var aTypedArray = ArrayBufferViewCore.aTypedArray;
|
|
var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
|
|
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
|
|
|
|
var PROPER_ORDER = !!function () {
|
|
try {
|
|
// eslint-disable-next-line no-throw-literal, es/no-typed-arrays, es/no-array-prototype-with -- required for testing
|
|
new Int8Array(1)['with'](2, { valueOf: function () { throw 8; } });
|
|
} catch (error) {
|
|
// some early implementations, like WebKit, does not follow the final semantic
|
|
// https://github.com/tc39/proposal-change-array-by-copy/pull/86
|
|
return error === 8;
|
|
}
|
|
}();
|
|
|
|
// `%TypedArray%.prototype.with` method
|
|
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.with
|
|
exportTypedArrayMethod('with', { 'with': function (index, value) {
|
|
var O = aTypedArray(this);
|
|
var relativeIndex = toIntegerOrInfinity(index);
|
|
var actualValue = isBigIntArray(O) ? toBigInt(value) : +value;
|
|
return arrayWith(O, getTypedArrayConstructor(O), relativeIndex, actualValue);
|
|
} }['with'], !PROPER_ORDER);
|
|
return es_typedArray_with;
|
|
}
|
|
|
|
requireEs_typedArray_with();
|
|
|
|
var esnext_array_group = {};
|
|
|
|
var arrayGroup;
|
|
var hasRequiredArrayGroup;
|
|
|
|
function requireArrayGroup () {
|
|
if (hasRequiredArrayGroup) return arrayGroup;
|
|
hasRequiredArrayGroup = 1;
|
|
var bind = requireFunctionBindContext();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var IndexedObject = requireIndexedObject();
|
|
var toObject = requireToObject();
|
|
var toPropertyKey = requireToPropertyKey();
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
var objectCreate = requireObjectCreate();
|
|
var arrayFromConstructorAndList = requireArrayFromConstructorAndList();
|
|
|
|
var $Array = Array;
|
|
var push = uncurryThis([].push);
|
|
|
|
arrayGroup = function ($this, callbackfn, that, specificConstructor) {
|
|
var O = toObject($this);
|
|
var self = IndexedObject(O);
|
|
var boundFunction = bind(callbackfn, that);
|
|
var target = objectCreate(null);
|
|
var length = lengthOfArrayLike(self);
|
|
var index = 0;
|
|
var Constructor, key, value;
|
|
for (;length > index; index++) {
|
|
value = self[index];
|
|
key = toPropertyKey(boundFunction(value, index, O));
|
|
// in some IE versions, `hasOwnProperty` returns incorrect result on integer keys
|
|
// but since it's a `null` prototype object, we can safely use `in`
|
|
if (key in target) push(target[key], value);
|
|
else target[key] = [value];
|
|
}
|
|
// TODO: Remove this block from `core-js@4`
|
|
if (specificConstructor) {
|
|
Constructor = specificConstructor(O);
|
|
if (Constructor !== $Array) {
|
|
for (key in target) target[key] = arrayFromConstructorAndList(Constructor, target[key]);
|
|
}
|
|
} return target;
|
|
};
|
|
return arrayGroup;
|
|
}
|
|
|
|
var hasRequiredEsnext_array_group;
|
|
|
|
function requireEsnext_array_group () {
|
|
if (hasRequiredEsnext_array_group) return esnext_array_group;
|
|
hasRequiredEsnext_array_group = 1;
|
|
var $ = require_export();
|
|
var $group = requireArrayGroup();
|
|
var addToUnscopables = requireAddToUnscopables();
|
|
|
|
// `Array.prototype.group` method
|
|
// https://github.com/tc39/proposal-array-grouping
|
|
$({ target: 'Array', proto: true }, {
|
|
group: function group(callbackfn /* , thisArg */) {
|
|
var thisArg = arguments.length > 1 ? arguments[1] : undefined;
|
|
return $group(this, callbackfn, thisArg);
|
|
}
|
|
});
|
|
|
|
addToUnscopables('group');
|
|
return esnext_array_group;
|
|
}
|
|
|
|
requireEsnext_array_group();
|
|
|
|
var esnext_json_parse = {};
|
|
|
|
var toString;
|
|
var hasRequiredToString;
|
|
|
|
function requireToString () {
|
|
if (hasRequiredToString) return toString;
|
|
hasRequiredToString = 1;
|
|
var classof = requireClassof();
|
|
|
|
var $String = String;
|
|
|
|
toString = function (argument) {
|
|
if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
|
|
return $String(argument);
|
|
};
|
|
return toString;
|
|
}
|
|
|
|
var parseJsonString;
|
|
var hasRequiredParseJsonString;
|
|
|
|
function requireParseJsonString () {
|
|
if (hasRequiredParseJsonString) return parseJsonString;
|
|
hasRequiredParseJsonString = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var hasOwn = requireHasOwnProperty();
|
|
|
|
var $SyntaxError = SyntaxError;
|
|
var $parseInt = parseInt;
|
|
var fromCharCode = String.fromCharCode;
|
|
var at = uncurryThis(''.charAt);
|
|
var slice = uncurryThis(''.slice);
|
|
var exec = uncurryThis(/./.exec);
|
|
|
|
var codePoints = {
|
|
'\\"': '"',
|
|
'\\\\': '\\',
|
|
'\\/': '/',
|
|
'\\b': '\b',
|
|
'\\f': '\f',
|
|
'\\n': '\n',
|
|
'\\r': '\r',
|
|
'\\t': '\t'
|
|
};
|
|
|
|
var IS_4_HEX_DIGITS = /^[\da-f]{4}$/i;
|
|
// eslint-disable-next-line regexp/no-control-character -- safe
|
|
var IS_C0_CONTROL_CODE = /^[\u0000-\u001F]$/;
|
|
|
|
parseJsonString = function (source, i) {
|
|
var unterminated = true;
|
|
var value = '';
|
|
while (i < source.length) {
|
|
var chr = at(source, i);
|
|
if (chr === '\\') {
|
|
var twoChars = slice(source, i, i + 2);
|
|
if (hasOwn(codePoints, twoChars)) {
|
|
value += codePoints[twoChars];
|
|
i += 2;
|
|
} else if (twoChars === '\\u') {
|
|
i += 2;
|
|
var fourHexDigits = slice(source, i, i + 4);
|
|
if (!exec(IS_4_HEX_DIGITS, fourHexDigits)) throw new $SyntaxError('Bad Unicode escape at: ' + i);
|
|
value += fromCharCode($parseInt(fourHexDigits, 16));
|
|
i += 4;
|
|
} else throw new $SyntaxError('Unknown escape sequence: "' + twoChars + '"');
|
|
} else if (chr === '"') {
|
|
unterminated = false;
|
|
i++;
|
|
break;
|
|
} else {
|
|
if (exec(IS_C0_CONTROL_CODE, chr)) throw new $SyntaxError('Bad control character in string literal at: ' + i);
|
|
value += chr;
|
|
i++;
|
|
}
|
|
}
|
|
if (unterminated) throw new $SyntaxError('Unterminated string at: ' + i);
|
|
return { value: value, end: i };
|
|
};
|
|
return parseJsonString;
|
|
}
|
|
|
|
var hasRequiredEsnext_json_parse;
|
|
|
|
function requireEsnext_json_parse () {
|
|
if (hasRequiredEsnext_json_parse) return esnext_json_parse;
|
|
hasRequiredEsnext_json_parse = 1;
|
|
var $ = require_export();
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var globalThis = requireGlobalThis();
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var call = requireFunctionCall();
|
|
var isCallable = requireIsCallable();
|
|
var isObject = requireIsObject();
|
|
var isArray = requireIsArray();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var toString = requireToString();
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
var createProperty = requireCreateProperty();
|
|
var fails = requireFails();
|
|
var parseJSONString = requireParseJsonString();
|
|
var NATIVE_SYMBOL = requireSymbolConstructorDetection();
|
|
|
|
var JSON = globalThis.JSON;
|
|
var Number = globalThis.Number;
|
|
var SyntaxError = globalThis.SyntaxError;
|
|
var nativeParse = JSON && JSON.parse;
|
|
var enumerableOwnProperties = getBuiltIn('Object', 'keys');
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
var at = uncurryThis(''.charAt);
|
|
var slice = uncurryThis(''.slice);
|
|
var exec = uncurryThis(/./.exec);
|
|
var push = uncurryThis([].push);
|
|
|
|
var IS_DIGIT = /^\d$/;
|
|
var IS_NON_ZERO_DIGIT = /^[1-9]$/;
|
|
var IS_NUMBER_START = /^[\d-]$/;
|
|
var IS_WHITESPACE = /^[\t\n\r ]$/;
|
|
|
|
var PRIMITIVE = 0;
|
|
var OBJECT = 1;
|
|
|
|
var $parse = function (source, reviver) {
|
|
source = toString(source);
|
|
var context = new Context(source, 0);
|
|
var root = context.parse();
|
|
var value = root.value;
|
|
var endIndex = context.skip(IS_WHITESPACE, root.end);
|
|
if (endIndex < source.length) {
|
|
throw new SyntaxError('Unexpected extra character: "' + at(source, endIndex) + '" after the parsed data at: ' + endIndex);
|
|
}
|
|
return isCallable(reviver) ? internalize({ '': value }, '', reviver, root) : value;
|
|
};
|
|
|
|
var internalize = function (holder, name, reviver, node) {
|
|
var val = holder[name];
|
|
var unmodified = node && val === node.value;
|
|
var context = unmodified && typeof node.source == 'string' ? { source: node.source } : {};
|
|
var elementRecordsLen, keys, len, i, P;
|
|
if (isObject(val)) {
|
|
var nodeIsArray = isArray(val);
|
|
var nodes = unmodified ? node.nodes : nodeIsArray ? [] : {};
|
|
if (nodeIsArray) {
|
|
elementRecordsLen = nodes.length;
|
|
len = lengthOfArrayLike(val);
|
|
for (i = 0; i < len; i++) {
|
|
internalizeProperty(val, i, internalize(val, '' + i, reviver, i < elementRecordsLen ? nodes[i] : undefined));
|
|
}
|
|
} else {
|
|
keys = enumerableOwnProperties(val);
|
|
len = lengthOfArrayLike(keys);
|
|
for (i = 0; i < len; i++) {
|
|
P = keys[i];
|
|
internalizeProperty(val, P, internalize(val, P, reviver, hasOwn(nodes, P) ? nodes[P] : undefined));
|
|
}
|
|
}
|
|
}
|
|
return call(reviver, holder, name, val, context);
|
|
};
|
|
|
|
var internalizeProperty = function (object, key, value) {
|
|
if (DESCRIPTORS) {
|
|
var descriptor = getOwnPropertyDescriptor(object, key);
|
|
if (descriptor && !descriptor.configurable) return;
|
|
}
|
|
if (value === undefined) delete object[key];
|
|
else createProperty(object, key, value);
|
|
};
|
|
|
|
var Node = function (value, end, source, nodes) {
|
|
this.value = value;
|
|
this.end = end;
|
|
this.source = source;
|
|
this.nodes = nodes;
|
|
};
|
|
|
|
var Context = function (source, index) {
|
|
this.source = source;
|
|
this.index = index;
|
|
};
|
|
|
|
// https://www.json.org/json-en.html
|
|
Context.prototype = {
|
|
fork: function (nextIndex) {
|
|
return new Context(this.source, nextIndex);
|
|
},
|
|
parse: function () {
|
|
var source = this.source;
|
|
var i = this.skip(IS_WHITESPACE, this.index);
|
|
var fork = this.fork(i);
|
|
var chr = at(source, i);
|
|
if (exec(IS_NUMBER_START, chr)) return fork.number();
|
|
switch (chr) {
|
|
case '{':
|
|
return fork.object();
|
|
case '[':
|
|
return fork.array();
|
|
case '"':
|
|
return fork.string();
|
|
case 't':
|
|
return fork.keyword(true);
|
|
case 'f':
|
|
return fork.keyword(false);
|
|
case 'n':
|
|
return fork.keyword(null);
|
|
} throw new SyntaxError('Unexpected character: "' + chr + '" at: ' + i);
|
|
},
|
|
node: function (type, value, start, end, nodes) {
|
|
return new Node(value, end, type ? null : slice(this.source, start, end), nodes);
|
|
},
|
|
object: function () {
|
|
var source = this.source;
|
|
var i = this.index + 1;
|
|
var expectKeypair = false;
|
|
var object = {};
|
|
var nodes = {};
|
|
while (i < source.length) {
|
|
i = this.until(['"', '}'], i);
|
|
if (at(source, i) === '}' && !expectKeypair) {
|
|
i++;
|
|
break;
|
|
}
|
|
// Parsing the key
|
|
var result = this.fork(i).string();
|
|
var key = result.value;
|
|
i = result.end;
|
|
i = this.until([':'], i) + 1;
|
|
// Parsing value
|
|
i = this.skip(IS_WHITESPACE, i);
|
|
result = this.fork(i).parse();
|
|
createProperty(nodes, key, result);
|
|
createProperty(object, key, result.value);
|
|
i = this.until([',', '}'], result.end);
|
|
var chr = at(source, i);
|
|
if (chr === ',') {
|
|
expectKeypair = true;
|
|
i++;
|
|
} else if (chr === '}') {
|
|
i++;
|
|
break;
|
|
}
|
|
}
|
|
return this.node(OBJECT, object, this.index, i, nodes);
|
|
},
|
|
array: function () {
|
|
var source = this.source;
|
|
var i = this.index + 1;
|
|
var expectElement = false;
|
|
var array = [];
|
|
var nodes = [];
|
|
while (i < source.length) {
|
|
i = this.skip(IS_WHITESPACE, i);
|
|
if (at(source, i) === ']' && !expectElement) {
|
|
i++;
|
|
break;
|
|
}
|
|
var result = this.fork(i).parse();
|
|
push(nodes, result);
|
|
push(array, result.value);
|
|
i = this.until([',', ']'], result.end);
|
|
if (at(source, i) === ',') {
|
|
expectElement = true;
|
|
i++;
|
|
} else if (at(source, i) === ']') {
|
|
i++;
|
|
break;
|
|
}
|
|
}
|
|
return this.node(OBJECT, array, this.index, i, nodes);
|
|
},
|
|
string: function () {
|
|
var index = this.index;
|
|
var parsed = parseJSONString(this.source, this.index + 1);
|
|
return this.node(PRIMITIVE, parsed.value, index, parsed.end);
|
|
},
|
|
number: function () {
|
|
var source = this.source;
|
|
var startIndex = this.index;
|
|
var i = startIndex;
|
|
if (at(source, i) === '-') i++;
|
|
if (at(source, i) === '0') i++;
|
|
else if (exec(IS_NON_ZERO_DIGIT, at(source, i))) i = this.skip(IS_DIGIT, i + 1);
|
|
else throw new SyntaxError('Failed to parse number at: ' + i);
|
|
if (at(source, i) === '.') i = this.skip(IS_DIGIT, i + 1);
|
|
if (at(source, i) === 'e' || at(source, i) === 'E') {
|
|
i++;
|
|
if (at(source, i) === '+' || at(source, i) === '-') i++;
|
|
var exponentStartIndex = i;
|
|
i = this.skip(IS_DIGIT, i);
|
|
if (exponentStartIndex === i) throw new SyntaxError("Failed to parse number's exponent value at: " + i);
|
|
}
|
|
return this.node(PRIMITIVE, Number(slice(source, startIndex, i)), startIndex, i);
|
|
},
|
|
keyword: function (value) {
|
|
var keyword = '' + value;
|
|
var index = this.index;
|
|
var endIndex = index + keyword.length;
|
|
if (slice(this.source, index, endIndex) !== keyword) throw new SyntaxError('Failed to parse value at: ' + index);
|
|
return this.node(PRIMITIVE, value, index, endIndex);
|
|
},
|
|
skip: function (regex, i) {
|
|
var source = this.source;
|
|
for (; i < source.length; i++) if (!exec(regex, at(source, i))) break;
|
|
return i;
|
|
},
|
|
until: function (array, i) {
|
|
i = this.skip(IS_WHITESPACE, i);
|
|
var chr = at(this.source, i);
|
|
for (var j = 0; j < array.length; j++) if (array[j] === chr) return i;
|
|
throw new SyntaxError('Unexpected character: "' + chr + '" at: ' + i);
|
|
}
|
|
};
|
|
|
|
var NO_SOURCE_SUPPORT = fails(function () {
|
|
var unsafeInt = '9007199254740993';
|
|
var source;
|
|
nativeParse(unsafeInt, function (key, value, context) {
|
|
source = context.source;
|
|
});
|
|
return source !== unsafeInt;
|
|
});
|
|
|
|
var PROPER_BASE_PARSE = NATIVE_SYMBOL && !fails(function () {
|
|
// Safari 9 bug
|
|
return 1 / nativeParse('-0 \t') !== -Infinity;
|
|
});
|
|
|
|
// `JSON.parse` method
|
|
// https://tc39.es/ecma262/#sec-json.parse
|
|
// https://github.com/tc39/proposal-json-parse-with-source
|
|
$({ target: 'JSON', stat: true, forced: NO_SOURCE_SUPPORT }, {
|
|
parse: function parse(text, reviver) {
|
|
return PROPER_BASE_PARSE && !isCallable(reviver) ? nativeParse(text) : $parse(text, reviver);
|
|
}
|
|
});
|
|
return esnext_json_parse;
|
|
}
|
|
|
|
requireEsnext_json_parse();
|
|
|
|
var esnext_uint8Array_setFromBase64 = {};
|
|
|
|
var anObjectOrUndefined;
|
|
var hasRequiredAnObjectOrUndefined;
|
|
|
|
function requireAnObjectOrUndefined () {
|
|
if (hasRequiredAnObjectOrUndefined) return anObjectOrUndefined;
|
|
hasRequiredAnObjectOrUndefined = 1;
|
|
var isObject = requireIsObject();
|
|
|
|
var $String = String;
|
|
var $TypeError = TypeError;
|
|
|
|
anObjectOrUndefined = function (argument) {
|
|
if (argument === undefined || isObject(argument)) return argument;
|
|
throw new $TypeError($String(argument) + ' is not an object or undefined');
|
|
};
|
|
return anObjectOrUndefined;
|
|
}
|
|
|
|
var aString;
|
|
var hasRequiredAString;
|
|
|
|
function requireAString () {
|
|
if (hasRequiredAString) return aString;
|
|
hasRequiredAString = 1;
|
|
var $TypeError = TypeError;
|
|
|
|
aString = function (argument) {
|
|
if (typeof argument == 'string') return argument;
|
|
throw new $TypeError('Argument is not a string');
|
|
};
|
|
return aString;
|
|
}
|
|
|
|
var base64Map;
|
|
var hasRequiredBase64Map;
|
|
|
|
function requireBase64Map () {
|
|
if (hasRequiredBase64Map) return base64Map;
|
|
hasRequiredBase64Map = 1;
|
|
var commonAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
|
|
var base64Alphabet = commonAlphabet + '+/';
|
|
var base64UrlAlphabet = commonAlphabet + '-_';
|
|
|
|
var inverse = function (characters) {
|
|
// TODO: use `Object.create(null)` in `core-js@4`
|
|
var result = {};
|
|
var index = 0;
|
|
for (; index < 64; index++) result[characters.charAt(index)] = index;
|
|
return result;
|
|
};
|
|
|
|
base64Map = {
|
|
i2c: base64Alphabet,
|
|
c2i: inverse(base64Alphabet),
|
|
i2cUrl: base64UrlAlphabet,
|
|
c2iUrl: inverse(base64UrlAlphabet)
|
|
};
|
|
return base64Map;
|
|
}
|
|
|
|
var getAlphabetOption;
|
|
var hasRequiredGetAlphabetOption;
|
|
|
|
function requireGetAlphabetOption () {
|
|
if (hasRequiredGetAlphabetOption) return getAlphabetOption;
|
|
hasRequiredGetAlphabetOption = 1;
|
|
var $TypeError = TypeError;
|
|
|
|
getAlphabetOption = function (options) {
|
|
var alphabet = options && options.alphabet;
|
|
if (alphabet === undefined || alphabet === 'base64' || alphabet === 'base64url') return alphabet || 'base64';
|
|
throw new $TypeError('Incorrect `alphabet` option');
|
|
};
|
|
return getAlphabetOption;
|
|
}
|
|
|
|
var uint8FromBase64;
|
|
var hasRequiredUint8FromBase64;
|
|
|
|
function requireUint8FromBase64 () {
|
|
if (hasRequiredUint8FromBase64) return uint8FromBase64;
|
|
hasRequiredUint8FromBase64 = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var anObjectOrUndefined = requireAnObjectOrUndefined();
|
|
var aString = requireAString();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var base64Map = requireBase64Map();
|
|
var getAlphabetOption = requireGetAlphabetOption();
|
|
var notDetached = requireArrayBufferNotDetached();
|
|
|
|
var base64Alphabet = base64Map.c2i;
|
|
var base64UrlAlphabet = base64Map.c2iUrl;
|
|
|
|
var SyntaxError = globalThis.SyntaxError;
|
|
var TypeError = globalThis.TypeError;
|
|
var at = uncurryThis(''.charAt);
|
|
|
|
var skipAsciiWhitespace = function (string, index) {
|
|
var length = string.length;
|
|
for (;index < length; index++) {
|
|
var chr = at(string, index);
|
|
if (chr !== ' ' && chr !== '\t' && chr !== '\n' && chr !== '\f' && chr !== '\r') break;
|
|
} return index;
|
|
};
|
|
|
|
var decodeBase64Chunk = function (chunk, alphabet, throwOnExtraBits) {
|
|
var chunkLength = chunk.length;
|
|
|
|
if (chunkLength < 4) {
|
|
chunk += chunkLength === 2 ? 'AA' : 'A';
|
|
}
|
|
|
|
var triplet = (alphabet[at(chunk, 0)] << 18)
|
|
+ (alphabet[at(chunk, 1)] << 12)
|
|
+ (alphabet[at(chunk, 2)] << 6)
|
|
+ alphabet[at(chunk, 3)];
|
|
|
|
var chunkBytes = [
|
|
(triplet >> 16) & 255,
|
|
(triplet >> 8) & 255,
|
|
triplet & 255
|
|
];
|
|
|
|
if (chunkLength === 2) {
|
|
if (throwOnExtraBits && chunkBytes[1] !== 0) {
|
|
throw new SyntaxError('Extra bits');
|
|
}
|
|
return [chunkBytes[0]];
|
|
}
|
|
|
|
if (chunkLength === 3) {
|
|
if (throwOnExtraBits && chunkBytes[2] !== 0) {
|
|
throw new SyntaxError('Extra bits');
|
|
}
|
|
return [chunkBytes[0], chunkBytes[1]];
|
|
}
|
|
|
|
return chunkBytes;
|
|
};
|
|
|
|
var writeBytes = function (bytes, elements, written) {
|
|
var elementsLength = elements.length;
|
|
for (var index = 0; index < elementsLength; index++) {
|
|
bytes[written + index] = elements[index];
|
|
}
|
|
return written + elementsLength;
|
|
};
|
|
|
|
/* eslint-disable max-statements, max-depth -- TODO */
|
|
uint8FromBase64 = function (string, options, into, maxLength) {
|
|
aString(string);
|
|
anObjectOrUndefined(options);
|
|
var alphabet = getAlphabetOption(options) === 'base64' ? base64Alphabet : base64UrlAlphabet;
|
|
var lastChunkHandling = options ? options.lastChunkHandling : undefined;
|
|
|
|
if (lastChunkHandling === undefined) lastChunkHandling = 'loose';
|
|
|
|
if (lastChunkHandling !== 'loose' && lastChunkHandling !== 'strict' && lastChunkHandling !== 'stop-before-partial') {
|
|
throw new TypeError('Incorrect `lastChunkHandling` option');
|
|
}
|
|
|
|
if (into) notDetached(into.buffer);
|
|
|
|
var bytes = into || [];
|
|
var written = 0;
|
|
var read = 0;
|
|
var chunk = '';
|
|
var index = 0;
|
|
|
|
if (maxLength) while (true) {
|
|
index = skipAsciiWhitespace(string, index);
|
|
if (index === string.length) {
|
|
if (chunk.length > 0) {
|
|
if (lastChunkHandling === 'stop-before-partial') {
|
|
break;
|
|
}
|
|
if (lastChunkHandling === 'loose') {
|
|
if (chunk.length === 1) {
|
|
throw new SyntaxError('Malformed padding: exactly one additional character');
|
|
}
|
|
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written);
|
|
} else {
|
|
throw new SyntaxError('Missing padding');
|
|
}
|
|
}
|
|
read = string.length;
|
|
break;
|
|
}
|
|
var chr = at(string, index);
|
|
++index;
|
|
if (chr === '=') {
|
|
if (chunk.length < 2) {
|
|
throw new SyntaxError('Padding is too early');
|
|
}
|
|
index = skipAsciiWhitespace(string, index);
|
|
if (chunk.length === 2) {
|
|
if (index === string.length) {
|
|
if (lastChunkHandling === 'stop-before-partial') {
|
|
break;
|
|
}
|
|
throw new SyntaxError('Malformed padding: only one =');
|
|
}
|
|
if (at(string, index) === '=') {
|
|
++index;
|
|
index = skipAsciiWhitespace(string, index);
|
|
}
|
|
}
|
|
if (index < string.length) {
|
|
throw new SyntaxError('Unexpected character after padding');
|
|
}
|
|
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, lastChunkHandling === 'strict'), written);
|
|
read = string.length;
|
|
break;
|
|
}
|
|
if (!hasOwn(alphabet, chr)) {
|
|
throw new SyntaxError('Unexpected character');
|
|
}
|
|
var remainingBytes = maxLength - written;
|
|
if (remainingBytes === 1 && chunk.length === 2 || remainingBytes === 2 && chunk.length === 3) {
|
|
// special case: we can fit exactly the number of bytes currently represented by chunk, so we were just checking for `=`
|
|
break;
|
|
}
|
|
|
|
chunk += chr;
|
|
if (chunk.length === 4) {
|
|
written = writeBytes(bytes, decodeBase64Chunk(chunk, alphabet, false), written);
|
|
chunk = '';
|
|
read = index;
|
|
if (written === maxLength) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return { bytes: bytes, read: read, written: written };
|
|
};
|
|
return uint8FromBase64;
|
|
}
|
|
|
|
var anUint8Array;
|
|
var hasRequiredAnUint8Array;
|
|
|
|
function requireAnUint8Array () {
|
|
if (hasRequiredAnUint8Array) return anUint8Array;
|
|
hasRequiredAnUint8Array = 1;
|
|
var classof = requireClassof();
|
|
|
|
var $TypeError = TypeError;
|
|
|
|
// Perform ? RequireInternalSlot(argument, [[TypedArrayName]])
|
|
// If argument.[[TypedArrayName]] is not "Uint8Array", throw a TypeError exception
|
|
anUint8Array = function (argument) {
|
|
if (classof(argument) === 'Uint8Array') return argument;
|
|
throw new $TypeError('Argument is not an Uint8Array');
|
|
};
|
|
return anUint8Array;
|
|
}
|
|
|
|
var hasRequiredEsnext_uint8Array_setFromBase64;
|
|
|
|
function requireEsnext_uint8Array_setFromBase64 () {
|
|
if (hasRequiredEsnext_uint8Array_setFromBase64) return esnext_uint8Array_setFromBase64;
|
|
hasRequiredEsnext_uint8Array_setFromBase64 = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var $fromBase64 = requireUint8FromBase64();
|
|
var anUint8Array = requireAnUint8Array();
|
|
|
|
var Uint8Array = globalThis.Uint8Array;
|
|
|
|
// `Uint8Array.prototype.setFromBase64` method
|
|
// https://github.com/tc39/proposal-arraybuffer-base64
|
|
if (Uint8Array) $({ target: 'Uint8Array', proto: true }, {
|
|
setFromBase64: function setFromBase64(string /* , options */) {
|
|
anUint8Array(this);
|
|
|
|
var result = $fromBase64(string, arguments.length > 1 ? arguments[1] : undefined, this, this.length);
|
|
|
|
return { read: result.read, written: result.written };
|
|
}
|
|
});
|
|
return esnext_uint8Array_setFromBase64;
|
|
}
|
|
|
|
requireEsnext_uint8Array_setFromBase64();
|
|
|
|
var esnext_uint8Array_setFromHex = {};
|
|
|
|
var uint8FromHex;
|
|
var hasRequiredUint8FromHex;
|
|
|
|
function requireUint8FromHex () {
|
|
if (hasRequiredUint8FromHex) return uint8FromHex;
|
|
hasRequiredUint8FromHex = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
var Uint8Array = globalThis.Uint8Array;
|
|
var SyntaxError = globalThis.SyntaxError;
|
|
var parseInt = globalThis.parseInt;
|
|
var min = Math.min;
|
|
var NOT_HEX = /[^\da-f]/i;
|
|
var exec = uncurryThis(NOT_HEX.exec);
|
|
var stringSlice = uncurryThis(''.slice);
|
|
|
|
uint8FromHex = function (string, into) {
|
|
var stringLength = string.length;
|
|
if (stringLength % 2 !== 0) throw new SyntaxError('String should be an even number of characters');
|
|
var maxLength = into ? min(into.length, stringLength / 2) : stringLength / 2;
|
|
var bytes = into || new Uint8Array(maxLength);
|
|
var read = 0;
|
|
var written = 0;
|
|
while (written < maxLength) {
|
|
var hexits = stringSlice(string, read, read += 2);
|
|
if (exec(NOT_HEX, hexits)) throw new SyntaxError('String should only contain hex characters');
|
|
bytes[written++] = parseInt(hexits, 16);
|
|
}
|
|
return { bytes: bytes, read: read };
|
|
};
|
|
return uint8FromHex;
|
|
}
|
|
|
|
var hasRequiredEsnext_uint8Array_setFromHex;
|
|
|
|
function requireEsnext_uint8Array_setFromHex () {
|
|
if (hasRequiredEsnext_uint8Array_setFromHex) return esnext_uint8Array_setFromHex;
|
|
hasRequiredEsnext_uint8Array_setFromHex = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var aString = requireAString();
|
|
var anUint8Array = requireAnUint8Array();
|
|
var notDetached = requireArrayBufferNotDetached();
|
|
var $fromHex = requireUint8FromHex();
|
|
|
|
// `Uint8Array.prototype.setFromHex` method
|
|
// https://github.com/tc39/proposal-arraybuffer-base64
|
|
if (globalThis.Uint8Array) $({ target: 'Uint8Array', proto: true }, {
|
|
setFromHex: function setFromHex(string) {
|
|
anUint8Array(this);
|
|
aString(string);
|
|
notDetached(this.buffer);
|
|
var read = $fromHex(string, this).read;
|
|
return { read: read, written: read / 2 };
|
|
}
|
|
});
|
|
return esnext_uint8Array_setFromHex;
|
|
}
|
|
|
|
requireEsnext_uint8Array_setFromHex();
|
|
|
|
var esnext_uint8Array_toBase64 = {};
|
|
|
|
var hasRequiredEsnext_uint8Array_toBase64;
|
|
|
|
function requireEsnext_uint8Array_toBase64 () {
|
|
if (hasRequiredEsnext_uint8Array_toBase64) return esnext_uint8Array_toBase64;
|
|
hasRequiredEsnext_uint8Array_toBase64 = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var anObjectOrUndefined = requireAnObjectOrUndefined();
|
|
var anUint8Array = requireAnUint8Array();
|
|
var notDetached = requireArrayBufferNotDetached();
|
|
var base64Map = requireBase64Map();
|
|
var getAlphabetOption = requireGetAlphabetOption();
|
|
|
|
var base64Alphabet = base64Map.i2c;
|
|
var base64UrlAlphabet = base64Map.i2cUrl;
|
|
|
|
var charAt = uncurryThis(''.charAt);
|
|
|
|
// `Uint8Array.prototype.toBase64` method
|
|
// https://github.com/tc39/proposal-arraybuffer-base64
|
|
if (globalThis.Uint8Array) $({ target: 'Uint8Array', proto: true }, {
|
|
toBase64: function toBase64(/* options */) {
|
|
var array = anUint8Array(this);
|
|
var options = arguments.length ? anObjectOrUndefined(arguments[0]) : undefined;
|
|
var alphabet = getAlphabetOption(options) === 'base64' ? base64Alphabet : base64UrlAlphabet;
|
|
var omitPadding = !!options && !!options.omitPadding;
|
|
notDetached(this.buffer);
|
|
|
|
var result = '';
|
|
var i = 0;
|
|
var length = array.length;
|
|
var triplet;
|
|
|
|
var at = function (shift) {
|
|
return charAt(alphabet, (triplet >> (6 * shift)) & 63);
|
|
};
|
|
|
|
for (; i + 2 < length; i += 3) {
|
|
triplet = (array[i] << 16) + (array[i + 1] << 8) + array[i + 2];
|
|
result += at(3) + at(2) + at(1) + at(0);
|
|
}
|
|
if (i + 2 === length) {
|
|
triplet = (array[i] << 16) + (array[i + 1] << 8);
|
|
result += at(3) + at(2) + at(1) + (omitPadding ? '' : '=');
|
|
} else if (i + 1 === length) {
|
|
triplet = array[i] << 16;
|
|
result += at(3) + at(2) + (omitPadding ? '' : '==');
|
|
}
|
|
|
|
return result;
|
|
}
|
|
});
|
|
return esnext_uint8Array_toBase64;
|
|
}
|
|
|
|
requireEsnext_uint8Array_toBase64();
|
|
|
|
var esnext_uint8Array_toHex = {};
|
|
|
|
var hasRequiredEsnext_uint8Array_toHex;
|
|
|
|
function requireEsnext_uint8Array_toHex () {
|
|
if (hasRequiredEsnext_uint8Array_toHex) return esnext_uint8Array_toHex;
|
|
hasRequiredEsnext_uint8Array_toHex = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var anUint8Array = requireAnUint8Array();
|
|
var notDetached = requireArrayBufferNotDetached();
|
|
|
|
var numberToString = uncurryThis(1.0.toString);
|
|
|
|
// `Uint8Array.prototype.toHex` method
|
|
// https://github.com/tc39/proposal-arraybuffer-base64
|
|
if (globalThis.Uint8Array) $({ target: 'Uint8Array', proto: true }, {
|
|
toHex: function toHex() {
|
|
anUint8Array(this);
|
|
notDetached(this.buffer);
|
|
var result = '';
|
|
for (var i = 0, length = this.length; i < length; i++) {
|
|
var hex = numberToString(this[i], 16);
|
|
result += hex.length === 1 ? '0' + hex : hex;
|
|
}
|
|
return result;
|
|
}
|
|
});
|
|
return esnext_uint8Array_toHex;
|
|
}
|
|
|
|
requireEsnext_uint8Array_toHex();
|
|
|
|
var web_urlSearchParams_delete = {};
|
|
|
|
var validateArgumentsLength;
|
|
var hasRequiredValidateArgumentsLength;
|
|
|
|
function requireValidateArgumentsLength () {
|
|
if (hasRequiredValidateArgumentsLength) return validateArgumentsLength;
|
|
hasRequiredValidateArgumentsLength = 1;
|
|
var $TypeError = TypeError;
|
|
|
|
validateArgumentsLength = function (passed, required) {
|
|
if (passed < required) throw new $TypeError('Not enough arguments');
|
|
return passed;
|
|
};
|
|
return validateArgumentsLength;
|
|
}
|
|
|
|
var hasRequiredWeb_urlSearchParams_delete;
|
|
|
|
function requireWeb_urlSearchParams_delete () {
|
|
if (hasRequiredWeb_urlSearchParams_delete) return web_urlSearchParams_delete;
|
|
hasRequiredWeb_urlSearchParams_delete = 1;
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var toString = requireToString();
|
|
var validateArgumentsLength = requireValidateArgumentsLength();
|
|
|
|
var $URLSearchParams = URLSearchParams;
|
|
var URLSearchParamsPrototype = $URLSearchParams.prototype;
|
|
var append = uncurryThis(URLSearchParamsPrototype.append);
|
|
var $delete = uncurryThis(URLSearchParamsPrototype['delete']);
|
|
var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
|
|
var push = uncurryThis([].push);
|
|
var params = new $URLSearchParams('a=1&a=2&b=3');
|
|
|
|
params['delete']('a', 1);
|
|
// `undefined` case is a Chromium 117 bug
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
|
|
params['delete']('b', undefined);
|
|
|
|
if (params + '' !== 'a=2') {
|
|
defineBuiltIn(URLSearchParamsPrototype, 'delete', function (name /* , value */) {
|
|
var length = arguments.length;
|
|
var $value = length < 2 ? undefined : arguments[1];
|
|
if (length && $value === undefined) return $delete(this, name);
|
|
var entries = [];
|
|
forEach(this, function (v, k) { // also validates `this`
|
|
push(entries, { key: k, value: v });
|
|
});
|
|
validateArgumentsLength(length, 1);
|
|
var key = toString(name);
|
|
var value = toString($value);
|
|
var index = 0;
|
|
var dindex = 0;
|
|
var found = false;
|
|
var entriesLength = entries.length;
|
|
var entry;
|
|
while (index < entriesLength) {
|
|
entry = entries[index++];
|
|
if (found || entry.key === key) {
|
|
found = true;
|
|
$delete(this, entry.key);
|
|
} else dindex++;
|
|
}
|
|
while (dindex < entriesLength) {
|
|
entry = entries[dindex++];
|
|
if (!(entry.key === key && entry.value === value)) append(this, entry.key, entry.value);
|
|
}
|
|
}, { enumerable: true, unsafe: true });
|
|
}
|
|
return web_urlSearchParams_delete;
|
|
}
|
|
|
|
requireWeb_urlSearchParams_delete();
|
|
|
|
var web_urlSearchParams_has = {};
|
|
|
|
var hasRequiredWeb_urlSearchParams_has;
|
|
|
|
function requireWeb_urlSearchParams_has () {
|
|
if (hasRequiredWeb_urlSearchParams_has) return web_urlSearchParams_has;
|
|
hasRequiredWeb_urlSearchParams_has = 1;
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var toString = requireToString();
|
|
var validateArgumentsLength = requireValidateArgumentsLength();
|
|
|
|
var $URLSearchParams = URLSearchParams;
|
|
var URLSearchParamsPrototype = $URLSearchParams.prototype;
|
|
var getAll = uncurryThis(URLSearchParamsPrototype.getAll);
|
|
var $has = uncurryThis(URLSearchParamsPrototype.has);
|
|
var params = new $URLSearchParams('a=1');
|
|
|
|
// `undefined` case is a Chromium 117 bug
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
|
|
if (params.has('a', 2) || !params.has('a', undefined)) {
|
|
defineBuiltIn(URLSearchParamsPrototype, 'has', function has(name /* , value */) {
|
|
var length = arguments.length;
|
|
var $value = length < 2 ? undefined : arguments[1];
|
|
if (length && $value === undefined) return $has(this, name);
|
|
var values = getAll(this, name); // also validates `this`
|
|
validateArgumentsLength(length, 1);
|
|
var value = toString($value);
|
|
var index = 0;
|
|
while (index < values.length) {
|
|
if (values[index++] === value) return true;
|
|
} return false;
|
|
}, { enumerable: true, unsafe: true });
|
|
}
|
|
return web_urlSearchParams_has;
|
|
}
|
|
|
|
requireWeb_urlSearchParams_has();
|
|
|
|
var web_urlSearchParams_size = {};
|
|
|
|
var hasRequiredWeb_urlSearchParams_size;
|
|
|
|
function requireWeb_urlSearchParams_size () {
|
|
if (hasRequiredWeb_urlSearchParams_size) return web_urlSearchParams_size;
|
|
hasRequiredWeb_urlSearchParams_size = 1;
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var defineBuiltInAccessor = requireDefineBuiltInAccessor();
|
|
|
|
var URLSearchParamsPrototype = URLSearchParams.prototype;
|
|
var forEach = uncurryThis(URLSearchParamsPrototype.forEach);
|
|
|
|
// `URLSearchParams.prototype.size` getter
|
|
// https://github.com/whatwg/url/pull/734
|
|
if (DESCRIPTORS && !('size' in URLSearchParamsPrototype)) {
|
|
defineBuiltInAccessor(URLSearchParamsPrototype, 'size', {
|
|
get: function size() {
|
|
var count = 0;
|
|
forEach(this, function () { count++; });
|
|
return count;
|
|
},
|
|
configurable: true,
|
|
enumerable: true
|
|
});
|
|
}
|
|
return web_urlSearchParams_size;
|
|
}
|
|
|
|
requireWeb_urlSearchParams_size();
|
|
|
|
var s_min = {};
|
|
|
|
/*!
|
|
* SJS 6.15.1
|
|
*/
|
|
|
|
var hasRequiredS_min;
|
|
|
|
function requireS_min () {
|
|
if (hasRequiredS_min) return s_min;
|
|
hasRequiredS_min = 1;
|
|
!function(){function e(e,t){return (t||"")+" (SystemJS https://github.com/systemjs/systemjs/blob/main/docs/errors.md#"+e+")"}function t(e,t){if(-1!==e.indexOf("\\")&&(e=e.replace(S,"/")),"/"===e[0]&&"/"===e[1])return t.slice(0,t.indexOf(":")+1)+e;if("."===e[0]&&("/"===e[1]||"."===e[1]&&("/"===e[2]||2===e.length&&(e+="/"))||1===e.length&&(e+="/"))||"/"===e[0]){var r,n=t.slice(0,t.indexOf(":")+1);if(r="/"===t[n.length+1]?"file:"!==n?(r=t.slice(n.length+2)).slice(r.indexOf("/")+1):t.slice(8):t.slice(n.length+("/"===t[n.length])),"/"===e[0])return t.slice(0,t.length-r.length-1)+e;for(var i=r.slice(0,r.lastIndexOf("/")+1)+e,o=[],s=-1,c=0;c<i.length;c++) -1!==s?"/"===i[c]&&(o.push(i.slice(s,c+1)),s=-1):"."===i[c]?"."!==i[c+1]||"/"!==i[c+2]&&c+2!==i.length?"/"===i[c+1]||c+1===i.length?c+=1:s=c:(o.pop(),c+=2):s=c;return -1!==s&&o.push(i.slice(s)),t.slice(0,t.length-r.length)+o.join("")}}function r(e,r){return t(e,r)||(-1!==e.indexOf(":")?e:t("./"+e,r))}function n(e,r,n,i,o){for(var s in e){var f=t(s,n)||s,a=e[s];if("string"==typeof a){var l=u(i,t(a,n)||a,o);l?r[f]=l:c("W1",s,a);}}}function i(e,t,i){var o;for(o in e.imports&&n(e.imports,i.imports,t,i,null),e.scopes||{}){var s=r(o,t);n(e.scopes[o],i.scopes[s]||(i.scopes[s]={}),t,i,s);}for(o in e.depcache||{})i.depcache[r(o,t)]=e.depcache[o];for(o in e.integrity||{})i.integrity[r(o,t)]=e.integrity[o];}function o(e,t){if(t[e])return e;var r=e.length;do{var n=e.slice(0,r+1);if(n in t)return n}while(-1!==(r=e.lastIndexOf("/",r-1)))}function s(e,t){var r=o(e,t);if(r){var n=t[r];if(null===n)return;if(!(e.length>r.length&&"/"!==n[n.length-1]))return n+e.slice(r.length);c("W2",r,n);}}function c(t,r,n){console.warn(e(t,[n,r].join(", ")));}function u(e,t,r){for(var n=e.scopes,i=r&&o(r,n);i;){var c=s(t,n[i]);if(c)return c;i=o(i.slice(0,i.lastIndexOf("/")),n);}return s(t,e.imports)||-1!==t.indexOf(":")&&t}function f(){this[b]={};}function a(t,r,n,i){var o=t[b][r];if(o)return o;var s=[],c=Object.create(null);j&&Object.defineProperty(c,j,{value:"Module"});var u=Promise.resolve().then((function(){return t.instantiate(r,n,i)})).then((function(n){if(!n)throw Error(e(2,r));var i=n[1]((function(e,t){o.h=true;var r=false;if("string"==typeof e)e in c&&c[e]===t||(c[e]=t,r=true);else {for(var n in e)t=e[n],n in c&&c[n]===t||(c[n]=t,r=true);e&&e.__esModule&&(c.__esModule=e.__esModule);}if(r)for(var i=0;i<s.length;i++){var u=s[i];u&&u(c);}return t}),2===n[1].length?{import:function(e,n){return t.import(e,r,n)},meta:t.createContext(r)}:void 0);return o.e=i.execute||function(){},[n[0],i.setters||[],n[2]||[]]}),(function(e){throw o.e=null,o.er=e,e})),f=u.then((function(e){return Promise.all(e[0].map((function(n,i){var o=e[1][i],s=e[2][i];return Promise.resolve(t.resolve(n,r)).then((function(e){var n=a(t,e,r,s);return Promise.resolve(n.I).then((function(){return o&&(n.i.push(o),!n.h&&n.I||o(n.n)),n}))}))}))).then((function(e){o.d=e;}))}));return o=t[b][r]={id:r,i:s,n:c,m:i,I:u,L:f,h:false,d:void 0,e:void 0,er:void 0,E:void 0,C:void 0,p:void 0}}function l(e,t,r,n){if(!n[t.id])return n[t.id]=true,Promise.resolve(t.L).then((function(){return t.p&&null!==t.p.e||(t.p=r),Promise.all(t.d.map((function(t){return l(e,t,r,n)})))})).catch((function(e){if(t.er)throw e;throw t.e=null,e}))}function h(e,t){return t.C=l(e,t,t,{}).then((function(){return d(e,t,{})})).then((function(){return t.n}))}function d(e,t,r){function n(){try{var e=o.call(I);if(e)return e=e.then((function(){t.C=t.n,t.E=null;}),(function(e){throw t.er=e,t.E=null,e})),t.E=e;t.C=t.n,t.L=t.I=void 0;}catch(r){throw t.er=r,r}}if(!r[t.id]){if(r[t.id]=true,!t.e){if(t.er)throw t.er;return t.E?t.E:void 0}var i,o=t.e;return t.e=null,t.d.forEach((function(n){try{var o=d(e,n,r);o&&(i=i||[]).push(o);}catch(s){throw t.er=s,s}})),i?Promise.all(i).then(n):n()}}function v(){[].forEach.call(document.querySelectorAll("script"),(function(t){if(!t.sp)if("systemjs-module"===t.type){if(t.sp=true,!t.src)return;System.import("import:"===t.src.slice(0,7)?t.src.slice(7):r(t.src,p)).catch((function(e){if(e.message.indexOf("https://github.com/systemjs/systemjs/blob/main/docs/errors.md#3")>-1){var r=document.createEvent("Event");r.initEvent("error",false,false),t.dispatchEvent(r);}return Promise.reject(e)}));}else if("systemjs-importmap"===t.type){t.sp=true;var n=t.src?(System.fetch||fetch)(t.src,{integrity:t.integrity,priority:t.fetchPriority,passThrough:true}).then((function(e){if(!e.ok)throw Error(e.status);return e.text()})).catch((function(r){return r.message=e("W4",t.src)+"\n"+r.message,console.warn(r),"function"==typeof t.onerror&&t.onerror(),"{}"})):t.innerHTML;M=M.then((function(){return n})).then((function(r){!function(t,r,n){var o={};try{o=JSON.parse(r);}catch(s){console.warn(Error(e("W5")));}i(o,n,t);}(R,r,t.src||p);}));}}));}var p,m="undefined"!=typeof Symbol,g="undefined"!=typeof self,y="undefined"!=typeof document,E=g?self:commonjsGlobal;if(y){var w=document.querySelector("base[href]");w&&(p=w.href);}if(!p&&"undefined"!=typeof location){var O=(p=location.href.split("#")[0].split("?")[0]).lastIndexOf("/");-1!==O&&(p=p.slice(0,O+1));}var x,S=/\\/g,j=m&&Symbol.toStringTag,b=m?Symbol():"@",P=f.prototype;P.import=function(e,t,r){var n=this;return t&&"object"==typeof t&&(r=t,t=void 0),Promise.resolve(n.prepareImport()).then((function(){return n.resolve(e,t,r)})).then((function(e){var t=a(n,e,void 0,r);return t.C||h(n,t)}))},P.createContext=function(e){var t=this;return {url:e,resolve:function(r,n){return Promise.resolve(t.resolve(r,n||e))}}},P.register=function(e,t,r){x=[e,t,r];},P.getRegister=function(){var e=x;return x=void 0,e};var I=Object.freeze(Object.create(null));E.System=new f;var L,C,M=Promise.resolve(),R={imports:{},scopes:{},depcache:{},integrity:{}},T=y;if(P.prepareImport=function(e){return (T||e)&&(v(),T=false),M},P.getImportMap=function(){return JSON.parse(JSON.stringify(R))},y&&(v(),window.addEventListener("DOMContentLoaded",v)),P.addImportMap=function(e,t){i(e,t||p,R);},y){window.addEventListener("error",(function(e){J=e.filename,W=e.error;}));var _=location.origin;}P.createScript=function(e){var t=document.createElement("script");t.async=true,e.indexOf(_+"/")&&(t.crossOrigin="anonymous");var r=R.integrity[e];return r&&(t.integrity=r),t.src=e,t};var J,W,q={},N=P.register;P.register=function(e,t){if(y&&"loading"===document.readyState&&"string"!=typeof e){var r=document.querySelectorAll("script[src]"),n=r[r.length-1];if(n){L=e;var i=this;C=setTimeout((function(){q[n.src]=[e,t],i.import(n.src);}));}}else L=void 0;return N.call(this,e,t)},P.instantiate=function(t,r){var n=q[t];if(n)return delete q[t],n;var i=this;return Promise.resolve(P.createScript(t)).then((function(n){return new Promise((function(o,s){n.addEventListener("error",(function(){s(Error(e(3,[t,r].join(", "))));})),n.addEventListener("load",(function(){if(document.head.removeChild(n),J===t)s(W);else {var e=i.getRegister(t);e&&e[0]===L&&clearTimeout(C),o(e);}})),document.head.appendChild(n);}))}))},P.shouldFetch=function(){return false},"undefined"!=typeof fetch&&(P.fetch=fetch);var k=P.instantiate,A=/^(text|application)\/(x-)?javascript(;|$)/;P.instantiate=function(t,r,n){var i=this;return this.shouldFetch(t,r,n)?this.fetch(t,{credentials:"same-origin",integrity:R.integrity[t],meta:n}).then((function(n){if(!n.ok)throw Error(e(7,[n.status,n.statusText,t,r].join(", ")));var o=n.headers.get("content-type");if(!o||!A.test(o))throw Error(e(4,o));return n.text().then((function(e){return e.indexOf("//# sourceURL=")<0&&(e+="\n//# sourceURL="+t),(0, eval)(e),i.getRegister(t)}))})):k.apply(this,arguments)},P.resolve=function(r,n){return u(R,t(r,n=n||p)||r,n)||function(t,r){throw Error(e(8,[t,r].join(", ")))}(r,n)};var F=P.instantiate;P.instantiate=function(e,t,r){var n=R.depcache[e];if(n)for(var i=0;i<n.length;i++)a(this,this.resolve(n[i],e),e);return F.call(this,e,t,r)},g&&"function"==typeof importScripts&&(P.instantiate=function(e){var t=this;return Promise.resolve().then((function(){return importScripts(e),t.getRegister(e)}))});}();
|
|
|
|
return s_min;
|
|
}
|
|
|
|
requireS_min();
|
|
|
|
})();
|