jodit 4.2.25 → 4.2.32

package/es5/164.js

@@ -0,0 +1,4939 @@
+"use strict";
+(self["webpackChunkjodit"] = self["webpackChunkjodit"] || []).push([[164],{
+
+/***/ 92687:
+/***/ (function() {
+
+
+/*
+ * classList.js: Cross-browser full element.classList implementation.
+ * 1.1.20170427
+ *
+ * By Eli Grey, http://eligrey.com
+ * License: Dedicated to the public domain.
+ *   See https://github.com/eligrey/classList.js/blob/master/LICENSE.md
+ */
+/*global self, document, DOMException */
+/*! @source http://purl.eligrey.com/github/classList.js/blob/master/classList.js */
+if ("document" in window.self) {
+    // Full polyfill for browsers with no classList support
+    // Including IE < Edge missing SVGElement.classList
+    if (!("classList" in document.createElement("_"))
+        || document.createElementNS && !("classList" in document.createElementNS("http://www.w3.org/2000/svg", "g"))) {
+        (function (view) {
+            "use strict";
+            if (!('Element' in view))
+                return;
+            var classListProp = "classList", protoProp = "prototype", elemCtrProto = view.Element[protoProp], objCtr = Object, strTrim = String[protoProp].trim || function () {
+                return this.replace(/^\s+|\s+$/g, "");
+            }, arrIndexOf = Array[protoProp].indexOf || function (item) {
+                var i = 0, len = this.length;
+                for (; i < len; i++) {
+                    if (i in this && this[i] === item) {
+                        return i;
+                    }
+                }
+                return -1;
+            }
+            // Vendors: please allow content code to instantiate DOMExceptions
+            , DOMEx = function (type, message) {
+                this.name = type;
+                this.code = DOMException[type];
+                this.message = message;
+            }, checkTokenAndGetIndex = function (classList, token) {
+                if (token === "") {
+                    throw new DOMEx("SYNTAX_ERR", "An invalid or illegal string was specified");
+                }
+                if (/\s/.test(token)) {
+                    throw new DOMEx("INVALID_CHARACTER_ERR", "String contains an invalid character");
+                }
+                return arrIndexOf.call(classList, token);
+            }, ClassList = function (elem) {
+                var trimmedClasses = strTrim.call(elem.getAttribute("class") || ""), classes = trimmedClasses ? trimmedClasses.split(/\s+/) : [], i = 0, len = classes.length;
+                for (; i < len; i++) {
+                    this.push(classes[i]);
+                }
+                this._updateClassName = function () {
+                    elem.setAttribute("class", this.toString());
+                };
+            }, classListProto = ClassList[protoProp] = [], classListGetter = function () {
+                return new ClassList(this);
+            };
+            // Most DOMException implementations don't allow calling DOMException's toString()
+            // on non-DOMExceptions. Error's toString() is sufficient here.
+            DOMEx[protoProp] = Error[protoProp];
+            classListProto.item = function (i) {
+                return this[i] || null;
+            };
+            classListProto.contains = function (token) {
+                token += "";
+                return checkTokenAndGetIndex(this, token) !== -1;
+            };
+            classListProto.add = function () {
+                var tokens = arguments, i = 0, l = tokens.length, token, updated = false;
+                do {
+                    token = tokens[i] + "";
+                    if (checkTokenAndGetIndex(this, token) === -1) {
+                        this.push(token);
+                        updated = true;
+                    }
+                } while (++i < l);
+                if (updated) {
+                    this._updateClassName();
+                }
+            };
+            classListProto.remove = function () {
+                var tokens = arguments, i = 0, l = tokens.length, token, updated = false, index;
+                do {
+                    token = tokens[i] + "";
+                    index = checkTokenAndGetIndex(this, token);
+                    while (index !== -1) {
+                        this.splice(index, 1);
+                        updated = true;
+                        index = checkTokenAndGetIndex(this, token);
+                    }
+                } while (++i < l);
+                if (updated) {
+                    this._updateClassName();
+                }
+            };
+            classListProto.toggle = function (token, force) {
+                token += "";
+                var result = this.contains(token), method = result ?
+                    force !== true && "remove"
+                    :
+                        force !== false && "add";
+                if (method) {
+                    this[method](token);
+                }
+                if (force === true || force === false) {
+                    return force;
+                }
+                else {
+                    return !result;
+                }
+            };
+            classListProto.toString = function () {
+                return this.join(" ");
+            };
+            if (objCtr.defineProperty) {
+                var classListPropDesc = {
+                    get: classListGetter,
+                    enumerable: true,
+                    configurable: true
+                };
+                try {
+                    objCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc);
+                }
+                catch (ex) { // IE 8 doesn't support enumerable:true
+                    // adding undefined to fight this issue https://github.com/eligrey/classList.js/issues/36
+                    // modernie IE8-MSW7 machine has IE8 8.0.6001.18702 and is affected
+                    if (ex.number === undefined || ex.number === -0x7FF5EC54) {
+                        classListPropDesc.enumerable = false;
+                        objCtr.defineProperty(elemCtrProto, classListProp, classListPropDesc);
+                    }
+                }
+            }
+            else if (objCtr[protoProp].__defineGetter__) {
+                elemCtrProto.__defineGetter__(classListProp, classListGetter);
+            }
+        }(window.self));
+    }
+    // There is full or partial native classList support, so just check if we need
+    // to normalize the add/remove and toggle APIs.
+    (function () {
+        "use strict";
+        var testElement = document.createElement("_");
+        testElement.classList.add("c1", "c2");
+        // Polyfill for IE 10/11 and Firefox <26, where classList.add and
+        // classList.remove exist but support only one argument at a time.
+        if (!testElement.classList.contains("c2")) {
+            var createMethod = function (method) {
+                var original = DOMTokenList.prototype[method];
+                DOMTokenList.prototype[method] = function (token) {
+                    var i, len = arguments.length;
+                    for (i = 0; i < len; i++) {
+                        token = arguments[i];
+                        original.call(this, token);
+                    }
+                };
+            };
+            createMethod('add');
+            createMethod('remove');
+        }
+        testElement.classList.toggle("c3", false);
+        // Polyfill for IE 10 and Firefox <24, where classList.toggle does not
+        // support the second argument.
+        if (testElement.classList.contains("c3")) {
+            var _toggle = DOMTokenList.prototype.toggle;
+            DOMTokenList.prototype.toggle = function (token, force) {
+                if (1 in arguments && !this.contains(token) === !force) {
+                    return force;
+                }
+                else {
+                    return _toggle.call(this, token);
+                }
+            };
+        }
+        testElement = null;
+    }());
+}
+
+
+/***/ }),
+
+/***/ 8489:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+// This file can be required in Browserify and Node.js for automatic polyfill
+// To use it:  require('es6-promise/auto');
+
+module.exports = (__webpack_require__(48743).polyfill)();
+
+
+/***/ }),
+
+/***/ 48743:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/*!
+ * @overview es6-promise - a tiny implementation of Promises/A+.
+ * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
+ * @license   Licensed under MIT license
+ *            See https://raw.githubusercontent.com/stefanpenner/es6-promise/master/LICENSE
+ * @version   v4.2.8+1e68dce6
+ */
+(function (global, factory) {
+     true ? module.exports = factory() :
+        0;
+}(this, (function () {
+    'use strict';
+    function objectOrFunction(x) {
+        var type = typeof x;
+        return x !== null && (type === 'object' || type === 'function');
+    }
+    function isFunction(x) {
+        return typeof x === 'function';
+    }
+    var _isArray = void 0;
+    if (Array.isArray) {
+        _isArray = Array.isArray;
+    }
+    else {
+        _isArray = function (x) {
+            return Object.prototype.toString.call(x) === '[object Array]';
+        };
+    }
+    var isArray = _isArray;
+    var len = 0;
+    var vertxNext = void 0;
+    var customSchedulerFn = void 0;
+    var asap = function asap(callback, arg) {
+        queue[len] = callback;
+        queue[len + 1] = arg;
+        len += 2;
+        if (len === 2) {
+            // If len is 2, that means that we need to schedule an async flush.
+            // If additional callbacks are queued before the queue is flushed, they
+            // will be processed by this flush that we are scheduling.
+            if (customSchedulerFn) {
+                customSchedulerFn(flush);
+            }
+            else {
+                scheduleFlush();
+            }
+        }
+    };
+    function setScheduler(scheduleFn) {
+        customSchedulerFn = scheduleFn;
+    }
+    function setAsap(asapFn) {
+        asap = asapFn;
+    }
+    var browserWindow = typeof window !== 'undefined' ? window : undefined;
+    var browserGlobal = browserWindow || {};
+    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+    var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+    // test for web worker but not in IE10
+    var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
+    // node
+    function useNextTick() {
+        // node version 0.10.x displays a deprecation warning when nextTick is used recursively
+        // see https://github.com/cujojs/when/issues/410 for details
+        return function () {
+            return process.nextTick(flush);
+        };
+    }
+    // vertx
+    function useVertxTimer() {
+        if (typeof vertxNext !== 'undefined') {
+            return function () {
+                vertxNext(flush);
+            };
+        }
+        return useSetTimeout();
+    }
+    function useMutationObserver() {
+        var iterations = 0;
+        var observer = new BrowserMutationObserver(flush);
+        var node = document.createTextNode('');
+        observer.observe(node, { characterData: true });
+        return function () {
+            node.data = iterations = ++iterations % 2;
+        };
+    }
+    // web worker
+    function useMessageChannel() {
+        var channel = new MessageChannel();
+        channel.port1.onmessage = flush;
+        return function () {
+            return channel.port2.postMessage(0);
+        };
+    }
+    function useSetTimeout() {
+        // Store setTimeout reference so es6-promise will be unaffected by
+        // other code modifying setTimeout (like sinon.useFakeTimers())
+        var globalSetTimeout = setTimeout;
+        return function () {
+            return globalSetTimeout(flush, 1);
+        };
+    }
+    var queue = new Array(1000);
+    function flush() {
+        for (var i = 0; i < len; i += 2) {
+            var callback = queue[i];
+            var arg = queue[i + 1];
+            callback(arg);
+            queue[i] = undefined;
+            queue[i + 1] = undefined;
+        }
+        len = 0;
+    }
+    function attemptVertx() {
+        try {
+            var vertx = Function('return this')().require('vertx');
+            vertxNext = vertx.runOnLoop || vertx.runOnContext;
+            return useVertxTimer();
+        }
+        catch (e) {
+            return useSetTimeout();
+        }
+    }
+    var scheduleFlush = void 0;
+    // Decide what async method to use to triggering processing of queued callbacks:
+    if (isNode) {
+        scheduleFlush = useNextTick();
+    }
+    else if (BrowserMutationObserver) {
+        scheduleFlush = useMutationObserver();
+    }
+    else if (isWorker) {
+        scheduleFlush = useMessageChannel();
+    }
+    else if (browserWindow === undefined && "function" === 'function') {
+        scheduleFlush = attemptVertx();
+    }
+    else {
+        scheduleFlush = useSetTimeout();
+    }
+    function then(onFulfillment, onRejection) {
+        var parent = this;
+        var child = new this.constructor(noop);
+        if (child[PROMISE_ID] === undefined) {
+            makePromise(child);
+        }
+        var _state = parent._state;
+        if (_state) {
+            var callback = arguments[_state - 1];
+            asap(function () {
+                return invokeCallback(_state, child, callback, parent._result);
+            });
+        }
+        else {
+            subscribe(parent, child, onFulfillment, onRejection);
+        }
+        return child;
+    }
+    /**
+      `Promise.resolve` returns a promise that will become resolved with the
+      passed `value`. It is shorthand for the following:
+    
+      ```javascript
+      let promise = new Promise(function(resolve, reject){
+        resolve(1);
+      });
+    
+      promise.then(function(value){
+        // value === 1
+      });
+      ```
+    
+      Instead of writing the above, your code now simply becomes the following:
+    
+      ```javascript
+      let promise = Promise.resolve(1);
+    
+      promise.then(function(value){
+        // value === 1
+      });
+      ```
+    
+      @method resolve
+      @static
+      @param {Any} value value that the returned promise will be resolved with
+      Useful for tooling.
+      @return {Promise} a promise that will become fulfilled with the given
+      `value`
+    */
+    function resolve$1(object) {
+        /*jshint validthis:true */
+        var Constructor = this;
+        if (object && typeof object === 'object' && object.constructor === Constructor) {
+            return object;
+        }
+        var promise = new Constructor(noop);
+        resolve(promise, object);
+        return promise;
+    }
+    var PROMISE_ID = Math.random().toString(36).substring(2);
+    function noop() { }
+    var PENDING = void 0;
+    var FULFILLED = 1;
+    var REJECTED = 2;
+    function selfFulfillment() {
+        return new TypeError("You cannot resolve a promise with itself");
+    }
+    function cannotReturnOwn() {
+        return new TypeError('A promises callback cannot return that same promise.');
+    }
+    function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
+        try {
+            then$$1.call(value, fulfillmentHandler, rejectionHandler);
+        }
+        catch (e) {
+            return e;
+        }
+    }
+    function handleForeignThenable(promise, thenable, then$$1) {
+        asap(function (promise) {
+            var sealed = false;
+            var error = tryThen(then$$1, thenable, function (value) {
+                if (sealed) {
+                    return;
+                }
+                sealed = true;
+                if (thenable !== value) {
+                    resolve(promise, value);
+                }
+                else {
+                    fulfill(promise, value);
+                }
+            }, function (reason) {
+                if (sealed) {
+                    return;
+                }
+                sealed = true;
+                reject(promise, reason);
+            }, 'Settle: ' + (promise._label || ' unknown promise'));
+            if (!sealed && error) {
+                sealed = true;
+                reject(promise, error);
+            }
+        }, promise);
+    }
+    function handleOwnThenable(promise, thenable) {
+        if (thenable._state === FULFILLED) {
+            fulfill(promise, thenable._result);
+        }
+        else if (thenable._state === REJECTED) {
+            reject(promise, thenable._result);
+        }
+        else {
+            subscribe(thenable, undefined, function (value) {
+                return resolve(promise, value);
+            }, function (reason) {
+                return reject(promise, reason);
+            });
+        }
+    }
+    function handleMaybeThenable(promise, maybeThenable, then$$1) {
+        if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
+            handleOwnThenable(promise, maybeThenable);
+        }
+        else {
+            if (then$$1 === undefined) {
+                fulfill(promise, maybeThenable);
+            }
+            else if (isFunction(then$$1)) {
+                handleForeignThenable(promise, maybeThenable, then$$1);
+            }
+            else {
+                fulfill(promise, maybeThenable);
+            }
+        }
+    }
+    function resolve(promise, value) {
+        if (promise === value) {
+            reject(promise, selfFulfillment());
+        }
+        else if (objectOrFunction(value)) {
+            var then$$1 = void 0;
+            try {
+                then$$1 = value.then;
+            }
+            catch (error) {
+                reject(promise, error);
+                return;
+            }
+            handleMaybeThenable(promise, value, then$$1);
+        }
+        else {
+            fulfill(promise, value);
+        }
+    }
+    function publishRejection(promise) {
+        if (promise._onerror) {
+            promise._onerror(promise._result);
+        }
+        publish(promise);
+    }
+    function fulfill(promise, value) {
+        if (promise._state !== PENDING) {
+            return;
+        }
+        promise._result = value;
+        promise._state = FULFILLED;
+        if (promise._subscribers.length !== 0) {
+            asap(publish, promise);
+        }
+    }
+    function reject(promise, reason) {
+        if (promise._state !== PENDING) {
+            return;
+        }
+        promise._state = REJECTED;
+        promise._result = reason;
+        asap(publishRejection, promise);
+    }
+    function subscribe(parent, child, onFulfillment, onRejection) {
+        var _subscribers = parent._subscribers;
+        var length = _subscribers.length;
+        parent._onerror = null;
+        _subscribers[length] = child;
+        _subscribers[length + FULFILLED] = onFulfillment;
+        _subscribers[length + REJECTED] = onRejection;
+        if (length === 0 && parent._state) {
+            asap(publish, parent);
+        }
+    }
+    function publish(promise) {
+        var subscribers = promise._subscribers;
+        var settled = promise._state;
+        if (subscribers.length === 0) {
+            return;
+        }
+        var child = void 0, callback = void 0, detail = promise._result;
+        for (var i = 0; i < subscribers.length; i += 3) {
+            child = subscribers[i];
+            callback = subscribers[i + settled];
+            if (child) {
+                invokeCallback(settled, child, callback, detail);
+            }
+            else {
+                callback(detail);
+            }
+        }
+        promise._subscribers.length = 0;
+    }
+    function invokeCallback(settled, promise, callback, detail) {
+        var hasCallback = isFunction(callback), value = void 0, error = void 0, succeeded = true;
+        if (hasCallback) {
+            try {
+                value = callback(detail);
+            }
+            catch (e) {
+                succeeded = false;
+                error = e;
+            }
+            if (promise === value) {
+                reject(promise, cannotReturnOwn());
+                return;
+            }
+        }
+        else {
+            value = detail;
+        }
+        if (promise._state !== PENDING) {
+            // noop
+        }
+        else if (hasCallback && succeeded) {
+            resolve(promise, value);
+        }
+        else if (succeeded === false) {
+            reject(promise, error);
+        }
+        else if (settled === FULFILLED) {
+            fulfill(promise, value);
+        }
+        else if (settled === REJECTED) {
+            reject(promise, value);
+        }
+    }
+    function initializePromise(promise, resolver) {
+        try {
+            resolver(function resolvePromise(value) {
+                resolve(promise, value);
+            }, function rejectPromise(reason) {
+                reject(promise, reason);
+            });
+        }
+        catch (e) {
+            reject(promise, e);
+        }
+    }
+    var id = 0;
+    function nextId() {
+        return id++;
+    }
+    function makePromise(promise) {
+        promise[PROMISE_ID] = id++;
+        promise._state = undefined;
+        promise._result = undefined;
+        promise._subscribers = [];
+    }
+    function validationError() {
+        return new Error('Array Methods must be provided an Array');
+    }
+    var Enumerator = function () {
+        function Enumerator(Constructor, input) {
+            this._instanceConstructor = Constructor;
+            this.promise = new Constructor(noop);
+            if (!this.promise[PROMISE_ID]) {
+                makePromise(this.promise);
+            }
+            if (isArray(input)) {
+                this.length = input.length;
+                this._remaining = input.length;
+                this._result = new Array(this.length);
+                if (this.length === 0) {
+                    fulfill(this.promise, this._result);
+                }
+                else {
+                    this.length = this.length || 0;
+                    this._enumerate(input);
+                    if (this._remaining === 0) {
+                        fulfill(this.promise, this._result);
+                    }
+                }
+            }
+            else {
+                reject(this.promise, validationError());
+            }
+        }
+        Enumerator.prototype._enumerate = function _enumerate(input) {
+            for (var i = 0; this._state === PENDING && i < input.length; i++) {
+                this._eachEntry(input[i], i);
+            }
+        };
+        Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
+            var c = this._instanceConstructor;
+            var resolve$$1 = c.resolve;
+            if (resolve$$1 === resolve$1) {
+                var _then = void 0;
+                var error = void 0;
+                var didError = false;
+                try {
+                    _then = entry.then;
+                }
+                catch (e) {
+                    didError = true;
+                    error = e;
+                }
+                if (_then === then && entry._state !== PENDING) {
+                    this._settledAt(entry._state, i, entry._result);
+                }
+                else if (typeof _then !== 'function') {
+                    this._remaining--;
+                    this._result[i] = entry;
+                }
+                else if (c === Promise$1) {
+                    var promise = new c(noop);
+                    if (didError) {
+                        reject(promise, error);
+                    }
+                    else {
+                        handleMaybeThenable(promise, entry, _then);
+                    }
+                    this._willSettleAt(promise, i);
+                }
+                else {
+                    this._willSettleAt(new c(function (resolve$$1) {
+                        return resolve$$1(entry);
+                    }), i);
+                }
+            }
+            else {
+                this._willSettleAt(resolve$$1(entry), i);
+            }
+        };
+        Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
+            var promise = this.promise;
+            if (promise._state === PENDING) {
+                this._remaining--;
+                if (state === REJECTED) {
+                    reject(promise, value);
+                }
+                else {
+                    this._result[i] = value;
+                }
+            }
+            if (this._remaining === 0) {
+                fulfill(promise, this._result);
+            }
+        };
+        Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
+            var enumerator = this;
+            subscribe(promise, undefined, function (value) {
+                return enumerator._settledAt(FULFILLED, i, value);
+            }, function (reason) {
+                return enumerator._settledAt(REJECTED, i, reason);
+            });
+        };
+        return Enumerator;
+    }();
+    /**
+      `Promise.all` accepts an array of promises, and returns a new promise which
+      is fulfilled with an array of fulfillment values for the passed promises, or
+      rejected with the reason of the first passed promise to be rejected. It casts all
+      elements of the passed iterable to promises as it runs this algorithm.
+    
+      Example:
+    
+      ```javascript
+      let promise1 = resolve(1);
+      let promise2 = resolve(2);
+      let promise3 = resolve(3);
+      let promises = [ promise1, promise2, promise3 ];
+    
+      Promise.all(promises).then(function(array){
+        // The array here would be [ 1, 2, 3 ];
+      });
+      ```
+    
+      If any of the `promises` given to `all` are rejected, the first promise
+      that is rejected will be given as an argument to the returned promises's
+      rejection handler. For example:
+    
+      Example:
+    
+      ```javascript
+      let promise1 = resolve(1);
+      let promise2 = reject(new Error("2"));
+      let promise3 = reject(new Error("3"));
+      let promises = [ promise1, promise2, promise3 ];
+    
+      Promise.all(promises).then(function(array){
+        // Code here never runs because there are rejected promises!
+      }, function(error) {
+        // error.message === "2"
+      });
+      ```
+    
+      @method all
+      @static
+      @param {Array} entries array of promises
+      @param {String} label optional string for labeling the promise.
+      Useful for tooling.
+      @return {Promise} promise that is fulfilled when all `promises` have been
+      fulfilled, or rejected if any of them become rejected.
+      @static
+    */
+    function all(entries) {
+        return new Enumerator(this, entries).promise;
+    }
+    /**
+      `Promise.race` returns a new promise which is settled in the same way as the
+      first passed promise to settle.
+    
+      Example:
+    
+      ```javascript
+      let promise1 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 1');
+        }, 200);
+      });
+    
+      let promise2 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 2');
+        }, 100);
+      });
+    
+      Promise.race([promise1, promise2]).then(function(result){
+        // result === 'promise 2' because it was resolved before promise1
+        // was resolved.
+      });
+      ```
+    
+      `Promise.race` is deterministic in that only the state of the first
+      settled promise matters. For example, even if other promises given to the
+      `promises` array argument are resolved, but the first settled promise has
+      become rejected before the other promises became fulfilled, the returned
+      promise will become rejected:
+    
+      ```javascript
+      let promise1 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          resolve('promise 1');
+        }, 200);
+      });
+    
+      let promise2 = new Promise(function(resolve, reject){
+        setTimeout(function(){
+          reject(new Error('promise 2'));
+        }, 100);
+      });
+    
+      Promise.race([promise1, promise2]).then(function(result){
+        // Code here never runs
+      }, function(reason){
+        // reason.message === 'promise 2' because promise 2 became rejected before
+        // promise 1 became fulfilled
+      });
+      ```
+    
+      An example real-world use case is implementing timeouts:
+    
+      ```javascript
+      Promise.race([ajax('foo.json'), timeout(5000)])
+      ```
+    
+      @method race
+      @static
+      @param {Array} promises array of promises to observe
+      Useful for tooling.
+      @return {Promise} a promise which settles in the same way as the first passed
+      promise to settle.
+    */
+    function race(entries) {
+        /*jshint validthis:true */
+        var Constructor = this;
+        if (!isArray(entries)) {
+            return new Constructor(function (_, reject) {
+                return reject(new TypeError('You must pass an array to race.'));
+            });
+        }
+        else {
+            return new Constructor(function (resolve, reject) {
+                var length = entries.length;
+                for (var i = 0; i < length; i++) {
+                    Constructor.resolve(entries[i]).then(resolve, reject);
+                }
+            });
+        }
+    }
+    /**
+      `Promise.reject` returns a promise rejected with the passed `reason`.
+      It is shorthand for the following:
+    
+      ```javascript
+      let promise = new Promise(function(resolve, reject){
+        reject(new Error('WHOOPS'));
+      });
+    
+      promise.then(function(value){
+        // Code here doesn't run because the promise is rejected!
+      }, function(reason){
+        // reason.message === 'WHOOPS'
+      });
+      ```
+    
+      Instead of writing the above, your code now simply becomes the following:
+    
+      ```javascript
+      let promise = Promise.reject(new Error('WHOOPS'));
+    
+      promise.then(function(value){
+        // Code here doesn't run because the promise is rejected!
+      }, function(reason){
+        // reason.message === 'WHOOPS'
+      });
+      ```
+    
+      @method reject
+      @static
+      @param {Any} reason value that the returned promise will be rejected with.
+      Useful for tooling.
+      @return {Promise} a promise rejected with the given `reason`.
+    */
+    function reject$1(reason) {
+        /*jshint validthis:true */
+        var Constructor = this;
+        var promise = new Constructor(noop);
+        reject(promise, reason);
+        return promise;
+    }
+    function needsResolver() {
+        throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+    }
+    function needsNew() {
+        throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+    }
+    /**
+      Promise objects represent the eventual result of an asynchronous operation. The
+      primary way of interacting with a promise is through its `then` method, which
+      registers callbacks to receive either a promise's eventual value or the reason
+      why the promise cannot be fulfilled.
+    
+      Terminology
+      -----------
+    
+      - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+      - `thenable` is an object or function that defines a `then` method.
+      - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+      - `exception` is a value that is thrown using the throw statement.
+      - `reason` is a value that indicates why a promise was rejected.
+      - `settled` the final resting state of a promise, fulfilled or rejected.
+    
+      A promise can be in one of three states: pending, fulfilled, or rejected.
+    
+      Promises that are fulfilled have a fulfillment value and are in the fulfilled
+      state.  Promises that are rejected have a rejection reason and are in the
+      rejected state.  A fulfillment value is never a thenable.
+    
+      Promises can also be said to *resolve* a value.  If this value is also a
+      promise, then the original promise's settled state will match the value's
+      settled state.  So a promise that *resolves* a promise that rejects will
+      itself reject, and a promise that *resolves* a promise that fulfills will
+      itself fulfill.
+    
+    
+      Basic Usage:
+      ------------
+    
+      ```js
+      let promise = new Promise(function(resolve, reject) {
+        // on success
+        resolve(value);
+    
+        // on failure
+        reject(reason);
+      });
+    
+      promise.then(function(value) {
+        // on fulfillment
+      }, function(reason) {
+        // on rejection
+      });
+      ```
+    
+      Advanced Usage:
+      ---------------
+    
+      Promises shine when abstracting away asynchronous interactions such as
+      `XMLHttpRequest`s.
+    
+      ```js
+      function getJSON(url) {
+        return new Promise(function(resolve, reject){
+          let xhr = new XMLHttpRequest();
+    
+          xhr.open('GET', url);
+          xhr.onreadystatechange = handler;
+          xhr.responseType = 'json';
+          xhr.setRequestHeader('Accept', 'application/json');
+          xhr.send();
+    
+          function handler() {
+            if (this.readyState === this.DONE) {
+              if (this.status === 200) {
+                resolve(this.response);
+              } else {
+                reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
+              }
+            }
+          };
+        });
+      }
+    
+      getJSON('/posts.json').then(function(json) {
+        // on fulfillment
+      }, function(reason) {
+        // on rejection
+      });
+      ```
+    
+      Unlike callbacks, promises are great composable primitives.
+    
+      ```js
+      Promise.all([
+        getJSON('/posts'),
+        getJSON('/comments')
+      ]).then(function(values){
+        values[0] // => postsJSON
+        values[1] // => commentsJSON
+    
+        return values;
+      });
+      ```
+    
+      @class Promise
+      @param {Function} resolver
+      Useful for tooling.
+      @constructor
+    */
+    var Promise$1 = function () {
+        function Promise(resolver) {
+            this[PROMISE_ID] = nextId();
+            this._result = this._state = undefined;
+            this._subscribers = [];
+            if (noop !== resolver) {
+                typeof resolver !== 'function' && needsResolver();
+                this instanceof Promise ? initializePromise(this, resolver) : needsNew();
+            }
+        }
+        /**
+        The primary way of interacting with a promise is through its `then` method,
+        which registers callbacks to receive either a promise's eventual value or the
+        reason why the promise cannot be fulfilled.
+         ```js
+        findUser().then(function(user){
+          // user is available
+        }, function(reason){
+          // user is unavailable, and you are given the reason why
+        });
+        ```
+         Chaining
+        --------
+         The return value of `then` is itself a promise.  This second, 'downstream'
+        promise is resolved with the return value of the first promise's fulfillment
+        or rejection handler, or rejected if the handler throws an exception.
+         ```js
+        findUser().then(function (user) {
+          return user.name;
+        }, function (reason) {
+          return 'default name';
+        }).then(function (userName) {
+          // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
+          // will be `'default name'`
+        });
+         findUser().then(function (user) {
+          throw new Error('Found user, but still unhappy');
+        }, function (reason) {
+          throw new Error('`findUser` rejected and we're unhappy');
+        }).then(function (value) {
+          // never reached
+        }, function (reason) {
+          // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
+          // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
+        });
+        ```
+        If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
+         ```js
+        findUser().then(function (user) {
+          throw new PedagogicalException('Upstream error');
+        }).then(function (value) {
+          // never reached
+        }).then(function (value) {
+          // never reached
+        }, function (reason) {
+          // The `PedgagocialException` is propagated all the way down to here
+        });
+        ```
+         Assimilation
+        ------------
+         Sometimes the value you want to propagate to a downstream promise can only be
+        retrieved asynchronously. This can be achieved by returning a promise in the
+        fulfillment or rejection handler. The downstream promise will then be pending
+        until the returned promise is settled. This is called *assimilation*.
+         ```js
+        findUser().then(function (user) {
+          return findCommentsByAuthor(user);
+        }).then(function (comments) {
+          // The user's comments are now available
+        });
+        ```
+         If the assimliated promise rejects, then the downstream promise will also reject.
+         ```js
+        findUser().then(function (user) {
+          return findCommentsByAuthor(user);
+        }).then(function (comments) {
+          // If `findCommentsByAuthor` fulfills, we'll have the value here
+        }, function (reason) {
+          // If `findCommentsByAuthor` rejects, we'll have the reason here
+        });
+        ```
+         Simple Example
+        --------------
+         Synchronous Example
+         ```javascript
+        let result;
+         try {
+          result = findResult();
+          // success
+        } catch(reason) {
+          // failure
+        }
+        ```
+         Errback Example
+         ```js
+        findResult(function(result, err){
+          if (err) {
+            // failure
+          } else {
+            // success
+          }
+        });
+        ```
+         Promise Example;
+         ```javascript
+        findResult().then(function(result){
+          // success
+        }, function(reason){
+          // failure
+        });
+        ```
+         Advanced Example
+        --------------
+         Synchronous Example
+         ```javascript
+        let author, books;
+         try {
+          author = findAuthor();
+          books  = findBooksByAuthor(author);
+          // success
+        } catch(reason) {
+          // failure
+        }
+        ```
+         Errback Example
+         ```js
+         function foundBooks(books) {
+         }
+         function failure(reason) {
+         }
+         findAuthor(function(author, err){
+          if (err) {
+            failure(err);
+            // failure
+          } else {
+            try {
+              findBoooksByAuthor(author, function(books, err) {
+                if (err) {
+                  failure(err);
+                } else {
+                  try {
+                    foundBooks(books);
+                  } catch(reason) {
+                    failure(reason);
+                  }
+                }
+              });
+            } catch(error) {
+              failure(err);
+            }
+            // success
+          }
+        });
+        ```
+         Promise Example;
+         ```javascript
+        findAuthor().
+          then(findBooksByAuthor).
+          then(function(books){
+            // found books
+        }).catch(function(reason){
+          // something went wrong
+        });
+        ```
+         @method then
+        @param {Function} onFulfilled
+        @param {Function} onRejected
+        Useful for tooling.
+        @return {Promise}
+        */
+        /**
+        `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+        as the catch block of a try/catch statement.
+        ```js
+        function findAuthor(){
+        throw new Error('couldn't find that author');
+        }
+        // synchronous
+        try {
+        findAuthor();
+        } catch(reason) {
+        // something went wrong
+        }
+        // async with promises
+        findAuthor().catch(function(reason){
+        // something went wrong
+        });
+        ```
+        @method catch
+        @param {Function} onRejection
+        Useful for tooling.
+        @return {Promise}
+        */
+        Promise.prototype.catch = function _catch(onRejection) {
+            return this.then(null, onRejection);
+        };
+        /**
+          `finally` will be invoked regardless of the promise's fate just as native
+          try/catch/finally behaves
+        
+          Synchronous example:
+        
+          ```js
+          findAuthor() {
+            if (Math.random() > 0.5) {
+              throw new Error();
+            }
+            return new Author();
+          }
+        
+          try {
+            return findAuthor(); // succeed or fail
+          } catch(error) {
+            return findOtherAuther();
+          } finally {
+            // always runs
+            // doesn't affect the return value
+          }
+          ```
+        
+          Asynchronous example:
+        
+          ```js
+          findAuthor().catch(function(reason){
+            return findOtherAuther();
+          }).finally(function(){
+            // author was either found, or not
+          });
+          ```
+        
+          @method finally
+          @param {Function} callback
+          @return {Promise}
+        */
+        Promise.prototype.finally = function _finally(callback) {
+            var promise = this;
+            var constructor = promise.constructor;
+            if (isFunction(callback)) {
+                return promise.then(function (value) {
+                    return constructor.resolve(callback()).then(function () {
+                        return value;
+                    });
+                }, function (reason) {
+                    return constructor.resolve(callback()).then(function () {
+                        throw reason;
+                    });
+                });
+            }
+            return promise.then(callback, callback);
+        };
+        return Promise;
+    }();
+    Promise$1.prototype.then = then;
+    Promise$1.all = all;
+    Promise$1.race = race;
+    Promise$1.resolve = resolve$1;
+    Promise$1.reject = reject$1;
+    Promise$1._setScheduler = setScheduler;
+    Promise$1._setAsap = setAsap;
+    Promise$1._asap = asap;
+    /*global self*/
+    function polyfill() {
+        var local = void 0;
+        if (typeof __webpack_require__.g !== 'undefined') {
+            local = __webpack_require__.g;
+        }
+        else if (typeof self !== 'undefined') {
+            local = self;
+        }
+        else {
+            try {
+                local = Function('return this')();
+            }
+            catch (e) {
+                throw new Error('polyfill failed because global object is unavailable in this environment');
+            }
+        }
+        var P = local.Promise;
+        if (P) {
+            var promiseToString = null;
+            try {
+                promiseToString = Object.prototype.toString.call(P.resolve());
+            }
+            catch (e) {
+                // silently ignored
+            }
+            if (promiseToString === '[object Promise]' && !P.cast) {
+                return;
+            }
+        }
+        local.Promise = Promise$1;
+    }
+    // Strange compat..
+    Promise$1.polyfill = polyfill;
+    Promise$1.Promise = Promise$1;
+    return Promise$1;
+})));
+
+
+
+/***/ }),
+
+/***/ 64707:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+__webpack_require__(49445);
+var entryUnbind = __webpack_require__(40532);
+module.exports = entryUnbind('Array', 'findIndex');
+
+
+/***/ }),
+
+/***/ 7513:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+__webpack_require__(95491);
+__webpack_require__(69507);
+var path = __webpack_require__(21504);
+module.exports = path.Array.from;
+
+
+/***/ }),
+
+/***/ 29368:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+__webpack_require__(92059);
+__webpack_require__(7222);
+__webpack_require__(88598);
+__webpack_require__(10695);
+__webpack_require__(62630);
+__webpack_require__(4282);
+__webpack_require__(38163);
+__webpack_require__(86912);
+__webpack_require__(1957);
+__webpack_require__(94811);
+__webpack_require__(89580);
+__webpack_require__(40582);
+__webpack_require__(80294);
+__webpack_require__(19644);
+__webpack_require__(28619);
+__webpack_require__(76880);
+__webpack_require__(9163);
+__webpack_require__(57914);
+__webpack_require__(20926);
+__webpack_require__(83775);
+var path = __webpack_require__(21504);
+module.exports = path.Symbol;
+
+
+/***/ }),
+
+/***/ 49649:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isCallable = __webpack_require__(55468);
+var tryToString = __webpack_require__(5174);
+var $TypeError = TypeError;
+// `Assert: IsCallable(argument) is true`
+module.exports = function (argument) {
+    if (isCallable(argument))
+        return argument;
+    throw new $TypeError(tryToString(argument) + ' is not a function');
+};
+
+
+/***/ }),
+
+/***/ 23785:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isPossiblePrototype = __webpack_require__(84200);
+var $String = String;
+var $TypeError = TypeError;
+module.exports = function (argument) {
+    if (isPossiblePrototype(argument))
+        return argument;
+    throw new $TypeError("Can't set " + $String(argument) + ' as a prototype');
+};
+
+
+/***/ }),
+
+/***/ 1922:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var wellKnownSymbol = __webpack_require__(47226);
+var create = __webpack_require__(52713);
+var defineProperty = (__webpack_require__(11154).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]
+module.exports = function (key) {
+    ArrayPrototype[UNSCOPABLES][key] = true;
+};
+
+
+/***/ }),
+
+/***/ 79002:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isObject = __webpack_require__(56063);
+var $String = String;
+var $TypeError = TypeError;
+// `Assert: Type(argument) is Object`
+module.exports = function (argument) {
+    if (isObject(argument))
+        return argument;
+    throw new $TypeError($String(argument) + ' is not an object');
+};
+
+
+/***/ }),
+
+/***/ 91531:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var bind = __webpack_require__(69661);
+var call = __webpack_require__(31944);
+var toObject = __webpack_require__(58860);
+var callWithSafeIterationClosing = __webpack_require__(23756);
+var isArrayIteratorMethod = __webpack_require__(96242);
+var isConstructor = __webpack_require__(38018);
+var lengthOfArrayLike = __webpack_require__(2701);
+var createProperty = __webpack_require__(44849);
+var getIterator = __webpack_require__(50318);
+var getIteratorMethod = __webpack_require__(38994);
+var $Array = Array;
+// `Array.from` method implementation
+// https://tc39.es/ecma262/#sec-array.from
+module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
+    var O = toObject(arrayLike);
+    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 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++) {
+            value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
+            createProperty(result, index, value);
+        }
+    }
+    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);
+        }
+    }
+    result.length = index;
+    return result;
+};
+
+
+/***/ }),
+
+/***/ 54962:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toIndexedObject = __webpack_require__(53324);
+var toAbsoluteIndex = __webpack_require__(13619);
+var lengthOfArrayLike = __webpack_require__(2701);
+// `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;
+    };
+};
+module.exports = {
+    // `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)
+};
+
+
+/***/ }),
+
+/***/ 84536:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var bind = __webpack_require__(69661);
+var uncurryThis = __webpack_require__(84369);
+var IndexedObject = __webpack_require__(21072);
+var toObject = __webpack_require__(58860);
+var lengthOfArrayLike = __webpack_require__(2701);
+var arraySpeciesCreate = __webpack_require__(24686);
+var push = uncurryThis([].push);
+// `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, 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;
+    };
+};
+module.exports = {
+    // `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)
+};
+
+
+/***/ }),
+
+/***/ 16074:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(11794);
+var wellKnownSymbol = __webpack_require__(47226);
+var V8_VERSION = __webpack_require__(9696);
+var SPECIES = wellKnownSymbol('species');
+module.exports = 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;
+    });
+};
+
+
+/***/ }),
+
+/***/ 85457:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+module.exports = uncurryThis([].slice);
+
+
+/***/ }),
+
+/***/ 85148:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isArray = __webpack_require__(96127);
+var isConstructor = __webpack_require__(38018);
+var isObject = __webpack_require__(56063);
+var wellKnownSymbol = __webpack_require__(47226);
+var SPECIES = wellKnownSymbol('species');
+var $Array = Array;
+// a part of `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+module.exports = 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;
+};
+
+
+/***/ }),
+
+/***/ 24686:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var arraySpeciesConstructor = __webpack_require__(85148);
+// `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+module.exports = function (originalArray, length) {
+    return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
+};
+
+
+/***/ }),
+
+/***/ 23756:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var anObject = __webpack_require__(79002);
+var iteratorClose = __webpack_require__(62004);
+// call something on iterator step with safe closing on error
+module.exports = function (iterator, fn, value, ENTRIES) {
+    try {
+        return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
+    }
+    catch (error) {
+        iteratorClose(iterator, 'throw', error);
+    }
+};
+
+
+/***/ }),
+
+/***/ 60947:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var wellKnownSymbol = __webpack_require__(47226);
+var ITERATOR = wellKnownSymbol('iterator');
+var SAFE_CLOSING = false;
+try {
+    var called = 0;
+    var iteratorWithReturn = {
+        next: function () {
+            return { done: !!called++ };
+        },
+        'return': function () {
+            SAFE_CLOSING = true;
+        }
+    };
+    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 */ }
+module.exports = 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 = {};
+        object[ITERATOR] = function () {
+            return {
+                next: function () {
+                    return { done: ITERATION_SUPPORT = true };
+                }
+            };
+        };
+        exec(object);
+    }
+    catch (error) { /* empty */ }
+    return ITERATION_SUPPORT;
+};
+
+
+/***/ }),
+
+/***/ 96321:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var toString = uncurryThis({}.toString);
+var stringSlice = uncurryThis(''.slice);
+module.exports = function (it) {
+    return stringSlice(toString(it), 8, -1);
+};
+
+
+/***/ }),
+
+/***/ 12318:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var TO_STRING_TAG_SUPPORT = __webpack_require__(46833);
+var isCallable = __webpack_require__(55468);
+var classofRaw = __webpack_require__(96321);
+var wellKnownSymbol = __webpack_require__(47226);
+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`
+module.exports = 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;
+};
+
+
+/***/ }),
+
+/***/ 79041:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var hasOwn = __webpack_require__(58898);
+var ownKeys = __webpack_require__(42576);
+var getOwnPropertyDescriptorModule = __webpack_require__(34072);
+var definePropertyModule = __webpack_require__(11154);
+module.exports = 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));
+        }
+    }
+};
+
+
+/***/ }),
+
+/***/ 18776:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(11794);
+module.exports = !fails(function () {
+    function F() { }
+    F.prototype.constructor = null;
+    // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+    return Object.getPrototypeOf(new F()) !== F.prototype;
+});
+
+
+/***/ }),
+
+/***/ 11392:
+/***/ (function(module) {
+
+
+// `CreateIterResultObject` abstract operation
+// https://tc39.es/ecma262/#sec-createiterresultobject
+module.exports = function (value, done) {
+    return { value: value, done: done };
+};
+
+
+/***/ }),
+
+/***/ 41752:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(54525);
+var definePropertyModule = __webpack_require__(11154);
+var createPropertyDescriptor = __webpack_require__(72787);
+module.exports = DESCRIPTORS ? function (object, key, value) {
+    return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+} : function (object, key, value) {
+    object[key] = value;
+    return object;
+};
+
+
+/***/ }),
+
+/***/ 72787:
+/***/ (function(module) {
+
+
+module.exports = function (bitmap, value) {
+    return {
+        enumerable: !(bitmap & 1),
+        configurable: !(bitmap & 2),
+        writable: !(bitmap & 4),
+        value: value
+    };
+};
+
+
+/***/ }),
+
+/***/ 44849:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(54525);
+var definePropertyModule = __webpack_require__(11154);
+var createPropertyDescriptor = __webpack_require__(72787);
+module.exports = function (object, key, value) {
+    if (DESCRIPTORS)
+        definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
+    else
+        object[key] = value;
+};
+
+
+/***/ }),
+
+/***/ 79093:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var makeBuiltIn = __webpack_require__(66530);
+var defineProperty = __webpack_require__(11154);
+module.exports = function (target, name, descriptor) {
+    if (descriptor.get)
+        makeBuiltIn(descriptor.get, name, { getter: true });
+    if (descriptor.set)
+        makeBuiltIn(descriptor.set, name, { setter: true });
+    return defineProperty.f(target, name, descriptor);
+};
+
+
+/***/ }),
+
+/***/ 47941:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isCallable = __webpack_require__(55468);
+var definePropertyModule = __webpack_require__(11154);
+var makeBuiltIn = __webpack_require__(66530);
+var defineGlobalProperty = __webpack_require__(61486);
+module.exports = 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;
+};
+
+
+/***/ }),
+
+/***/ 61486:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var defineProperty = Object.defineProperty;
+module.exports = function (key, value) {
+    try {
+        defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
+    }
+    catch (error) {
+        globalThis[key] = value;
+    }
+    return value;
+};
+
+
+/***/ }),
+
+/***/ 54525:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(11794);
+// Detect IE8's incomplete defineProperty implementation
+module.exports = !fails(function () {
+    // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+    return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
+});
+
+
+/***/ }),
+
+/***/ 33350:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var isObject = __webpack_require__(56063);
+var document = globalThis.document;
+// typeof document.createElement is 'object' in old IE
+var EXISTS = isObject(document) && isObject(document.createElement);
+module.exports = function (it) {
+    return EXISTS ? document.createElement(it) : {};
+};
+
+
+/***/ }),
+
+/***/ 74098:
+/***/ (function(module) {
+
+
+var $TypeError = TypeError;
+var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
+module.exports = function (it) {
+    if (it > MAX_SAFE_INTEGER)
+        throw $TypeError('Maximum allowed index exceeded');
+    return it;
+};
+
+
+/***/ }),
+
+/***/ 40532:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var uncurryThis = __webpack_require__(84369);
+module.exports = function (CONSTRUCTOR, METHOD) {
+    return uncurryThis(globalThis[CONSTRUCTOR].prototype[METHOD]);
+};
+
+
+/***/ }),
+
+/***/ 36922:
+/***/ (function(module) {
+
+
+// IE8- don't enum bug keys
+module.exports = [
+    'constructor',
+    'hasOwnProperty',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toLocaleString',
+    'toString',
+    'valueOf'
+];
+
+
+/***/ }),
+
+/***/ 61100:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var navigator = globalThis.navigator;
+var userAgent = navigator && navigator.userAgent;
+module.exports = userAgent ? String(userAgent) : '';
+
+
+/***/ }),
+
+/***/ 9696:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var userAgent = __webpack_require__(61100);
+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];
+    }
+}
+module.exports = version;
+
+
+/***/ }),
+
+/***/ 22829:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var getOwnPropertyDescriptor = (__webpack_require__(34072).f);
+var createNonEnumerableProperty = __webpack_require__(41752);
+var defineBuiltIn = __webpack_require__(47941);
+var defineGlobalProperty = __webpack_require__(61486);
+var copyConstructorProperties = __webpack_require__(79041);
+var isForced = __webpack_require__(43721);
+/*
+  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
+*/
+module.exports = 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);
+        }
+};
+
+
+/***/ }),
+
+/***/ 11794:
+/***/ (function(module) {
+
+
+module.exports = function (exec) {
+    try {
+        return !!exec();
+    }
+    catch (error) {
+        return true;
+    }
+};
+
+
+/***/ }),
+
+/***/ 14150:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_BIND = __webpack_require__(38719);
+var FunctionPrototype = Function.prototype;
+var apply = FunctionPrototype.apply;
+var call = FunctionPrototype.call;
+// eslint-disable-next-line es/no-reflect -- safe
+module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
+    return call.apply(apply, arguments);
+});
+
+
+/***/ }),
+
+/***/ 69661:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(55211);
+var aCallable = __webpack_require__(49649);
+var NATIVE_BIND = __webpack_require__(38719);
+var bind = uncurryThis(uncurryThis.bind);
+// optional / simple context binding
+module.exports = function (fn, that) {
+    aCallable(fn);
+    return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function ( /* ...args */) {
+        return fn.apply(that, arguments);
+    };
+};
+
+
+/***/ }),
+
+/***/ 38719:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(11794);
+module.exports = !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');
+});
+
+
+/***/ }),
+
+/***/ 31944:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_BIND = __webpack_require__(38719);
+var call = Function.prototype.call;
+module.exports = NATIVE_BIND ? call.bind(call) : function () {
+    return call.apply(call, arguments);
+};
+
+
+/***/ }),
+
+/***/ 84735:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(54525);
+var hasOwn = __webpack_require__(58898);
+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));
+module.exports = {
+    EXISTS: EXISTS,
+    PROPER: PROPER,
+    CONFIGURABLE: CONFIGURABLE
+};
+
+
+/***/ }),
+
+/***/ 24689:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var aCallable = __webpack_require__(49649);
+module.exports = 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 */ }
+};
+
+
+/***/ }),
+
+/***/ 55211:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var classofRaw = __webpack_require__(96321);
+var uncurryThis = __webpack_require__(84369);
+module.exports = 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);
+};
+
+
+/***/ }),
+
+/***/ 84369:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_BIND = __webpack_require__(38719);
+var FunctionPrototype = Function.prototype;
+var call = FunctionPrototype.call;
+var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
+module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
+    return function () {
+        return call.apply(fn, arguments);
+    };
+};
+
+
+/***/ }),
+
+/***/ 93572:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var isCallable = __webpack_require__(55468);
+var aFunction = function (argument) {
+    return isCallable(argument) ? argument : undefined;
+};
+module.exports = function (namespace, method) {
+    return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
+};
+
+
+/***/ }),
+
+/***/ 38994:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var classof = __webpack_require__(12318);
+var getMethod = __webpack_require__(17585);
+var isNullOrUndefined = __webpack_require__(77630);
+var Iterators = __webpack_require__(24396);
+var wellKnownSymbol = __webpack_require__(47226);
+var ITERATOR = wellKnownSymbol('iterator');
+module.exports = function (it) {
+    if (!isNullOrUndefined(it))
+        return getMethod(it, ITERATOR)
+            || getMethod(it, '@@iterator')
+            || Iterators[classof(it)];
+};
+
+
+/***/ }),
+
+/***/ 50318:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(31944);
+var aCallable = __webpack_require__(49649);
+var anObject = __webpack_require__(79002);
+var tryToString = __webpack_require__(5174);
+var getIteratorMethod = __webpack_require__(38994);
+var $TypeError = TypeError;
+module.exports = function (argument, usingIterator) {
+    var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
+    if (aCallable(iteratorMethod))
+        return anObject(call(iteratorMethod, argument));
+    throw new $TypeError(tryToString(argument) + ' is not iterable');
+};
+
+
+/***/ }),
+
+/***/ 91918:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var isArray = __webpack_require__(96127);
+var isCallable = __webpack_require__(55468);
+var classof = __webpack_require__(96321);
+var toString = __webpack_require__(67850);
+var push = uncurryThis([].push);
+module.exports = function (replacer) {
+    if (isCallable(replacer))
+        return replacer;
+    if (!isArray(replacer))
+        return;
+    var rawLength = replacer.length;
+    var keys = [];
+    for (var i = 0; i < rawLength; i++) {
+        var element = replacer[i];
+        if (typeof element == 'string')
+            push(keys, element);
+        else if (typeof element == 'number' || classof(element) === 'Number' || classof(element) === 'String')
+            push(keys, toString(element));
+    }
+    var keysLength = keys.length;
+    var root = true;
+    return function (key, value) {
+        if (root) {
+            root = false;
+            return value;
+        }
+        if (isArray(this))
+            return value;
+        for (var j = 0; j < keysLength; j++)
+            if (keys[j] === key)
+                return value;
+    };
+};
+
+
+/***/ }),
+
+/***/ 17585:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var aCallable = __webpack_require__(49649);
+var isNullOrUndefined = __webpack_require__(77630);
+// `GetMethod` abstract operation
+// https://tc39.es/ecma262/#sec-getmethod
+module.exports = function (V, P) {
+    var func = V[P];
+    return isNullOrUndefined(func) ? undefined : aCallable(func);
+};
+
+
+/***/ }),
+
+/***/ 36749:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var check = function (it) {
+    return it && it.Math === Math && it;
+};
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+module.exports =
+    // 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 __webpack_require__.g == 'object' && __webpack_require__.g) ||
+        check(typeof this == 'object' && this) ||
+        // eslint-disable-next-line no-new-func -- fallback
+        (function () { return this; })() || Function('return this')();
+
+
+/***/ }),
+
+/***/ 58898:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var toObject = __webpack_require__(58860);
+var hasOwnProperty = uncurryThis({}.hasOwnProperty);
+// `HasOwnProperty` abstract operation
+// https://tc39.es/ecma262/#sec-hasownproperty
+// eslint-disable-next-line es/no-object-hasown -- safe
+module.exports = Object.hasOwn || function hasOwn(it, key) {
+    return hasOwnProperty(toObject(it), key);
+};
+
+
+/***/ }),
+
+/***/ 25220:
+/***/ (function(module) {
+
+
+module.exports = {};
+
+
+/***/ }),
+
+/***/ 56194:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var getBuiltIn = __webpack_require__(93572);
+module.exports = getBuiltIn('document', 'documentElement');
+
+
+/***/ }),
+
+/***/ 13126:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(54525);
+var fails = __webpack_require__(11794);
+var createElement = __webpack_require__(33350);
+// Thanks to IE8 for its funny defineProperty
+module.exports = !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;
+});
+
+
+/***/ }),
+
+/***/ 21072:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var fails = __webpack_require__(11794);
+var classof = __webpack_require__(96321);
+var $Object = Object;
+var split = uncurryThis(''.split);
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+module.exports = 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;
+
+
+/***/ }),
+
+/***/ 70181:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var isCallable = __webpack_require__(55468);
+var store = __webpack_require__(50662);
+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);
+    };
+}
+module.exports = store.inspectSource;
+
+
+/***/ }),
+
+/***/ 238:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_WEAK_MAP = __webpack_require__(14041);
+var globalThis = __webpack_require__(36749);
+var isObject = __webpack_require__(56063);
+var createNonEnumerableProperty = __webpack_require__(41752);
+var hasOwn = __webpack_require__(58898);
+var shared = __webpack_require__(50662);
+var sharedKey = __webpack_require__(44840);
+var hiddenKeys = __webpack_require__(25220);
+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);
+    };
+}
+module.exports = {
+    set: set,
+    get: get,
+    has: has,
+    enforce: enforce,
+    getterFor: getterFor
+};
+
+
+/***/ }),
+
+/***/ 96242:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var wellKnownSymbol = __webpack_require__(47226);
+var Iterators = __webpack_require__(24396);
+var ITERATOR = wellKnownSymbol('iterator');
+var ArrayPrototype = Array.prototype;
+// check on default Array iterator
+module.exports = function (it) {
+    return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+};
+
+
+/***/ }),
+
+/***/ 96127:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var classof = __webpack_require__(96321);
+// `IsArray` abstract operation
+// https://tc39.es/ecma262/#sec-isarray
+// eslint-disable-next-line es/no-array-isarray -- safe
+module.exports = Array.isArray || function isArray(argument) {
+    return classof(argument) === 'Array';
+};
+
+
+/***/ }),
+
+/***/ 55468:
+/***/ (function(module) {
+
+
+// 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
+module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
+    return typeof argument == 'function' || argument === documentAll;
+} : function (argument) {
+    return typeof argument == 'function';
+};
+
+
+/***/ }),
+
+/***/ 38018:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var fails = __webpack_require__(11794);
+var isCallable = __webpack_require__(55468);
+var classof = __webpack_require__(12318);
+var getBuiltIn = __webpack_require__(93572);
+var inspectSource = __webpack_require__(70181);
+var noop = function () { };
+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
+module.exports = !construct || fails(function () {
+    var called;
+    return isConstructorModern(isConstructorModern.call)
+        || !isConstructorModern(Object)
+        || !isConstructorModern(function () { called = true; })
+        || called;
+}) ? isConstructorLegacy : isConstructorModern;
+
+
+/***/ }),
+
+/***/ 43721:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(11794);
+var isCallable = __webpack_require__(55468);
+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';
+module.exports = isForced;
+
+
+/***/ }),
+
+/***/ 77630:
+/***/ (function(module) {
+
+
+// we can't use just `it == null` since of `document.all` special case
+// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+module.exports = function (it) {
+    return it === null || it === undefined;
+};
+
+
+/***/ }),
+
+/***/ 56063:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isCallable = __webpack_require__(55468);
+module.exports = function (it) {
+    return typeof it == 'object' ? it !== null : isCallable(it);
+};
+
+
+/***/ }),
+
+/***/ 84200:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isObject = __webpack_require__(56063);
+module.exports = function (argument) {
+    return isObject(argument) || argument === null;
+};
+
+
+/***/ }),
+
+/***/ 32470:
+/***/ (function(module) {
+
+
+module.exports = false;
+
+
+/***/ }),
+
+/***/ 81264:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var getBuiltIn = __webpack_require__(93572);
+var isCallable = __webpack_require__(55468);
+var isPrototypeOf = __webpack_require__(67618);
+var USE_SYMBOL_AS_UID = __webpack_require__(16401);
+var $Object = Object;
+module.exports = USE_SYMBOL_AS_UID ? function (it) {
+    return typeof it == 'symbol';
+} : function (it) {
+    var $Symbol = getBuiltIn('Symbol');
+    return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+};
+
+
+/***/ }),
+
+/***/ 62004:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(31944);
+var anObject = __webpack_require__(79002);
+var getMethod = __webpack_require__(17585);
+module.exports = 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;
+};
+
+
+/***/ }),
+
+/***/ 89767:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var IteratorPrototype = (__webpack_require__(47922).IteratorPrototype);
+var create = __webpack_require__(52713);
+var createPropertyDescriptor = __webpack_require__(72787);
+var setToStringTag = __webpack_require__(36698);
+var Iterators = __webpack_require__(24396);
+var returnThis = function () { return this; };
+module.exports = 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;
+};
+
+
+/***/ }),
+
+/***/ 33649:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var call = __webpack_require__(31944);
+var IS_PURE = __webpack_require__(32470);
+var FunctionName = __webpack_require__(84735);
+var isCallable = __webpack_require__(55468);
+var createIteratorConstructor = __webpack_require__(89767);
+var getPrototypeOf = __webpack_require__(59210);
+var setPrototypeOf = __webpack_require__(72478);
+var setToStringTag = __webpack_require__(36698);
+var createNonEnumerableProperty = __webpack_require__(41752);
+var defineBuiltIn = __webpack_require__(47941);
+var wellKnownSymbol = __webpack_require__(47226);
+var Iterators = __webpack_require__(24396);
+var IteratorsCore = __webpack_require__(47922);
+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; };
+module.exports = 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;
+};
+
+
+/***/ }),
+
+/***/ 47922:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(11794);
+var isCallable = __webpack_require__(55468);
+var isObject = __webpack_require__(56063);
+var create = __webpack_require__(52713);
+var getPrototypeOf = __webpack_require__(59210);
+var defineBuiltIn = __webpack_require__(47941);
+var wellKnownSymbol = __webpack_require__(47226);
+var IS_PURE = __webpack_require__(32470);
+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;
+    });
+}
+module.exports = {
+    IteratorPrototype: IteratorPrototype,
+    BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
+};
+
+
+/***/ }),
+
+/***/ 24396:
+/***/ (function(module) {
+
+
+module.exports = {};
+
+
+/***/ }),
+
+/***/ 2701:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toLength = __webpack_require__(72843);
+// `LengthOfArrayLike` abstract operation
+// https://tc39.es/ecma262/#sec-lengthofarraylike
+module.exports = function (obj) {
+    return toLength(obj.length);
+};
+
+
+/***/ }),
+
+/***/ 66530:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var fails = __webpack_require__(11794);
+var isCallable = __webpack_require__(55468);
+var hasOwn = __webpack_require__(58898);
+var DESCRIPTORS = __webpack_require__(54525);
+var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(84735).CONFIGURABLE);
+var inspectSource = __webpack_require__(70181);
+var InternalStateModule = __webpack_require__(238);
+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 = module.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(function toString() {
+    return isCallable(this) && getInternalState(this).source || inspectSource(this);
+}, 'toString');
+
+
+/***/ }),
+
+/***/ 64814:
+/***/ (function(module) {
+
+
+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
+module.exports = Math.trunc || function trunc(x) {
+    var n = +x;
+    return (n > 0 ? floor : ceil)(n);
+};
+
+
+/***/ }),
+
+/***/ 52713:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/* global ActiveXObject -- old IE, WSH */
+var anObject = __webpack_require__(79002);
+var definePropertiesModule = __webpack_require__(68126);
+var enumBugKeys = __webpack_require__(36922);
+var hiddenKeys = __webpack_require__(25220);
+var html = __webpack_require__(56194);
+var documentCreateElement = __webpack_require__(33350);
+var sharedKey = __webpack_require__(44840);
+var GT = '>';
+var LT = '<';
+var PROTOTYPE = 'prototype';
+var SCRIPT = 'script';
+var IE_PROTO = sharedKey('IE_PROTO');
+var EmptyConstructor = function () { };
+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
+module.exports = 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);
+};
+
+
+/***/ }),
+
+/***/ 68126:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(54525);
+var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(90739);
+var definePropertyModule = __webpack_require__(11154);
+var anObject = __webpack_require__(79002);
+var toIndexedObject = __webpack_require__(53324);
+var objectKeys = __webpack_require__(14769);
+// `Object.defineProperties` method
+// https://tc39.es/ecma262/#sec-object.defineproperties
+// eslint-disable-next-line es/no-object-defineproperties -- safe
+exports.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;
+};
+
+
+/***/ }),
+
+/***/ 11154:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(54525);
+var IE8_DOM_DEFINE = __webpack_require__(13126);
+var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(90739);
+var anObject = __webpack_require__(79002);
+var toPropertyKey = __webpack_require__(92776);
+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
+exports.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;
+};
+
+
+/***/ }),
+
+/***/ 34072:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(54525);
+var call = __webpack_require__(31944);
+var propertyIsEnumerableModule = __webpack_require__(66000);
+var createPropertyDescriptor = __webpack_require__(72787);
+var toIndexedObject = __webpack_require__(53324);
+var toPropertyKey = __webpack_require__(92776);
+var hasOwn = __webpack_require__(58898);
+var IE8_DOM_DEFINE = __webpack_require__(13126);
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+// `Object.getOwnPropertyDescriptor` method
+// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+exports.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]);
+};
+
+
+/***/ }),
+
+/***/ 23701:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/* eslint-disable es/no-object-getownpropertynames -- safe */
+var classof = __webpack_require__(96321);
+var toIndexedObject = __webpack_require__(53324);
+var $getOwnPropertyNames = (__webpack_require__(17213).f);
+var arraySlice = __webpack_require__(85457);
+var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
+    ? Object.getOwnPropertyNames(window) : [];
+var getWindowNames = function (it) {
+    try {
+        return $getOwnPropertyNames(it);
+    }
+    catch (error) {
+        return arraySlice(windowNames);
+    }
+};
+// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
+module.exports.f = function getOwnPropertyNames(it) {
+    return windowNames && classof(it) === 'Window'
+        ? getWindowNames(it)
+        : $getOwnPropertyNames(toIndexedObject(it));
+};
+
+
+/***/ }),
+
+/***/ 17213:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var internalObjectKeys = __webpack_require__(55155);
+var enumBugKeys = __webpack_require__(36922);
+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
+exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+    return internalObjectKeys(O, hiddenKeys);
+};
+
+
+/***/ }),
+
+/***/ 89452:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+exports.f = Object.getOwnPropertySymbols;
+
+
+/***/ }),
+
+/***/ 59210:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var hasOwn = __webpack_require__(58898);
+var isCallable = __webpack_require__(55468);
+var toObject = __webpack_require__(58860);
+var sharedKey = __webpack_require__(44840);
+var CORRECT_PROTOTYPE_GETTER = __webpack_require__(18776);
+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
+module.exports = 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;
+};
+
+
+/***/ }),
+
+/***/ 67618:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+module.exports = uncurryThis({}.isPrototypeOf);
+
+
+/***/ }),
+
+/***/ 55155:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var hasOwn = __webpack_require__(58898);
+var toIndexedObject = __webpack_require__(53324);
+var indexOf = (__webpack_require__(54962).indexOf);
+var hiddenKeys = __webpack_require__(25220);
+var push = uncurryThis([].push);
+module.exports = 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;
+};
+
+
+/***/ }),
+
+/***/ 14769:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var internalObjectKeys = __webpack_require__(55155);
+var enumBugKeys = __webpack_require__(36922);
+// `Object.keys` method
+// https://tc39.es/ecma262/#sec-object.keys
+// eslint-disable-next-line es/no-object-keys -- safe
+module.exports = Object.keys || function keys(O) {
+    return internalObjectKeys(O, enumBugKeys);
+};
+
+
+/***/ }),
+
+/***/ 66000:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+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
+exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+    var descriptor = getOwnPropertyDescriptor(this, V);
+    return !!descriptor && descriptor.enumerable;
+} : $propertyIsEnumerable;
+
+
+/***/ }),
+
+/***/ 72478:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/* eslint-disable no-proto -- safe */
+var uncurryThisAccessor = __webpack_require__(24689);
+var isObject = __webpack_require__(56063);
+var requireObjectCoercible = __webpack_require__(7605);
+var aPossiblePrototype = __webpack_require__(23785);
+// `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
+module.exports = 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);
+
+
+/***/ }),
+
+/***/ 46724:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var TO_STRING_TAG_SUPPORT = __webpack_require__(46833);
+var classof = __webpack_require__(12318);
+// `Object.prototype.toString` method implementation
+// https://tc39.es/ecma262/#sec-object.prototype.tostring
+module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {
+    return '[object ' + classof(this) + ']';
+};
+
+
+/***/ }),
+
+/***/ 69775:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(31944);
+var isCallable = __webpack_require__(55468);
+var isObject = __webpack_require__(56063);
+var $TypeError = TypeError;
+// `OrdinaryToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-ordinarytoprimitive
+module.exports = 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");
+};
+
+
+/***/ }),
+
+/***/ 42576:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var getBuiltIn = __webpack_require__(93572);
+var uncurryThis = __webpack_require__(84369);
+var getOwnPropertyNamesModule = __webpack_require__(17213);
+var getOwnPropertySymbolsModule = __webpack_require__(89452);
+var anObject = __webpack_require__(79002);
+var concat = uncurryThis([].concat);
+// all object keys, includes non-enumerable and symbols
+module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+    var keys = getOwnPropertyNamesModule.f(anObject(it));
+    var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+    return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+};
+
+
+/***/ }),
+
+/***/ 21504:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+module.exports = globalThis;
+
+
+/***/ }),
+
+/***/ 7605:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isNullOrUndefined = __webpack_require__(77630);
+var $TypeError = TypeError;
+// `RequireObjectCoercible` abstract operation
+// https://tc39.es/ecma262/#sec-requireobjectcoercible
+module.exports = function (it) {
+    if (isNullOrUndefined(it))
+        throw new $TypeError("Can't call method on " + it);
+    return it;
+};
+
+
+/***/ }),
+
+/***/ 36698:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineProperty = (__webpack_require__(11154).f);
+var hasOwn = __webpack_require__(58898);
+var wellKnownSymbol = __webpack_require__(47226);
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+module.exports = 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 });
+    }
+};
+
+
+/***/ }),
+
+/***/ 44840:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var shared = __webpack_require__(27962);
+var uid = __webpack_require__(15489);
+var keys = shared('keys');
+module.exports = function (key) {
+    return keys[key] || (keys[key] = uid(key));
+};
+
+
+/***/ }),
+
+/***/ 50662:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var IS_PURE = __webpack_require__(32470);
+var globalThis = __webpack_require__(36749);
+var defineGlobalProperty = __webpack_require__(61486);
+var SHARED = '__core-js_shared__';
+var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
+(store.versions || (store.versions = [])).push({
+    version: '3.38.1',
+    mode: IS_PURE ? 'pure' : 'global',
+    copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
+    license: 'https://github.com/zloirock/core-js/blob/v3.38.1/LICENSE',
+    source: 'https://github.com/zloirock/core-js'
+});
+
+
+/***/ }),
+
+/***/ 27962:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var store = __webpack_require__(50662);
+module.exports = function (key, value) {
+    return store[key] || (store[key] = value || {});
+};
+
+
+/***/ }),
+
+/***/ 48692:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var toIntegerOrInfinity = __webpack_require__(39784);
+var toString = __webpack_require__(67850);
+var requireObjectCoercible = __webpack_require__(7605);
+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;
+    };
+};
+module.exports = {
+    // `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)
+};
+
+
+/***/ }),
+
+/***/ 8464:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/* eslint-disable es/no-symbol -- required for testing */
+var V8_VERSION = __webpack_require__(9696);
+var fails = __webpack_require__(11794);
+var globalThis = __webpack_require__(36749);
+var $String = globalThis.String;
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+module.exports = !!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;
+});
+
+
+/***/ }),
+
+/***/ 67109:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(31944);
+var getBuiltIn = __webpack_require__(93572);
+var wellKnownSymbol = __webpack_require__(47226);
+var defineBuiltIn = __webpack_require__(47941);
+module.exports = function () {
+    var Symbol = getBuiltIn('Symbol');
+    var SymbolPrototype = Symbol && Symbol.prototype;
+    var valueOf = SymbolPrototype && SymbolPrototype.valueOf;
+    var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+    if (SymbolPrototype && !SymbolPrototype[TO_PRIMITIVE]) {
+        // `Symbol.prototype[@@toPrimitive]` method
+        // https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
+        // eslint-disable-next-line no-unused-vars -- required for .length
+        defineBuiltIn(SymbolPrototype, TO_PRIMITIVE, function (hint) {
+            return call(valueOf, this);
+        }, { arity: 1 });
+    }
+};
+
+
+/***/ }),
+
+/***/ 68097:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_SYMBOL = __webpack_require__(8464);
+/* eslint-disable es/no-symbol -- safe */
+module.exports = NATIVE_SYMBOL && !!Symbol['for'] && !!Symbol.keyFor;
+
+
+/***/ }),
+
+/***/ 13619:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toIntegerOrInfinity = __webpack_require__(39784);
+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).
+module.exports = function (index, length) {
+    var integer = toIntegerOrInfinity(index);
+    return integer < 0 ? max(integer + length, 0) : min(integer, length);
+};
+
+
+/***/ }),
+
+/***/ 53324:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+// toObject with fallback for non-array-like ES3 strings
+var IndexedObject = __webpack_require__(21072);
+var requireObjectCoercible = __webpack_require__(7605);
+module.exports = function (it) {
+    return IndexedObject(requireObjectCoercible(it));
+};
+
+
+/***/ }),
+
+/***/ 39784:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var trunc = __webpack_require__(64814);
+// `ToIntegerOrInfinity` abstract operation
+// https://tc39.es/ecma262/#sec-tointegerorinfinity
+module.exports = function (argument) {
+    var number = +argument;
+    // eslint-disable-next-line no-self-compare -- NaN check
+    return number !== number || number === 0 ? 0 : trunc(number);
+};
+
+
+/***/ }),
+
+/***/ 72843:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toIntegerOrInfinity = __webpack_require__(39784);
+var min = Math.min;
+// `ToLength` abstract operation
+// https://tc39.es/ecma262/#sec-tolength
+module.exports = function (argument) {
+    var len = toIntegerOrInfinity(argument);
+    return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+};
+
+
+/***/ }),
+
+/***/ 58860:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var requireObjectCoercible = __webpack_require__(7605);
+var $Object = Object;
+// `ToObject` abstract operation
+// https://tc39.es/ecma262/#sec-toobject
+module.exports = function (argument) {
+    return $Object(requireObjectCoercible(argument));
+};
+
+
+/***/ }),
+
+/***/ 18258:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(31944);
+var isObject = __webpack_require__(56063);
+var isSymbol = __webpack_require__(81264);
+var getMethod = __webpack_require__(17585);
+var ordinaryToPrimitive = __webpack_require__(69775);
+var wellKnownSymbol = __webpack_require__(47226);
+var $TypeError = TypeError;
+var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+// `ToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-toprimitive
+module.exports = 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);
+};
+
+
+/***/ }),
+
+/***/ 92776:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toPrimitive = __webpack_require__(18258);
+var isSymbol = __webpack_require__(81264);
+// `ToPropertyKey` abstract operation
+// https://tc39.es/ecma262/#sec-topropertykey
+module.exports = function (argument) {
+    var key = toPrimitive(argument, 'string');
+    return isSymbol(key) ? key : key + '';
+};
+
+
+/***/ }),
+
+/***/ 46833:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var wellKnownSymbol = __webpack_require__(47226);
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var test = {};
+test[TO_STRING_TAG] = 'z';
+module.exports = String(test) === '[object z]';
+
+
+/***/ }),
+
+/***/ 67850:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var classof = __webpack_require__(12318);
+var $String = String;
+module.exports = function (argument) {
+    if (classof(argument) === 'Symbol')
+        throw new TypeError('Cannot convert a Symbol value to a string');
+    return $String(argument);
+};
+
+
+/***/ }),
+
+/***/ 5174:
+/***/ (function(module) {
+
+
+var $String = String;
+module.exports = function (argument) {
+    try {
+        return $String(argument);
+    }
+    catch (error) {
+        return 'Object';
+    }
+};
+
+
+/***/ }),
+
+/***/ 15489:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(84369);
+var id = 0;
+var postfix = Math.random();
+var toString = uncurryThis(1.0.toString);
+module.exports = function (key) {
+    return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
+};
+
+
+/***/ }),
+
+/***/ 16401:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/* eslint-disable es/no-symbol -- required for testing */
+var NATIVE_SYMBOL = __webpack_require__(8464);
+module.exports = NATIVE_SYMBOL
+    && !Symbol.sham
+    && typeof Symbol.iterator == 'symbol';
+
+
+/***/ }),
+
+/***/ 90739:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(54525);
+var fails = __webpack_require__(11794);
+// V8 ~ Chrome 36-
+// https://bugs.chromium.org/p/v8/issues/detail?id=3334
+module.exports = 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;
+});
+
+
+/***/ }),
+
+/***/ 14041:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var isCallable = __webpack_require__(55468);
+var WeakMap = globalThis.WeakMap;
+module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
+
+
+/***/ }),
+
+/***/ 44604:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var path = __webpack_require__(21504);
+var hasOwn = __webpack_require__(58898);
+var wrappedWellKnownSymbolModule = __webpack_require__(25514);
+var defineProperty = (__webpack_require__(11154).f);
+module.exports = function (NAME) {
+    var Symbol = path.Symbol || (path.Symbol = {});
+    if (!hasOwn(Symbol, NAME))
+        defineProperty(Symbol, NAME, {
+            value: wrappedWellKnownSymbolModule.f(NAME)
+        });
+};
+
+
+/***/ }),
+
+/***/ 25514:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var wellKnownSymbol = __webpack_require__(47226);
+exports.f = wellKnownSymbol;
+
+
+/***/ }),
+
+/***/ 47226:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var shared = __webpack_require__(27962);
+var hasOwn = __webpack_require__(58898);
+var uid = __webpack_require__(15489);
+var NATIVE_SYMBOL = __webpack_require__(8464);
+var USE_SYMBOL_AS_UID = __webpack_require__(16401);
+var Symbol = globalThis.Symbol;
+var WellKnownSymbolsStore = shared('wks');
+var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
+module.exports = function (name) {
+    if (!hasOwn(WellKnownSymbolsStore, name)) {
+        WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
+            ? Symbol[name]
+            : createWellKnownSymbol('Symbol.' + name);
+    }
+    return WellKnownSymbolsStore[name];
+};
+
+
+/***/ }),
+
+/***/ 92059:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var fails = __webpack_require__(11794);
+var isArray = __webpack_require__(96127);
+var isObject = __webpack_require__(56063);
+var toObject = __webpack_require__(58860);
+var lengthOfArrayLike = __webpack_require__(2701);
+var doesNotExceedSafeInteger = __webpack_require__(74098);
+var createProperty = __webpack_require__(44849);
+var arraySpeciesCreate = __webpack_require__(24686);
+var arrayMethodHasSpeciesSupport = __webpack_require__(16074);
+var wellKnownSymbol = __webpack_require__(47226);
+var V8_VERSION = __webpack_require__(9696);
+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);
+            }
+        }
+        A.length = n;
+        return A;
+    }
+});
+
+
+/***/ }),
+
+/***/ 49445:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var $findIndex = (__webpack_require__(84536).findIndex);
+var addToUnscopables = __webpack_require__(1922);
+var FIND_INDEX = 'findIndex';
+var SKIPS_HOLES = true;
+// Shouldn't skip holes
+// eslint-disable-next-line es/no-array-prototype-findindex -- testing
+if (FIND_INDEX in [])
+    Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; });
+// `Array.prototype.findIndex` method
+// https://tc39.es/ecma262/#sec-array.prototype.findindex
+$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
+    findIndex: function findIndex(callbackfn /* , that = undefined */) {
+        return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
+    }
+});
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables(FIND_INDEX);
+
+
+/***/ }),
+
+/***/ 69507:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var from = __webpack_require__(91531);
+var checkCorrectnessOfIteration = __webpack_require__(60947);
+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
+});
+
+
+/***/ }),
+
+/***/ 15159:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var getBuiltIn = __webpack_require__(93572);
+var apply = __webpack_require__(14150);
+var call = __webpack_require__(31944);
+var uncurryThis = __webpack_require__(84369);
+var fails = __webpack_require__(11794);
+var isCallable = __webpack_require__(55468);
+var isSymbol = __webpack_require__(81264);
+var arraySlice = __webpack_require__(85457);
+var getReplacerFunction = __webpack_require__(91918);
+var NATIVE_SYMBOL = __webpack_require__(8464);
+var $String = String;
+var $stringify = getBuiltIn('JSON', 'stringify');
+var exec = uncurryThis(/./.exec);
+var charAt = uncurryThis(''.charAt);
+var charCodeAt = uncurryThis(''.charCodeAt);
+var replace = uncurryThis(''.replace);
+var numberToString = uncurryThis(1.0.toString);
+var tester = /[\uD800-\uDFFF]/g;
+var low = /^[\uD800-\uDBFF]$/;
+var hi = /^[\uDC00-\uDFFF]$/;
+var WRONG_SYMBOLS_CONVERSION = !NATIVE_SYMBOL || fails(function () {
+    var symbol = getBuiltIn('Symbol')('stringify detection');
+    // MS Edge converts symbol values to JSON as {}
+    return $stringify([symbol]) !== '[null]'
+        // WebKit converts symbol values to JSON as null
+        || $stringify({ a: symbol }) !== '{}'
+        // V8 throws on boxed symbols
+        || $stringify(Object(symbol)) !== '{}';
+});
+// https://github.com/tc39/proposal-well-formed-stringify
+var ILL_FORMED_UNICODE = fails(function () {
+    return $stringify('\uDF06\uD834') !== '"\\udf06\\ud834"'
+        || $stringify('\uDEAD') !== '"\\udead"';
+});
+var stringifyWithSymbolsFix = function (it, replacer) {
+    var args = arraySlice(arguments);
+    var $replacer = getReplacerFunction(replacer);
+    if (!isCallable($replacer) && (it === undefined || isSymbol(it)))
+        return; // IE8 returns string on undefined
+    args[1] = function (key, value) {
+        // some old implementations (like WebKit) could pass numbers as keys
+        if (isCallable($replacer))
+            value = call($replacer, this, $String(key), value);
+        if (!isSymbol(value))
+            return value;
+    };
+    return apply($stringify, null, args);
+};
+var fixIllFormed = function (match, offset, string) {
+    var prev = charAt(string, offset - 1);
+    var next = charAt(string, offset + 1);
+    if ((exec(low, match) && !exec(hi, next)) || (exec(hi, match) && !exec(low, prev))) {
+        return '\\u' + numberToString(charCodeAt(match, 0), 16);
+    }
+    return match;
+};
+if ($stringify) {
+    // `JSON.stringify` method
+    // https://tc39.es/ecma262/#sec-json.stringify
+    $({ target: 'JSON', stat: true, arity: 3, forced: WRONG_SYMBOLS_CONVERSION || ILL_FORMED_UNICODE }, {
+        // eslint-disable-next-line no-unused-vars -- required for `.length`
+        stringify: function stringify(it, replacer, space) {
+            var args = arraySlice(arguments);
+            var result = apply(WRONG_SYMBOLS_CONVERSION ? stringifyWithSymbolsFix : $stringify, null, args);
+            return ILL_FORMED_UNICODE && typeof result == 'string' ? replace(result, tester, fixIllFormed) : result;
+        }
+    });
+}
+
+
+/***/ }),
+
+/***/ 57914:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(36749);
+var setToStringTag = __webpack_require__(36698);
+// JSON[@@toStringTag] property
+// https://tc39.es/ecma262/#sec-json-@@tostringtag
+setToStringTag(globalThis.JSON, 'JSON', true);
+
+
+/***/ }),
+
+/***/ 20926:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var setToStringTag = __webpack_require__(36698);
+// Math[@@toStringTag] property
+// https://tc39.es/ecma262/#sec-math-@@tostringtag
+setToStringTag(Math, 'Math', true);
+
+
+/***/ }),
+
+/***/ 43130:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var NATIVE_SYMBOL = __webpack_require__(8464);
+var fails = __webpack_require__(11794);
+var getOwnPropertySymbolsModule = __webpack_require__(89452);
+var toObject = __webpack_require__(58860);
+// V8 ~ Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
+// https://bugs.chromium.org/p/v8/issues/detail?id=3443
+var FORCED = !NATIVE_SYMBOL || fails(function () { getOwnPropertySymbolsModule.f(1); });
+// `Object.getOwnPropertySymbols` method
+// https://tc39.es/ecma262/#sec-object.getownpropertysymbols
+$({ target: 'Object', stat: true, forced: FORCED }, {
+    getOwnPropertySymbols: function getOwnPropertySymbols(it) {
+        var $getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+        return $getOwnPropertySymbols ? $getOwnPropertySymbols(toObject(it)) : [];
+    }
+});
+
+
+/***/ }),
+
+/***/ 7222:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var TO_STRING_TAG_SUPPORT = __webpack_require__(46833);
+var defineBuiltIn = __webpack_require__(47941);
+var toString = __webpack_require__(46724);
+// `Object.prototype.toString` method
+// https://tc39.es/ecma262/#sec-object.prototype.tostring
+if (!TO_STRING_TAG_SUPPORT) {
+    defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });
+}
+
+
+/***/ }),
+
+/***/ 83775:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var globalThis = __webpack_require__(36749);
+var setToStringTag = __webpack_require__(36698);
+$({ global: true }, { Reflect: {} });
+// Reflect[@@toStringTag] property
+// https://tc39.es/ecma262/#sec-reflect-@@tostringtag
+setToStringTag(globalThis.Reflect, 'Reflect', true);
+
+
+/***/ }),
+
+/***/ 95491:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var charAt = (__webpack_require__(48692).charAt);
+var toString = __webpack_require__(67850);
+var InternalStateModule = __webpack_require__(238);
+var defineIterator = __webpack_require__(33649);
+var createIterResultObject = __webpack_require__(11392);
+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);
+});
+
+
+/***/ }),
+
+/***/ 10695:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.asyncIterator` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.asynciterator
+defineWellKnownSymbol('asyncIterator');
+
+
+/***/ }),
+
+/***/ 2624:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var globalThis = __webpack_require__(36749);
+var call = __webpack_require__(31944);
+var uncurryThis = __webpack_require__(84369);
+var IS_PURE = __webpack_require__(32470);
+var DESCRIPTORS = __webpack_require__(54525);
+var NATIVE_SYMBOL = __webpack_require__(8464);
+var fails = __webpack_require__(11794);
+var hasOwn = __webpack_require__(58898);
+var isPrototypeOf = __webpack_require__(67618);
+var anObject = __webpack_require__(79002);
+var toIndexedObject = __webpack_require__(53324);
+var toPropertyKey = __webpack_require__(92776);
+var $toString = __webpack_require__(67850);
+var createPropertyDescriptor = __webpack_require__(72787);
+var nativeObjectCreate = __webpack_require__(52713);
+var objectKeys = __webpack_require__(14769);
+var getOwnPropertyNamesModule = __webpack_require__(17213);
+var getOwnPropertyNamesExternal = __webpack_require__(23701);
+var getOwnPropertySymbolsModule = __webpack_require__(89452);
+var getOwnPropertyDescriptorModule = __webpack_require__(34072);
+var definePropertyModule = __webpack_require__(11154);
+var definePropertiesModule = __webpack_require__(68126);
+var propertyIsEnumerableModule = __webpack_require__(66000);
+var defineBuiltIn = __webpack_require__(47941);
+var defineBuiltInAccessor = __webpack_require__(79093);
+var shared = __webpack_require__(27962);
+var sharedKey = __webpack_require__(44840);
+var hiddenKeys = __webpack_require__(25220);
+var uid = __webpack_require__(15489);
+var wellKnownSymbol = __webpack_require__(47226);
+var wrappedWellKnownSymbolModule = __webpack_require__(25514);
+var defineWellKnownSymbol = __webpack_require__(44604);
+var defineSymbolToPrimitive = __webpack_require__(67109);
+var setToStringTag = __webpack_require__(36698);
+var InternalStateModule = __webpack_require__(238);
+var $forEach = (__webpack_require__(84536).forEach);
+var HIDDEN = sharedKey('hidden');
+var SYMBOL = 'Symbol';
+var PROTOTYPE = 'prototype';
+var setInternalState = InternalStateModule.set;
+var getInternalState = InternalStateModule.getterFor(SYMBOL);
+var ObjectPrototype = Object[PROTOTYPE];
+var $Symbol = globalThis.Symbol;
+var SymbolPrototype = $Symbol && $Symbol[PROTOTYPE];
+var RangeError = globalThis.RangeError;
+var TypeError = globalThis.TypeError;
+var QObject = globalThis.QObject;
+var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+var nativeDefineProperty = definePropertyModule.f;
+var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
+var nativePropertyIsEnumerable = propertyIsEnumerableModule.f;
+var push = uncurryThis([].push);
+var AllSymbols = shared('symbols');
+var ObjectPrototypeSymbols = shared('op-symbols');
+var WellKnownSymbolsStore = shared('wks');
+// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
+var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
+// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
+var fallbackDefineProperty = function (O, P, Attributes) {
+    var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);
+    if (ObjectPrototypeDescriptor)
+        delete ObjectPrototype[P];
+    nativeDefineProperty(O, P, Attributes);
+    if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
+        nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
+    }
+};
+var setSymbolDescriptor = DESCRIPTORS && fails(function () {
+    return nativeObjectCreate(nativeDefineProperty({}, 'a', {
+        get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; }
+    })).a !== 7;
+}) ? fallbackDefineProperty : nativeDefineProperty;
+var wrap = function (tag, description) {
+    var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype);
+    setInternalState(symbol, {
+        type: SYMBOL,
+        tag: tag,
+        description: description
+    });
+    if (!DESCRIPTORS)
+        symbol.description = description;
+    return symbol;
+};
+var $defineProperty = function defineProperty(O, P, Attributes) {
+    if (O === ObjectPrototype)
+        $defineProperty(ObjectPrototypeSymbols, P, Attributes);
+    anObject(O);
+    var key = toPropertyKey(P);
+    anObject(Attributes);
+    if (hasOwn(AllSymbols, key)) {
+        if (!Attributes.enumerable) {
+            if (!hasOwn(O, HIDDEN))
+                nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, nativeObjectCreate(null)));
+            O[HIDDEN][key] = true;
+        }
+        else {
+            if (hasOwn(O, HIDDEN) && O[HIDDEN][key])
+                O[HIDDEN][key] = false;
+            Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) });
+        }
+        return setSymbolDescriptor(O, key, Attributes);
+    }
+    return nativeDefineProperty(O, key, Attributes);
+};
+var $defineProperties = function defineProperties(O, Properties) {
+    anObject(O);
+    var properties = toIndexedObject(Properties);
+    var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));
+    $forEach(keys, function (key) {
+        if (!DESCRIPTORS || call($propertyIsEnumerable, properties, key))
+            $defineProperty(O, key, properties[key]);
+    });
+    return O;
+};
+var $create = function create(O, Properties) {
+    return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);
+};
+var $propertyIsEnumerable = function propertyIsEnumerable(V) {
+    var P = toPropertyKey(V);
+    var enumerable = call(nativePropertyIsEnumerable, this, P);
+    if (this === ObjectPrototype && hasOwn(AllSymbols, P) && !hasOwn(ObjectPrototypeSymbols, P))
+        return false;
+    return enumerable || !hasOwn(this, P) || !hasOwn(AllSymbols, P) || hasOwn(this, HIDDEN) && this[HIDDEN][P]
+        ? enumerable : true;
+};
+var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
+    var it = toIndexedObject(O);
+    var key = toPropertyKey(P);
+    if (it === ObjectPrototype && hasOwn(AllSymbols, key) && !hasOwn(ObjectPrototypeSymbols, key))
+        return;
+    var descriptor = nativeGetOwnPropertyDescriptor(it, key);
+    if (descriptor && hasOwn(AllSymbols, key) && !(hasOwn(it, HIDDEN) && it[HIDDEN][key])) {
+        descriptor.enumerable = true;
+    }
+    return descriptor;
+};
+var $getOwnPropertyNames = function getOwnPropertyNames(O) {
+    var names = nativeGetOwnPropertyNames(toIndexedObject(O));
+    var result = [];
+    $forEach(names, function (key) {
+        if (!hasOwn(AllSymbols, key) && !hasOwn(hiddenKeys, key))
+            push(result, key);
+    });
+    return result;
+};
+var $getOwnPropertySymbols = function (O) {
+    var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
+    var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));
+    var result = [];
+    $forEach(names, function (key) {
+        if (hasOwn(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn(ObjectPrototype, key))) {
+            push(result, AllSymbols[key]);
+        }
+    });
+    return result;
+};
+// `Symbol` constructor
+// https://tc39.es/ecma262/#sec-symbol-constructor
+if (!NATIVE_SYMBOL) {
+    $Symbol = function Symbol() {
+        if (isPrototypeOf(SymbolPrototype, this))
+            throw new TypeError('Symbol is not a constructor');
+        var description = !arguments.length || arguments[0] === undefined ? undefined : $toString(arguments[0]);
+        var tag = uid(description);
+        var setter = function (value) {
+            var $this = this === undefined ? globalThis : this;
+            if ($this === ObjectPrototype)
+                call(setter, ObjectPrototypeSymbols, value);
+            if (hasOwn($this, HIDDEN) && hasOwn($this[HIDDEN], tag))
+                $this[HIDDEN][tag] = false;
+            var descriptor = createPropertyDescriptor(1, value);
+            try {
+                setSymbolDescriptor($this, tag, descriptor);
+            }
+            catch (error) {
+                if (!(error instanceof RangeError))
+                    throw error;
+                fallbackDefineProperty($this, tag, descriptor);
+            }
+        };
+        if (DESCRIPTORS && USE_SETTER)
+            setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });
+        return wrap(tag, description);
+    };
+    SymbolPrototype = $Symbol[PROTOTYPE];
+    defineBuiltIn(SymbolPrototype, 'toString', function toString() {
+        return getInternalState(this).tag;
+    });
+    defineBuiltIn($Symbol, 'withoutSetter', function (description) {
+        return wrap(uid(description), description);
+    });
+    propertyIsEnumerableModule.f = $propertyIsEnumerable;
+    definePropertyModule.f = $defineProperty;
+    definePropertiesModule.f = $defineProperties;
+    getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;
+    getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;
+    getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;
+    wrappedWellKnownSymbolModule.f = function (name) {
+        return wrap(wellKnownSymbol(name), name);
+    };
+    if (DESCRIPTORS) {
+        // https://github.com/tc39/proposal-Symbol-description
+        defineBuiltInAccessor(SymbolPrototype, 'description', {
+            configurable: true,
+            get: function description() {
+                return getInternalState(this).description;
+            }
+        });
+        if (!IS_PURE) {
+            defineBuiltIn(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });
+        }
+    }
+}
+$({ global: true, constructor: true, wrap: true, forced: !NATIVE_SYMBOL, sham: !NATIVE_SYMBOL }, {
+    Symbol: $Symbol
+});
+$forEach(objectKeys(WellKnownSymbolsStore), function (name) {
+    defineWellKnownSymbol(name);
+});
+$({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL }, {
+    useSetter: function () { USE_SETTER = true; },
+    useSimple: function () { USE_SETTER = false; }
+});
+$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, {
+    // `Object.create` method
+    // https://tc39.es/ecma262/#sec-object.create
+    create: $create,
+    // `Object.defineProperty` method
+    // https://tc39.es/ecma262/#sec-object.defineproperty
+    defineProperty: $defineProperty,
+    // `Object.defineProperties` method
+    // https://tc39.es/ecma262/#sec-object.defineproperties
+    defineProperties: $defineProperties,
+    // `Object.getOwnPropertyDescriptor` method
+    // https://tc39.es/ecma262/#sec-object.getownpropertydescriptors
+    getOwnPropertyDescriptor: $getOwnPropertyDescriptor
+});
+$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, {
+    // `Object.getOwnPropertyNames` method
+    // https://tc39.es/ecma262/#sec-object.getownpropertynames
+    getOwnPropertyNames: $getOwnPropertyNames
+});
+// `Symbol.prototype[@@toPrimitive]` method
+// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
+defineSymbolToPrimitive();
+// `Symbol.prototype[@@toStringTag]` property
+// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag
+setToStringTag($Symbol, SYMBOL);
+hiddenKeys[HIDDEN] = true;
+
+
+/***/ }),
+
+/***/ 62630:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+// `Symbol.prototype.description` getter
+// https://tc39.es/ecma262/#sec-symbol.prototype.description
+
+var $ = __webpack_require__(22829);
+var DESCRIPTORS = __webpack_require__(54525);
+var globalThis = __webpack_require__(36749);
+var uncurryThis = __webpack_require__(84369);
+var hasOwn = __webpack_require__(58898);
+var isCallable = __webpack_require__(55468);
+var isPrototypeOf = __webpack_require__(67618);
+var toString = __webpack_require__(67850);
+var defineBuiltInAccessor = __webpack_require__(79093);
+var copyConstructorProperties = __webpack_require__(79041);
+var NativeSymbol = globalThis.Symbol;
+var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
+if (DESCRIPTORS && isCallable(NativeSymbol) && (!('description' in SymbolPrototype) ||
+    // Safari 12 bug
+    NativeSymbol().description !== undefined)) {
+    var EmptyStringDescriptionStore = {};
+    // wrap Symbol constructor for correct work with undefined description
+    var SymbolWrapper = function Symbol() {
+        var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString(arguments[0]);
+        var result = isPrototypeOf(SymbolPrototype, this)
+            // eslint-disable-next-line sonar/inconsistent-function-call -- ok
+            ? new NativeSymbol(description)
+            // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
+            : description === undefined ? NativeSymbol() : NativeSymbol(description);
+        if (description === '')
+            EmptyStringDescriptionStore[result] = true;
+        return result;
+    };
+    copyConstructorProperties(SymbolWrapper, NativeSymbol);
+    SymbolWrapper.prototype = SymbolPrototype;
+    SymbolPrototype.constructor = SymbolWrapper;
+    var NATIVE_SYMBOL = String(NativeSymbol('description detection')) === 'Symbol(description detection)';
+    var thisSymbolValue = uncurryThis(SymbolPrototype.valueOf);
+    var symbolDescriptiveString = uncurryThis(SymbolPrototype.toString);
+    var regexp = /^Symbol\((.*)\)[^)]+$/;
+    var replace = uncurryThis(''.replace);
+    var stringSlice = uncurryThis(''.slice);
+    defineBuiltInAccessor(SymbolPrototype, 'description', {
+        configurable: true,
+        get: function description() {
+            var symbol = thisSymbolValue(this);
+            if (hasOwn(EmptyStringDescriptionStore, symbol))
+                return '';
+            var string = symbolDescriptiveString(symbol);
+            var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, '$1');
+            return desc === '' ? undefined : desc;
+        }
+    });
+    $({ global: true, constructor: true, forced: true }, {
+        Symbol: SymbolWrapper
+    });
+}
+
+
+/***/ }),
+
+/***/ 18323:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var getBuiltIn = __webpack_require__(93572);
+var hasOwn = __webpack_require__(58898);
+var toString = __webpack_require__(67850);
+var shared = __webpack_require__(27962);
+var NATIVE_SYMBOL_REGISTRY = __webpack_require__(68097);
+var StringToSymbolRegistry = shared('string-to-symbol-registry');
+var SymbolToStringRegistry = shared('symbol-to-string-registry');
+// `Symbol.for` method
+// https://tc39.es/ecma262/#sec-symbol.for
+$({ target: 'Symbol', stat: true, forced: !NATIVE_SYMBOL_REGISTRY }, {
+    'for': function (key) {
+        var string = toString(key);
+        if (hasOwn(StringToSymbolRegistry, string))
+            return StringToSymbolRegistry[string];
+        var symbol = getBuiltIn('Symbol')(string);
+        StringToSymbolRegistry[string] = symbol;
+        SymbolToStringRegistry[symbol] = string;
+        return symbol;
+    }
+});
+
+
+/***/ }),
+
+/***/ 4282:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.hasInstance` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.hasinstance
+defineWellKnownSymbol('hasInstance');
+
+
+/***/ }),
+
+/***/ 38163:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.isConcatSpreadable` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.isconcatspreadable
+defineWellKnownSymbol('isConcatSpreadable');
+
+
+/***/ }),
+
+/***/ 86912:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.iterator` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.iterator
+defineWellKnownSymbol('iterator');
+
+
+/***/ }),
+
+/***/ 88598:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+// TODO: Remove this module from `core-js@4` since it's split to modules listed below
+__webpack_require__(2624);
+__webpack_require__(18323);
+__webpack_require__(87397);
+__webpack_require__(15159);
+__webpack_require__(43130);
+
+
+/***/ }),
+
+/***/ 87397:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(22829);
+var hasOwn = __webpack_require__(58898);
+var isSymbol = __webpack_require__(81264);
+var tryToString = __webpack_require__(5174);
+var shared = __webpack_require__(27962);
+var NATIVE_SYMBOL_REGISTRY = __webpack_require__(68097);
+var SymbolToStringRegistry = shared('symbol-to-string-registry');
+// `Symbol.keyFor` method
+// https://tc39.es/ecma262/#sec-symbol.keyfor
+$({ target: 'Symbol', stat: true, forced: !NATIVE_SYMBOL_REGISTRY }, {
+    keyFor: function keyFor(sym) {
+        if (!isSymbol(sym))
+            throw new TypeError(tryToString(sym) + ' is not a symbol');
+        if (hasOwn(SymbolToStringRegistry, sym))
+            return SymbolToStringRegistry[sym];
+    }
+});
+
+
+/***/ }),
+
+/***/ 94811:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.matchAll` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.matchall
+defineWellKnownSymbol('matchAll');
+
+
+/***/ }),
+
+/***/ 1957:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.match` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.match
+defineWellKnownSymbol('match');
+
+
+/***/ }),
+
+/***/ 89580:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.replace` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.replace
+defineWellKnownSymbol('replace');
+
+
+/***/ }),
+
+/***/ 40582:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.search` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.search
+defineWellKnownSymbol('search');
+
+
+/***/ }),
+
+/***/ 80294:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.species` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.species
+defineWellKnownSymbol('species');
+
+
+/***/ }),
+
+/***/ 19644:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.split` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.split
+defineWellKnownSymbol('split');
+
+
+/***/ }),
+
+/***/ 28619:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+var defineSymbolToPrimitive = __webpack_require__(67109);
+// `Symbol.toPrimitive` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.toprimitive
+defineWellKnownSymbol('toPrimitive');
+// `Symbol.prototype[@@toPrimitive]` method
+// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
+defineSymbolToPrimitive();
+
+
+/***/ }),
+
+/***/ 76880:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var getBuiltIn = __webpack_require__(93572);
+var defineWellKnownSymbol = __webpack_require__(44604);
+var setToStringTag = __webpack_require__(36698);
+// `Symbol.toStringTag` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.tostringtag
+defineWellKnownSymbol('toStringTag');
+// `Symbol.prototype[@@toStringTag]` property
+// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag
+setToStringTag(getBuiltIn('Symbol'), 'Symbol');
+
+
+/***/ }),
+
+/***/ 9163:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineWellKnownSymbol = __webpack_require__(44604);
+// `Symbol.unscopables` well-known symbol
+// https://tc39.es/ecma262/#sec-symbol.unscopables
+defineWellKnownSymbol('unscopables');
+
+
+/***/ })
+
+}]);