bootstrap-table
Version:
An extended table to integration with some of the most widely used CSS frameworks. (Supports Bootstrap, Semantic UI, Bulma, Material Design, Foundation)
4,636 lines • 161 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('jquery')) :
typeof define === 'function' && define.amd ? define(['jquery'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.jQuery));
})(this, (function ($) { 'use strict';
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _arrayWithHoles(r) {
if (Array.isArray(r)) return r;
}
function _assertThisInitialized(e) {
if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
return e;
}
function _callSuper(t, o, e) {
return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
}
function _classCallCheck(a, n) {
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties(e, r) {
for (var t = 0; t < r.length; t++) {
var o = r[t];
o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
}
}
function _createClass(e, r, t) {
return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
writable: false
}), e;
}
function _get() {
return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {
var p = _superPropBase(e, t);
if (p) {
var n = Object.getOwnPropertyDescriptor(p, t);
return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
}
}, _get.apply(null, arguments);
}
function _getPrototypeOf(t) {
return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
}, _getPrototypeOf(t);
}
function _inherits(t, e) {
if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
t.prototype = Object.create(e && e.prototype, {
constructor: {
value: t,
writable: true,
configurable: true
}
}), Object.defineProperty(t, "prototype", {
writable: false
}), e && _setPrototypeOf(t, e);
}
function _isNativeReflectConstruct() {
try {
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
} catch (t) {}
return (_isNativeReflectConstruct = function () {
return !!t;
})();
}
function _iterableToArrayLimit(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e,
n,
i,
u,
a = [],
f = true,
o = false;
try {
if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
} catch (r) {
o = true, n = r;
} finally {
try {
if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _possibleConstructorReturn(t, e) {
if (e && ("object" == typeof e || "function" == typeof e)) return e;
if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
return _assertThisInitialized(t);
}
function _setPrototypeOf(t, e) {
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
return t.__proto__ = e, t;
}, _setPrototypeOf(t, e);
}
function _slicedToArray(r, e) {
return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _superPropBase(t, o) {
for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t)););
return t;
}
function _superPropGet(t, o, e, r) {
var p = _get(_getPrototypeOf(t.prototype ), o, e);
return "function" == typeof p ? function (t) {
return p.apply(e, t);
} : p;
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r);
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (String )(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
}
}
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
var es_array_concat = {};
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.51.0',
mode: IS_PURE ? 'pure' : 'global',
copyright: '© 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved.',
license: 'https://github.com/zloirock/core-js/blob/v3.51.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();
// eslint-disable-next-line es/no-object-create -- safe
var create = Object.create || Object;
shared = function (key, value) {
return store[key] || (store[key] = value || create(null));
};
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.1.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 [at] 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 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 new $TypeError('Maximum allowed index exceeded');
return it;
};
return doesNotExceedSafeInteger;
}
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 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 toStringTagSupport;
var hasRequiredToStringTagSupport;
function requireToStringTagSupport () {
if (hasRequiredToStringTagSupport) return toStringTagSupport;
hasRequiredToStringTagSupport = 1;
var wellKnownSymbol = requireWellKnownSymbol();
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var test = {};
// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
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 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 arraySpeciesConstructor;
var hasRequiredArraySpeciesConstructor;
function requireArraySpeciesConstructor () {
if (hasRequiredArraySpeciesConstructor) return arraySpeciesConstructor;
hasRequiredArraySpeciesConstructor = 1;
var isArray = requireIsArray();
var isConstructor = requireIsConstructor();
var isObject = requireIsObject();
var wellKnownSymbol = requireWellKnownSymbol();
var SPECIES = wellKnownSymbol('species');
var $Array = Array;
// a part of `ArraySpeciesCreate` abstract operation
// https://tc39.es/ecma262/#sec-arrayspeciescreate
arraySpeciesConstructor = function (originalArray) {
var C;
if (isArray(originalArray)) {
C = originalArray.constructor;
// cross-realm fallback
if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;
else if (isObject(C)) {
C = C[SPECIES];
if (C === null) C = undefined;
}
} return C === undefined ? $Array : C;
};
return arraySpeciesConstructor;
}
var arraySpeciesCreate;
var hasRequiredArraySpeciesCreate;
function requireArraySpeciesCreate () {
if (hasRequiredArraySpeciesCreate) return arraySpeciesCreate;
hasRequiredArraySpeciesCreate = 1;
var arraySpeciesConstructor = requireArraySpeciesConstructor();
// `ArraySpeciesCreate` abstract operation
// https://tc39.es/ecma262/#sec-arrayspeciescreate
arraySpeciesCreate = function (originalArray, length) {
return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
};
return arraySpeciesCreate;
}
var arrayMethodHasSpeciesSupport;
var hasRequiredArrayMethodHasSpeciesSupport;
function requireArrayMethodHasSpeciesSupport () {
if (hasRequiredArrayMethodHasSpeciesSupport) return arrayMethodHasSpeciesSupport;
hasRequiredArrayMethodHasSpeciesSupport = 1;
var fails = requireFails();
var wellKnownSymbol = requireWellKnownSymbol();
var V8_VERSION = requireEnvironmentV8Version();
var SPECIES = wellKnownSymbol('species');
arrayMethodHasSpeciesSupport = function (METHOD_NAME) {
// We can't use this feature detection in V8 since it causes
// deoptimization and serious performance degradation
// https://github.com/zloirock/core-js/issues/677
return V8_VERSION >= 51 || !fails(function () {
var array = [];
var constructor = array.constructor = {};
constructor[SPECIES] = function () {
return { foo: 1 };
};
return array[METHOD_NAME](Boolean).foo !== 1;
});
};
return arrayMethodHasSpeciesSupport;
}
var hasRequiredEs_array_concat;
function requireEs_array_concat () {
if (hasRequiredEs_array_concat) return es_array_concat;
hasRequiredEs_array_concat = 1;
var $ = require_export();
var fails = requireFails();
var isArray = requireIsArray();
var isObject = requireIsObject();
var toObject = requireToObject();
var lengthOfArrayLike = requireLengthOfArrayLike();
var doesNotExceedSafeInteger = requireDoesNotExceedSafeInteger();
var createProperty = requireCreateProperty();
var setArrayLength = requireArraySetLength();
var arraySpeciesCreate = requireArraySpeciesCreate();
var arrayMethodHasSpeciesSupport = requireArrayMethodHasSpeciesSupport();
var wellKnownSymbol = requireWellKnownSymbol();
var V8_VERSION = requireEnvironmentV8Version();
var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');
// We can't use this feature detection in V8 since it causes
// deoptimization and serious performance degradation
// https://github.com/zloirock/core-js/issues/679
var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {
var array = [];
array[IS_CONCAT_SPREADABLE] = false;
return array.concat()[0] !== array;
});
var isConcatSpreadable = function (O) {
if (!isObject(O)) return false;
var spreadable = O[IS_CONCAT_SPREADABLE];
return spreadable !== undefined ? !!spreadable : isArray(O);
};
var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat');
// `Array.prototype.concat` method
// https://tc39.es/ecma262/#sec-array.prototype.concat
// with adding support of @@isConcatSpreadable and @@species
$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
// eslint-disable-next-line no-unused-vars -- required for `.length`
concat: function concat(arg) {
var O = toObject(this);
var A = arraySpeciesCreate(O, 0);
var n = 0;
var i, k, length, len, E;
for (i = -1, length = arguments.length; i < length; i++) {
E = i === -1 ? O : arguments[i];
if (isConcatSpreadable(E)) {
len = lengthOfArrayLike(E);
doesNotExceedSafeInteger(n + len);
for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);
} else {
doesNotExceedSafeInteger(n + 1);
createProperty(A, n++, E);
}
}
setArrayLength(A, n);
return A;
}
});
return es_array_concat;
}
requireEs_array_concat();
var objectDefineProperties = {};
var objectKeys;
var hasRequiredObjectKeys;
function requireObjectKeys () {
if (hasRequiredObjectKeys) return objectKeys;
hasRequiredObjectKeys = 1;
var internalObjectKeys = requireObjectKeysInternal();
var enumBugKeys = requireEnumBugKeys();
// `Object.keys` method
// https://tc39.es/ecma262/#sec-object.keys
// eslint-disable-next-line es/no-object-keys -- safe
objectKeys = Object.keys || function keys(O) {
return internalObjectKeys(O, enumBugKeys);
};
return objectKeys;
}
var hasRequiredObjectDefineProperties;
function requireObjectDefineProperties () {
if (hasRequiredObjectDefineProperties) return objectDefineProperties;
hasRequiredObjectDefineProperties = 1;
var DESCRIPTORS = requireDescriptors();
var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
var definePropertyModule = requireObjectDefineProperty();
var anObject = requireAnObject();
var toIndexedObject = requireToIndexedObject();
var objectKeys = requireObjectKeys();
// `Object.defineProperties` method
// https://tc39.es/ecma262/#sec-object.defineproperties
// eslint-disable-next-line es/no-object-defineproperties -- safe
objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
anObject(O);
var props = toIndexedObject(Properties);
var keys = objectKeys(Properties);
var length = keys.length;
var index = 0;
var key;
while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
return O;
};
return objectDefineProperties;
}
var html;
var hasRequiredHtml;
function requireHtml () {
if (hasRequiredHtml) return html;
hasRequiredHtml = 1;
var getBuiltIn = requireGetBuiltIn();
html = getBuiltIn('document', 'documentElement');
return html;
}
var objectCreate;
var hasRequiredObjectCreate;
function requireObjectCreate () {
if (hasRequiredObjectCreate) return objectCreate;
hasRequiredObjectCreate = 1;
/* global ActiveXObject -- old IE, WSH */
var anObject = requireAnObject();
var definePropertiesModule = requireObjectDefineProperties();
var enumBugKeys = requireEnumBugKeys();
var hiddenKeys = requireHiddenKeys();
var html = requireHtml();
var documentCreateElement = requireDocumentCreateElement();
var sharedKey = requireSharedKey();
var GT = '>';
var LT = '<';
var PROTOTYPE = 'prototype';
var SCRIPT = 'script';
var IE_PROTO = sharedKey('IE_PROTO');
var EmptyConstructor = function () { /* empty */ };
var scriptTag = function (content) {
return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
};
// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
var NullProtoObjectViaActiveX = function (activeXDocument) {
activeXDocument.write(scriptTag(''));
activeXDocument.close();
var temp = activeXDocument.parentWindow.Object;
// eslint-disable-next-line no-useless-assignment -- avoid memory leak
activeXDocument = null;
return temp;
};
// Create object with fake `null` prototype: use iframe Object with cleared prototype
var NullProtoObjectViaIFrame = function () {
// Thrash, waste and sodomy: IE GC bug
var iframe = documentCreateElement('iframe');
var JS = 'java' + SCRIPT + ':';
var iframeDocument;
iframe.style.display = 'none';
html.appendChild(iframe);
// https://github.com/zloirock/core-js/issues/475
iframe.src = String(JS);
iframeDocument = iframe.contentWindow.document;
iframeDocument.open();
iframeDocument.write(scriptTag('document.F=Object'));
iframeDocument.close();
return iframeDocument.F;
};
// Check for document.domain and active x support
// No need to use active x approach when document.domain is not set
// see https://github.com/es-shims/es5-shim/issues/150
// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
// avoid IE GC bug
var activeXDocument;
var NullProtoObject = function () {
try {
activeXDocument = new ActiveXObject('htmlfile');
} catch (error) { /* ignore */ }
NullProtoObject = typeof document != 'undefined'
? document.domain && activeXDocument
? NullProtoObjectViaActiveX(activeXDocument) // old IE
: NullProtoObjectViaIFrame()
: NullProtoObjectViaActiveX(activeXDocument); // WSH
var length = enumBugKeys.length;
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
return NullProtoObject();
};
hiddenKeys[IE_PROTO] = true;
// `Object.create` method
// https://tc39.es/ecma262/#sec-object.create
// eslint-disable-next-line es/no-object-create -- safe
objectCreate = Object.create || function create(O, Properties) {
var result;
if (O !== null) {
EmptyConstructor[PROTOTYPE] = anObject(O);
result = new EmptyConstructor();
EmptyConstructor[PROTOTYPE] = null;
// add "__proto__" for Object.getPrototypeOf polyfill
result[IE_PROTO] = O;
} else result = NullProtoObject();
return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
};
return objectCreate;
}
var addToUnscopables;
var hasRequiredAddToUnscopables;
function requireAddToUnscopables () {
if (hasRequiredAddToUnscopables) return addToUnscopables;
hasRequiredAddToUnscopables = 1;
var wellKnownSymbol = requireWellKnownSymbol();
var create = requireObjectCreate();
var defineProperty = requireObjectDefineProperty().f;
var UNSCOPABLES = wellKnownSymbol('unscopables');
var ArrayPrototype = Array.prototype;
// Array.prototype[@@unscopables]
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
if (ArrayPrototype[UNSCOPABLES] === undefined) {
defineProperty(ArrayPrototype, UNSCOPABLES, {
configurable: true,
value: create(null)
});
}
// add a key to Array.prototype[@@unscopables]
addToUnscopables = function (key) {
ArrayPrototype[UNSCOPABLES][key] = true;
};
return addToUnscopables;
}
var iterators;
var hasRequiredIterators;
function requireIterators () {
if (hasRequiredIterators) return iterators;
hasRequiredIterators = 1;
iterators = Object.create ? Object.create(null) : {};
return iterators;
}
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 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 setToStringTag;
var hasRequiredSetToStringTag;
function requireSetToStringTag () {
if (hasRequiredSetToStringTag) return setToStringTag;
hasRequiredSetToStringTag = 1;
var defineProperty = requireObjectDefineProperty().f;
var hasOwn = requireHasOwnProperty();
var wellKnownSymbol = requireWellKnownSymbol();
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
setToStringTag = function (target, TAG, STATIC) {
if (target && !STATIC) target = target.prototype;
if (target && !hasOwn(target, TO_STRING_TAG)) {
defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });
}
};
return setToStringTag;
}
var iteratorCreateConstructor;
var hasRequiredIteratorCreateConstructor;
function requireIteratorCreateConstructor () {
if (hasRequiredIteratorCreateConstructor) return iteratorCreateConstructor;
hasRequiredIteratorCreateConstructor = 1;
var IteratorPrototype = requireIteratorsCore().IteratorPrototype;
var create = requireObjectCreate();
var createPropertyDescriptor = requireCreatePropertyDescriptor();
var setToStringTag = requireSetToStringTag();
var Iterators = requireIterators();
var returnThis = function () { return this; };
iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
var TO_STRING_TAG = NAME + ' Iterator';
IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
Iterators[TO_STRING_TAG] = returnThis;
return IteratorConstructor;
};
return iteratorCreateConstructor;
}
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 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 iteratorDefine;
var hasRequiredIteratorDefine;
function requireIteratorDefine () {
if (hasRequiredIteratorDefine) return iteratorDefine;
hasRequiredIteratorDefine = 1;
var $ = require_export();
var call = requireFunctionCall();
var IS_PURE = requireIsPure();
var FunctionName = requireFunctionName();
var isCallable = requireIsCallable();
var createIteratorConstructor = requireIteratorCreateConstructor();
var getPrototypeOf = requireObjectGetPrototypeOf();
var setPrototypeOf = requireObjectSetPrototypeOf();
var setToStringTag = requireSetToStringTag();
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
var defineBuiltIn = requireDefineBuiltIn();
var wellKnownSymbol = requireWellKnownSymbol();
var Iterators = requireIterators();
var IteratorsCore = requireIteratorsCore();
var PROPER_FUNCTION_NAME = FunctionName.PROPER;
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
var IteratorPrototype = IteratorsCore.IteratorPrototype;
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
var ITERATOR = wellKnownSymbol('iterator');
var KEYS = 'keys';
var VALUES = 'values';
var ENTRIES = 'entries';
var returnThis = function () { return this; };
iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
createIteratorConstructor(IteratorConstructor, NAME, next);
var getIterationMethod = function (KIND) {
if (KIND === DEFAULT && defaultIterator) return defaultIterator;
if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];
switch (KIND) {
case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
}
return function () { return new IteratorConstructor(this); };
};
var TO_STRING_TAG = NAME + ' Iterator';
var INCORRECT_VALUES_NAME = false;
var IterablePrototype = Iterable.prototype;
var nativeIterator = IterablePrototype[ITERATOR]
|| IterablePrototype['@@iterator']
|| DEFAULT && IterablePrototype[DEFAULT];
var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
var CurrentIteratorPrototype, methods, KEY;
// fix native
if (anyNativeIterator) {
CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
if (setPrototypeOf) {
setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
} else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {
defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);
}
}
// Set @@toStringTag to native iterators
setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;
}
}
// fix Array.prototype.{ values, @@iterator }.name in V8 / FF
if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {
if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {
createNonEnumerableProperty(IterablePrototype, 'name', VALUES);
} else {
INCORRECT_VALUES_NAME = true;
defaultIterator = function values() { return call(nativeIterator, this); };
}
}
// export additional methods
if (DEFAULT) {
methods = {
values: getIterationMethod(VALUES),
keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
entries: getIterationMethod(ENTRIES)
};
if (FORCED) for (KEY in methods) {
if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
defineBuiltIn(IterablePrototype, KEY, methods[KEY]);
}
} else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
}
// define iterator
if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });
}
Iterators[NAME] = defaultIterator;
return methods;
};
return iteratorDefine;
}
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 es_array_iterator;
var hasRequiredEs_array_iterator;
function requireEs_array_iterator () {
if (hasRequiredEs_array_iterator) return es_array_iterator;
hasRequiredEs_array_iterator = 1;
var toIndexedObject = requireToIndexedObject();
var addToUnscopables = requireAddToUnscopables();
var Iterators = requireIterators();
var InternalStateModule = requireInternalState();
var defineProperty = requireObjectDefineProperty().f;
var defineIterator = requireIteratorDefine();
var createIterResultObject = requireCreateIterResultObject();
var IS_PURE = requireIsPure();
var DESCRIPTORS = requireDescriptors();
var ARRAY_ITERATOR = 'Array Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
// `Array.prototype.entries` method
// https://tc39.es/ecma262/#sec-array.prototype.entries
// `Array.prototype.keys` method
// https://tc39.es/ecma262/#sec-array.prototype.keys
// `Array.prototype.values` method
// https://tc39.es/ecma262/#sec-array.prototype.values
// `Array.prototype[@@iterator]` method
// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
// `CreateArrayIterator` internal method
// https://tc39.es/ecma262/#sec-createarrayiterator
es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
setInternalState(this, {
type: ARRAY_ITERATOR,
target: toIndexedObject(iterated), // target
index: 0, // next index
kind: kind // kind
});
// `%ArrayIteratorPrototype%.next` method
// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
}, function () {
var state = getInternalState(this);
var target = state.target;
var index = state.index++;
if (!target || index >= target.length) {
state.target = null;
return createIterResultObject(undefined, true);
}
switch (state.kind) {
case 'keys': return createIterResultObject(index, false);
case 'values': return createIterResultObject(target[index], false);
} return createIterResultObject([index, target[index]], false);
}, 'values');
// argumentsList[@@iterator] is %ArrayProto_values%
// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
// https://tc39.es/ecma262/#sec-createmappedargumentsobject
var values = Iterators.Arguments = Iterators.Array;
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('keys');
addToUnscopables('values');
addToUnscopables('entries');
// V8 ~ Chrome 45- bug
if (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {
defineProperty(values, 'name', { value: 'values' });
} catch (error) { /* empty */ }
return es_array_iterator;
}
requireEs_array_iterator();
var es_object_assign = {};
var objectAssign;
var hasRequiredObjectAssign;
function requireObjectAssign () {
if (hasRequiredObjectAssign) return objectAssign;
hasRequiredObjectAssign = 1;
var DESCRIPTORS = requireDescriptors();
var uncurryThis = requireFunctionUncurryThis();
var call = requireFunctionCall();
var fails = requireFails();
var objectKeys = requireObjectKeys();
var getOwnPropertySymbolsModule = requireObjectGetOwnPropertySymbols();
var propertyIsEnumerableModule = requireObjectPropertyIsEnumerable();
var toObject = requireToObject();
var IndexedObject = requireIndexedObject();
// eslint-disable-next-line es/no-object-assign -- safe
var $assign = Object.assign;
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
var defineProperty = Object.defineProperty;
var concat = uncurryThis([].concat);
// `Object.assign` method
// https://tc39.es/ecma262/#sec-object.assign
objectAssign = !$assign || fails(function () {
// should have correct order of operations (Edge bug)
if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
enumerable: true,
get: function () {
defineProperty(this, 'b', {
value: 3,
enumerable: false
});
}
}), { b: 2 })).b !== 1) return true;
// should work with symbols and should have deterministic property order (V8 bug)
var A = {};
var B = {};
// eslint-disable-next-line es/no-symbol -- safe
var symbol = Symbol('assign detection');
var alphabet = 'abcdefghijklmnopqrst';
A[symbol] = 7;
// eslint-disable-next-line es/no-array-prototype-foreach -- safe
alphabet.split('').forEach(function (chr) { B[chr] = chr; });
return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;
}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
var T = toObject(target);
var argumentsLength = arguments.length;
var index = 1;
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
var propertyIsEnumerable = propertyIsEnumerableModule.f;
while (argumentsLength > index) {
var S = IndexedObject(arguments[index++]);
var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
var length = keys.length;
var j = 0;
var key;
while (length > j) {
key = keys[j++];
if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];
}
} return T;
} : $assign;
return objectAssign;
}
var hasRequiredEs_object_assign;
function requireEs_object_assign () {
if (hasRequiredEs_object_assign) return es_object_assign;
hasRequiredEs_object_assign = 1;
var $ = require_export();
var assign = requireObjectAssign();
// `Object.assign` method
// https://tc39.es/ecma262/#sec-object.assign
// eslint-disable-next-line es/no-object-assign -- required for testing
$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
assign: assign
});
return es_object_assign;
}
requireEs_object_assign();
var es_object_entries = {};
var objectToArray;
var hasRequiredObjectToArray;
function requireObjectToArray () {
if (hasRequiredObjectToArray) return objectToArray;
hasRequiredObjectToArray = 1;
var DESCRIPTORS = requireDescriptors();
var fails = requireFails();
var uncurryThis = requireFunctionUncurryThis();
var objectGetPrototypeOf = requireObjectGetPrototypeOf();
var objectKeys = requireObjectKeys();
var toIndexedObject = requireToIndexedObject();
var $propertyIsEnumerable = requireObjectPropertyIsEnumerable().f;
var propertyIsEnumerable = uncurryThis($propertyIsEnumerable);
var push = uncurryThis([].push);
// in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys
// of `null` prototype objects
var IE_BUG = DESCRIPTORS && fails(function () {
// eslint-disable-next-line es/no-object-create -- safe
var O = Object.create(null);
O[2] = 2;
return !propertyIsEnumerable(O, 2);
});
// `Object.{ entries, values }` methods implementation
var createMethod = function (TO_ENTRIES) {
return function (it) {
var O = toIndexedObject(it);
var keys = objectKeys(O);
var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null;
var length = keys.length;
var i = 0;
var result = [];
var key;
while (length > i) {
key = keys[i++];
if (!DESCRIPTORS || (IE_WORKAROUND ? key in O : propertyIsEnumerable(O, key))) {
push(result, TO_ENTRIES ? [key, O[key]] : O[key]);
}
}
return result;
};
};
objectToArray = {
// `Object.entries` method
// https://tc39.es/ecma262/#sec-object.entries
entries: createMethod(true),
// `Object.values` method
// https://tc39.es/ecma262/#sec-object.values
values: createMethod(false)
};
return objectToArray;
}
var hasRequiredEs_object_entries;
function requireEs_object_entries () {
if (hasRequiredEs_object_entries) return es_object_entries;
hasRequiredEs_object_entries = 1;
var $ = require_export();
var $entries = requireObjectToArray().entries;
// `Object.entries` method
// https://tc39.es/ecma262/#sec-object.entries
$({ target: 'Object', stat: true }, {
entries: function entries(O) {
return $entries(O);
}
});
return es_object_entries;
}
requireEs_object_entries();
var es_object_toString = {};
var objectToString;
var hasRequiredObjectToString;
function requireObjectToString () {
if (hasRequiredObjectToString) return objectToString;
hasRequiredObjectToString = 1;
var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
var classof = requireClassof();
// `Object.prototype.toString` method implementation
// https://tc39.es/ecma262/#sec-object.prototype.tostring
objectToString = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {
return '[object ' + classof(this) + ']';
};
return objectToString;
}
var hasRequiredEs_object_toString;
function requireEs_object_toString () {
if (hasRequiredEs_object_toString) return es_object_toString;
hasRequiredEs_object_toString = 1;
var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
var defineBuiltIn = requireDefineBuiltIn();
var toString = requireObjectToString();
// `Object.prototype.toString` method
// https://tc39.es/ecma262/#sec-object.prototype.tostring
if (!TO_STRING_TAG_SUPPORT) {
defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });
}
return es_object_toString;
}
requireEs_object_toString();
var es_regexp_exec = {};
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 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 regexpStickyHelpers;
var hasRequiredRegexpStickyHelpers;
function requireRegexpStickyHelpers () {
if (hasRequiredRegexpStickyHelpers) return regexpStickyHelpers;
hasRequiredRegexpStickyHelpers = 1;
var fails = requireFails();
var globalThis = requireGlobalThis();
// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
var $RegExp = globalThis.RegExp;
var UNSUPPORTED_Y = fails(function () {
var re = $RegExp('a', 'y');
re.lastIndex = 2;
return re.exec('abcd') !== null;
});
// UC Browser bug
// https://github.com/zloirock/core-js/issues/1008
var MISSED_STICKY = UNSUPPORTED_Y || fails(function () {
return !$RegExp('a', 'y').sticky;
});
var BROKEN_CARET = UNSUPPORTED_Y || fails(function () {
// https://bugzilla.mozilla.org/show_bug.cgi?id=773687
var re = $RegExp('^r', 'gy');
re.lastIndex = 2;
return re.exec('str') !== null;
});
regexpStickyHelpers = {
BROKEN_CARET: BROKEN_CARET,
MISSED_STICKY: MISSED_STICKY,
UNSUPPORTED_Y: UNSUPPORTED_Y
};
return regexpStickyHelpers;
}
var regexpUnsupportedDotAll;
var hasRequiredRegexpUnsupportedDotAll;
function requireRegexpUnsupportedDotAll () {
if (hasRequiredRegexpUnsupportedDotAll) return regexpUnsupportedDotAll;
hasRequiredRegexpUnsupportedDotAll = 1;
var fails = requireFails();
var globalThis = requireGlobalThis();
// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
var $RegExp = globalThis.RegExp;
regexpUnsupportedDotAll = fails(function () {
var re = $RegExp('.', 's');
return !(re.dotAll && re.test('\n') && re.flags === 's');
});
return regexpUnsupportedDotAll;
}
var regexpUnsupportedNcg;
var hasRequiredRegexpUnsupportedNcg;
function requireRegexpUnsupportedNcg () {
if (hasRequiredRegexpUnsupportedNcg) return regexpUnsupportedNcg;
hasRequiredRegexpUnsupportedNcg = 1;
var fails = requireFails();
var globalThis = requireGlobalThis();
// babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
var $RegExp = globalThis.RegExp;
regexpUnsupportedNcg = fails(function () {
var re = $RegExp('(?<a>b)', 'g');
return re.exec('b').groups.a !== 'b' ||
'b'.replace(re, '$<a>c') !== 'bc';
});
return regexpUnsupportedNcg;
}
var regexpExec;
var hasRequiredRegexpExec;
function requireRegexpExec () {
if (hasRequiredRegexpExec) return regexpExec;
hasRequiredRegexpExec = 1;
/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
/* eslint-disable regexp/no-useless-quantifier -- testing */
var call = requireFunctionCall();
var uncurryThis = requireFunctionUncurryThis();
var toString = requireToString();
var regexpFlags = requireRegexpFlags();
var stickyHelpers = requireRegexpStickyHelpers();
var shared = requireShared();
var create = requireObjectCreate();
var getInternalState = requireInternalState().get;
var UNSUPPORTED_DOT_ALL = requireRegexpUnsupportedDotAll();
var UNSUPPORTED_NCG = requireRegexpUnsupportedNcg();
var nativeReplace = shared('native-string-replace', String.prototype.replace);
var nativeExec = RegExp.prototype.exec;
var patchedExec = nativeExec;
var charAt = uncurryThis(''.charAt);
var indexOf = uncurryThis(''.indexOf);
var replace = uncurryThis(''.replace);
var stringSlice = uncurryThis(''.slice);
var UPDATES_LAST_INDEX_WRONG = (function () {
var re1 = /a/;
var re2 = /b*/g;
call(nativeExec, re1, 'a');
call(nativeExec, re2, 'a');
return re1.lastIndex !== 0 || re2.lastIndex !== 0;
})();
var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
// nonparticipating capturing group, copied from es5-shim's String#split patch.
var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
var setGroups = function (re, groups) {
var object = re.groups = create(null);
for (var i = 0; i < groups.length; i++) {
var group = groups[i];
object[group[0]] = re[group[1]];
}
};
if (PATCH) {
patchedExec = function exec(string) {
var re = this;
var state = getInternalState(re);
var str = toString(string);
var raw = state.raw;
var result, reCopy, lastIndex;
if (raw) {
raw.lastIndex = re.lastIndex;
result = call(patchedExec, raw, str);
re.lastIndex = raw.lastIndex;
if (result && state.groups) setGroups(result, state.groups);
return result;
}
var groups = state.groups;
var sticky = UNSUPPORTED_Y && re.sticky;
var flags = call(regexpFlags, re);
var source = re.source;
var charsAdded = 0;
var strCopy = str;
if (sticky) {
flags = replace(flags, 'y', '');
if (indexOf(flags, 'g') === -1) {
flags += 'g';
}
strCopy = stringSlice(str, re.lastIndex);
// Support anchored sticky behavior.
var prevChar = re.lastIndex > 0 && charAt(str, re.lastIndex - 1);
if (re.lastIndex > 0 &&
(!re.multiline || re.multiline && prevChar !== '\n' && prevChar !== '\r' && prevChar !== '\u2028' && prevChar !== '\u2029')) {
source = '(?: (?:' + source + '))';
strCopy = ' ' + strCopy;
charsAdded++;
}
// ^(? + rx + ) is needed, in combination with some str slicing, to
// simulate the 'y' flag.
reCopy = new RegExp('^(?:' + source + ')', flags);
}
if (NPCG_INCLUDED) {
reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
}
if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
var match = call(nativeExec, sticky ? reCopy : re, strCopy);
if (sticky) {
if (match) {
match.input = str;
match[0] = stringSlice(match[0], charsAdded);
match.index = re.lastIndex;
re.lastIndex += match[0].length;
} else re.lastIndex = 0;
} else if (UPDATES_LAST_INDEX_WRONG && match) {
re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
}
if (NPCG_INCLUDED && match && match.length > 1) {
// Fix browsers whose `exec` methods don't consistently return `undefined`
// for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/
call(nativeReplace, match[0], reCopy, function () {
for (var i = 1; i < arguments.length - 2; i++) {
if (arguments[i] === undefined) match[i] = undefined;
}
});
}
if (match && groups) setGroups(match, groups);
return match;
};
}
regexpExec = patchedExec;
return regexpExec;
}
var hasRequiredEs_regexp_exec;
function requireEs_regexp_exec () {
if (hasRequiredEs_regexp_exec) return es_regexp_exec;
hasRequiredEs_regexp_exec = 1;
var $ = require_export();
var exec = requireRegexpExec();
// `RegExp.prototype.exec` method
// https://tc39.es/ecma262/#sec-regexp.prototype.exec
$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
exec: exec
});
return es_regexp_exec;
}
requireEs_regexp_exec();
var es_regexp_toString = {};
var regexpFlagsDetection;
var hasRequiredRegexpFlagsDetection;
function requireRegexpFlagsDetection () {
if (hasRequiredRegexpFlagsDetection) return regexpFlagsDetection;
hasRequiredRegexpFlagsDetection = 1;
var globalThis = requireGlobalThis();
var fails = requireFails();
// babel-minify and Closure Compiler transpiles RegExp('.', 'd') -> /./d and it causes SyntaxError
var RegExp = globalThis.RegExp;
var FLAGS_GETTER_IS_CORRECT = !fails(function () {
var INDICES_SUPPORT = true;
try {
RegExp('.', 'd');
} catch (error) {
INDICES_SUPPORT = false;
}
var O = {};
// modern V8 bug
var calls = '';
var expected = INDICES_SUPPORT ? 'dgimsy' : 'gimsy';
var addGetter = function (key, chr) {
// eslint-disable-next-line es/no-object-defineproperty -- safe
Object.defineProperty(O, key, { get: function () {
calls += chr;
return true;
} });
};
var pairs = {
dotAll: 's',
global: 'g',
ignoreCase: 'i',
multiline: 'm',
sticky: 'y'
};
if (INDICES_SUPPORT) pairs.hasIndices = 'd';
for (var key in pairs) addGetter(key, pairs[key]);
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var result = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get.call(O);
return result !== expected || calls !== expected;
});
regexpFlagsDetection = { correct: FLAGS_GETTER_IS_CORRECT };
return regexpFlagsDetection;
}
var regexpGetFlags;
var hasRequiredRegexpGetFlags;
function requireRegexpGetFlags () {
if (hasRequiredRegexpGetFlags) return regexpGetFlags;
hasRequiredRegexpGetFlags = 1;
var call = requireFunctionCall();
var hasOwn = requireHasOwnProperty();
var isPrototypeOf = requireObjectIsPrototypeOf();
var regExpFlagsDetection = requireRegexpFlagsDetection();
var regExpFlagsGetterImplementation = requireRegexpFlags();
var RegExpPrototype = RegExp.prototype;
regexpGetFlags = regExpFlagsDetection.correct ? function (it) {
return it.flags;
} : function (it) {
return (!regExpFlagsDetection.correct && isPrototypeOf(RegExpPrototype, it) && !hasOwn(it, 'flags'))
? call(regExpFlagsGetterImplementation, it)
: it.flags;
};
return regexpGetFlags;
}
var hasRequiredEs_regexp_toString;
function requireEs_regexp_toString () {
if (hasRequiredEs_regexp_toString) return es_regexp_toString;
hasRequiredEs_regexp_toString = 1;
var PROPER_FUNCTION_NAME = requireFunctionName().PROPER;
var defineBuiltIn = requireDefineBuiltIn();
var anObject = requireAnObject();
var $toString = requireToString();
var fails = requireFails();
var getRegExpFlags = requireRegexpGetFlags();
var TO_STRING = 'toString';
var RegExpPrototype = RegExp.prototype;
var nativeToString = RegExpPrototype[TO_STRING];
var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) !== '/a/b'; });
// FF44- RegExp#toString has a wrong name
var INCORRECT_NAME = PROPER_FUNCTION_NAME && nativeToString.name !== TO_STRING;
// `RegExp.prototype.toString` method
// https://tc39.es/ecma262/#sec-regexp.prototype.tostring
if (NOT_GENERIC || INCORRECT_NAME) {
defineBuiltIn(RegExpPrototype, TO_STRING, function toString() {
var R = anObject(this);
var pattern = $toString(R.source);
var flags = $toString(getRegExpFlags(R));
return '/' + pattern + '/' + flags;
}, { unsafe: true });
}
return es_regexp_toString;
}
requireEs_regexp_toString();
var es_string_iterator = {};
var stringMultibyte;
var hasRequiredStringMultibyte;
function requireStringMultibyte () {
if (hasRequiredStringMultibyte) return stringMultibyte;
hasRequiredStringMultibyte = 1;
var uncurryThis = requireFunctionUncurryThis();
var toIntegerOrInfinity = requireToIntegerOrInfinity();
var toString = requireToString();
var requireObjectCoercible = requireRequireObjectCoercible();
var charAt = uncurryThis(''.charAt);
var charCodeAt = uncurryThis(''.charCodeAt);
var stringSlice = uncurryThis(''.slice);
var createMethod = function (CONVERT_TO_STRING) {
return function ($this, pos) {
var S = toString(requireObjectCoercible($this));
var position = toIntegerOrInfinity(pos);
var size = S.length;
var first, second;
if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
first = charCodeAt(S, position);
return first < 0xD800 || first > 0xDBFF || position + 1 === size
|| (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
? CONVERT_TO_STRING
? charAt(S, position)
: first
: CONVERT_TO_STRING
? stringSlice(S, position, position + 2)
: (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
};
};
stringMultibyte = {
// `String.prototype.codePointAt` method
// https://tc39.es/ecma262/#sec-string.prototype.codepointat
codeAt: createMethod(false),
// `String.prototype.at` method
// https://github.com/mathiasbynens/String.prototype.at
charAt: createMethod(true)
};
return stringMultibyte;
}
var hasRequiredEs_string_iterator;
function requireEs_string_iterator () {
if (hasRequiredEs_string_iterator) return es_string_iterator;
hasRequiredEs_string_iterator = 1;
var charAt = requireStringMultibyte().charAt;
var toString = requireToString();
var InternalStateModule = requireInternalState();
var defineIterator = requireIteratorDefine();
var createIterResultObject = requireCreateIterResultObject();
var STRING_ITERATOR = 'String Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
// `String.prototype[@@iterator]` method
// https://tc39.es/ecma262/#sec-string.prototype-@@iterator
defineIterator(String, 'String', function (iterated) {
setInternalState(this, {
type: STRING_ITERATOR,
string: toString(iterated),
index: 0
});
// `%StringIteratorPrototype%.next` method
// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next
}, function next() {
var state = getInternalState(this);
var string = state.string;
var index = state.index;
var point;
if (index >= string.length) return createIterResultObject(undefined, true);
point = charAt(string, index);
state.index += point.length;
return createIterResultObject(point, false);
});
return es_string_iterator;
}
requireEs_string_iterator();
var es_string_search = {};
var fixRegexpWellKnownSymbolLogic;
var hasRequiredFixRegexpWellKnownSymbolLogic;
function requireFixRegexpWellKnownSymbolLogic () {
if (hasRequiredFixRegexpWellKnownSymbolLogic) return fixRegexpWellKnownSymbolLogic;
hasRequiredFixRegexpWellKnownSymbolLogic = 1;
// TODO: Remove from `core-js [at] 4` since it's moved to entry points
requireEs_regexp_exec();
var call = requireFunctionCall();
var defineBuiltIn = requireDefineBuiltIn();
var regexpExec = requireRegexpExec();
var fails = requireFails();
var wellKnownSymbol = requireWellKnownSymbol();
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
var SPECIES = wellKnownSymbol('species');
var RegExpPrototype = RegExp.prototype;
fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) {
var SYMBOL = wellKnownSymbol(KEY);
var DELEGATES_TO_SYMBOL = !fails(function () {
// String methods call symbol-named RegExp methods
var O = {};
// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
O[SYMBOL] = function () { return 7; };
return ''[KEY](O) !== 7;
});
var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {
// Symbol-named RegExp methods call .exec
var execCalled = false;
var re = /a/;
if (KEY === 'split') {
// We can't use real regex here since it causes deoptimization
// and serious performance degradation in V8
// https://github.com/zloirock/core-js/issues/306
// RegExp[@@split] doesn't call the regex's exec method, but first creates
// a new one. We need to return the patched regex when creating the new one.
var constructor = {};
// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
constructor[SPECIES] = function () { return re; };
re = { constructor: constructor, flags: '' };
// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
re[SYMBOL] = /./[SYMBOL];
}
re.exec = function () {
execCalled = true;
return null;
};
re[SYMBOL]('');
return !execCalled;
});
if (
!DELEGATES_TO_SYMBOL ||
!DELEGATES_TO_EXEC ||
FORCED
) {
var nativeRegExpMethod = /./[SYMBOL];
var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
var $exec = regexp.exec;
if ($exec === regexpExec || $exec === RegExpPrototype.exec) {
if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
// The native String method already delegates to @@method (this
// polyfilled function), leasing to infinite recursion.
// We avoid it by directly calling the native @@method method.
return { done: true, value: call(nativeRegExpMethod, regexp, str, arg2) };
}
return { done: true, value: call(nativeMethod, str, regexp, arg2) };
}
return { done: false };
});
defineBuiltIn(String.prototype, KEY, methods[0]);
defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]);
}
if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
};
return fixRegexpWellKnownSymbolLogic;
}
var sameValue;
var hasRequiredSameValue;
function requireSameValue () {
if (hasRequiredSameValue) return sameValue;
hasRequiredSameValue = 1;
// `SameValue` abstract operation
// https://tc39.es/ecma262/#sec-samevalue
// eslint-disable-next-line es/no-object-is -- safe
sameValue = Object.is || function is(x, y) {
// eslint-disable-next-line no-self-compare -- NaN check
return x === y ? x !== 0 || 1 / x === 1 / y : x !== x && y !== y;
};
return sameValue;
}
var regexpExecAbstract;
var hasRequiredRegexpExecAbstract;
function requireRegexpExecAbstract () {
if (hasRequiredRegexpExecAbstract) return regexpExecAbstract;
hasRequiredRegexpExecAbstract = 1;
var call = requireFunctionCall();
var anObject = requireAnObject();
var isCallable = requireIsCallable();
var classof = requireClassofRaw();
var regexpExec = requireRegexpExec();
var $TypeError = TypeError;
// `RegExpExec` abstract operation
// https://tc39.es/ecma262/#sec-regexpexec
regexpExecAbstract = function (R, S) {
var exec = R.exec;
if (isCallable(exec)) {
var result = call(exec, R, S);
if (result !== null) anObject(result);
return result;
}
if (classof(R) === 'RegExp') return call(regexpExec, R, S);
throw new $TypeError('RegExp#exec called on incompatible receiver');
};
return regexpExecAbstract;
}
var hasRequiredEs_string_search;
function requireEs_string_search () {
if (hasRequiredEs_string_search) return es_string_search;
hasRequiredEs_string_search = 1;
var call = requireFunctionCall();
var fixRegExpWellKnownSymbolLogic = requireFixRegexpWellKnownSymbolLogic();
var anObject = requireAnObject();
var isObject = requireIsObject();
var requireObjectCoercible = requireRequireObjectCoercible();
var sameValue = requireSameValue();
var toString = requireToString();
var getMethod = requireGetMethod();
var regExpExec = requireRegexpExecAbstract();
// @@search logic
fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCallNative) {
return [
// `String.prototype.search` method
// https://tc39.es/ecma262/#sec-string.prototype.search
function search(regexp) {
var O = requireObjectCoercible(this);
var searcher = isObject(regexp) ? getMethod(regexp, SEARCH) : undefined;
if (searcher) return call(searcher, regexp, O);
var S = toString(O);
return new RegExp(regexp)[SEARCH](S);
},
// `RegExp.prototype[@@search]` method
// https://tc39.es/ecma262/#sec-regexp.prototype-@@search
function (string) {
var rx = anObject(this);
var S = toString(string);
var res = maybeCallNative(nativeSearch, rx, S);
if (res.done) return res.value;
var previousLastIndex = rx.lastIndex;
if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0;
var result = regExpExec(rx, S);
if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex;
return result === null ? -1 : result.index;
}
];
});
return es_string_search;
}
requireEs_string_search();
var web_domCollections_iterator = {};
var domIterables;
var hasRequiredDomIterables;
function requireDomIterables () {
if (hasRequiredDomIterables) return domIterables;
hasRequiredDomIterables = 1;
// iterable DOM collections
// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
domIterables = {
CSSRuleList: 0,
CSSStyleDeclaration: 0,
CSSValueList: 0,
ClientRectList: 0,
DOMRectList: 0,
DOMStringList: 0,
DOMTokenList: 1,
DataTransferItemList: 0,
FileList: 0,
HTMLAllCollection: 0,
HTMLCollection: 0,
HTMLFormElement: 0,
HTMLSelectElement: 0,
MediaList: 0,
MimeTypeArray: 0,
NamedNodeMap: 0,
NodeList: 1,
PaintRequestList: 0,
Plugin: 0,
PluginArray: 0,
SVGLengthList: 0,
SVGNumberList: 0,
SVGPathSegList: 0,
SVGPointList: 0,
SVGStringList: 0,
SVGTransformList: 0,
SourceBufferList: 0,
StyleSheetList: 0,
TextTrackCueList: 0,
TextTrackList: 0,
TouchList: 0
};
return domIterables;
}
var domTokenListPrototype;
var hasRequiredDomTokenListPrototype;
function requireDomTokenListPrototype () {
if (hasRequiredDomTokenListPrototype) return domTokenListPrototype;
hasRequiredDomTokenListPrototype = 1;
// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
var documentCreateElement = requireDocumentCreateElement();
var classList = documentCreateElement('span').classList;
var DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;
domTokenListPrototype = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;
return domTokenListPrototype;
}
var hasRequiredWeb_domCollections_iterator;
function requireWeb_domCollections_iterator () {
if (hasRequiredWeb_domCollections_iterator) return web_domCollections_iterator;
hasRequiredWeb_domCollections_iterator = 1;
var globalThis = requireGlobalThis();
var DOMIterables = requireDomIterables();
var DOMTokenListPrototype = requireDomTokenListPrototype();
var ArrayIteratorMethods = requireEs_array_iterator();
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
var setToStringTag = requireSetToStringTag();
var wellKnownSymbol = requireWellKnownSymbol();
var ITERATOR = wellKnownSymbol('iterator');
var ArrayValues = ArrayIteratorMethods.values;
var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
if (CollectionPrototype) {
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
} catch (error) {
CollectionPrototype[ITERATOR] = ArrayValues;
}
setToStringTag(CollectionPrototype, COLLECTION_NAME, true);
if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
} catch (error) {
CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
}
}
}
};
for (var COLLECTION_NAME in DOMIterables) {
handlePrototype(globalThis[COLLECTION_NAME] && globalThis[COLLECTION_NAME].prototype, COLLECTION_NAME);
}
handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
return web_domCollections_iterator;
}
requireWeb_domCollections_iterator();
var web_urlSearchParams = {};
var safeGetBuiltIn;
var hasRequiredSafeGetBuiltIn;
function requireSafeGetBuiltIn () {
if (hasRequiredSafeGetBuiltIn) return safeGetBuiltIn;
hasRequiredSafeGetBuiltIn = 1;
var globalThis = requireGlobalThis();
var DESCRIPTORS = requireDescriptors();
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
// Avoid NodeJS experimental warning
safeGetBuiltIn = function (name) {
if (!DESCRIPTORS) return globalThis[name];
var descriptor = getOwnPropertyDescriptor(globalThis, name);
return descriptor && descriptor.value;
};
return safeGetBuiltIn;
}
var urlConstructorDetection;
var hasRequiredUrlConstructorDetection;
function requireUrlConstructorDetection () {
if (hasRequiredUrlConstructorDetection) return urlConstructorDetection;
hasRequiredUrlConstructorDetection = 1;
var fails = requireFails();
var wellKnownSymbol = requireWellKnownSymbol();
var DESCRIPTORS = requireDescriptors();
var IS_PURE = requireIsPure();
var ITERATOR = wellKnownSymbol('iterator');
urlConstructorDetection = !fails(function () {
// eslint-disable-next-line unicorn/relative-url-style -- required for testing
var url = new URL('b?a=1&b=2&c=3', 'https://a');
var params = url.searchParams;
var params2 = new URLSearchParams('a=1&a=2&b=3');
var result = '';
url.pathname = 'c%20d';
params.forEach(function (value, key) {
params['delete']('b');
result += key + value;
});
params2['delete']('a', 2);
// `undefined` case is a Chromium 117 bug
// https://bugs.chromium.org/p/v8/issues/detail?id=14222
params2['delete']('b', undefined);
return (IS_PURE && (!url.toJSON || !params2.has('a', 1) || params2.has('a', 2) || !params2.has('a', undefined) || params2.has('b')))
|| (!params.size && (IS_PURE || !DESCRIPTORS))
|| !params.sort
|| url.href !== 'https://a/c%20d?a=1&c=3'
|| params.get('c') !== '3'
|| String(new URLSearchParams('?a=1')) !== 'a=1'
|| !params[ITERATOR]
// throws in Edge
|| new URL('https://a@b').username !== 'a'
|| new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
// not punycoded in Edge
|| new URL('https://тест').host !== 'xn--e1aybc'
// not escaped in Chrome 62-
|| new URL('https://a#б').hash !== '#%D0%B1'
// fails in Chrome 66-
|| result !== 'a1c3'
// throws in Safari
|| new URL('https://x', undefined).host !== 'x';
});
return urlConstructorDetection;
}
var es_string_fromCodePoint = {};
var hasRequiredEs_string_fromCodePoint;
function requireEs_string_fromCodePoint () {
if (hasRequiredEs_string_fromCodePoint) return es_string_fromCodePoint;
hasRequiredEs_string_fromCodePoint = 1;
var $ = require_export();
var uncurryThis = requireFunctionUncurryThis();
var toAbsoluteIndex = requireToAbsoluteIndex();
var $RangeError = RangeError;
var fromCharCode = String.fromCharCode;
// eslint-disable-next-line es/no-string-fromcodepoint -- required for testing
var $fromCodePoint = String.fromCodePoint;
var join = uncurryThis([].join);
// length should be 1, old FF problem
var INCORRECT_LENGTH = !!$fromCodePoint && $fromCodePoint.length !== 1;
// `String.fromCodePoint` method
// https://tc39.es/ecma262/#sec-string.fromcodepoint
$({ target: 'String', stat: true, arity: 1, forced: INCORRECT_LENGTH }, {
// eslint-disable-next-line no-unused-vars -- required for `.length`
fromCodePoint: function fromCodePoint(x) {
var elements = [];
var length = arguments.length;
var i = 0;
var code;
while (length > i) {
code = +arguments[i];
if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw new $RangeError(code + ' is not a valid code point');
elements[i++] = code < 0x10000
? fromCharCode(code)
: fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00);
} return join(elements, '');
}
});
return es_string_fromCodePoint;
}
var urlPercentCoding;
var hasRequiredUrlPercentCoding;
function requireUrlPercentCoding () {
if (hasRequiredUrlPercentCoding) return urlPercentCoding;
hasRequiredUrlPercentCoding = 1;
// TODO: in core-js [at] 4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
requireEs_string_fromCodePoint();
var getBuiltIn = requireGetBuiltIn();
var uncurryThis = requireFunctionUncurryThis();
var fromCharCode = String.fromCharCode;
var fromCodePoint = getBuiltIn('String', 'fromCodePoint');
var $encodeURIComponent = encodeURIComponent;
var $parseInt = parseInt;
var charAt = uncurryThis(''.charAt);
var push = uncurryThis([].push);
var replace = uncurryThis(''.replace);
var stringSlice = uncurryThis(''.slice);
var exec = uncurryThis(/./.exec);
var FALLBACK_REPLACER = '\uFFFD';
var VALID_HEX = /^[0-9a-f]+$/i;
// a surrogate pair is matched first, so a one-unit match is always a lone surrogate
var SURROGATE = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g;
var parseHexOctet = function (string, start) {
var substr = stringSlice(string, start, start + 2);
if (!exec(VALID_HEX, substr)) return NaN;
return $parseInt(substr, 16);
};
var getLeadingOnes = function (octet) {
var count = 0;
for (var mask = 0x80; mask > 0 && (octet & mask) !== 0; mask >>= 1) {
count++;
}
return count;
};
var utf8Decode = function (octets) {
var codePoint = null;
var length = octets.length;
switch (length) {
case 1:
codePoint = octets[0];
break;
case 2:
codePoint = (octets[0] & 0x1F) << 6 | (octets[1] & 0x3F);
break;
case 3:
codePoint = (octets[0] & 0x0F) << 12 | (octets[1] & 0x3F) << 6 | (octets[2] & 0x3F);
break;
case 4:
codePoint = (octets[0] & 0x07) << 18 | (octets[1] & 0x3F) << 12 | (octets[2] & 0x3F) << 6 | (octets[3] & 0x3F);
break;
}
// reject surrogates, overlong encodings, and out-of-range codepoints
if (codePoint === null
|| codePoint > 0x10FFFF
|| (codePoint >= 0xD800 && codePoint <= 0xDFFF)
|| codePoint < (length > 3 ? 0x10000 : length > 2 ? 0x800 : length > 1 ? 0x80 : 0)
) return null;
return codePoint;
};
var replaceLoneSurrogate = function (chunk) {
return chunk.length === 2 ? chunk : FALLBACK_REPLACER;
};
// https://url.spec.whatwg.org/#percent-decode
/* eslint-disable max-depth -- ok */
var decode = function (input) {
var length = input.length;
var result = '';
var i = 0;
while (i < length) {
var decodedChar = charAt(input, i);
if (decodedChar === '%') {
if (charAt(input, i + 1) === '%' || i + 3 > length) {
result += '%';
i++;
continue;
}
var octet = parseHexOctet(input, i + 1);
// eslint-disable-next-line no-self-compare -- NaN check
if (octet !== octet) {
result += decodedChar;
i++;
continue;
}
i += 2;
var byteSequenceLength = getLeadingOnes(octet);
if (byteSequenceLength === 0) {
decodedChar = fromCharCode(octet);
} else {
if (byteSequenceLength === 1 || byteSequenceLength > 4) {
result += FALLBACK_REPLACER;
i++;
continue;
}
var octets = [octet];
var sequenceIndex = 1;
while (sequenceIndex < byteSequenceLength) {
i++;
if (i + 3 > length || charAt(input, i) !== '%') break;
var nextByte = parseHexOctet(input, i + 1);
// eslint-disable-next-line no-self-compare -- NaN check
if (nextByte !== nextByte || nextByte > 191 || nextByte < 128) break;
// https://encoding.spec.whatwg.org/#utf-8-decoder - position-specific byte ranges
if (sequenceIndex === 1) {
if (octet === 0xE0 && nextByte < 0xA0) break;
if (octet === 0xED && nextByte > 0x9F) break;
if (octet === 0xF0 && nextByte < 0x90) break;
if (octet === 0xF4 && nextByte > 0x8F) break;
}
push(octets, nextByte);
i += 2;
sequenceIndex++;
}
if (octets.length !== byteSequenceLength) {
result += FALLBACK_REPLACER;
continue;
}
var codePoint = utf8Decode(octets);
if (codePoint === null) {
for (var replacement = 0; replacement < byteSequenceLength; replacement++) result += FALLBACK_REPLACER;
i++;
continue;
} else {
decodedChar = fromCodePoint(codePoint);
}
}
}
result += decodedChar;
i++;
}
return result;
};
/* eslint-enable max-depth -- ok */
// https://url.spec.whatwg.org/#string-percent-encode-after-encoding
// a lone surrogate is the only input `encodeURIComponent` throws on, and the UTF-8
// encoder replaces it - so the throw selects the slow path instead of a per-call scan
var encode = function (input) {
try {
return $encodeURIComponent(input);
} catch (error) {
return $encodeURIComponent(replace(input, SURROGATE, replaceLoneSurrogate));
}
};
urlPercentCoding = {
decode: decode,
encode: encode
};
return urlPercentCoding;
}
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 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 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 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 getIteratorMethodInternal;
var hasRequiredGetIteratorMethodInternal;
function requireGetIteratorMethodInternal () {
if (hasRequiredGetIteratorMethodInternal) return getIteratorMethodInternal;
hasRequiredGetIteratorMethodInternal = 1;
var classof = requireClassofRaw();
var isNullOrUndefined = requireIsNullOrUndefined();
var getMethod = requireGetMethod();
var wellKnownSymbol = requireWellKnownSymbol();
var ITERATOR = wellKnownSymbol('iterator');
var ArrayPrototype = Array.prototype;
getIteratorMethodInternal = function (it) {
if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
|| getMethod(it, '@@iterator')
|| (classof(it) === 'Arguments' ? ArrayPrototype[ITERATOR] : undefined);
};
return getIteratorMethodInternal;
}
var getIteratorInternal;
var hasRequiredGetIteratorInternal;
function requireGetIteratorInternal () {
if (hasRequiredGetIteratorInternal) return getIteratorInternal;
hasRequiredGetIteratorInternal = 1;
var call = requireFunctionCall();
var isCallable = requireIsCallable();
var anObject = requireAnObject();
var tryToString = requireTryToString();
var getIteratorMethod = requireGetIteratorMethodInternal();
var $TypeError = TypeError;
getIteratorInternal = function (argument, usingIterator) {
var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
if (isCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
throw new $TypeError(tryToString(argument) + ' is not iterable');
};
return getIteratorInternal;
}
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 arraySlice;
var hasRequiredArraySlice;
function requireArraySlice () {
if (hasRequiredArraySlice) return arraySlice;
hasRequiredArraySlice = 1;
var uncurryThis = requireFunctionUncurryThis();
arraySlice = uncurryThis([].slice);
return arraySlice;
}
var arraySort;
var hasRequiredArraySort;
function requireArraySort () {
if (hasRequiredArraySort) return arraySort;
hasRequiredArraySort = 1;
var arraySlice = requireArraySlice();
var floor = Math.floor;
var sort = function (array, comparefn) {
var length = array.length;
if (length < 8) {
// insertion sort
var i = 1;
var element, j;
while (i < length) {
j = i;
element = array[i];
while (j && comparefn(array[j - 1], element) > 0) {
array[j] = array[--j];
}
if (j !== i++) array[j] = element;
}
} else {
// merge sort
var middle = floor(length / 2);
var left = sort(arraySlice(array, 0, middle), comparefn);
var right = sort(arraySlice(array, middle), comparefn);
var llength = left.length;
var rlength = right.length;
var lindex = 0;
var rindex = 0;
while (lindex < llength || rindex < rlength) {
array[lindex + rindex] = (lindex < llength && rindex < rlength)
? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]
: lindex < llength ? left[lindex++] : right[rindex++];
}
}
return array;
};
arraySort = sort;
return arraySort;
}
var web_urlSearchParams_constructor;
var hasRequiredWeb_urlSearchParams_constructor;
function requireWeb_urlSearchParams_constructor () {
if (hasRequiredWeb_urlSearchParams_constructor) return web_urlSearchParams_constructor;
hasRequiredWeb_urlSearchParams_constructor = 1;
// TODO: in core-js [at] 4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
requireEs_array_iterator();
var $ = require_export();
var globalThis = requireGlobalThis();
var safeGetBuiltIn = requireSafeGetBuiltIn();
var call = requireFunctionCall();
var uncurryThis = requireFunctionUncurryThis();
var DESCRIPTORS = requireDescriptors();
var USE_NATIVE_URL = requireUrlConstructorDetection();
var percentCoding = requireUrlPercentCoding();
var defineBuiltIn = requireDefineBuiltIn();
var defineBuiltInAccessor = requireDefineBuiltInAccessor();
var defineBuiltIns = requireDefineBuiltIns();
var setToStringTag = requireSetToStringTag();
var createIteratorConstructor = requireIteratorCreateConstructor();
var InternalStateModule = requireInternalState();
var anInstance = requireAnInstance();
var isCallable = requireIsCallable();
var hasOwn = requireHasOwnProperty();
var bind = requireFunctionBindContext();
var classof = requireClassof();
var anObject = requireAnObject();
var isObject = requireIsObject();
var $toString = requireToString();
var create = requireObjectCreate();
var createPropertyDescriptor = requireCreatePropertyDescriptor();
var getIterator = requireGetIteratorInternal();
var getIteratorMethod = requireGetIteratorMethodInternal();
var createIterResultObject = requireCreateIterResultObject();
var validateArgumentsLength = requireValidateArgumentsLength();
var wellKnownSymbol = requireWellKnownSymbol();
var arraySort = requireArraySort();
var ITERATOR = wellKnownSymbol('iterator');
var URL_SEARCH_PARAMS = 'URLSearchParams';
var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
var setInternalState = InternalStateModule.set;
var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
var percentDecode = percentCoding.decode;
var percentEncode = percentCoding.encode;
var nativeFetch = safeGetBuiltIn('fetch');
var NativeRequest = safeGetBuiltIn('Request');
var Headers = safeGetBuiltIn('Headers');
var RequestPrototype = NativeRequest && NativeRequest.prototype;
var HeadersPrototype = Headers && Headers.prototype;
var TypeError = globalThis.TypeError;
var charAt = uncurryThis(''.charAt);
var join = uncurryThis([].join);
var push = uncurryThis([].push);
var replace = uncurryThis(''.replace);
var shift = uncurryThis([].shift);
var splice = uncurryThis([].splice);
var split = uncurryThis(''.split);
var stringSlice = uncurryThis(''.slice);
var plus = /\+/g;
// https://url.spec.whatwg.org/#urlencoded-parsing - `+` decodes to a space
var decodeQueryComponent = function (input) {
return percentDecode(replace(input, plus, ' '));
};
var find = /[!'()~]|%20/g;
var replacements = {
'!': '%21',
"'": '%27',
'(': '%28',
')': '%29',
'~': '%7E',
'%20': '+'
};
var replacer = function (match) {
return replacements[match];
};
var serialize = function (it) {
return replace(percentEncode(it), find, replacer);
};
var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
setInternalState(this, {
type: URL_SEARCH_PARAMS_ITERATOR,
target: getInternalParamsState(params).entries,
index: 0,
kind: kind
});
}, URL_SEARCH_PARAMS, function next() {
var state = getInternalIteratorState(this);
var target = state.target;
var index = state.index++;
if (!target || index >= target.length) {
state.target = null;
return createIterResultObject(undefined, true);
}
var entry = target[index];
switch (state.kind) {
case 'keys': return createIterResultObject(entry.key, false);
case 'values': return createIterResultObject(entry.value, false);
} return createIterResultObject([entry.key, entry.value], false);
}, true);
var URLSearchParamsState = function (init) {
this.entries = [];
this.url = null;
if (init !== undefined) {
if (isObject(init)) this.parseObject(init);
else this.parseQuery(typeof init == 'string' ? charAt(init, 0) === '?' ? stringSlice(init, 1) : init : $toString(init));
}
};
URLSearchParamsState.prototype = {
type: URL_SEARCH_PARAMS,
bindURL: function (url) {
this.url = url;
this.update();
},
parseObject: function (object) {
var entries = this.entries;
var iteratorMethod = getIteratorMethod(object);
var iterator, next, step, entryIterator, entryNext, first, second;
if (iteratorMethod) {
iterator = getIterator(object, iteratorMethod);
next = iterator.next;
while (!(step = call(next, iterator)).done) {
entryIterator = getIterator(anObject(step.value));
entryNext = entryIterator.next;
if (
(first = call(entryNext, entryIterator)).done ||
(second = call(entryNext, entryIterator)).done ||
!call(entryNext, entryIterator).done
) throw new TypeError('Expected sequence with length 2');
push(entries, { key: $toString(first.value), value: $toString(second.value) });
}
} else for (var key in object) if (hasOwn(object, key)) {
push(entries, { key: key, value: $toString(object[key]) });
}
},
parseQuery: function (query) {
if (query) {
var entries = this.entries;
var attributes = split(query, '&');
var index = 0;
var attribute, entry;
while (index < attributes.length) {
attribute = attributes[index++];
if (attribute.length) {
entry = split(attribute, '=');
push(entries, {
key: decodeQueryComponent(shift(entry)),
value: decodeQueryComponent(join(entry, '='))
});
}
}
}
},
serialize: function () {
var entries = this.entries;
var result = [];
var index = 0;
var entry;
while (index < entries.length) {
entry = entries[index++];
push(result, serialize(entry.key) + '=' + serialize(entry.value));
} return join(result, '&');
},
update: function () {
this.entries.length = 0;
this.parseQuery(this.url.query);
},
updateURL: function () {
if (this.url) this.url.update();
}
};
// `URLSearchParams` constructor
// https://url.spec.whatwg.org/#interface-urlsearchparams
var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
anInstance(this, URLSearchParamsPrototype);
var init = arguments.length > 0 ? arguments[0] : undefined;
var state = setInternalState(this, new URLSearchParamsState(init));
if (!DESCRIPTORS) this.size = state.entries.length;
};
var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
defineBuiltIns(URLSearchParamsPrototype, {
// `URLSearchParams.prototype.append` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-append
append: function append(name, value) {
var state = getInternalParamsState(this);
validateArgumentsLength(arguments.length, 2);
push(state.entries, { key: $toString(name), value: $toString(value) });
if (!DESCRIPTORS) this.size++;
state.updateURL();
},
// `URLSearchParams.prototype.delete` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-delete
'delete': function (name /* , value */) {
var state = getInternalParamsState(this);
var length = validateArgumentsLength(arguments.length, 1);
var entries = state.entries;
var key = $toString(name);
var $value = length < 2 ? undefined : arguments[1];
var value = $value === undefined ? $value : $toString($value);
var index = 0;
while (index < entries.length) {
var entry = entries[index];
if (entry.key === key && (value === undefined || entry.value === value)) {
splice(entries, index, 1);
} else index++;
}
if (!DESCRIPTORS) this.size = entries.length;
state.updateURL();
},
// `URLSearchParams.prototype.get` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-get
get: function get(name) {
var entries = getInternalParamsState(this).entries;
validateArgumentsLength(arguments.length, 1);
var key = $toString(name);
var index = 0;
for (; index < entries.length; index++) {
if (entries[index].key === key) return entries[index].value;
}
return null;
},
// `URLSearchParams.prototype.getAll` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-getall
getAll: function getAll(name) {
var entries = getInternalParamsState(this).entries;
validateArgumentsLength(arguments.length, 1);
var key = $toString(name);
var result = [];
var index = 0;
for (; index < entries.length; index++) {
if (entries[index].key === key) push(result, entries[index].value);
}
return result;
},
// `URLSearchParams.prototype.has` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-has
has: function has(name /* , value */) {
var entries = getInternalParamsState(this).entries;
var length = validateArgumentsLength(arguments.length, 1);
var key = $toString(name);
var $value = length < 2 ? undefined : arguments[1];
var value = $value === undefined ? $value : $toString($value);
var index = 0;
while (index < entries.length) {
var entry = entries[index++];
if (entry.key === key && (value === undefined || entry.value === value)) return true;
}
return false;
},
// `URLSearchParams.prototype.set` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-set
set: function set(name, value) {
var state = getInternalParamsState(this);
validateArgumentsLength(arguments.length, 2);
var entries = state.entries;
var found = false;
var key = $toString(name);
var val = $toString(value);
var index = 0;
var entry;
for (; index < entries.length; index++) {
entry = entries[index];
if (entry.key === key) {
if (found) splice(entries, index--, 1);
else {
found = true;
entry.value = val;
}
}
}
if (!found) push(entries, { key: key, value: val });
if (!DESCRIPTORS) this.size = entries.length;
state.updateURL();
},
// `URLSearchParams.prototype.sort` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-sort
sort: function sort() {
var state = getInternalParamsState(this);
arraySort(state.entries, function (a, b) {
return a.key > b.key ? 1 : -1;
});
state.updateURL();
},
// `URLSearchParams.prototype.forEach` method
forEach: function forEach(callback /* , thisArg */) {
var entries = getInternalParamsState(this).entries;
var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined);
var index = 0;
var entry;
while (index < entries.length) {
entry = entries[index++];
boundFunction(entry.value, entry.key, this);
}
},
// `URLSearchParams.prototype.keys` method
keys: function keys() {
return new URLSearchParamsIterator(this, 'keys');
},
// `URLSearchParams.prototype.values` method
values: function values() {
return new URLSearchParamsIterator(this, 'values');
},
// `URLSearchParams.prototype.entries` method
entries: function entries() {
return new URLSearchParamsIterator(this, 'entries');
}
}, { enumerable: true });
// `URLSearchParams.prototype[@@iterator]` method
defineBuiltIn(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries, { name: 'entries' });
// `URLSearchParams.prototype.toString` method
// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
defineBuiltIn(URLSearchParamsPrototype, 'toString', function toString() {
return getInternalParamsState(this).serialize();
}, { enumerable: true });
// `URLSearchParams.prototype.size` getter
// https://url.spec.whatwg.org/#dom-urlsearchparams-size
if (DESCRIPTORS) defineBuiltInAccessor(URLSearchParamsPrototype, 'size', {
get: function size() {
return getInternalParamsState(this).entries.length;
},
configurable: true,
enumerable: true
});
setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
$({ global: true, constructor: true, forced: !USE_NATIVE_URL }, {
URLSearchParams: URLSearchParamsConstructor
});
// Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`
if (!USE_NATIVE_URL && isCallable(Headers)) {
var headersHas = uncurryThis(HeadersPrototype.has);
var headersSet = uncurryThis(HeadersPrototype.set);
var wrapRequestOptions = function (init) {
if (isObject(init)) {
var body = init.body;
var headers;
if (classof(body) === URL_SEARCH_PARAMS) {
headers = init.headers ? new Headers(init.headers) : new Headers();
if (!headersHas(headers, 'content-type')) {
headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
}
return create(init, {
body: createPropertyDescriptor(0, $toString(body)),
headers: createPropertyDescriptor(0, headers)
});
}
} return init;
};
if (isCallable(nativeFetch)) {
$({ global: true, enumerable: true, dontCallGetSet: true, forced: true }, {
fetch: function fetch(input /* , init */) {
return nativeFetch(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
}
});
}
if (isCallable(NativeRequest)) {
var RequestConstructor = function Request(input /* , init */) {
anInstance(this, RequestPrototype);
return new NativeRequest(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
};
RequestPrototype.constructor = RequestConstructor;
RequestConstructor.prototype = RequestPrototype;
$({ global: true, constructor: true, dontCallGetSet: true, forced: true }, {
Request: RequestConstructor
});
}
}
web_urlSearchParams_constructor = {
URLSearchParams: URLSearchParamsConstructor,
getState: getInternalParamsState
};
return web_urlSearchParams_constructor;
}
var hasRequiredWeb_urlSearchParams;
function requireWeb_urlSearchParams () {
if (hasRequiredWeb_urlSearchParams) return web_urlSearchParams;
hasRequiredWeb_urlSearchParams = 1;
// TODO: Remove this module from `core-js [at] 4` since it's replaced to module below
requireWeb_urlSearchParams_constructor();
return web_urlSearchParams;
}
requireWeb_urlSearchParams();
/**
* @author: general
* @website: note.generals.space
* @email: generals.space@gmail.com
* @github: https://github.com/generals-space/bootstrap-table-addrbar
* @update: zhixin wen <wenzhixin2010@gmail.com>
*/
var Utils = $.fn.bootstrapTable.utils;
Object.assign($.fn.bootstrapTable.defaults, {
addrbar: false,
addrPrefix: '',
addrCustomParams: {}
});
$.BootstrapTable = /*#__PURE__*/function (_$$BootstrapTable) {
function _class() {
_classCallCheck(this, _class);
return _callSuper(this, _class, arguments);
}
_inherits(_class, _$$BootstrapTable);
return _createClass(_class, [{
key: "init",
value: function init() {
if (this.options.pagination && this.options.addrbar) {
this.initAddrbar();
}
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_superPropGet(_class, "init", this)(args);
}
/*
* Priority order:
* The value specified by the user has the highest priority.
* If it is not specified, it will be obtained from the address bar.
* If it is not obtained, the default value will be used.
*/
}, {
key: "getDefaultOptionValue",
value: function getDefaultOptionValue(optionName, prefixName) {
if (this.options[optionName] !== $.BootstrapTable.DEFAULTS[optionName]) {
return this.options[optionName];
}
return this.searchParams.get("".concat(this.options.addrPrefix || '').concat(prefixName)) || $.BootstrapTable.DEFAULTS[optionName];
}
}, {
key: "initAddrbar",
value: function initAddrbar() {
var _this = this;
// 标志位, 初始加载后关闭
this.addrbarInit = true;
this.searchParams = new URLSearchParams(window.location.search.substring(1));
this.options.pageNumber = +this.getDefaultOptionValue('pageNumber', 'page');
this.options.pageSize = +this.getDefaultOptionValue('pageSize', 'size');
this.options.sortOrder = this.getDefaultOptionValue('sortOrder', 'order');
this.options.sortName = this.getDefaultOptionValue('sortName', 'sort');
this.options.searchText = this.getDefaultOptionValue('searchText', 'search');
var prefix = this.options.addrPrefix || '';
var onLoadSuccess = this.options.onLoadSuccess;
var onPageChange = this.options.onPageChange;
this.options.onLoadSuccess = function (data) {
if (_this.addrbarInit) {
_this.addrbarInit = false;
} else {
_this.updateHistoryState(prefix);
}
if (onLoadSuccess) {
onLoadSuccess.call(_this, data);
}
};
this.options.onPageChange = function (number, size) {
_this.updateHistoryState(prefix);
if (onPageChange) {
onPageChange.call(_this, number, size);
}
};
}
}, {
key: "updateHistoryState",
value: function updateHistoryState(prefix) {
var params = {};
params["".concat(prefix, "page")] = this.options.pageNumber;
params["".concat(prefix, "size")] = this.options.pageSize;
params["".concat(prefix, "order")] = this.options.sortOrder;
params["".concat(prefix, "sort")] = this.options.sortName;
params["".concat(prefix, "search")] = this.options.searchText;
for (var _i = 0, _Object$entries = Object.entries(params); _i < _Object$entries.length; _i++) {
var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
key = _Object$entries$_i[0],
value = _Object$entries$_i[1];
if (value === undefined) {
this.searchParams.delete(key);
} else {
this.searchParams.set(key, value);
}
}
var customParams = Utils.calculateObjectValue(this.options, this.options.addrCustomParams, [], {});
for (var _i2 = 0, _Object$entries2 = Object.entries(customParams); _i2 < _Object$entries2.length; _i2++) {
var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
_key2 = _Object$entries2$_i[0],
_value = _Object$entries2$_i[1];
this.searchParams.set(_key2, _value);
}
var url = "?".concat(this.searchParams.toString());
if (location.hash) {
url += location.hash;
}
window.history.pushState({}, '', url);
}
}, {
key: "resetSearch",
value: function resetSearch(text) {
_superPropGet(_class, "resetSearch", this)([text]);
this.options.searchText = text || '';
}
}]);
}($.BootstrapTable);
}));