@genai-fi/base 3.0.1

package/dist/DialogQR-BU45QB3i.js

@@ -0,0 +1,1625 @@
+import { jsx as U, jsxs as Rt } from "react/jsx-runtime";
+import { useRef as ue, useCallback as ae, useEffect as ce } from "react";
+import { g as le } from "./_commonjsHelpers-DaMA6jEr.js";
+import { Dialog as fe, DialogContent as de, DialogActions as ge } from "@mui/material";
+import { useTranslation as he } from "react-i18next";
+import { c as me } from "./createSvgIcon-BfF8yuCp.js";
+import "./webrtcState-D0nJpE9Z.js";
+import { B as It } from "./Button-DQwRVw4a.js";
+import "./index-SOhdqzHq.js";
+import "./style/theme.js";
+import "./FileSaver.min-DhePf63e.js";
+import "./components/BusyButton/BusyButton.js";
+import './assets/DialogQR.css';var V = {}, $, Tt;
+function we() {
+  return Tt || (Tt = 1, $ = function() {
+    return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+  }), $;
+}
+var W = {}, q = {}, Nt;
+function F() {
+  if (Nt) return q;
+  Nt = 1;
+  let r;
+  const o = [
+    0,
+    // Not used
+    26,
+    44,
+    70,
+    100,
+    134,
+    172,
+    196,
+    242,
+    292,
+    346,
+    404,
+    466,
+    532,
+    581,
+    655,
+    733,
+    815,
+    901,
+    991,
+    1085,
+    1156,
+    1258,
+    1364,
+    1474,
+    1588,
+    1706,
+    1828,
+    1921,
+    2051,
+    2185,
+    2323,
+    2465,
+    2611,
+    2761,
+    2876,
+    3034,
+    3196,
+    3362,
+    3532,
+    3706
+  ];
+  return q.getSymbolSize = function(n) {
+    if (!n) throw new Error('"version" cannot be null or undefined');
+    if (n < 1 || n > 40) throw new Error('"version" should be in range from 1 to 40');
+    return n * 4 + 17;
+  }, q.getSymbolTotalCodewords = function(n) {
+    return o[n];
+  }, q.getBCHDigit = function(i) {
+    let n = 0;
+    for (; i !== 0; )
+      n++, i >>>= 1;
+    return n;
+  }, q.setToSJISFunction = function(n) {
+    if (typeof n != "function")
+      throw new Error('"toSJISFunc" is not a valid function.');
+    r = n;
+  }, q.isKanjiModeEnabled = function() {
+    return typeof r < "u";
+  }, q.toSJIS = function(n) {
+    return r(n);
+  }, q;
+}
+var Z = {}, Mt;
+function Et() {
+  return Mt || (Mt = 1, function(r) {
+    r.L = { bit: 1 }, r.M = { bit: 0 }, r.Q = { bit: 3 }, r.H = { bit: 2 };
+    function o(i) {
+      if (typeof i != "string")
+        throw new Error("Param is not a string");
+      switch (i.toLowerCase()) {
+        case "l":
+        case "low":
+          return r.L;
+        case "m":
+        case "medium":
+          return r.M;
+        case "q":
+        case "quartile":
+          return r.Q;
+        case "h":
+        case "high":
+          return r.H;
+        default:
+          throw new Error("Unknown EC Level: " + i);
+      }
+    }
+    r.isValid = function(n) {
+      return n && typeof n.bit < "u" && n.bit >= 0 && n.bit < 4;
+    }, r.from = function(n, t) {
+      if (r.isValid(n))
+        return n;
+      try {
+        return o(n);
+      } catch {
+        return t;
+      }
+    };
+  }(Z)), Z;
+}
+var x, Pt;
+function Ce() {
+  if (Pt) return x;
+  Pt = 1;
+  function r() {
+    this.buffer = [], this.length = 0;
+  }
+  return r.prototype = {
+    get: function(o) {
+      const i = Math.floor(o / 8);
+      return (this.buffer[i] >>> 7 - o % 8 & 1) === 1;
+    },
+    put: function(o, i) {
+      for (let n = 0; n < i; n++)
+        this.putBit((o >>> i - n - 1 & 1) === 1);
+    },
+    getLengthInBits: function() {
+      return this.length;
+    },
+    putBit: function(o) {
+      const i = Math.floor(this.length / 8);
+      this.buffer.length <= i && this.buffer.push(0), o && (this.buffer[i] |= 128 >>> this.length % 8), this.length++;
+    }
+  }, x = r, x;
+}
+var X, St;
+function ye() {
+  if (St) return X;
+  St = 1;
+  function r(o) {
+    if (!o || o < 1)
+      throw new Error("BitMatrix size must be defined and greater than 0");
+    this.size = o, this.data = new Uint8Array(o * o), this.reservedBit = new Uint8Array(o * o);
+  }
+  return r.prototype.set = function(o, i, n, t) {
+    const e = o * this.size + i;
+    this.data[e] = n, t && (this.reservedBit[e] = !0);
+  }, r.prototype.get = function(o, i) {
+    return this.data[o * this.size + i];
+  }, r.prototype.xor = function(o, i, n) {
+    this.data[o * this.size + i] ^= n;
+  }, r.prototype.isReserved = function(o, i) {
+    return this.reservedBit[o * this.size + i];
+  }, X = r, X;
+}
+var tt = {}, bt;
+function Ee() {
+  return bt || (bt = 1, function(r) {
+    const o = F().getSymbolSize;
+    r.getRowColCoords = function(n) {
+      if (n === 1) return [];
+      const t = Math.floor(n / 7) + 2, e = o(n), s = e === 145 ? 26 : Math.ceil((e - 13) / (2 * t - 2)) * 2, a = [e - 7];
+      for (let u = 1; u < t - 1; u++)
+        a[u] = a[u - 1] - s;
+      return a.push(6), a.reverse();
+    }, r.getPositions = function(n) {
+      const t = [], e = r.getRowColCoords(n), s = e.length;
+      for (let a = 0; a < s; a++)
+        for (let u = 0; u < s; u++)
+          a === 0 && u === 0 || // top-left
+          a === 0 && u === s - 1 || // bottom-left
+          a === s - 1 && u === 0 || t.push([e[a], e[u]]);
+      return t;
+    };
+  }(tt)), tt;
+}
+var et = {}, vt;
+function Be() {
+  if (vt) return et;
+  vt = 1;
+  const r = F().getSymbolSize, o = 7;
+  return et.getPositions = function(n) {
+    const t = r(n);
+    return [
+      // top-left
+      [0, 0],
+      // top-right
+      [t - o, 0],
+      // bottom-left
+      [0, t - o]
+    ];
+  }, et;
+}
+var nt = {}, Dt;
+function pe() {
+  return Dt || (Dt = 1, function(r) {
+    r.Patterns = {
+      PATTERN000: 0,
+      PATTERN001: 1,
+      PATTERN010: 2,
+      PATTERN011: 3,
+      PATTERN100: 4,
+      PATTERN101: 5,
+      PATTERN110: 6,
+      PATTERN111: 7
+    };
+    const o = {
+      N1: 3,
+      N2: 3,
+      N3: 40,
+      N4: 10
+    };
+    r.isValid = function(t) {
+      return t != null && t !== "" && !isNaN(t) && t >= 0 && t <= 7;
+    }, r.from = function(t) {
+      return r.isValid(t) ? parseInt(t, 10) : void 0;
+    }, r.getPenaltyN1 = function(t) {
+      const e = t.size;
+      let s = 0, a = 0, u = 0, c = null, d = null;
+      for (let B = 0; B < e; B++) {
+        a = u = 0, c = d = null;
+        for (let h = 0; h < e; h++) {
+          let l = t.get(B, h);
+          l === c ? a++ : (a >= 5 && (s += o.N1 + (a - 5)), c = l, a = 1), l = t.get(h, B), l === d ? u++ : (u >= 5 && (s += o.N1 + (u - 5)), d = l, u = 1);
+        }
+        a >= 5 && (s += o.N1 + (a - 5)), u >= 5 && (s += o.N1 + (u - 5));
+      }
+      return s;
+    }, r.getPenaltyN2 = function(t) {
+      const e = t.size;
+      let s = 0;
+      for (let a = 0; a < e - 1; a++)
+        for (let u = 0; u < e - 1; u++) {
+          const c = t.get(a, u) + t.get(a, u + 1) + t.get(a + 1, u) + t.get(a + 1, u + 1);
+          (c === 4 || c === 0) && s++;
+        }
+      return s * o.N2;
+    }, r.getPenaltyN3 = function(t) {
+      const e = t.size;
+      let s = 0, a = 0, u = 0;
+      for (let c = 0; c < e; c++) {
+        a = u = 0;
+        for (let d = 0; d < e; d++)
+          a = a << 1 & 2047 | t.get(c, d), d >= 10 && (a === 1488 || a === 93) && s++, u = u << 1 & 2047 | t.get(d, c), d >= 10 && (u === 1488 || u === 93) && s++;
+      }
+      return s * o.N3;
+    }, r.getPenaltyN4 = function(t) {
+      let e = 0;
+      const s = t.data.length;
+      for (let u = 0; u < s; u++) e += t.data[u];
+      return Math.abs(Math.ceil(e * 100 / s / 5) - 10) * o.N4;
+    };
+    function i(n, t, e) {
+      switch (n) {
+        case r.Patterns.PATTERN000:
+          return (t + e) % 2 === 0;
+        case r.Patterns.PATTERN001:
+          return t % 2 === 0;
+        case r.Patterns.PATTERN010:
+          return e % 3 === 0;
+        case r.Patterns.PATTERN011:
+          return (t + e) % 3 === 0;
+        case r.Patterns.PATTERN100:
+          return (Math.floor(t / 2) + Math.floor(e / 3)) % 2 === 0;
+        case r.Patterns.PATTERN101:
+          return t * e % 2 + t * e % 3 === 0;
+        case r.Patterns.PATTERN110:
+          return (t * e % 2 + t * e % 3) % 2 === 0;
+        case r.Patterns.PATTERN111:
+          return (t * e % 3 + (t + e) % 2) % 2 === 0;
+        default:
+          throw new Error("bad maskPattern:" + n);
+      }
+    }
+    r.applyMask = function(t, e) {
+      const s = e.size;
+      for (let a = 0; a < s; a++)
+        for (let u = 0; u < s; u++)
+          e.isReserved(u, a) || e.xor(u, a, i(t, u, a));
+    }, r.getBestMask = function(t, e) {
+      const s = Object.keys(r.Patterns).length;
+      let a = 0, u = 1 / 0;
+      for (let c = 0; c < s; c++) {
+        e(c), r.applyMask(c, t);
+        const d = r.getPenaltyN1(t) + r.getPenaltyN2(t) + r.getPenaltyN3(t) + r.getPenaltyN4(t);
+        r.applyMask(c, t), d < u && (u = d, a = c);
+      }
+      return a;
+    };
+  }(nt)), nt;
+}
+var j = {}, Lt;
+function te() {
+  if (Lt) return j;
+  Lt = 1;
+  const r = Et(), o = [
+    // L  M  Q  H
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    1,
+    2,
+    2,
+    4,
+    1,
+    2,
+    4,
+    4,
+    2,
+    4,
+    4,
+    4,
+    2,
+    4,
+    6,
+    5,
+    2,
+    4,
+    6,
+    6,
+    2,
+    5,
+    8,
+    8,
+    4,
+    5,
+    8,
+    8,
+    4,
+    5,
+    8,
+    11,
+    4,
+    8,
+    10,
+    11,
+    4,
+    9,
+    12,
+    16,
+    4,
+    9,
+    16,
+    16,
+    6,
+    10,
+    12,
+    18,
+    6,
+    10,
+    17,
+    16,
+    6,
+    11,
+    16,
+    19,
+    6,
+    13,
+    18,
+    21,
+    7,
+    14,
+    21,
+    25,
+    8,
+    16,
+    20,
+    25,
+    8,
+    17,
+    23,
+    25,
+    9,
+    17,
+    23,
+    34,
+    9,
+    18,
+    25,
+    30,
+    10,
+    20,
+    27,
+    32,
+    12,
+    21,
+    29,
+    35,
+    12,
+    23,
+    34,
+    37,
+    12,
+    25,
+    34,
+    40,
+    13,
+    26,
+    35,
+    42,
+    14,
+    28,
+    38,
+    45,
+    15,
+    29,
+    40,
+    48,
+    16,
+    31,
+    43,
+    51,
+    17,
+    33,
+    45,
+    54,
+    18,
+    35,
+    48,
+    57,
+    19,
+    37,
+    51,
+    60,
+    19,
+    38,
+    53,
+    63,
+    20,
+    40,
+    56,
+    66,
+    21,
+    43,
+    59,
+    70,
+    22,
+    45,
+    62,
+    74,
+    24,
+    47,
+    65,
+    77,
+    25,
+    49,
+    68,
+    81
+  ], i = [
+    // L  M  Q  H
+    7,
+    10,
+    13,
+    17,
+    10,
+    16,
+    22,
+    28,
+    15,
+    26,
+    36,
+    44,
+    20,
+    36,
+    52,
+    64,
+    26,
+    48,
+    72,
+    88,
+    36,
+    64,
+    96,
+    112,
+    40,
+    72,
+    108,
+    130,
+    48,
+    88,
+    132,
+    156,
+    60,
+    110,
+    160,
+    192,
+    72,
+    130,
+    192,
+    224,
+    80,
+    150,
+    224,
+    264,
+    96,
+    176,
+    260,
+    308,
+    104,
+    198,
+    288,
+    352,
+    120,
+    216,
+    320,
+    384,
+    132,
+    240,
+    360,
+    432,
+    144,
+    280,
+    408,
+    480,
+    168,
+    308,
+    448,
+    532,
+    180,
+    338,
+    504,
+    588,
+    196,
+    364,
+    546,
+    650,
+    224,
+    416,
+    600,
+    700,
+    224,
+    442,
+    644,
+    750,
+    252,
+    476,
+    690,
+    816,
+    270,
+    504,
+    750,
+    900,
+    300,
+    560,
+    810,
+    960,
+    312,
+    588,
+    870,
+    1050,
+    336,
+    644,
+    952,
+    1110,
+    360,
+    700,
+    1020,
+    1200,
+    390,
+    728,
+    1050,
+    1260,
+    420,
+    784,
+    1140,
+    1350,
+    450,
+    812,
+    1200,
+    1440,
+    480,
+    868,
+    1290,
+    1530,
+    510,
+    924,
+    1350,
+    1620,
+    540,
+    980,
+    1440,
+    1710,
+    570,
+    1036,
+    1530,
+    1800,
+    570,
+    1064,
+    1590,
+    1890,
+    600,
+    1120,
+    1680,
+    1980,
+    630,
+    1204,
+    1770,
+    2100,
+    660,
+    1260,
+    1860,
+    2220,
+    720,
+    1316,
+    1950,
+    2310,
+    750,
+    1372,
+    2040,
+    2430
+  ];
+  return j.getBlocksCount = function(t, e) {
+    switch (e) {
+      case r.L:
+        return o[(t - 1) * 4 + 0];
+      case r.M:
+        return o[(t - 1) * 4 + 1];
+      case r.Q:
+        return o[(t - 1) * 4 + 2];
+      case r.H:
+        return o[(t - 1) * 4 + 3];
+      default:
+        return;
+    }
+  }, j.getTotalCodewordsCount = function(t, e) {
+    switch (e) {
+      case r.L:
+        return i[(t - 1) * 4 + 0];
+      case r.M:
+        return i[(t - 1) * 4 + 1];
+      case r.Q:
+        return i[(t - 1) * 4 + 2];
+      case r.H:
+        return i[(t - 1) * 4 + 3];
+      default:
+        return;
+    }
+  }, j;
+}
+var rt = {}, K = {}, _t;
+function Ae() {
+  if (_t) return K;
+  _t = 1;
+  const r = new Uint8Array(512), o = new Uint8Array(256);
+  return function() {
+    let n = 1;
+    for (let t = 0; t < 255; t++)
+      r[t] = n, o[n] = t, n <<= 1, n & 256 && (n ^= 285);
+    for (let t = 255; t < 512; t++)
+      r[t] = r[t - 255];
+  }(), K.log = function(n) {
+    if (n < 1) throw new Error("log(" + n + ")");
+    return o[n];
+  }, K.exp = function(n) {
+    return r[n];
+  }, K.mul = function(n, t) {
+    return n === 0 || t === 0 ? 0 : r[o[n] + o[t]];
+  }, K;
+}
+var qt;
+function Re() {
+  return qt || (qt = 1, function(r) {
+    const o = Ae();
+    r.mul = function(n, t) {
+      const e = new Uint8Array(n.length + t.length - 1);
+      for (let s = 0; s < n.length; s++)
+        for (let a = 0; a < t.length; a++)
+          e[s + a] ^= o.mul(n[s], t[a]);
+      return e;
+    }, r.mod = function(n, t) {
+      let e = new Uint8Array(n);
+      for (; e.length - t.length >= 0; ) {
+        const s = e[0];
+        for (let u = 0; u < t.length; u++)
+          e[u] ^= o.mul(t[u], s);
+        let a = 0;
+        for (; a < e.length && e[a] === 0; ) a++;
+        e = e.slice(a);
+      }
+      return e;
+    }, r.generateECPolynomial = function(n) {
+      let t = new Uint8Array([1]);
+      for (let e = 0; e < n; e++)
+        t = r.mul(t, new Uint8Array([1, o.exp(e)]));
+      return t;
+    };
+  }(rt)), rt;
+}
+var ot, Ut;
+function Ie() {
+  if (Ut) return ot;
+  Ut = 1;
+  const r = Re();
+  function o(i) {
+    this.genPoly = void 0, this.degree = i, this.degree && this.initialize(this.degree);
+  }
+  return o.prototype.initialize = function(n) {
+    this.degree = n, this.genPoly = r.generateECPolynomial(this.degree);
+  }, o.prototype.encode = function(n) {
+    if (!this.genPoly)
+      throw new Error("Encoder not initialized");
+    const t = new Uint8Array(n.length + this.degree);
+    t.set(n);
+    const e = r.mod(t, this.genPoly), s = this.degree - e.length;
+    if (s > 0) {
+      const a = new Uint8Array(this.degree);
+      return a.set(e, s), a;
+    }
+    return e;
+  }, ot = o, ot;
+}
+var it = {}, st = {}, ut = {}, Ft;
+function ee() {
+  return Ft || (Ft = 1, ut.isValid = function(o) {
+    return !isNaN(o) && o >= 1 && o <= 40;
+  }), ut;
+}
+var v = {}, kt;
+function ne() {
+  if (kt) return v;
+  kt = 1;
+  const r = "[0-9]+", o = "[A-Z $%*+\\-./:]+";
+  let i = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+  i = i.replace(/u/g, "\\u");
+  const n = "(?:(?![A-Z0-9 $%*+\\-./:]|" + i + `)(?:.|[\r
+]))+`;
+  v.KANJI = new RegExp(i, "g"), v.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), v.BYTE = new RegExp(n, "g"), v.NUMERIC = new RegExp(r, "g"), v.ALPHANUMERIC = new RegExp(o, "g");
+  const t = new RegExp("^" + i + "$"), e = new RegExp("^" + r + "$"), s = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+  return v.testKanji = function(u) {
+    return t.test(u);
+  }, v.testNumeric = function(u) {
+    return e.test(u);
+  }, v.testAlphanumeric = function(u) {
+    return s.test(u);
+  }, v;
+}
+var zt;
+function k() {
+  return zt || (zt = 1, function(r) {
+    const o = ee(), i = ne();
+    r.NUMERIC = {
+      id: "Numeric",
+      bit: 1,
+      ccBits: [10, 12, 14]
+    }, r.ALPHANUMERIC = {
+      id: "Alphanumeric",
+      bit: 2,
+      ccBits: [9, 11, 13]
+    }, r.BYTE = {
+      id: "Byte",
+      bit: 4,
+      ccBits: [8, 16, 16]
+    }, r.KANJI = {
+      id: "Kanji",
+      bit: 8,
+      ccBits: [8, 10, 12]
+    }, r.MIXED = {
+      bit: -1
+    }, r.getCharCountIndicator = function(e, s) {
+      if (!e.ccBits) throw new Error("Invalid mode: " + e);
+      if (!o.isValid(s))
+        throw new Error("Invalid version: " + s);
+      return s >= 1 && s < 10 ? e.ccBits[0] : s < 27 ? e.ccBits[1] : e.ccBits[2];
+    }, r.getBestModeForData = function(e) {
+      return i.testNumeric(e) ? r.NUMERIC : i.testAlphanumeric(e) ? r.ALPHANUMERIC : i.testKanji(e) ? r.KANJI : r.BYTE;
+    }, r.toString = function(e) {
+      if (e && e.id) return e.id;
+      throw new Error("Invalid mode");
+    }, r.isValid = function(e) {
+      return e && e.bit && e.ccBits;
+    };
+    function n(t) {
+      if (typeof t != "string")
+        throw new Error("Param is not a string");
+      switch (t.toLowerCase()) {
+        case "numeric":
+          return r.NUMERIC;
+        case "alphanumeric":
+          return r.ALPHANUMERIC;
+        case "kanji":
+          return r.KANJI;
+        case "byte":
+          return r.BYTE;
+        default:
+          throw new Error("Unknown mode: " + t);
+      }
+    }
+    r.from = function(e, s) {
+      if (r.isValid(e))
+        return e;
+      try {
+        return n(e);
+      } catch {
+        return s;
+      }
+    };
+  }(st)), st;
+}
+var Vt;
+function Te() {
+  return Vt || (Vt = 1, function(r) {
+    const o = F(), i = te(), n = Et(), t = k(), e = ee(), s = 7973, a = o.getBCHDigit(s);
+    function u(h, l, N) {
+      for (let M = 1; M <= 40; M++)
+        if (l <= r.getCapacity(M, N, h))
+          return M;
+    }
+    function c(h, l) {
+      return t.getCharCountIndicator(h, l) + 4;
+    }
+    function d(h, l) {
+      let N = 0;
+      return h.forEach(function(M) {
+        const S = c(M.mode, l);
+        N += S + M.getBitsLength();
+      }), N;
+    }
+    function B(h, l) {
+      for (let N = 1; N <= 40; N++)
+        if (d(h, N) <= r.getCapacity(N, l, t.MIXED))
+          return N;
+    }
+    r.from = function(l, N) {
+      return e.isValid(l) ? parseInt(l, 10) : N;
+    }, r.getCapacity = function(l, N, M) {
+      if (!e.isValid(l))
+        throw new Error("Invalid QR Code version");
+      typeof M > "u" && (M = t.BYTE);
+      const S = o.getSymbolTotalCodewords(l), R = i.getTotalCodewordsCount(l, N), P = (S - R) * 8;
+      if (M === t.MIXED) return P;
+      const I = P - c(M, l);
+      switch (M) {
+        case t.NUMERIC:
+          return Math.floor(I / 10 * 3);
+        case t.ALPHANUMERIC:
+          return Math.floor(I / 11 * 2);
+        case t.KANJI:
+          return Math.floor(I / 13);
+        case t.BYTE:
+        default:
+          return Math.floor(I / 8);
+      }
+    }, r.getBestVersionForData = function(l, N) {
+      let M;
+      const S = n.from(N, n.M);
+      if (Array.isArray(l)) {
+        if (l.length > 1)
+          return B(l, S);
+        if (l.length === 0)
+          return 1;
+        M = l[0];
+      } else
+        M = l;
+      return u(M.mode, M.getLength(), S);
+    }, r.getEncodedBits = function(l) {
+      if (!e.isValid(l) || l < 7)
+        throw new Error("Invalid QR Code version");
+      let N = l << 12;
+      for (; o.getBCHDigit(N) - a >= 0; )
+        N ^= s << o.getBCHDigit(N) - a;
+      return l << 12 | N;
+    };
+  }(it)), it;
+}
+var at = {}, Ht;
+function Ne() {
+  if (Ht) return at;
+  Ht = 1;
+  const r = F(), o = 1335, i = 21522, n = r.getBCHDigit(o);
+  return at.getEncodedBits = function(e, s) {
+    const a = e.bit << 3 | s;
+    let u = a << 10;
+    for (; r.getBCHDigit(u) - n >= 0; )
+      u ^= o << r.getBCHDigit(u) - n;
+    return (a << 10 | u) ^ i;
+  }, at;
+}
+var ct = {}, lt, Kt;
+function Me() {
+  if (Kt) return lt;
+  Kt = 1;
+  const r = k();
+  function o(i) {
+    this.mode = r.NUMERIC, this.data = i.toString();
+  }
+  return o.getBitsLength = function(n) {
+    return 10 * Math.floor(n / 3) + (n % 3 ? n % 3 * 3 + 1 : 0);
+  }, o.prototype.getLength = function() {
+    return this.data.length;
+  }, o.prototype.getBitsLength = function() {
+    return o.getBitsLength(this.data.length);
+  }, o.prototype.write = function(n) {
+    let t, e, s;
+    for (t = 0; t + 3 <= this.data.length; t += 3)
+      e = this.data.substr(t, 3), s = parseInt(e, 10), n.put(s, 10);
+    const a = this.data.length - t;
+    a > 0 && (e = this.data.substr(t), s = parseInt(e, 10), n.put(s, a * 3 + 1));
+  }, lt = o, lt;
+}
+var ft, Jt;
+function Pe() {
+  if (Jt) return ft;
+  Jt = 1;
+  const r = k(), o = [
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    " ",
+    "$",
+    "%",
+    "*",
+    "+",
+    "-",
+    ".",
+    "/",
+    ":"
+  ];
+  function i(n) {
+    this.mode = r.ALPHANUMERIC, this.data = n;
+  }
+  return i.getBitsLength = function(t) {
+    return 11 * Math.floor(t / 2) + 6 * (t % 2);
+  }, i.prototype.getLength = function() {
+    return this.data.length;
+  }, i.prototype.getBitsLength = function() {
+    return i.getBitsLength(this.data.length);
+  }, i.prototype.write = function(t) {
+    let e;
+    for (e = 0; e + 2 <= this.data.length; e += 2) {
+      let s = o.indexOf(this.data[e]) * 45;
+      s += o.indexOf(this.data[e + 1]), t.put(s, 11);
+    }
+    this.data.length % 2 && t.put(o.indexOf(this.data[e]), 6);
+  }, ft = i, ft;
+}
+var dt, jt;
+function Se() {
+  return jt || (jt = 1, dt = function(o) {
+    for (var i = [], n = o.length, t = 0; t < n; t++) {
+      var e = o.charCodeAt(t);
+      if (e >= 55296 && e <= 56319 && n > t + 1) {
+        var s = o.charCodeAt(t + 1);
+        s >= 56320 && s <= 57343 && (e = (e - 55296) * 1024 + s - 56320 + 65536, t += 1);
+      }
+      if (e < 128) {
+        i.push(e);
+        continue;
+      }
+      if (e < 2048) {
+        i.push(e >> 6 | 192), i.push(e & 63 | 128);
+        continue;
+      }
+      if (e < 55296 || e >= 57344 && e < 65536) {
+        i.push(e >> 12 | 224), i.push(e >> 6 & 63 | 128), i.push(e & 63 | 128);
+        continue;
+      }
+      if (e >= 65536 && e <= 1114111) {
+        i.push(e >> 18 | 240), i.push(e >> 12 & 63 | 128), i.push(e >> 6 & 63 | 128), i.push(e & 63 | 128);
+        continue;
+      }
+      i.push(239, 191, 189);
+    }
+    return new Uint8Array(i).buffer;
+  }), dt;
+}
+var gt, Yt;
+function be() {
+  if (Yt) return gt;
+  Yt = 1;
+  const r = Se(), o = k();
+  function i(n) {
+    this.mode = o.BYTE, typeof n == "string" && (n = r(n)), this.data = new Uint8Array(n);
+  }
+  return i.getBitsLength = function(t) {
+    return t * 8;
+  }, i.prototype.getLength = function() {
+    return this.data.length;
+  }, i.prototype.getBitsLength = function() {
+    return i.getBitsLength(this.data.length);
+  }, i.prototype.write = function(n) {
+    for (let t = 0, e = this.data.length; t < e; t++)
+      n.put(this.data[t], 8);
+  }, gt = i, gt;
+}
+var ht, Ot;
+function ve() {
+  if (Ot) return ht;
+  Ot = 1;
+  const r = k(), o = F();
+  function i(n) {
+    this.mode = r.KANJI, this.data = n;
+  }
+  return i.getBitsLength = function(t) {
+    return t * 13;
+  }, i.prototype.getLength = function() {
+    return this.data.length;
+  }, i.prototype.getBitsLength = function() {
+    return i.getBitsLength(this.data.length);
+  }, i.prototype.write = function(n) {
+    let t;
+    for (t = 0; t < this.data.length; t++) {
+      let e = o.toSJIS(this.data[t]);
+      if (e >= 33088 && e <= 40956)
+        e -= 33088;
+      else if (e >= 57408 && e <= 60351)
+        e -= 49472;
+      else
+        throw new Error(
+          "Invalid SJIS character: " + this.data[t] + `
+Make sure your charset is UTF-8`
+        );
+      e = (e >>> 8 & 255) * 192 + (e & 255), n.put(e, 13);
+    }
+  }, ht = i, ht;
+}
+var mt = { exports: {} }, Gt;
+function De() {
+  return Gt || (Gt = 1, function(r) {
+    var o = {
+      single_source_shortest_paths: function(i, n, t) {
+        var e = {}, s = {};
+        s[n] = 0;
+        var a = o.PriorityQueue.make();
+        a.push(n, 0);
+        for (var u, c, d, B, h, l, N, M, S; !a.empty(); ) {
+          u = a.pop(), c = u.value, B = u.cost, h = i[c] || {};
+          for (d in h)
+            h.hasOwnProperty(d) && (l = h[d], N = B + l, M = s[d], S = typeof s[d] > "u", (S || M > N) && (s[d] = N, a.push(d, N), e[d] = c));
+        }
+        if (typeof t < "u" && typeof s[t] > "u") {
+          var R = ["Could not find a path from ", n, " to ", t, "."].join("");
+          throw new Error(R);
+        }
+        return e;
+      },
+      extract_shortest_path_from_predecessor_list: function(i, n) {
+        for (var t = [], e = n; e; )
+          t.push(e), i[e], e = i[e];
+        return t.reverse(), t;
+      },
+      find_path: function(i, n, t) {
+        var e = o.single_source_shortest_paths(i, n, t);
+        return o.extract_shortest_path_from_predecessor_list(
+          e,
+          t
+        );
+      },
+      /**
+       * A very naive priority queue implementation.
+       */
+      PriorityQueue: {
+        make: function(i) {
+          var n = o.PriorityQueue, t = {}, e;
+          i = i || {};
+          for (e in n)
+            n.hasOwnProperty(e) && (t[e] = n[e]);
+          return t.queue = [], t.sorter = i.sorter || n.default_sorter, t;
+        },
+        default_sorter: function(i, n) {
+          return i.cost - n.cost;
+        },
+        /**
+         * Add a new item to the queue and ensure the highest priority element
+         * is at the front of the queue.
+         */
+        push: function(i, n) {
+          var t = { value: i, cost: n };
+          this.queue.push(t), this.queue.sort(this.sorter);
+        },
+        /**
+         * Return the highest priority element in the queue.
+         */
+        pop: function() {
+          return this.queue.shift();
+        },
+        empty: function() {
+          return this.queue.length === 0;
+        }
+      }
+    };
+    r.exports = o;
+  }(mt)), mt.exports;
+}
+var Qt;
+function Le() {
+  return Qt || (Qt = 1, function(r) {
+    const o = k(), i = Me(), n = Pe(), t = be(), e = ve(), s = ne(), a = F(), u = De();
+    function c(R) {
+      return unescape(encodeURIComponent(R)).length;
+    }
+    function d(R, P, I) {
+      const p = [];
+      let b;
+      for (; (b = R.exec(I)) !== null; )
+        p.push({
+          data: b[0],
+          index: b.index,
+          mode: P,
+          length: b[0].length
+        });
+      return p;
+    }
+    function B(R) {
+      const P = d(s.NUMERIC, o.NUMERIC, R), I = d(s.ALPHANUMERIC, o.ALPHANUMERIC, R);
+      let p, b;
+      return a.isKanjiModeEnabled() ? (p = d(s.BYTE, o.BYTE, R), b = d(s.KANJI, o.KANJI, R)) : (p = d(s.BYTE_KANJI, o.BYTE, R), b = []), P.concat(I, p, b).sort(function(y, C) {
+        return y.index - C.index;
+      }).map(function(y) {
+        return {
+          data: y.data,
+          mode: y.mode,
+          length: y.length
+        };
+      });
+    }
+    function h(R, P) {
+      switch (P) {
+        case o.NUMERIC:
+          return i.getBitsLength(R);
+        case o.ALPHANUMERIC:
+          return n.getBitsLength(R);
+        case o.KANJI:
+          return e.getBitsLength(R);
+        case o.BYTE:
+          return t.getBitsLength(R);
+      }
+    }
+    function l(R) {
+      return R.reduce(function(P, I) {
+        const p = P.length - 1 >= 0 ? P[P.length - 1] : null;
+        return p && p.mode === I.mode ? (P[P.length - 1].data += I.data, P) : (P.push(I), P);
+      }, []);
+    }
+    function N(R) {
+      const P = [];
+      for (let I = 0; I < R.length; I++) {
+        const p = R[I];
+        switch (p.mode) {
+          case o.NUMERIC:
+            P.push([
+              p,
+              { data: p.data, mode: o.ALPHANUMERIC, length: p.length },
+              { data: p.data, mode: o.BYTE, length: p.length }
+            ]);
+            break;
+          case o.ALPHANUMERIC:
+            P.push([
+              p,
+              { data: p.data, mode: o.BYTE, length: p.length }
+            ]);
+            break;
+          case o.KANJI:
+            P.push([
+              p,
+              { data: p.data, mode: o.BYTE, length: c(p.data) }
+            ]);
+            break;
+          case o.BYTE:
+            P.push([
+              { data: p.data, mode: o.BYTE, length: c(p.data) }
+            ]);
+        }
+      }
+      return P;
+    }
+    function M(R, P) {
+      const I = {}, p = { start: {} };
+      let b = ["start"];
+      for (let g = 0; g < R.length; g++) {
+        const y = R[g], C = [];
+        for (let f = 0; f < y.length; f++) {
+          const A = y[f], m = "" + g + f;
+          C.push(m), I[m] = { node: A, lastCount: 0 }, p[m] = {};
+          for (let E = 0; E < b.length; E++) {
+            const w = b[E];
+            I[w] && I[w].node.mode === A.mode ? (p[w][m] = h(I[w].lastCount + A.length, A.mode) - h(I[w].lastCount, A.mode), I[w].lastCount += A.length) : (I[w] && (I[w].lastCount = A.length), p[w][m] = h(A.length, A.mode) + 4 + o.getCharCountIndicator(A.mode, P));
+          }
+        }
+        b = C;
+      }
+      for (let g = 0; g < b.length; g++)
+        p[b[g]].end = 0;
+      return { map: p, table: I };
+    }
+    function S(R, P) {
+      let I;
+      const p = o.getBestModeForData(R);
+      if (I = o.from(P, p), I !== o.BYTE && I.bit < p.bit)
+        throw new Error('"' + R + '" cannot be encoded with mode ' + o.toString(I) + `.
+ Suggested mode is: ` + o.toString(p));
+      switch (I === o.KANJI && !a.isKanjiModeEnabled() && (I = o.BYTE), I) {
+        case o.NUMERIC:
+          return new i(R);
+        case o.ALPHANUMERIC:
+          return new n(R);
+        case o.KANJI:
+          return new e(R);
+        case o.BYTE:
+          return new t(R);
+      }
+    }
+    r.fromArray = function(P) {
+      return P.reduce(function(I, p) {
+        return typeof p == "string" ? I.push(S(p, null)) : p.data && I.push(S(p.data, p.mode)), I;
+      }, []);
+    }, r.fromString = function(P, I) {
+      const p = B(P, a.isKanjiModeEnabled()), b = N(p), g = M(b, I), y = u.find_path(g.map, "start", "end"), C = [];
+      for (let f = 1; f < y.length - 1; f++)
+        C.push(g.table[y[f]].node);
+      return r.fromArray(l(C));
+    }, r.rawSplit = function(P) {
+      return r.fromArray(
+        B(P, a.isKanjiModeEnabled())
+      );
+    };
+  }(ct)), ct;
+}
+var $t;
+function _e() {
+  if ($t) return W;
+  $t = 1;
+  const r = F(), o = Et(), i = Ce(), n = ye(), t = Ee(), e = Be(), s = pe(), a = te(), u = Ie(), c = Te(), d = Ne(), B = k(), h = Le();
+  function l(g, y) {
+    const C = g.size, f = e.getPositions(y);
+    for (let A = 0; A < f.length; A++) {
+      const m = f[A][0], E = f[A][1];
+      for (let w = -1; w <= 7; w++)
+        if (!(m + w <= -1 || C <= m + w))
+          for (let T = -1; T <= 7; T++)
+            E + T <= -1 || C <= E + T || (w >= 0 && w <= 6 && (T === 0 || T === 6) || T >= 0 && T <= 6 && (w === 0 || w === 6) || w >= 2 && w <= 4 && T >= 2 && T <= 4 ? g.set(m + w, E + T, !0, !0) : g.set(m + w, E + T, !1, !0));
+    }
+  }
+  function N(g) {
+    const y = g.size;
+    for (let C = 8; C < y - 8; C++) {
+      const f = C % 2 === 0;
+      g.set(C, 6, f, !0), g.set(6, C, f, !0);
+    }
+  }
+  function M(g, y) {
+    const C = t.getPositions(y);
+    for (let f = 0; f < C.length; f++) {
+      const A = C[f][0], m = C[f][1];
+      for (let E = -2; E <= 2; E++)
+        for (let w = -2; w <= 2; w++)
+          E === -2 || E === 2 || w === -2 || w === 2 || E === 0 && w === 0 ? g.set(A + E, m + w, !0, !0) : g.set(A + E, m + w, !1, !0);
+    }
+  }
+  function S(g, y) {
+    const C = g.size, f = c.getEncodedBits(y);
+    let A, m, E;
+    for (let w = 0; w < 18; w++)
+      A = Math.floor(w / 3), m = w % 3 + C - 8 - 3, E = (f >> w & 1) === 1, g.set(A, m, E, !0), g.set(m, A, E, !0);
+  }
+  function R(g, y, C) {
+    const f = g.size, A = d.getEncodedBits(y, C);
+    let m, E;
+    for (m = 0; m < 15; m++)
+      E = (A >> m & 1) === 1, m < 6 ? g.set(m, 8, E, !0) : m < 8 ? g.set(m + 1, 8, E, !0) : g.set(f - 15 + m, 8, E, !0), m < 8 ? g.set(8, f - m - 1, E, !0) : m < 9 ? g.set(8, 15 - m - 1 + 1, E, !0) : g.set(8, 15 - m - 1, E, !0);
+    g.set(f - 8, 8, 1, !0);
+  }
+  function P(g, y) {
+    const C = g.size;
+    let f = -1, A = C - 1, m = 7, E = 0;
+    for (let w = C - 1; w > 0; w -= 2)
+      for (w === 6 && w--; ; ) {
+        for (let T = 0; T < 2; T++)
+          if (!g.isReserved(A, w - T)) {
+            let _ = !1;
+            E < y.length && (_ = (y[E] >>> m & 1) === 1), g.set(A, w - T, _), m--, m === -1 && (E++, m = 7);
+          }
+        if (A += f, A < 0 || C <= A) {
+          A -= f, f = -f;
+          break;
+        }
+      }
+  }
+  function I(g, y, C) {
+    const f = new i();
+    C.forEach(function(T) {
+      f.put(T.mode.bit, 4), f.put(T.getLength(), B.getCharCountIndicator(T.mode, g)), T.write(f);
+    });
+    const A = r.getSymbolTotalCodewords(g), m = a.getTotalCodewordsCount(g, y), E = (A - m) * 8;
+    for (f.getLengthInBits() + 4 <= E && f.put(0, 4); f.getLengthInBits() % 8 !== 0; )
+      f.putBit(0);
+    const w = (E - f.getLengthInBits()) / 8;
+    for (let T = 0; T < w; T++)
+      f.put(T % 2 ? 17 : 236, 8);
+    return p(f, g, y);
+  }
+  function p(g, y, C) {
+    const f = r.getSymbolTotalCodewords(y), A = a.getTotalCodewordsCount(y, C), m = f - A, E = a.getBlocksCount(y, C), w = f % E, T = E - w, _ = Math.floor(f / E), H = Math.floor(m / E), oe = H + 1, Bt = _ - H, ie = new u(Bt);
+    let Y = 0;
+    const J = new Array(E), pt = new Array(E);
+    let O = 0;
+    const se = new Uint8Array(g.buffer);
+    for (let z = 0; z < E; z++) {
+      const Q = z < T ? H : oe;
+      J[z] = se.slice(Y, Y + Q), pt[z] = ie.encode(J[z]), Y += Q, O = Math.max(O, Q);
+    }
+    const G = new Uint8Array(f);
+    let At = 0, D, L;
+    for (D = 0; D < O; D++)
+      for (L = 0; L < E; L++)
+        D < J[L].length && (G[At++] = J[L][D]);
+    for (D = 0; D < Bt; D++)
+      for (L = 0; L < E; L++)
+        G[At++] = pt[L][D];
+    return G;
+  }
+  function b(g, y, C, f) {
+    let A;
+    if (Array.isArray(g))
+      A = h.fromArray(g);
+    else if (typeof g == "string") {
+      let _ = y;
+      if (!_) {
+        const H = h.rawSplit(g);
+        _ = c.getBestVersionForData(H, C);
+      }
+      A = h.fromString(g, _ || 40);
+    } else
+      throw new Error("Invalid data");
+    const m = c.getBestVersionForData(A, C);
+    if (!m)
+      throw new Error("The amount of data is too big to be stored in a QR Code");
+    if (!y)
+      y = m;
+    else if (y < m)
+      throw new Error(
+        `
+The chosen QR Code version cannot contain this amount of data.
+Minimum version required to store current data is: ` + m + `.
+`
+      );
+    const E = I(y, C, A), w = r.getSymbolSize(y), T = new n(w);
+    return l(T, y), N(T), M(T, y), R(T, C, 0), y >= 7 && S(T, y), P(T, E), isNaN(f) && (f = s.getBestMask(
+      T,
+      R.bind(null, T, C)
+    )), s.applyMask(f, T), R(T, C, f), {
+      modules: T,
+      version: y,
+      errorCorrectionLevel: C,
+      maskPattern: f,
+      segments: A
+    };
+  }
+  return W.create = function(y, C) {
+    if (typeof y > "u" || y === "")
+      throw new Error("No input text");
+    let f = o.M, A, m;
+    return typeof C < "u" && (f = o.from(C.errorCorrectionLevel, o.M), A = c.from(C.version), m = s.from(C.maskPattern), C.toSJISFunc && r.setToSJISFunction(C.toSJISFunc)), b(y, A, f, m);
+  }, W;
+}
+var wt = {}, Ct = {}, Wt;
+function re() {
+  return Wt || (Wt = 1, function(r) {
+    function o(i) {
+      if (typeof i == "number" && (i = i.toString()), typeof i != "string")
+        throw new Error("Color should be defined as hex string");
+      let n = i.slice().replace("#", "").split("");
+      if (n.length < 3 || n.length === 5 || n.length > 8)
+        throw new Error("Invalid hex color: " + i);
+      (n.length === 3 || n.length === 4) && (n = Array.prototype.concat.apply([], n.map(function(e) {
+        return [e, e];
+      }))), n.length === 6 && n.push("F", "F");
+      const t = parseInt(n.join(""), 16);
+      return {
+        r: t >> 24 & 255,
+        g: t >> 16 & 255,
+        b: t >> 8 & 255,
+        a: t & 255,
+        hex: "#" + n.slice(0, 6).join("")
+      };
+    }
+    r.getOptions = function(n) {
+      n || (n = {}), n.color || (n.color = {});
+      const t = typeof n.margin > "u" || n.margin === null || n.margin < 0 ? 4 : n.margin, e = n.width && n.width >= 21 ? n.width : void 0, s = n.scale || 4;
+      return {
+        width: e,
+        scale: e ? 4 : s,
+        margin: t,
+        color: {
+          dark: o(n.color.dark || "#000000ff"),
+          light: o(n.color.light || "#ffffffff")
+        },
+        type: n.type,
+        rendererOpts: n.rendererOpts || {}
+      };
+    }, r.getScale = function(n, t) {
+      return t.width && t.width >= n + t.margin * 2 ? t.width / (n + t.margin * 2) : t.scale;
+    }, r.getImageWidth = function(n, t) {
+      const e = r.getScale(n, t);
+      return Math.floor((n + t.margin * 2) * e);
+    }, r.qrToImageData = function(n, t, e) {
+      const s = t.modules.size, a = t.modules.data, u = r.getScale(s, e), c = Math.floor((s + e.margin * 2) * u), d = e.margin * u, B = [e.color.light, e.color.dark];
+      for (let h = 0; h < c; h++)
+        for (let l = 0; l < c; l++) {
+          let N = (h * c + l) * 4, M = e.color.light;
+          if (h >= d && l >= d && h < c - d && l < c - d) {
+            const S = Math.floor((h - d) / u), R = Math.floor((l - d) / u);
+            M = B[a[S * s + R] ? 1 : 0];
+          }
+          n[N++] = M.r, n[N++] = M.g, n[N++] = M.b, n[N] = M.a;
+        }
+    };
+  }(Ct)), Ct;
+}
+var Zt;
+function qe() {
+  return Zt || (Zt = 1, function(r) {
+    const o = re();
+    function i(t, e, s) {
+      t.clearRect(0, 0, e.width, e.height), e.style || (e.style = {}), e.height = s, e.width = s, e.style.height = s + "px", e.style.width = s + "px";
+    }
+    function n() {
+      try {
+        return document.createElement("canvas");
+      } catch {
+        throw new Error("You need to specify a canvas element");
+      }
+    }
+    r.render = function(e, s, a) {
+      let u = a, c = s;
+      typeof u > "u" && (!s || !s.getContext) && (u = s, s = void 0), s || (c = n()), u = o.getOptions(u);
+      const d = o.getImageWidth(e.modules.size, u), B = c.getContext("2d"), h = B.createImageData(d, d);
+      return o.qrToImageData(h.data, e, u), i(B, c, d), B.putImageData(h, 0, 0), c;
+    }, r.renderToDataURL = function(e, s, a) {
+      let u = a;
+      typeof u > "u" && (!s || !s.getContext) && (u = s, s = void 0), u || (u = {});
+      const c = r.render(e, s, u), d = u.type || "image/png", B = u.rendererOpts || {};
+      return c.toDataURL(d, B.quality);
+    };
+  }(wt)), wt;
+}
+var yt = {}, xt;
+function Ue() {
+  if (xt) return yt;
+  xt = 1;
+  const r = re();
+  function o(t, e) {
+    const s = t.a / 255, a = e + '="' + t.hex + '"';
+    return s < 1 ? a + " " + e + '-opacity="' + s.toFixed(2).slice(1) + '"' : a;
+  }
+  function i(t, e, s) {
+    let a = t + e;
+    return typeof s < "u" && (a += " " + s), a;
+  }
+  function n(t, e, s) {
+    let a = "", u = 0, c = !1, d = 0;
+    for (let B = 0; B < t.length; B++) {
+      const h = Math.floor(B % e), l = Math.floor(B / e);
+      !h && !c && (c = !0), t[B] ? (d++, B > 0 && h > 0 && t[B - 1] || (a += c ? i("M", h + s, 0.5 + l + s) : i("m", u, 0), u = 0, c = !1), h + 1 < e && t[B + 1] || (a += i("h", d), d = 0)) : u++;
+    }
+    return a;
+  }
+  return yt.render = function(e, s, a) {
+    const u = r.getOptions(s), c = e.modules.size, d = e.modules.data, B = c + u.margin * 2, h = u.color.light.a ? "<path " + o(u.color.light, "fill") + ' d="M0 0h' + B + "v" + B + 'H0z"/>' : "", l = "<path " + o(u.color.dark, "stroke") + ' d="' + n(d, c, u.margin) + '"/>', N = 'viewBox="0 0 ' + B + " " + B + '"', S = '<svg xmlns="http://www.w3.org/2000/svg" ' + (u.width ? 'width="' + u.width + '" height="' + u.width + '" ' : "") + N + ' shape-rendering="crispEdges">' + h + l + `</svg>
+`;
+    return typeof a == "function" && a(null, S), S;
+  }, yt;
+}
+var Xt;
+function Fe() {
+  if (Xt) return V;
+  Xt = 1;
+  const r = we(), o = _e(), i = qe(), n = Ue();
+  function t(e, s, a, u, c) {
+    const d = [].slice.call(arguments, 1), B = d.length, h = typeof d[B - 1] == "function";
+    if (!h && !r())
+      throw new Error("Callback required as last argument");
+    if (h) {
+      if (B < 2)
+        throw new Error("Too few arguments provided");
+      B === 2 ? (c = a, a = s, s = u = void 0) : B === 3 && (s.getContext && typeof c > "u" ? (c = u, u = void 0) : (c = u, u = a, a = s, s = void 0));
+    } else {
+      if (B < 1)
+        throw new Error("Too few arguments provided");
+      return B === 1 ? (a = s, s = u = void 0) : B === 2 && !s.getContext && (u = a, a = s, s = void 0), new Promise(function(l, N) {
+        try {
+          const M = o.create(a, u);
+          l(e(M, s, u));
+        } catch (M) {
+          N(M);
+        }
+      });
+    }
+    try {
+      const l = o.create(a, u);
+      c(null, e(l, s, u));
+    } catch (l) {
+      c(l);
+    }
+  }
+  return V.create = o.create, V.toCanvas = t.bind(null, i.render), V.toDataURL = t.bind(null, i.renderToDataURL), V.toString = t.bind(null, function(e, s, a) {
+    return n.render(e, a);
+  }), V;
+}
+var ke = Fe();
+const ze = /* @__PURE__ */ le(ke), Ve = "_link_1udre_3", He = "_container_1udre_14", Ke = "_canvas_1udre_19", Je = "_dialog_1udre_30", je = {
+  link: Ve,
+  container: He,
+  canvas: Ke,
+  dialog: Je
+}, Ye = me(/* @__PURE__ */ U("path", {
+  d: "M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2m0 16H8V7h11z"
+}), "ContentCopy");
+function on({ url: r, open: o, onClose: i }) {
+  var s;
+  const { t: n } = he("translation"), t = ue(null), e = ae(() => {
+    navigator.clipboard.writeText(r);
+  }, [r]);
+  return ce(() => {
+    t.current && ze.toCanvas(t.current, r, { width: 350 }).catch((a) => console.error(a));
+  }, [r, o]), /* @__PURE__ */ Rt(
+    fe,
+    {
+      open: o,
+      onClose: i,
+      keepMounted: !0,
+      className: je.dialog,
+      children: [
+        /* @__PURE__ */ U(de, { children: /* @__PURE__ */ U(
+          "a",
+          {
+            href: r,
+            target: "_blank",
+            rel: "noreferrer",
+            "data-testid": "qr-dialog-link",
+            children: /* @__PURE__ */ U(
+              "canvas",
+              {
+                width: 164,
+                height: 164,
+                ref: t
+              }
+            )
+          }
+        ) }),
+        /* @__PURE__ */ Rt(ge, { children: [
+          /* @__PURE__ */ U(
+            It,
+            {
+              disabled: !((s = navigator == null ? void 0 : navigator.clipboard) != null && s.writeText),
+              onClick: e,
+              variant: "outlined",
+              startIcon: /* @__PURE__ */ U(Ye, {}),
+              children: n("deploy.actions.copy")
+            }
+          ),
+          /* @__PURE__ */ U(
+            It,
+            {
+              onClick: i,
+              variant: "outlined",
+              children: n("deploy.actions.close")
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+export {
+  on as D,
+  ze as q,
+  je as s
+};