6785 lines
215 KiB
JavaScript
Executable File
6785 lines
215 KiB
JavaScript
Executable File
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_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 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 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_take = {};
|
|
|
|
var hasRequiredEs_iterator_take;
|
|
|
|
function requireEs_iterator_take () {
|
|
if (hasRequiredEs_iterator_take) return es_iterator_take;
|
|
hasRequiredEs_iterator_take = 1;
|
|
var $ = require_export();
|
|
var call = requireFunctionCall();
|
|
var anObject = requireAnObject();
|
|
var getIteratorDirect = requireGetIteratorDirect();
|
|
var notANaN = requireNotANan();
|
|
var toPositiveInteger = requireToPositiveInteger();
|
|
var createIteratorProxy = requireIteratorCreateProxy();
|
|
var iteratorClose = requireIteratorClose();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var IteratorProxy = createIteratorProxy(function () {
|
|
var iterator = this.iterator;
|
|
if (!this.remaining--) {
|
|
this.done = true;
|
|
return iteratorClose(iterator, 'normal', undefined);
|
|
}
|
|
var result = anObject(call(this.next, iterator));
|
|
var done = this.done = !!result.done;
|
|
if (!done) return result.value;
|
|
});
|
|
|
|
// `Iterator.prototype.take` method
|
|
// https://tc39.es/ecma262/#sec-iterator.prototype.take
|
|
$({ target: 'Iterator', proto: true, real: true, forced: IS_PURE }, {
|
|
take: function take(limit) {
|
|
anObject(this);
|
|
var remaining = toPositiveInteger(notANaN(+limit));
|
|
return new IteratorProxy(getIteratorDirect(this), {
|
|
remaining: remaining
|
|
});
|
|
}
|
|
});
|
|
return es_iterator_take;
|
|
}
|
|
|
|
requireEs_iterator_take();
|
|
|
|
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_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_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 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 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_suppressedError_constructor = {};
|
|
|
|
var errorStackClear;
|
|
var hasRequiredErrorStackClear;
|
|
|
|
function requireErrorStackClear () {
|
|
if (hasRequiredErrorStackClear) return errorStackClear;
|
|
hasRequiredErrorStackClear = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
var $Error = Error;
|
|
var replace = uncurryThis(''.replace);
|
|
|
|
var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
|
|
// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe
|
|
var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
|
|
var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
|
|
|
|
errorStackClear = function (stack, dropEntries) {
|
|
if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string' && !$Error.prepareStackTrace) {
|
|
while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
|
|
} return stack;
|
|
};
|
|
return errorStackClear;
|
|
}
|
|
|
|
var errorStackInstallable;
|
|
var hasRequiredErrorStackInstallable;
|
|
|
|
function requireErrorStackInstallable () {
|
|
if (hasRequiredErrorStackInstallable) return errorStackInstallable;
|
|
hasRequiredErrorStackInstallable = 1;
|
|
var fails = requireFails();
|
|
var createPropertyDescriptor = requireCreatePropertyDescriptor();
|
|
|
|
errorStackInstallable = !fails(function () {
|
|
var error = new Error('a');
|
|
if (!('stack' in error)) return true;
|
|
// eslint-disable-next-line es/no-object-defineproperty -- safe
|
|
Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
|
|
return error.stack !== 7;
|
|
});
|
|
return errorStackInstallable;
|
|
}
|
|
|
|
var errorStackInstall;
|
|
var hasRequiredErrorStackInstall;
|
|
|
|
function requireErrorStackInstall () {
|
|
if (hasRequiredErrorStackInstall) return errorStackInstall;
|
|
hasRequiredErrorStackInstall = 1;
|
|
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
|
|
var clearErrorStack = requireErrorStackClear();
|
|
var ERROR_STACK_INSTALLABLE = requireErrorStackInstallable();
|
|
|
|
// non-standard V8
|
|
var captureStackTrace = Error.captureStackTrace;
|
|
|
|
errorStackInstall = function (error, C, stack, dropEntries) {
|
|
if (ERROR_STACK_INSTALLABLE) {
|
|
if (captureStackTrace) captureStackTrace(error, C);
|
|
else createNonEnumerableProperty(error, 'stack', clearErrorStack(stack, dropEntries));
|
|
}
|
|
};
|
|
return errorStackInstall;
|
|
}
|
|
|
|
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 normalizeStringArgument;
|
|
var hasRequiredNormalizeStringArgument;
|
|
|
|
function requireNormalizeStringArgument () {
|
|
if (hasRequiredNormalizeStringArgument) return normalizeStringArgument;
|
|
hasRequiredNormalizeStringArgument = 1;
|
|
var toString = requireToString();
|
|
|
|
normalizeStringArgument = function (argument, $default) {
|
|
return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);
|
|
};
|
|
return normalizeStringArgument;
|
|
}
|
|
|
|
var hasRequiredEsnext_suppressedError_constructor;
|
|
|
|
function requireEsnext_suppressedError_constructor () {
|
|
if (hasRequiredEsnext_suppressedError_constructor) return esnext_suppressedError_constructor;
|
|
hasRequiredEsnext_suppressedError_constructor = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var isPrototypeOf = requireObjectIsPrototypeOf();
|
|
var getPrototypeOf = requireObjectGetPrototypeOf();
|
|
var setPrototypeOf = requireObjectSetPrototypeOf();
|
|
var copyConstructorProperties = requireCopyConstructorProperties();
|
|
var create = requireObjectCreate();
|
|
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
|
|
var createPropertyDescriptor = requireCreatePropertyDescriptor();
|
|
var installErrorStack = requireErrorStackInstall();
|
|
var normalizeStringArgument = requireNormalizeStringArgument();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var fails = requireFails();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var NativeSuppressedError = globalThis.SuppressedError;
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
var $Error = Error;
|
|
|
|
// https://github.com/oven-sh/bun/issues/9282
|
|
var WRONG_ARITY = !!NativeSuppressedError && NativeSuppressedError.length !== 3;
|
|
|
|
// https://github.com/oven-sh/bun/issues/9283
|
|
var EXTRA_ARGS_SUPPORT = !!NativeSuppressedError && fails(function () {
|
|
return new NativeSuppressedError(1, 2, 3, { cause: 4 }).cause === 4;
|
|
});
|
|
|
|
var PATCH = WRONG_ARITY || EXTRA_ARGS_SUPPORT;
|
|
|
|
var $SuppressedError = function SuppressedError(error, suppressed, message) {
|
|
var isInstance = isPrototypeOf(SuppressedErrorPrototype, this);
|
|
var that;
|
|
if (setPrototypeOf) {
|
|
that = PATCH && (!isInstance || getPrototypeOf(this) === SuppressedErrorPrototype)
|
|
? new NativeSuppressedError()
|
|
: setPrototypeOf(new $Error(), isInstance ? getPrototypeOf(this) : SuppressedErrorPrototype);
|
|
} else {
|
|
that = isInstance ? this : create(SuppressedErrorPrototype);
|
|
createNonEnumerableProperty(that, TO_STRING_TAG, 'Error');
|
|
}
|
|
if (message !== undefined) createNonEnumerableProperty(that, 'message', normalizeStringArgument(message));
|
|
installErrorStack(that, $SuppressedError, that.stack, 1);
|
|
createNonEnumerableProperty(that, 'error', error);
|
|
createNonEnumerableProperty(that, 'suppressed', suppressed);
|
|
return that;
|
|
};
|
|
|
|
if (setPrototypeOf) setPrototypeOf($SuppressedError, $Error);
|
|
else copyConstructorProperties($SuppressedError, $Error, { name: true });
|
|
|
|
var SuppressedErrorPrototype = $SuppressedError.prototype = PATCH ? NativeSuppressedError.prototype : create($Error.prototype, {
|
|
constructor: createPropertyDescriptor(1, $SuppressedError),
|
|
message: createPropertyDescriptor(1, ''),
|
|
name: createPropertyDescriptor(1, 'SuppressedError')
|
|
});
|
|
|
|
if (PATCH && !IS_PURE) SuppressedErrorPrototype.constructor = $SuppressedError;
|
|
|
|
// `SuppressedError` constructor
|
|
// https://github.com/tc39/proposal-explicit-resource-management
|
|
$({ global: true, constructor: true, arity: 3, forced: PATCH }, {
|
|
SuppressedError: $SuppressedError
|
|
});
|
|
return esnext_suppressedError_constructor;
|
|
}
|
|
|
|
requireEsnext_suppressedError_constructor();
|
|
|
|
var esnext_array_group = {};
|
|
|
|
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 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 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 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_asyncIterator_asyncDispose = {};
|
|
|
|
var asyncIteratorPrototype;
|
|
var hasRequiredAsyncIteratorPrototype;
|
|
|
|
function requireAsyncIteratorPrototype () {
|
|
if (hasRequiredAsyncIteratorPrototype) return asyncIteratorPrototype;
|
|
hasRequiredAsyncIteratorPrototype = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var shared = requireSharedStore();
|
|
var isCallable = requireIsCallable();
|
|
var create = requireObjectCreate();
|
|
var getPrototypeOf = requireObjectGetPrototypeOf();
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var USE_FUNCTION_CONSTRUCTOR = 'USE_FUNCTION_CONSTRUCTOR';
|
|
var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator');
|
|
var AsyncIterator = globalThis.AsyncIterator;
|
|
var PassedAsyncIteratorPrototype = shared.AsyncIteratorPrototype;
|
|
var AsyncIteratorPrototype, prototype;
|
|
|
|
if (PassedAsyncIteratorPrototype) {
|
|
AsyncIteratorPrototype = PassedAsyncIteratorPrototype;
|
|
} else if (isCallable(AsyncIterator)) {
|
|
AsyncIteratorPrototype = AsyncIterator.prototype;
|
|
} else if (shared[USE_FUNCTION_CONSTRUCTOR] || globalThis[USE_FUNCTION_CONSTRUCTOR]) {
|
|
try {
|
|
// eslint-disable-next-line no-new-func -- we have no alternatives without usage of modern syntax
|
|
prototype = getPrototypeOf(getPrototypeOf(getPrototypeOf(Function('return async function*(){}()')())));
|
|
if (getPrototypeOf(prototype) === Object.prototype) AsyncIteratorPrototype = prototype;
|
|
} catch (error) { /* empty */ }
|
|
}
|
|
|
|
if (!AsyncIteratorPrototype) AsyncIteratorPrototype = {};
|
|
else if (IS_PURE) AsyncIteratorPrototype = create(AsyncIteratorPrototype);
|
|
|
|
if (!isCallable(AsyncIteratorPrototype[ASYNC_ITERATOR])) {
|
|
defineBuiltIn(AsyncIteratorPrototype, ASYNC_ITERATOR, function () {
|
|
return this;
|
|
});
|
|
}
|
|
|
|
asyncIteratorPrototype = AsyncIteratorPrototype;
|
|
return asyncIteratorPrototype;
|
|
}
|
|
|
|
var hasRequiredEsnext_asyncIterator_asyncDispose;
|
|
|
|
function requireEsnext_asyncIterator_asyncDispose () {
|
|
if (hasRequiredEsnext_asyncIterator_asyncDispose) return esnext_asyncIterator_asyncDispose;
|
|
hasRequiredEsnext_asyncIterator_asyncDispose = 1;
|
|
// https://github.com/tc39/proposal-async-explicit-resource-management
|
|
var call = requireFunctionCall();
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
var getMethod = requireGetMethod();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var AsyncIteratorPrototype = requireAsyncIteratorPrototype();
|
|
|
|
var ASYNC_DISPOSE = wellKnownSymbol('asyncDispose');
|
|
var Promise = getBuiltIn('Promise');
|
|
|
|
if (!hasOwn(AsyncIteratorPrototype, ASYNC_DISPOSE)) {
|
|
defineBuiltIn(AsyncIteratorPrototype, ASYNC_DISPOSE, function () {
|
|
var O = this;
|
|
return new Promise(function (resolve, reject) {
|
|
var $return = getMethod(O, 'return');
|
|
if ($return) {
|
|
Promise.resolve(call($return, O)).then(function () {
|
|
resolve(undefined);
|
|
}, reject);
|
|
} else resolve(undefined);
|
|
});
|
|
});
|
|
}
|
|
return esnext_asyncIterator_asyncDispose;
|
|
}
|
|
|
|
requireEsnext_asyncIterator_asyncDispose();
|
|
|
|
var esnext_iterator_dispose = {};
|
|
|
|
var hasRequiredEsnext_iterator_dispose;
|
|
|
|
function requireEsnext_iterator_dispose () {
|
|
if (hasRequiredEsnext_iterator_dispose) return esnext_iterator_dispose;
|
|
hasRequiredEsnext_iterator_dispose = 1;
|
|
// https://github.com/tc39/proposal-explicit-resource-management
|
|
var call = requireFunctionCall();
|
|
var defineBuiltIn = requireDefineBuiltIn();
|
|
var getMethod = requireGetMethod();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
var IteratorPrototype = requireIteratorsCore().IteratorPrototype;
|
|
|
|
var DISPOSE = wellKnownSymbol('dispose');
|
|
|
|
if (!hasOwn(IteratorPrototype, DISPOSE)) {
|
|
defineBuiltIn(IteratorPrototype, DISPOSE, function () {
|
|
var $return = getMethod(this, 'return');
|
|
if ($return) call($return, this);
|
|
});
|
|
}
|
|
return esnext_iterator_dispose;
|
|
}
|
|
|
|
requireEsnext_iterator_dispose();
|
|
|
|
var esnext_json_parse = {};
|
|
|
|
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_symbol_asyncDispose = {};
|
|
|
|
var path;
|
|
var hasRequiredPath;
|
|
|
|
function requirePath () {
|
|
if (hasRequiredPath) return path;
|
|
hasRequiredPath = 1;
|
|
var globalThis = requireGlobalThis();
|
|
|
|
path = globalThis;
|
|
return path;
|
|
}
|
|
|
|
var wellKnownSymbolWrapped = {};
|
|
|
|
var hasRequiredWellKnownSymbolWrapped;
|
|
|
|
function requireWellKnownSymbolWrapped () {
|
|
if (hasRequiredWellKnownSymbolWrapped) return wellKnownSymbolWrapped;
|
|
hasRequiredWellKnownSymbolWrapped = 1;
|
|
var wellKnownSymbol = requireWellKnownSymbol();
|
|
|
|
wellKnownSymbolWrapped.f = wellKnownSymbol;
|
|
return wellKnownSymbolWrapped;
|
|
}
|
|
|
|
var wellKnownSymbolDefine;
|
|
var hasRequiredWellKnownSymbolDefine;
|
|
|
|
function requireWellKnownSymbolDefine () {
|
|
if (hasRequiredWellKnownSymbolDefine) return wellKnownSymbolDefine;
|
|
hasRequiredWellKnownSymbolDefine = 1;
|
|
var path = requirePath();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var wrappedWellKnownSymbolModule = requireWellKnownSymbolWrapped();
|
|
var defineProperty = requireObjectDefineProperty().f;
|
|
|
|
wellKnownSymbolDefine = function (NAME) {
|
|
var Symbol = path.Symbol || (path.Symbol = {});
|
|
if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {
|
|
value: wrappedWellKnownSymbolModule.f(NAME)
|
|
});
|
|
};
|
|
return wellKnownSymbolDefine;
|
|
}
|
|
|
|
var hasRequiredEsnext_symbol_asyncDispose;
|
|
|
|
function requireEsnext_symbol_asyncDispose () {
|
|
if (hasRequiredEsnext_symbol_asyncDispose) return esnext_symbol_asyncDispose;
|
|
hasRequiredEsnext_symbol_asyncDispose = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var defineWellKnownSymbol = requireWellKnownSymbolDefine();
|
|
var defineProperty = requireObjectDefineProperty().f;
|
|
var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
|
|
|
|
var Symbol = globalThis.Symbol;
|
|
|
|
// `Symbol.asyncDispose` well-known symbol
|
|
// https://github.com/tc39/proposal-async-explicit-resource-management
|
|
defineWellKnownSymbol('asyncDispose');
|
|
|
|
if (Symbol) {
|
|
var descriptor = getOwnPropertyDescriptor(Symbol, 'asyncDispose');
|
|
// workaround of NodeJS 20.4 bug
|
|
// https://github.com/nodejs/node/issues/48699
|
|
// and incorrect descriptor from some transpilers and userland helpers
|
|
if (descriptor.enumerable && descriptor.configurable && descriptor.writable) {
|
|
defineProperty(Symbol, 'asyncDispose', { value: descriptor.value, enumerable: false, configurable: false, writable: false });
|
|
}
|
|
}
|
|
return esnext_symbol_asyncDispose;
|
|
}
|
|
|
|
requireEsnext_symbol_asyncDispose();
|
|
|
|
var esnext_symbol_dispose = {};
|
|
|
|
var hasRequiredEsnext_symbol_dispose;
|
|
|
|
function requireEsnext_symbol_dispose () {
|
|
if (hasRequiredEsnext_symbol_dispose) return esnext_symbol_dispose;
|
|
hasRequiredEsnext_symbol_dispose = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var defineWellKnownSymbol = requireWellKnownSymbolDefine();
|
|
var defineProperty = requireObjectDefineProperty().f;
|
|
var getOwnPropertyDescriptor = requireObjectGetOwnPropertyDescriptor().f;
|
|
|
|
var Symbol = globalThis.Symbol;
|
|
|
|
// `Symbol.dispose` well-known symbol
|
|
// https://github.com/tc39/proposal-explicit-resource-management
|
|
defineWellKnownSymbol('dispose');
|
|
|
|
if (Symbol) {
|
|
var descriptor = getOwnPropertyDescriptor(Symbol, 'dispose');
|
|
// workaround of NodeJS 20.4 bug
|
|
// https://github.com/nodejs/node/issues/48699
|
|
// and incorrect descriptor from some transpilers and userland helpers
|
|
if (descriptor.enumerable && descriptor.configurable && descriptor.writable) {
|
|
defineProperty(Symbol, 'dispose', { value: descriptor.value, enumerable: false, configurable: false, writable: false });
|
|
}
|
|
}
|
|
return esnext_symbol_dispose;
|
|
}
|
|
|
|
requireEsnext_symbol_dispose();
|
|
|
|
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_domException_stack = {};
|
|
|
|
var inheritIfRequired;
|
|
var hasRequiredInheritIfRequired;
|
|
|
|
function requireInheritIfRequired () {
|
|
if (hasRequiredInheritIfRequired) return inheritIfRequired;
|
|
hasRequiredInheritIfRequired = 1;
|
|
var isCallable = requireIsCallable();
|
|
var isObject = requireIsObject();
|
|
var setPrototypeOf = requireObjectSetPrototypeOf();
|
|
|
|
// makes subclassing work correct for wrapped built-ins
|
|
inheritIfRequired = function ($this, dummy, Wrapper) {
|
|
var NewTarget, NewTargetPrototype;
|
|
if (
|
|
// it can work only with native `setPrototypeOf`
|
|
setPrototypeOf &&
|
|
// we haven't completely correct pre-ES6 way for getting `new.target`, so use this
|
|
isCallable(NewTarget = dummy.constructor) &&
|
|
NewTarget !== Wrapper &&
|
|
isObject(NewTargetPrototype = NewTarget.prototype) &&
|
|
NewTargetPrototype !== Wrapper.prototype
|
|
) setPrototypeOf($this, NewTargetPrototype);
|
|
return $this;
|
|
};
|
|
return inheritIfRequired;
|
|
}
|
|
|
|
var domExceptionConstants;
|
|
var hasRequiredDomExceptionConstants;
|
|
|
|
function requireDomExceptionConstants () {
|
|
if (hasRequiredDomExceptionConstants) return domExceptionConstants;
|
|
hasRequiredDomExceptionConstants = 1;
|
|
domExceptionConstants = {
|
|
IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 },
|
|
DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 },
|
|
HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 },
|
|
WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 },
|
|
InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 },
|
|
NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 },
|
|
NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 },
|
|
NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 },
|
|
NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 },
|
|
InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 },
|
|
InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 },
|
|
SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 },
|
|
InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 },
|
|
NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 },
|
|
InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 },
|
|
ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 },
|
|
TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 },
|
|
SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 },
|
|
NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 },
|
|
AbortError: { s: 'ABORT_ERR', c: 20, m: 1 },
|
|
URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 },
|
|
QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 },
|
|
TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 },
|
|
InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 },
|
|
DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 }
|
|
};
|
|
return domExceptionConstants;
|
|
}
|
|
|
|
var hasRequiredWeb_domException_stack;
|
|
|
|
function requireWeb_domException_stack () {
|
|
if (hasRequiredWeb_domException_stack) return web_domException_stack;
|
|
hasRequiredWeb_domException_stack = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
var createPropertyDescriptor = requireCreatePropertyDescriptor();
|
|
var defineProperty = requireObjectDefineProperty().f;
|
|
var hasOwn = requireHasOwnProperty();
|
|
var anInstance = requireAnInstance();
|
|
var inheritIfRequired = requireInheritIfRequired();
|
|
var normalizeStringArgument = requireNormalizeStringArgument();
|
|
var DOMExceptionConstants = requireDomExceptionConstants();
|
|
var clearErrorStack = requireErrorStackClear();
|
|
var DESCRIPTORS = requireDescriptors();
|
|
var IS_PURE = requireIsPure();
|
|
|
|
var DOM_EXCEPTION = 'DOMException';
|
|
var Error = getBuiltIn('Error');
|
|
var NativeDOMException = getBuiltIn(DOM_EXCEPTION);
|
|
|
|
var $DOMException = function DOMException() {
|
|
anInstance(this, DOMExceptionPrototype);
|
|
var argumentsLength = arguments.length;
|
|
var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]);
|
|
var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error');
|
|
var that = new NativeDOMException(message, name);
|
|
var error = new Error(message);
|
|
error.name = DOM_EXCEPTION;
|
|
defineProperty(that, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1)));
|
|
inheritIfRequired(that, this, $DOMException);
|
|
return that;
|
|
};
|
|
|
|
var DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype;
|
|
|
|
var ERROR_HAS_STACK = 'stack' in new Error(DOM_EXCEPTION);
|
|
var DOM_EXCEPTION_HAS_STACK = 'stack' in new NativeDOMException(1, 2);
|
|
|
|
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
|
|
var descriptor = NativeDOMException && DESCRIPTORS && Object.getOwnPropertyDescriptor(globalThis, DOM_EXCEPTION);
|
|
|
|
// Bun ~ 0.1.1 DOMException have incorrect descriptor and we can't redefine it
|
|
// https://github.com/Jarred-Sumner/bun/issues/399
|
|
var BUGGY_DESCRIPTOR = !!descriptor && !(descriptor.writable && descriptor.configurable);
|
|
|
|
var FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !BUGGY_DESCRIPTOR && !DOM_EXCEPTION_HAS_STACK;
|
|
|
|
// `DOMException` constructor patch for `.stack` where it's required
|
|
// https://webidl.spec.whatwg.org/#es-DOMException-specialness
|
|
$({ global: true, constructor: true, forced: IS_PURE || FORCED_CONSTRUCTOR }, { // TODO: fix export logic
|
|
DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException
|
|
});
|
|
|
|
var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION);
|
|
var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;
|
|
|
|
if (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) {
|
|
if (!IS_PURE) {
|
|
defineProperty(PolyfilledDOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, PolyfilledDOMException));
|
|
}
|
|
|
|
for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) {
|
|
var constant = DOMExceptionConstants[key];
|
|
var constantName = constant.s;
|
|
if (!hasOwn(PolyfilledDOMException, constantName)) {
|
|
defineProperty(PolyfilledDOMException, constantName, createPropertyDescriptor(6, constant.c));
|
|
}
|
|
}
|
|
}
|
|
return web_domException_stack;
|
|
}
|
|
|
|
requireWeb_domException_stack();
|
|
|
|
var web_immediate = {};
|
|
|
|
var web_clearImmediate = {};
|
|
|
|
var functionApply;
|
|
var hasRequiredFunctionApply;
|
|
|
|
function requireFunctionApply () {
|
|
if (hasRequiredFunctionApply) return functionApply;
|
|
hasRequiredFunctionApply = 1;
|
|
var NATIVE_BIND = requireFunctionBindNative();
|
|
|
|
var FunctionPrototype = Function.prototype;
|
|
var apply = FunctionPrototype.apply;
|
|
var call = FunctionPrototype.call;
|
|
|
|
// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
|
|
functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
|
|
return call.apply(apply, arguments);
|
|
});
|
|
return functionApply;
|
|
}
|
|
|
|
var arraySlice;
|
|
var hasRequiredArraySlice;
|
|
|
|
function requireArraySlice () {
|
|
if (hasRequiredArraySlice) return arraySlice;
|
|
hasRequiredArraySlice = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
arraySlice = uncurryThis([].slice);
|
|
return arraySlice;
|
|
}
|
|
|
|
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 environmentIsIos;
|
|
var hasRequiredEnvironmentIsIos;
|
|
|
|
function requireEnvironmentIsIos () {
|
|
if (hasRequiredEnvironmentIsIos) return environmentIsIos;
|
|
hasRequiredEnvironmentIsIos = 1;
|
|
var userAgent = requireEnvironmentUserAgent();
|
|
|
|
// eslint-disable-next-line redos/no-vulnerable -- safe
|
|
environmentIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
|
|
return environmentIsIos;
|
|
}
|
|
|
|
var task;
|
|
var hasRequiredTask;
|
|
|
|
function requireTask () {
|
|
if (hasRequiredTask) return task;
|
|
hasRequiredTask = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var apply = requireFunctionApply();
|
|
var bind = requireFunctionBindContext();
|
|
var isCallable = requireIsCallable();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var fails = requireFails();
|
|
var html = requireHtml();
|
|
var arraySlice = requireArraySlice();
|
|
var createElement = requireDocumentCreateElement();
|
|
var validateArgumentsLength = requireValidateArgumentsLength();
|
|
var IS_IOS = requireEnvironmentIsIos();
|
|
var IS_NODE = requireEnvironmentIsNode();
|
|
|
|
var set = globalThis.setImmediate;
|
|
var clear = globalThis.clearImmediate;
|
|
var process = globalThis.process;
|
|
var Dispatch = globalThis.Dispatch;
|
|
var Function = globalThis.Function;
|
|
var MessageChannel = globalThis.MessageChannel;
|
|
var String = globalThis.String;
|
|
var counter = 0;
|
|
var queue = {};
|
|
var ONREADYSTATECHANGE = 'onreadystatechange';
|
|
var $location, defer, channel, port;
|
|
|
|
fails(function () {
|
|
// Deno throws a ReferenceError on `location` access without `--location` flag
|
|
$location = globalThis.location;
|
|
});
|
|
|
|
var run = function (id) {
|
|
if (hasOwn(queue, id)) {
|
|
var fn = queue[id];
|
|
delete queue[id];
|
|
fn();
|
|
}
|
|
};
|
|
|
|
var runner = function (id) {
|
|
return function () {
|
|
run(id);
|
|
};
|
|
};
|
|
|
|
var eventListener = function (event) {
|
|
run(event.data);
|
|
};
|
|
|
|
var globalPostMessageDefer = function (id) {
|
|
// old engines have not location.origin
|
|
globalThis.postMessage(String(id), $location.protocol + '//' + $location.host);
|
|
};
|
|
|
|
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
|
|
if (!set || !clear) {
|
|
set = function setImmediate(handler) {
|
|
validateArgumentsLength(arguments.length, 1);
|
|
var fn = isCallable(handler) ? handler : Function(handler);
|
|
var args = arraySlice(arguments, 1);
|
|
queue[++counter] = function () {
|
|
apply(fn, undefined, args);
|
|
};
|
|
defer(counter);
|
|
return counter;
|
|
};
|
|
clear = function clearImmediate(id) {
|
|
delete queue[id];
|
|
};
|
|
// Node.js 0.8-
|
|
if (IS_NODE) {
|
|
defer = function (id) {
|
|
process.nextTick(runner(id));
|
|
};
|
|
// Sphere (JS game engine) Dispatch API
|
|
} else if (Dispatch && Dispatch.now) {
|
|
defer = function (id) {
|
|
Dispatch.now(runner(id));
|
|
};
|
|
// Browsers with MessageChannel, includes WebWorkers
|
|
// except iOS - https://github.com/zloirock/core-js/issues/624
|
|
} else if (MessageChannel && !IS_IOS) {
|
|
channel = new MessageChannel();
|
|
port = channel.port2;
|
|
channel.port1.onmessage = eventListener;
|
|
defer = bind(port.postMessage, port);
|
|
// Browsers with postMessage, skip WebWorkers
|
|
// IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
|
|
} else if (
|
|
globalThis.addEventListener &&
|
|
isCallable(globalThis.postMessage) &&
|
|
!globalThis.importScripts &&
|
|
$location && $location.protocol !== 'file:' &&
|
|
!fails(globalPostMessageDefer)
|
|
) {
|
|
defer = globalPostMessageDefer;
|
|
globalThis.addEventListener('message', eventListener, false);
|
|
// IE8-
|
|
} else if (ONREADYSTATECHANGE in createElement('script')) {
|
|
defer = function (id) {
|
|
html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
|
|
html.removeChild(this);
|
|
run(id);
|
|
};
|
|
};
|
|
// Rest old browsers
|
|
} else {
|
|
defer = function (id) {
|
|
setTimeout(runner(id), 0);
|
|
};
|
|
}
|
|
}
|
|
|
|
task = {
|
|
set: set,
|
|
clear: clear
|
|
};
|
|
return task;
|
|
}
|
|
|
|
var hasRequiredWeb_clearImmediate;
|
|
|
|
function requireWeb_clearImmediate () {
|
|
if (hasRequiredWeb_clearImmediate) return web_clearImmediate;
|
|
hasRequiredWeb_clearImmediate = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var clearImmediate = requireTask().clear;
|
|
|
|
// `clearImmediate` method
|
|
// http://w3c.github.io/setImmediate/#si-clearImmediate
|
|
$({ global: true, bind: true, enumerable: true, forced: globalThis.clearImmediate !== clearImmediate }, {
|
|
clearImmediate: clearImmediate
|
|
});
|
|
return web_clearImmediate;
|
|
}
|
|
|
|
var web_setImmediate = {};
|
|
|
|
var schedulersFix;
|
|
var hasRequiredSchedulersFix;
|
|
|
|
function requireSchedulersFix () {
|
|
if (hasRequiredSchedulersFix) return schedulersFix;
|
|
hasRequiredSchedulersFix = 1;
|
|
var globalThis = requireGlobalThis();
|
|
var apply = requireFunctionApply();
|
|
var isCallable = requireIsCallable();
|
|
var ENVIRONMENT = requireEnvironment();
|
|
var USER_AGENT = requireEnvironmentUserAgent();
|
|
var arraySlice = requireArraySlice();
|
|
var validateArgumentsLength = requireValidateArgumentsLength();
|
|
|
|
var Function = globalThis.Function;
|
|
// dirty IE9- and Bun 0.3.0- checks
|
|
var WRAP = /MSIE .\./.test(USER_AGENT) || ENVIRONMENT === 'BUN' && (function () {
|
|
var version = globalThis.Bun.version.split('.');
|
|
return version.length < 3 || version[0] === '0' && (version[1] < 3 || version[1] === '3' && version[2] === '0');
|
|
})();
|
|
|
|
// IE9- / Bun 0.3.0- setTimeout / setInterval / setImmediate additional parameters fix
|
|
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers
|
|
// https://github.com/oven-sh/bun/issues/1633
|
|
schedulersFix = function (scheduler, hasTimeArg) {
|
|
var firstParamIndex = hasTimeArg ? 2 : 1;
|
|
return WRAP ? function (handler, timeout /* , ...arguments */) {
|
|
var boundArgs = validateArgumentsLength(arguments.length, 1) > firstParamIndex;
|
|
var fn = isCallable(handler) ? handler : Function(handler);
|
|
var params = boundArgs ? arraySlice(arguments, firstParamIndex) : [];
|
|
var callback = boundArgs ? function () {
|
|
apply(fn, this, params);
|
|
} : fn;
|
|
return hasTimeArg ? scheduler(callback, timeout) : scheduler(callback);
|
|
} : scheduler;
|
|
};
|
|
return schedulersFix;
|
|
}
|
|
|
|
var hasRequiredWeb_setImmediate;
|
|
|
|
function requireWeb_setImmediate () {
|
|
if (hasRequiredWeb_setImmediate) return web_setImmediate;
|
|
hasRequiredWeb_setImmediate = 1;
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var setTask = requireTask().set;
|
|
var schedulersFix = requireSchedulersFix();
|
|
|
|
// https://github.com/oven-sh/bun/issues/1633
|
|
var setImmediate = globalThis.setImmediate ? schedulersFix(setTask, false) : setTask;
|
|
|
|
// `setImmediate` method
|
|
// http://w3c.github.io/setImmediate/#si-setImmediate
|
|
$({ global: true, bind: true, enumerable: true, forced: globalThis.setImmediate !== setImmediate }, {
|
|
setImmediate: setImmediate
|
|
});
|
|
return web_setImmediate;
|
|
}
|
|
|
|
var hasRequiredWeb_immediate;
|
|
|
|
function requireWeb_immediate () {
|
|
if (hasRequiredWeb_immediate) return web_immediate;
|
|
hasRequiredWeb_immediate = 1;
|
|
// TODO: Remove this module from `core-js@4` since it's split to modules listed below
|
|
requireWeb_clearImmediate();
|
|
requireWeb_setImmediate();
|
|
return web_immediate;
|
|
}
|
|
|
|
requireWeb_immediate();
|
|
|
|
var web_structuredClone = {};
|
|
|
|
var isConstructor;
|
|
var hasRequiredIsConstructor;
|
|
|
|
function requireIsConstructor () {
|
|
if (hasRequiredIsConstructor) return isConstructor;
|
|
hasRequiredIsConstructor = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var fails = requireFails();
|
|
var isCallable = requireIsCallable();
|
|
var classof = requireClassof();
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
var inspectSource = requireInspectSource();
|
|
|
|
var noop = function () { /* empty */ };
|
|
var construct = getBuiltIn('Reflect', 'construct');
|
|
var constructorRegExp = /^\s*(?:class|function)\b/;
|
|
var exec = uncurryThis(constructorRegExp.exec);
|
|
var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
|
|
|
|
var isConstructorModern = function isConstructor(argument) {
|
|
if (!isCallable(argument)) return false;
|
|
try {
|
|
construct(noop, [], argument);
|
|
return true;
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
var isConstructorLegacy = function isConstructor(argument) {
|
|
if (!isCallable(argument)) return false;
|
|
switch (classof(argument)) {
|
|
case 'AsyncFunction':
|
|
case 'GeneratorFunction':
|
|
case 'AsyncGeneratorFunction': return false;
|
|
}
|
|
try {
|
|
// we can't check .prototype since constructors produced by .bind haven't it
|
|
// `Function#toString` throws on some built-it function in some legacy engines
|
|
// (for example, `DOMQuad` and similar in FF41-)
|
|
return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
isConstructorLegacy.sham = true;
|
|
|
|
// `IsConstructor` abstract operation
|
|
// https://tc39.es/ecma262/#sec-isconstructor
|
|
isConstructor = !construct || fails(function () {
|
|
var called;
|
|
return isConstructorModern(isConstructorModern.call)
|
|
|| !isConstructorModern(Object)
|
|
|| !isConstructorModern(function () { called = true; })
|
|
|| called;
|
|
}) ? isConstructorLegacy : isConstructorModern;
|
|
return isConstructor;
|
|
}
|
|
|
|
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 regexpGetFlags;
|
|
var hasRequiredRegexpGetFlags;
|
|
|
|
function requireRegexpGetFlags () {
|
|
if (hasRequiredRegexpGetFlags) return regexpGetFlags;
|
|
hasRequiredRegexpGetFlags = 1;
|
|
var call = requireFunctionCall();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var isPrototypeOf = requireObjectIsPrototypeOf();
|
|
var regExpFlags = requireRegexpFlags();
|
|
|
|
var RegExpPrototype = RegExp.prototype;
|
|
|
|
regexpGetFlags = function (R) {
|
|
var flags = R.flags;
|
|
return flags === undefined && !('flags' in RegExpPrototype) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype, R)
|
|
? call(regExpFlags, R) : flags;
|
|
};
|
|
return regexpGetFlags;
|
|
}
|
|
|
|
var mapHelpers;
|
|
var hasRequiredMapHelpers;
|
|
|
|
function requireMapHelpers () {
|
|
if (hasRequiredMapHelpers) return mapHelpers;
|
|
hasRequiredMapHelpers = 1;
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
|
|
// eslint-disable-next-line es/no-map -- safe
|
|
var MapPrototype = Map.prototype;
|
|
|
|
mapHelpers = {
|
|
// eslint-disable-next-line es/no-map -- safe
|
|
Map: Map,
|
|
set: uncurryThis(MapPrototype.set),
|
|
get: uncurryThis(MapPrototype.get),
|
|
has: uncurryThis(MapPrototype.has),
|
|
remove: uncurryThis(MapPrototype['delete']),
|
|
proto: MapPrototype
|
|
};
|
|
return mapHelpers;
|
|
}
|
|
|
|
var hasRequiredWeb_structuredClone;
|
|
|
|
function requireWeb_structuredClone () {
|
|
if (hasRequiredWeb_structuredClone) return web_structuredClone;
|
|
hasRequiredWeb_structuredClone = 1;
|
|
var IS_PURE = requireIsPure();
|
|
var $ = require_export();
|
|
var globalThis = requireGlobalThis();
|
|
var getBuiltIn = requireGetBuiltIn();
|
|
var uncurryThis = requireFunctionUncurryThis();
|
|
var fails = requireFails();
|
|
var uid = requireUid();
|
|
var isCallable = requireIsCallable();
|
|
var isConstructor = requireIsConstructor();
|
|
var isNullOrUndefined = requireIsNullOrUndefined();
|
|
var isObject = requireIsObject();
|
|
var isSymbol = requireIsSymbol();
|
|
var iterate = requireIterate();
|
|
var anObject = requireAnObject();
|
|
var classof = requireClassof();
|
|
var hasOwn = requireHasOwnProperty();
|
|
var createProperty = requireCreateProperty();
|
|
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
|
|
var lengthOfArrayLike = requireLengthOfArrayLike();
|
|
var validateArgumentsLength = requireValidateArgumentsLength();
|
|
var getRegExpFlags = requireRegexpGetFlags();
|
|
var MapHelpers = requireMapHelpers();
|
|
var SetHelpers = requireSetHelpers();
|
|
var setIterate = requireSetIterate();
|
|
var detachTransferable = requireDetachTransferable();
|
|
var ERROR_STACK_INSTALLABLE = requireErrorStackInstallable();
|
|
var PROPER_STRUCTURED_CLONE_TRANSFER = requireStructuredCloneProperTransfer();
|
|
|
|
var Object = globalThis.Object;
|
|
var Array = globalThis.Array;
|
|
var Date = globalThis.Date;
|
|
var Error = globalThis.Error;
|
|
var TypeError = globalThis.TypeError;
|
|
var PerformanceMark = globalThis.PerformanceMark;
|
|
var DOMException = getBuiltIn('DOMException');
|
|
var Map = MapHelpers.Map;
|
|
var mapHas = MapHelpers.has;
|
|
var mapGet = MapHelpers.get;
|
|
var mapSet = MapHelpers.set;
|
|
var Set = SetHelpers.Set;
|
|
var setAdd = SetHelpers.add;
|
|
var setHas = SetHelpers.has;
|
|
var objectKeys = getBuiltIn('Object', 'keys');
|
|
var push = uncurryThis([].push);
|
|
var thisBooleanValue = uncurryThis(true.valueOf);
|
|
var thisNumberValue = uncurryThis(1.0.valueOf);
|
|
var thisStringValue = uncurryThis(''.valueOf);
|
|
var thisTimeValue = uncurryThis(Date.prototype.getTime);
|
|
var PERFORMANCE_MARK = uid('structuredClone');
|
|
var DATA_CLONE_ERROR = 'DataCloneError';
|
|
var TRANSFERRING = 'Transferring';
|
|
|
|
var checkBasicSemantic = function (structuredCloneImplementation) {
|
|
return !fails(function () {
|
|
var set1 = new globalThis.Set([7]);
|
|
var set2 = structuredCloneImplementation(set1);
|
|
var number = structuredCloneImplementation(Object(7));
|
|
return set2 === set1 || !set2.has(7) || !isObject(number) || +number !== 7;
|
|
}) && structuredCloneImplementation;
|
|
};
|
|
|
|
var checkErrorsCloning = function (structuredCloneImplementation, $Error) {
|
|
return !fails(function () {
|
|
var error = new $Error();
|
|
var test = structuredCloneImplementation({ a: error, b: error });
|
|
return !(test && test.a === test.b && test.a instanceof $Error && test.a.stack === error.stack);
|
|
});
|
|
};
|
|
|
|
// https://github.com/whatwg/html/pull/5749
|
|
var checkNewErrorsCloningSemantic = function (structuredCloneImplementation) {
|
|
return !fails(function () {
|
|
var test = structuredCloneImplementation(new globalThis.AggregateError([1], PERFORMANCE_MARK, { cause: 3 }));
|
|
return test.name !== 'AggregateError' || test.errors[0] !== 1 || test.message !== PERFORMANCE_MARK || test.cause !== 3;
|
|
});
|
|
};
|
|
|
|
// FF94+, Safari 15.4+, Chrome 98+, NodeJS 17.0+, Deno 1.13+
|
|
// FF<103 and Safari implementations can't clone errors
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=1556604
|
|
// FF103 can clone errors, but `.stack` of clone is an empty string
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=1778762
|
|
// FF104+ fixed it on usual errors, but not on DOMExceptions
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=1777321
|
|
// Chrome <102 returns `null` if cloned object contains multiple references to one error
|
|
// https://bugs.chromium.org/p/v8/issues/detail?id=12542
|
|
// NodeJS implementation can't clone DOMExceptions
|
|
// https://github.com/nodejs/node/issues/41038
|
|
// only FF103+ supports new (html/5749) error cloning semantic
|
|
var nativeStructuredClone = globalThis.structuredClone;
|
|
|
|
var FORCED_REPLACEMENT = IS_PURE
|
|
|| !checkErrorsCloning(nativeStructuredClone, Error)
|
|
|| !checkErrorsCloning(nativeStructuredClone, DOMException)
|
|
|| !checkNewErrorsCloningSemantic(nativeStructuredClone);
|
|
|
|
// Chrome 82+, Safari 14.1+, Deno 1.11+
|
|
// Chrome 78-81 implementation swaps `.name` and `.message` of cloned `DOMException`
|
|
// Chrome returns `null` if cloned object contains multiple references to one error
|
|
// Safari 14.1 implementation doesn't clone some `RegExp` flags, so requires a workaround
|
|
// Safari implementation can't clone errors
|
|
// Deno 1.2-1.10 implementations too naive
|
|
// NodeJS 16.0+ does not have `PerformanceMark` constructor
|
|
// NodeJS <17.2 structured cloning implementation from `performance.mark` is too naive
|
|
// and can't clone, for example, `RegExp` or some boxed primitives
|
|
// https://github.com/nodejs/node/issues/40840
|
|
// no one of those implementations supports new (html/5749) error cloning semantic
|
|
var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function (value) {
|
|
return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail;
|
|
});
|
|
|
|
var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark;
|
|
|
|
var throwUncloneable = function (type) {
|
|
throw new DOMException('Uncloneable type: ' + type, DATA_CLONE_ERROR);
|
|
};
|
|
|
|
var throwUnpolyfillable = function (type, action) {
|
|
throw new DOMException((action || 'Cloning') + ' of ' + type + ' cannot be properly polyfilled in this engine', DATA_CLONE_ERROR);
|
|
};
|
|
|
|
var tryNativeRestrictedStructuredClone = function (value, type) {
|
|
if (!nativeRestrictedStructuredClone) throwUnpolyfillable(type);
|
|
return nativeRestrictedStructuredClone(value);
|
|
};
|
|
|
|
var createDataTransfer = function () {
|
|
var dataTransfer;
|
|
try {
|
|
dataTransfer = new globalThis.DataTransfer();
|
|
} catch (error) {
|
|
try {
|
|
dataTransfer = new globalThis.ClipboardEvent('').clipboardData;
|
|
} catch (error2) { /* empty */ }
|
|
}
|
|
return dataTransfer && dataTransfer.items && dataTransfer.files ? dataTransfer : null;
|
|
};
|
|
|
|
var cloneBuffer = function (value, map, $type) {
|
|
if (mapHas(map, value)) return mapGet(map, value);
|
|
|
|
var type = $type || classof(value);
|
|
var clone, length, options, source, target, i;
|
|
|
|
if (type === 'SharedArrayBuffer') {
|
|
if (nativeRestrictedStructuredClone) clone = nativeRestrictedStructuredClone(value);
|
|
// SharedArrayBuffer should use shared memory, we can't polyfill it, so return the original
|
|
else clone = value;
|
|
} else {
|
|
var DataView = globalThis.DataView;
|
|
|
|
// `ArrayBuffer#slice` is not available in IE10
|
|
// `ArrayBuffer#slice` and `DataView` are not available in old FF
|
|
if (!DataView && !isCallable(value.slice)) throwUnpolyfillable('ArrayBuffer');
|
|
// detached buffers throws in `DataView` and `.slice`
|
|
try {
|
|
if (isCallable(value.slice) && !value.resizable) {
|
|
clone = value.slice(0);
|
|
} else {
|
|
length = value.byteLength;
|
|
options = 'maxByteLength' in value ? { maxByteLength: value.maxByteLength } : undefined;
|
|
// eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe
|
|
clone = new ArrayBuffer(length, options);
|
|
source = new DataView(value);
|
|
target = new DataView(clone);
|
|
for (i = 0; i < length; i++) {
|
|
target.setUint8(i, source.getUint8(i));
|
|
}
|
|
}
|
|
} catch (error) {
|
|
throw new DOMException('ArrayBuffer is detached', DATA_CLONE_ERROR);
|
|
}
|
|
}
|
|
|
|
mapSet(map, value, clone);
|
|
|
|
return clone;
|
|
};
|
|
|
|
var cloneView = function (value, type, offset, length, map) {
|
|
var C = globalThis[type];
|
|
// in some old engines like Safari 9, typeof C is 'object'
|
|
// on Uint8ClampedArray or some other constructors
|
|
if (!isObject(C)) throwUnpolyfillable(type);
|
|
return new C(cloneBuffer(value.buffer, map), offset, length);
|
|
};
|
|
|
|
var structuredCloneInternal = function (value, map) {
|
|
if (isSymbol(value)) throwUncloneable('Symbol');
|
|
if (!isObject(value)) return value;
|
|
// effectively preserves circular references
|
|
if (map) {
|
|
if (mapHas(map, value)) return mapGet(map, value);
|
|
} else map = new Map();
|
|
|
|
var type = classof(value);
|
|
var C, name, cloned, dataTransfer, i, length, keys, key;
|
|
|
|
switch (type) {
|
|
case 'Array':
|
|
cloned = Array(lengthOfArrayLike(value));
|
|
break;
|
|
case 'Object':
|
|
cloned = {};
|
|
break;
|
|
case 'Map':
|
|
cloned = new Map();
|
|
break;
|
|
case 'Set':
|
|
cloned = new Set();
|
|
break;
|
|
case 'RegExp':
|
|
// in this block because of a Safari 14.1 bug
|
|
// old FF does not clone regexes passed to the constructor, so get the source and flags directly
|
|
cloned = new RegExp(value.source, getRegExpFlags(value));
|
|
break;
|
|
case 'Error':
|
|
name = value.name;
|
|
switch (name) {
|
|
case 'AggregateError':
|
|
cloned = new (getBuiltIn(name))([]);
|
|
break;
|
|
case 'EvalError':
|
|
case 'RangeError':
|
|
case 'ReferenceError':
|
|
case 'SuppressedError':
|
|
case 'SyntaxError':
|
|
case 'TypeError':
|
|
case 'URIError':
|
|
cloned = new (getBuiltIn(name))();
|
|
break;
|
|
case 'CompileError':
|
|
case 'LinkError':
|
|
case 'RuntimeError':
|
|
cloned = new (getBuiltIn('WebAssembly', name))();
|
|
break;
|
|
default:
|
|
cloned = new Error();
|
|
}
|
|
break;
|
|
case 'DOMException':
|
|
cloned = new DOMException(value.message, value.name);
|
|
break;
|
|
case 'ArrayBuffer':
|
|
case 'SharedArrayBuffer':
|
|
cloned = cloneBuffer(value, map, type);
|
|
break;
|
|
case 'DataView':
|
|
case 'Int8Array':
|
|
case 'Uint8Array':
|
|
case 'Uint8ClampedArray':
|
|
case 'Int16Array':
|
|
case 'Uint16Array':
|
|
case 'Int32Array':
|
|
case 'Uint32Array':
|
|
case 'Float16Array':
|
|
case 'Float32Array':
|
|
case 'Float64Array':
|
|
case 'BigInt64Array':
|
|
case 'BigUint64Array':
|
|
length = type === 'DataView' ? value.byteLength : value.length;
|
|
cloned = cloneView(value, type, value.byteOffset, length, map);
|
|
break;
|
|
case 'DOMQuad':
|
|
try {
|
|
cloned = new DOMQuad(
|
|
structuredCloneInternal(value.p1, map),
|
|
structuredCloneInternal(value.p2, map),
|
|
structuredCloneInternal(value.p3, map),
|
|
structuredCloneInternal(value.p4, map)
|
|
);
|
|
} catch (error) {
|
|
cloned = tryNativeRestrictedStructuredClone(value, type);
|
|
}
|
|
break;
|
|
case 'File':
|
|
if (nativeRestrictedStructuredClone) try {
|
|
cloned = nativeRestrictedStructuredClone(value);
|
|
// NodeJS 20.0.0 bug, https://github.com/nodejs/node/issues/47612
|
|
if (classof(cloned) !== type) cloned = undefined;
|
|
} catch (error) { /* empty */ }
|
|
if (!cloned) try {
|
|
cloned = new File([value], value.name, value);
|
|
} catch (error) { /* empty */ }
|
|
if (!cloned) throwUnpolyfillable(type);
|
|
break;
|
|
case 'FileList':
|
|
dataTransfer = createDataTransfer();
|
|
if (dataTransfer) {
|
|
for (i = 0, length = lengthOfArrayLike(value); i < length; i++) {
|
|
dataTransfer.items.add(structuredCloneInternal(value[i], map));
|
|
}
|
|
cloned = dataTransfer.files;
|
|
} else cloned = tryNativeRestrictedStructuredClone(value, type);
|
|
break;
|
|
case 'ImageData':
|
|
// Safari 9 ImageData is a constructor, but typeof ImageData is 'object'
|
|
try {
|
|
cloned = new ImageData(
|
|
structuredCloneInternal(value.data, map),
|
|
value.width,
|
|
value.height,
|
|
{ colorSpace: value.colorSpace }
|
|
);
|
|
} catch (error) {
|
|
cloned = tryNativeRestrictedStructuredClone(value, type);
|
|
} break;
|
|
default:
|
|
if (nativeRestrictedStructuredClone) {
|
|
cloned = nativeRestrictedStructuredClone(value);
|
|
} else switch (type) {
|
|
case 'BigInt':
|
|
// can be a 3rd party polyfill
|
|
cloned = Object(value.valueOf());
|
|
break;
|
|
case 'Boolean':
|
|
cloned = Object(thisBooleanValue(value));
|
|
break;
|
|
case 'Number':
|
|
cloned = Object(thisNumberValue(value));
|
|
break;
|
|
case 'String':
|
|
cloned = Object(thisStringValue(value));
|
|
break;
|
|
case 'Date':
|
|
cloned = new Date(thisTimeValue(value));
|
|
break;
|
|
case 'Blob':
|
|
try {
|
|
cloned = value.slice(0, value.size, value.type);
|
|
} catch (error) {
|
|
throwUnpolyfillable(type);
|
|
} break;
|
|
case 'DOMPoint':
|
|
case 'DOMPointReadOnly':
|
|
C = globalThis[type];
|
|
try {
|
|
cloned = C.fromPoint
|
|
? C.fromPoint(value)
|
|
: new C(value.x, value.y, value.z, value.w);
|
|
} catch (error) {
|
|
throwUnpolyfillable(type);
|
|
} break;
|
|
case 'DOMRect':
|
|
case 'DOMRectReadOnly':
|
|
C = globalThis[type];
|
|
try {
|
|
cloned = C.fromRect
|
|
? C.fromRect(value)
|
|
: new C(value.x, value.y, value.width, value.height);
|
|
} catch (error) {
|
|
throwUnpolyfillable(type);
|
|
} break;
|
|
case 'DOMMatrix':
|
|
case 'DOMMatrixReadOnly':
|
|
C = globalThis[type];
|
|
try {
|
|
cloned = C.fromMatrix
|
|
? C.fromMatrix(value)
|
|
: new C(value);
|
|
} catch (error) {
|
|
throwUnpolyfillable(type);
|
|
} break;
|
|
case 'AudioData':
|
|
case 'VideoFrame':
|
|
if (!isCallable(value.clone)) throwUnpolyfillable(type);
|
|
try {
|
|
cloned = value.clone();
|
|
} catch (error) {
|
|
throwUncloneable(type);
|
|
} break;
|
|
case 'CropTarget':
|
|
case 'CryptoKey':
|
|
case 'FileSystemDirectoryHandle':
|
|
case 'FileSystemFileHandle':
|
|
case 'FileSystemHandle':
|
|
case 'GPUCompilationInfo':
|
|
case 'GPUCompilationMessage':
|
|
case 'ImageBitmap':
|
|
case 'RTCCertificate':
|
|
case 'WebAssembly.Module':
|
|
throwUnpolyfillable(type);
|
|
// break omitted
|
|
default:
|
|
throwUncloneable(type);
|
|
}
|
|
}
|
|
|
|
mapSet(map, value, cloned);
|
|
|
|
switch (type) {
|
|
case 'Array':
|
|
case 'Object':
|
|
keys = objectKeys(value);
|
|
for (i = 0, length = lengthOfArrayLike(keys); i < length; i++) {
|
|
key = keys[i];
|
|
createProperty(cloned, key, structuredCloneInternal(value[key], map));
|
|
} break;
|
|
case 'Map':
|
|
value.forEach(function (v, k) {
|
|
mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map));
|
|
});
|
|
break;
|
|
case 'Set':
|
|
value.forEach(function (v) {
|
|
setAdd(cloned, structuredCloneInternal(v, map));
|
|
});
|
|
break;
|
|
case 'Error':
|
|
createNonEnumerableProperty(cloned, 'message', structuredCloneInternal(value.message, map));
|
|
if (hasOwn(value, 'cause')) {
|
|
createNonEnumerableProperty(cloned, 'cause', structuredCloneInternal(value.cause, map));
|
|
}
|
|
if (name === 'AggregateError') {
|
|
cloned.errors = structuredCloneInternal(value.errors, map);
|
|
} else if (name === 'SuppressedError') {
|
|
cloned.error = structuredCloneInternal(value.error, map);
|
|
cloned.suppressed = structuredCloneInternal(value.suppressed, map);
|
|
} // break omitted
|
|
case 'DOMException':
|
|
if (ERROR_STACK_INSTALLABLE) {
|
|
createNonEnumerableProperty(cloned, 'stack', structuredCloneInternal(value.stack, map));
|
|
}
|
|
}
|
|
|
|
return cloned;
|
|
};
|
|
|
|
var tryToTransfer = function (rawTransfer, map) {
|
|
if (!isObject(rawTransfer)) throw new TypeError('Transfer option cannot be converted to a sequence');
|
|
|
|
var transfer = [];
|
|
|
|
iterate(rawTransfer, function (value) {
|
|
push(transfer, anObject(value));
|
|
});
|
|
|
|
var i = 0;
|
|
var length = lengthOfArrayLike(transfer);
|
|
var buffers = new Set();
|
|
var value, type, C, transferred, canvas, context;
|
|
|
|
while (i < length) {
|
|
value = transfer[i++];
|
|
|
|
type = classof(value);
|
|
|
|
if (type === 'ArrayBuffer' ? setHas(buffers, value) : mapHas(map, value)) {
|
|
throw new DOMException('Duplicate transferable', DATA_CLONE_ERROR);
|
|
}
|
|
|
|
if (type === 'ArrayBuffer') {
|
|
setAdd(buffers, value);
|
|
continue;
|
|
}
|
|
|
|
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
|
transferred = nativeStructuredClone(value, { transfer: [value] });
|
|
} else switch (type) {
|
|
case 'ImageBitmap':
|
|
C = globalThis.OffscreenCanvas;
|
|
if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING);
|
|
try {
|
|
canvas = new C(value.width, value.height);
|
|
context = canvas.getContext('bitmaprenderer');
|
|
context.transferFromImageBitmap(value);
|
|
transferred = canvas.transferToImageBitmap();
|
|
} catch (error) { /* empty */ }
|
|
break;
|
|
case 'AudioData':
|
|
case 'VideoFrame':
|
|
if (!isCallable(value.clone) || !isCallable(value.close)) throwUnpolyfillable(type, TRANSFERRING);
|
|
try {
|
|
transferred = value.clone();
|
|
value.close();
|
|
} catch (error) { /* empty */ }
|
|
break;
|
|
case 'MediaSourceHandle':
|
|
case 'MessagePort':
|
|
case 'MIDIAccess':
|
|
case 'OffscreenCanvas':
|
|
case 'ReadableStream':
|
|
case 'RTCDataChannel':
|
|
case 'TransformStream':
|
|
case 'WebTransportReceiveStream':
|
|
case 'WebTransportSendStream':
|
|
case 'WritableStream':
|
|
throwUnpolyfillable(type, TRANSFERRING);
|
|
}
|
|
|
|
if (transferred === undefined) throw new DOMException('This object cannot be transferred: ' + type, DATA_CLONE_ERROR);
|
|
|
|
mapSet(map, value, transferred);
|
|
}
|
|
|
|
return buffers;
|
|
};
|
|
|
|
var detachBuffers = function (buffers) {
|
|
setIterate(buffers, function (buffer) {
|
|
if (PROPER_STRUCTURED_CLONE_TRANSFER) {
|
|
nativeRestrictedStructuredClone(buffer, { transfer: [buffer] });
|
|
} else if (isCallable(buffer.transfer)) {
|
|
buffer.transfer();
|
|
} else if (detachTransferable) {
|
|
detachTransferable(buffer);
|
|
} else {
|
|
throwUnpolyfillable('ArrayBuffer', TRANSFERRING);
|
|
}
|
|
});
|
|
};
|
|
|
|
// `structuredClone` method
|
|
// https://html.spec.whatwg.org/multipage/structured-data.html#dom-structuredclone
|
|
$({ global: true, enumerable: true, sham: !PROPER_STRUCTURED_CLONE_TRANSFER, forced: FORCED_REPLACEMENT }, {
|
|
structuredClone: function structuredClone(value /* , { transfer } */) {
|
|
var options = validateArgumentsLength(arguments.length, 1) > 1 && !isNullOrUndefined(arguments[1]) ? anObject(arguments[1]) : undefined;
|
|
var transfer = options ? options.transfer : undefined;
|
|
var map, buffers;
|
|
|
|
if (transfer !== undefined) {
|
|
map = new Map();
|
|
buffers = tryToTransfer(transfer, map);
|
|
}
|
|
|
|
var clone = structuredCloneInternal(value, map);
|
|
|
|
// since of an issue with cloning views of transferred buffers, we a forced to detach them later
|
|
// https://github.com/zloirock/core-js/issues/1265
|
|
if (buffers) detachBuffers(buffers);
|
|
|
|
return clone;
|
|
}
|
|
});
|
|
return web_structuredClone;
|
|
}
|
|
|
|
requireWeb_structuredClone();
|
|
|
|
var web_urlSearchParams_delete = {};
|
|
|
|
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();
|