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)
5,645 lines • 198 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 _arrayWithoutHoles(r) {
if (Array.isArray(r)) return _arrayLikeToArray(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), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
writable: false
}), e;
}
function _createForOfIteratorHelper(r, e) {
var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (!t) {
if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
t && (r = t);
var n = 0,
F = function () {};
return {
s: F,
n: function () {
return n >= r.length ? {
done: true
} : {
done: false,
value: r[n++]
};
},
e: function (r) {
throw r;
},
f: F
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var o,
a = true,
u = false;
return {
s: function () {
t = t.call(r);
},
n: function () {
var r = t.next();
return a = r.done, r;
},
e: function (r) {
u = true, o = r;
},
f: function () {
try {
a || null == t.return || t.return();
} finally {
if (u) throw o;
}
}
};
}
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 _iterableToArray(r) {
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _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 _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 _toConsumableArray(r) {
return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r);
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (String )(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
return typeof o;
} : function (o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
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 es_array_filter = {};
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 arrayIteration;
var hasRequiredArrayIteration;
function requireArrayIteration () {
if (hasRequiredArrayIteration) return arrayIteration;
hasRequiredArrayIteration = 1;
var bind = requireFunctionBindContext();
var IndexedObject = requireIndexedObject();
var toObject = requireToObject();
var lengthOfArrayLike = requireLengthOfArrayLike();
var arraySpeciesCreate = requireArraySpeciesCreate();
var createProperty = requireCreateProperty();
// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
var createMethod = function (TYPE) {
var IS_MAP = TYPE === 1;
var IS_FILTER = TYPE === 2;
var IS_SOME = TYPE === 3;
var IS_EVERY = TYPE === 4;
var IS_FIND_INDEX = TYPE === 6;
var IS_FILTER_REJECT = TYPE === 7;
var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;
return function ($this, callbackfn, that) {
var O = toObject($this);
var self = IndexedObject(O);
var length = lengthOfArrayLike(self);
var boundFunction = bind(callbackfn, that);
var index = 0;
var resIndex = 0;
var target = IS_MAP ? arraySpeciesCreate($this, length) : IS_FILTER || IS_FILTER_REJECT ? arraySpeciesCreate($this, 0) : undefined;
var value, result;
for (;length > index; index++) if (NO_HOLES || index in self) {
value = self[index];
result = boundFunction(value, index, O);
if (TYPE) {
if (IS_MAP) createProperty(target, index, result); // map
else if (result) switch (TYPE) {
case 3: return true; // some
case 5: return value; // find
case 6: return index; // findIndex
case 2: createProperty(target, resIndex++, value); // filter
} else switch (TYPE) {
case 4: return false; // every
case 7: createProperty(target, resIndex++, value); // filterReject
}
}
}
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
};
};
arrayIteration = {
// `Array.prototype.forEach` method
// https://tc39.es/ecma262/#sec-array.prototype.foreach
forEach: createMethod(0),
// `Array.prototype.map` method
// https://tc39.es/ecma262/#sec-array.prototype.map
map: createMethod(1),
// `Array.prototype.filter` method
// https://tc39.es/ecma262/#sec-array.prototype.filter
filter: createMethod(2),
// `Array.prototype.some` method
// https://tc39.es/ecma262/#sec-array.prototype.some
some: createMethod(3),
// `Array.prototype.every` method
// https://tc39.es/ecma262/#sec-array.prototype.every
every: createMethod(4),
// `Array.prototype.find` method
// https://tc39.es/ecma262/#sec-array.prototype.find
find: createMethod(5),
// `Array.prototype.findIndex` method
// https://tc39.es/ecma262/#sec-array.prototype.findIndex
findIndex: createMethod(6),
// `Array.prototype.filterReject` method
// https://github.com/tc39/proposal-array-filtering
filterReject: createMethod(7)
};
return arrayIteration;
}
var hasRequiredEs_array_filter;
function requireEs_array_filter () {
if (hasRequiredEs_array_filter) return es_array_filter;
hasRequiredEs_array_filter = 1;
var $ = require_export();
var $filter = requireArrayIteration().filter;
var arrayMethodHasSpeciesSupport = requireArrayMethodHasSpeciesSupport();
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');
// `Array.prototype.filter` method
// https://tc39.es/ecma262/#sec-array.prototype.filter
// with adding support of @@species
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
filter: function filter(callbackfn /* , thisArg */) {
return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
return es_array_filter;
}
requireEs_array_filter();
var es_array_find = {};
var objectDefineProperties = {};
var objectKeys;
var hasRequiredObjectKeys;
function requireObjectKeys () {
if (hasRequiredObjectKeys) return objectKeys;
hasRequiredObjectKeys = 1;
var internalObjectKeys = requireObjectKeysInternal();
var enumBugKeys = requireEnumBugKeys();
// `Object.keys` method
// https://tc39.es/ecma262/#sec-object.keys
// eslint-disable-next-line es/no-object-keys -- safe
objectKeys = Object.keys || function keys(O) {
return internalObjectKeys(O, enumBugKeys);
};
return objectKeys;
}
var hasRequiredObjectDefineProperties;
function requireObjectDefineProperties () {
if (hasRequiredObjectDefineProperties) return objectDefineProperties;
hasRequiredObjectDefineProperties = 1;
var DESCRIPTORS = requireDescriptors();
var V8_PROTOTYPE_DEFINE_BUG = requireV8PrototypeDefineBug();
var definePropertyModule = requireObjectDefineProperty();
var anObject = requireAnObject();
var toIndexedObject = requireToIndexedObject();
var objectKeys = requireObjectKeys();
// `Object.defineProperties` method
// https://tc39.es/ecma262/#sec-object.defineproperties
// eslint-disable-next-line es/no-object-defineproperties -- safe
objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
anObject(O);
var props = toIndexedObject(Properties);
var keys = objectKeys(Properties);
var length = keys.length;
var index = 0;
var key;
while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
return O;
};
return objectDefineProperties;
}
var html;
var hasRequiredHtml;
function requireHtml () {
if (hasRequiredHtml) return html;
hasRequiredHtml = 1;
var getBuiltIn = requireGetBuiltIn();
html = getBuiltIn('document', 'documentElement');
return html;
}
var objectCreate;
var hasRequiredObjectCreate;
function requireObjectCreate () {
if (hasRequiredObjectCreate) return objectCreate;
hasRequiredObjectCreate = 1;
/* global ActiveXObject -- old IE, WSH */
var anObject = requireAnObject();
var definePropertiesModule = requireObjectDefineProperties();
var enumBugKeys = requireEnumBugKeys();
var hiddenKeys = requireHiddenKeys();
var html = requireHtml();
var documentCreateElement = requireDocumentCreateElement();
var sharedKey = requireSharedKey();
var GT = '>';
var LT = '<';
var PROTOTYPE = 'prototype';
var SCRIPT = 'script';
var IE_PROTO = sharedKey('IE_PROTO');
var EmptyConstructor = function () { /* empty */ };
var scriptTag = function (content) {
return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
};
// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
var NullProtoObjectViaActiveX = function (activeXDocument) {
activeXDocument.write(scriptTag(''));
activeXDocument.close();
var temp = activeXDocument.parentWindow.Object;
// eslint-disable-next-line no-useless-assignment -- avoid memory leak
activeXDocument = null;
return temp;
};
// Create object with fake `null` prototype: use iframe Object with cleared prototype
var NullProtoObjectViaIFrame = function () {
// Thrash, waste and sodomy: IE GC bug
var iframe = documentCreateElement('iframe');
var JS = 'java' + SCRIPT + ':';
var iframeDocument;
iframe.style.display = 'none';
html.appendChild(iframe);
// https://github.com/zloirock/core-js/issues/475
iframe.src = String(JS);
iframeDocument = iframe.contentWindow.document;
iframeDocument.open();
iframeDocument.write(scriptTag('document.F=Object'));
iframeDocument.close();
return iframeDocument.F;
};
// Check for document.domain and active x support
// No need to use active x approach when document.domain is not set
// see https://github.com/es-shims/es5-shim/issues/150
// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
// avoid IE GC bug
var activeXDocument;
var NullProtoObject = function () {
try {
activeXDocument = new ActiveXObject('htmlfile');
} catch (error) { /* ignore */ }
NullProtoObject = typeof document != 'undefined'
? document.domain && activeXDocument
? NullProtoObjectViaActiveX(activeXDocument) // old IE
: NullProtoObjectViaIFrame()
: NullProtoObjectViaActiveX(activeXDocument); // WSH
var length = enumBugKeys.length;
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
return NullProtoObject();
};
hiddenKeys[IE_PROTO] = true;
// `Object.create` method
// https://tc39.es/ecma262/#sec-object.create
// eslint-disable-next-line es/no-object-create -- safe
objectCreate = Object.create || function create(O, Properties) {
var result;
if (O !== null) {
EmptyConstructor[PROTOTYPE] = anObject(O);
result = new EmptyConstructor();
EmptyConstructor[PROTOTYPE] = null;
// add "__proto__" for Object.getPrototypeOf polyfill
result[IE_PROTO] = O;
} else result = NullProtoObject();
return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
};
return objectCreate;
}
var addToUnscopables;
var hasRequiredAddToUnscopables;
function requireAddToUnscopables () {
if (hasRequiredAddToUnscopables) return addToUnscopables;
hasRequiredAddToUnscopables = 1;
var wellKnownSymbol = requireWellKnownSymbol();
var create = requireObjectCreate();
var defineProperty = requireObjectDefineProperty().f;
var UNSCOPABLES = wellKnownSymbol('unscopables');
var ArrayPrototype = Array.prototype;
// Array.prototype[@@unscopables]
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
if (ArrayPrototype[UNSCOPABLES] === undefined) {
defineProperty(ArrayPrototype, UNSCOPABLES, {
configurable: true,
value: create(null)
});
}
// add a key to Array.prototype[@@unscopables]
addToUnscopables = function (key) {
ArrayPrototype[UNSCOPABLES][key] = true;
};
return addToUnscopables;
}
var hasRequiredEs_array_find;
function requireEs_array_find () {
if (hasRequiredEs_array_find) return es_array_find;
hasRequiredEs_array_find = 1;
var $ = require_export();
var $find = requireArrayIteration().find;
var addToUnscopables = requireAddToUnscopables();
var FIND = 'find';
var SKIPS_HOLES = true;
// Shouldn't skip holes
// eslint-disable-next-line es/no-array-prototype-find -- testing
if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });
// `Array.prototype.find` method
// https://tc39.es/ecma262/#sec-array.prototype.find
$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
find: function find(callbackfn /* , that = undefined */) {
return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables(FIND);
return es_array_find;
}
requireEs_array_find();
var es_array_flat = {};
var flattenIntoArray_1;
var hasRequiredFlattenIntoArray;
function requireFlattenIntoArray () {
if (hasRequiredFlattenIntoArray) return flattenIntoArray_1;
hasRequiredFlattenIntoArray = 1;
var isArray = requireIsArray();
var lengthOfArrayLike = requireLengthOfArrayLike();
var doesNotExceedSafeInteger = requireDoesNotExceedSafeInteger();
var bind = requireFunctionBindContext();
var createProperty = requireCreateProperty();
// `FlattenIntoArray` abstract operation
// https://tc39.es/ecma262/#sec-flattenintoarray
var flattenIntoArray = function (target, original, source, sourceLen, start, depth, mapper, thisArg) {
var targetIndex = start;
var sourceIndex = 0;
var mapFn = mapper ? bind(mapper, thisArg) : false;
var element, elementLen;
while (sourceIndex < sourceLen) {
if (sourceIndex in source) {
element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
if (depth > 0 && isArray(element)) {
elementLen = lengthOfArrayLike(element);
targetIndex = flattenIntoArray(target, original, element, elementLen, targetIndex, depth - 1) - 1;
} else {
doesNotExceedSafeInteger(targetIndex + 1);
createProperty(target, targetIndex, element);
}
targetIndex++;
}
sourceIndex++;
}
return targetIndex;
};
flattenIntoArray_1 = flattenIntoArray;
return flattenIntoArray_1;
}
var hasRequiredEs_array_flat;
function requireEs_array_flat () {
if (hasRequiredEs_array_flat) return es_array_flat;
hasRequiredEs_array_flat = 1;
var $ = require_export();
var flattenIntoArray = requireFlattenIntoArray();
var toObject = requireToObject();
var lengthOfArrayLike = requireLengthOfArrayLike();
var toIntegerOrInfinity = requireToIntegerOrInfinity();
var arraySpeciesCreate = requireArraySpeciesCreate();
// `Array.prototype.flat` method
// https://tc39.es/ecma262/#sec-array.prototype.flat
$({ target: 'Array', proto: true }, {
flat: function flat(/* depthArg = 1 */) {
var depthArg = arguments.length ? arguments[0] : undefined;
var O = toObject(this);
var sourceLen = lengthOfArrayLike(O);
var depthNum = depthArg === undefined ? 1 : toIntegerOrInfinity(depthArg);
var A = arraySpeciesCreate(O, 0);
flattenIntoArray(A, O, O, sourceLen, 0, depthNum);
return A;
}
});
return es_array_flat;
}
requireEs_array_flat();
var es_array_includes = {};
var hasRequiredEs_array_includes;
function requireEs_array_includes () {
if (hasRequiredEs_array_includes) return es_array_includes;
hasRequiredEs_array_includes = 1;
var $ = require_export();
var $includes = requireArrayIncludes().includes;
var fails = requireFails();
var addToUnscopables = requireAddToUnscopables();
// FF99+ bug
var BROKEN_ON_SPARSE = fails(function () {
// eslint-disable-next-line es/no-array-prototype-includes -- detection
return !Array(1).includes();
});
// Safari 26.4- bug
var BROKEN_ON_SPARSE_WITH_FROM_INDEX = fails(function () {
// eslint-disable-next-line no-sparse-arrays, es/no-array-prototype-includes -- detection
return [, 1].includes(undefined, 1);
});
// `Array.prototype.includes` method
// https://tc39.es/ecma262/#sec-array.prototype.includes
$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE || BROKEN_ON_SPARSE_WITH_FROM_INDEX }, {
includes: function includes(el /* , fromIndex = 0 */) {
return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
}
});
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('includes');
return es_array_includes;
}
requireEs_array_includes();
var es_array_indexOf = {};
var arrayMethodIsStrict;
var hasRequiredArrayMethodIsStrict;
function requireArrayMethodIsStrict () {
if (hasRequiredArrayMethodIsStrict) return arrayMethodIsStrict;
hasRequiredArrayMethodIsStrict = 1;
var fails = requireFails();
arrayMethodIsStrict = function (METHOD_NAME, argument) {
var method = [][METHOD_NAME];
return !!method && fails(function () {
// eslint-disable-next-line no-useless-call -- required for testing
method.call(null, argument || function () { return 1; }, 1);
});
};
return arrayMethodIsStrict;
}
var hasRequiredEs_array_indexOf;
function requireEs_array_indexOf () {
if (hasRequiredEs_array_indexOf) return es_array_indexOf;
hasRequiredEs_array_indexOf = 1;
/* eslint-disable es/no-array-prototype-indexof -- required for testing */
var $ = require_export();
var uncurryThis = requireFunctionUncurryThisClause();
var $indexOf = requireArrayIncludes().indexOf;
var arrayMethodIsStrict = requireArrayMethodIsStrict();
var nativeIndexOf = uncurryThis([].indexOf);
var NEGATIVE_ZERO = !!nativeIndexOf && 1 / nativeIndexOf([1], 1, -0) < 0;
var FORCED = NEGATIVE_ZERO || !arrayMethodIsStrict('indexOf');
// `Array.prototype.indexOf` method
// https://tc39.es/ecma262/#sec-array.prototype.indexof
$({ target: 'Array', proto: true, forced: FORCED }, {
indexOf: function indexOf(searchElement /* , fromIndex = 0 */) {
var fromIndex = arguments.length > 1 ? arguments[1] : undefined;
return NEGATIVE_ZERO
// convert -0 to +0
? nativeIndexOf(this, searchElement, fromIndex) || 0
: $indexOf(this, searchElement, fromIndex);
}
});
return es_array_indexOf;
}
requireEs_array_indexOf();
var es_array_map = {};
var hasRequiredEs_array_map;
function requireEs_array_map () {
if (hasRequiredEs_array_map) return es_array_map;
hasRequiredEs_array_map = 1;
var $ = require_export();
var $map = requireArrayIteration().map;
var arrayMethodHasSpeciesSupport = requireArrayMethodHasSpeciesSupport();
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');
// `Array.prototype.map` method
// https://tc39.es/ecma262/#sec-array.prototype.map
// with adding support of @@species
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
map: function map(callbackfn /* , thisArg */) {
return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
return es_array_map;
}
requireEs_array_map();
var es_array_slice = {};
var arraySlice;
var hasRequiredArraySlice;
function requireArraySlice () {
if (hasRequiredArraySlice) return arraySlice;
hasRequiredArraySlice = 1;
var uncurryThis = requireFunctionUncurryThis();
arraySlice = uncurryThis([].slice);
return arraySlice;
}
var hasRequiredEs_array_slice;
function requireEs_array_slice () {
if (hasRequiredEs_array_slice) return es_array_slice;
hasRequiredEs_array_slice = 1;
var $ = require_export();
var isArray = requireIsArray();
var isConstructor = requireIsConstructor();
var isObject = requireIsObject();
var toAbsoluteIndex = requireToAbsoluteIndex();
var lengthOfArrayLike = requireLengthOfArrayLike();
var toIndexedObject = requireToIndexedObject();
var createProperty = requireCreateProperty();
var setArrayLength = requireArraySetLength();
var wellKnownSymbol = requireWellKnownSymbol();
var arrayMethodHasSpeciesSupport = requireArrayMethodHasSpeciesSupport();
var nativeSlice = requireArraySlice();
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');
var SPECIES = wellKnownSymbol('species');
var $Array = Array;
var max = Math.max;
// `Array.prototype.slice` method
// https://tc39.es/ecma262/#sec-array.prototype.slice
// fallback for not array-like ES3 strings and DOM objects
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
slice: function slice(start, end) {
var O = toIndexedObject(this);
var length = lengthOfArrayLike(O);
var k = toAbsoluteIndex(start, length);
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
// inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
var Constructor, result, n;
if (isArray(O)) {
Constructor = O.constructor;
// cross-realm fallback
if (isConstructor(Constructor) && (Constructor === $Array || isArray(Constructor.prototype))) {
Constructor = undefined;
} else if (isObject(Constructor)) {
Constructor = Constructor[SPECIES];
if (Constructor === null) Constructor = undefined;
}
if (Constructor === $Array || Constructor === undefined) {
return nativeSlice(O, k, fin);
}
}
result = new (Constructor === undefined ? $Array : Constructor)(max(fin - k, 0));
for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
setArrayLength(result, n);
return result;
}
});
return es_array_slice;
}
requireEs_array_slice();
var es_array_sort = {};
var deletePropertyOrThrow;
var hasRequiredDeletePropertyOrThrow;
function requireDeletePropertyOrThrow () {
if (hasRequiredDeletePropertyOrThrow) return deletePropertyOrThrow;
hasRequiredDeletePropertyOrThrow = 1;
var tryToString = requireTryToString();
var $TypeError = TypeError;
deletePropertyOrThrow = function (O, P) {
if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
};
return deletePropertyOrThrow;
}
var 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 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 environmentFfVersion;
var hasRequiredEnvironmentFfVersion;
function requireEnvironmentFfVersion () {
if (hasRequiredEnvironmentFfVersion) return environmentFfVersion;
hasRequiredEnvironmentFfVersion = 1;
var userAgent = requireEnvironmentUserAgent();
var firefox = userAgent.match(/firefox\/(\d+)/i);
environmentFfVersion = !!firefox && +firefox[1];
return environmentFfVersion;
}
var environmentIsIeOrEdge;
var hasRequiredEnvironmentIsIeOrEdge;
function requireEnvironmentIsIeOrEdge () {
if (hasRequiredEnvironmentIsIeOrEdge) return environmentIsIeOrEdge;
hasRequiredEnvironmentIsIeOrEdge = 1;
var UA = requireEnvironmentUserAgent();
environmentIsIeOrEdge = /MSIE|Trident/.test(UA);
return environmentIsIeOrEdge;
}
var environmentWebkitVersion;
var hasRequiredEnvironmentWebkitVersion;
function requireEnvironmentWebkitVersion () {
if (hasRequiredEnvironmentWebkitVersion) return environmentWebkitVersion;
hasRequiredEnvironmentWebkitVersion = 1;
var userAgent = requireEnvironmentUserAgent();
var webkit = userAgent.match(/AppleWebKit\/(\d+)\./);
environmentWebkitVersion = !!webkit && +webkit[1];
return environmentWebkitVersion;
}
var hasRequiredEs_array_sort;
function requireEs_array_sort () {
if (hasRequiredEs_array_sort) return es_array_sort;
hasRequiredEs_array_sort = 1;
var $ = require_export();
var uncurryThis = requireFunctionUncurryThis();
var aCallable = requireACallable();
var toObject = requireToObject();
var lengthOfArrayLike = requireLengthOfArrayLike();
var deletePropertyOrThrow = requireDeletePropertyOrThrow();
var toString = requireToString();
var fails = requireFails();
var internalSort = requireArraySort();
var arrayMethodIsStrict = requireArrayMethodIsStrict();
var FF = requireEnvironmentFfVersion();
var IE_OR_EDGE = requireEnvironmentIsIeOrEdge();
var V8 = requireEnvironmentV8Version();
var WEBKIT = requireEnvironmentWebkitVersion();
var test = [];
var nativeSort = uncurryThis(test.sort);
var push = uncurryThis(test.push);
// IE8-
var FAILS_ON_UNDEFINED = fails(function () {
test.sort(undefined);
});
// V8 bug
var FAILS_ON_NULL = fails(function () {
test.sort(null);
});
// Old WebKit
var STRICT_METHOD = arrayMethodIsStrict('sort');
var STABLE_SORT = !fails(function () {
// feature detection can be too slow, so check engines versions
if (V8) return V8 < 70;
if (FF && FF > 3) return;
if (IE_OR_EDGE) return true;
if (WEBKIT) return WEBKIT < 603;
var result = '';
var code, chr, value, index;
// generate an array with more 512 elements (Chakra and old V8 fails only in this case)
for (code = 65; code < 76; code++) {
chr = String.fromCharCode(code);
switch (code) {
case 66: case 69: case 70: case 72: value = 3; break;
case 68: case 71: value = 4; break;
default: value = 2;
}
for (index = 0; index < 47; index++) {
test.push({ k: chr + index, v: value });
}
}
test.sort(function (a, b) { return b.v - a.v; });
for (index = 0; index < test.length; index++) {
chr = test[index].k.charAt(0);
if (result.charAt(result.length - 1) !== chr) result += chr;
}
return result !== 'DGBEFHACIJK';
});
var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;
var getSortCompare = function (comparefn) {
return function (x, y) {
if (y === undefined) return -1;
if (x === undefined) return 1;
if (comparefn !== undefined) return +comparefn(x, y) || 0;
var xString = toString(x);
var yString = toString(y);
return xString === yString ? 0 : xString > yString ? 1 : -1;
};
};
// `Array.prototype.sort` method
// https://tc39.es/ecma262/#sec-array.prototype.sort
$({ target: 'Array', proto: true, forced: FORCED }, {
sort: function sort(comparefn) {
if (comparefn !== undefined) aCallable(comparefn);
var array = toObject(this);
if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);
var items = [];
var arrayLength = lengthOfArrayLike(array);
var itemsLength, index;
for (index = 0; index < arrayLength; index++) {
if (index in array) push(items, array[index]);
}
internalSort(items, getSortCompare(comparefn));
itemsLength = lengthOfArrayLike(items);
index = 0;
while (index < itemsLength) array[index] = items[index++];
while (index < arrayLength) deletePropertyOrThrow(array, index++);
return array;
}
});
return es_array_sort;
}
requireEs_array_sort();
var es_array_unscopables_flat = {};
var hasRequiredEs_array_unscopables_flat;
function requireEs_array_unscopables_flat () {
if (hasRequiredEs_array_unscopables_flat) return es_array_unscopables_flat;
hasRequiredEs_array_unscopables_flat = 1;
// this method was added to unscopables after implementation
// in popular engines, so it's moved to a separate module
var addToUnscopables = requireAddToUnscopables();
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('flat');
return es_array_unscopables_flat;
}
requireEs_array_unscopables_flat();
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_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 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_string_replace = {};
var functionApply;
var hasRequiredFunctionApply;
function requireFunctionApply () {
if (hasRequiredFunctionApply) return functionApply;
hasRequiredFunctionApply = 1;
var NATIVE_BIND = requireFunctionBindNative();
var FunctionPrototype = Function.prototype;
var apply = FunctionPrototype.apply;
var call = FunctionPrototype.call;
// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
return call.apply(apply, arguments);
});
return functionApply;
}
var 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 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 advanceStringIndex;
var hasRequiredAdvanceStringIndex;
function requireAdvanceStringIndex () {
if (hasRequiredAdvanceStringIndex) return advanceStringIndex;
hasRequiredAdvanceStringIndex = 1;
var charAt = requireStringMultibyte().charAt;
// `AdvanceStringIndex` abstract operation
// https://tc39.es/ecma262/#sec-advancestringindex
advanceStringIndex = function (S, index, unicode) {
return index + (unicode ? charAt(S, index).length || 1 : 1);
};
return advanceStringIndex;
}
var getSubstitution;
var hasRequiredGetSubstitution;
function requireGetSubstitution () {
if (hasRequiredGetSubstitution) return getSubstitution;
hasRequiredGetSubstitution = 1;
var uncurryThis = requireFunctionUncurryThis();
var toObject = requireToObject();
var floor = Math.floor;
var charAt = uncurryThis(''.charAt);
var replace = uncurryThis(''.replace);
var stringSlice = uncurryThis(''.slice);
// eslint-disable-next-line redos/no-vulnerable -- safe
var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
// `GetSubstitution` abstract operation
// https://tc39.es/ecma262/#sec-getsubstitution
getSubstitution = function (matched, str, position, captures, namedCaptures, replacement) {
var tailPos = position + matched.length;
var m = captures.length;
var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
if (namedCaptures !== undefined) {
namedCaptures = toObject(namedCaptures);
symbols = SUBSTITUTION_SYMBOLS;
}
return replace(replacement, symbols, function (match, ch) {
var capture;
switch (charAt(ch, 0)) {
case '$': return '$';
case '&': return matched;
case '`': return stringSlice(str, 0, position);
case "'": return stringSlice(str, tailPos);
case '<':
capture = namedCaptures[stringSlice(ch, 1, -1)];
break;
default: // \d\d?
var n = +ch;
if (n === 0) return match;
if (n > m) {
var f = floor(n / 10);
if (f === 0) return match;
if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);
return match;
}
capture = captures[n - 1];
}
return capture === undefined ? '' : capture;
});
};
return getSubstitution;
}
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 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_replace;
function requireEs_string_replace () {
if (hasRequiredEs_string_replace) return es_string_replace;
hasRequiredEs_string_replace = 1;
var apply = requireFunctionApply();
var call = requireFunctionCall();
var uncurryThis = requireFunctionUncurryThis();
var fixRegExpWellKnownSymbolLogic = requireFixRegexpWellKnownSymbolLogic();
var fails = requireFails();
var anObject = requireAnObject();
var isCallable = requireIsCallable();
var isObject = requireIsObject();
var toIntegerOrInfinity = requireToIntegerOrInfinity();
var toLength = requireToLength();
var toString = requireToString();
var requireObjectCoercible = requireRequireObjectCoercible();
var advanceStringIndex = requireAdvanceStringIndex();
var getMethod = requireGetMethod();
var getSubstitution = requireGetSubstitution();
var getRegExpFlags = requireRegexpGetFlags();
var regExpExec = requireRegexpExecAbstract();
var wellKnownSymbol = requireWellKnownSymbol();
var REPLACE = wellKnownSymbol('replace');
var max = Math.max;
var min = Math.min;
var concat = uncurryThis([].concat);
var push = uncurryThis([].push);
var stringIndexOf = uncurryThis(''.indexOf);
var stringSlice = uncurryThis(''.slice);
var maybeToString = function (it) {
return it === undefined ? it : String(it);
};
// IE <= 11 replaces $0 with the whole match, as if it was $&
// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
var REPLACE_KEEPS_$0 = (function () {
// eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
return 'a'.replace(/./, '$0') === '$0';
})();
// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
if (/./[REPLACE]) {
return /./[REPLACE]('a', '$0') === '';
}
return false;
})();
var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
var re = /./;
re.exec = function () {
var result = [];
result.groups = { a: '7' };
return result;
};
// eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive
return ''.replace(re, '$<a>') !== '7';
});
// @@replace logic
fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
return [
// `String.prototype.replace` method
// https://tc39.es/ecma262/#sec-string.prototype.replace
function replace(searchValue, replaceValue) {
var O = requireObjectCoercible(this);
var replacer = isObject(searchValue) ? getMethod(searchValue, REPLACE) : undefined;
return replacer
? call(replacer, searchValue, O, replaceValue)
: call(nativeReplace, toString(O), searchValue, replaceValue);
},
// `RegExp.prototype[@@replace]` method
// https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
function (string, replaceValue) {
var rx = anObject(this);
var S = toString(string);
var functionalReplace = isCallable(replaceValue);
if (!functionalReplace) replaceValue = toString(replaceValue);
var flags = toString(getRegExpFlags(rx));
if (
typeof replaceValue == 'string' &&
!~stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) &&
!~stringIndexOf(replaceValue, '$<') &&
!~stringIndexOf(flags, 'y')
) {
var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
if (res.done) return res.value;
}
var global = !!~stringIndexOf(flags, 'g');
var fullUnicode;
if (global) {
fullUnicode = !!~stringIndexOf(flags, 'u') || !!~stringIndexOf(flags, 'v');
rx.lastIndex = 0;
}
var results = [];
var result;
while (true) {
result = regExpExec(rx, S);
if (result === null) break;
push(results, result);
if (!global) break;
var matchStr = toString(result[0]);
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
}
var accumulatedResult = '';
var nextSourcePosition = 0;
for (var i = 0; i < results.length; i++) {
result = results[i];
var matched = toString(result[0]);
var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
var captures = [];
var replacement;
// NOTE: This is equivalent to
// captures = result.slice(1).map(maybeToString)
// but for some reason `nativeSlice.call(result, 1, result.length)` (called in
// the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
// causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
var namedCaptures = result.groups;
if (functionalReplace) {
var replacerArgs = concat([matched], captures, position, S);
if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
replacement = toString(apply(replaceValue, undefined, replacerArgs));
} else {
replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
}
if (position >= nextSourcePosition) {
accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
nextSourcePosition = position + matched.length;
}
}
return accumulatedResult + stringSlice(S, nextSourcePosition);
}
];
}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
return es_string_replace;
}
requireEs_string_replace();
var es_array_from = {};
var iteratorClose;
var hasRequiredIteratorClose;
function requireIteratorClose () {
if (hasRequiredIteratorClose) return iteratorClose;
hasRequiredIteratorClose = 1;
var call = requireFunctionCall();
var anObject = requireAnObject();
var getMethod = requireGetMethod();
iteratorClose = function (iterator, kind, value) {
var innerResult, innerError;
anObject(iterator);
try {
innerResult = getMethod(iterator, 'return');
if (!innerResult) {
if (kind === 'throw') throw value;
return value;
}
innerResult = call(innerResult, iterator);
} catch (error) {
innerError = true;
innerResult = error;
}
if (kind === 'throw') throw value;
if (innerError) throw innerResult;
anObject(innerResult);
return value;
};
return iteratorClose;
}
var callWithSafeIterationClosing;
var hasRequiredCallWithSafeIterationClosing;
function requireCallWithSafeIterationClosing () {
if (hasRequiredCallWithSafeIterationClosing) return callWithSafeIterationClosing;
hasRequiredCallWithSafeIterationClosing = 1;
var anObject = requireAnObject();
var iteratorClose = requireIteratorClose();
// call something on iterator step with safe closing on error
callWithSafeIterationClosing = function (iterator, fn, value, ENTRIES) {
try {
return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
} catch (error) {
iteratorClose(iterator, 'throw', error);
}
};
return callWithSafeIterationClosing;
}
var iterators;
var hasRequiredIterators;
function requireIterators () {
if (hasRequiredIterators) return iterators;
hasRequiredIterators = 1;
iterators = Object.create ? Object.create(null) : {};
return iterators;
}
var isArrayIteratorMethod;
var hasRequiredIsArrayIteratorMethod;
function requireIsArrayIteratorMethod () {
if (hasRequiredIsArrayIteratorMethod) return isArrayIteratorMethod;
hasRequiredIsArrayIteratorMethod = 1;
var wellKnownSymbol = requireWellKnownSymbol();
var Iterators = requireIterators();
var ITERATOR = wellKnownSymbol('iterator');
var ArrayPrototype = Array.prototype;
// check on default Array iterator
isArrayIteratorMethod = function (it) {
return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
};
return isArrayIteratorMethod;
}
var 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 arrayFrom;
var hasRequiredArrayFrom;
function requireArrayFrom () {
if (hasRequiredArrayFrom) return arrayFrom;
hasRequiredArrayFrom = 1;
var bind = requireFunctionBindContext();
var call = requireFunctionCall();
var toObject = requireToObject();
var callWithSafeIterationClosing = requireCallWithSafeIterationClosing();
var isArrayIteratorMethod = requireIsArrayIteratorMethod();
var isConstructor = requireIsConstructor();
var lengthOfArrayLike = requireLengthOfArrayLike();
var createProperty = requireCreateProperty();
var setArrayLength = requireArraySetLength();
var getIterator = requireGetIteratorInternal();
var getIteratorMethod = requireGetIteratorMethodInternal();
var iteratorClose = requireIteratorClose();
var doesNotExceedSafeInteger = requireDoesNotExceedSafeInteger();
var $Array = Array;
// `Array.from` method implementation
// https://tc39.es/ecma262/#sec-array.from
arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
var IS_CONSTRUCTOR = isConstructor(this);
var argumentsLength = arguments.length;
var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
var mapping = mapfn !== undefined;
if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
var O = toObject(arrayLike);
var iteratorMethod = getIteratorMethod(O);
var index = 0;
var length, result, step, iterator, next, value;
// if the target is not iterable or it's an array with the default iterator - use a simple case
if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {
result = IS_CONSTRUCTOR ? new this() : [];
iterator = getIterator(O, iteratorMethod);
next = iterator.next;
for (;!(step = call(next, iterator)).done; index++) {
try {
doesNotExceedSafeInteger(index);
} catch (error) {
iteratorClose(iterator, 'throw', error);
}
value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
try {
createProperty(result, index, value);
} catch (error) {
iteratorClose(iterator, 'throw', error);
}
}
} else {
length = lengthOfArrayLike(O);
result = IS_CONSTRUCTOR ? new this(length) : $Array(length);
for (;length > index; index++) {
value = mapping ? mapfn(O[index], index) : O[index];
createProperty(result, index, value);
}
}
setArrayLength(result, index);
return result;
};
return arrayFrom;
}
var checkCorrectnessOfIteration;
var hasRequiredCheckCorrectnessOfIteration;
function requireCheckCorrectnessOfIteration () {
if (hasRequiredCheckCorrectnessOfIteration) return checkCorrectnessOfIteration;
hasRequiredCheckCorrectnessOfIteration = 1;
var wellKnownSymbol = requireWellKnownSymbol();
var ITERATOR = wellKnownSymbol('iterator');
var SAFE_CLOSING = false;
try {
var called = 0;
var iteratorWithReturn = {
next: function () {
return { done: !!called++ };
},
'return': function () {
SAFE_CLOSING = true;
}
};
// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
iteratorWithReturn[ITERATOR] = function () {
return this;
};
// eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
Array.from(iteratorWithReturn, function () { throw 2; });
} catch (error) { /* empty */ }
checkCorrectnessOfIteration = function (exec, SKIP_CLOSING) {
try {
if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
} catch (error) { return false; } // workaround of old WebKit + `eval` bug
var ITERATION_SUPPORT = false;
try {
var object = {};
// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
object[ITERATOR] = function () {
return {
next: function () {
return { done: ITERATION_SUPPORT = true };
}
};
};
exec(object);
} catch (error) { /* empty */ }
return ITERATION_SUPPORT;
};
return checkCorrectnessOfIteration;
}
var hasRequiredEs_array_from;
function requireEs_array_from () {
if (hasRequiredEs_array_from) return es_array_from;
hasRequiredEs_array_from = 1;
var $ = require_export();
var from = requireArrayFrom();
var checkCorrectnessOfIteration = requireCheckCorrectnessOfIteration();
var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
// eslint-disable-next-line es/no-array-from -- required for testing
Array.from(iterable);
});
// `Array.from` method
// https://tc39.es/ecma262/#sec-array.from
$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
from: from
});
return es_array_from;
}
requireEs_array_from();
var es_string_iterator = {};
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 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_trim = {};
var whitespaces;
var hasRequiredWhitespaces;
function requireWhitespaces () {
if (hasRequiredWhitespaces) return whitespaces;
hasRequiredWhitespaces = 1;
// a string of all valid unicode whitespaces
whitespaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
'\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
return whitespaces;
}
var stringTrim;
var hasRequiredStringTrim;
function requireStringTrim () {
if (hasRequiredStringTrim) return stringTrim;
hasRequiredStringTrim = 1;
var uncurryThis = requireFunctionUncurryThis();
var requireObjectCoercible = requireRequireObjectCoercible();
var toString = requireToString();
var whitespaces = requireWhitespaces();
var replace = uncurryThis(''.replace);
var ltrim = RegExp('^[' + whitespaces + ']+');
var rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$');
// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
var createMethod = function (TYPE) {
return function ($this) {
var string = toString(requireObjectCoercible($this));
if (TYPE & 1) string = replace(string, ltrim, '');
if (TYPE & 2) string = replace(string, rtrim, '$1');
return string;
};
};
stringTrim = {
// `String.prototype.{ trimLeft, trimStart }` methods
// https://tc39.es/ecma262/#sec-string.prototype.trimstart
start: createMethod(1),
// `String.prototype.{ trimRight, trimEnd }` methods
// https://tc39.es/ecma262/#sec-string.prototype.trimend
end: createMethod(2),
// `String.prototype.trim` method
// https://tc39.es/ecma262/#sec-string.prototype.trim
trim: createMethod(3)
};
return stringTrim;
}
var stringTrimForced;
var hasRequiredStringTrimForced;
function requireStringTrimForced () {
if (hasRequiredStringTrimForced) return stringTrimForced;
hasRequiredStringTrimForced = 1;
var PROPER_FUNCTION_NAME = requireFunctionName().PROPER;
var fails = requireFails();
var whitespaces = requireWhitespaces();
var non = '\u200B\u0085\u180E';
// check that a method works with the correct list
// of whitespaces and has a correct name
stringTrimForced = function (METHOD_NAME) {
return fails(function () {
return !!whitespaces[METHOD_NAME]()
|| non[METHOD_NAME]() !== non
|| (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME);
});
};
return stringTrimForced;
}
var hasRequiredEs_string_trim;
function requireEs_string_trim () {
if (hasRequiredEs_string_trim) return es_string_trim;
hasRequiredEs_string_trim = 1;
var $ = require_export();
var $trim = requireStringTrim().trim;
var forcedStringTrimMethod = requireStringTrimForced();
// `String.prototype.trim` method
// https://tc39.es/ecma262/#sec-string.prototype.trim
$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {
trim: function trim() {
return $trim(this);
}
});
return es_string_trim;
}
requireEs_string_trim();
var web_domCollections_forEach = {};
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 arrayForEach;
var hasRequiredArrayForEach;
function requireArrayForEach () {
if (hasRequiredArrayForEach) return arrayForEach;
hasRequiredArrayForEach = 1;
var $forEach = requireArrayIteration().forEach;
var arrayMethodIsStrict = requireArrayMethodIsStrict();
var STRICT_METHOD = arrayMethodIsStrict('forEach');
// `Array.prototype.forEach` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.foreach
arrayForEach = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {
return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
// eslint-disable-next-line es/no-array-prototype-foreach -- safe
} : [].forEach;
return arrayForEach;
}
var hasRequiredWeb_domCollections_forEach;
function requireWeb_domCollections_forEach () {
if (hasRequiredWeb_domCollections_forEach) return web_domCollections_forEach;
hasRequiredWeb_domCollections_forEach = 1;
var globalThis = requireGlobalThis();
var DOMIterables = requireDomIterables();
var DOMTokenListPrototype = requireDomTokenListPrototype();
var forEach = requireArrayForEach();
var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
var handlePrototype = function (CollectionPrototype) {
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {
createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);
} catch (error) {
CollectionPrototype.forEach = forEach;
}
};
for (var COLLECTION_NAME in DOMIterables) {
if (DOMIterables[COLLECTION_NAME]) {
handlePrototype(globalThis[COLLECTION_NAME] && globalThis[COLLECTION_NAME].prototype);
}
}
handlePrototype(DOMTokenListPrototype);
return web_domCollections_forEach;
}
requireWeb_domCollections_forEach();
/**
* Bootstrap Table DOM Manipulation Utility Library
* Provides jQuery-style DOM manipulation APIs using native JavaScript
*
* Security Notice:
* - The `create()` method uses innerHTML to parse HTML strings. Always sanitize user input
* before passing it to create() to prevent XSS attacks.
* - The `html()` method sets innerHTML directly. Use the `text()` method for user-provided content.
* - The `attr()` method allows setting arbitrary attributes including event handlers.
* Avoid setting event handler attributes (onclick, onerror, etc.) with user-controlled data.
*/
var DOMHelper = /*#__PURE__*/function () {
function DOMHelper() {
_classCallCheck(this, DOMHelper);
}
return _createClass(DOMHelper, null, [{
key: "$",
value:
/**
* Element selector
* @param {string|Element} selector - CSS selector or DOM element
* @param {Element} context - Search context, defaults to document
* @returns {Element|null} First matched element
*/
function $(selector) {
var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document;
if (typeof selector === 'string') {
return context.querySelector(selector);
}
if (selector instanceof Element) {
return selector;
}
return null;
}
/**
* Element selector (multiple)
* @param {string|Element|NodeList} selector - CSS selector, DOM element, or NodeList
* @param {Element} context - Search context, defaults to document
* @returns {Element[]} Array of all matched elements. Note: if selector is an Element, returns [Element]
*/
}, {
key: "$$",
value: function $$(selector) {
var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document;
if (typeof selector === 'string') {
return Array.from(context.querySelectorAll(selector));
}
if (selector instanceof NodeList) {
return Array.from(selector);
}
if (selector instanceof Element) {
return [selector];
}
return [];
}
/**
* Create DOM element
* @param {string} html - HTML string. Note: This method uses innerHTML and can execute scripts.
* Always sanitize user input before passing it to this method.
* @returns {Element|null} Created DOM element. Returns null if html is empty, not a string,
* or contains only whitespace.
*/
}, {
key: "create",
value: function create(html) {
if (typeof html !== 'string') return null;
var trimmed = html.trim();
if (!trimmed) return null;
var template = document.createElement('template');
template.innerHTML = trimmed;
return template.content.firstChild;
}
/**
* Add CSS class
* @param {Element|string} element - DOM element or selector
* @param {string} className - Class name to add (space-separated for multiple classes)
* @returns {Element|null} The element itself
*/
}, {
key: "addClass",
value: function addClass(element, className) {
var _element$classList;
if (typeof element === 'string') element = this.$(element);
if (!element || !element.classList) return element;
if (!className) return element;
var classes = className.split(' ').filter(function (c) {
return c;
});
(_element$classList = element.classList).add.apply(_element$classList, _toConsumableArray(classes));
return element;
}
/**
* Remove CSS class
* @param {Element|string} element - DOM element or selector
* @param {string} className - Class name to remove (space-separated for multiple classes)
* @returns {Element|null} The element itself
*/
}, {
key: "removeClass",
value: function removeClass(element, className) {
var _element$classList2;
if (typeof element === 'string') element = this.$(element);
if (!element || !element.classList) return element;
if (!className) return element;
var classes = className.split(' ').filter(function (c) {
return c;
});
(_element$classList2 = element.classList).remove.apply(_element$classList2, _toConsumableArray(classes));
return element;
}
/**
* Toggle CSS class
* @param {Element|string} element - DOM element or selector
* @param {string} className - Class name to toggle (space-separated for multiple classes)
* @returns {Element|null} The element itself
*/
}, {
key: "toggleClass",
value: function toggleClass(element, className) {
if (typeof element === 'string') element = this.$(element);
if (!element || !element.classList) return element;
if (!className) return element;
var classes = className.split(' ').filter(function (c) {
return c;
});
classes.forEach(function (cls) {
return element.classList.toggle(cls);
});
return element;
}
/**
* Check if element has CSS class
* @param {Element|string} element - DOM element or selector
* @param {string} className - Class name to check
* @returns {boolean} Whether the class exists
*/
}, {
key: "hasClass",
value: function hasClass(element, className) {
if (typeof element === 'string') element = this.$(element);
if (!element || !element.classList) return false;
if (!className) return false;
return element.classList.contains(className);
}
/**
* Get or set attribute
* @param {Element|string} element - DOM element or selector
* @param {string} name - Attribute name. Warning: Avoid setting event handler attributes
* (onclick, onerror, etc.) with user-controlled data to prevent XSS.
* @param {string} [value] - Attribute value (omit to get)
* @returns {Element|null} Element when setting, or string|null when getting attribute
*/
}, {
key: "attr",
value: function attr(element, name, value) {
if (typeof element === 'string') element = this.$(element);
if (!element) return value === undefined ? null : element;
if (value === undefined) {
return element.getAttribute(name);
}
element.setAttribute(name, value);
return element;
}
/**
* Remove attribute
* @param {Element|string} element - DOM element or selector
* @param {string} name - Attribute name
* @returns {Element|null} The element itself
*/
}, {
key: "removeAttr",
value: function removeAttr(element, name) {
if (typeof element === 'string') element = this.$(element);
if (!element) return element;
element.removeAttribute(name);
return element;
}
/**
* Get or set data attribute
* @param {Element|string} element - DOM element or selector
* @param {string} key - Data key name
* @param {string} [value] - Data value (omit to get)
* @returns {(string|undefined) when getting (value omitted); (Element|null|undefined) when setting (value provided)}
* Returns the data attribute value (string or undefined) when getting, or the element (or null/undefined if not found) when setting.
*/
}, {
key: "data",
value: function data(element, key, value) {
if (typeof element === 'string') element = this.$(element);
if (!element) return value === undefined ? undefined : element;
if (value === undefined) {
return element.dataset[key];
}
element.dataset[key] = value;
return element;
}
/**
* Append child element
* @param {Element|string} parent - Parent element or selector
* @param {Element|string} child - Child element or HTML string
* @returns {Element|null} Parent element
*/
}, {
key: "append",
value: function append(parent, child) {
if (typeof parent === 'string') parent = this.$(parent);
if (typeof child === 'string') child = this.create(child);
if (parent && child) {
parent.appendChild(child);
}
return parent;
}
/**
* Prepend child element
* @param {Element|string} parent - Parent element or selector
* @param {Element|string} child - Child element or HTML string
* @returns {Element|null} Parent element
*/
}, {
key: "prepend",
value: function prepend(parent, child) {
if (typeof parent === 'string') parent = this.$(parent);
if (typeof child === 'string') child = this.create(child);
if (parent && child) {
parent.insertBefore(child, parent.firstChild);
}
return parent;
}
/**
* Insert element after target
* @param {Element|string} newElement - Element to insert
* @param {Element|string} targetElement - Target element
* @returns {Element|null} Inserted element
*/
}, {
key: "insertAfter",
value: function insertAfter(newElement, targetElement) {
if (typeof targetElement === 'string') targetElement = this.$(targetElement);
if (typeof newElement === 'string') newElement = this.create(newElement);
if (targetElement && newElement && targetElement.parentNode) {
targetElement.parentNode.insertBefore(newElement, targetElement.nextSibling);
}
return newElement;
}
/**
* Insert element before target
* @param {Element|string} newElement - Element to insert
* @param {Element|string} targetElement - Target element
* @returns {Element|null} Inserted element
*/
}, {
key: "insertBefore",
value: function insertBefore(newElement, targetElement) {
if (typeof targetElement === 'string') targetElement = this.$(targetElement);
if (typeof newElement === 'string') newElement = this.create(newElement);
if (targetElement && newElement && targetElement.parentNode) {
targetElement.parentNode.insertBefore(newElement, targetElement);
}
return newElement;
}
/**
* Find child elements
* @param {Element|string} element - Parent element or selector
* @param {string} selector - CSS selector
* @returns {Element[]} Array of matched child elements
*/
}, {
key: "find",
value: function find(element, selector) {
if (typeof element === 'string') element = this.$(element);
if (!element) return [];
return Array.from(element.querySelectorAll(selector));
}
/**
* Find first matching child element
* @param {Element|string} element - Parent element or selector
* @param {string} selector - CSS selector
* @returns {Element|null} First matched child element
*/
}, {
key: "findFirst",
value: function findFirst(element, selector) {
if (typeof element === 'string') element = this.$(element);
if (!element) return null;
return element.querySelector(selector);
}
/**
* Get or set style
* @param {Element|string} element - DOM element or selector
* @param {string|Object} property - Property name or property object
* @param {string} [value] - Style value (when property is string)
* @returns {Element|string|null} Element when setting, style value when getting
*/
}, {
key: "css",
value: function css(element, property, value) {
if (typeof element === 'string') element = this.$(element);
if (!element) {
return null;
}
if (_typeof(property) === 'object') {
// Batch set styles
Object.assign(element.style, property);
return element;
}
if (value === undefined) {
// Get style
return getComputedStyle(element)[property];
}
// Set style
element.style[property] = value;
return element;
}
/**
* Get element width
* @param {Element|string} element - DOM element or selector
* @returns {number} Element width
*/
}, {
key: "width",
value: function width(element) {
if (typeof element === 'string') element = this.$(element);
if (!element) return 0;
return element.offsetWidth;
}
/**
* Get element height
* @param {Element|string} element - DOM element or selector
* @returns {number} Element height
*/
}, {
key: "height",
value: function height(element) {
if (typeof element === 'string') element = this.$(element);
if (!element) return 0;
return element.offsetHeight;
}
/**
* Get element outer width (including border, optionally including margin)
* @param {Element|string} element - DOM element or selector
* @param {boolean} [includeMargin=false] - Whether to include margin
* @returns {number} Element outer width
*/
}, {
key: "outerWidth",
value: function outerWidth(element) {
var includeMargin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
if (typeof element === 'string') element = this.$(element);
if (!element) return 0;
var width = element.offsetWidth;
if (includeMargin) {
var style = getComputedStyle(element);
var marginLeft = parseInt(style.marginLeft, 10) || 0;
var marginRight = parseInt(style.marginRight, 10) || 0;
width += marginLeft + marginRight;
}
return width;
}
/**
* Get element outer height (including border, optionally including margin)
* @param {Element|string} element - DOM element or selector
* @param {boolean} [includeMargin=false] - Whether to include margin
* @returns {number} Element outer height
*/
}, {
key: "outerHeight",
value: function outerHeight(element) {
var includeMargin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
if (typeof element === 'string') element = this.$(element);
if (!element) return 0;
var height = element.offsetHeight;
if (includeMargin) {
var style = getComputedStyle(element);
var marginTop = parseInt(style.marginTop, 10) || 0;
var marginBottom = parseInt(style.marginBottom, 10) || 0;
height += marginTop + marginBottom;
}
return height;
}
/**
* Get or set element value
* @param {Element|string} element - DOM element or selector
* @param {string} [value] - Value (omit to get)
* @returns {Element|string|null} Element when setting, current value when getting
*/
}, {
key: "val",
value: function val(element, value) {
if (typeof element === 'string') element = this.$(element);
if (!element) return value === undefined ? null : element;
if (value === undefined) {
return element.value;
}
element.value = value;
return element;
}
/**
* Get or set HTML content
* @param {Element|string} element - DOM element or selector
* @param {string} [content] - HTML content (omit to get). Warning: This method uses innerHTML
* and can execute scripts. Use text() for user-provided content.
* @returns {Element|string|null} Element when setting, HTML content when getting
*/
}, {
key: "html",
value: function html(element, content) {
if (typeof element === 'string') element = this.$(element);
if (!element) return content === undefined ? null : element;
if (content === undefined) {
return element.innerHTML;
}
element.innerHTML = content;
return element;
}
/**
* Get or set text content
* @param {Element|string} element - DOM element or selector
* @param {string} [content] - Text content (omit to get)
* @returns {Element|string|null} Element when setting, text content when getting
*/
}, {
key: "text",
value: function text(element, content) {
if (typeof element === 'string') element = this.$(element);
if (!element) return content === undefined ? null : element;
if (content === undefined) {
return element.textContent;
}
element.textContent = content;
return element;
}
/**
* Remove element
* @param {Element|string} element - DOM element or selector
* @returns {Element|null} Removed element
*/
}, {
key: "remove",
value: function remove(element) {
if (typeof element === 'string') element = this.$(element);
if (!element || !element.parentNode) return element;
element.parentNode.removeChild(element);
return element;
}
/**
* Empty element content
* @param {Element|string} element - DOM element or selector
* @returns {Element|null} Emptied element
*/
}, {
key: "empty",
value: function empty(element) {
if (typeof element === 'string') element = this.$(element);
if (!element) return element;
element.innerHTML = '';
return element;
}
/**
* Iterate over element collection
* @param {Element[]|NodeList|string} elements - Element collection or selector
* @param {Function} callback - Callback function with params (index, element)
* @returns {Element[]} Element collection
*/
}, {
key: "each",
value: function each(elements, callback) {
if (typeof elements === 'string') {
elements = this.$$(elements);
} else if (elements instanceof NodeList) {
elements = Array.from(elements);
} else if (!Array.isArray(elements)) {
elements = [elements];
}
elements.forEach(function (element, index) {
callback.call(element, index, element);
});
return elements;
}
/**
* Get parent element
* @param {Element|string} element - DOM element or selector
* @param {string} [selector] - Parent element selector (optional)
* @returns {Element|null} Parent element
*/
}, {
key: "parent",
value: function parent(element, selector) {
if (typeof element === 'string') element = this.$(element);
if (!element) return null;
var parent = element.parentElement;
if (selector) {
while (parent && !parent.matches(selector)) {
parent = parent.parentElement;
}
}
return parent;
}
/**
* Get child elements
* @param {Element|string} element - DOM element or selector
* @param {string} [selector] - Child element selector (optional)
* @returns {Element[]} Array of child elements
*/
}, {
key: "children",
value: function children(element, selector) {
if (typeof element === 'string') element = this.$(element);
if (!element) return [];
var children = Array.from(element.children);
if (selector) {
children = children.filter(function (child) {
return child.matches(selector);
});
}
return children;
}
/**
* Get next sibling element
* @param {Element|string} element - DOM element or selector
* @param {string} [selector] - Sibling element selector (optional)
* @returns {Element|null} Next sibling element
*/
}, {
key: "next",
value: function next(element, selector) {
if (typeof element === 'string') element = this.$(element);
if (!element) return null;
var next = element.nextElementSibling;
if (selector) {
while (next && !next.matches(selector)) {
next = next.nextElementSibling;
}
}
return next;
}
/**
* Get previous sibling element
* @param {Element|string} element - DOM element or selector
* @param {string} [selector] - Sibling element selector (optional)
* @returns {Element|null} Previous sibling element
*/
}, {
key: "prev",
value: function prev(element, selector) {
if (typeof element === 'string') element = this.$(element);
if (!element) return null;
var prev = element.previousElementSibling;
if (selector) {
while (prev && !prev.matches(selector)) {
prev = prev.previousElementSibling;
}
}
return prev;
}
/**
* Get element position relative to document
* @param {Element|string} element - DOM element or selector
* @returns {Object} Position info {top, left, width, height}
*/
}, {
key: "offset",
value: function offset(element) {
if (typeof element === 'string') element = this.$(element);
if (!element) return {
top: 0,
left: 0,
width: 0,
height: 0
};
var rect = element.getBoundingClientRect();
return {
top: rect.top + window.scrollY,
left: rect.left + window.scrollX,
width: rect.width,
height: rect.height
};
}
/**
* Get element position relative to parent
* @param {Element|string} element - DOM element or selector
* @returns {Object} Position info {top, left}
*/
}, {
key: "position",
value: function position(element) {
if (typeof element === 'string') element = this.$(element);
if (!element) return {
top: 0,
left: 0
};
return {
top: element.offsetTop,
left: element.offsetLeft
};
}
/**
* Check if element matches selector
* @param {Element|string} element - DOM element or selector
* @param {string} selector - CSS selector
* @returns {boolean} Whether it matches
*/
}, {
key: "is",
value: function is(element, selector) {
if (typeof element === 'string') element = this.$(element);
if (!element) return false;
return element.matches(selector);
}
}]);
}(); // Export DOMHelper class
var Utils = $.fn.bootstrapTable.utils;
function printPageBuilderDefault(table, styles) {
return "\n <html>\n <head>\n ".concat(styles, "\n <style type=\"text/css\" media=\"print\">\n @page {\n size: auto;\n margin: 25px 0 25px 0;\n }\n </style>\n <style type=\"text/css\" media=\"all\">\n table {\n border-collapse: collapse;\n font-size: 12px;\n }\n table, th, td {\n border: 1px solid grey;\n }\n th, td {\n text-align: center;\n vertical-align: middle;\n }\n p {\n font-weight: bold;\n margin-left:20px;\n }\n table {\n width: 94%;\n margin-left: 3%;\n margin-right: 3%;\n }\n div.bs-table-print {\n text-align: center;\n }\n table {\n -webkit-print-color-adjust: exact;\n print-color-adjust: exact;\n }\n </style>\n </head>\n <title>Print Table</title>\n <body>\n <p>Printed on: ").concat(new Date(), " </p>\n <div class=\"bs-table-print\">").concat(table, "</div>\n </body>\n </html>\n ");
}
Object.assign($.fn.bootstrapTable.locales, {
formatPrint: function formatPrint() {
return 'Print';
}
});
Object.assign($.fn.bootstrapTable.defaults, $.fn.bootstrapTable.locales);
Object.assign($.fn.bootstrapTable.defaults, {
showPrint: false,
printAsFilteredAndSortedOnUI: true,
printSortColumn: undefined,
printSortOrder: 'asc',
printStyles: [],
printPageBuilder: function printPageBuilder(table, styles) {
return printPageBuilderDefault(table, styles);
}
});
Object.assign($.fn.bootstrapTable.columnDefaults, {
printFilter: undefined,
printIgnore: false,
printFormatter: undefined
});
Utils.assignIcons($.fn.bootstrapTable.icons, 'print', {
glyphicon: 'glyphicon-print icon-share',
fa: 'fa-print',
bi: 'bi-printer',
icon: 'icon-printer',
'material-icons': 'print'
});
$.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() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
_superPropGet(_class, "init", this)(args);
if (!this.options.showPrint) {
return;
}
this.mergedCells = [];
}
}, {
key: "initToolbar",
value: function initToolbar() {
var _this = this;
this.showToolbar = this.showToolbar || this.options.showPrint;
if (this.options.showPrint) {
this.buttons = Object.assign(this.buttons, {
print: {
text: this.options.formatPrint(),
icon: this.options.icons.print,
event: function event() {
_this.doPrint(_this.options.printAsFilteredAndSortedOnUI ? _this.getData() : _this.options.data.slice(0));
},
attributes: {
'aria-label': this.options.formatPrint(),
title: this.options.formatPrint()
}
}
});
}
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
_superPropGet(_class, "initToolbar", this)(args);
}
}, {
key: "mergeCells",
value: function mergeCells(options) {
_superPropGet(_class, "mergeCells", this)([options]);
if (!this.options.showPrint) {
return;
}
var col = this.getVisibleFields().indexOf(options.field);
if (Utils.hasDetailViewIcon(this.options)) {
col += 1;
}
this.mergedCells.push({
row: options.index,
col: col,
rowspan: +options.rowspan || 1,
colspan: +options.colspan || 1
});
}
}, {
key: "doPrint",
value: function doPrint(data) {
var _this2 = this;
var canPrint = function canPrint(column) {
return !column.printIgnore && column.visible;
};
var formatValue = function formatValue(row, i, column) {
var value_ = Utils.getItemField(row, column.field, _this2.options.escape, column.escape);
var value = Utils.calculateObjectValue(column, column.printFormatter || column.formatter, [value_, row, i], value_);
return typeof value === 'undefined' || value === null ? _this2.options.undefinedText : DOMHelper.html(DOMHelper.create('<div></div>'), value).innerHTML;
};
var getCellStyle = function getCellStyle(row, i, column) {
var value_ = Utils.getItemField(row, column.field, _this2.options.escape, column.escape);
var cellStyle = Utils.calculateObjectValue(_this2.header, _this2.header.cellStyles[column.fieldIndex], [value_, row, i, column.field], {});
var attrs = '';
var fieldClass = row["_".concat(column.field, "_class")];
var fieldStyle = row["_".concat(column.field, "_style")];
var classes = [fieldClass, cellStyle.classes].filter(Boolean);
var styles = [fieldStyle, cellStyle.css].filter(Boolean);
if (classes.length) {
attrs += " class=\"".concat(Utils.escapeAttr(Utils.classToString(classes)), "\"");
}
if (styles.length) {
var style = Utils.serializeStyle(styles);
if (style) {
attrs += " style=\"".concat(Utils.escapeAttr(style), "\"");
}
}
return attrs;
};
var buildTable = function buildTable(data, columnsArray) {
var dir = _this2.$el.attr('dir') || 'ltr';
var html = ["<table dir=\"".concat(dir, "\"><thead>")];
var _iterator = _createForOfIteratorHelper(columnsArray),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var _columns2 = _step.value;
html.push('<tr>');
for (var h = 0; h < _columns2.length; h++) {
if (canPrint(_columns2[h])) {
var title = _this2.options.escape && _this2.options.escapeTitle ? Utils.escapeHTML(_columns2[h].title) : _columns2[h].title;
html.push("<th\n ".concat(Utils.sprintf(' rowspan="%s"', _columns2[h].rowspan), "\n ").concat(Utils.sprintf(' colspan="%s"', _columns2[h].colspan), "\n >").concat(title, "</th>"));
}
}
html.push('</tr>');
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
html.push('</thead><tbody>');
var notRender = [];
if (_this2.mergedCells) {
for (var mc = 0; mc < _this2.mergedCells.length; mc++) {
var currentMergedCell = _this2.mergedCells[mc];
for (var rs = 0; rs < currentMergedCell.rowspan; rs++) {
var row = currentMergedCell.row + rs;
for (var cs = 0; cs < currentMergedCell.colspan; cs++) {
var col = currentMergedCell.col + cs;
notRender.push("".concat(row, ",").concat(col));
}
}
}
}
for (var i = 0; i < data.length; i++) {
var rowStyle = Utils.calculateObjectValue(_this2.options, _this2.options.rowStyle, [data[i], i], {});
var rowStyleAttr = '';
if (rowStyle.classes) {
rowStyleAttr += " class=\"".concat(Utils.escapeAttr(Utils.classToString(rowStyle.classes)), "\"");
}
if (rowStyle.css) {
var style = Utils.serializeStyle(rowStyle.css);
if (style) {
rowStyleAttr += " style=\"".concat(Utils.escapeAttr(style), "\"");
}
}
if (!rowStyle.classes && data[i]._class) {
rowStyleAttr += " class=\"".concat(Utils.escapeAttr(data[i]._class), "\"");
}
if (!rowStyle.css && data[i]._style) {
rowStyleAttr += " style=\"".concat(Utils.escapeAttr(data[i]._style), "\"");
}
html.push("<tr".concat(rowStyleAttr, ">"));
var columns = columnsArray.flat(1);
columns.sort(function (c1, c2) {
return c1.colspanIndex - c2.colspanIndex;
});
for (var j = 0; j < columns.length; j++) {
if (columns[j].colspanGroup > 0) continue;
var rowspan = 0;
var colspan = 0;
if (_this2.mergedCells) {
for (var _mc = 0; _mc < _this2.mergedCells.length; _mc++) {
var _currentMergedCell = _this2.mergedCells[_mc];
if (_currentMergedCell.col === j && _currentMergedCell.row === i) {
rowspan = _currentMergedCell.rowspan;
colspan = _currentMergedCell.colspan;
}
}
}
if (canPrint(columns[j]) && (!notRender.includes("".concat(i, ",").concat(j)) || rowspan > 0 && colspan > 0)) {
if (rowspan > 0 && colspan > 0) {
html.push("<td".concat(getCellStyle(data[i], i, columns[j]), " ").concat(Utils.sprintf(' rowspan="%s"', rowspan), " ").concat(Utils.sprintf(' colspan="%s"', colspan), ">"), formatValue(data[i], i, columns[j]), '</td>');
} else {
html.push("<td".concat(getCellStyle(data[i], i, columns[j]), ">"), formatValue(data[i], i, columns[j]), '</td>');
}
}
}
html.push('</tr>');
}
html.push('</tbody>');
if (_this2.options.showFooter) {
html.push('<tfoot><tr>');
var _columns = columnsArray.flat(1).filter(function (column) {
return !(column.colspanGroup > 0);
});
_columns.sort(function (c1, c2) {
return c1.colspanIndex - c2.colspanIndex;
});
var footerData = Utils.trToData(_columns, _this2.$el.find('>tfoot>tr').get());
var _iterator2 = _createForOfIteratorHelper(_columns),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var column = _step2.value;
if (canPrint(column)) {
var footerValue = Utils.calculateObjectValue(column, column.footerFormatter, [data], footerData[0] && footerData[0][column.field] || '');
html.push("<th>".concat(footerValue, "</th>"));
}
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
html.push('</tr></tfoot>');
}
html.push('</table>');
return html.join('');
};
var sortRows = function sortRows(data, colName, sortOrder) {
if (!colName) {
return data;
}
var reverse = sortOrder !== 'asc';
reverse = -(+reverse || -1);
return data.sort(function (a, b) {
return reverse * a[colName].localeCompare(b[colName]);
});
};
var filterRow = function filterRow(row, filters) {
for (var index = 0; index < filters.length; ++index) {
if (row[filters[index].colName] !== filters[index].value) {
return false;
}
}
return true;
};
var filterRows = function filterRows(data, filters) {
return data.filter(function (row) {
return filterRow(row, filters);
});
};
var getColumnFilters = function getColumnFilters(columns) {
return !columns || !columns[0] ? [] : columns[0].filter(function (col) {
return col.printFilter;
}).map(function (col) {
return {
colName: col.field,
value: col.printFilter
};
});
};
data = filterRows(data, getColumnFilters(this.options.columns));
data = sortRows(data, this.options.printSortColumn, this.options.printSortOrder);
var table = buildTable(data, this.options.columns);
var newWin = window.open('');
if (!newWin) {
return;
}
var printStyles = typeof this.options.printStyles === 'string' ? this.options.printStyles.replace(/\[|\]| /g, '').toLowerCase().split(',') : this.options.printStyles;
var startPrint = function startPrint() {
newWin.focus();
newWin.addEventListener('afterprint', function () {
newWin.close();
}, {
once: true
});
newWin.print();
};
var styles = printStyles.length ? printStyles.map(function (s) {
return "<link rel=\"stylesheet\" href=\"".concat(s, "\" />");
}).join('') : '';
var calculatedPrintPage = Utils.calculateObjectValue(this, this.options.printPageBuilder, [table, styles], printPageBuilderDefault(table, styles));
newWin.document.write(calculatedPrintPage);
newWin.document.close();
var links = DOMHelper.$$('link[rel="stylesheet"]', newWin.document.documentElement);
if (!links.length) {
startPrint();
} else {
var loadedCount = 0;
var totalStyles = links.length;
var checkDone = function checkDone() {
loadedCount++;
if (loadedCount === totalStyles) {
startPrint();
}
};
var _iterator3 = _createForOfIteratorHelper(links),
_step3;
try {
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
var link = _step3.value;
if (link.sheet) {
checkDone();
} else {
link.addEventListener('load', checkDone);
link.addEventListener('error', checkDone);
}
}
} catch (err) {
_iterator3.e(err);
} finally {
_iterator3.f();
}
}
}
}]);
}($.BootstrapTable);
}));