cross-spawn-cb 1.5.2 → 1.5.3

package/assets/cross-spawn-6.0.5.js

@@ -1,8 +1,10 @@
 'use strict';
 
-var require$$0$1 = require('path');
-var require$$0$2 = require('child_process');
-var require$$0 = require('fs');
+require('buffer-v6-polyfill');
+var require$$0 = require('path');
+var require$$5 = require('child_process');
+var require$$6 = require('function-exec-sync');
+var require$$0$1 = require('fs');
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 function getDefaultExportFromCjs(x) {
@@ -13,6 +15,2122 @@ var src$1 = {
     exports: {}
 };
 
+var polyfills = {};
+
+var es_object_assign = {};
+
+function _type_of$6(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var globalThis_1;
+var hasRequiredGlobalThis;
+function requireGlobalThis() {
+    if (hasRequiredGlobalThis) return globalThis_1;
+    hasRequiredGlobalThis = 1;
+    var check = function check(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 === "undefined" ? "undefined" : _type_of$6(globalThis)) == 'object' && globalThis) || check((typeof window === "undefined" ? "undefined" : _type_of$6(window)) == 'object' && window) || // eslint-disable-next-line no-restricted-globals -- safe
+    check((typeof self === "undefined" ? "undefined" : _type_of$6(self)) == 'object' && self) || check(_type_of$6(commonjsGlobal) == 'object' && commonjsGlobal) || check((typeof globalThis_1 === "undefined" ? "undefined" : _type_of$6(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 fails(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 get() {
+                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() {}).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;
+    functionCall = NATIVE_BIND ? call.bind(call) : function functionCall() {
+        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 createPropertyDescriptor(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;
+    var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
+    functionUncurryThis = NATIVE_BIND ? uncurryThisWithBind : function functionUncurryThis(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 classofRaw(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 indexedObject(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 isNullOrUndefined(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 requireObjectCoercible(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 toIndexedObject(it) {
+        return IndexedObject(requireObjectCoercible(it));
+    };
+    return toIndexedObject;
+}
+
+function _type_of$5(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var isCallable;
+var hasRequiredIsCallable;
+function requireIsCallable() {
+    if (hasRequiredIsCallable) return isCallable;
+    hasRequiredIsCallable = 1;
+    // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+    var documentAll = (typeof document === "undefined" ? "undefined" : _type_of$5(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 isCallable(argument) {
+        return typeof argument == 'function' || argument === documentAll;
+    } : function(argument) {
+        return typeof argument == 'function';
+    };
+    return isCallable;
+}
+
+function _type_of$4(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var isObject;
+var hasRequiredIsObject;
+function requireIsObject() {
+    if (hasRequiredIsObject) return isObject;
+    hasRequiredIsObject = 1;
+    var isCallable = requireIsCallable();
+    isObject = function isObject(it) {
+        return (typeof it === "undefined" ? "undefined" : _type_of$4(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 aFunction(argument) {
+        return isCallable(argument) ? argument : undefined;
+    };
+    getBuiltIn = function getBuiltIn(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;
+}
+
+function _instanceof$1(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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) || !_instanceof$1(Object(symbol), Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+        !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+    });
+    return symbolConstructorDetection;
+}
+
+function _type_of$3(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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 && _type_of$3(Symbol.iterator) == 'symbol';
+    return useSymbolAsUid;
+}
+
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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 isSymbol(it) {
+        return (typeof it === "undefined" ? "undefined" : _type_of$2(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 tryToString(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 aCallable(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 getMethod(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 ordinaryToPrimitive(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 defineGlobalProperty(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.39.0',
+        mode: IS_PURE ? 'pure' : 'global',
+        copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
+        license: 'https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE',
+        source: 'https://github.com/zloirock/core-js'
+    });
+    return sharedStore.exports;
+}
+
+var shared;
+var hasRequiredShared;
+function requireShared() {
+    if (hasRequiredShared) return shared;
+    hasRequiredShared = 1;
+    var store = requireSharedStore();
+    shared = function shared(key, value) {
+        return store[key] || (store[key] = value || {});
+    };
+    return shared;
+}
+
+var toObject;
+var hasRequiredToObject;
+function requireToObject() {
+    if (hasRequiredToObject) return toObject;
+    hasRequiredToObject = 1;
+    var requireObjectCoercible = requireRequireObjectCoercible();
+    var $Object = Object;
+    // `ToObject` abstract operation
+    // https://tc39.es/ecma262/#sec-toobject
+    toObject = function toObject(argument) {
+        return $Object(requireObjectCoercible(argument));
+    };
+    return toObject;
+}
+
+var hasOwnProperty_1;
+var hasRequiredHasOwnProperty;
+function requireHasOwnProperty() {
+    if (hasRequiredHasOwnProperty) return hasOwnProperty_1;
+    hasRequiredHasOwnProperty = 1;
+    var uncurryThis = requireFunctionUncurryThis();
+    var toObject = requireToObject();
+    var hasOwnProperty = uncurryThis({}.hasOwnProperty);
+    // `HasOwnProperty` abstract operation
+    // https://tc39.es/ecma262/#sec-hasownproperty
+    // eslint-disable-next-line es/no-object-hasown -- safe
+    hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
+        return hasOwnProperty(toObject(it), key);
+    };
+    return hasOwnProperty_1;
+}
+
+var uid;
+var hasRequiredUid;
+function requireUid() {
+    if (hasRequiredUid) return uid;
+    hasRequiredUid = 1;
+    var uncurryThis = requireFunctionUncurryThis();
+    var id = 0;
+    var postfix = Math.random();
+    var toString = uncurryThis(1.0.toString);
+    uid = function uid(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 wellKnownSymbol(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 toPrimitive(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 toPropertyKey(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 documentCreateElement(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 get() {
+                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) {}
+        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() {}, '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 anObject(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) {}
+        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 createNonEnumerableProperty(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() {}).name === 'something';
+    var CONFIGURABLE = EXISTS && (!DESCRIPTORS || DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable);
+    functionName = {
+        EXISTS: EXISTS,
+        PROPER: PROPER,
+        CONFIGURABLE: CONFIGURABLE
+    };
+    return functionName;
+}
+
+var inspectSource;
+var hasRequiredInspectSource;
+function requireInspectSource() {
+    if (hasRequiredInspectSource) return inspectSource;
+    hasRequiredInspectSource = 1;
+    var uncurryThis = requireFunctionUncurryThis();
+    var isCallable = requireIsCallable();
+    var store = requireSharedStore();
+    var functionToString = uncurryThis(Function.toString);
+    // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+    if (!isCallable(store.inspectSource)) {
+        store.inspectSource = function(it) {
+            return functionToString(it);
+        };
+    }
+    inspectSource = store.inspectSource;
+    return inspectSource;
+}
+
+var weakMapBasicDetection;
+var hasRequiredWeakMapBasicDetection;
+function requireWeakMapBasicDetection() {
+    if (hasRequiredWeakMapBasicDetection) return weakMapBasicDetection;
+    hasRequiredWeakMapBasicDetection = 1;
+    var globalThis = requireGlobalThis();
+    var isCallable = requireIsCallable();
+    var WeakMap = globalThis.WeakMap;
+    weakMapBasicDetection = isCallable(WeakMap) && /native code/.test(String(WeakMap));
+    return weakMapBasicDetection;
+}
+
+var sharedKey;
+var hasRequiredSharedKey;
+function requireSharedKey() {
+    if (hasRequiredSharedKey) return sharedKey;
+    hasRequiredSharedKey = 1;
+    var shared = requireShared();
+    var uid = requireUid();
+    var keys = shared('keys');
+    sharedKey = function sharedKey(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 enforce(it) {
+        return has(it) ? get(it) : set(it, {});
+    };
+    var getterFor = function getterFor(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 set(it, metadata) {
+            if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+            metadata.facade = it;
+            store.set(it, metadata);
+            return metadata;
+        };
+        get = function get(it) {
+            return store.get(it) || {};
+        };
+        has = function has(it) {
+            return store.has(it);
+        };
+    } else {
+        var STATE = sharedKey('state');
+        hiddenKeys[STATE] = true;
+        set = function set(it, metadata) {
+            if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+            metadata.facade = it;
+            createNonEnumerableProperty(it, STATE, metadata);
+            return metadata;
+        };
+        get = function get(it) {
+            return hasOwn(it, STATE) ? it[STATE] : {};
+        };
+        has = function has(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() {}, 'length', {
+            value: 8
+        }).length !== 8;
+    });
+    var TEMPLATE = String(String).split('String');
+    var makeBuiltIn$1 = makeBuiltIn.exports = function makeBuiltIn(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) {}
+        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 defineBuiltIn(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) {}
+            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 toIntegerOrInfinity(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 toAbsoluteIndex(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 toLength(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 lengthOfArrayLike(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 createMethod(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 objectKeysInternal(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 copyConstructorProperties(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 isForced(feature, detection) {
+        var value = data[normalize(feature)];
+        return value === POLYFILL ? true : value === NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
+    };
+    var normalize = isForced.normalize = function normalize(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;
+}
+
+function _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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 _export(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 === "undefined" ? "undefined" : _type_of$1(sourceProperty)) == (typeof targetProperty === "undefined" ? "undefined" : _type_of$1(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 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 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 get() {
+                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;
+        alphabet.split('').forEach(function(chr) {
+            B[chr] = chr;
+        });
+        return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;
+    }) ? function assign(target, source) {
+        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;
+}
+
+var path;
+var hasRequiredPath;
+function requirePath() {
+    if (hasRequiredPath) return path;
+    hasRequiredPath = 1;
+    var globalThis = requireGlobalThis();
+    path = globalThis;
+    return path;
+}
+
+var assign$2;
+var hasRequiredAssign$2;
+function requireAssign$2() {
+    if (hasRequiredAssign$2) return assign$2;
+    hasRequiredAssign$2 = 1;
+    requireEs_object_assign();
+    var path = requirePath();
+    assign$2 = path.Object.assign;
+    return assign$2;
+}
+
+var assign$1;
+var hasRequiredAssign$1;
+function requireAssign$1() {
+    if (hasRequiredAssign$1) return assign$1;
+    hasRequiredAssign$1 = 1;
+    var parent = requireAssign$2();
+    assign$1 = parent;
+    return assign$1;
+}
+
+var assign;
+var hasRequiredAssign;
+function requireAssign() {
+    if (hasRequiredAssign) return assign;
+    hasRequiredAssign = 1;
+    var parent = requireAssign$1();
+    assign = parent;
+    return assign;
+}
+
+var es_object_keys = {};
+
+var hasRequiredEs_object_keys;
+function requireEs_object_keys() {
+    if (hasRequiredEs_object_keys) return es_object_keys;
+    hasRequiredEs_object_keys = 1;
+    var $ = require_export();
+    var toObject = requireToObject();
+    var nativeKeys = requireObjectKeys();
+    var fails = requireFails();
+    var FAILS_ON_PRIMITIVES = fails(function() {
+        nativeKeys(1);
+    });
+    // `Object.keys` method
+    // https://tc39.es/ecma262/#sec-object.keys
+    $({
+        target: 'Object',
+        stat: true,
+        forced: FAILS_ON_PRIMITIVES
+    }, {
+        keys: function keys(it) {
+            return nativeKeys(toObject(it));
+        }
+    });
+    return es_object_keys;
+}
+
+var keys$2;
+var hasRequiredKeys$2;
+function requireKeys$2() {
+    if (hasRequiredKeys$2) return keys$2;
+    hasRequiredKeys$2 = 1;
+    requireEs_object_keys();
+    var path = requirePath();
+    keys$2 = path.Object.keys;
+    return keys$2;
+}
+
+var keys$1;
+var hasRequiredKeys$1;
+function requireKeys$1() {
+    if (hasRequiredKeys$1) return keys$1;
+    hasRequiredKeys$1 = 1;
+    var parent = requireKeys$2();
+    keys$1 = parent;
+    return keys$1;
+}
+
+var keys;
+var hasRequiredKeys;
+function requireKeys() {
+    if (hasRequiredKeys) return keys;
+    hasRequiredKeys = 1;
+    var parent = requireKeys$1();
+    keys = parent;
+    return keys;
+}
+
+var es_array_find = {};
+
+var functionUncurryThisClause;
+var hasRequiredFunctionUncurryThisClause;
+function requireFunctionUncurryThisClause() {
+    if (hasRequiredFunctionUncurryThisClause) return functionUncurryThisClause;
+    hasRequiredFunctionUncurryThisClause = 1;
+    var classofRaw = requireClassofRaw();
+    var uncurryThis = requireFunctionUncurryThis();
+    functionUncurryThisClause = function functionUncurryThisClause(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 functionBindContext(fn, that) {
+        aCallable(fn);
+        return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function() {
+            return fn.apply(that, arguments);
+        };
+    };
+    return functionBindContext;
+}
+
+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 toStringTagSupport;
+var hasRequiredToStringTagSupport;
+function requireToStringTagSupport() {
+    if (hasRequiredToStringTagSupport) return toStringTagSupport;
+    hasRequiredToStringTagSupport = 1;
+    var wellKnownSymbol = requireWellKnownSymbol();
+    var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+    var test = {};
+    test[TO_STRING_TAG] = 'z';
+    toStringTagSupport = String(test) === '[object z]';
+    return toStringTagSupport;
+}
+
+var classof;
+var hasRequiredClassof;
+function requireClassof() {
+    if (hasRequiredClassof) return classof;
+    hasRequiredClassof = 1;
+    var TO_STRING_TAG_SUPPORT = requireToStringTagSupport();
+    var isCallable = requireIsCallable();
+    var classofRaw = requireClassofRaw();
+    var wellKnownSymbol = requireWellKnownSymbol();
+    var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+    var $Object = Object;
+    // ES3 wrong here
+    var CORRECT_ARGUMENTS = classofRaw(function() {
+        return arguments;
+    }()) === 'Arguments';
+    // fallback for IE11 Script Access Denied error
+    var tryGet = function tryGet(it, key) {
+        try {
+            return it[key];
+        } catch (error) {}
+    };
+    // getting tag from ES6+ `Object.prototype.toString`
+    classof = TO_STRING_TAG_SUPPORT ? classofRaw : function classof(it) {
+        var O, tag, result;
+        return it === undefined ? 'Undefined' : it === null ? 'Null' : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (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 noop() {};
+    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 arraySpeciesConstructor(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 arraySpeciesCreate(originalArray, length) {
+        return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
+    };
+    return arraySpeciesCreate;
+}
+
+var arrayIteration;
+var hasRequiredArrayIteration;
+function requireArrayIteration() {
+    if (hasRequiredArrayIteration) return arrayIteration;
+    hasRequiredArrayIteration = 1;
+    var bind = requireFunctionBindContext();
+    var uncurryThis = requireFunctionUncurryThis();
+    var IndexedObject = requireIndexedObject();
+    var toObject = requireToObject();
+    var lengthOfArrayLike = requireLengthOfArrayLike();
+    var arraySpeciesCreate = requireArraySpeciesCreate();
+    var push = uncurryThis([].push);
+    // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
+    var createMethod = function createMethod(TYPE) {
+        var IS_MAP = TYPE === 1;
+        var IS_FILTER = TYPE === 2;
+        var IS_SOME = TYPE === 3;
+        var IS_EVERY = TYPE === 4;
+        var IS_FIND_INDEX = TYPE === 6;
+        var IS_FILTER_REJECT = TYPE === 7;
+        var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;
+        return function($this, callbackfn, that, specificCreate) {
+            var O = toObject($this);
+            var self = IndexedObject(O);
+            var length = lengthOfArrayLike(self);
+            var boundFunction = bind(callbackfn, that);
+            var index = 0;
+            var create = specificCreate || arraySpeciesCreate;
+            var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
+            var value, result;
+            for(; length > index; index++)if (NO_HOLES || index in self) {
+                value = self[index];
+                result = boundFunction(value, index, O);
+                if (TYPE) {
+                    if (IS_MAP) target[index] = result; // map
+                    else if (result) switch(TYPE){
+                        case 3:
+                            return true; // some
+                        case 5:
+                            return value; // find
+                        case 6:
+                            return index; // findIndex
+                        case 2:
+                            push(target, value); // filter
+                    }
+                    else switch(TYPE){
+                        case 4:
+                            return false; // every
+                        case 7:
+                            push(target, 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 objectDefineProperties = {};
+
+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 EmptyConstructor() {};
+    var scriptTag = function scriptTag(content) {
+        return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+    };
+    // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+    var NullProtoObjectViaActiveX = function NullProtoObjectViaActiveX(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 NullProtoObjectViaIFrame() {
+        // 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 NullProtoObject1() {
+        try {
+            activeXDocument = new ActiveXObject('htmlfile');
+        } catch (error) {}
+        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 addToUnscopables(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;
+}
+
+var entryUnbind;
+var hasRequiredEntryUnbind;
+function requireEntryUnbind() {
+    if (hasRequiredEntryUnbind) return entryUnbind;
+    hasRequiredEntryUnbind = 1;
+    var globalThis = requireGlobalThis();
+    var uncurryThis = requireFunctionUncurryThis();
+    entryUnbind = function entryUnbind(CONSTRUCTOR, METHOD) {
+        return uncurryThis(globalThis[CONSTRUCTOR].prototype[METHOD]);
+    };
+    return entryUnbind;
+}
+
+var find$2;
+var hasRequiredFind$2;
+function requireFind$2() {
+    if (hasRequiredFind$2) return find$2;
+    hasRequiredFind$2 = 1;
+    requireEs_array_find();
+    var entryUnbind = requireEntryUnbind();
+    find$2 = entryUnbind('Array', 'find');
+    return find$2;
+}
+
+var find$1;
+var hasRequiredFind$1;
+function requireFind$1() {
+    if (hasRequiredFind$1) return find$1;
+    hasRequiredFind$1 = 1;
+    var parent = requireFind$2();
+    find$1 = parent;
+    return find$1;
+}
+
+var find;
+var hasRequiredFind;
+function requireFind() {
+    if (hasRequiredFind) return find;
+    hasRequiredFind = 1;
+    var parent = requireFind$1();
+    find = parent;
+    return find;
+}
+
+var hasRequiredPolyfills;
+function requirePolyfills() {
+    if (hasRequiredPolyfills) return polyfills;
+    hasRequiredPolyfills = 1;
+    requireAssign();
+    requireKeys();
+    requireFind();
+    var path = require$$0;
+    if (!path.delimiter) {
+        var isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);
+        path.delimiter = isWindows ? ';' : ':';
+    }
+    // early node is missing spawnSync
+    var cp = require$$5;
+    if (!cp.spawnSync) {
+        var path1 = require$$0;
+        var spawnCallback = path1.join(__dirname, '..', 'dist', 'cjs', 'spawnCallback.js');
+        var functionExec = null; // break dependencies
+        cp.spawnSync = function spawnSyncPolyfill(cmd, args, options) {
+            if (!functionExec) functionExec = require$$6;
+            return functionExec({
+                callbacks: true
+            }, spawnCallback, cmd, args, options || {});
+        };
+    }
+    return polyfills;
+}
+
 var crossSpawn6_0_5 = {
     exports: {}
 };
@@ -41,7 +2159,7 @@ function requireWindows() {
     hasRequiredWindows = 1;
     windows = isexe;
     isexe.sync = sync;
-    var fs = require$$0;
+    var fs = require$$0$1;
     function checkPathExt(path, options) {
         var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
         if (!pathext) {
@@ -83,7 +2201,7 @@ function requireMode() {
     hasRequiredMode = 1;
     mode = isexe;
     isexe.sync = sync;
-    var fs = require$$0;
+    var fs = require$$0$1;
     function isexe(path, options, cb) {
         fs.stat(path, function(er, stat) {
             cb(er, er ? false : checkStat(stat, options));
@@ -177,7 +2295,7 @@ function requireWhich() {
     which_1 = which;
     which.sync = whichSync;
     var isWindows = process.platform === 'win32' || process.env.OSTYPE === 'cygwin' || process.env.OSTYPE === 'msys';
-    var path = require$$0$1;
+    var path = require$$0;
     var COLON = isWindows ? ';' : ':';
     var isexe = requireIsexe();
     function getNotFoundError(cmd) {
@@ -307,7 +2425,7 @@ var hasRequiredResolveCommand;
 function requireResolveCommand() {
     if (hasRequiredResolveCommand) return resolveCommand_1;
     hasRequiredResolveCommand = 1;
-    var path = require$$0$1;
+    var path = require$$0;
     var which = requireWhich();
     var pathKey = requirePathKey()();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -418,7 +2536,7 @@ var hasRequiredReadShebang;
 function requireReadShebang() {
     if (hasRequiredReadShebang) return readShebang_1;
     hasRequiredReadShebang = 1;
-    var fs = require$$0;
+    var fs = require$$0$1;
     var shebangCommand = requireShebangCommand();
     function readShebang(command) {
         // Read the first 150 bytes from the file
@@ -1711,7 +3829,7 @@ var hasRequiredParse;
 function requireParse() {
     if (hasRequiredParse) return parse_1;
     hasRequiredParse = 1;
-    var path = require$$0$1;
+    var path = require$$0;
     var niceTry = requireSrc$1();
     var resolveCommand = requireResolveCommand();
     var escape = require_escape();
@@ -1813,7 +3931,7 @@ function requireParse() {
             args = null;
         }
         args = args ? args.slice(0) : []; // Clone array to avoid changing the original
-        options = Object.assign({}, options); // Clone object to avoid changing the original
+        options = require('core-js/actual/object/assign')({}, options); // Clone object to avoid changing the original
         // Build our parsed object
         var parsed = {
             command: command,
@@ -1890,7 +4008,7 @@ var hasRequiredCrossSpawn6_0_5;
 function requireCrossSpawn6_0_5() {
     if (hasRequiredCrossSpawn6_0_5) return crossSpawn6_0_5.exports;
     hasRequiredCrossSpawn6_0_5 = 1;
-    var cp = require$$0$2;
+    var cp = require$$5;
     var parse = requireParse();
     var enoent = requireEnoent();
     function spawn(command, args, options) {
@@ -1924,8 +4042,9 @@ var hasRequiredSrc;
 function requireSrc() {
     if (hasRequiredSrc) return src$1.exports;
     hasRequiredSrc = 1;
-    var path = require$$0$1;
-    var cp = require$$0$2;
+    requirePolyfills();
+    var path = require$$0;
+    var cp = require$$5;
     var spawn_ = requireCrossSpawn6_0_5();
     var NODES = [
         'node',