@paypay/mini-app-js-sdk 2.51.0 → 2.55.0

package/dist/mini-app-js-sdk.es.js

@@ -18,6 +18,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -213,6 +225,8 @@ const PPUtilFunctionName = {
   saveRefreshToken: "saveRefreshToken",
   saveCodeVerifier: "saveCodeVerifier",
   makeVisible: "makeVisible",
+  hideIframe: "hideIframe",
+  showIframe: "showIframe",
   consoleDebugInfo: "consoleDebugInfo",
   clientPopState: "clientPopState"
 };
@@ -292,14 +306,26 @@ const smartPaymentSupportedFunctions = [
   "getUAID",
   "getCashbackInformation",
   "renderCoupons",
-  "getLoginUrl"
+  "getLoginUrl",
+  "renderButton"
 ];
-class PPError extends Error {
-  constructor(message, errorCode) {
-    super(message);
-    this.errorCode = errorCode;
-  }
-}
+const JS_SDK_VERSION = "2.55.0";
+const REVISION = "a78757a";
+const coreBaseUrl = new URL("https://mini-app-sdk-core.paypay.ne.jp/");
+const CORE_IFRAME_ORIGIN = coreBaseUrl.origin;
+const CORE_IFRAME_URL = new URL(
+  `./iframe.html?v=${JS_SDK_VERSION}&rev=${REVISION}`,
+  coreBaseUrl
+).href;
+const COUPON_IFRAME_URL = new URL(
+  `./coupon/iframe.html?v=${JS_SDK_VERSION}`,
+  coreBaseUrl
+).href;
+new URL(
+  `./button/iframe.html?v=${JS_SDK_VERSION}`,
+  coreBaseUrl
+).href;
+const SENTRY_DSN = "https://377b45f154b1fb17d8e98a6ffb67030a@o4505819519320064.ingest.sentry.io/4506579323453440";
 var MiniAppErrorType = /* @__PURE__ */ ((MiniAppErrorType2) => {
   MiniAppErrorType2["success"] = "SUCCESS";
   MiniAppErrorType2["invalidUrl"] = "INVALID_URL";
@@ -374,19 +400,123 @@ var MiniAppErrorType = /* @__PURE__ */ ((MiniAppErrorType2) => {
   MiniAppErrorType2["invalidVirtualAccount"] = "INVALID_VIRTUAL_ACCOUNT";
   return MiniAppErrorType2;
 })(MiniAppErrorType || {});
-const JS_SDK_VERSION = "2.51.0";
-const REVISION = "9c03362";
-const coreBaseUrl = new URL("https://mini-app-sdk-core.paypay.ne.jp/");
-const CORE_IFRAME_ORIGIN = coreBaseUrl.origin;
-const CORE_IFRAME_URL = new URL(
-  `./iframe.html?v=${JS_SDK_VERSION}&rev=${REVISION}`,
-  coreBaseUrl
-).href;
-const COUPON_IFRAME_URL = new URL(
-  `./coupon/iframe.html?v=${JS_SDK_VERSION}`,
-  coreBaseUrl
-).href;
-const SENTRY_DSN = "https://377b45f154b1fb17d8e98a6ffb67030a@o4505819519320064.ingest.sentry.io/4506579323453440";
+function setCookie({ name, value, options }) {
+  return api.set(name, value, options);
+}
+function getCookie({ name }) {
+  return api.get(name);
+}
+function removeCookie$1({ name, options }) {
+  return api.remove(name, options);
+}
+function setLocalStorage({
+  name,
+  value
+}) {
+  return localStorage.setItem(name, value);
+}
+function getLocalStorage({ name }) {
+  return localStorage.getItem(name);
+}
+function removeLocalStorage({ name }) {
+  return localStorage.removeItem(name);
+}
+function setSessionStorage({
+  name,
+  value
+}) {
+  return sessionStorage.setItem(name, value);
+}
+function getSessionStorage({ name }) {
+  return sessionStorage.getItem(name);
+}
+function removeSessionStorage({ name }) {
+  return sessionStorage.removeItem(name);
+}
+function removeQueryParametersFromUrl(removeParams) {
+  const url = new URL(window.location.href);
+  removeParams.forEach((param) => url.searchParams.delete(param));
+  const newURL = `${url.pathname}${url.search}`;
+  history.replaceState(history.state, "", newURL);
+}
+function getUrl() {
+  return window.location.href;
+}
+class PPError extends Error {
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
+  }
+}
+function insertIframe(_a) {
+  var {
+    containerSelector: containerQuerySelector,
+    attributes: _b
+  } = _a, _c = _b, { styles } = _c, attributes = __objRest(_c, ["styles"]);
+  return new Promise((resolve, reject) => {
+    const container = document.querySelector(containerQuerySelector);
+    if (!container) {
+      reject(
+        new PPError(
+          `Container with selector "${containerQuerySelector}" not found.`,
+          MiniAppErrorType.badRequestInsufficientParameter
+        )
+      );
+      return;
+    }
+    const iframe = document.createElement("iframe");
+    iframe.onload = () => {
+      resolve(true);
+    };
+    iframe.onerror = () => {
+      reject(
+        new PPError("Failed to load iframe.", MiniAppErrorType.notReachable)
+      );
+    };
+    Object.assign(iframe.style, styles);
+    Object.entries(attributes).forEach(([key, value]) => {
+      iframe.setAttribute(key, value);
+    });
+    container.innerHTML = "";
+    container.appendChild(iframe);
+  });
+}
+function removeElement({ selector }) {
+  const element = document.querySelector(selector);
+  if (element) {
+    element.remove();
+    return true;
+  }
+  return false;
+}
+function updateElementStyle({
+  selector,
+  styles
+}) {
+  const element = document.querySelector(selector);
+  if (element) {
+    Object.assign(element.style, styles);
+    return true;
+  }
+  return false;
+}
+const clientWindowBridgeFunctions = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getCookie,
+  getLocalStorage,
+  getSessionStorage,
+  getUrl,
+  insertIframe,
+  removeCookie: removeCookie$1,
+  removeElement,
+  removeLocalStorage,
+  removeQueryParametersFromUrl,
+  removeSessionStorage,
+  setCookie,
+  setLocalStorage,
+  setSessionStorage,
+  updateElementStyle
+}, Symbol.toStringTag, { value: "Module" }));
 const SDK_VERSION = "8.45.1";
 const GLOBAL_OBJ = globalThis;
 function getGlobalSingleton(name, creator, obj) {
@@ -1270,6 +1400,109 @@ function addBreadcrumbToSentry(breadcrumb) {
     addBreadcrumb(breadcrumb);
   }
 }
+class LocalStorageProxy {
+  constructor() {
+    var _a;
+    this.useLocalStorage = true;
+    this.memoryStorage = {};
+    try {
+      localStorage.setItem(
+        PpLocalStorageKey.initializedAt,
+        Date.now().toString()
+      );
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key != null) {
+          this.memoryStorage[key] = (_a = localStorage.getItem(key)) != null ? _a : "";
+        }
+      }
+    } catch (e) {
+      this.useLocalStorage = false;
+    }
+  }
+  getItem(key) {
+    var _a, _b;
+    if (this.useLocalStorage) {
+      try {
+        if (localStorage.getItem(PpLocalStorageKey.initializedAt) != null) {
+          const val = localStorage.getItem(key);
+          if (val != null) {
+            return val;
+          }
+          return (_a = api.get(key)) != null ? _a : null;
+        } else {
+          console.debug("local storage value has lost unexpectedly.");
+          addBreadcrumbToSentry({
+            message: "local storage value has lost unexpectedly.",
+            category: "storage"
+          });
+        }
+      } catch (e) {
+      }
+    }
+    this.useLocalStorage = false;
+    return (_b = this.memoryStorage[key]) != null ? _b : null;
+  }
+  setItem(key, value) {
+    this.memoryStorage[key] = value;
+    if (this.useLocalStorage) {
+      try {
+        localStorage.setItem(key, value);
+        removeCookie(key);
+      } catch (e) {
+        this.useLocalStorage = false;
+        console.warn("localStorage has become unavailable.");
+      }
+    }
+  }
+  removeItem(key) {
+    delete this.memoryStorage[key];
+    try {
+      localStorage.removeItem(key);
+      removeCookie(key);
+    } catch (e) {
+      this.useLocalStorage = false;
+    }
+  }
+  clear() {
+    try {
+      localStorage.clear();
+      localStorage.setItem(
+        PpLocalStorageKey.initializedAt,
+        Date.now().toString()
+      );
+      clearAllCookies();
+    } catch (e) {
+    }
+    this.memoryStorage = {};
+  }
+}
+const cookieAttributes = Object.freeze(__spreadValues({
+  expires: 365,
+  sameSite: "None"
+}, { secure: true, Partitioned: true }));
+function writeCookie(key, value) {
+  api.set(key, value, cookieAttributes);
+}
+function removeCookie(key) {
+  api.remove(key, cookieAttributes);
+}
+(() => {
+  return new LocalStorageProxy();
+})();
+function clearAllCookies() {
+  const cookies = api.get();
+  for (const key in cookies) {
+    removeCookie(key);
+  }
+  writeCookie(PpLocalStorageKey.initializedAt, Date.now().toString());
+}
+function isFunction(val) {
+  return typeof val === "function";
+}
+function getRandomString() {
+  return Math.random().toString(36).substring(7);
+}
 function middlewareHandler(middlewares, message, messageHandler, params) {
   let index = -1;
   const next = (_params) => __async(this, null, function* () {
@@ -1288,12 +1521,27 @@ const deepClone = (obj) => {
   }
   return JSON.parse(JSON.stringify(obj));
 };
+const hasCallbacks = (params) => {
+  var _a;
+  const callbacks = (_a = params[0]) == null ? void 0 : _a.callbacks;
+  return typeof callbacks === "object" && callbacks !== null;
+};
+const getCallbacksPlaceholder = (callbacks) => {
+  return Object.keys(callbacks).reduce(
+    (cbs, name) => {
+      cbs[name] = true;
+      return cbs;
+    },
+    {}
+  );
+};
 class WindowBridge {
   constructor(functions, allowedOrigins, middlewares = []) {
-    this.deferredCallbacks = {};
+    this.deferredPromises = {};
     this.functions = functions;
     this.allowedOrigins = allowedOrigins;
     this.middlewares = middlewares;
+    this.registeredCallbacks = {};
     this.messageEventHandler = this.messageEventHandler.bind(this);
     this.subscribeToMessageEvent();
   }
@@ -1332,6 +1580,10 @@ class WindowBridge {
       this.handleResponse(
         receivedMessageEvent
       );
+    } else if (receivedMessageEvent.data.type === "callback") {
+      this.handleCallback(
+        receivedMessageEvent
+      );
     }
   }
   handleRequest(receivedMessageEvent) {
@@ -1346,6 +1598,18 @@ class WindowBridge {
           MiniAppErrorType.functionNotFound
         );
       }
+      const params = deepClone(receivedMessageEvent.data.params);
+      if (hasCallbacks(params)) {
+        params[0].callbacks = Object.keys(params[0].callbacks).reduce(
+          (cbs, name) => {
+            cbs[name] = (...args) => {
+              this.invokeCallback(receivedMessageEvent, name, args);
+            };
+            return cbs;
+          },
+          {}
+        );
+      }
       try {
         this.sendSuccessResponse(
           receivedMessageEvent,
@@ -1353,7 +1617,7 @@ class WindowBridge {
             [...this.middlewares, ...(_a = functionToInvoke.middlewares) != null ? _a : []],
             receivedMessageEvent,
             functionToInvoke,
-            deepClone(receivedMessageEvent.data.params)
+            params
           )
         );
       } catch (error) {
@@ -1370,17 +1634,18 @@ class WindowBridge {
     });
   }
   handleResponse(receivedMessageEvent) {
-    if (!this.deferredCallbacks[receivedMessageEvent.data.key]) {
+    if (!this.deferredPromises[receivedMessageEvent.data.key]) {
       console.warn(
-        `Callback for ${receivedMessageEvent.data.functionName} not found`
+        `Promise for ${receivedMessageEvent.data.functionName} not found`
       );
       return;
     }
-    const [resolve, reject] = this.deferredCallbacks[receivedMessageEvent.data.key];
-    delete this.deferredCallbacks[receivedMessageEvent.data.key];
+    const [resolve, reject] = this.deferredPromises[receivedMessageEvent.data.key];
+    delete this.deferredPromises[receivedMessageEvent.data.key];
     if (receivedMessageEvent.data.status === "success") {
       resolve(receivedMessageEvent.data.result);
     } else {
+      delete this.registeredCallbacks[receivedMessageEvent.data.key];
       reject(
         new PPError(
           receivedMessageEvent.data.message,
@@ -1389,6 +1654,18 @@ class WindowBridge {
       );
     }
   }
+  handleCallback(receivedMessageEvent) {
+    var _a;
+    const { key, callbackName, args } = receivedMessageEvent.data;
+    const callback = (_a = this.registeredCallbacks[key]) == null ? void 0 : _a[callbackName];
+    if (!callback) {
+      console.warn(
+        `Callback with key ${key} and name ${callbackName} not found.`
+      );
+      return;
+    }
+    callback(...args);
+  }
   sendErrorResponse(receivedMessageEvent, message, errorCode) {
     sendWindowBridgeErrorToSentry(
       receivedMessageEvent.data.functionName,
@@ -1408,18 +1685,81 @@ class WindowBridge {
     });
   }
   sendResponse(receivedMessageEvent, data) {
-    var _a;
-    (_a = receivedMessageEvent.source) == null ? void 0 : _a.postMessage(
+    this.sendMessage(
+      receivedMessageEvent.source,
+      receivedMessageEvent.origin,
       __spreadValues({
-        forWindowBridge: true,
         type: "response",
         key: receivedMessageEvent.data.key,
         functionName: receivedMessageEvent.data.functionName
+      }, data)
+    );
+  }
+  invokeCallback(receivedMessageEvent, callbackName, args) {
+    this.sendMessage(
+      receivedMessageEvent.source,
+      receivedMessageEvent.origin,
+      {
+        type: "callback",
+        key: receivedMessageEvent.data.key,
+        functionName: receivedMessageEvent.data.functionName,
+        callbackName,
+        args
+      }
+    );
+  }
+  sendMessage(targetWindow, origin, data) {
+    targetWindow.postMessage(
+      __spreadValues({
+        forWindowBridge: true
       }, deepClone(data)),
-      // Just a hack to overcome weird function overload mismatch
-      receivedMessageEvent.origin
+      origin
     );
   }
+  sendRequest(getTargetWindow, targetWindowOrigin, functionName, params) {
+    return new Promise((resolve, reject) => __async(this, null, function* () {
+      const key = `${functionName}--${getRandomString()}`;
+      try {
+        const targetWindow = yield getTargetWindow();
+        if (!targetWindow) {
+          throw new Error("Target window is undefined");
+        }
+        let messageParams = params[0];
+        if (hasCallbacks(params)) {
+          const callbacks = params[0].callbacks;
+          this.addFunctionCallbacks(key, callbacks);
+          messageParams = __spreadProps(__spreadValues({}, params[0]), {
+            // Convert callbacks to a format that can be sent over postMessage
+            callbacks: getCallbacksPlaceholder(callbacks)
+          });
+        }
+        this.deferredPromises[key] = [resolve, reject];
+        this.sendMessage(targetWindow, targetWindowOrigin, {
+          type: "request",
+          key,
+          functionName,
+          params: [messageParams]
+        });
+      } catch (error) {
+        delete this.deferredPromises[key];
+        delete this.registeredCallbacks[key];
+        reject(
+          new PPError(
+            error.message,
+            MiniAppErrorType.messageSendingFailed
+          )
+        );
+      }
+    }));
+  }
+  addFunctionCallbacks(key, callbacks) {
+    Object.keys(callbacks).forEach((callbackName) => {
+      if (typeof callbacks[callbackName] !== "function") {
+        throw new Error(`Callback ${callbackName} is not a function`);
+      }
+    });
+    this.registeredCallbacks[key] = __spreadValues({}, callbacks);
+  }
   /**
    * A static method to create a new `WindowBridge` instance and enforce singleton pattern
    * @param functions an objection of functions that can be invoked on the current window
@@ -1479,2192 +1819,22 @@ class WindowBridge {
   getTargetWindowFunctionProxy(getTargetWindow, targetWindowOrigin) {
     return new Proxy(this, {
       get(windowBridgeInstance, functionName) {
-        return (...params) => (
-          // eslint-disable-next-line no-async-promise-executor, @typescript-eslint/no-misused-promises
-          new Promise((resolve, reject) => __async(this, null, function* () {
-            const functionNameString = functionName.toString();
-            const key = `${functionNameString}--${getRandomString()}`;
-            try {
-              const targetWindow = yield getTargetWindow();
-              if (!targetWindow) {
-                throw new Error("Target window is undefined");
-              }
-              windowBridgeInstance.deferredCallbacks[key] = [resolve, reject];
-              targetWindow.postMessage(
-                {
-                  forWindowBridge: true,
-                  type: "request",
-                  functionName: functionNameString,
-                  key,
-                  params: deepClone(params)
-                },
-                targetWindowOrigin
-              );
-            } catch (error) {
-              delete windowBridgeInstance.deferredCallbacks[key];
-              reject(
-                new PPError(
-                  error.message,
-                  MiniAppErrorType.messageSendingFailed
-                )
-              );
-            }
-          }))
+        return (...params) => windowBridgeInstance.sendRequest(
+          getTargetWindow,
+          targetWindowOrigin,
+          functionName.toString(),
+          params
         );
       }
     });
   }
 }
-const BROWSER_ALIASES_MAP = {
-  "Amazon Silk": "amazon_silk",
-  "Android Browser": "android",
-  Bada: "bada",
-  BlackBerry: "blackberry",
-  Chrome: "chrome",
-  Chromium: "chromium",
-  Electron: "electron",
-  Epiphany: "epiphany",
-  Firefox: "firefox",
-  Focus: "focus",
-  Generic: "generic",
-  "Google Search": "google_search",
-  Googlebot: "googlebot",
-  "Internet Explorer": "ie",
-  "K-Meleon": "k_meleon",
-  Maxthon: "maxthon",
-  "Microsoft Edge": "edge",
-  "MZ Browser": "mz",
-  "NAVER Whale Browser": "naver",
-  Opera: "opera",
-  "Opera Coast": "opera_coast",
-  PhantomJS: "phantomjs",
-  Puffin: "puffin",
-  QupZilla: "qupzilla",
-  QQ: "qq",
-  QQLite: "qqlite",
-  Safari: "safari",
-  Sailfish: "sailfish",
-  "Samsung Internet for Android": "samsung_internet",
-  SeaMonkey: "seamonkey",
-  Sleipnir: "sleipnir",
-  Swing: "swing",
-  Tizen: "tizen",
-  "UC Browser": "uc",
-  Vivaldi: "vivaldi",
-  "WebOS Browser": "webos",
-  WeChat: "wechat",
-  "Yandex Browser": "yandex",
-  Roku: "roku"
-};
-const BROWSER_MAP = {
-  amazon_silk: "Amazon Silk",
-  android: "Android Browser",
-  bada: "Bada",
-  blackberry: "BlackBerry",
-  chrome: "Chrome",
-  chromium: "Chromium",
-  electron: "Electron",
-  epiphany: "Epiphany",
-  firefox: "Firefox",
-  focus: "Focus",
-  generic: "Generic",
-  googlebot: "Googlebot",
-  google_search: "Google Search",
-  ie: "Internet Explorer",
-  k_meleon: "K-Meleon",
-  maxthon: "Maxthon",
-  edge: "Microsoft Edge",
-  mz: "MZ Browser",
-  naver: "NAVER Whale Browser",
-  opera: "Opera",
-  opera_coast: "Opera Coast",
-  phantomjs: "PhantomJS",
-  puffin: "Puffin",
-  qupzilla: "QupZilla",
-  qq: "QQ Browser",
-  qqlite: "QQ Browser Lite",
-  safari: "Safari",
-  sailfish: "Sailfish",
-  samsung_internet: "Samsung Internet for Android",
-  seamonkey: "SeaMonkey",
-  sleipnir: "Sleipnir",
-  swing: "Swing",
-  tizen: "Tizen",
-  uc: "UC Browser",
-  vivaldi: "Vivaldi",
-  webos: "WebOS Browser",
-  wechat: "WeChat",
-  yandex: "Yandex Browser"
-};
-const PLATFORMS_MAP = {
-  tablet: "tablet",
-  mobile: "mobile",
-  desktop: "desktop",
-  tv: "tv"
-};
-const OS_MAP = {
-  WindowsPhone: "Windows Phone",
-  Windows: "Windows",
-  MacOS: "macOS",
-  iOS: "iOS",
-  Android: "Android",
-  WebOS: "WebOS",
-  BlackBerry: "BlackBerry",
-  Bada: "Bada",
-  Tizen: "Tizen",
-  Linux: "Linux",
-  ChromeOS: "Chrome OS",
-  PlayStation4: "PlayStation 4",
-  Roku: "Roku"
-};
-const ENGINE_MAP = {
-  EdgeHTML: "EdgeHTML",
-  Blink: "Blink",
-  Trident: "Trident",
-  Presto: "Presto",
-  Gecko: "Gecko",
-  WebKit: "WebKit"
-};
-class Utils {
-  /**
-   * Get first matched item for a string
-   * @param {RegExp} regexp
-   * @param {String} ua
-   * @return {Array|{index: number, input: string}|*|boolean|string}
-   */
-  static getFirstMatch(regexp, ua) {
-    const match = ua.match(regexp);
-    return match && match.length > 0 && match[1] || "";
-  }
-  /**
-   * Get second matched item for a string
-   * @param regexp
-   * @param {String} ua
-   * @return {Array|{index: number, input: string}|*|boolean|string}
-   */
-  static getSecondMatch(regexp, ua) {
-    const match = ua.match(regexp);
-    return match && match.length > 1 && match[2] || "";
-  }
-  /**
-   * Match a regexp and return a constant or undefined
-   * @param {RegExp} regexp
-   * @param {String} ua
-   * @param {*} _const Any const that will be returned if regexp matches the string
-   * @return {*}
-   */
-  static matchAndReturnConst(regexp, ua, _const) {
-    if (regexp.test(ua)) {
-      return _const;
-    }
-    return void 0;
-  }
-  static getWindowsVersionName(version) {
-    switch (version) {
-      case "NT":
-        return "NT";
-      case "XP":
-        return "XP";
-      case "NT 5.0":
-        return "2000";
-      case "NT 5.1":
-        return "XP";
-      case "NT 5.2":
-        return "2003";
-      case "NT 6.0":
-        return "Vista";
-      case "NT 6.1":
-        return "7";
-      case "NT 6.2":
-        return "8";
-      case "NT 6.3":
-        return "8.1";
-      case "NT 10.0":
-        return "10";
-      default:
-        return void 0;
-    }
-  }
-  /**
-   * Get macOS version name
-   *    10.5 - Leopard
-   *    10.6 - Snow Leopard
-   *    10.7 - Lion
-   *    10.8 - Mountain Lion
-   *    10.9 - Mavericks
-   *    10.10 - Yosemite
-   *    10.11 - El Capitan
-   *    10.12 - Sierra
-   *    10.13 - High Sierra
-   *    10.14 - Mojave
-   *    10.15 - Catalina
-   *
-   * @example
-   *   getMacOSVersionName("10.14") // 'Mojave'
-   *
-   * @param  {string} version
-   * @return {string} versionName
-   */
-  static getMacOSVersionName(version) {
-    const v = version.split(".").splice(0, 2).map((s) => parseInt(s, 10) || 0);
-    v.push(0);
-    if (v[0] !== 10) return void 0;
-    switch (v[1]) {
-      case 5:
-        return "Leopard";
-      case 6:
-        return "Snow Leopard";
-      case 7:
-        return "Lion";
-      case 8:
-        return "Mountain Lion";
-      case 9:
-        return "Mavericks";
-      case 10:
-        return "Yosemite";
-      case 11:
-        return "El Capitan";
-      case 12:
-        return "Sierra";
-      case 13:
-        return "High Sierra";
-      case 14:
-        return "Mojave";
-      case 15:
-        return "Catalina";
-      default:
-        return void 0;
-    }
-  }
-  /**
-   * Get Android version name
-   *    1.5 - Cupcake
-   *    1.6 - Donut
-   *    2.0 - Eclair
-   *    2.1 - Eclair
-   *    2.2 - Froyo
-   *    2.x - Gingerbread
-   *    3.x - Honeycomb
-   *    4.0 - Ice Cream Sandwich
-   *    4.1 - Jelly Bean
-   *    4.4 - KitKat
-   *    5.x - Lollipop
-   *    6.x - Marshmallow
-   *    7.x - Nougat
-   *    8.x - Oreo
-   *    9.x - Pie
-   *
-   * @example
-   *   getAndroidVersionName("7.0") // 'Nougat'
-   *
-   * @param  {string} version
-   * @return {string} versionName
-   */
-  static getAndroidVersionName(version) {
-    const v = version.split(".").splice(0, 2).map((s) => parseInt(s, 10) || 0);
-    v.push(0);
-    if (v[0] === 1 && v[1] < 5) return void 0;
-    if (v[0] === 1 && v[1] < 6) return "Cupcake";
-    if (v[0] === 1 && v[1] >= 6) return "Donut";
-    if (v[0] === 2 && v[1] < 2) return "Eclair";
-    if (v[0] === 2 && v[1] === 2) return "Froyo";
-    if (v[0] === 2 && v[1] > 2) return "Gingerbread";
-    if (v[0] === 3) return "Honeycomb";
-    if (v[0] === 4 && v[1] < 1) return "Ice Cream Sandwich";
-    if (v[0] === 4 && v[1] < 4) return "Jelly Bean";
-    if (v[0] === 4 && v[1] >= 4) return "KitKat";
-    if (v[0] === 5) return "Lollipop";
-    if (v[0] === 6) return "Marshmallow";
-    if (v[0] === 7) return "Nougat";
-    if (v[0] === 8) return "Oreo";
-    if (v[0] === 9) return "Pie";
-    return void 0;
-  }
-  /**
-   * Get version precisions count
-   *
-   * @example
-   *   getVersionPrecision("1.10.3") // 3
-   *
-   * @param  {string} version
-   * @return {number}
-   */
-  static getVersionPrecision(version) {
-    return version.split(".").length;
-  }
-  /**
-   * Calculate browser version weight
-   *
-   * @example
-   *   compareVersions('1.10.2.1',  '1.8.2.1.90')    // 1
-   *   compareVersions('1.010.2.1', '1.09.2.1.90');  // 1
-   *   compareVersions('1.10.2.1',  '1.10.2.1');     // 0
-   *   compareVersions('1.10.2.1',  '1.0800.2');     // -1
-   *   compareVersions('1.10.2.1',  '1.10',  true);  // 0
-   *
-   * @param {String} versionA versions versions to compare
-   * @param {String} versionB versions versions to compare
-   * @param {boolean} [isLoose] enable loose comparison
-   * @return {Number} comparison result: -1 when versionA is lower,
-   * 1 when versionA is bigger, 0 when both equal
-   */
-  /* eslint consistent-return: 1 */
-  static compareVersions(versionA, versionB, isLoose = false) {
-    const versionAPrecision = Utils.getVersionPrecision(versionA);
-    const versionBPrecision = Utils.getVersionPrecision(versionB);
-    let precision = Math.max(versionAPrecision, versionBPrecision);
-    let lastPrecision = 0;
-    const chunks = Utils.map([versionA, versionB], (version) => {
-      const delta = precision - Utils.getVersionPrecision(version);
-      const _version = version + new Array(delta + 1).join(".0");
-      return Utils.map(_version.split("."), (chunk) => new Array(20 - chunk.length).join("0") + chunk).reverse();
-    });
-    if (isLoose) {
-      lastPrecision = precision - Math.min(versionAPrecision, versionBPrecision);
-    }
-    precision -= 1;
-    while (precision >= lastPrecision) {
-      if (chunks[0][precision] > chunks[1][precision]) {
-        return 1;
-      }
-      if (chunks[0][precision] === chunks[1][precision]) {
-        if (precision === lastPrecision) {
-          return 0;
-        }
-        precision -= 1;
-      } else if (chunks[0][precision] < chunks[1][precision]) {
-        return -1;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Array::map polyfill
-   *
-   * @param  {Array} arr
-   * @param  {Function} iterator
-   * @return {Array}
-   */
-  static map(arr, iterator) {
-    const result = [];
-    let i;
-    if (Array.prototype.map) {
-      return Array.prototype.map.call(arr, iterator);
-    }
-    for (i = 0; i < arr.length; i += 1) {
-      result.push(iterator(arr[i]));
-    }
-    return result;
-  }
-  /**
-   * Array::find polyfill
-   *
-   * @param  {Array} arr
-   * @param  {Function} predicate
-   * @return {Array}
-   */
-  static find(arr, predicate) {
-    let i;
-    let l;
-    if (Array.prototype.find) {
-      return Array.prototype.find.call(arr, predicate);
-    }
-    for (i = 0, l = arr.length; i < l; i += 1) {
-      const value = arr[i];
-      if (predicate(value, i)) {
-        return value;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Object::assign polyfill
-   *
-   * @param  {Object} obj
-   * @param  {Object} ...objs
-   * @return {Object}
-   */
-  static assign(obj, ...assigners) {
-    const result = obj;
-    let i;
-    let l;
-    if (Object.assign) {
-      return Object.assign(obj, ...assigners);
-    }
-    for (i = 0, l = assigners.length; i < l; i += 1) {
-      const assigner = assigners[i];
-      if (typeof assigner === "object" && assigner !== null) {
-        const keys = Object.keys(assigner);
-        keys.forEach((key) => {
-          result[key] = assigner[key];
-        });
-      }
-    }
-    return obj;
-  }
-  /**
-   * Get short version/alias for a browser name
-   *
-   * @example
-   *   getBrowserAlias('Microsoft Edge') // edge
-   *
-   * @param  {string} browserName
-   * @return {string}
-   */
-  static getBrowserAlias(browserName) {
-    return BROWSER_ALIASES_MAP[browserName];
-  }
-  /**
-   * Get short version/alias for a browser name
-   *
-   * @example
-   *   getBrowserAlias('edge') // Microsoft Edge
-   *
-   * @param  {string} browserAlias
-   * @return {string}
-   */
-  static getBrowserTypeByAlias(browserAlias) {
-    return BROWSER_MAP[browserAlias] || "";
-  }
-}
-const commonVersionIdentifier = /version\/(\d+(\.?_?\d+)+)/i;
-const browsersList = [
-  /* Googlebot */
-  {
-    test: [/googlebot/i],
-    describe(ua) {
-      const browser = {
-        name: "Googlebot"
-      };
-      const version = Utils.getFirstMatch(/googlebot\/(\d+(\.\d+))/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  /* Opera < 13.0 */
-  {
-    test: [/opera/i],
-    describe(ua) {
-      const browser = {
-        name: "Opera"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  /* Opera > 13.0 */
-  {
-    test: [/opr\/|opios/i],
-    describe(ua) {
-      const browser = {
-        name: "Opera"
-      };
-      const version = Utils.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/SamsungBrowser/i],
-    describe(ua) {
-      const browser = {
-        name: "Samsung Internet for Android"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/Whale/i],
-    describe(ua) {
-      const browser = {
-        name: "NAVER Whale Browser"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/MZBrowser/i],
-    describe(ua) {
-      const browser = {
-        name: "MZ Browser"
-      };
-      const version = Utils.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/focus/i],
-    describe(ua) {
-      const browser = {
-        name: "Focus"
-      };
-      const version = Utils.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/swing/i],
-    describe(ua) {
-      const browser = {
-        name: "Swing"
-      };
-      const version = Utils.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/coast/i],
-    describe(ua) {
-      const browser = {
-        name: "Opera Coast"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/opt\/\d+(?:.?_?\d+)+/i],
-    describe(ua) {
-      const browser = {
-        name: "Opera Touch"
-      };
-      const version = Utils.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/yabrowser/i],
-    describe(ua) {
-      const browser = {
-        name: "Yandex Browser"
-      };
-      const version = Utils.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/ucbrowser/i],
-    describe(ua) {
-      const browser = {
-        name: "UC Browser"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/Maxthon|mxios/i],
-    describe(ua) {
-      const browser = {
-        name: "Maxthon"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/epiphany/i],
-    describe(ua) {
-      const browser = {
-        name: "Epiphany"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/puffin/i],
-    describe(ua) {
-      const browser = {
-        name: "Puffin"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/sleipnir/i],
-    describe(ua) {
-      const browser = {
-        name: "Sleipnir"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/k-meleon/i],
-    describe(ua) {
-      const browser = {
-        name: "K-Meleon"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/micromessenger/i],
-    describe(ua) {
-      const browser = {
-        name: "WeChat"
-      };
-      const version = Utils.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/qqbrowser/i],
-    describe(ua) {
-      const browser = {
-        name: /qqbrowserlite/i.test(ua) ? "QQ Browser Lite" : "QQ Browser"
-      };
-      const version = Utils.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/msie|trident/i],
-    describe(ua) {
-      const browser = {
-        name: "Internet Explorer"
-      };
-      const version = Utils.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/\sedg\//i],
-    describe(ua) {
-      const browser = {
-        name: "Microsoft Edge"
-      };
-      const version = Utils.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/edg([ea]|ios)/i],
-    describe(ua) {
-      const browser = {
-        name: "Microsoft Edge"
-      };
-      const version = Utils.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/vivaldi/i],
-    describe(ua) {
-      const browser = {
-        name: "Vivaldi"
-      };
-      const version = Utils.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/seamonkey/i],
-    describe(ua) {
-      const browser = {
-        name: "SeaMonkey"
-      };
-      const version = Utils.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/sailfish/i],
-    describe(ua) {
-      const browser = {
-        name: "Sailfish"
-      };
-      const version = Utils.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/silk/i],
-    describe(ua) {
-      const browser = {
-        name: "Amazon Silk"
-      };
-      const version = Utils.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/phantom/i],
-    describe(ua) {
-      const browser = {
-        name: "PhantomJS"
-      };
-      const version = Utils.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/slimerjs/i],
-    describe(ua) {
-      const browser = {
-        name: "SlimerJS"
-      };
-      const version = Utils.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
-    describe(ua) {
-      const browser = {
-        name: "BlackBerry"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/(web|hpw)[o0]s/i],
-    describe(ua) {
-      const browser = {
-        name: "WebOS Browser"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua) || Utils.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/bada/i],
-    describe(ua) {
-      const browser = {
-        name: "Bada"
-      };
-      const version = Utils.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/tizen/i],
-    describe(ua) {
-      const browser = {
-        name: "Tizen"
-      };
-      const version = Utils.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/qupzilla/i],
-    describe(ua) {
-      const browser = {
-        name: "QupZilla"
-      };
-      const version = Utils.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/firefox|iceweasel|fxios/i],
-    describe(ua) {
-      const browser = {
-        name: "Firefox"
-      };
-      const version = Utils.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/electron/i],
-    describe(ua) {
-      const browser = {
-        name: "Electron"
-      };
-      const version = Utils.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/MiuiBrowser/i],
-    describe(ua) {
-      const browser = {
-        name: "Miui"
-      };
-      const version = Utils.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/chromium/i],
-    describe(ua) {
-      const browser = {
-        name: "Chromium"
-      };
-      const version = Utils.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, ua) || Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/chrome|crios|crmo/i],
-    describe(ua) {
-      const browser = {
-        name: "Chrome"
-      };
-      const version = Utils.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  {
-    test: [/GSA/i],
-    describe(ua) {
-      const browser = {
-        name: "Google Search"
-      };
-      const version = Utils.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  /* Android Browser */
-  {
-    test(parser) {
-      const notLikeAndroid = !parser.test(/like android/i);
-      const butAndroid = parser.test(/android/i);
-      return notLikeAndroid && butAndroid;
-    },
-    describe(ua) {
-      const browser = {
-        name: "Android Browser"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  /* PlayStation 4 */
-  {
-    test: [/playstation 4/i],
-    describe(ua) {
-      const browser = {
-        name: "PlayStation 4"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  /* Safari */
-  {
-    test: [/safari|applewebkit/i],
-    describe(ua) {
-      const browser = {
-        name: "Safari"
-      };
-      const version = Utils.getFirstMatch(commonVersionIdentifier, ua);
-      if (version) {
-        browser.version = version;
-      }
-      return browser;
-    }
-  },
-  /* Something else */
-  {
-    test: [/.*/i],
-    describe(ua) {
-      const regexpWithoutDeviceSpec = /^(.*)\/(.*) /;
-      const regexpWithDeviceSpec = /^(.*)\/(.*)[ \t]\((.*)/;
-      const hasDeviceSpec = ua.search("\\(") !== -1;
-      const regexp = hasDeviceSpec ? regexpWithDeviceSpec : regexpWithoutDeviceSpec;
-      return {
-        name: Utils.getFirstMatch(regexp, ua),
-        version: Utils.getSecondMatch(regexp, ua)
-      };
-    }
-  }
-];
-const osParsersList = [
-  /* Roku */
-  {
-    test: [/Roku\/DVP/],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, ua);
-      return {
-        name: OS_MAP.Roku,
-        version
-      };
-    }
-  },
-  /* Windows Phone */
-  {
-    test: [/windows phone/i],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, ua);
-      return {
-        name: OS_MAP.WindowsPhone,
-        version
-      };
-    }
-  },
-  /* Windows */
-  {
-    test: [/windows /i],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, ua);
-      const versionName = Utils.getWindowsVersionName(version);
-      return {
-        name: OS_MAP.Windows,
-        version,
-        versionName
-      };
-    }
-  },
-  /* Firefox on iPad */
-  {
-    test: [/Macintosh(.*?) FxiOS(.*?)\//],
-    describe(ua) {
-      const result = {
-        name: OS_MAP.iOS
-      };
-      const version = Utils.getSecondMatch(/(Version\/)(\d[\d.]+)/, ua);
-      if (version) {
-        result.version = version;
-      }
-      return result;
-    }
-  },
-  /* macOS */
-  {
-    test: [/macintosh/i],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, ua).replace(/[_\s]/g, ".");
-      const versionName = Utils.getMacOSVersionName(version);
-      const os = {
-        name: OS_MAP.MacOS,
-        version
-      };
-      if (versionName) {
-        os.versionName = versionName;
-      }
-      return os;
-    }
-  },
-  /* iOS */
-  {
-    test: [/(ipod|iphone|ipad)/i],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, ua).replace(/[_\s]/g, ".");
-      return {
-        name: OS_MAP.iOS,
-        version
-      };
-    }
-  },
-  /* Android */
-  {
-    test(parser) {
-      const notLikeAndroid = !parser.test(/like android/i);
-      const butAndroid = parser.test(/android/i);
-      return notLikeAndroid && butAndroid;
-    },
-    describe(ua) {
-      const version = Utils.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, ua);
-      const versionName = Utils.getAndroidVersionName(version);
-      const os = {
-        name: OS_MAP.Android,
-        version
-      };
-      if (versionName) {
-        os.versionName = versionName;
-      }
-      return os;
-    }
-  },
-  /* WebOS */
-  {
-    test: [/(web|hpw)[o0]s/i],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, ua);
-      const os = {
-        name: OS_MAP.WebOS
-      };
-      if (version && version.length) {
-        os.version = version;
-      }
-      return os;
-    }
-  },
-  /* BlackBerry */
-  {
-    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, ua) || Utils.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, ua) || Utils.getFirstMatch(/\bbb(\d+)/i, ua);
-      return {
-        name: OS_MAP.BlackBerry,
-        version
-      };
-    }
-  },
-  /* Bada */
-  {
-    test: [/bada/i],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, ua);
-      return {
-        name: OS_MAP.Bada,
-        version
-      };
-    }
-  },
-  /* Tizen */
-  {
-    test: [/tizen/i],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, ua);
-      return {
-        name: OS_MAP.Tizen,
-        version
-      };
-    }
-  },
-  /* Linux */
-  {
-    test: [/linux/i],
-    describe() {
-      return {
-        name: OS_MAP.Linux
-      };
-    }
-  },
-  /* Chrome OS */
-  {
-    test: [/CrOS/],
-    describe() {
-      return {
-        name: OS_MAP.ChromeOS
-      };
-    }
-  },
-  /* Playstation 4 */
-  {
-    test: [/PlayStation 4/],
-    describe(ua) {
-      const version = Utils.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, ua);
-      return {
-        name: OS_MAP.PlayStation4,
-        version
-      };
-    }
-  }
-];
-const platformParsersList = [
-  /* Googlebot */
-  {
-    test: [/googlebot/i],
-    describe() {
-      return {
-        type: "bot",
-        vendor: "Google"
-      };
-    }
-  },
-  /* Huawei */
-  {
-    test: [/huawei/i],
-    describe(ua) {
-      const model = Utils.getFirstMatch(/(can-l01)/i, ua) && "Nova";
-      const platform = {
-        type: PLATFORMS_MAP.mobile,
-        vendor: "Huawei"
-      };
-      if (model) {
-        platform.model = model;
-      }
-      return platform;
-    }
-  },
-  /* Nexus Tablet */
-  {
-    test: [/nexus\s*(?:7|8|9|10).*/i],
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tablet,
-        vendor: "Nexus"
-      };
-    }
-  },
-  /* iPad */
-  {
-    test: [/ipad/i],
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tablet,
-        vendor: "Apple",
-        model: "iPad"
-      };
-    }
-  },
-  /* Firefox on iPad */
-  {
-    test: [/Macintosh(.*?) FxiOS(.*?)\//],
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tablet,
-        vendor: "Apple",
-        model: "iPad"
-      };
-    }
-  },
-  /* Amazon Kindle Fire */
-  {
-    test: [/kftt build/i],
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tablet,
-        vendor: "Amazon",
-        model: "Kindle Fire HD 7"
-      };
-    }
-  },
-  /* Another Amazon Tablet with Silk */
-  {
-    test: [/silk/i],
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tablet,
-        vendor: "Amazon"
-      };
-    }
-  },
-  /* Tablet */
-  {
-    test: [/tablet(?! pc)/i],
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tablet
-      };
-    }
-  },
-  /* iPod/iPhone */
-  {
-    test(parser) {
-      const iDevice = parser.test(/ipod|iphone/i);
-      const likeIDevice = parser.test(/like (ipod|iphone)/i);
-      return iDevice && !likeIDevice;
-    },
-    describe(ua) {
-      const model = Utils.getFirstMatch(/(ipod|iphone)/i, ua);
-      return {
-        type: PLATFORMS_MAP.mobile,
-        vendor: "Apple",
-        model
-      };
-    }
-  },
-  /* Nexus Mobile */
-  {
-    test: [/nexus\s*[0-6].*/i, /galaxy nexus/i],
-    describe() {
-      return {
-        type: PLATFORMS_MAP.mobile,
-        vendor: "Nexus"
-      };
-    }
-  },
-  /* Mobile */
-  {
-    test: [/[^-]mobi/i],
-    describe() {
-      return {
-        type: PLATFORMS_MAP.mobile
-      };
-    }
-  },
-  /* BlackBerry */
-  {
-    test(parser) {
-      return parser.getBrowserName(true) === "blackberry";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.mobile,
-        vendor: "BlackBerry"
-      };
-    }
-  },
-  /* Bada */
-  {
-    test(parser) {
-      return parser.getBrowserName(true) === "bada";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.mobile
-      };
-    }
-  },
-  /* Windows Phone */
-  {
-    test(parser) {
-      return parser.getBrowserName() === "windows phone";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.mobile,
-        vendor: "Microsoft"
-      };
-    }
-  },
-  /* Android Tablet */
-  {
-    test(parser) {
-      const osMajorVersion = Number(String(parser.getOSVersion()).split(".")[0]);
-      return parser.getOSName(true) === "android" && osMajorVersion >= 3;
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tablet
-      };
-    }
-  },
-  /* Android Mobile */
-  {
-    test(parser) {
-      return parser.getOSName(true) === "android";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.mobile
-      };
-    }
-  },
-  /* desktop */
-  {
-    test(parser) {
-      return parser.getOSName(true) === "macos";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.desktop,
-        vendor: "Apple"
-      };
-    }
-  },
-  /* Windows */
-  {
-    test(parser) {
-      return parser.getOSName(true) === "windows";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.desktop
-      };
-    }
-  },
-  /* Linux */
-  {
-    test(parser) {
-      return parser.getOSName(true) === "linux";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.desktop
-      };
-    }
-  },
-  /* PlayStation 4 */
-  {
-    test(parser) {
-      return parser.getOSName(true) === "playstation 4";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tv
-      };
-    }
-  },
-  /* Roku */
-  {
-    test(parser) {
-      return parser.getOSName(true) === "roku";
-    },
-    describe() {
-      return {
-        type: PLATFORMS_MAP.tv
-      };
-    }
-  }
-];
-const enginesParsersList = [
-  /* EdgeHTML */
-  {
-    test(parser) {
-      return parser.getBrowserName(true) === "microsoft edge";
-    },
-    describe(ua) {
-      const isBlinkBased = /\sedg\//i.test(ua);
-      if (isBlinkBased) {
-        return {
-          name: ENGINE_MAP.Blink
-        };
-      }
-      const version = Utils.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i, ua);
-      return {
-        name: ENGINE_MAP.EdgeHTML,
-        version
-      };
-    }
-  },
-  /* Trident */
-  {
-    test: [/trident/i],
-    describe(ua) {
-      const engine = {
-        name: ENGINE_MAP.Trident
-      };
-      const version = Utils.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        engine.version = version;
-      }
-      return engine;
-    }
-  },
-  /* Presto */
-  {
-    test(parser) {
-      return parser.test(/presto/i);
-    },
-    describe(ua) {
-      const engine = {
-        name: ENGINE_MAP.Presto
-      };
-      const version = Utils.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        engine.version = version;
-      }
-      return engine;
-    }
-  },
-  /* Gecko */
-  {
-    test(parser) {
-      const isGecko = parser.test(/gecko/i);
-      const likeGecko = parser.test(/like gecko/i);
-      return isGecko && !likeGecko;
-    },
-    describe(ua) {
-      const engine = {
-        name: ENGINE_MAP.Gecko
-      };
-      const version = Utils.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        engine.version = version;
-      }
-      return engine;
-    }
-  },
-  /* Blink */
-  {
-    test: [/(apple)?webkit\/537\.36/i],
-    describe() {
-      return {
-        name: ENGINE_MAP.Blink
-      };
-    }
-  },
-  /* WebKit */
-  {
-    test: [/(apple)?webkit/i],
-    describe(ua) {
-      const engine = {
-        name: ENGINE_MAP.WebKit
-      };
-      const version = Utils.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i, ua);
-      if (version) {
-        engine.version = version;
-      }
-      return engine;
-    }
-  }
-];
-class Parser {
-  /**
-   * Create instance of Parser
-   *
-   * @param {String} UA User-Agent string
-   * @param {Boolean} [skipParsing=false] parser can skip parsing in purpose of performance
-   * improvements if you need to make a more particular parsing
-   * like {@link Parser#parseBrowser} or {@link Parser#parsePlatform}
-   *
-   * @throw {Error} in case of empty UA String
-   *
-   * @constructor
-   */
-  constructor(UA, skipParsing = false) {
-    if (UA === void 0 || UA === null || UA === "") {
-      throw new Error("UserAgent parameter can't be empty");
-    }
-    this._ua = UA;
-    this.parsedResult = {};
-    if (skipParsing !== true) {
-      this.parse();
-    }
-  }
-  /**
-   * Get UserAgent string of current Parser instance
-   * @return {String} User-Agent String of the current <Parser> object
-   *
-   * @public
-   */
-  getUA() {
-    return this._ua;
-  }
-  /**
-   * Test a UA string for a regexp
-   * @param {RegExp} regex
-   * @return {Boolean}
-   */
-  test(regex) {
-    return regex.test(this._ua);
-  }
-  /**
-   * Get parsed browser object
-   * @return {Object}
-   */
-  parseBrowser() {
-    this.parsedResult.browser = {};
-    const browserDescriptor = Utils.find(browsersList, (_browser) => {
-      if (typeof _browser.test === "function") {
-        return _browser.test(this);
-      }
-      if (_browser.test instanceof Array) {
-        return _browser.test.some((condition) => this.test(condition));
-      }
-      throw new Error("Browser's test function is not valid");
-    });
-    if (browserDescriptor) {
-      this.parsedResult.browser = browserDescriptor.describe(this.getUA());
-    }
-    return this.parsedResult.browser;
-  }
-  /**
-   * Get parsed browser object
-   * @return {Object}
-   *
-   * @public
-   */
-  getBrowser() {
-    if (this.parsedResult.browser) {
-      return this.parsedResult.browser;
-    }
-    return this.parseBrowser();
-  }
-  /**
-   * Get browser's name
-   * @return {String} Browser's name or an empty string
-   *
-   * @public
-   */
-  getBrowserName(toLowerCase) {
-    if (toLowerCase) {
-      return String(this.getBrowser().name).toLowerCase() || "";
-    }
-    return this.getBrowser().name || "";
-  }
-  /**
-   * Get browser's version
-   * @return {String} version of browser
-   *
-   * @public
-   */
-  getBrowserVersion() {
-    return this.getBrowser().version;
-  }
-  /**
-   * Get OS
-   * @return {Object}
-   *
-   * @example
-   * this.getOS();
-   * {
-   *   name: 'macOS',
-   *   version: '10.11.12'
-   * }
-   */
-  getOS() {
-    if (this.parsedResult.os) {
-      return this.parsedResult.os;
-    }
-    return this.parseOS();
-  }
-  /**
-   * Parse OS and save it to this.parsedResult.os
-   * @return {*|{}}
-   */
-  parseOS() {
-    this.parsedResult.os = {};
-    const os = Utils.find(osParsersList, (_os) => {
-      if (typeof _os.test === "function") {
-        return _os.test(this);
-      }
-      if (_os.test instanceof Array) {
-        return _os.test.some((condition) => this.test(condition));
-      }
-      throw new Error("Browser's test function is not valid");
-    });
-    if (os) {
-      this.parsedResult.os = os.describe(this.getUA());
-    }
-    return this.parsedResult.os;
-  }
-  /**
-   * Get OS name
-   * @param {Boolean} [toLowerCase] return lower-cased value
-   * @return {String} name of the OS — macOS, Windows, Linux, etc.
-   */
-  getOSName(toLowerCase) {
-    const { name } = this.getOS();
-    if (toLowerCase) {
-      return String(name).toLowerCase() || "";
-    }
-    return name || "";
-  }
-  /**
-   * Get OS version
-   * @return {String} full version with dots ('10.11.12', '5.6', etc)
-   */
-  getOSVersion() {
-    return this.getOS().version;
-  }
-  /**
-   * Get parsed platform
-   * @return {{}}
-   */
-  getPlatform() {
-    if (this.parsedResult.platform) {
-      return this.parsedResult.platform;
-    }
-    return this.parsePlatform();
-  }
-  /**
-   * Get platform name
-   * @param {Boolean} [toLowerCase=false]
-   * @return {*}
-   */
-  getPlatformType(toLowerCase = false) {
-    const { type } = this.getPlatform();
-    if (toLowerCase) {
-      return String(type).toLowerCase() || "";
-    }
-    return type || "";
-  }
-  /**
-   * Get parsed platform
-   * @return {{}}
-   */
-  parsePlatform() {
-    this.parsedResult.platform = {};
-    const platform = Utils.find(platformParsersList, (_platform) => {
-      if (typeof _platform.test === "function") {
-        return _platform.test(this);
-      }
-      if (_platform.test instanceof Array) {
-        return _platform.test.some((condition) => this.test(condition));
-      }
-      throw new Error("Browser's test function is not valid");
-    });
-    if (platform) {
-      this.parsedResult.platform = platform.describe(this.getUA());
-    }
-    return this.parsedResult.platform;
-  }
-  /**
-   * Get parsed engine
-   * @return {{}}
-   */
-  getEngine() {
-    if (this.parsedResult.engine) {
-      return this.parsedResult.engine;
-    }
-    return this.parseEngine();
-  }
-  /**
-   * Get engines's name
-   * @return {String} Engines's name or an empty string
-   *
-   * @public
-   */
-  getEngineName(toLowerCase) {
-    if (toLowerCase) {
-      return String(this.getEngine().name).toLowerCase() || "";
-    }
-    return this.getEngine().name || "";
-  }
-  /**
-   * Get parsed platform
-   * @return {{}}
-   */
-  parseEngine() {
-    this.parsedResult.engine = {};
-    const engine = Utils.find(enginesParsersList, (_engine) => {
-      if (typeof _engine.test === "function") {
-        return _engine.test(this);
-      }
-      if (_engine.test instanceof Array) {
-        return _engine.test.some((condition) => this.test(condition));
-      }
-      throw new Error("Browser's test function is not valid");
-    });
-    if (engine) {
-      this.parsedResult.engine = engine.describe(this.getUA());
-    }
-    return this.parsedResult.engine;
-  }
-  /**
-   * Parse full information about the browser
-   * @returns {Parser}
-   */
-  parse() {
-    this.parseBrowser();
-    this.parseOS();
-    this.parsePlatform();
-    this.parseEngine();
-    return this;
-  }
-  /**
-   * Get parsed result
-   * @return {ParsedResult}
-   */
-  getResult() {
-    return Utils.assign({}, this.parsedResult);
-  }
-  /**
-   * Check if parsed browser matches certain conditions
-   *
-   * @param {Object} checkTree It's one or two layered object,
-   * which can include a platform or an OS on the first layer
-   * and should have browsers specs on the bottom-laying layer
-   *
-   * @returns {Boolean|undefined} Whether the browser satisfies the set conditions or not.
-   * Returns `undefined` when the browser is no described in the checkTree object.
-   *
-   * @example
-   * const browser = Bowser.getParser(window.navigator.userAgent);
-   * if (browser.satisfies({chrome: '>118.01.1322' }))
-   * // or with os
-   * if (browser.satisfies({windows: { chrome: '>118.01.1322' } }))
-   * // or with platforms
-   * if (browser.satisfies({desktop: { chrome: '>118.01.1322' } }))
-   */
-  satisfies(checkTree) {
-    const platformsAndOSes = {};
-    let platformsAndOSCounter = 0;
-    const browsers = {};
-    let browsersCounter = 0;
-    const allDefinitions = Object.keys(checkTree);
-    allDefinitions.forEach((key) => {
-      const currentDefinition = checkTree[key];
-      if (typeof currentDefinition === "string") {
-        browsers[key] = currentDefinition;
-        browsersCounter += 1;
-      } else if (typeof currentDefinition === "object") {
-        platformsAndOSes[key] = currentDefinition;
-        platformsAndOSCounter += 1;
-      }
-    });
-    if (platformsAndOSCounter > 0) {
-      const platformsAndOSNames = Object.keys(platformsAndOSes);
-      const OSMatchingDefinition = Utils.find(platformsAndOSNames, (name) => this.isOS(name));
-      if (OSMatchingDefinition) {
-        const osResult = this.satisfies(platformsAndOSes[OSMatchingDefinition]);
-        if (osResult !== void 0) {
-          return osResult;
-        }
-      }
-      const platformMatchingDefinition = Utils.find(
-        platformsAndOSNames,
-        (name) => this.isPlatform(name)
-      );
-      if (platformMatchingDefinition) {
-        const platformResult = this.satisfies(platformsAndOSes[platformMatchingDefinition]);
-        if (platformResult !== void 0) {
-          return platformResult;
-        }
-      }
-    }
-    if (browsersCounter > 0) {
-      const browserNames = Object.keys(browsers);
-      const matchingDefinition = Utils.find(browserNames, (name) => this.isBrowser(name, true));
-      if (matchingDefinition !== void 0) {
-        return this.compareVersion(browsers[matchingDefinition]);
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Check if the browser name equals the passed string
-   * @param browserName The string to compare with the browser name
-   * @param [includingAlias=false] The flag showing whether alias will be included into comparison
-   * @returns {boolean}
-   */
-  isBrowser(browserName, includingAlias = false) {
-    const defaultBrowserName = this.getBrowserName().toLowerCase();
-    let browserNameLower = browserName.toLowerCase();
-    const alias = Utils.getBrowserTypeByAlias(browserNameLower);
-    if (includingAlias && alias) {
-      browserNameLower = alias.toLowerCase();
-    }
-    return browserNameLower === defaultBrowserName;
-  }
-  compareVersion(version) {
-    let expectedResults = [0];
-    let comparableVersion = version;
-    let isLoose = false;
-    const currentBrowserVersion = this.getBrowserVersion();
-    if (typeof currentBrowserVersion !== "string") {
-      return void 0;
-    }
-    if (version[0] === ">" || version[0] === "<") {
-      comparableVersion = version.substr(1);
-      if (version[1] === "=") {
-        isLoose = true;
-        comparableVersion = version.substr(2);
-      } else {
-        expectedResults = [];
-      }
-      if (version[0] === ">") {
-        expectedResults.push(1);
-      } else {
-        expectedResults.push(-1);
-      }
-    } else if (version[0] === "=") {
-      comparableVersion = version.substr(1);
-    } else if (version[0] === "~") {
-      isLoose = true;
-      comparableVersion = version.substr(1);
-    }
-    return expectedResults.indexOf(
-      Utils.compareVersions(currentBrowserVersion, comparableVersion, isLoose)
-    ) > -1;
-  }
-  isOS(osName) {
-    return this.getOSName(true) === String(osName).toLowerCase();
-  }
-  isPlatform(platformType) {
-    return this.getPlatformType(true) === String(platformType).toLowerCase();
-  }
-  isEngine(engineName) {
-    return this.getEngineName(true) === String(engineName).toLowerCase();
-  }
-  /**
-   * Is anything? Check if the browser is called "anything",
-   * the OS called "anything" or the platform called "anything"
-   * @param {String} anything
-   * @param [includingAlias=false] The flag showing whether alias will be included into comparison
-   * @returns {Boolean}
-   */
-  is(anything, includingAlias = false) {
-    return this.isBrowser(anything, includingAlias) || this.isOS(anything) || this.isPlatform(anything);
-  }
-  /**
-   * Check if any of the given values satisfies this.is(anything)
-   * @param {String[]} anythings
-   * @returns {Boolean}
-   */
-  some(anythings = []) {
-    return anythings.some((anything) => this.is(anything));
-  }
-}
-/*!
- * Bowser - a browser detector
- * https://github.com/lancedikson/bowser
- * MIT License | (c) Dustin Diaz 2012-2015
- * MIT License | (c) Denis Demchenko 2015-2019
- */
-class Bowser {
-  /**
-   * Creates a {@link Parser} instance
-   *
-   * @param {String} UA UserAgent string
-   * @param {Boolean} [skipParsing=false] Will make the Parser postpone parsing until you ask it
-   * explicitly. Same as `skipParsing` for {@link Parser}.
-   * @returns {Parser}
-   * @throws {Error} when UA is not a String
-   *
-   * @example
-   * const parser = Bowser.getParser(window.navigator.userAgent);
-   * const result = parser.getResult();
-   */
-  static getParser(UA, skipParsing = false) {
-    if (typeof UA !== "string") {
-      throw new Error("UserAgent should be a string");
-    }
-    return new Parser(UA, skipParsing);
-  }
-  /**
-   * Creates a {@link Parser} instance and runs {@link Parser.getResult} immediately
-   *
-   * @param UA
-   * @return {ParsedResult}
-   *
-   * @example
-   * const result = Bowser.parse(window.navigator.userAgent);
-   */
-  static parse(UA) {
-    return new Parser(UA).getResult();
-  }
-  static get BROWSER_MAP() {
-    return BROWSER_MAP;
-  }
-  static get ENGINE_MAP() {
-    return ENGINE_MAP;
-  }
-  static get OS_MAP() {
-    return OS_MAP;
-  }
-  static get PLATFORMS_MAP() {
-    return PLATFORMS_MAP;
-  }
-}
-class LocalStorageProxy {
-  constructor() {
-    var _a;
-    this.useLocalStorage = true;
-    this.memoryStorage = {};
-    try {
-      localStorage.setItem(
-        PpLocalStorageKey.initializedAt,
-        Date.now().toString()
-      );
-      for (let i = 0; i < localStorage.length; i++) {
-        const key = localStorage.key(i);
-        if (key != null) {
-          this.memoryStorage[key] = (_a = localStorage.getItem(key)) != null ? _a : "";
-        }
-      }
-    } catch (e) {
-      this.useLocalStorage = false;
-    }
-  }
-  getItem(key) {
-    var _a;
-    if (this.useLocalStorage) {
-      try {
-        if (localStorage.getItem(PpLocalStorageKey.initializedAt) != null) {
-          return localStorage.getItem(key);
-        } else {
-          console.debug("local storage value has lost unexpectedly.");
-          addBreadcrumbToSentry({
-            message: "local storage value has lost unexpectedly.",
-            category: "storage"
-          });
-        }
-      } catch (e) {
-      }
-    }
-    this.useLocalStorage = false;
-    return (_a = this.memoryStorage[key]) != null ? _a : null;
-  }
-  setItem(key, value) {
-    this.memoryStorage[key] = value;
-    if (this.useLocalStorage) {
-      try {
-        localStorage.setItem(key, value);
-      } catch (e) {
-        this.useLocalStorage = false;
-        console.warn("localStorage has become unavailable.");
-      }
-    }
-  }
-  removeItem(key) {
-    delete this.memoryStorage[key];
-    try {
-      localStorage.removeItem(key);
-    } catch (e) {
-      this.useLocalStorage = false;
-    }
-  }
-  clear() {
-    try {
-      localStorage.clear();
-      localStorage.setItem(
-        PpLocalStorageKey.initializedAt,
-        Date.now().toString()
-      );
-    } catch (e) {
-    }
-    this.memoryStorage = {};
-  }
-}
-function writeCookie(key, value) {
-  api.set(key, value, __spreadValues({
-    expires: 365,
-    sameSite: "None"
-  }, { secure: true, Partitioned: true }));
-}
-class CookieStorageProxy {
-  constructor() {
-    var _a;
-    this.useCookie = true;
-    this.memoryStorage = {};
-    try {
-      writeCookie(PpLocalStorageKey.initializedAt, Date.now().toString());
-      const cookies = api.get();
-      for (const key in cookies) {
-        this.memoryStorage[key] = (_a = cookies[key]) != null ? _a : "";
-      }
-    } catch (e) {
-      this.useCookie = false;
-    }
-  }
-  getItem(key) {
-    var _a;
-    if (this.useCookie) {
-      try {
-        if (api.get(PpLocalStorageKey.initializedAt) != null) {
-          const val = api.get(key);
-          if (val != null) {
-            return val;
-          }
-          return localStorage.getItem(key);
-        } else {
-          addBreadcrumbToSentry({
-            message: "cookie value has lost unexpectedly.",
-            category: "storage"
-          });
-        }
-      } catch (e) {
-      }
-    }
-    this.useCookie = false;
-    return (_a = this.memoryStorage[key]) != null ? _a : null;
-  }
-  setItem(key, value) {
-    this.memoryStorage[key] = value;
-    if (this.useCookie) {
-      try {
-        writeCookie(key, value);
-        localStorage.removeItem(key);
-      } catch (e) {
-        this.useCookie = false;
-        console.warn("cookie has become unavailable.");
-      }
-    }
-  }
-  removeItem(key) {
-    delete this.memoryStorage[key];
-    try {
-      api.remove(key);
-      localStorage.removeItem(key);
-    } catch (e) {
-      this.useCookie = false;
-    }
-  }
-  clear() {
-    try {
-      localStorage.clear();
-      const cookies = api.get();
-      for (const key in cookies) {
-        api.remove(key);
-      }
-      writeCookie(PpLocalStorageKey.initializedAt, Date.now().toString());
-    } catch (e) {
-    }
-    this.memoryStorage = {};
-  }
-}
-(() => {
-  const browser = Bowser.getParser(window.navigator.userAgent);
-  if (browser.satisfies({ safari: ">=18.4", chrome: ">=0", edge: ">=0" })) {
-    return new CookieStorageProxy();
-  }
-  return new LocalStorageProxy();
-})();
-function isFunction(val) {
-  return typeof val === "function";
-}
-function getRandomString() {
-  return Math.random().toString(36).substring(7);
-}
-function setCookie({ name, value, options }) {
-  return api.set(name, value, options);
-}
-function getCookie({ name }) {
-  return api.get(name);
-}
-function removeCookie({ name, options }) {
-  return api.remove(name, options);
-}
-function setLocalStorage({
-  name,
-  value
-}) {
-  return localStorage.setItem(name, value);
-}
-function getLocalStorage({ name }) {
-  return localStorage.getItem(name);
-}
-function removeLocalStorage({ name }) {
-  return localStorage.removeItem(name);
-}
-function setSessionStorage({
-  name,
-  value
-}) {
-  return sessionStorage.setItem(name, value);
-}
-function getSessionStorage({ name }) {
-  return sessionStorage.getItem(name);
-}
-function removeSessionStorage({ name }) {
-  return sessionStorage.removeItem(name);
-}
-function removeQueryParametersFromUrl(removeParams) {
-  const url = new URL(window.location.href);
-  removeParams.forEach((param) => url.searchParams.delete(param));
-  const newURL = `${url.pathname}${url.search}`;
-  history.replaceState(history.state, "", newURL);
-}
-function getUrl() {
-  return window.location.href;
-}
-const clientWindowBridgeFunctions = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  getCookie,
-  getLocalStorage,
-  getSessionStorage,
-  getUrl,
-  removeCookie,
-  removeLocalStorage,
-  removeQueryParametersFromUrl,
-  removeSessionStorage,
-  setCookie,
-  setLocalStorage,
-  setSessionStorage
-}, Symbol.toStringTag, { value: "Module" }));
-const IFRAME_NAME = "ppmna-iframe";
-const IFRAME_CONTAINER_NAME = "ppsdk-container";
-let iframeContainer;
-function getCoreIframeContainer() {
-  if (!iframeContainer) {
-    iframeContainer = createIframeContainer();
+const IFRAME_NAME = "ppmna-iframe";
+const IFRAME_CONTAINER_NAME = "ppsdk-container";
+let iframeContainer;
+function getCoreIframeContainer() {
+  if (!iframeContainer) {
+    iframeContainer = createIframeContainer();
   }
   return iframeContainer;
 }
@@ -3753,10 +1923,6 @@ function receiveMessageFromIframe(messageData, params, eventHandler) {
   if (messageData.result === PPFunctionResult.complete) {
     (_c = params == null ? void 0 : params.complete) == null ? void 0 : _c.call(params);
     removeEventListener("message", eventHandler);
-    functionEnd(messageData.messageId);
-    if (!isFunctionRunning()) {
-      showCoreIframe(false);
-    }
   }
 }
 function postMessageToCore(messageData) {
@@ -3769,8 +1935,8 @@ function postMessageToCore(messageData) {
     );
   });
 }
-function triggerPostMessageToCore(type, showIframeFlag, params, postMessageParams) {
-  const messageId = functionStart();
+function triggerPostMessageToCore(type, params, postMessageParams) {
+  const messageId = getRandomString();
   const fnMessageHandler = (e) => {
     if (!checkIFrameOrigin(e.origin)) {
       return;
@@ -3818,20 +1984,6 @@ function isSupportedSmartpayment(functionName) {
     functionName
   );
 }
-let runningFunctions = [];
-function isFunctionRunning() {
-  return runningFunctions.length > 0;
-}
-function functionEnd(messageId) {
-  runningFunctions = runningFunctions.filter((val) => {
-    return val !== messageId;
-  });
-}
-function functionStart() {
-  const messageId = getRandomString();
-  runningFunctions.push(messageId);
-  return messageId;
-}
 function promiseToCallback(functionName, target, getLoggingParams) {
   return function(params = {}) {
     const loggingParams = getLoggingParams == null ? void 0 : getLoggingParams(params);
@@ -3925,6 +2077,14 @@ const commonMessageHandler = (e) => {
     showCoreIframe(true);
     return;
   }
+  if (e.data.name === PPUtilFunctionName.showIframe) {
+    showCoreIframe(true);
+    return;
+  }
+  if (e.data.name === PPUtilFunctionName.hideIframe) {
+    showCoreIframe(false);
+    return;
+  }
   if (e.data.name === PPUtilFunctionName.link) {
     const linkOption = e.data.data;
     if (linkOption.target === "_blank") {
@@ -3951,18 +2111,14 @@ addEventListener("popstate", () => {
 function init(params) {
   const refreshToken = getRefreshToken(params.clientId);
   const codeVerifier = getCodeVerifier(params.clientId);
-  const clientVersion = "2.51.0";
-  const initParams = {
-    env: params.env,
-    mode: params.mode,
-    debugMode: params.debugMode,
-    clientId: params.clientId,
+  const clientVersion = "2.55.0";
+  const initParams = __spreadProps(__spreadValues({}, params), {
     refreshToken,
     clientVersion,
     codeVerifier,
     clientSdkType,
     clientUrl: window.location.href
-  };
+  });
   let initDonePromiseResolve;
   const nextInitDonePromise = new Promise(
     (resolve) => initDonePromiseResolve = resolve
@@ -3975,7 +2131,6 @@ function init(params) {
   initDonePromise.then(() => getCoreIframe()).then(() => {
     triggerPostMessageToCore(
       PPFunctionName.init,
-      false,
       __spreadProps(__spreadValues({}, params), { complete }),
       initParams
     );
@@ -4031,8 +2186,8 @@ function executePendingFunctionCalls(client2) {
   }
 }
 const clientProperties = {
-  version: "2.51.0",
-  revision: "9c03362"
+  version: "2.55.0",
+  revision: "a78757a"
 };
 function isInitClientParams(params) {
   return params.clientId !== void 0;
@@ -4080,7 +2235,6 @@ function getClient({
             }
             triggerPostMessageToCore(
               prop,
-              false,
               params,
               params
             );
@@ -4124,9 +2278,13 @@ const markAsReady = promiseToCallback(
   "markAsReady",
   coreFunctions.markAsReady
 );
+promiseToCallback(
+  "renderButton",
+  coreFunctions.renderButton
+);
 function getKycPassportInfo(params) {
   const url = window.location.href;
-  triggerPostMessageToCore(PPFunctionName.getKycPassportInfo, false, params, __spreadProps(__spreadValues({}, params), {
+  triggerPostMessageToCore(PPFunctionName.getKycPassportInfo, params, __spreadProps(__spreadValues({}, params), {
     url
   }));
 }
@@ -4223,12 +2381,7 @@ function scanCode(params) {
   const scanCodeParams = __spreadProps(__spreadValues({}, params), {
     redirectUrlOnCancel: (_a = params == null ? void 0 : params.redirectUrlOnCancel) != null ? _a : window.location.href
   });
-  triggerPostMessageToCore(
-    PPFunctionName.scanCode,
-    false,
-    params,
-    scanCodeParams
-  );
+  triggerPostMessageToCore(PPFunctionName.scanCode, params, scanCodeParams);
 }
 function setTitle(params) {
   var _a, _b, _c;
@@ -4238,7 +2391,7 @@ function setTitle(params) {
 }
 function share(params) {
   if (!(navigator == null ? void 0 : navigator.share)) {
-    triggerPostMessageToCore(PPFunctionName.share, false, params, params);
+    triggerPostMessageToCore(PPFunctionName.share, params, params);
     return;
   }
   const data = {
@@ -4288,12 +2441,9 @@ function removeStorageData(params) {
 }
 function verifyMultiFactorAuthResult(params) {
   const url = new URL(window.location.href);
-  triggerPostMessageToCore(
-    PPFunctionName.verifyMultiFactorAuthResult,
-    false,
-    params,
-    __spreadProps(__spreadValues({}, params), { sessionId: url.searchParams.get("ppSessionId") })
-  );
+  triggerPostMessageToCore(PPFunctionName.verifyMultiFactorAuthResult, params, __spreadProps(__spreadValues({}, params), {
+    sessionId: url.searchParams.get("ppSessionId")
+  }));
 }
 const clientFunctions = {
   verifyMultiFactorAuthResult,