@vkontakte/videoplayer-shared 1.0.31-dev.2d3fd91.0 → 1.0.31-dev.680271f.0

package/es5.umd.js

@@ -0,0 +1,3112 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VKShared = {}));
+})(this, (function (exports) { 'use strict';
+
+    var VERSION = '1.0.31-dev.680271f.0';
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    var Subscription = /** @class */ (function () {
+        function Subscription() {
+            this.subscriptions = [];
+        }
+        Subscription.prototype.unsubscribe = function () {
+            var subscriptions = this.subscriptions;
+            this.subscriptions = [];
+            subscriptions.forEach(function (it) { return typeof it === 'function' ? it() : it.unsubscribe(); });
+        };
+        Subscription.prototype.add = function (item) {
+            this.subscriptions.push(item);
+            return this;
+        };
+        return Subscription;
+    }());
+
+    var assertNever = function (x) {
+        throw new Error("".concat(x, " is value of unexpected type"));
+    };
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    var checkNever = function (_x) {
+    };
+
+    var noop = function () {
+        /* no op */
+    };
+
+    var Observable = /** @class */ (function () {
+        function Observable(subscribe) {
+            if (subscribe) {
+                this._subscribe = subscribe;
+            }
+        }
+        Observable.prototype.subscribe = function (listener, error) {
+            var _a;
+            var errorEmitter;
+            if (!error) {
+                errorEmitter = { next: noop, error: noop };
+            }
+            else if (typeof error === 'function') {
+                errorEmitter = { next: error, error: noop };
+            }
+            else {
+                errorEmitter = {
+                    next: function (value) { return error.next(value); },
+                    error: function (value) { var _a; return (_a = error.error) === null || _a === void 0 ? void 0 : _a.call(error, value); },
+                };
+            }
+            var emitter = typeof listener === 'function' ? {
+                next: function (value) {
+                    try {
+                        listener(value);
+                    }
+                    catch (e) {
+                        errorEmitter.next(e);
+                    }
+                },
+                error: function (value) { return errorEmitter.next(value); },
+            } : {
+                next: function (value) { return listener.next(value); },
+                error: function (value) { return listener.error ? listener.error(value) : errorEmitter.next(value); },
+            };
+            var unsubscriber;
+            try {
+                unsubscriber = this._subscribe(emitter);
+            }
+            catch (e) {
+                (_a = emitter.error) === null || _a === void 0 ? void 0 : _a.call(emitter, e);
+            }
+            return new Subscription().add(function () {
+                emitter.next = noop;
+                emitter.error = noop;
+                switch (typeof unsubscriber) {
+                    case 'function':
+                        unsubscriber();
+                        return;
+                    case 'object':
+                        unsubscriber.unsubscribe();
+                        return;
+                    case 'undefined':
+                        return;
+                    default:
+                        return assertNever(unsubscriber);
+                }
+            });
+        };
+        Observable.prototype.pipe = function () {
+            var operators = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                operators[_i] = arguments[_i];
+            }
+            return operators.reduce(function (prev, op) { return op(prev); }, this);
+        };
+        Observable.prototype._subscribe = function (_emitter) {
+            /* empty */
+        };
+        return Observable;
+    }());
+
+    var Subject = /** @class */ (function (_super) {
+        __extends(Subject, _super);
+        function Subject() {
+            var _this = _super.call(this) || this;
+            _this.keyCounter = 0;
+            _this.subscribers = new Map();
+            return _this;
+        }
+        Subject.prototype.next = function (value) {
+            this.subscribers.forEach(function (it) { return it.next(value); });
+        };
+        Subject.prototype.error = function (value) {
+            this.subscribers.forEach(function (it) { var _a; return (_a = it.error) === null || _a === void 0 ? void 0 : _a.call(it, value); });
+        };
+        Subject.prototype._subscribe = function (emitter) {
+            var _this = this;
+            var key = this.keyCounter++;
+            this.subscribers.set(key, emitter);
+            return new Subscription().add(function () { return _this.subscribers.delete(key); });
+        };
+        return Subject;
+    }(Observable));
+
+    var Logger = /** @class */ (function () {
+        function Logger() {
+            var _this = this;
+            this.log$ = new Subject();
+            this.logs = [];
+            this.log = function (inputEntry) {
+                var entry = __assign(__assign({}, inputEntry), { timestamp: Date.now() });
+                _this.logs.push(entry);
+                _this.log$.next(entry);
+            };
+            this.getAllLogs = function () { return _this.logs; };
+        }
+        Logger.prototype.createCustomLog = function (transform) {
+            var _this = this;
+            return function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var entry;
+                try {
+                    entry = transform.apply(void 0, __spreadArray([], __read(args), false));
+                }
+                catch (_a) {
+                    entry = {
+                        message: 'error in `createCustomLog`',
+                        component: 'Logger',
+                    };
+                }
+                _this.log(entry);
+            };
+        };
+        Logger.prototype.createComponentLog = function (component) {
+            return this.createCustomLog(function (entry) { return (__assign({ component: component }, entry)); });
+        };
+        return Logger;
+    }());
+
+    function assertNonNullable(value, failMessage) {
+        if (failMessage === void 0) { failMessage = "Assertion \"value is not nullable\" failed"; }
+        if (value === undefined || value === null) {
+            throw new Error(failMessage);
+        }
+    }
+    function assertNullable(value, failMessage) {
+        if (failMessage === void 0) { failMessage = "Assertion \"value is nullable\" failed"; }
+        if (value !== undefined && value !== null) {
+            throw new Error(failMessage);
+        }
+    }
+    function isNonNullable(value) {
+        return typeof value !== 'undefined' && value !== null;
+    }
+    function isNullable(value) {
+        return value === undefined || value === null;
+    }
+
+    function assertNotEmptyArray(value, failMessage) {
+        if (!(value === null || value === void 0 ? void 0 : value.length)) {
+            throw new Error(failMessage);
+        }
+    }
+    function assertEmptyArray(value, failMessage) {
+        if (value === null || value === void 0 ? void 0 : value.length) {
+            throw new Error(failMessage);
+        }
+    }
+
+    var addScript = function (scriptSrc, abortSignal, timeout) { return new Promise(function (resolve, reject) {
+        abortSignal.addEventListener('abort', function () {
+            removeListeners();
+            script.remove();
+        });
+        var onLoadFail = function () {
+            removeListeners();
+            reject();
+        };
+        var onLoadSuccess = function () {
+            removeListeners();
+            resolve();
+        };
+        var removeListeners = function () {
+            failTimeout && clearTimeout(failTimeout);
+            script.removeEventListener('load', onLoadSuccess);
+            script.removeEventListener('error', onLoadFail);
+        };
+        var failTimeout;
+        if (timeout) {
+            failTimeout = window.setTimeout(onLoadFail, timeout);
+        }
+        var script = document.createElement('script');
+        script.addEventListener('load', onLoadSuccess);
+        script.addEventListener('error', onLoadFail);
+        script.src = scriptSrc;
+        document.head.appendChild(script);
+    }); };
+
+    var _a$1;
+    var now = typeof ((_a$1 = window.performance) === null || _a$1 === void 0 ? void 0 : _a$1.now) === 'function' ?
+        function () { return window.performance.now(); } :
+        function () { return Date.now(); };
+
+    // Декоратор оборачивающий async функции в генераторы
+    // В этих async функциях await заменяем на yield, он передаёт контроль этой утилите
+    // Декоратор проверяет состояние сигнала и если тот не абортнут передаёт контроль внутрь функции обратно
+    // Если сигнал абортнут, целевая функция останавливается на точке вызова yield и не продолжает исполнение
+    // Таким образом её можно уничтожать не боясь что какой-то асинхронный код выстрелит после уничтожения
+    var abortable = function (signal, createGenerator) { return function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        return __awaiter(void 0, void 0, void 0, function () {
+            var generator, done, value, result;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        generator = createGenerator.apply(void 0, __spreadArray([], __read(params), false));
+                        done = signal.aborted;
+                        value = undefined;
+                        _b.label = 1;
+                    case 1:
+                        if (!(!done && !signal.aborted)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, generator.next(value)];
+                    case 2:
+                        result = _b.sent();
+                        done = (_a = result.done) !== null && _a !== void 0 ? _a : false;
+                        value = result.value;
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/, value];
+                }
+            });
+        });
+    }; };
+
+    exports.CurrentClientBrowser = void 0;
+    (function (CurrentClientBrowser) {
+        CurrentClientBrowser["Unknown"] = "Unknown";
+        CurrentClientBrowser["Yandex"] = "Yandex";
+        CurrentClientBrowser["Chrome"] = "Chrome";
+        CurrentClientBrowser["Chromium"] = "Chromium";
+        CurrentClientBrowser["Firefox"] = "Firefox";
+        CurrentClientBrowser["Safari"] = "Safari";
+        CurrentClientBrowser["Opera"] = "Opera";
+        CurrentClientBrowser["Edge"] = "Edge";
+        CurrentClientBrowser["Rest"] = "Rest";
+    })(exports.CurrentClientBrowser || (exports.CurrentClientBrowser = {}));
+    exports.CurrentClientDevice = void 0;
+    (function (CurrentClientDevice) {
+        CurrentClientDevice["Unknown"] = "Unknown";
+        CurrentClientDevice["Android"] = "Android";
+        CurrentClientDevice["iPhone"] = "iPhone";
+        CurrentClientDevice["iPad"] = "iPad";
+        CurrentClientDevice["iPod"] = "iPod";
+        CurrentClientDevice["RestMobile"] = "RestMobile";
+        CurrentClientDevice["Mac"] = "Mac";
+        CurrentClientDevice["Desktop"] = "Desktop";
+    })(exports.CurrentClientDevice || (exports.CurrentClientDevice = {}));
+    var getCurrentBrowser = function () {
+        var userAgent = window.navigator.userAgent;
+        var isYandex = /yabrowser/i.test(userAgent) ? exports.CurrentClientBrowser.Yandex : undefined;
+        var isChrome = /chrome|crios/i.test(userAgent) ? exports.CurrentClientBrowser.Chrome : undefined;
+        var isChromium = /chromium/i.test(userAgent) ? exports.CurrentClientBrowser.Chromium : undefined;
+        var isFirefox = /firefox|fxios/i.test(userAgent) ? exports.CurrentClientBrowser.Firefox : undefined;
+        var isSafari = /webkit|safari|khtml/i.test(userAgent) ? exports.CurrentClientBrowser.Safari : undefined;
+        var isOpera = /opr\//i.test(userAgent) ? exports.CurrentClientBrowser.Opera : undefined;
+        var isEdge = /edg/i.test(userAgent) ? exports.CurrentClientBrowser.Edge : undefined;
+        var isAndroid = /android/i.test(userAgent) ? exports.CurrentClientDevice.Android : undefined;
+        var isiPhone = /iphone/i.test(userAgent) ? exports.CurrentClientDevice.iPhone : undefined;
+        var isiPad = /ipad/i.test(userAgent) ? exports.CurrentClientDevice.iPad : undefined;
+        var isiPod = /ipod/i.test(userAgent) ? exports.CurrentClientDevice.iPod : undefined;
+        var isMac = /mac/i.test(userAgent) ? exports.CurrentClientDevice.Mac : undefined;
+        var isRestMobile = /webOS|BlackBerry|IEMobile|Opera Mini/i.test(userAgent) ? exports.CurrentClientDevice.RestMobile : undefined;
+        // Порядок браузеров важен для определения!
+        return {
+            browser: isYandex || isFirefox || isOpera || isEdge || isChrome || isChromium || isSafari || exports.CurrentClientBrowser.Rest,
+            device: isAndroid || isiPhone || isiPad || isiPod || isRestMobile || isMac || exports.CurrentClientDevice.Desktop,
+        };
+    };
+    // флаг нужен для того, чтобы проверить, включено ли у iOS-устройства полноразмерное открытие сайтов
+    var isIOS = function (checkForceDesktop) {
+        if (checkForceDesktop === void 0) { checkForceDesktop = false; }
+        var iosDevices = [exports.CurrentClientDevice.iPhone, exports.CurrentClientDevice.iPad, exports.CurrentClientDevice.iPod];
+        var isMobile = iosDevices.includes(getCurrentBrowser().device);
+        if (!checkForceDesktop) {
+            return isMobile;
+        }
+        var _a = window.navigator, userAgent = _a.userAgent, maxTouchPoints = _a.maxTouchPoints;
+        return Boolean(isMobile || /macintosh/i.test(userAgent) && maxTouchPoints > 0);
+    };
+    var getIOSVersion = function () {
+        var userAgent = window.navigator.userAgent;
+        var iosVersionMatch = userAgent.match(/Version\/(\d+(\.\d+)?)/i);
+        if (!iosVersionMatch) {
+            return null;
+        }
+        var versionString = iosVersionMatch[1];
+        var versionNumber = parseFloat(versionString);
+        if (isNaN(versionNumber)) {
+            return null;
+        }
+        return versionNumber;
+    };
+    var isMacLike = function () { return [exports.CurrentClientDevice.Mac, exports.CurrentClientDevice.iPhone, exports.CurrentClientDevice.iPad, exports.CurrentClientDevice.iPod].includes(getCurrentBrowser().device); };
+
+    var getExponentialDelay = function (errorsCount, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.start, start = _c === void 0 ? 0 : _c, _d = _b.factor, factor = _d === void 0 ? 2 : _d, _e = _b.max, max = _e === void 0 ? Infinity : _e, _f = _b.min, min = _f === void 0 ? start : _f, _g = _b.random, random = _g === void 0 ? 0 : _g;
+        var delay = start;
+        delay *= Math.pow(factor, errorsCount);
+        delay *= 1 + (Math.random() * random * 2 - random);
+        delay = Math.round(delay);
+        delay = Math.min(delay, max);
+        delay = Math.max(delay, min);
+        return delay;
+    };
+
+    var Storage;
+    (function (Storage) {
+        Storage[Storage["LOCAL_STORAGE"] = 0] = "LOCAL_STORAGE";
+        Storage[Storage["SESSION_STORAGE"] = 1] = "SESSION_STORAGE";
+        Storage[Storage["RUNTIME"] = 2] = "RUNTIME";
+    })(Storage || (Storage = {}));
+    var runtimeStorage;
+    var availableStorage;
+    var key = "vk-videoplayer-dummy-key-".concat(Math.random());
+    var getAvailable = function () {
+        if (availableStorage !== undefined) {
+            return availableStorage;
+        }
+        try {
+            localStorage.setItem(key, 'test');
+            localStorage.removeItem(key);
+            availableStorage = Storage.LOCAL_STORAGE;
+        }
+        catch (error) {
+            if (error instanceof DOMException || error instanceof TypeError) {
+                try {
+                    sessionStorage.getItem(key);
+                    availableStorage = Storage.SESSION_STORAGE;
+                }
+                catch (error) {
+                    if (error instanceof DOMException || error instanceof TypeError) {
+                        availableStorage = Storage.RUNTIME;
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+        if (availableStorage === Storage.RUNTIME) {
+            runtimeStorage = new Map();
+        }
+        return availableStorage;
+    };
+    var isPersistent = function () { return getAvailable() === Storage.LOCAL_STORAGE; };
+    var get$1 = function (key) {
+        var _a, _b;
+        var storage = getAvailable();
+        switch (storage) {
+            case Storage.LOCAL_STORAGE:
+                return (_a = localStorage.getItem(key)) !== null && _a !== void 0 ? _a : undefined;
+            case Storage.SESSION_STORAGE:
+                return (_b = sessionStorage.getItem(key)) !== null && _b !== void 0 ? _b : undefined;
+            case Storage.RUNTIME:
+                return runtimeStorage === null || runtimeStorage === void 0 ? void 0 : runtimeStorage.get(key);
+            default:
+                assertNever(storage);
+        }
+    };
+    var set$1 = function (key, value) {
+        var storage = getAvailable();
+        switch (storage) {
+            case Storage.LOCAL_STORAGE:
+                try {
+                    localStorage.setItem(key, value);
+                }
+                catch (error) {
+                    if (error instanceof DOMException) {
+                        console.error(error); // eslint-disable-line no-console
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                break;
+            case Storage.SESSION_STORAGE:
+                try {
+                    sessionStorage.setItem(key, value);
+                }
+                catch (error) {
+                    if (error instanceof DOMException) {
+                        console.error(error); // eslint-disable-line no-console
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                break;
+            case Storage.RUNTIME:
+                return void (runtimeStorage === null || runtimeStorage === void 0 ? void 0 : runtimeStorage.set(key, value));
+            default:
+                assertNever(storage);
+        }
+    };
+    var has$1 = function (key) {
+        var _a;
+        var storage = getAvailable();
+        switch (storage) {
+            case Storage.LOCAL_STORAGE:
+                return key in localStorage;
+            case Storage.SESSION_STORAGE:
+                return key in sessionStorage;
+            case Storage.RUNTIME:
+                return (_a = runtimeStorage === null || runtimeStorage === void 0 ? void 0 : runtimeStorage.has(key)) !== null && _a !== void 0 ? _a : false;
+            default:
+                assertNever(storage);
+                return false;
+        }
+    };
+    var remove = function (key) {
+        var storage = getAvailable();
+        switch (storage) {
+            case Storage.LOCAL_STORAGE:
+                return localStorage.removeItem(key);
+            case Storage.SESSION_STORAGE:
+                return sessionStorage.removeItem(key);
+            case Storage.RUNTIME:
+                return void (runtimeStorage === null || runtimeStorage === void 0 ? void 0 : runtimeStorage.delete(key));
+            default:
+                assertNever(storage);
+        }
+    };
+    var clear = function () {
+        var storage = getAvailable();
+        switch (storage) {
+            case Storage.LOCAL_STORAGE:
+                return localStorage.clear();
+            case Storage.SESSION_STORAGE:
+                return sessionStorage.clear();
+            case Storage.RUNTIME:
+                return runtimeStorage === null || runtimeStorage === void 0 ? void 0 : runtimeStorage.clear();
+            default:
+                assertNever(storage);
+        }
+    };
+
+    var iframeSafeStorage = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        clear: clear,
+        get: get$1,
+        has: has$1,
+        isPersistent: isPersistent,
+        remove: remove,
+        set: set$1
+    });
+
+    exports.VideoQuality = void 0;
+    (function (VideoQuality) {
+        // Служебный тип качества когда оно не известно (не путать с авто)
+        VideoQuality["INVARIANT"] = "Invariant quality";
+        VideoQuality["Q_144P"] = "144p";
+        VideoQuality["Q_240P"] = "240p";
+        VideoQuality["Q_360P"] = "360p";
+        VideoQuality["Q_480P"] = "480p";
+        VideoQuality["Q_720P"] = "720p";
+        VideoQuality["Q_1080P"] = "1080p";
+        VideoQuality["Q_1440P"] = "1440p";
+        VideoQuality["Q_2160P"] = "2160p";
+        VideoQuality["Q_4320P"] = "4320p";
+    })(exports.VideoQuality || (exports.VideoQuality = {}));
+
+    var _a;
+    var videoQualitiesSizes = (_a = {},
+        _a[exports.VideoQuality.Q_144P] = { width: 256, height: 144 },
+        _a[exports.VideoQuality.Q_240P] = { width: 428, height: 240 },
+        _a[exports.VideoQuality.Q_360P] = { width: 640, height: 360 },
+        _a[exports.VideoQuality.Q_480P] = { width: 856, height: 480 },
+        _a[exports.VideoQuality.Q_720P] = { width: 1280, height: 720 },
+        _a[exports.VideoQuality.Q_1080P] = { width: 1920, height: 1080 },
+        _a[exports.VideoQuality.Q_1440P] = { width: 2560, height: 1440 },
+        _a[exports.VideoQuality.Q_2160P] = { width: 3840, height: 2160 },
+        _a[exports.VideoQuality.Q_4320P] = { width: 7680, height: 4320 },
+        _a);
+    var isHigher = function (a, b) { return videoQualitiesSizes[a].height > videoQualitiesSizes[b].height; };
+    var isHigherOrEqual = function (a, b) { return videoQualitiesSizes[a].height >= videoQualitiesSizes[b].height; };
+    var isLower = function (a, b) { return videoQualitiesSizes[a].height < videoQualitiesSizes[b].height; };
+    var isLowerOrEqual = function (a, b) { return videoQualitiesSizes[a].height <= videoQualitiesSizes[b].height; };
+    var getHighestQuality = function (qualities) {
+        return qualities.sort(function (a, b) {
+            if (a === b) {
+                return 0;
+            }
+            if (a === exports.VideoQuality.INVARIANT) {
+                return 1;
+            }
+            if (b === exports.VideoQuality.INVARIANT) {
+                return -1;
+            }
+            return isLower(a, b) ? 1 : -1;
+        })[0];
+    };
+    var allExactAscending = Object.keys(videoQualitiesSizes).sort(function (a, b) { return isLower(a, b) ? -1 : 1; });
+    /**
+     * Выбирает качество, наиболее близкое к указанной высоте кадра, но не менее её.
+     * @param tolerance позволяет выбрать качество менее заданной высоты на величину погрешности (в процентах)
+     */
+    var videoHeightToQuality = function (height, tolerance) {
+        if (tolerance === void 0) { tolerance = 0.02; }
+        var qualities = __spreadArray([], __read(allExactAscending), false);
+        return qualities.find(function (quality) {
+            return videoQualitiesSizes[quality].height * (1 + tolerance) >= height;
+        });
+    };
+    /**
+     * Выбирает качество описывающее заданные размеры видео потока, т.е. не меньше его.
+     */
+    var videoSizeToQuality = function (_a) {
+        var width = _a.width, height = _a.height;
+        var min = Math.min(width, height);
+        var max = Math.max(width, height);
+        return allExactAscending.find(function (testQuality) {
+            var testSize = videoQualitiesSizes[testQuality];
+            return testSize.width >= max &&
+                testSize.height >= min;
+        });
+    };
+    var videoQualityToHeight = function (quality) { return videoQualitiesSizes[quality].height; };
+    var isInvariantQuality = function (quality) {
+        return quality === exports.VideoQuality.INVARIANT;
+    };
+    var areQualitiesExact = function (qualities) {
+        return qualities.every(function (q) { return !isInvariantQuality(q); });
+    };
+    function assertQualityIsExact(quality) {
+        if (isInvariantQuality(quality)) {
+            throw new Error('Expected exact quality');
+        }
+    }
+
+    var fillWithDefault = function (partial, defaultConfig) {
+        var e_1, _a;
+        var fullConfig = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
+        try {
+            for (var _b = __values(Object.keys(defaultConfig)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var topLevelKey = _c.value;
+                var defaultValue = defaultConfig[topLevelKey];
+                var givenValue = partial[topLevelKey];
+                if (Array.isArray(defaultValue) && Array.isArray(givenValue)) {
+                    fullConfig[topLevelKey] = givenValue;
+                }
+                else if (typeof defaultValue === 'object' && typeof givenValue === 'object') {
+                    fullConfig[topLevelKey] = fillWithDefault(givenValue, defaultValue);
+                }
+                else {
+                    fullConfig[topLevelKey] = topLevelKey in partial ? givenValue : defaultValue;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return fullConfig;
+    };
+
+    var ValueSubject = /** @class */ (function (_super) {
+        __extends(ValueSubject, _super);
+        function ValueSubject(initialValue) {
+            var _this = _super.call(this) || this;
+            _this.value = initialValue;
+            return _this;
+        }
+        ValueSubject.prototype.next = function (value) {
+            _super.prototype.next.call(this, this.value = value);
+        };
+        ValueSubject.prototype.error = function (value) {
+            _super.prototype.error.call(this, this.value = value);
+        };
+        ValueSubject.prototype.getValue = function () {
+            return this.value;
+        };
+        ValueSubject.prototype._subscribe = function (emitter) {
+            var result = _super.prototype._subscribe.call(this, emitter);
+            emitter.next(this.value);
+            return result;
+        };
+        return ValueSubject;
+    }(Subject));
+
+    function combine(observables) {
+        return new Observable(function (emitter) {
+            var values = {};
+            var missingValuesCount = Object.keys(observables).length;
+            var createKeyListener = function (key) { return function (value) {
+                if (!(key in values)) {
+                    missingValuesCount--;
+                }
+                values[key] = value;
+                if (missingValuesCount === 0) {
+                    emitter.next(values);
+                }
+            }; };
+            return Object.entries(observables).reduce(function (subscription, _a) {
+                var _b = __read(_a, 2), key = _b[0], observable = _b[1];
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return subscription.add(observable.subscribe(createKeyListener(key)));
+            }, new Subscription());
+        });
+    }
+
+    /**
+     *  Создаёт Observable, в который попадают все события исходных Observable (синхронно в момент возникновения)
+     */
+    function merge() {
+        var observables = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            observables[_i] = arguments[_i];
+        }
+        return new Observable(function (emitter) {
+            return observables.reduce(function (subscription, it) { return subscription.add(it.subscribe(emitter)); }, new Subscription());
+        });
+    }
+
+    var timeout = (function (time) {
+        return new Observable(function (emitter) {
+            var id = window.setTimeout(function () {
+                try {
+                    emitter.next();
+                }
+                catch (e) {
+                    if (emitter.error) {
+                        emitter.error(e);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }, time);
+            return function () { return window.clearTimeout(id); };
+        });
+    });
+
+    var interval = (function (time) {
+        return new Observable(function (emitter) {
+            var id = window.setInterval(function () { return emitter.next(); }, time);
+            return function () { return window.clearInterval(id); };
+        });
+    });
+
+    var observableFrom = (function (values) {
+        return new Observable(function (emitter) {
+            values.forEach(function (it) { return emitter.next(it); });
+        });
+    });
+
+    var fromEvent = (function (target, eventName) {
+        return new Observable(function (emitter) {
+            var listener = function (e) { return emitter.next(e); }; // eslint-disable-line @typescript-eslint/no-explicit-any
+            target.addEventListener(eventName, listener);
+            return function () { return target.removeEventListener(eventName, listener); };
+        });
+    });
+
+    function buffer(size) {
+        return function (o) {
+            return new Observable(function (emitter) { return o.subscribe(new BufferEmitter(emitter, size)); });
+        };
+    }
+    var BufferEmitter = /** @class */ (function () {
+        function BufferEmitter(destination, size) {
+            this.destination = destination;
+            this.size = size;
+            this.lastValues = [];
+        }
+        BufferEmitter.prototype.next = function (value) {
+            if (this.lastValues.length === this.size) {
+                this.lastValues.shift();
+            }
+            this.lastValues.push(value);
+            this.destination.next(this.lastValues);
+        };
+        BufferEmitter.prototype.error = function (e) {
+            var _a, _b;
+            (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+        };
+        return BufferEmitter;
+    }());
+
+    var defaultConfig$1 = {
+        leading: false,
+        trailing: true,
+    };
+    function debounce(time, config) {
+        if (config === void 0) { config = defaultConfig$1; }
+        return function (o) {
+            return new Observable(function (emitter) { return o.subscribe(new DebounceEmitter(emitter, time, config)); });
+        };
+    }
+    var DebounceEmitter = /** @class */ (function () {
+        function DebounceEmitter(destination, time, config) {
+            this.destination = destination;
+            this.time = time;
+            this.config = config;
+        }
+        DebounceEmitter.prototype.next = function (value) {
+            var _this = this;
+            this.lastValue = value;
+            if (isNonNullable(this.timeout)) {
+                window.clearTimeout(this.timeout);
+            }
+            else if (this.config.leading) {
+                this.destination.next(value);
+            }
+            this.timeout = window.setTimeout(function () {
+                if (_this.config.trailing) {
+                    try {
+                        _this.destination.next(_this.lastValue); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    }
+                    catch (e) {
+                        if (_this.destination.error) {
+                            _this.destination.error(e);
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                _this.timeout = undefined;
+            }, this.time);
+        };
+        DebounceEmitter.prototype.error = function (e) {
+            var _a, _b;
+            (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+        };
+        return DebounceEmitter;
+    }());
+
+    var defaultConfig = {
+        leading: true,
+        trailing: false,
+    };
+    function throttle(time, config) {
+        if (config === void 0) { config = defaultConfig; }
+        return function (o) {
+            return new Observable(function (emitter) { return o.subscribe(new ThrottleEmitter(emitter, time, config)); });
+        };
+    }
+    var ThrottleEmitter = /** @class */ (function () {
+        function ThrottleEmitter(destination, time, config) {
+            this.destination = destination;
+            this.time = time;
+            this.config = config;
+        }
+        ThrottleEmitter.prototype.next = function (value) {
+            var _this = this;
+            this.lastValue = value;
+            if (isNullable(this.timeout)) {
+                if (this.config.leading) {
+                    this.destination.next(value);
+                }
+                this.timeout = window.setTimeout(function () {
+                    if (_this.config.trailing) {
+                        _this.destination.next(_this.lastValue); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                    }
+                    _this.timeout = undefined;
+                }, this.time);
+            }
+        };
+        ThrottleEmitter.prototype.error = function (e) {
+            var _a, _b;
+            (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+        };
+        return ThrottleEmitter;
+    }());
+
+    /**
+     *  Пропускает только те события, которые удовлетворяют предикату
+     */
+    function filter(predicate) {
+        return function (o) { return new Observable(function (emitter) { return o.subscribe(new FilterEmitter(emitter, predicate)); }); };
+    }
+    var FilterEmitter = /** @class */ (function () {
+        function FilterEmitter(destination, predicate) {
+            this.destination = destination;
+            this.predicate = predicate;
+        }
+        FilterEmitter.prototype.next = function (value) {
+            var suitable;
+            try {
+                suitable = this.predicate(value);
+            }
+            catch (e) {
+                this.error(e);
+                throw e;
+            }
+            if (suitable) {
+                this.destination.next(value);
+            }
+        };
+        FilterEmitter.prototype.error = function (e) {
+            var _a, _b;
+            (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+        };
+        return FilterEmitter;
+    }());
+
+    /**
+     * Пропускает только события, содержащие значения, отличные от предыдущего
+     */
+    function filterChanged(equal) {
+        if (equal === void 0) { equal = function (a, b) { return a === b; }; }
+        return function (o) { return new Observable(function (emitter) { return o.subscribe(new FilterChangedEmitter(emitter, equal)); }); };
+    }
+    var NO_VALUE = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
+    var FilterChangedEmitter = /** @class */ (function () {
+        function FilterChangedEmitter(destination, predicate) {
+            this.destination = destination;
+            this.predicate = predicate;
+            this.lastValue = NO_VALUE;
+        }
+        FilterChangedEmitter.prototype.next = function (value) {
+            var changed;
+            try {
+                changed = this.lastValue === NO_VALUE || !this.predicate(this.lastValue, value);
+                this.lastValue = value;
+            }
+            catch (e) {
+                this.error(e);
+                throw e;
+            }
+            if (changed) {
+                this.destination.next(value);
+            }
+        };
+        FilterChangedEmitter.prototype.error = function (e) {
+            var _a, _b;
+            (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+        };
+        return FilterChangedEmitter;
+    }());
+
+    function map(mapper) {
+        return function (o) { return new Observable(function (emitter) { return o.subscribe(new MapEmitter$1(emitter, mapper)); }); };
+    }
+    var MapEmitter$1 = /** @class */ (function () {
+        function MapEmitter(destination, mapper) {
+            this.destination = destination;
+            this.mapper = mapper;
+        }
+        MapEmitter.prototype.next = function (value) {
+            var result;
+            try {
+                result = this.mapper(value);
+            }
+            catch (e) {
+                this.error(e);
+                throw e;
+            }
+            this.destination.next(result);
+        };
+        MapEmitter.prototype.error = function (value) {
+            var _a, _b;
+            (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+        };
+        return MapEmitter;
+    }());
+
+    function mapTo(value) {
+        return map(function () { return value; });
+    }
+
+    /**
+     *  Отписывается от исходного потока после получения первого события.
+     */
+    function once() {
+        return function (o) {
+            return new Observable(function (emitter) {
+                var eventFired = false;
+                var subscriptionReady = false;
+                var subscription = o.subscribe(function (event) {
+                    if (!eventFired) {
+                        eventFired = true;
+                        emitter.next(event);
+                    }
+                    if (subscriptionReady) {
+                        subscription.unsubscribe();
+                    }
+                }, function (error) {
+                    var _a;
+                    eventFired = true;
+                    (_a = emitter.error) === null || _a === void 0 ? void 0 : _a.call(emitter, error);
+                    if (subscriptionReady) {
+                        subscription.unsubscribe();
+                    }
+                });
+                subscriptionReady = true;
+                if (eventFired) {
+                    subscription.unsubscribe();
+                }
+                return subscription;
+            });
+        };
+    }
+
+    function pairwise() {
+        return function (o) { return new Observable(function (emitter) { return o.subscribe(new PairwiseEmitter(emitter)); }); };
+    }
+    var PairwiseEmitter = /** @class */ (function () {
+        function PairwiseEmitter(destination) {
+            this.destination = destination;
+            this.hasLast = false;
+        }
+        PairwiseEmitter.prototype.next = function (value) {
+            var last = this.last;
+            this.last = value;
+            if (!this.hasLast) {
+                this.hasLast = true;
+                return;
+            }
+            this.destination.next([last, value]); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+        };
+        PairwiseEmitter.prototype.error = function (value) {
+            var _a, _b;
+            (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+        };
+        return PairwiseEmitter;
+    }());
+
+    function tap(effect) {
+        return function (o) { return new Observable(function (emitter) { return o.subscribe(new MapEmitter(emitter, effect)); }); };
+    }
+    var MapEmitter = /** @class */ (function () {
+        function MapEmitter(destination, effect) {
+            this.destination = destination;
+            this.effect = effect;
+        }
+        MapEmitter.prototype.next = function (value) {
+            try {
+                this.effect(value);
+            }
+            catch (e) {
+                this.error(e);
+                throw e;
+            }
+            this.destination.next(value);
+        };
+        MapEmitter.prototype.error = function (value) {
+            var _a, _b;
+            (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+        };
+        return MapEmitter;
+    }());
+
+    exports.ErrorCategory = void 0;
+    (function (ErrorCategory) {
+        ErrorCategory["NETWORK"] = "network";
+        ErrorCategory["VIDEO_PIPELINE"] = "video_pipeline";
+        ErrorCategory["EXTERNAL_API"] = "external_api";
+        ErrorCategory["PARSER"] = "parser";
+        ErrorCategory["DOM"] = "dom";
+        ErrorCategory["WTF"] = "wtf";
+    })(exports.ErrorCategory || (exports.ErrorCategory = {}));
+
+    function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+    function _possibleConstructorReturn(self, call) { if (call && (_typeof$8(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+    function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+    function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+    function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+    function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+    function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+    function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+    function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+    function _typeof$8(o) { "@babel/helpers - typeof"; return _typeof$8 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$8(o); }
+    function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+    function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+    function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+    function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof$8(i) ? i : String(i); }
+    function _toPrimitive(t, r) { if ("object" != _typeof$8(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof$8(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+    var Emitter = /*#__PURE__*/function () {
+      function Emitter() {
+        _classCallCheck(this, Emitter);
+        Object.defineProperty(this, 'listeners', {
+          value: {},
+          writable: true,
+          configurable: true
+        });
+      }
+      _createClass(Emitter, [{
+        key: "addEventListener",
+        value: function addEventListener(type, callback, options) {
+          if (!(type in this.listeners)) {
+            this.listeners[type] = [];
+          }
+          this.listeners[type].push({
+            callback: callback,
+            options: options
+          });
+        }
+      }, {
+        key: "removeEventListener",
+        value: function removeEventListener(type, callback) {
+          if (!(type in this.listeners)) {
+            return;
+          }
+          var stack = this.listeners[type];
+          for (var i = 0, l = stack.length; i < l; i++) {
+            if (stack[i].callback === callback) {
+              stack.splice(i, 1);
+              return;
+            }
+          }
+        }
+      }, {
+        key: "dispatchEvent",
+        value: function dispatchEvent(event) {
+          var _this = this;
+          if (!(event.type in this.listeners)) {
+            return;
+          }
+          var stack = this.listeners[event.type];
+          var stackToCall = stack.slice();
+          var _loop = function _loop() {
+            var listener = stackToCall[i];
+            try {
+              listener.callback.call(_this, event);
+            } catch (e) {
+              Promise.resolve().then(function () {
+                throw e;
+              });
+            }
+            if (listener.options && listener.options.once) {
+              _this.removeEventListener(event.type, listener.callback);
+            }
+          };
+          for (var i = 0, l = stackToCall.length; i < l; i++) {
+            _loop();
+          }
+          return !event.defaultPrevented;
+        }
+      }]);
+      return Emitter;
+    }();
+    var AbortSignal = /*#__PURE__*/function (_Emitter) {
+      _inherits(AbortSignal, _Emitter);
+      function AbortSignal() {
+        var _this2;
+        _classCallCheck(this, AbortSignal);
+        _this2 = _callSuper(this, AbortSignal);
+        // Some versions of babel does not transpile super() correctly for IE <= 10, if the parent
+        // constructor has failed to run, then "this.listeners" will still be undefined and then we call
+        // the parent constructor directly instead as a workaround. For general details, see babel bug:
+        // https://github.com/babel/babel/issues/3041
+        // This hack was added as a fix for the issue described here:
+        // https://github.com/Financial-Times/polyfill-library/pull/59#issuecomment-477558042
+        if (!_this2.listeners) {
+          Emitter.call(_assertThisInitialized(_this2));
+        }
+
+        // Compared to assignment, Object.defineProperty makes properties non-enumerable by default and
+        // we want Object.keys(new AbortController().signal) to be [] for compat with the native impl
+        Object.defineProperty(_assertThisInitialized(_this2), 'aborted', {
+          value: false,
+          writable: true,
+          configurable: true
+        });
+        Object.defineProperty(_assertThisInitialized(_this2), 'onabort', {
+          value: null,
+          writable: true,
+          configurable: true
+        });
+        Object.defineProperty(_assertThisInitialized(_this2), 'reason', {
+          value: undefined,
+          writable: true,
+          configurable: true
+        });
+        return _this2;
+      }
+      _createClass(AbortSignal, [{
+        key: "toString",
+        value: function toString() {
+          return '[object AbortSignal]';
+        }
+      }, {
+        key: "dispatchEvent",
+        value: function dispatchEvent(event) {
+          if (event.type === 'abort') {
+            this.aborted = true;
+            if (typeof this.onabort === 'function') {
+              this.onabort.call(this, event);
+            }
+          }
+          _get(_getPrototypeOf(AbortSignal.prototype), "dispatchEvent", this).call(this, event);
+        }
+      }]);
+      return AbortSignal;
+    }(Emitter);
+    var AbortController = /*#__PURE__*/function () {
+      function AbortController() {
+        _classCallCheck(this, AbortController);
+        // Compared to assignment, Object.defineProperty makes properties non-enumerable by default and
+        // we want Object.keys(new AbortController()) to be [] for compat with the native impl
+        Object.defineProperty(this, 'signal', {
+          value: new AbortSignal(),
+          writable: true,
+          configurable: true
+        });
+      }
+      _createClass(AbortController, [{
+        key: "abort",
+        value: function abort(reason) {
+          var event;
+          try {
+            event = new Event('abort');
+          } catch (e) {
+            if (typeof document !== 'undefined') {
+              if (!document.createEvent) {
+                // For Internet Explorer 8:
+                event = document.createEventObject();
+                event.type = 'abort';
+              } else {
+                // For Internet Explorer 11:
+                event = document.createEvent('Event');
+                event.initEvent('abort', false, false);
+              }
+            } else {
+              // Fallback where document isn't available:
+              event = {
+                type: 'abort',
+                bubbles: false,
+                cancelable: false
+              };
+            }
+          }
+          var signalReason = reason;
+          if (signalReason === undefined) {
+            if (typeof document === 'undefined') {
+              signalReason = new Error('This operation was aborted');
+              signalReason.name = 'AbortError';
+            } else {
+              try {
+                signalReason = new DOMException('signal is aborted without reason');
+              } catch (err) {
+                // IE 11 does not support calling the DOMException constructor, use a
+                // regular error object on it instead.
+                signalReason = new Error('This operation was aborted');
+                signalReason.name = 'AbortError';
+              }
+            }
+          }
+          this.signal.reason = signalReason;
+          this.signal.dispatchEvent(event);
+        }
+      }, {
+        key: "toString",
+        value: function toString() {
+          return '[object AbortController]';
+        }
+      }]);
+      return AbortController;
+    }();
+    if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+      // These are necessary to make sure that we get correct output for:
+      // Object.prototype.toString.call(new AbortController())
+      AbortController.prototype[Symbol.toStringTag] = 'AbortController';
+      AbortSignal.prototype[Symbol.toStringTag] = 'AbortSignal';
+    }
+
+    function polyfillNeeded(self) {
+      if (self.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL) {
+        console.log('__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL=true is set, will force install polyfill');
+        return true;
+      }
+
+      // Note that the "unfetch" minimal fetch polyfill defines fetch() without
+      // defining window.Request, and this polyfill need to work on top of unfetch
+      // so the below feature detection needs the !self.AbortController part.
+      // The Request.prototype check is also needed because Safari versions 11.1.2
+      // up to and including 12.1.x has a window.AbortController present but still
+      // does NOT correctly implement abortable fetch:
+      // https://bugs.webkit.org/show_bug.cgi?id=174980#c2
+      return typeof self.Request === 'function' && !self.Request.prototype.hasOwnProperty('signal') || !self.AbortController;
+    }
+
+    /**
+     * Note: the "fetch.Request" default value is available for fetch imported from
+     * the "node-fetch" package and not in browsers. This is OK since browsers
+     * will be importing umd-polyfill.js from that path "self" is passed the
+     * decorator so the default value will not be used (because browsers that define
+     * fetch also has Request). One quirky setup where self.fetch exists but
+     * self.Request does not is when the "unfetch" minimal fetch polyfill is used
+     * on top of IE11; for this case the browser will try to use the fetch.Request
+     * default value which in turn will be undefined but then then "if (Request)"
+     * will ensure that you get a patched fetch but still no Request (as expected).
+     * @param {fetch, Request = fetch.Request}
+     * @returns {fetch: abortableFetch, Request: AbortableRequest}
+     */
+    function abortableFetchDecorator(patchTargets) {
+      if ('function' === typeof patchTargets) {
+        patchTargets = {
+          fetch: patchTargets
+        };
+      }
+      var _patchTargets = patchTargets,
+        fetch = _patchTargets.fetch,
+        _patchTargets$Request = _patchTargets.Request,
+        NativeRequest = _patchTargets$Request === void 0 ? fetch.Request : _patchTargets$Request,
+        NativeAbortController = _patchTargets.AbortController,
+        _patchTargets$__FORCE = _patchTargets.__FORCE_INSTALL_ABORTCONTROLLER_POLYFILL,
+        __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL = _patchTargets$__FORCE === void 0 ? false : _patchTargets$__FORCE;
+      if (!polyfillNeeded({
+        fetch: fetch,
+        Request: NativeRequest,
+        AbortController: NativeAbortController,
+        __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL: __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL
+      })) {
+        return {
+          fetch: fetch,
+          Request: Request
+        };
+      }
+      var Request = NativeRequest;
+      // Note that the "unfetch" minimal fetch polyfill defines fetch() without
+      // defining window.Request, and this polyfill need to work on top of unfetch
+      // hence we only patch it if it's available. Also we don't patch it if signal
+      // is already available on the Request prototype because in this case support
+      // is present and the patching below can cause a crash since it assigns to
+      // request.signal which is technically a read-only property. This latter error
+      // happens when you run the main5.js node-fetch example in the repo
+      // "abortcontroller-polyfill-examples". The exact error is:
+      //   request.signal = init.signal;
+      //   ^
+      // TypeError: Cannot set property signal of #<Request> which has only a getter
+      if (Request && !Request.prototype.hasOwnProperty('signal') || __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL) {
+        Request = function Request(input, init) {
+          var signal;
+          if (init && init.signal) {
+            signal = init.signal;
+            // Never pass init.signal to the native Request implementation when the polyfill has
+            // been installed because if we're running on top of a browser with a
+            // working native AbortController (i.e. the polyfill was installed due to
+            // __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL being set), then passing our
+            // fake AbortSignal to the native fetch will trigger:
+            // TypeError: Failed to construct 'Request': member signal is not of type AbortSignal.
+            delete init.signal;
+          }
+          var request = new NativeRequest(input, init);
+          if (signal) {
+            Object.defineProperty(request, 'signal', {
+              writable: false,
+              enumerable: false,
+              configurable: true,
+              value: signal
+            });
+          }
+          return request;
+        };
+        Request.prototype = NativeRequest.prototype;
+      }
+      var realFetch = fetch;
+      var abortableFetch = function abortableFetch(input, init) {
+        var signal = Request && Request.prototype.isPrototypeOf(input) ? input.signal : init ? init.signal : undefined;
+        if (signal) {
+          var abortError;
+          try {
+            abortError = new DOMException('Aborted', 'AbortError');
+          } catch (err) {
+            // IE 11 does not support calling the DOMException constructor, use a
+            // regular error object on it instead.
+            abortError = new Error('Aborted');
+            abortError.name = 'AbortError';
+          }
+
+          // Return early if already aborted, thus avoiding making an HTTP request
+          if (signal.aborted) {
+            return Promise.reject(abortError);
+          }
+
+          // Turn an event into a promise, reject it once `abort` is dispatched
+          var cancellation = new Promise(function (_, reject) {
+            signal.addEventListener('abort', function () {
+              return reject(abortError);
+            }, {
+              once: true
+            });
+          });
+          if (init && init.signal) {
+            // Never pass .signal to the native implementation when the polyfill has
+            // been installed because if we're running on top of a browser with a
+            // working native AbortController (i.e. the polyfill was installed due to
+            // __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL being set), then passing our
+            // fake AbortSignal to the native fetch will trigger:
+            // TypeError: Failed to execute 'fetch' on 'Window': member signal is not of type AbortSignal.
+            delete init.signal;
+          }
+          // Return the fastest promise (don't need to wait for request to finish)
+          return Promise.race([cancellation, realFetch(input, init)]);
+        }
+        return realFetch(input, init);
+      };
+      return {
+        fetch: abortableFetch,
+        Request: Request
+      };
+    }
+
+    /* eslint-disable @typescript-eslint/ban-ts-comment */
+    // @ts-expect-error
+    var needed = polyfillNeeded({
+        fetch: window.fetch,
+        Request: window.Request,
+        AbortController: window.AbortController,
+    });
+    var polyfill = needed ? abortableFetchDecorator({
+        fetch: window.fetch,
+        Request: window.Request,
+        AbortController: window.AbortController,
+    }) : undefined;
+    var fetch = needed ? polyfill.fetch : window.fetch;
+    needed ? polyfill.Request : window.Request;
+
+    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
+    var fails$9 = function fails(exec) {
+      try {
+        return !!exec();
+      } catch (error) {
+        return true;
+      }
+    };
+
+    var fails$8 = fails$9;
+    var functionBindNative = !fails$8(function () {
+      // eslint-disable-next-line es/no-function-prototype-bind -- safe
+      var test = function () {/* empty */}.bind();
+      // eslint-disable-next-line no-prototype-builtins -- safe
+      return typeof test != 'function' || test.hasOwnProperty('prototype');
+    });
+
+    var NATIVE_BIND$3 = functionBindNative;
+    var FunctionPrototype$2 = Function.prototype;
+    var call$9 = FunctionPrototype$2.call;
+    var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$2.bind.bind(call$9, call$9);
+    var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) {
+      return function () {
+        return call$9.apply(fn, arguments);
+      };
+    };
+
+    var uncurryThis$8 = functionUncurryThis;
+    var toString$2 = uncurryThis$8({}.toString);
+    var stringSlice = uncurryThis$8(''.slice);
+    var classofRaw$2 = function classofRaw(it) {
+      return stringSlice(toString$2(it), 8, -1);
+    };
+
+    var uncurryThis$7 = functionUncurryThis;
+    var fails$7 = fails$9;
+    var classof$4 = classofRaw$2;
+    var $Object$4 = Object;
+    var split = uncurryThis$7(''.split);
+
+    // fallback for non-array-like ES3 and non-enumerable old V8 strings
+    var indexedObject = fails$7(function () {
+      // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+      // eslint-disable-next-line no-prototype-builtins -- safe
+      return !$Object$4('z').propertyIsEnumerable(0);
+    }) ? function (it) {
+      return classof$4(it) == 'String' ? split(it, '') : $Object$4(it);
+    } : $Object$4;
+
+    // we can't use just `it == null` since of `document.all` special case
+    // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+    var isNullOrUndefined$3 = function isNullOrUndefined(it) {
+      return it === null || it === undefined;
+    };
+
+    var isNullOrUndefined$2 = isNullOrUndefined$3;
+    var $TypeError$7 = TypeError;
+
+    // `RequireObjectCoercible` abstract operation
+    // https://tc39.es/ecma262/#sec-requireobjectcoercible
+    var requireObjectCoercible$2 = function requireObjectCoercible(it) {
+      if (isNullOrUndefined$2(it)) throw $TypeError$7("Can't call method on " + it);
+      return it;
+    };
+
+    // toObject with fallback for non-array-like ES3 strings
+    var IndexedObject = indexedObject;
+    var requireObjectCoercible$1 = requireObjectCoercible$2;
+    var toIndexedObject$5 = function toIndexedObject(it) {
+      return IndexedObject(requireObjectCoercible$1(it));
+    };
+
+    var iterators = {};
+
+    function _typeof$7(o) { "@babel/helpers - typeof"; return _typeof$7 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$7(o); }
+    var check = function check(it) {
+      return it && it.Math == Math && it;
+    };
+
+    // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+    var global$c =
+    // eslint-disable-next-line es/no-global-this -- safe
+    check((typeof globalThis === "undefined" ? "undefined" : _typeof$7(globalThis)) == 'object' && globalThis) || check((typeof window === "undefined" ? "undefined" : _typeof$7(window)) == 'object' && window) ||
+    // eslint-disable-next-line no-restricted-globals -- safe
+    check((typeof self === "undefined" ? "undefined" : _typeof$7(self)) == 'object' && self) || check(_typeof$7(commonjsGlobal) == 'object' && commonjsGlobal) ||
+    // eslint-disable-next-line no-new-func -- fallback
+    function () {
+      return this;
+    }() || commonjsGlobal || Function('return this')();
+
+    function _typeof$6(o) { "@babel/helpers - typeof"; return _typeof$6 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$6(o); }
+    var documentAll$2 = (typeof document === "undefined" ? "undefined" : _typeof$6(document)) == 'object' && document.all;
+
+    // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+    // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
+    var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined;
+    var documentAll_1 = {
+      all: documentAll$2,
+      IS_HTMLDDA: IS_HTMLDDA
+    };
+
+    var $documentAll$1 = documentAll_1;
+    var documentAll$1 = $documentAll$1.all;
+
+    // `IsCallable` abstract operation
+    // https://tc39.es/ecma262/#sec-iscallable
+    var isCallable$b = $documentAll$1.IS_HTMLDDA ? function (argument) {
+      return typeof argument == 'function' || argument === documentAll$1;
+    } : function (argument) {
+      return typeof argument == 'function';
+    };
+
+    var global$b = global$c;
+    var isCallable$a = isCallable$b;
+    var WeakMap$1 = global$b.WeakMap;
+    var weakMapBasicDetection = isCallable$a(WeakMap$1) && /native code/.test(String(WeakMap$1));
+
+    function _typeof$5(o) { "@babel/helpers - typeof"; return _typeof$5 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$5(o); }
+    var isCallable$9 = isCallable$b;
+    var $documentAll = documentAll_1;
+    var documentAll = $documentAll.all;
+    var isObject$6 = $documentAll.IS_HTMLDDA ? function (it) {
+      return _typeof$5(it) == 'object' ? it !== null : isCallable$9(it) || it === documentAll;
+    } : function (it) {
+      return _typeof$5(it) == 'object' ? it !== null : isCallable$9(it);
+    };
+
+    var fails$6 = fails$9;
+
+    // Detect IE8's incomplete defineProperty implementation
+    var descriptors = !fails$6(function () {
+      // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+      return Object.defineProperty({}, 1, {
+        get: function get() {
+          return 7;
+        }
+      })[1] != 7;
+    });
+
+    var objectDefineProperty = {};
+
+    var global$a = global$c;
+    var isObject$5 = isObject$6;
+    var document$1 = global$a.document;
+    // typeof document.createElement is 'object' in old IE
+    var EXISTS$1 = isObject$5(document$1) && isObject$5(document$1.createElement);
+    var documentCreateElement$1 = function documentCreateElement(it) {
+      return EXISTS$1 ? document$1.createElement(it) : {};
+    };
+
+    var DESCRIPTORS$6 = descriptors;
+    var fails$5 = fails$9;
+    var createElement = documentCreateElement$1;
+
+    // Thanks to IE8 for its funny defineProperty
+    var ie8DomDefine = !DESCRIPTORS$6 && !fails$5(function () {
+      // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+      return Object.defineProperty(createElement('div'), 'a', {
+        get: function get() {
+          return 7;
+        }
+      }).a != 7;
+    });
+
+    var DESCRIPTORS$5 = descriptors;
+    var fails$4 = fails$9;
+
+    // V8 ~ Chrome 36-
+    // https://bugs.chromium.org/p/v8/issues/detail?id=3334
+    var v8PrototypeDefineBug = DESCRIPTORS$5 && fails$4(function () {
+      // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+      return Object.defineProperty(function () {/* empty */}, 'prototype', {
+        value: 42,
+        writable: false
+      }).prototype != 42;
+    });
+
+    var isObject$4 = isObject$6;
+    var $String$2 = String;
+    var $TypeError$6 = TypeError;
+
+    // `Assert: Type(argument) is Object`
+    var anObject$6 = function anObject(argument) {
+      if (isObject$4(argument)) return argument;
+      throw $TypeError$6($String$2(argument) + ' is not an object');
+    };
+
+    var NATIVE_BIND$2 = functionBindNative;
+    var call$8 = Function.prototype.call;
+    var functionCall = NATIVE_BIND$2 ? call$8.bind(call$8) : function () {
+      return call$8.apply(call$8, arguments);
+    };
+
+    var path$3 = {};
+
+    var path$2 = path$3;
+    var global$9 = global$c;
+    var isCallable$8 = isCallable$b;
+    var aFunction = function aFunction(variable) {
+      return isCallable$8(variable) ? variable : undefined;
+    };
+    var getBuiltIn$2 = function getBuiltIn(namespace, method) {
+      return arguments.length < 2 ? aFunction(path$2[namespace]) || aFunction(global$9[namespace]) : path$2[namespace] && path$2[namespace][method] || global$9[namespace] && global$9[namespace][method];
+    };
+
+    var uncurryThis$6 = functionUncurryThis;
+    var objectIsPrototypeOf = uncurryThis$6({}.isPrototypeOf);
+
+    var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
+
+    var global$8 = global$c;
+    var userAgent = engineUserAgent;
+    var process = global$8.process;
+    var Deno = global$8.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];
+      }
+    }
+    var engineV8Version = version;
+
+    /* eslint-disable es/no-symbol -- required for testing */
+    var V8_VERSION = engineV8Version;
+    var fails$3 = fails$9;
+    var global$7 = global$c;
+    var $String$1 = global$7.String;
+
+    // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+    var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$3(function () {
+      var symbol = Symbol();
+      // 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$1(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;
+    });
+
+    function _typeof$4(o) { "@babel/helpers - typeof"; return _typeof$4 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$4(o); }
+    var NATIVE_SYMBOL$1 = symbolConstructorDetection;
+    var useSymbolAsUid = NATIVE_SYMBOL$1 && !Symbol.sham && _typeof$4(Symbol.iterator) == 'symbol';
+
+    function _typeof$3(o) { "@babel/helpers - typeof"; return _typeof$3 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$3(o); }
+    var getBuiltIn$1 = getBuiltIn$2;
+    var isCallable$7 = isCallable$b;
+    var isPrototypeOf$1 = objectIsPrototypeOf;
+    var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
+    var $Object$3 = Object;
+    var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
+      return _typeof$3(it) == 'symbol';
+    } : function (it) {
+      var $Symbol = getBuiltIn$1('Symbol');
+      return isCallable$7($Symbol) && isPrototypeOf$1($Symbol.prototype, $Object$3(it));
+    };
+
+    var $String = String;
+    var tryToString$3 = function tryToString(argument) {
+      try {
+        return $String(argument);
+      } catch (error) {
+        return 'Object';
+      }
+    };
+
+    var isCallable$6 = isCallable$b;
+    var tryToString$2 = tryToString$3;
+    var $TypeError$5 = TypeError;
+
+    // `Assert: IsCallable(argument) is true`
+    var aCallable$3 = function aCallable(argument) {
+      if (isCallable$6(argument)) return argument;
+      throw $TypeError$5(tryToString$2(argument) + ' is not a function');
+    };
+
+    var aCallable$2 = aCallable$3;
+    var isNullOrUndefined$1 = isNullOrUndefined$3;
+
+    // `GetMethod` abstract operation
+    // https://tc39.es/ecma262/#sec-getmethod
+    var getMethod$3 = function getMethod(V, P) {
+      var func = V[P];
+      return isNullOrUndefined$1(func) ? undefined : aCallable$2(func);
+    };
+
+    var call$7 = functionCall;
+    var isCallable$5 = isCallable$b;
+    var isObject$3 = isObject$6;
+    var $TypeError$4 = TypeError;
+
+    // `OrdinaryToPrimitive` abstract operation
+    // https://tc39.es/ecma262/#sec-ordinarytoprimitive
+    var ordinaryToPrimitive$1 = function ordinaryToPrimitive(input, pref) {
+      var fn, val;
+      if (pref === 'string' && isCallable$5(fn = input.toString) && !isObject$3(val = call$7(fn, input))) return val;
+      if (isCallable$5(fn = input.valueOf) && !isObject$3(val = call$7(fn, input))) return val;
+      if (pref !== 'string' && isCallable$5(fn = input.toString) && !isObject$3(val = call$7(fn, input))) return val;
+      throw $TypeError$4("Can't convert object to primitive value");
+    };
+
+    var shared$3 = {exports: {}};
+
+    var global$6 = global$c;
+
+    // eslint-disable-next-line es/no-object-defineproperty -- safe
+    var defineProperty$1 = Object.defineProperty;
+    var defineGlobalProperty$1 = function defineGlobalProperty(key, value) {
+      try {
+        defineProperty$1(global$6, key, {
+          value: value,
+          configurable: true,
+          writable: true
+        });
+      } catch (error) {
+        global$6[key] = value;
+      }
+      return value;
+    };
+
+    var global$5 = global$c;
+    var defineGlobalProperty = defineGlobalProperty$1;
+    var SHARED = '__core-js_shared__';
+    var store$2 = global$5[SHARED] || defineGlobalProperty(SHARED, {});
+    var sharedStore = store$2;
+
+    var store$1 = sharedStore;
+    (shared$3.exports = function (key, value) {
+      return store$1[key] || (store$1[key] = value !== undefined ? value : {});
+    })('versions', []).push({
+      version: '3.31.0',
+      mode: 'pure' ,
+      copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',
+      license: 'https://github.com/zloirock/core-js/blob/v3.31.0/LICENSE',
+      source: 'https://github.com/zloirock/core-js'
+    });
+    var sharedExports = shared$3.exports;
+
+    var requireObjectCoercible = requireObjectCoercible$2;
+    var $Object$2 = Object;
+
+    // `ToObject` abstract operation
+    // https://tc39.es/ecma262/#sec-toobject
+    var toObject$2 = function toObject(argument) {
+      return $Object$2(requireObjectCoercible(argument));
+    };
+
+    var uncurryThis$5 = functionUncurryThis;
+    var toObject$1 = toObject$2;
+    var hasOwnProperty = uncurryThis$5({}.hasOwnProperty);
+
+    // `HasOwnProperty` abstract operation
+    // https://tc39.es/ecma262/#sec-hasownproperty
+    // eslint-disable-next-line es/no-object-hasown -- safe
+    var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
+      return hasOwnProperty(toObject$1(it), key);
+    };
+
+    var uncurryThis$4 = functionUncurryThis;
+    var id = 0;
+    var postfix = Math.random();
+    var toString$1 = uncurryThis$4(1.0.toString);
+    var uid$2 = function uid(key) {
+      return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$1(++id + postfix, 36);
+    };
+
+    var global$4 = global$c;
+    var shared$2 = sharedExports;
+    var hasOwn$7 = hasOwnProperty_1;
+    var uid$1 = uid$2;
+    var NATIVE_SYMBOL = symbolConstructorDetection;
+    var USE_SYMBOL_AS_UID = useSymbolAsUid;
+    var _Symbol = global$4.Symbol;
+    var WellKnownSymbolsStore = shared$2('wks');
+    var createWellKnownSymbol = USE_SYMBOL_AS_UID ? _Symbol['for'] || _Symbol : _Symbol && _Symbol.withoutSetter || uid$1;
+    var wellKnownSymbol$9 = function wellKnownSymbol(name) {
+      if (!hasOwn$7(WellKnownSymbolsStore, name)) {
+        WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$7(_Symbol, name) ? _Symbol[name] : createWellKnownSymbol('Symbol.' + name);
+      }
+      return WellKnownSymbolsStore[name];
+    };
+
+    var call$6 = functionCall;
+    var isObject$2 = isObject$6;
+    var isSymbol$1 = isSymbol$2;
+    var getMethod$2 = getMethod$3;
+    var ordinaryToPrimitive = ordinaryToPrimitive$1;
+    var wellKnownSymbol$8 = wellKnownSymbol$9;
+    var $TypeError$3 = TypeError;
+    var TO_PRIMITIVE = wellKnownSymbol$8('toPrimitive');
+
+    // `ToPrimitive` abstract operation
+    // https://tc39.es/ecma262/#sec-toprimitive
+    var toPrimitive$1 = function toPrimitive(input, pref) {
+      if (!isObject$2(input) || isSymbol$1(input)) return input;
+      var exoticToPrim = getMethod$2(input, TO_PRIMITIVE);
+      var result;
+      if (exoticToPrim) {
+        if (pref === undefined) pref = 'default';
+        result = call$6(exoticToPrim, input, pref);
+        if (!isObject$2(result) || isSymbol$1(result)) return result;
+        throw $TypeError$3("Can't convert object to primitive value");
+      }
+      if (pref === undefined) pref = 'number';
+      return ordinaryToPrimitive(input, pref);
+    };
+
+    var toPrimitive = toPrimitive$1;
+    var isSymbol = isSymbol$2;
+
+    // `ToPropertyKey` abstract operation
+    // https://tc39.es/ecma262/#sec-topropertykey
+    var toPropertyKey$3 = function toPropertyKey(argument) {
+      var key = toPrimitive(argument, 'string');
+      return isSymbol(key) ? key : key + '';
+    };
+
+    var DESCRIPTORS$4 = descriptors;
+    var IE8_DOM_DEFINE$1 = ie8DomDefine;
+    var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug;
+    var anObject$5 = anObject$6;
+    var toPropertyKey$2 = toPropertyKey$3;
+    var $TypeError$2 = 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$1 = Object.getOwnPropertyDescriptor;
+    var ENUMERABLE = 'enumerable';
+    var CONFIGURABLE$1 = 'configurable';
+    var WRITABLE = 'writable';
+
+    // `Object.defineProperty` method
+    // https://tc39.es/ecma262/#sec-object.defineproperty
+    objectDefineProperty.f = DESCRIPTORS$4 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) {
+      anObject$5(O);
+      P = toPropertyKey$2(P);
+      anObject$5(Attributes);
+      if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+        var current = $getOwnPropertyDescriptor$1(O, P);
+        if (current && current[WRITABLE]) {
+          O[P] = Attributes.value;
+          Attributes = {
+            configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
+            enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+            writable: false
+          };
+        }
+      }
+      return $defineProperty(O, P, Attributes);
+    } : $defineProperty : function defineProperty(O, P, Attributes) {
+      anObject$5(O);
+      P = toPropertyKey$2(P);
+      anObject$5(Attributes);
+      if (IE8_DOM_DEFINE$1) try {
+        return $defineProperty(O, P, Attributes);
+      } catch (error) {/* empty */}
+      if ('get' in Attributes || 'set' in Attributes) throw $TypeError$2('Accessors not supported');
+      if ('value' in Attributes) O[P] = Attributes.value;
+      return O;
+    };
+
+    var createPropertyDescriptor$4 = function createPropertyDescriptor(bitmap, value) {
+      return {
+        enumerable: !(bitmap & 1),
+        configurable: !(bitmap & 2),
+        writable: !(bitmap & 4),
+        value: value
+      };
+    };
+
+    var DESCRIPTORS$3 = descriptors;
+    var definePropertyModule$2 = objectDefineProperty;
+    var createPropertyDescriptor$3 = createPropertyDescriptor$4;
+    var createNonEnumerableProperty$5 = DESCRIPTORS$3 ? function (object, key, value) {
+      return definePropertyModule$2.f(object, key, createPropertyDescriptor$3(1, value));
+    } : function (object, key, value) {
+      object[key] = value;
+      return object;
+    };
+
+    var shared$1 = sharedExports;
+    var uid = uid$2;
+    var keys = shared$1('keys');
+    var sharedKey$3 = function sharedKey(key) {
+      return keys[key] || (keys[key] = uid(key));
+    };
+
+    var hiddenKeys$3 = {};
+
+    var NATIVE_WEAK_MAP = weakMapBasicDetection;
+    var global$3 = global$c;
+    var isObject$1 = isObject$6;
+    var createNonEnumerableProperty$4 = createNonEnumerableProperty$5;
+    var hasOwn$6 = hasOwnProperty_1;
+    var shared = sharedStore;
+    var sharedKey$2 = sharedKey$3;
+    var hiddenKeys$2 = hiddenKeys$3;
+    var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+    var TypeError$1 = global$3.TypeError;
+    var WeakMap = global$3.WeakMap;
+    var set, get, has;
+    var enforce = function enforce(it) {
+      return has(it) ? get(it) : set(it, {});
+    };
+    var getterFor = function getterFor(TYPE) {
+      return function (it) {
+        var state;
+        if (!isObject$1(it) || (state = get(it)).type !== TYPE) {
+          throw TypeError$1('Incompatible receiver, ' + TYPE + ' required');
+        }
+        return state;
+      };
+    };
+    if (NATIVE_WEAK_MAP || shared.state) {
+      var store = shared.state || (shared.state = new WeakMap());
+      /* eslint-disable no-self-assign -- prototype methods protection */
+      store.get = store.get;
+      store.has = store.has;
+      store.set = store.set;
+      /* eslint-enable no-self-assign -- prototype methods protection */
+      set = function set(it, metadata) {
+        if (store.has(it)) throw TypeError$1(OBJECT_ALREADY_INITIALIZED);
+        metadata.facade = it;
+        store.set(it, metadata);
+        return metadata;
+      };
+      get = function get(it) {
+        return store.get(it) || {};
+      };
+      has = function has(it) {
+        return store.has(it);
+      };
+    } else {
+      var STATE = sharedKey$2('state');
+      hiddenKeys$2[STATE] = true;
+      set = function set(it, metadata) {
+        if (hasOwn$6(it, STATE)) throw TypeError$1(OBJECT_ALREADY_INITIALIZED);
+        metadata.facade = it;
+        createNonEnumerableProperty$4(it, STATE, metadata);
+        return metadata;
+      };
+      get = function get(it) {
+        return hasOwn$6(it, STATE) ? it[STATE] : {};
+      };
+      has = function has(it) {
+        return hasOwn$6(it, STATE);
+      };
+    }
+    var internalState = {
+      set: set,
+      get: get,
+      has: has,
+      enforce: enforce,
+      getterFor: getterFor
+    };
+
+    function _typeof$2(o) { "@babel/helpers - typeof"; return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$2(o); }
+    var NATIVE_BIND$1 = functionBindNative;
+    var FunctionPrototype$1 = Function.prototype;
+    var apply$1 = FunctionPrototype$1.apply;
+    var call$5 = FunctionPrototype$1.call;
+
+    // eslint-disable-next-line es/no-reflect -- safe
+    var functionApply = (typeof Reflect === "undefined" ? "undefined" : _typeof$2(Reflect)) == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$5.bind(apply$1) : function () {
+      return call$5.apply(apply$1, arguments);
+    });
+
+    var classofRaw$1 = classofRaw$2;
+    var uncurryThis$3 = functionUncurryThis;
+    var functionUncurryThisClause = function functionUncurryThisClause(fn) {
+      // Nashorn bug:
+      //   https://github.com/zloirock/core-js/issues/1128
+      //   https://github.com/zloirock/core-js/issues/1130
+      if (classofRaw$1(fn) === 'Function') return uncurryThis$3(fn);
+    };
+
+    var objectGetOwnPropertyDescriptor = {};
+
+    var objectPropertyIsEnumerable = {};
+
+    var $propertyIsEnumerable = {}.propertyIsEnumerable;
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
+
+    // Nashorn ~ JDK8 bug
+    var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({
+      1: 2
+    }, 1);
+
+    // `Object.prototype.propertyIsEnumerable` method implementation
+    // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+    objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+      var descriptor = getOwnPropertyDescriptor$1(this, V);
+      return !!descriptor && descriptor.enumerable;
+    } : $propertyIsEnumerable;
+
+    var DESCRIPTORS$2 = descriptors;
+    var call$4 = functionCall;
+    var propertyIsEnumerableModule = objectPropertyIsEnumerable;
+    var createPropertyDescriptor$2 = createPropertyDescriptor$4;
+    var toIndexedObject$4 = toIndexedObject$5;
+    var toPropertyKey$1 = toPropertyKey$3;
+    var hasOwn$5 = hasOwnProperty_1;
+    var IE8_DOM_DEFINE = ie8DomDefine;
+
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+    // `Object.getOwnPropertyDescriptor` method
+    // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+    objectGetOwnPropertyDescriptor.f = DESCRIPTORS$2 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+      O = toIndexedObject$4(O);
+      P = toPropertyKey$1(P);
+      if (IE8_DOM_DEFINE) try {
+        return $getOwnPropertyDescriptor(O, P);
+      } catch (error) {/* empty */}
+      if (hasOwn$5(O, P)) return createPropertyDescriptor$2(!call$4(propertyIsEnumerableModule.f, O, P), O[P]);
+    };
+
+    var fails$2 = fails$9;
+    var isCallable$4 = isCallable$b;
+    var replacement = /#|\.prototype\./;
+    var isForced$1 = function isForced(feature, detection) {
+      var value = data[normalize(feature)];
+      return value == POLYFILL ? true : value == NATIVE ? false : isCallable$4(detection) ? fails$2(detection) : !!detection;
+    };
+    var normalize = isForced$1.normalize = function (string) {
+      return String(string).replace(replacement, '.').toLowerCase();
+    };
+    var data = isForced$1.data = {};
+    var NATIVE = isForced$1.NATIVE = 'N';
+    var POLYFILL = isForced$1.POLYFILL = 'P';
+    var isForced_1 = isForced$1;
+
+    var uncurryThis$2 = functionUncurryThisClause;
+    var aCallable$1 = aCallable$3;
+    var NATIVE_BIND = functionBindNative;
+    var bind$2 = uncurryThis$2(uncurryThis$2.bind);
+
+    // optional / simple context binding
+    var functionBindContext = function functionBindContext(fn, that) {
+      aCallable$1(fn);
+      return that === undefined ? fn : NATIVE_BIND ? bind$2(fn, that) : function /* ...args */
+      () {
+        return fn.apply(that, arguments);
+      };
+    };
+
+    function _typeof$1(o) { "@babel/helpers - typeof"; return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$1(o); }
+    var global$2 = global$c;
+    var apply = functionApply;
+    var uncurryThis$1 = functionUncurryThisClause;
+    var isCallable$3 = isCallable$b;
+    var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+    var isForced = isForced_1;
+    var path$1 = path$3;
+    var bind$1 = functionBindContext;
+    var createNonEnumerableProperty$3 = createNonEnumerableProperty$5;
+    var hasOwn$4 = hasOwnProperty_1;
+    var wrapConstructor = function wrapConstructor(NativeConstructor) {
+      var Wrapper = function Wrapper(a, b, c) {
+        if (this instanceof Wrapper) {
+          switch (arguments.length) {
+            case 0:
+              return new NativeConstructor();
+            case 1:
+              return new NativeConstructor(a);
+            case 2:
+              return new NativeConstructor(a, b);
+          }
+          return new NativeConstructor(a, b, c);
+        }
+        return apply(NativeConstructor, this, arguments);
+      };
+      Wrapper.prototype = NativeConstructor.prototype;
+      return Wrapper;
+    };
+
+    /*
+      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
+    */
+    var _export = function _export(options, source) {
+      var TARGET = options.target;
+      var GLOBAL = options.global;
+      var STATIC = options.stat;
+      var PROTO = options.proto;
+      var nativeSource = GLOBAL ? global$2 : STATIC ? global$2[TARGET] : (global$2[TARGET] || {}).prototype;
+      var target = GLOBAL ? path$1 : path$1[TARGET] || createNonEnumerableProperty$3(path$1, TARGET, {})[TARGET];
+      var targetPrototype = target.prototype;
+      var FORCED, USE_NATIVE, VIRTUAL_PROTOTYPE;
+      var key, sourceProperty, targetProperty, nativeProperty, resultProperty, descriptor;
+      for (key in source) {
+        FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+        // contains in native
+        USE_NATIVE = !FORCED && nativeSource && hasOwn$4(nativeSource, key);
+        targetProperty = target[key];
+        if (USE_NATIVE) if (options.dontCallGetSet) {
+          descriptor = getOwnPropertyDescriptor(nativeSource, key);
+          nativeProperty = descriptor && descriptor.value;
+        } else nativeProperty = nativeSource[key];
+
+        // export native or implementation
+        sourceProperty = USE_NATIVE && nativeProperty ? nativeProperty : source[key];
+        if (USE_NATIVE && _typeof$1(targetProperty) == _typeof$1(sourceProperty)) continue;
+
+        // bind methods to global for calling from export context
+        if (options.bind && USE_NATIVE) resultProperty = bind$1(sourceProperty, global$2);
+        // wrap global constructors for prevent changes in this version
+        else if (options.wrap && USE_NATIVE) resultProperty = wrapConstructor(sourceProperty);
+        // make static versions for prototype methods
+        else if (PROTO && isCallable$3(sourceProperty)) resultProperty = uncurryThis$1(sourceProperty);
+        // default case
+        else resultProperty = sourceProperty;
+
+        // add a flag to not completely full polyfills
+        if (options.sham || sourceProperty && sourceProperty.sham || targetProperty && targetProperty.sham) {
+          createNonEnumerableProperty$3(resultProperty, 'sham', true);
+        }
+        createNonEnumerableProperty$3(target, key, resultProperty);
+        if (PROTO) {
+          VIRTUAL_PROTOTYPE = TARGET + 'Prototype';
+          if (!hasOwn$4(path$1, VIRTUAL_PROTOTYPE)) {
+            createNonEnumerableProperty$3(path$1, VIRTUAL_PROTOTYPE, {});
+          }
+          // export virtual prototype methods
+          createNonEnumerableProperty$3(path$1[VIRTUAL_PROTOTYPE], key, sourceProperty);
+          // export real prototype methods
+          if (options.real && targetPrototype && (FORCED || !targetPrototype[key])) {
+            createNonEnumerableProperty$3(targetPrototype, key, sourceProperty);
+          }
+        }
+      }
+    };
+
+    var DESCRIPTORS$1 = descriptors;
+    var hasOwn$3 = hasOwnProperty_1;
+    var FunctionPrototype = Function.prototype;
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    var getDescriptor = DESCRIPTORS$1 && Object.getOwnPropertyDescriptor;
+    var EXISTS = hasOwn$3(FunctionPrototype, 'name');
+    // additional protection from minified / mangled / dropped function names
+    var PROPER = EXISTS && function something() {/* empty */}.name === 'something';
+    var CONFIGURABLE = EXISTS && (!DESCRIPTORS$1 || DESCRIPTORS$1 && getDescriptor(FunctionPrototype, 'name').configurable);
+    var functionName = {
+      EXISTS: EXISTS,
+      PROPER: PROPER,
+      CONFIGURABLE: CONFIGURABLE
+    };
+
+    var objectDefineProperties = {};
+
+    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
+    var mathTrunc = Math.trunc || function trunc(x) {
+      var n = +x;
+      return (n > 0 ? floor : ceil)(n);
+    };
+
+    var trunc = mathTrunc;
+
+    // `ToIntegerOrInfinity` abstract operation
+    // https://tc39.es/ecma262/#sec-tointegerorinfinity
+    var toIntegerOrInfinity$2 = function toIntegerOrInfinity(argument) {
+      var number = +argument;
+      // eslint-disable-next-line no-self-compare -- NaN check
+      return number !== number || number === 0 ? 0 : trunc(number);
+    };
+
+    var toIntegerOrInfinity$1 = toIntegerOrInfinity$2;
+    var max = Math.max;
+    var min$1 = 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).
+    var toAbsoluteIndex$1 = function toAbsoluteIndex(index, length) {
+      var integer = toIntegerOrInfinity$1(index);
+      return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
+    };
+
+    var toIntegerOrInfinity = toIntegerOrInfinity$2;
+    var min = Math.min;
+
+    // `ToLength` abstract operation
+    // https://tc39.es/ecma262/#sec-tolength
+    var toLength$1 = function toLength(argument) {
+      return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+    };
+
+    var toLength = toLength$1;
+
+    // `LengthOfArrayLike` abstract operation
+    // https://tc39.es/ecma262/#sec-lengthofarraylike
+    var lengthOfArrayLike$2 = function lengthOfArrayLike(obj) {
+      return toLength(obj.length);
+    };
+
+    var toIndexedObject$3 = toIndexedObject$5;
+    var toAbsoluteIndex = toAbsoluteIndex$1;
+    var lengthOfArrayLike$1 = lengthOfArrayLike$2;
+
+    // `Array.prototype.{ indexOf, includes }` methods implementation
+    var createMethod = function createMethod(IS_INCLUDES) {
+      return function ($this, el, fromIndex) {
+        var O = toIndexedObject$3($this);
+        var length = lengthOfArrayLike$1(O);
+        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;
+      };
+    };
+    var arrayIncludes = {
+      // `Array.prototype.includes` method
+      // https://tc39.es/ecma262/#sec-array.prototype.includes
+      includes: createMethod(true),
+      // `Array.prototype.indexOf` method
+      // https://tc39.es/ecma262/#sec-array.prototype.indexof
+      indexOf: createMethod(false)
+    };
+
+    var uncurryThis = functionUncurryThis;
+    var hasOwn$2 = hasOwnProperty_1;
+    var toIndexedObject$2 = toIndexedObject$5;
+    var indexOf = arrayIncludes.indexOf;
+    var hiddenKeys$1 = hiddenKeys$3;
+    var push = uncurryThis([].push);
+    var objectKeysInternal = function objectKeysInternal(object, names) {
+      var O = toIndexedObject$2(object);
+      var i = 0;
+      var result = [];
+      var key;
+      for (key in O) !hasOwn$2(hiddenKeys$1, key) && hasOwn$2(O, key) && push(result, key);
+      // Don't enum bug & hidden keys
+      while (names.length > i) if (hasOwn$2(O, key = names[i++])) {
+        ~indexOf(result, key) || push(result, key);
+      }
+      return result;
+    };
+
+    // IE8- don't enum bug keys
+    var enumBugKeys$2 = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
+
+    var internalObjectKeys = objectKeysInternal;
+    var enumBugKeys$1 = enumBugKeys$2;
+
+    // `Object.keys` method
+    // https://tc39.es/ecma262/#sec-object.keys
+    // eslint-disable-next-line es/no-object-keys -- safe
+    var objectKeys$1 = Object.keys || function keys(O) {
+      return internalObjectKeys(O, enumBugKeys$1);
+    };
+
+    var DESCRIPTORS = descriptors;
+    var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
+    var definePropertyModule$1 = objectDefineProperty;
+    var anObject$4 = anObject$6;
+    var toIndexedObject$1 = toIndexedObject$5;
+    var objectKeys = objectKeys$1;
+
+    // `Object.defineProperties` method
+    // https://tc39.es/ecma262/#sec-object.defineproperties
+    // eslint-disable-next-line es/no-object-defineproperties -- safe
+    objectDefineProperties.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
+      anObject$4(O);
+      var props = toIndexedObject$1(Properties);
+      var keys = objectKeys(Properties);
+      var length = keys.length;
+      var index = 0;
+      var key;
+      while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]);
+      return O;
+    };
+
+    var getBuiltIn = getBuiltIn$2;
+    var html$1 = getBuiltIn('document', 'documentElement');
+
+    /* global ActiveXObject -- old IE, WSH */
+    var anObject$3 = anObject$6;
+    var definePropertiesModule = objectDefineProperties;
+    var enumBugKeys = enumBugKeys$2;
+    var hiddenKeys = hiddenKeys$3;
+    var html = html$1;
+    var documentCreateElement = documentCreateElement$1;
+    var sharedKey$1 = sharedKey$3;
+    var GT = '>';
+    var LT = '<';
+    var PROTOTYPE = 'prototype';
+    var SCRIPT = 'script';
+    var IE_PROTO$1 = sharedKey$1('IE_PROTO');
+    var EmptyConstructor = function EmptyConstructor() {/* empty */};
+    var scriptTag = function scriptTag(content) {
+      return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+    };
+
+    // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+    var NullProtoObjectViaActiveX = function NullProtoObjectViaActiveX(activeXDocument) {
+      activeXDocument.write(scriptTag(''));
+      activeXDocument.close();
+      var temp = activeXDocument.parentWindow.Object;
+      activeXDocument = null; // avoid memory leak
+      return temp;
+    };
+
+    // Create object with fake `null` prototype: use iframe Object with cleared prototype
+    var NullProtoObjectViaIFrame = function NullProtoObjectViaIFrame() {
+      // Thrash, waste and sodomy: IE GC bug
+      var iframe = documentCreateElement('iframe');
+      var JS = 'java' + SCRIPT + ':';
+      var iframeDocument;
+      iframe.style.display = 'none';
+      html.appendChild(iframe);
+      // https://github.com/zloirock/core-js/issues/475
+      iframe.src = String(JS);
+      iframeDocument = iframe.contentWindow.document;
+      iframeDocument.open();
+      iframeDocument.write(scriptTag('document.F=Object'));
+      iframeDocument.close();
+      return iframeDocument.F;
+    };
+
+    // Check for document.domain and active x support
+    // No need to use active x approach when document.domain is not set
+    // see https://github.com/es-shims/es5-shim/issues/150
+    // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+    // avoid IE GC bug
+    var activeXDocument;
+    var _NullProtoObject = function NullProtoObject() {
+      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$1] = true;
+
+    // `Object.create` method
+    // https://tc39.es/ecma262/#sec-object.create
+    // eslint-disable-next-line es/no-object-create -- safe
+    var objectCreate = Object.create || function create(O, Properties) {
+      var result;
+      if (O !== null) {
+        EmptyConstructor[PROTOTYPE] = anObject$3(O);
+        result = new EmptyConstructor();
+        EmptyConstructor[PROTOTYPE] = null;
+        // add "__proto__" for Object.getPrototypeOf polyfill
+        result[IE_PROTO$1] = O;
+      } else result = _NullProtoObject();
+      return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
+    };
+
+    var fails$1 = fails$9;
+    var correctPrototypeGetter = !fails$1(function () {
+      function F() {/* empty */}
+      F.prototype.constructor = null;
+      // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+      return Object.getPrototypeOf(new F()) !== F.prototype;
+    });
+
+    var hasOwn$1 = hasOwnProperty_1;
+    var isCallable$2 = isCallable$b;
+    var toObject = toObject$2;
+    var sharedKey = sharedKey$3;
+    var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
+    var IE_PROTO = sharedKey('IE_PROTO');
+    var $Object$1 = Object;
+    var ObjectPrototype = $Object$1.prototype;
+
+    // `Object.getPrototypeOf` method
+    // https://tc39.es/ecma262/#sec-object.getprototypeof
+    // eslint-disable-next-line es/no-object-getprototypeof -- safe
+    var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object$1.getPrototypeOf : function (O) {
+      var object = toObject(O);
+      if (hasOwn$1(object, IE_PROTO)) return object[IE_PROTO];
+      var constructor = object.constructor;
+      if (isCallable$2(constructor) && object instanceof constructor) {
+        return constructor.prototype;
+      }
+      return object instanceof $Object$1 ? ObjectPrototype : null;
+    };
+
+    var createNonEnumerableProperty$2 = createNonEnumerableProperty$5;
+    var defineBuiltIn$2 = function defineBuiltIn(target, key, value, options) {
+      if (options && options.enumerable) target[key] = value;else createNonEnumerableProperty$2(target, key, value);
+      return target;
+    };
+
+    var fails = fails$9;
+    var isCallable$1 = isCallable$b;
+    var isObject = isObject$6;
+    var create$1 = objectCreate;
+    var getPrototypeOf$1 = objectGetPrototypeOf;
+    var defineBuiltIn$1 = defineBuiltIn$2;
+    var wellKnownSymbol$7 = wellKnownSymbol$9;
+    var ITERATOR$3 = wellKnownSymbol$7('iterator');
+    var BUGGY_SAFARI_ITERATORS$1 = false;
+
+    // `%IteratorPrototype%` object
+    // https://tc39.es/ecma262/#sec-%iteratorprototype%-object
+    var IteratorPrototype$1, 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$1 = true;else {
+        PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator));
+        if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$1 = PrototypeOfArrayIteratorPrototype;
+      }
+    }
+    var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype$1) || fails(function () {
+      var test = {};
+      // FF44- legacy iterators case
+      return IteratorPrototype$1[ITERATOR$3].call(test) !== test;
+    });
+    if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$1 = {};else IteratorPrototype$1 = create$1(IteratorPrototype$1);
+
+    // `%IteratorPrototype%[@@iterator]()` method
+    // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+    if (!isCallable$1(IteratorPrototype$1[ITERATOR$3])) {
+      defineBuiltIn$1(IteratorPrototype$1, ITERATOR$3, function () {
+        return this;
+      });
+    }
+    var iteratorsCore = {
+      IteratorPrototype: IteratorPrototype$1,
+      BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1
+    };
+
+    var wellKnownSymbol$6 = wellKnownSymbol$9;
+    var TO_STRING_TAG$3 = wellKnownSymbol$6('toStringTag');
+    var test = {};
+    test[TO_STRING_TAG$3] = 'z';
+    var toStringTagSupport = String(test) === '[object z]';
+
+    var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport;
+    var isCallable = isCallable$b;
+    var classofRaw = classofRaw$2;
+    var wellKnownSymbol$5 = wellKnownSymbol$9;
+    var TO_STRING_TAG$2 = wellKnownSymbol$5('toStringTag');
+    var $Object = Object;
+
+    // ES3 wrong here
+    var CORRECT_ARGUMENTS = classofRaw(function () {
+      return arguments;
+    }()) == 'Arguments';
+
+    // fallback for IE11 Script Access Denied error
+    var tryGet = function tryGet(it, key) {
+      try {
+        return it[key];
+      } catch (error) {/* empty */}
+    };
+
+    // getting tag from ES6+ `Object.prototype.toString`
+    var classof$3 = TO_STRING_TAG_SUPPORT$2 ? 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$2)) == 'string' ? tag
+      // builtinTag case
+      : CORRECT_ARGUMENTS ? classofRaw(O)
+      // ES3 arguments fallback
+      : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
+    };
+
+    var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport;
+    var classof$2 = classof$3;
+
+    // `Object.prototype.toString` method implementation
+    // https://tc39.es/ecma262/#sec-object.prototype.tostring
+    var objectToString = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() {
+      return '[object ' + classof$2(this) + ']';
+    };
+
+    var TO_STRING_TAG_SUPPORT = toStringTagSupport;
+    var defineProperty = objectDefineProperty.f;
+    var createNonEnumerableProperty$1 = createNonEnumerableProperty$5;
+    var hasOwn = hasOwnProperty_1;
+    var toString = objectToString;
+    var wellKnownSymbol$4 = wellKnownSymbol$9;
+    var TO_STRING_TAG$1 = wellKnownSymbol$4('toStringTag');
+    var setToStringTag$2 = function setToStringTag(it, TAG, STATIC, SET_METHOD) {
+      if (it) {
+        var target = STATIC ? it : it.prototype;
+        if (!hasOwn(target, TO_STRING_TAG$1)) {
+          defineProperty(target, TO_STRING_TAG$1, {
+            configurable: true,
+            value: TAG
+          });
+        }
+        if (SET_METHOD && !TO_STRING_TAG_SUPPORT) {
+          createNonEnumerableProperty$1(target, 'toString', toString);
+        }
+      }
+    };
+
+    var IteratorPrototype = iteratorsCore.IteratorPrototype;
+    var create = objectCreate;
+    var createPropertyDescriptor$1 = createPropertyDescriptor$4;
+    var setToStringTag$1 = setToStringTag$2;
+    var Iterators$5 = iterators;
+    var returnThis$1 = function returnThis() {
+      return this;
+    };
+    var iteratorCreateConstructor = function iteratorCreateConstructor(IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
+      var TO_STRING_TAG = NAME + ' Iterator';
+      IteratorConstructor.prototype = create(IteratorPrototype, {
+        next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next)
+      });
+      setToStringTag$1(IteratorConstructor, TO_STRING_TAG, false, true);
+      Iterators$5[TO_STRING_TAG] = returnThis$1;
+      return IteratorConstructor;
+    };
+
+    var $$1 = _export;
+    var call$3 = functionCall;
+    var FunctionName = functionName;
+    var createIteratorConstructor = iteratorCreateConstructor;
+    var getPrototypeOf = objectGetPrototypeOf;
+    var setToStringTag = setToStringTag$2;
+    var defineBuiltIn = defineBuiltIn$2;
+    var wellKnownSymbol$3 = wellKnownSymbol$9;
+    var Iterators$4 = iterators;
+    var IteratorsCore = iteratorsCore;
+    var PROPER_FUNCTION_NAME = FunctionName.PROPER;
+    FunctionName.CONFIGURABLE;
+    IteratorsCore.IteratorPrototype;
+    var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
+    var ITERATOR$2 = wellKnownSymbol$3('iterator');
+    var KEYS = 'keys';
+    var VALUES = 'values';
+    var ENTRIES = 'entries';
+    var returnThis = function returnThis() {
+      return this;
+    };
+    var iteratorDefine = function iteratorDefine(Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+      createIteratorConstructor(IteratorConstructor, NAME, next);
+      var getIterationMethod = function getIterationMethod(KIND) {
+        if (KIND === DEFAULT && defaultIterator) return defaultIterator;
+        if (!BUGGY_SAFARI_ITERATORS && 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$2] || 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) {
+          // Set @@toStringTag to native iterators
+          setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
+          Iterators$4[TO_STRING_TAG] = returnThis;
+        }
+      }
+
+      // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
+      if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+        {
+          INCORRECT_VALUES_NAME = true;
+          defaultIterator = function values() {
+            return call$3(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 $$1({
+          target: NAME,
+          proto: true,
+          forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME
+        }, methods);
+      }
+
+      // define iterator
+      if ((FORCED) && IterablePrototype[ITERATOR$2] !== defaultIterator) {
+        defineBuiltIn(IterablePrototype, ITERATOR$2, defaultIterator, {
+          name: DEFAULT
+        });
+      }
+      Iterators$4[NAME] = defaultIterator;
+      return methods;
+    };
+
+    // `CreateIterResultObject` abstract operation
+    // https://tc39.es/ecma262/#sec-createiterresultobject
+    var createIterResultObject$1 = function createIterResultObject(value, done) {
+      return {
+        value: value,
+        done: done
+      };
+    };
+
+    var toIndexedObject = toIndexedObject$5;
+    var Iterators$3 = iterators;
+    var InternalStateModule = internalState;
+    objectDefineProperty.f;
+    var defineIterator = iteratorDefine;
+    var createIterResultObject = createIterResultObject$1;
+    var ARRAY_ITERATOR = 'Array Iterator';
+    var setInternalState = InternalStateModule.set;
+    var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
+
+    // `Array.prototype.entries` method
+    // https://tc39.es/ecma262/#sec-array.prototype.entries
+    // `Array.prototype.keys` method
+    // https://tc39.es/ecma262/#sec-array.prototype.keys
+    // `Array.prototype.values` method
+    // https://tc39.es/ecma262/#sec-array.prototype.values
+    // `Array.prototype[@@iterator]` method
+    // https://tc39.es/ecma262/#sec-array.prototype-@@iterator
+    // `CreateArrayIterator` internal method
+    // https://tc39.es/ecma262/#sec-createarrayiterator
+    defineIterator(Array, 'Array', function (iterated, kind) {
+      setInternalState(this, {
+        type: ARRAY_ITERATOR,
+        target: toIndexedObject(iterated),
+        // target
+        index: 0,
+        // next index
+        kind: kind // kind
+      });
+      // `%ArrayIteratorPrototype%.next` method
+      // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
+    }, function () {
+      var state = getInternalState(this);
+      var target = state.target;
+      var kind = state.kind;
+      var index = state.index++;
+      if (!target || index >= target.length) {
+        state.target = undefined;
+        return createIterResultObject(undefined, true);
+      }
+      if (kind == 'keys') return createIterResultObject(index, false);
+      if (kind == 'values') return createIterResultObject(target[index], false);
+      return createIterResultObject([index, target[index]], false);
+    }, 'values');
+
+    // argumentsList[@@iterator] is %ArrayProto_values%
+    // https://tc39.es/ecma262/#sec-createunmappedargumentsobject
+    // https://tc39.es/ecma262/#sec-createmappedargumentsobject
+    Iterators$3.Arguments = Iterators$3.Array;
+
+    var wellKnownSymbol$2 = wellKnownSymbol$9;
+    var Iterators$2 = iterators;
+    var ITERATOR$1 = wellKnownSymbol$2('iterator');
+    var ArrayPrototype = Array.prototype;
+
+    // check on default Array iterator
+    var isArrayIteratorMethod$1 = function isArrayIteratorMethod(it) {
+      return it !== undefined && (Iterators$2.Array === it || ArrayPrototype[ITERATOR$1] === it);
+    };
+
+    var classof$1 = classof$3;
+    var getMethod$1 = getMethod$3;
+    var isNullOrUndefined = isNullOrUndefined$3;
+    var Iterators$1 = iterators;
+    var wellKnownSymbol$1 = wellKnownSymbol$9;
+    var ITERATOR = wellKnownSymbol$1('iterator');
+    var getIteratorMethod$2 = function getIteratorMethod(it) {
+      if (!isNullOrUndefined(it)) return getMethod$1(it, ITERATOR) || getMethod$1(it, '@@iterator') || Iterators$1[classof$1(it)];
+    };
+
+    var call$2 = functionCall;
+    var aCallable = aCallable$3;
+    var anObject$2 = anObject$6;
+    var tryToString$1 = tryToString$3;
+    var getIteratorMethod$1 = getIteratorMethod$2;
+    var $TypeError$1 = TypeError;
+    var getIterator$1 = function getIterator(argument, usingIterator) {
+      var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
+      if (aCallable(iteratorMethod)) return anObject$2(call$2(iteratorMethod, argument));
+      throw $TypeError$1(tryToString$1(argument) + ' is not iterable');
+    };
+
+    var call$1 = functionCall;
+    var anObject$1 = anObject$6;
+    var getMethod = getMethod$3;
+    var iteratorClose$1 = function iteratorClose(iterator, kind, value) {
+      var innerResult, innerError;
+      anObject$1(iterator);
+      try {
+        innerResult = getMethod(iterator, 'return');
+        if (!innerResult) {
+          if (kind === 'throw') throw value;
+          return value;
+        }
+        innerResult = call$1(innerResult, iterator);
+      } catch (error) {
+        innerError = true;
+        innerResult = error;
+      }
+      if (kind === 'throw') throw value;
+      if (innerError) throw innerResult;
+      anObject$1(innerResult);
+      return value;
+    };
+
+    function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+    var bind = functionBindContext;
+    var call = functionCall;
+    var anObject = anObject$6;
+    var tryToString = tryToString$3;
+    var isArrayIteratorMethod = isArrayIteratorMethod$1;
+    var lengthOfArrayLike = lengthOfArrayLike$2;
+    var isPrototypeOf = objectIsPrototypeOf;
+    var getIterator = getIterator$1;
+    var getIteratorMethod = getIteratorMethod$2;
+    var iteratorClose = iteratorClose$1;
+    var $TypeError = TypeError;
+    var Result = function Result(stopped, result) {
+      this.stopped = stopped;
+      this.result = result;
+    };
+    var ResultPrototype = Result.prototype;
+    var iterate$1 = function iterate(iterable, unboundFunction, options) {
+      var that = options && options.that;
+      var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+      var IS_RECORD = !!(options && options.IS_RECORD);
+      var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+      var INTERRUPTED = !!(options && options.INTERRUPTED);
+      var fn = bind(unboundFunction, that);
+      var iterator, iterFn, index, length, result, next, step;
+      var stop = function stop(condition) {
+        if (iterator) iteratorClose(iterator, 'normal', condition);
+        return new Result(true, condition);
+      };
+      var callFn = function callFn(value) {
+        if (AS_ENTRIES) {
+          anObject(value);
+          return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+        }
+        return INTERRUPTED ? fn(value, stop) : fn(value);
+      };
+      if (IS_RECORD) {
+        iterator = iterable.iterator;
+      } else if (IS_ITERATOR) {
+        iterator = iterable;
+      } else {
+        iterFn = getIteratorMethod(iterable);
+        if (!iterFn) throw $TypeError(tryToString(iterable) + ' is not iterable');
+        // optimisation for array iterators
+        if (isArrayIteratorMethod(iterFn)) {
+          for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+            result = callFn(iterable[index]);
+            if (result && isPrototypeOf(ResultPrototype, result)) return result;
+          }
+          return new Result(false);
+        }
+        iterator = getIterator(iterable, iterFn);
+      }
+      next = IS_RECORD ? iterable.next : iterator.next;
+      while (!(step = call(next, iterator)).done) {
+        try {
+          result = callFn(step.value);
+        } catch (error) {
+          iteratorClose(iterator, 'throw', error);
+        }
+        if (_typeof(result) == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
+      }
+      return new Result(false);
+    };
+
+    var toPropertyKey = toPropertyKey$3;
+    var definePropertyModule = objectDefineProperty;
+    var createPropertyDescriptor = createPropertyDescriptor$4;
+    var createProperty$1 = function createProperty(object, key, value) {
+      var propertyKey = toPropertyKey(key);
+      if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));else object[propertyKey] = value;
+    };
+
+    var $ = _export;
+    var iterate = iterate$1;
+    var createProperty = createProperty$1;
+
+    // `Object.fromEntries` method
+    // https://github.com/tc39/proposal-object-from-entries
+    $({
+      target: 'Object',
+      stat: true
+    }, {
+      fromEntries: function fromEntries(iterable) {
+        var obj = {};
+        iterate(iterable, function (k, v) {
+          createProperty(obj, k, v);
+        }, {
+          AS_ENTRIES: true
+        });
+        return obj;
+      }
+    });
+
+    var path = path$3;
+    var fromEntries$2 = path.Object.fromEntries;
+
+    // iterable DOM collections
+    // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
+    var domIterables = {
+      CSSRuleList: 0,
+      CSSStyleDeclaration: 0,
+      CSSValueList: 0,
+      ClientRectList: 0,
+      DOMRectList: 0,
+      DOMStringList: 0,
+      DOMTokenList: 1,
+      DataTransferItemList: 0,
+      FileList: 0,
+      HTMLAllCollection: 0,
+      HTMLCollection: 0,
+      HTMLFormElement: 0,
+      HTMLSelectElement: 0,
+      MediaList: 0,
+      MimeTypeArray: 0,
+      NamedNodeMap: 0,
+      NodeList: 1,
+      PaintRequestList: 0,
+      Plugin: 0,
+      PluginArray: 0,
+      SVGLengthList: 0,
+      SVGNumberList: 0,
+      SVGPathSegList: 0,
+      SVGPointList: 0,
+      SVGStringList: 0,
+      SVGTransformList: 0,
+      SourceBufferList: 0,
+      StyleSheetList: 0,
+      TextTrackCueList: 0,
+      TextTrackList: 0,
+      TouchList: 0
+    };
+
+    var DOMIterables = domIterables;
+    var global$1 = global$c;
+    var classof = classof$3;
+    var createNonEnumerableProperty = createNonEnumerableProperty$5;
+    var Iterators = iterators;
+    var wellKnownSymbol = wellKnownSymbol$9;
+    var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+    for (var COLLECTION_NAME in DOMIterables) {
+      var Collection = global$1[COLLECTION_NAME];
+      var CollectionPrototype = Collection && Collection.prototype;
+      if (CollectionPrototype && classof(CollectionPrototype) !== TO_STRING_TAG) {
+        createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
+      }
+      Iterators[COLLECTION_NAME] = Iterators.Array;
+    }
+
+    var parent$1 = fromEntries$2;
+    var fromEntries$1 = parent$1;
+
+    var parent = fromEntries$1;
+    var fromEntries = parent;
+    var __polyfill_Object_fromEntries_1l7jl5fabj9k = /*@__PURE__*/getDefaultExportFromCjs(fromEntries);
+
+    exports.VKNumericLanguage = void 0;
+    (function (VKNumericLanguage) {
+        VKNumericLanguage["Armenian"] = "58";
+        VKNumericLanguage["Azerbaijani"] = "57";
+        VKNumericLanguage["Belarusian"] = "114";
+        VKNumericLanguage["English"] = "3";
+        VKNumericLanguage["Kazakh"] = "97";
+        VKNumericLanguage["Portuguese"] = "73";
+        VKNumericLanguage["Russian"] = "0";
+        VKNumericLanguage["Spanish"] = "4";
+        VKNumericLanguage["Ukrainian"] = "1";
+        VKNumericLanguage["Uzbek"] = "65";
+        VKNumericLanguage["Vietnamese"] = "75";
+    })(exports.VKNumericLanguage || (exports.VKNumericLanguage = {}));
+    var VK_DOMAIN = 'vk.com';
+    var loadVKLangPack = function (language, packName, packPrefix) { return __awaiter(void 0, void 0, void 0, function () {
+        var url, response, data;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    url = new URL("https://".concat(VK_DOMAIN, "/js/lang-pack.js"));
+                    url.searchParams.set('format', 'json');
+                    url.searchParams.set('name', packName);
+                    if (language !== undefined) {
+                        url.searchParams.set('lang', language);
+                    }
+                    return [4 /*yield*/, fetch(url.toString())];
+                case 1:
+                    response = _a.sent();
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    data = _a.sent();
+                    return [2 /*return*/, mapVKResponse(data, packPrefix)];
+            }
+        });
+    }); };
+    var mapVKResponse = function (data, packPrefix) { return __polyfill_Object_fromEntries_1l7jl5fabj9k(Object.entries(data.keys).map(function (_a) {
+        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+        return [key.substring("".concat(packPrefix, "_").length), mapToken(value)];
+    })); };
+    var mapToken = function (vkToken) { return Array.isArray(vkToken) ? vkToken[0] : vkToken; };
+
+    exports.InterfaceLanguage = void 0;
+    (function (InterfaceLanguage) {
+        InterfaceLanguage["RU"] = "ru";
+        InterfaceLanguage["EN"] = "en";
+    })(exports.InterfaceLanguage || (exports.InterfaceLanguage = {}));
+
+    exports.Logger = Logger;
+    exports.Observable = Observable;
+    exports.Subject = Subject;
+    exports.Subscription = Subscription;
+    exports.VERSION = VERSION;
+    exports.ValueSubject = ValueSubject;
+    exports.abortable = abortable;
+    exports.addScript = addScript;
+    exports.areQualitiesExact = areQualitiesExact;
+    exports.assertEmptyArray = assertEmptyArray;
+    exports.assertNever = assertNever;
+    exports.assertNonNullable = assertNonNullable;
+    exports.assertNotEmptyArray = assertNotEmptyArray;
+    exports.assertNullable = assertNullable;
+    exports.assertQualityIsExact = assertQualityIsExact;
+    exports.buffer = buffer;
+    exports.checkNever = checkNever;
+    exports.combine = combine;
+    exports.debounce = debounce;
+    exports.fillWithDefault = fillWithDefault;
+    exports.filter = filter;
+    exports.filterChanged = filterChanged;
+    exports.fromEvent = fromEvent;
+    exports.getCurrentBrowser = getCurrentBrowser;
+    exports.getExponentialDelay = getExponentialDelay;
+    exports.getHighestQuality = getHighestQuality;
+    exports.getIOSVersion = getIOSVersion;
+    exports.interval = interval;
+    exports.isHigher = isHigher;
+    exports.isHigherOrEqual = isHigherOrEqual;
+    exports.isIOS = isIOS;
+    exports.isInvariantQuality = isInvariantQuality;
+    exports.isLower = isLower;
+    exports.isLowerOrEqual = isLowerOrEqual;
+    exports.isMacLike = isMacLike;
+    exports.isNonNullable = isNonNullable;
+    exports.isNullable = isNullable;
+    exports.loadVKLangPack = loadVKLangPack;
+    exports.map = map;
+    exports.mapTo = mapTo;
+    exports.merge = merge;
+    exports.noop = noop;
+    exports.now = now;
+    exports.observableFrom = observableFrom;
+    exports.once = once;
+    exports.pairwise = pairwise;
+    exports.safeStorage = iframeSafeStorage;
+    exports.tap = tap;
+    exports.throttle = throttle;
+    exports.timeout = timeout;
+    exports.videoHeightToQuality = videoHeightToQuality;
+    exports.videoQualityToHeight = videoQualityToHeight;
+    exports.videoSizeToQuality = videoSizeToQuality;
+
+}));
+//# sourceMappingURL=es5.umd.js.map