@ogcio/design-system-react 1.24.0 → 1.25.0

package/dist/browser-support/browser-support.js

@@ -0,0 +1,2202 @@
+"use client";
+import { jsxs as M, jsx as y } from "react/jsx-runtime";
+import { c as F } from "../clsx-OuTLNxxd.js";
+import { useMemo as S } from "react";
+import { Alert as B } from "../alert/alert.js";
+import { BROWSER_POLICY as x, DS_HOST as k } from "../constants.js";
+import { Link as A } from "../link/link.js";
+import { u as P } from "../useTranslation-BmIU4GBA.js";
+const O = {
+  AmazonBot: "amazonbot",
+  "Amazon Silk": "amazon_silk",
+  "Android Browser": "android",
+  BaiduSpider: "baiduspider",
+  Bada: "bada",
+  BingCrawler: "bingcrawler",
+  BlackBerry: "blackberry",
+  "ChatGPT-User": "chatgpt_user",
+  Chrome: "chrome",
+  ClaudeBot: "claudebot",
+  Chromium: "chromium",
+  Diffbot: "diffbot",
+  DuckDuckBot: "duckduckbot",
+  Electron: "electron",
+  Epiphany: "epiphany",
+  FacebookExternalHit: "facebookexternalhit",
+  Firefox: "firefox",
+  Focus: "focus",
+  Generic: "generic",
+  "Google Search": "google_search",
+  Googlebot: "googlebot",
+  GPTBot: "gptbot",
+  "Internet Explorer": "ie",
+  InternetArchiveCrawler: "internetarchivecrawler",
+  "K-Meleon": "k_meleon",
+  LibreWolf: "librewolf",
+  Maxthon: "maxthon",
+  "Meta-ExternalAds": "meta_externalads",
+  "Meta-ExternalAgent": "meta_externalagent",
+  "Meta-ExternalFetcher": "meta_externalfetcher",
+  "Meta-WebIndexer": "meta_webindexer",
+  "Microsoft Edge": "edge",
+  "MZ Browser": "mz",
+  "NAVER Whale Browser": "naver",
+  "OAI-SearchBot": "oai_searchbot",
+  Omgilibot: "omgilibot",
+  Opera: "opera",
+  "Opera Coast": "opera_coast",
+  "Pale Moon": "pale_moon",
+  PerplexityBot: "perplexitybot",
+  "Perplexity-User": "perplexity_user",
+  PhantomJS: "phantomjs",
+  PingdomBot: "pingdombot",
+  Puffin: "puffin",
+  QQ: "qq",
+  QQLite: "qqlite",
+  QupZilla: "qupzilla",
+  Roku: "roku",
+  Safari: "safari",
+  Sailfish: "sailfish",
+  "Samsung Internet for Android": "samsung_internet",
+  SeaMonkey: "seamonkey",
+  Sleipnir: "sleipnir",
+  "Sogou Browser": "sogou",
+  Swing: "swing",
+  Tizen: "tizen",
+  "UC Browser": "uc",
+  Vivaldi: "vivaldi",
+  "WebOS Browser": "webos",
+  WeChat: "wechat",
+  YahooSlurp: "yahooslurp",
+  "Yandex Browser": "yandex",
+  YandexBot: "yandexbot",
+  YouBot: "youbot"
+}, w = {
+  amazonbot: "AmazonBot",
+  amazon_silk: "Amazon Silk",
+  android: "Android Browser",
+  baiduspider: "BaiduSpider",
+  bada: "Bada",
+  bingcrawler: "BingCrawler",
+  blackberry: "BlackBerry",
+  chatgpt_user: "ChatGPT-User",
+  chrome: "Chrome",
+  claudebot: "ClaudeBot",
+  chromium: "Chromium",
+  diffbot: "Diffbot",
+  duckduckbot: "DuckDuckBot",
+  edge: "Microsoft Edge",
+  electron: "Electron",
+  epiphany: "Epiphany",
+  facebookexternalhit: "FacebookExternalHit",
+  firefox: "Firefox",
+  focus: "Focus",
+  generic: "Generic",
+  google_search: "Google Search",
+  googlebot: "Googlebot",
+  gptbot: "GPTBot",
+  ie: "Internet Explorer",
+  internetarchivecrawler: "InternetArchiveCrawler",
+  k_meleon: "K-Meleon",
+  librewolf: "LibreWolf",
+  maxthon: "Maxthon",
+  meta_externalads: "Meta-ExternalAds",
+  meta_externalagent: "Meta-ExternalAgent",
+  meta_externalfetcher: "Meta-ExternalFetcher",
+  meta_webindexer: "Meta-WebIndexer",
+  mz: "MZ Browser",
+  naver: "NAVER Whale Browser",
+  oai_searchbot: "OAI-SearchBot",
+  omgilibot: "Omgilibot",
+  opera: "Opera",
+  opera_coast: "Opera Coast",
+  pale_moon: "Pale Moon",
+  perplexitybot: "PerplexityBot",
+  perplexity_user: "Perplexity-User",
+  phantomjs: "PhantomJS",
+  pingdombot: "PingdomBot",
+  puffin: "Puffin",
+  qq: "QQ Browser",
+  qqlite: "QQ Browser Lite",
+  qupzilla: "QupZilla",
+  roku: "Roku",
+  safari: "Safari",
+  sailfish: "Sailfish",
+  samsung_internet: "Samsung Internet for Android",
+  seamonkey: "SeaMonkey",
+  sleipnir: "Sleipnir",
+  sogou: "Sogou Browser",
+  swing: "Swing",
+  tizen: "Tizen",
+  uc: "UC Browser",
+  vivaldi: "Vivaldi",
+  webos: "WebOS Browser",
+  wechat: "WeChat",
+  yahooslurp: "YahooSlurp",
+  yandex: "Yandex Browser",
+  yandexbot: "YandexBot",
+  youbot: "YouBot"
+}, n = {
+  bot: "bot",
+  desktop: "desktop",
+  mobile: "mobile",
+  tablet: "tablet",
+  tv: "tv"
+}, b = {
+  Android: "Android",
+  Bada: "Bada",
+  BlackBerry: "BlackBerry",
+  ChromeOS: "Chrome OS",
+  HarmonyOS: "HarmonyOS",
+  iOS: "iOS",
+  Linux: "Linux",
+  MacOS: "macOS",
+  PlayStation4: "PlayStation 4",
+  Roku: "Roku",
+  Tizen: "Tizen",
+  WebOS: "WebOS",
+  Windows: "Windows",
+  WindowsPhone: "Windows Phone"
+}, g = {
+  Blink: "Blink",
+  EdgeHTML: "EdgeHTML",
+  Gecko: "Gecko",
+  Presto: "Presto",
+  Trident: "Trident",
+  WebKit: "WebKit"
+};
+class s {
+  /**
+   * Get first matched item for a string
+   * @param {RegExp} regexp
+   * @param {String} ua
+   * @return {Array|{index: number, input: string}|*|boolean|string}
+   */
+  static getFirstMatch(e, t) {
+    const i = t.match(e);
+    return i && i.length > 0 && i[1] || "";
+  }
+  /**
+   * Get second matched item for a string
+   * @param regexp
+   * @param {String} ua
+   * @return {Array|{index: number, input: string}|*|boolean|string}
+   */
+  static getSecondMatch(e, t) {
+    const i = t.match(e);
+    return i && i.length > 1 && i[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(e, t, i) {
+    if (e.test(t))
+      return i;
+  }
+  static getWindowsVersionName(e) {
+    switch (e) {
+      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;
+    }
+  }
+  /**
+   * 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
+   *    11 - Big Sur
+   *    12 - Monterey
+   *    13 - Ventura
+   *    14 - Sonoma
+   *    15 - Sequoia
+   *
+   * @example
+   *   getMacOSVersionName("10.14") // 'Mojave'
+   *
+   * @param  {string} version
+   * @return {string} versionName
+   */
+  static getMacOSVersionName(e) {
+    const t = e.split(".").splice(0, 2).map((c) => parseInt(c, 10) || 0);
+    t.push(0);
+    const i = t[0], a = t[1];
+    if (i === 10)
+      switch (a) {
+        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;
+      }
+    switch (i) {
+      case 11:
+        return "Big Sur";
+      case 12:
+        return "Monterey";
+      case 13:
+        return "Ventura";
+      case 14:
+        return "Sonoma";
+      case 15:
+        return "Sequoia";
+      default:
+        return;
+    }
+  }
+  /**
+   * 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(e) {
+    const t = e.split(".").splice(0, 2).map((i) => parseInt(i, 10) || 0);
+    if (t.push(0), !(t[0] === 1 && t[1] < 5)) {
+      if (t[0] === 1 && t[1] < 6) return "Cupcake";
+      if (t[0] === 1 && t[1] >= 6) return "Donut";
+      if (t[0] === 2 && t[1] < 2) return "Eclair";
+      if (t[0] === 2 && t[1] === 2) return "Froyo";
+      if (t[0] === 2 && t[1] > 2) return "Gingerbread";
+      if (t[0] === 3) return "Honeycomb";
+      if (t[0] === 4 && t[1] < 1) return "Ice Cream Sandwich";
+      if (t[0] === 4 && t[1] < 4) return "Jelly Bean";
+      if (t[0] === 4 && t[1] >= 4) return "KitKat";
+      if (t[0] === 5) return "Lollipop";
+      if (t[0] === 6) return "Marshmallow";
+      if (t[0] === 7) return "Nougat";
+      if (t[0] === 8) return "Oreo";
+      if (t[0] === 9) return "Pie";
+    }
+  }
+  /**
+   * Get version precisions count
+   *
+   * @example
+   *   getVersionPrecision("1.10.3") // 3
+   *
+   * @param  {string} version
+   * @return {number}
+   */
+  static getVersionPrecision(e) {
+    return e.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(e, t, i = !1) {
+    const a = s.getVersionPrecision(e), c = s.getVersionPrecision(t);
+    let u = Math.max(a, c), l = 0;
+    const d = s.map([e, t], (m) => {
+      const h = u - s.getVersionPrecision(m), v = m + new Array(h + 1).join(".0");
+      return s.map(v.split("."), (p) => new Array(20 - p.length).join("0") + p).reverse();
+    });
+    for (i && (l = u - Math.min(a, c)), u -= 1; u >= l; ) {
+      if (d[0][u] > d[1][u])
+        return 1;
+      if (d[0][u] === d[1][u]) {
+        if (u === l)
+          return 0;
+        u -= 1;
+      } else if (d[0][u] < d[1][u])
+        return -1;
+    }
+  }
+  /**
+   * Array::map polyfill
+   *
+   * @param  {Array} arr
+   * @param  {Function} iterator
+   * @return {Array}
+   */
+  static map(e, t) {
+    const i = [];
+    let a;
+    if (Array.prototype.map)
+      return Array.prototype.map.call(e, t);
+    for (a = 0; a < e.length; a += 1)
+      i.push(t(e[a]));
+    return i;
+  }
+  /**
+   * Array::find polyfill
+   *
+   * @param  {Array} arr
+   * @param  {Function} predicate
+   * @return {Array}
+   */
+  static find(e, t) {
+    let i, a;
+    if (Array.prototype.find)
+      return Array.prototype.find.call(e, t);
+    for (i = 0, a = e.length; i < a; i += 1) {
+      const c = e[i];
+      if (t(c, i))
+        return c;
+    }
+  }
+  /**
+   * Object::assign polyfill
+   *
+   * @param  {Object} obj
+   * @param  {Object} ...objs
+   * @return {Object}
+   */
+  static assign(e, ...t) {
+    const i = e;
+    let a, c;
+    if (Object.assign)
+      return Object.assign(e, ...t);
+    for (a = 0, c = t.length; a < c; a += 1) {
+      const u = t[a];
+      typeof u == "object" && u !== null && Object.keys(u).forEach((d) => {
+        i[d] = u[d];
+      });
+    }
+    return e;
+  }
+  /**
+   * Get short version/alias for a browser name
+   *
+   * @example
+   *   getBrowserAlias('Microsoft Edge') // edge
+   *
+   * @param  {string} browserName
+   * @return {string}
+   */
+  static getBrowserAlias(e) {
+    return O[e];
+  }
+  /**
+   * Get browser name for a short version/alias
+   *
+   * @example
+   *   getBrowserTypeByAlias('edge') // Microsoft Edge
+   *
+   * @param  {string} browserAlias
+   * @return {string}
+   */
+  static getBrowserTypeByAlias(e) {
+    return w[e] || "";
+  }
+}
+const o = /version\/(\d+(\.?_?\d+)+)/i, _ = [
+  /* GPTBot */
+  {
+    test: [/gptbot/i],
+    describe(r) {
+      const e = {
+        name: "GPTBot"
+      }, t = s.getFirstMatch(/gptbot\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* ChatGPT-User */
+  {
+    test: [/chatgpt-user/i],
+    describe(r) {
+      const e = {
+        name: "ChatGPT-User"
+      }, t = s.getFirstMatch(/chatgpt-user\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* OAI-SearchBot */
+  {
+    test: [/oai-searchbot/i],
+    describe(r) {
+      const e = {
+        name: "OAI-SearchBot"
+      }, t = s.getFirstMatch(/oai-searchbot\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* ClaudeBot */
+  {
+    test: [/claudebot/i, /claude-web/i, /claude-user/i, /claude-searchbot/i],
+    describe(r) {
+      const e = {
+        name: "ClaudeBot"
+      }, t = s.getFirstMatch(/(?:claudebot|claude-web|claude-user|claude-searchbot)\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Omgilibot */
+  {
+    test: [/omgilibot/i, /webzio-extended/i],
+    describe(r) {
+      const e = {
+        name: "Omgilibot"
+      }, t = s.getFirstMatch(/(?:omgilibot|webzio-extended)\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Diffbot */
+  {
+    test: [/diffbot/i],
+    describe(r) {
+      const e = {
+        name: "Diffbot"
+      }, t = s.getFirstMatch(/diffbot\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* PerplexityBot */
+  {
+    test: [/perplexitybot/i],
+    describe(r) {
+      const e = {
+        name: "PerplexityBot"
+      }, t = s.getFirstMatch(/perplexitybot\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Perplexity-User */
+  {
+    test: [/perplexity-user/i],
+    describe(r) {
+      const e = {
+        name: "Perplexity-User"
+      }, t = s.getFirstMatch(/perplexity-user\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* YouBot */
+  {
+    test: [/youbot/i],
+    describe(r) {
+      const e = {
+        name: "YouBot"
+      }, t = s.getFirstMatch(/youbot\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Meta-WebIndexer */
+  {
+    test: [/meta-webindexer/i],
+    describe(r) {
+      const e = {
+        name: "Meta-WebIndexer"
+      }, t = s.getFirstMatch(/meta-webindexer\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Meta-ExternalAds */
+  {
+    test: [/meta-externalads/i],
+    describe(r) {
+      const e = {
+        name: "Meta-ExternalAds"
+      }, t = s.getFirstMatch(/meta-externalads\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Meta-ExternalAgent */
+  {
+    test: [/meta-externalagent/i],
+    describe(r) {
+      const e = {
+        name: "Meta-ExternalAgent"
+      }, t = s.getFirstMatch(/meta-externalagent\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Meta-ExternalFetcher */
+  {
+    test: [/meta-externalfetcher/i],
+    describe(r) {
+      const e = {
+        name: "Meta-ExternalFetcher"
+      }, t = s.getFirstMatch(/meta-externalfetcher\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Googlebot */
+  {
+    test: [/googlebot/i],
+    describe(r) {
+      const e = {
+        name: "Googlebot"
+      }, t = s.getFirstMatch(/googlebot\/(\d+(\.\d+))/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* AmazonBot */
+  {
+    test: [/amazonbot/i],
+    describe(r) {
+      const e = {
+        name: "AmazonBot"
+      }, t = s.getFirstMatch(/amazonbot\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* BingCrawler */
+  {
+    test: [/bingbot/i],
+    describe(r) {
+      const e = {
+        name: "BingCrawler"
+      }, t = s.getFirstMatch(/bingbot\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* BaiduSpider */
+  {
+    test: [/baiduspider/i],
+    describe(r) {
+      const e = {
+        name: "BaiduSpider"
+      }, t = s.getFirstMatch(/baiduspider\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* DuckDuckBot */
+  {
+    test: [/duckduckbot/i],
+    describe(r) {
+      const e = {
+        name: "DuckDuckBot"
+      }, t = s.getFirstMatch(/duckduckbot\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* InternetArchiveCrawler */
+  {
+    test: [/ia_archiver/i],
+    describe(r) {
+      const e = {
+        name: "InternetArchiveCrawler"
+      }, t = s.getFirstMatch(/ia_archiver\/(\d+(\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* FacebookExternalHit */
+  {
+    test: [/facebookexternalhit/i, /facebookcatalog/i],
+    describe() {
+      return {
+        name: "FacebookExternalHit"
+      };
+    }
+  },
+  /* YahooSlurp */
+  {
+    test: [/yahoo!?[\s/]*slurp/i],
+    describe() {
+      return {
+        name: "YahooSlurp"
+      };
+    }
+  },
+  /* YandexBot */
+  {
+    test: [/yandexbot/i, /yandexmobilebot/i],
+    describe() {
+      return {
+        name: "YandexBot"
+      };
+    }
+  },
+  /* PingdomBot */
+  {
+    test: [/pingdom/i],
+    describe() {
+      return {
+        name: "PingdomBot"
+      };
+    }
+  },
+  /* Opera < 13.0 */
+  {
+    test: [/opera/i],
+    describe(r) {
+      const e = {
+        name: "Opera"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Opera > 13.0 */
+  {
+    test: [/opr\/|opios/i],
+    describe(r) {
+      const e = {
+        name: "Opera"
+      }, t = s.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/SamsungBrowser/i],
+    describe(r) {
+      const e = {
+        name: "Samsung Internet for Android"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/Whale/i],
+    describe(r) {
+      const e = {
+        name: "NAVER Whale Browser"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/PaleMoon/i],
+    describe(r) {
+      const e = {
+        name: "Pale Moon"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:PaleMoon)[\s/](\d+(?:\.\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/MZBrowser/i],
+    describe(r) {
+      const e = {
+        name: "MZ Browser"
+      }, t = s.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/focus/i],
+    describe(r) {
+      const e = {
+        name: "Focus"
+      }, t = s.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/swing/i],
+    describe(r) {
+      const e = {
+        name: "Swing"
+      }, t = s.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/coast/i],
+    describe(r) {
+      const e = {
+        name: "Opera Coast"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/opt\/\d+(?:.?_?\d+)+/i],
+    describe(r) {
+      const e = {
+        name: "Opera Touch"
+      }, t = s.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/yabrowser/i],
+    describe(r) {
+      const e = {
+        name: "Yandex Browser"
+      }, t = s.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/ucbrowser/i],
+    describe(r) {
+      const e = {
+        name: "UC Browser"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/Maxthon|mxios/i],
+    describe(r) {
+      const e = {
+        name: "Maxthon"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/epiphany/i],
+    describe(r) {
+      const e = {
+        name: "Epiphany"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/puffin/i],
+    describe(r) {
+      const e = {
+        name: "Puffin"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/sleipnir/i],
+    describe(r) {
+      const e = {
+        name: "Sleipnir"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/k-meleon/i],
+    describe(r) {
+      const e = {
+        name: "K-Meleon"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/micromessenger/i],
+    describe(r) {
+      const e = {
+        name: "WeChat"
+      }, t = s.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/qqbrowser/i],
+    describe(r) {
+      const e = {
+        name: /qqbrowserlite/i.test(r) ? "QQ Browser Lite" : "QQ Browser"
+      }, t = s.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/msie|trident/i],
+    describe(r) {
+      const e = {
+        name: "Internet Explorer"
+      }, t = s.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/\sedg\//i],
+    describe(r) {
+      const e = {
+        name: "Microsoft Edge"
+      }, t = s.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/edg([ea]|ios)/i],
+    describe(r) {
+      const e = {
+        name: "Microsoft Edge"
+      }, t = s.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/vivaldi/i],
+    describe(r) {
+      const e = {
+        name: "Vivaldi"
+      }, t = s.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/seamonkey/i],
+    describe(r) {
+      const e = {
+        name: "SeaMonkey"
+      }, t = s.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/sailfish/i],
+    describe(r) {
+      const e = {
+        name: "Sailfish"
+      }, t = s.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/silk/i],
+    describe(r) {
+      const e = {
+        name: "Amazon Silk"
+      }, t = s.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/phantom/i],
+    describe(r) {
+      const e = {
+        name: "PhantomJS"
+      }, t = s.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/slimerjs/i],
+    describe(r) {
+      const e = {
+        name: "SlimerJS"
+      }, t = s.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(r) {
+      const e = {
+        name: "BlackBerry"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(r) {
+      const e = {
+        name: "WebOS Browser"
+      }, t = s.getFirstMatch(o, r) || s.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/bada/i],
+    describe(r) {
+      const e = {
+        name: "Bada"
+      }, t = s.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/tizen/i],
+    describe(r) {
+      const e = {
+        name: "Tizen"
+      }, t = s.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/qupzilla/i],
+    describe(r) {
+      const e = {
+        name: "QupZilla"
+      }, t = s.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/librewolf/i],
+    describe(r) {
+      const e = {
+        name: "LibreWolf"
+      }, t = s.getFirstMatch(/(?:librewolf)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/firefox|iceweasel|fxios/i],
+    describe(r) {
+      const e = {
+        name: "Firefox"
+      }, t = s.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/electron/i],
+    describe(r) {
+      const e = {
+        name: "Electron"
+      }, t = s.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/sogoumobilebrowser/i, /metasr/i, /se 2\.[x]/i],
+    describe(r) {
+      const e = {
+        name: "Sogou Browser"
+      }, t = s.getFirstMatch(/(?:sogoumobilebrowser)[\s/](\d+(\.?_?\d+)+)/i, r), i = s.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, r), a = s.getFirstMatch(/se ([\d.]+)x/i, r), c = t || i || a;
+      return c && (e.version = c), e;
+    }
+  },
+  {
+    test: [/MiuiBrowser/i],
+    describe(r) {
+      const e = {
+        name: "Miui"
+      }, t = s.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/chromium/i],
+    describe(r) {
+      const e = {
+        name: "Chromium"
+      }, t = s.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, r) || s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/chrome|crios|crmo/i],
+    describe(r) {
+      const e = {
+        name: "Chrome"
+      }, t = s.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  {
+    test: [/GSA/i],
+    describe(r) {
+      const e = {
+        name: "Google Search"
+      }, t = s.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Android Browser */
+  {
+    test(r) {
+      const e = !r.test(/like android/i), t = r.test(/android/i);
+      return e && t;
+    },
+    describe(r) {
+      const e = {
+        name: "Android Browser"
+      }, t = s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* PlayStation 4 */
+  {
+    test: [/playstation 4/i],
+    describe(r) {
+      const e = {
+        name: "PlayStation 4"
+      }, t = s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Safari */
+  {
+    test: [/safari|applewebkit/i],
+    describe(r) {
+      const e = {
+        name: "Safari"
+      }, t = s.getFirstMatch(o, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Something else */
+  {
+    test: [/.*/i],
+    describe(r) {
+      const e = /^(.*)\/(.*) /, t = /^(.*)\/(.*)[ \t]\((.*)/, a = r.search("\\(") !== -1 ? t : e;
+      return {
+        name: s.getFirstMatch(a, r),
+        version: s.getSecondMatch(a, r)
+      };
+    }
+  }
+], E = [
+  /* Roku */
+  {
+    test: [/Roku\/DVP/],
+    describe(r) {
+      const e = s.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, r);
+      return {
+        name: b.Roku,
+        version: e
+      };
+    }
+  },
+  /* Windows Phone */
+  {
+    test: [/windows phone/i],
+    describe(r) {
+      const e = s.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, r);
+      return {
+        name: b.WindowsPhone,
+        version: e
+      };
+    }
+  },
+  /* Windows */
+  {
+    test: [/windows /i],
+    describe(r) {
+      const e = s.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, r), t = s.getWindowsVersionName(e);
+      return {
+        name: b.Windows,
+        version: e,
+        versionName: t
+      };
+    }
+  },
+  /* Firefox on iPad */
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe(r) {
+      const e = {
+        name: b.iOS
+      }, t = s.getSecondMatch(/(Version\/)(\d[\d.]+)/, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* macOS */
+  {
+    test: [/macintosh/i],
+    describe(r) {
+      const e = s.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, r).replace(/[_\s]/g, "."), t = s.getMacOSVersionName(e), i = {
+        name: b.MacOS,
+        version: e
+      };
+      return t && (i.versionName = t), i;
+    }
+  },
+  /* iOS */
+  {
+    test: [/(ipod|iphone|ipad)/i],
+    describe(r) {
+      const e = s.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, r).replace(/[_\s]/g, ".");
+      return {
+        name: b.iOS,
+        version: e
+      };
+    }
+  },
+  /* HarmonyOS */
+  {
+    test: [/OpenHarmony/i],
+    describe(r) {
+      const e = s.getFirstMatch(/OpenHarmony\s+(\d+(\.\d+)*)/i, r);
+      return {
+        name: b.HarmonyOS,
+        version: e
+      };
+    }
+  },
+  /* Android */
+  {
+    test(r) {
+      const e = !r.test(/like android/i), t = r.test(/android/i);
+      return e && t;
+    },
+    describe(r) {
+      const e = s.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, r), t = s.getAndroidVersionName(e), i = {
+        name: b.Android,
+        version: e
+      };
+      return t && (i.versionName = t), i;
+    }
+  },
+  /* WebOS */
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(r) {
+      const e = s.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, r), t = {
+        name: b.WebOS
+      };
+      return e && e.length && (t.version = e), t;
+    }
+  },
+  /* BlackBerry */
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(r) {
+      const e = s.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, r) || s.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, r) || s.getFirstMatch(/\bbb(\d+)/i, r);
+      return {
+        name: b.BlackBerry,
+        version: e
+      };
+    }
+  },
+  /* Bada */
+  {
+    test: [/bada/i],
+    describe(r) {
+      const e = s.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, r);
+      return {
+        name: b.Bada,
+        version: e
+      };
+    }
+  },
+  /* Tizen */
+  {
+    test: [/tizen/i],
+    describe(r) {
+      const e = s.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, r);
+      return {
+        name: b.Tizen,
+        version: e
+      };
+    }
+  },
+  /* Linux */
+  {
+    test: [/linux/i],
+    describe() {
+      return {
+        name: b.Linux
+      };
+    }
+  },
+  /* Chrome OS */
+  {
+    test: [/CrOS/],
+    describe() {
+      return {
+        name: b.ChromeOS
+      };
+    }
+  },
+  /* Playstation 4 */
+  {
+    test: [/PlayStation 4/],
+    describe(r) {
+      const e = s.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, r);
+      return {
+        name: b.PlayStation4,
+        version: e
+      };
+    }
+  }
+], N = [
+  /* Googlebot */
+  {
+    test: [/googlebot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Google"
+      };
+    }
+  },
+  /* AmazonBot */
+  {
+    test: [/amazonbot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Amazon"
+      };
+    }
+  },
+  /* GPTBot */
+  {
+    test: [/gptbot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "OpenAI"
+      };
+    }
+  },
+  /* ChatGPT-User */
+  {
+    test: [/chatgpt-user/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "OpenAI"
+      };
+    }
+  },
+  /* OAI-SearchBot */
+  {
+    test: [/oai-searchbot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "OpenAI"
+      };
+    }
+  },
+  /* Baidu */
+  {
+    test: [/baiduspider/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Baidu"
+      };
+    }
+  },
+  /* Bingbot */
+  {
+    test: [/bingbot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Bing"
+      };
+    }
+  },
+  /* DuckDuckBot */
+  {
+    test: [/duckduckbot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "DuckDuckGo"
+      };
+    }
+  },
+  /* ClaudeBot */
+  {
+    test: [/claudebot/i, /claude-web/i, /claude-user/i, /claude-searchbot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Anthropic"
+      };
+    }
+  },
+  /* Omgilibot */
+  {
+    test: [/omgilibot/i, /webzio-extended/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Webz.io"
+      };
+    }
+  },
+  /* Diffbot */
+  {
+    test: [/diffbot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Diffbot"
+      };
+    }
+  },
+  /* PerplexityBot */
+  {
+    test: [/perplexitybot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Perplexity AI"
+      };
+    }
+  },
+  /* Perplexity-User */
+  {
+    test: [/perplexity-user/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Perplexity AI"
+      };
+    }
+  },
+  /* YouBot */
+  {
+    test: [/youbot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "You.com"
+      };
+    }
+  },
+  /* Internet Archive Crawler */
+  {
+    test: [/ia_archiver/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Internet Archive"
+      };
+    }
+  },
+  /* Meta-WebIndexer */
+  {
+    test: [/meta-webindexer/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Meta"
+      };
+    }
+  },
+  /* Meta-ExternalAds */
+  {
+    test: [/meta-externalads/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Meta"
+      };
+    }
+  },
+  /* Meta-ExternalAgent */
+  {
+    test: [/meta-externalagent/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Meta"
+      };
+    }
+  },
+  /* Meta-ExternalFetcher */
+  {
+    test: [/meta-externalfetcher/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Meta"
+      };
+    }
+  },
+  /* Meta Web Crawler */
+  {
+    test: [/facebookexternalhit/i, /facebookcatalog/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Meta"
+      };
+    }
+  },
+  /* Yahoo! Slurp */
+  {
+    test: [/yahoo/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Yahoo"
+      };
+    }
+  },
+  /* Yandex */
+  {
+    test: [/yandexbot/i, /yandexmobilebot/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Yandex"
+      };
+    }
+  },
+  /* Pingdom */
+  {
+    test: [/pingdom/i],
+    describe() {
+      return {
+        type: n.bot,
+        vendor: "Pingdom"
+      };
+    }
+  },
+  /* Huawei */
+  {
+    test: [/huawei/i],
+    describe(r) {
+      const e = s.getFirstMatch(/(can-l01)/i, r) && "Nova", t = {
+        type: n.mobile,
+        vendor: "Huawei"
+      };
+      return e && (t.model = e), t;
+    }
+  },
+  /* Nexus Tablet */
+  {
+    test: [/nexus\s*(?:7|8|9|10).*/i],
+    describe() {
+      return {
+        type: n.tablet,
+        vendor: "Nexus"
+      };
+    }
+  },
+  /* iPad */
+  {
+    test: [/ipad/i],
+    describe() {
+      return {
+        type: n.tablet,
+        vendor: "Apple",
+        model: "iPad"
+      };
+    }
+  },
+  /* Firefox on iPad */
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe() {
+      return {
+        type: n.tablet,
+        vendor: "Apple",
+        model: "iPad"
+      };
+    }
+  },
+  /* Amazon Kindle Fire */
+  {
+    test: [/kftt build/i],
+    describe() {
+      return {
+        type: n.tablet,
+        vendor: "Amazon",
+        model: "Kindle Fire HD 7"
+      };
+    }
+  },
+  /* Another Amazon Tablet with Silk */
+  {
+    test: [/silk/i],
+    describe() {
+      return {
+        type: n.tablet,
+        vendor: "Amazon"
+      };
+    }
+  },
+  /* Tablet */
+  {
+    test: [/tablet(?! pc)/i],
+    describe() {
+      return {
+        type: n.tablet
+      };
+    }
+  },
+  /* iPod/iPhone */
+  {
+    test(r) {
+      const e = r.test(/ipod|iphone/i), t = r.test(/like (ipod|iphone)/i);
+      return e && !t;
+    },
+    describe(r) {
+      const e = s.getFirstMatch(/(ipod|iphone)/i, r);
+      return {
+        type: n.mobile,
+        vendor: "Apple",
+        model: e
+      };
+    }
+  },
+  /* Nexus Mobile */
+  {
+    test: [/nexus\s*[0-6].*/i, /galaxy nexus/i],
+    describe() {
+      return {
+        type: n.mobile,
+        vendor: "Nexus"
+      };
+    }
+  },
+  /* Nokia */
+  {
+    test: [/Nokia/i],
+    describe(r) {
+      const e = s.getFirstMatch(/Nokia\s+([0-9]+(\.[0-9]+)?)/i, r), t = {
+        type: n.mobile,
+        vendor: "Nokia"
+      };
+      return e && (t.model = e), t;
+    }
+  },
+  /* Mobile */
+  {
+    test: [/[^-]mobi/i],
+    describe() {
+      return {
+        type: n.mobile
+      };
+    }
+  },
+  /* BlackBerry */
+  {
+    test(r) {
+      return r.getBrowserName(!0) === "blackberry";
+    },
+    describe() {
+      return {
+        type: n.mobile,
+        vendor: "BlackBerry"
+      };
+    }
+  },
+  /* Bada */
+  {
+    test(r) {
+      return r.getBrowserName(!0) === "bada";
+    },
+    describe() {
+      return {
+        type: n.mobile
+      };
+    }
+  },
+  /* Windows Phone */
+  {
+    test(r) {
+      return r.getBrowserName() === "windows phone";
+    },
+    describe() {
+      return {
+        type: n.mobile,
+        vendor: "Microsoft"
+      };
+    }
+  },
+  /* Android Tablet */
+  {
+    test(r) {
+      const e = Number(String(r.getOSVersion()).split(".")[0]);
+      return r.getOSName(!0) === "android" && e >= 3;
+    },
+    describe() {
+      return {
+        type: n.tablet
+      };
+    }
+  },
+  /* Android Mobile */
+  {
+    test(r) {
+      return r.getOSName(!0) === "android";
+    },
+    describe() {
+      return {
+        type: n.mobile
+      };
+    }
+  },
+  /* desktop */
+  {
+    test(r) {
+      return r.getOSName(!0) === "macos";
+    },
+    describe() {
+      return {
+        type: n.desktop,
+        vendor: "Apple"
+      };
+    }
+  },
+  /* Windows */
+  {
+    test(r) {
+      return r.getOSName(!0) === "windows";
+    },
+    describe() {
+      return {
+        type: n.desktop
+      };
+    }
+  },
+  /* Linux */
+  {
+    test(r) {
+      return r.getOSName(!0) === "linux";
+    },
+    describe() {
+      return {
+        type: n.desktop
+      };
+    }
+  },
+  /* PlayStation 4 */
+  {
+    test(r) {
+      return r.getOSName(!0) === "playstation 4";
+    },
+    describe() {
+      return {
+        type: n.tv
+      };
+    }
+  },
+  /* Roku */
+  {
+    test(r) {
+      return r.getOSName(!0) === "roku";
+    },
+    describe() {
+      return {
+        type: n.tv
+      };
+    }
+  }
+], C = [
+  /* EdgeHTML */
+  {
+    test(r) {
+      return r.getBrowserName(!0) === "microsoft edge";
+    },
+    describe(r) {
+      if (/\sedg\//i.test(r))
+        return {
+          name: g.Blink
+        };
+      const t = s.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i, r);
+      return {
+        name: g.EdgeHTML,
+        version: t
+      };
+    }
+  },
+  /* Trident */
+  {
+    test: [/trident/i],
+    describe(r) {
+      const e = {
+        name: g.Trident
+      }, t = s.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Presto */
+  {
+    test(r) {
+      return r.test(/presto/i);
+    },
+    describe(r) {
+      const e = {
+        name: g.Presto
+      }, t = s.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Gecko */
+  {
+    test(r) {
+      const e = r.test(/gecko/i), t = r.test(/like gecko/i);
+      return e && !t;
+    },
+    describe(r) {
+      const e = {
+        name: g.Gecko
+      }, t = s.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  },
+  /* Blink */
+  {
+    test: [/(apple)?webkit\/537\.36/i],
+    describe() {
+      return {
+        name: g.Blink
+      };
+    }
+  },
+  /* WebKit */
+  {
+    test: [/(apple)?webkit/i],
+    describe(r) {
+      const e = {
+        name: g.WebKit
+      }, t = s.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i, r);
+      return t && (e.version = t), e;
+    }
+  }
+];
+class f {
+  /**
+   * 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(e, t = !1) {
+    if (e == null || e === "")
+      throw new Error("UserAgent parameter can't be empty");
+    this._ua = e, this.parsedResult = {}, t !== !0 && 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(e) {
+    return e.test(this._ua);
+  }
+  /**
+   * Get parsed browser object
+   * @return {Object}
+   */
+  parseBrowser() {
+    this.parsedResult.browser = {};
+    const e = s.find(_, (t) => {
+      if (typeof t.test == "function")
+        return t.test(this);
+      if (Array.isArray(t.test))
+        return t.test.some((i) => this.test(i));
+      throw new Error("Browser's test function is not valid");
+    });
+    return e && (this.parsedResult.browser = e.describe(this.getUA())), this.parsedResult.browser;
+  }
+  /**
+   * Get parsed browser object
+   * @return {Object}
+   *
+   * @public
+   */
+  getBrowser() {
+    return this.parsedResult.browser ? this.parsedResult.browser : this.parseBrowser();
+  }
+  /**
+   * Get browser's name
+   * @return {String} Browser's name or an empty string
+   *
+   * @public
+   */
+  getBrowserName(e) {
+    return e ? String(this.getBrowser().name).toLowerCase() || "" : 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() {
+    return this.parsedResult.os ? this.parsedResult.os : this.parseOS();
+  }
+  /**
+   * Parse OS and save it to this.parsedResult.os
+   * @return {*|{}}
+   */
+  parseOS() {
+    this.parsedResult.os = {};
+    const e = s.find(E, (t) => {
+      if (typeof t.test == "function")
+        return t.test(this);
+      if (Array.isArray(t.test))
+        return t.test.some((i) => this.test(i));
+      throw new Error("Browser's test function is not valid");
+    });
+    return e && (this.parsedResult.os = e.describe(this.getUA())), this.parsedResult.os;
+  }
+  /**
+   * Get OS name
+   * @param {Boolean} [toLowerCase] return lower-cased value
+   * @return {String} name of the OS — macOS, Windows, Linux, etc.
+   */
+  getOSName(e) {
+    const { name: t } = this.getOS();
+    return e ? String(t).toLowerCase() || "" : t || "";
+  }
+  /**
+   * 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() {
+    return this.parsedResult.platform ? this.parsedResult.platform : this.parsePlatform();
+  }
+  /**
+   * Get platform name
+   * @param {Boolean} [toLowerCase=false]
+   * @return {*}
+   */
+  getPlatformType(e = !1) {
+    const { type: t } = this.getPlatform();
+    return e ? String(t).toLowerCase() || "" : t || "";
+  }
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  parsePlatform() {
+    this.parsedResult.platform = {};
+    const e = s.find(N, (t) => {
+      if (typeof t.test == "function")
+        return t.test(this);
+      if (Array.isArray(t.test))
+        return t.test.some((i) => this.test(i));
+      throw new Error("Browser's test function is not valid");
+    });
+    return e && (this.parsedResult.platform = e.describe(this.getUA())), this.parsedResult.platform;
+  }
+  /**
+   * Get parsed engine
+   * @return {{}}
+   */
+  getEngine() {
+    return this.parsedResult.engine ? this.parsedResult.engine : this.parseEngine();
+  }
+  /**
+   * Get engines's name
+   * @return {String} Engines's name or an empty string
+   *
+   * @public
+   */
+  getEngineName(e) {
+    return e ? String(this.getEngine().name).toLowerCase() || "" : this.getEngine().name || "";
+  }
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  parseEngine() {
+    this.parsedResult.engine = {};
+    const e = s.find(C, (t) => {
+      if (typeof t.test == "function")
+        return t.test(this);
+      if (Array.isArray(t.test))
+        return t.test.some((i) => this.test(i));
+      throw new Error("Browser's test function is not valid");
+    });
+    return e && (this.parsedResult.engine = e.describe(this.getUA())), this.parsedResult.engine;
+  }
+  /**
+   * Parse full information about the browser
+   * @returns {Parser}
+   */
+  parse() {
+    return this.parseBrowser(), this.parseOS(), this.parsePlatform(), this.parseEngine(), this;
+  }
+  /**
+   * Get parsed result
+   * @return {ParsedResult}
+   */
+  getResult() {
+    return s.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(e) {
+    const t = {};
+    let i = 0;
+    const a = {};
+    let c = 0;
+    if (Object.keys(e).forEach((l) => {
+      const d = e[l];
+      typeof d == "string" ? (a[l] = d, c += 1) : typeof d == "object" && (t[l] = d, i += 1);
+    }), i > 0) {
+      const l = Object.keys(t), d = s.find(l, (h) => this.isOS(h));
+      if (d) {
+        const h = this.satisfies(t[d]);
+        if (h !== void 0)
+          return h;
+      }
+      const m = s.find(
+        l,
+        (h) => this.isPlatform(h)
+      );
+      if (m) {
+        const h = this.satisfies(t[m]);
+        if (h !== void 0)
+          return h;
+      }
+    }
+    if (c > 0) {
+      const l = Object.keys(a), d = s.find(l, (m) => this.isBrowser(m, !0));
+      if (d !== void 0)
+        return this.compareVersion(a[d]);
+    }
+  }
+  /**
+   * Check if the browser name equals the passed string
+   * @param {string} 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(e, t = !1) {
+    const i = this.getBrowserName().toLowerCase();
+    let a = e.toLowerCase();
+    const c = s.getBrowserTypeByAlias(a);
+    return t && c && (a = c.toLowerCase()), a === i;
+  }
+  compareVersion(e) {
+    let t = [0], i = e, a = !1;
+    const c = this.getBrowserVersion();
+    if (typeof c == "string")
+      return e[0] === ">" || e[0] === "<" ? (i = e.substr(1), e[1] === "=" ? (a = !0, i = e.substr(2)) : t = [], e[0] === ">" ? t.push(1) : t.push(-1)) : e[0] === "=" ? i = e.substr(1) : e[0] === "~" && (a = !0, i = e.substr(1)), t.indexOf(
+        s.compareVersions(c, i, a)
+      ) > -1;
+  }
+  /**
+   * Check if the OS name equals the passed string
+   * @param {string} osName The string to compare with the OS name
+   * @returns {boolean}
+   */
+  isOS(e) {
+    return this.getOSName(!0) === String(e).toLowerCase();
+  }
+  /**
+   * Check if the platform type equals the passed string
+   * @param {string} platformType The string to compare with the platform type
+   * @returns {boolean}
+   */
+  isPlatform(e) {
+    return this.getPlatformType(!0) === String(e).toLowerCase();
+  }
+  /**
+   * Check if the engine name equals the passed string
+   * @param {string} engineName The string to compare with the engine name
+   * @returns {boolean}
+   */
+  isEngine(e) {
+    return this.getEngineName(!0) === String(e).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(e, t = !1) {
+    return this.isBrowser(e, t) || this.isOS(e) || this.isPlatform(e);
+  }
+  /**
+   * Check if any of the given values satisfies this.is(anything)
+   * @param {String[]} anythings
+   * @returns {Boolean}
+   */
+  some(e = []) {
+    return e.some((t) => this.is(t));
+  }
+}
+/*!
+ * Bowser - a browser detector
+ * https://github.com/lancedikson/bowser
+ * MIT License | (c) Dustin Diaz 2012-2015
+ * MIT License | (c) Denis Demchenko 2015-2019
+ */
+class R {
+  /**
+   * 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(e, t = !1) {
+    if (typeof e != "string")
+      throw new Error("UserAgent should be a string");
+    return new f(e, t);
+  }
+  /**
+   * 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(e) {
+    return new f(e).getResult();
+  }
+  static get BROWSER_MAP() {
+    return w;
+  }
+  static get ENGINE_MAP() {
+    return g;
+  }
+  static get OS_MAP() {
+    return b;
+  }
+  static get PLATFORMS_MAP() {
+    return n;
+  }
+}
+const G = ({
+  className: r,
+  ...e
+}) => {
+  const { t } = P();
+  return S(
+    () => R.getParser(navigator.userAgent).satisfies(x),
+    []
+  ) ? null : /* @__PURE__ */ M(
+    B,
+    {
+      ...e,
+      variant: "warning",
+      title: t("Limited browser support detected"),
+      dismissible: !0,
+      className: F("gi-min-w-full", r),
+      children: [
+        t(
+          "This browser is not officially supported. Please update or switch to a supported browser for the best experience."
+        ),
+        /* @__PURE__ */ y(
+          A,
+          {
+            href: `${k}/get-started/developers/supported-browsers/`,
+            target: "_blank",
+            rel: "noreferrer",
+            children: t("View supported browsers")
+          }
+        )
+      ]
+    }
+  );
+};
+export {
+  G as BrowserSupport
+};