@vkontakte/videoplayer-shared 1.0.30 → 1.0.31-dev.0e8d526.0

package/es2015.umd.js

@@ -0,0 +1,2928 @@
+(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';
+
+  const VERSION = '1.0.31-dev.0e8d526.0';
+
+  class Subscription {
+      constructor() {
+          this.subscriptions = [];
+      }
+      unsubscribe() {
+          const subscriptions = this.subscriptions;
+          this.subscriptions = [];
+          subscriptions.forEach((it) => typeof it === 'function' ? it() : it.unsubscribe());
+      }
+      add(item) {
+          this.subscriptions.push(item);
+          return this;
+      }
+  }
+
+  const assertNever = (x) => {
+      throw new Error(`${x} is value of unexpected type`);
+  };
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  const checkNever = (_x) => {
+  };
+
+  const noop = () => {
+      /* no op */
+  };
+
+  class Observable {
+      constructor(subscribe) {
+          if (subscribe) {
+              this._subscribe = subscribe;
+          }
+      }
+      subscribe(listener, error) {
+          var _a;
+          let errorEmitter;
+          if (!error) {
+              errorEmitter = { next: noop, error: noop };
+          }
+          else if (typeof error === 'function') {
+              errorEmitter = { next: error, error: noop };
+          }
+          else {
+              errorEmitter = {
+                  next: (value) => error.next(value),
+                  error: (value) => { var _a; return (_a = error.error) === null || _a === void 0 ? void 0 : _a.call(error, value); },
+              };
+          }
+          const emitter = typeof listener === 'function' ? {
+              next: (value) => {
+                  try {
+                      listener(value);
+                  }
+                  catch (e) {
+                      errorEmitter.next(e);
+                  }
+              },
+              error: (value) => errorEmitter.next(value),
+          } : {
+              next: (value) => listener.next(value),
+              error: (value) => listener.error ? listener.error(value) : errorEmitter.next(value),
+          };
+          let 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(() => {
+              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);
+              }
+          });
+      }
+      pipe(...operators) {
+          return operators.reduce((prev, op) => op(prev), this);
+      }
+      _subscribe(_emitter) {
+          /* empty */
+      }
+  }
+
+  class Subject extends Observable {
+      constructor() {
+          super();
+          this.keyCounter = 0;
+          this.subscribers = new Map();
+      }
+      next(value) {
+          this.subscribers.forEach((it) => it.next(value));
+      }
+      error(value) {
+          this.subscribers.forEach((it) => { var _a; return (_a = it.error) === null || _a === void 0 ? void 0 : _a.call(it, value); });
+      }
+      _subscribe(emitter) {
+          const key = this.keyCounter++;
+          this.subscribers.set(key, emitter);
+          return new Subscription().add(() => this.subscribers.delete(key));
+      }
+  }
+
+  class Logger {
+      constructor() {
+          this.log$ = new Subject();
+          this.logs = [];
+          this.log = (inputEntry) => {
+              const entry = Object.assign(Object.assign({}, inputEntry), { timestamp: Date.now() });
+              this.logs.push(entry);
+              this.log$.next(entry);
+          };
+          this.getAllLogs = () => this.logs;
+      }
+      createCustomLog(transform) {
+          return (...args) => {
+              let entry;
+              try {
+                  entry = transform(...args);
+              }
+              catch (_a) {
+                  entry = {
+                      message: 'error in `createCustomLog`',
+                      component: 'Logger',
+                  };
+              }
+              this.log(entry);
+          };
+      }
+      createComponentLog(component) {
+          return this.createCustomLog((entry) => (Object.assign({ component }, entry)));
+      }
+  }
+
+  function assertNonNullable(value, failMessage = `Assertion "value is not nullable" failed`) {
+      if (value === undefined || value === null) {
+          throw new Error(failMessage);
+      }
+  }
+  function assertNullable(value, 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);
+      }
+  }
+
+  const addScript = (scriptSrc, abortSignal, timeout) => new Promise((resolve, reject) => {
+      abortSignal.addEventListener('abort', () => {
+          removeListeners();
+          script.remove();
+      });
+      const onLoadFail = () => {
+          removeListeners();
+          reject();
+      };
+      const onLoadSuccess = () => {
+          removeListeners();
+          resolve();
+      };
+      const removeListeners = () => {
+          failTimeout && clearTimeout(failTimeout);
+          script.removeEventListener('load', onLoadSuccess);
+          script.removeEventListener('error', onLoadFail);
+      };
+      let failTimeout;
+      if (timeout) {
+          failTimeout = window.setTimeout(onLoadFail, timeout);
+      }
+      const script = document.createElement('script');
+      script.addEventListener('load', onLoadSuccess);
+      script.addEventListener('error', onLoadFail);
+      script.src = scriptSrc;
+      document.head.appendChild(script);
+  });
+
+  var _a;
+  const now = typeof ((_a = window.performance) === null || _a === void 0 ? void 0 : _a.now) === 'function' ?
+      () => window.performance.now() :
+      () => Date.now();
+
+  /******************************************************************************
+  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 */
+
+
+  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());
+      });
+  }
+
+  // Декоратор оборачивающий async функции в генераторы
+  // В этих async функциях await заменяем на yield, он передаёт контроль этой утилите
+  // Декоратор проверяет состояние сигнала и если тот не абортнут передаёт контроль внутрь функции обратно
+  // Если сигнал абортнут, целевая функция останавливается на точке вызова yield и не продолжает исполнение
+  // Таким образом её можно уничтожать не боясь что какой-то асинхронный код выстрелит после уничтожения
+  const abortable = (signal, createGenerator) => (...params) => __awaiter(void 0, void 0, void 0, function* () {
+      var _a;
+      const generator = createGenerator(...params);
+      let done = signal.aborted;
+      let value = undefined;
+      while (!done && !signal.aborted) {
+          const result = yield generator.next(value);
+          done = (_a = result.done) !== null && _a !== void 0 ? _a : false;
+          value = result.value;
+      }
+      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 = {}));
+  const getCurrentBrowser = () => {
+      const { userAgent } = window.navigator;
+      const isYandex = /yabrowser/i.test(userAgent) ? exports.CurrentClientBrowser.Yandex : undefined;
+      const isChrome = /chrome|crios/i.test(userAgent) ? exports.CurrentClientBrowser.Chrome : undefined;
+      const isChromium = /chromium/i.test(userAgent) ? exports.CurrentClientBrowser.Chromium : undefined;
+      const isFirefox = /firefox|fxios/i.test(userAgent) ? exports.CurrentClientBrowser.Firefox : undefined;
+      const isSafari = /webkit|safari|khtml/i.test(userAgent) ? exports.CurrentClientBrowser.Safari : undefined;
+      const isOpera = /opr\//i.test(userAgent) ? exports.CurrentClientBrowser.Opera : undefined;
+      const isEdge = /edg/i.test(userAgent) ? exports.CurrentClientBrowser.Edge : undefined;
+      const isAndroid = /android/i.test(userAgent) ? exports.CurrentClientDevice.Android : undefined;
+      const isiPhone = /iphone/i.test(userAgent) ? exports.CurrentClientDevice.iPhone : undefined;
+      const isiPad = /ipad/i.test(userAgent) ? exports.CurrentClientDevice.iPad : undefined;
+      const isiPod = /ipod/i.test(userAgent) ? exports.CurrentClientDevice.iPod : undefined;
+      const isMac = /mac/i.test(userAgent) ? exports.CurrentClientDevice.Mac : undefined;
+      const 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-устройства полноразмерное открытие сайтов
+  const isIOS = (checkForceDesktop = false) => {
+      const iosDevices = [exports.CurrentClientDevice.iPhone, exports.CurrentClientDevice.iPad, exports.CurrentClientDevice.iPod];
+      const isMobile = iosDevices.includes(getCurrentBrowser().device);
+      if (!checkForceDesktop) {
+          return isMobile;
+      }
+      const { userAgent, maxTouchPoints } = window.navigator;
+      return Boolean(isMobile || /macintosh/i.test(userAgent) && maxTouchPoints > 0);
+  };
+  const getIOSVersion = () => {
+      const { userAgent } = window.navigator;
+      const iosVersionMatch = userAgent.match(/Version\/(\d+(\.\d+)?)/i);
+      if (!iosVersionMatch) {
+          return null;
+      }
+      const versionString = iosVersionMatch[1];
+      const versionNumber = parseFloat(versionString);
+      if (isNaN(versionNumber)) {
+          return null;
+      }
+      return versionNumber;
+  };
+  const isMacLike = () => [exports.CurrentClientDevice.Mac, exports.CurrentClientDevice.iPhone, exports.CurrentClientDevice.iPad, exports.CurrentClientDevice.iPod].includes(getCurrentBrowser().device);
+
+  const getExponentialDelay = (errorsCount, { start = 0, factor = 2, max = Infinity, min = start, random = 0 } = {}) => {
+      let 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 = {}));
+  let runtimeStorage;
+  let availableStorage;
+  const key = `vk-videoplayer-dummy-key-${Math.random()}`;
+  const getAvailable = () => {
+      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;
+  };
+  const isPersistent = () => getAvailable() === Storage.LOCAL_STORAGE;
+  const get$1 = (key) => {
+      var _a, _b;
+      const 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);
+      }
+  };
+  const set$1 = (key, value) => {
+      const 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);
+      }
+  };
+  const has$1 = (key) => {
+      var _a;
+      const 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;
+      }
+  };
+  const remove = (key) => {
+      const 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);
+      }
+  };
+  const clear = () => {
+      const 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 = {}));
+
+  const videoQualitiesSizes = {
+      [exports.VideoQuality.Q_144P]: { width: 256, height: 144 },
+      [exports.VideoQuality.Q_240P]: { width: 428, height: 240 },
+      [exports.VideoQuality.Q_360P]: { width: 640, height: 360 },
+      [exports.VideoQuality.Q_480P]: { width: 856, height: 480 },
+      [exports.VideoQuality.Q_720P]: { width: 1280, height: 720 },
+      [exports.VideoQuality.Q_1080P]: { width: 1920, height: 1080 },
+      [exports.VideoQuality.Q_1440P]: { width: 2560, height: 1440 },
+      [exports.VideoQuality.Q_2160P]: { width: 3840, height: 2160 },
+      [exports.VideoQuality.Q_4320P]: { width: 7680, height: 4320 },
+  };
+  const isHigher = (a, b) => videoQualitiesSizes[a].height > videoQualitiesSizes[b].height;
+  const isHigherOrEqual = (a, b) => videoQualitiesSizes[a].height >= videoQualitiesSizes[b].height;
+  const isLower = (a, b) => videoQualitiesSizes[a].height < videoQualitiesSizes[b].height;
+  const isLowerOrEqual = (a, b) => videoQualitiesSizes[a].height <= videoQualitiesSizes[b].height;
+  const getHighestQuality = (qualities) => qualities.sort((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];
+  const allExactAscending = Object.keys(videoQualitiesSizes).sort((a, b) => isLower(a, b) ? -1 : 1);
+  /**
+   * Выбирает качество, наиболее близкое к указанной высоте кадра, но не менее её.
+   * @param tolerance позволяет выбрать качество менее заданной высоты на величину погрешности (в процентах)
+   */
+  const videoHeightToQuality = (height, tolerance = 0.02) => {
+      const qualities = [...allExactAscending];
+      return qualities.find((quality) => videoQualitiesSizes[quality].height * (1 + tolerance) >= height);
+  };
+  /**
+   * Выбирает качество описывающее заданные размеры видео потока, т.е. не меньше его.
+   */
+  const videoSizeToQuality = ({ width, height }) => {
+      const min = Math.min(width, height);
+      const max = Math.max(width, height);
+      return allExactAscending.find(testQuality => {
+          const testSize = videoQualitiesSizes[testQuality];
+          return testSize.width >= max &&
+              testSize.height >= min;
+      });
+  };
+  const videoQualityToHeight = (quality) => videoQualitiesSizes[quality].height;
+  const isInvariantQuality = (quality) => quality === exports.VideoQuality.INVARIANT;
+  const areQualitiesExact = (qualities) => qualities.every(q => !isInvariantQuality(q));
+  function assertQualityIsExact(quality) {
+      if (isInvariantQuality(quality)) {
+          throw new Error('Expected exact quality');
+      }
+  }
+
+  const fillWithDefault = (partial, defaultConfig) => {
+      const fullConfig = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
+      for (const topLevelKey of Object.keys(defaultConfig)) {
+          const defaultValue = defaultConfig[topLevelKey];
+          const 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;
+          }
+      }
+      return fullConfig;
+  };
+
+  class ValueSubject extends Subject {
+      constructor(initialValue) {
+          super();
+          this.value = initialValue;
+      }
+      next(value) {
+          super.next(this.value = value);
+      }
+      error(value) {
+          super.error(this.value = value);
+      }
+      getValue() {
+          return this.value;
+      }
+      _subscribe(emitter) {
+          const result = super._subscribe(emitter);
+          emitter.next(this.value);
+          return result;
+      }
+  }
+
+  function combine(observables) {
+      return new Observable((emitter) => {
+          const values = {};
+          let missingValuesCount = Object.keys(observables).length;
+          const createKeyListener = (key) => (value) => {
+              if (!(key in values)) {
+                  missingValuesCount--;
+              }
+              values[key] = value;
+              if (missingValuesCount === 0) {
+                  emitter.next(values);
+              }
+          };
+          return Object.entries(observables).reduce((subscription, [key, observable]) => {
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              return subscription.add(observable.subscribe(createKeyListener(key)));
+          }, new Subscription());
+      });
+  }
+
+  /**
+   *  Создаёт Observable, в который попадают все события исходных Observable (синхронно в момент возникновения)
+   */
+  function merge(...observables) {
+      return new Observable((emitter) => observables.reduce((subscription, it) => subscription.add(it.subscribe(emitter)), new Subscription()));
+  }
+
+  var timeout = (time) => new Observable((emitter) => {
+      const id = window.setTimeout(() => {
+          try {
+              emitter.next();
+          }
+          catch (e) {
+              if (emitter.error) {
+                  emitter.error(e);
+              }
+              else {
+                  throw e;
+              }
+          }
+      }, time);
+      return () => window.clearTimeout(id);
+  });
+
+  var interval = (time) => new Observable((emitter) => {
+      const id = window.setInterval(() => emitter.next(), time);
+      return () => window.clearInterval(id);
+  });
+
+  var observableFrom = (values) => new Observable((emitter) => {
+      values.forEach((it) => emitter.next(it));
+  });
+
+  var fromEvent = (target, eventName) => new Observable((emitter) => {
+      const listener = (e) => emitter.next(e); // eslint-disable-line @typescript-eslint/no-explicit-any
+      target.addEventListener(eventName, listener);
+      return () => target.removeEventListener(eventName, listener);
+  });
+
+  function buffer(size) {
+      return (o) => new Observable((emitter) => o.subscribe(new BufferEmitter(emitter, size)));
+  }
+  class BufferEmitter {
+      constructor(destination, size) {
+          this.destination = destination;
+          this.size = size;
+          this.lastValues = [];
+      }
+      next(value) {
+          if (this.lastValues.length === this.size) {
+              this.lastValues.shift();
+          }
+          this.lastValues.push(value);
+          this.destination.next(this.lastValues);
+      }
+      error(e) {
+          var _a, _b;
+          (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+      }
+  }
+
+  const defaultConfig$1 = {
+      leading: false,
+      trailing: true,
+  };
+  function debounce(time, config = defaultConfig$1) {
+      return (o) => new Observable((emitter) => o.subscribe(new DebounceEmitter(emitter, time, config)));
+  }
+  class DebounceEmitter {
+      constructor(destination, time, config) {
+          this.destination = destination;
+          this.time = time;
+          this.config = config;
+      }
+      next(value) {
+          this.lastValue = value;
+          if (isNonNullable(this.timeout)) {
+              window.clearTimeout(this.timeout);
+          }
+          else if (this.config.leading) {
+              this.destination.next(value);
+          }
+          this.timeout = window.setTimeout(() => {
+              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);
+      }
+      error(e) {
+          var _a, _b;
+          (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+      }
+  }
+
+  const defaultConfig = {
+      leading: true,
+      trailing: false,
+  };
+  function throttle(time, config = defaultConfig) {
+      return (o) => new Observable((emitter) => o.subscribe(new ThrottleEmitter(emitter, time, config)));
+  }
+  class ThrottleEmitter {
+      constructor(destination, time, config) {
+          this.destination = destination;
+          this.time = time;
+          this.config = config;
+      }
+      next(value) {
+          this.lastValue = value;
+          if (isNullable(this.timeout)) {
+              if (this.config.leading) {
+                  this.destination.next(value);
+              }
+              this.timeout = window.setTimeout(() => {
+                  if (this.config.trailing) {
+                      this.destination.next(this.lastValue); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+                  }
+                  this.timeout = undefined;
+              }, this.time);
+          }
+      }
+      error(e) {
+          var _a, _b;
+          (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+      }
+  }
+
+  /**
+   *  Пропускает только те события, которые удовлетворяют предикату
+   */
+  function filter(predicate) {
+      return (o) => new Observable((emitter) => o.subscribe(new FilterEmitter(emitter, predicate)));
+  }
+  class FilterEmitter {
+      constructor(destination, predicate) {
+          this.destination = destination;
+          this.predicate = predicate;
+      }
+      next(value) {
+          let suitable;
+          try {
+              suitable = this.predicate(value);
+          }
+          catch (e) {
+              this.error(e);
+              throw e;
+          }
+          if (suitable) {
+              this.destination.next(value);
+          }
+      }
+      error(e) {
+          var _a, _b;
+          (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+      }
+  }
+
+  /**
+   * Пропускает только события, содержащие значения, отличные от предыдущего
+   */
+  function filterChanged(equal = (a, b) => a === b) {
+      return (o) => new Observable((emitter) => o.subscribe(new FilterChangedEmitter(emitter, equal)));
+  }
+  const NO_VALUE = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
+  class FilterChangedEmitter {
+      constructor(destination, predicate) {
+          this.destination = destination;
+          this.predicate = predicate;
+          this.lastValue = NO_VALUE;
+      }
+      next(value) {
+          let 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);
+          }
+      }
+      error(e) {
+          var _a, _b;
+          (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+      }
+  }
+
+  function map(mapper) {
+      return (o) => new Observable((emitter) => o.subscribe(new MapEmitter$1(emitter, mapper)));
+  }
+  let MapEmitter$1 = class MapEmitter {
+      constructor(destination, mapper) {
+          this.destination = destination;
+          this.mapper = mapper;
+      }
+      next(value) {
+          let result;
+          try {
+              result = this.mapper(value);
+          }
+          catch (e) {
+              this.error(e);
+              throw e;
+          }
+          this.destination.next(result);
+      }
+      error(value) {
+          var _a, _b;
+          (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+      }
+  };
+
+  function mapTo(value) {
+      return map(() => value);
+  }
+
+  /**
+   *  Отписывается от исходного потока после получения первого события.
+   */
+  function once() {
+      return (o) => new Observable((emitter) => {
+          let eventFired = false;
+          let subscriptionReady = false;
+          const subscription = o.subscribe((event) => {
+              if (!eventFired) {
+                  eventFired = true;
+                  emitter.next(event);
+              }
+              if (subscriptionReady) {
+                  subscription.unsubscribe();
+              }
+          }, 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 (o) => new Observable((emitter) => o.subscribe(new PairwiseEmitter(emitter)));
+  }
+  class PairwiseEmitter {
+      constructor(destination) {
+          this.destination = destination;
+          this.hasLast = false;
+      }
+      next(value) {
+          const 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
+      }
+      error(value) {
+          var _a, _b;
+          (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+      }
+  }
+
+  function tap(effect) {
+      return (o) => new Observable((emitter) => o.subscribe(new MapEmitter(emitter, effect)));
+  }
+  class MapEmitter {
+      constructor(destination, effect) {
+          this.destination = destination;
+          this.effect = effect;
+      }
+      next(value) {
+          try {
+              this.effect(value);
+          }
+          catch (e) {
+              this.error(e);
+              throw e;
+          }
+          this.destination.next(value);
+      }
+      error(value) {
+          var _a, _b;
+          (_b = (_a = this.destination).error) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+      }
+  }
+
+  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 = {}));
+
+  class Emitter {
+    constructor() {
+      Object.defineProperty(this, 'listeners', { value: {}, writable: true, configurable: true });
+    }
+    addEventListener(type, callback, options) {
+      if (!(type in this.listeners)) {
+        this.listeners[type] = [];
+      }
+      this.listeners[type].push({ callback, options });
+    }
+    removeEventListener(type, callback) {
+      if (!(type in this.listeners)) {
+        return;
+      }
+      const stack = this.listeners[type];
+      for (let i = 0, l = stack.length; i < l; i++) {
+        if (stack[i].callback === callback) {
+          stack.splice(i, 1);
+          return;
+        }
+      }
+    }
+    dispatchEvent(event) {
+      if (!(event.type in this.listeners)) {
+        return;
+      }
+      const stack = this.listeners[event.type];
+      const stackToCall = stack.slice();
+      for (let i = 0, l = stackToCall.length; i < l; i++) {
+        const listener = stackToCall[i];
+        try {
+          listener.callback.call(this, event);
+        } catch (e) {
+          Promise.resolve().then(() => {
+            throw e;
+          });
+        }
+        if (listener.options && listener.options.once) {
+          this.removeEventListener(event.type, listener.callback);
+        }
+      }
+      return !event.defaultPrevented;
+    }
+  }
+
+  class AbortSignal extends Emitter {
+    constructor() {
+      super();
+      // 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 (!this.listeners) {
+        Emitter.call(this);
+      }
+
+      // 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(this, 'aborted', { value: false, writable: true, configurable: true });
+      Object.defineProperty(this, 'onabort', { value: null, writable: true, configurable: true });
+      Object.defineProperty(this, 'reason', { value: undefined, writable: true, configurable: true });
+    }
+    toString() {
+      return '[object AbortSignal]';
+    }
+    dispatchEvent(event) {
+      if (event.type === 'abort') {
+        this.aborted = true;
+        if (typeof this.onabort === 'function') {
+          this.onabort.call(this, event);
+        }
+      }
+
+      super.dispatchEvent(event);
+    }
+  }
+
+  class AbortController {
+    constructor() {
+      // 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 });
+    }
+    abort(reason) {
+      let 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,
+          };
+        }
+      }
+
+      let 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);
+    }
+    toString() {
+      return '[object 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 };
+    }
+    const {
+      fetch,
+      Request: NativeRequest = fetch.Request,
+      AbortController: NativeAbortController,
+      __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL = false,
+    } = patchTargets;
+
+    if (
+      !polyfillNeeded({
+        fetch,
+        Request: NativeRequest,
+        AbortController: NativeAbortController,
+        __FORCE_INSTALL_ABORTCONTROLLER_POLYFILL,
+      })
+    ) {
+      return { fetch, Request };
+    }
+
+    let 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) {
+        let 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;
+        }
+        const 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;
+    }
+
+    const realFetch = fetch;
+    const abortableFetch = (input, init) => {
+      const signal = Request && Request.prototype.isPrototypeOf(input) ? input.signal : init ? init.signal : undefined;
+
+      if (signal) {
+        let 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
+        const cancellation = new Promise((_, reject) => {
+          signal.addEventListener('abort', () => 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 };
+  }
+
+  /* eslint-disable @typescript-eslint/ban-ts-comment */
+  // @ts-expect-error
+  const needed = polyfillNeeded({
+      fetch: window.fetch,
+      Request: window.Request,
+      AbortController: window.AbortController,
+  });
+  const polyfill = needed ? abortableFetchDecorator({
+      fetch: window.fetch,
+      Request: window.Request,
+      AbortController: window.AbortController,
+  }) : undefined;
+  const 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 (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 (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 (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 (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 (it) {
+    return IndexedObject(requireObjectCoercible$1(it));
+  };
+
+  var iterators = {};
+
+  var check = function (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 == 'object' && globalThis) ||
+    check(typeof window == 'object' && window) ||
+    // eslint-disable-next-line no-restricted-globals -- safe
+    check(typeof self == 'object' && self) ||
+    check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+    // eslint-disable-next-line no-new-func -- fallback
+    (function () { return this; })() || commonjsGlobal || Function('return this')();
+
+  var documentAll$2 = typeof 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));
+
+  var isCallable$9 = isCallable$b;
+  var $documentAll = documentAll_1;
+
+  var documentAll = $documentAll.all;
+
+  var isObject$6 = $documentAll.IS_HTMLDDA ? function (it) {
+    return typeof it == 'object' ? it !== null : isCallable$9(it) || it === documentAll;
+  } : function (it) {
+    return typeof 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 () { 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 (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 () { 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 (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 (variable) {
+    return isCallable$8(variable) ? variable : undefined;
+  };
+
+  var getBuiltIn$2 = function (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;
+  });
+
+  /* eslint-disable es/no-symbol -- required for testing */
+
+  var NATIVE_SYMBOL$1 = symbolConstructorDetection;
+
+  var useSymbolAsUid = NATIVE_SYMBOL$1
+    && !Symbol.sham
+    && typeof Symbol.iterator == 'symbol';
+
+  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 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 (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 (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 (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 (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 (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 (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 (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$1 = global$4.Symbol;
+  var WellKnownSymbolsStore = shared$2('wks');
+  var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
+
+  var wellKnownSymbol$9 = function (name) {
+    if (!hasOwn$7(WellKnownSymbolsStore, name)) {
+      WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$7(Symbol$1, name)
+        ? Symbol$1[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 (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 (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 (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 (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 (it) {
+    return has(it) ? get(it) : set(it, {});
+  };
+
+  var getterFor = function (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 (it, metadata) {
+      if (store.has(it)) throw TypeError$1(OBJECT_ALREADY_INITIALIZED);
+      metadata.facade = it;
+      store.set(it, metadata);
+      return metadata;
+    };
+    get = function (it) {
+      return store.get(it) || {};
+    };
+    has = function (it) {
+      return store.has(it);
+    };
+  } else {
+    var STATE = sharedKey$2('state');
+    hiddenKeys$2[STATE] = true;
+    set = function (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 (it) {
+      return hasOwn$6(it, STATE) ? it[STATE] : {};
+    };
+    has = function (it) {
+      return hasOwn$6(it, STATE);
+    };
+  }
+
+  var internalState = {
+    set: set,
+    get: get,
+    has: has,
+    enforce: enforce,
+    getterFor: getterFor
+  };
+
+  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 == '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 (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 (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 (fn, that) {
+    aCallable$1(fn);
+    return that === undefined ? fn : NATIVE_BIND ? bind$2(fn, that) : function (/* ...args */) {
+      return fn.apply(that, arguments);
+    };
+  };
+
+  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 (NativeConstructor) {
+    var Wrapper = function (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 (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 targetProperty == typeof 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 (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 (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 (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 (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 (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 (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 () { /* empty */ };
+
+  var scriptTag = function (content) {
+    return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+  };
+
+  // Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+  var NullProtoObjectViaActiveX = function (activeXDocument) {
+    activeXDocument.write(scriptTag(''));
+    activeXDocument.close();
+    var temp = activeXDocument.parentWindow.Object;
+    activeXDocument = null; // avoid memory leak
+    return temp;
+  };
+
+  // Create object with fake `null` prototype: use iframe Object with cleared prototype
+  var NullProtoObjectViaIFrame = function () {
+    // Thrash, waste and sodomy: IE GC bug
+    var iframe = documentCreateElement('iframe');
+    var JS = 'java' + SCRIPT + ':';
+    var iframeDocument;
+    iframe.style.display = 'none';
+    html.appendChild(iframe);
+    // https://github.com/zloirock/core-js/issues/475
+    iframe.src = String(JS);
+    iframeDocument = iframe.contentWindow.document;
+    iframeDocument.open();
+    iframeDocument.write(scriptTag('document.F=Object'));
+    iframeDocument.close();
+    return iframeDocument.F;
+  };
+
+  // Check for document.domain and active x support
+  // No need to use active x approach when document.domain is not set
+  // see https://github.com/es-shims/es5-shim/issues/150
+  // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+  // avoid IE GC bug
+  var activeXDocument;
+  var NullProtoObject = function () {
+    try {
+      activeXDocument = new ActiveXObject('htmlfile');
+    } catch (error) { /* ignore */ }
+    NullProtoObject = typeof document != 'undefined'
+      ? document.domain && activeXDocument
+        ? NullProtoObjectViaActiveX(activeXDocument) // old IE
+        : NullProtoObjectViaIFrame()
+      : NullProtoObjectViaActiveX(activeXDocument); // WSH
+    var length = enumBugKeys.length;
+    while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+    return NullProtoObject();
+  };
+
+  hiddenKeys[IE_PROTO$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 (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 (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 (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 () { return this; };
+
+  var iteratorCreateConstructor = function (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 () { return this; };
+
+  var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+    createIteratorConstructor(IteratorConstructor, NAME, next);
+
+    var getIterationMethod = function (KIND) {
+      if (KIND === DEFAULT && defaultIterator) return defaultIterator;
+      if (!BUGGY_SAFARI_ITERATORS && KIND 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 (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 (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 (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 (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 (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;
+  };
+
+  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 (stopped, result) {
+    this.stopped = stopped;
+    this.result = result;
+  };
+
+  var ResultPrototype = Result.prototype;
+
+  var iterate$1 = function (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 (condition) {
+      if (iterator) iteratorClose(iterator, 'normal', condition);
+      return new Result(true, condition);
+    };
+
+    var callFn = function (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 (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_lmk8764ajd87 = /*@__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 = {}));
+  const VK_DOMAIN = 'vk.com';
+  const loadVKLangPack = (language, packName, packPrefix) => __awaiter(void 0, void 0, void 0, function* () {
+      const url = new URL(`https://${VK_DOMAIN}/js/lang-pack.js`);
+      url.searchParams.set('format', 'json');
+      url.searchParams.set('name', packName);
+      if (language !== undefined) {
+          url.searchParams.set('lang', language);
+      }
+      const response = yield fetch(url.toString());
+      const data = yield response.json();
+      return mapVKResponse(data, packPrefix);
+  });
+  const mapVKResponse = (data, packPrefix) => __polyfill_Object_fromEntries_lmk8764ajd87(Object.entries(data.keys).map(([key, value]) => [key.substring(`${packPrefix}_`.length), mapToken(value)]));
+  const mapToken = (vkToken) => 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=es2015.umd.js.map