@moneyto/components 0.0.10 → 0.0.13

package/dist/mobile-apps.js

@@ -0,0 +1,1741 @@
+import { c as he, p as me, a as q, ap as Te, m as Lt, n as qt, i as G, e as O, t as It, f as we, g as D, k as x, j as Dt, l as Me, b as St, h as k, r as Tt, q as pe, x as Ie, s as tt, S as be, w as kt, at as Ut } from "./Styles-Dmz3r-1B.js";
+import { g as Ne, A as Mt, M as ve, h as Ft, d as _e, G as Le } from "./google-play-DwU6F6by.js";
+const et = () => "ontouchstart" in window || navigator.maxTouchPoints > 0, zt = () => !("MSStream" in window) && (/iPad|iPhone|iPod/.test(navigator.userAgent) || navigator.userAgent.includes("Mac") && "ontouchend" in document);
+var H = {}, nt, Vt;
+function qe() {
+  return Vt || (Vt = 1, nt = function() {
+    return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+  }), nt;
+}
+var rt = {}, F = {}, Kt;
+function z() {
+  if (Kt) return F;
+  Kt = 1;
+  let o;
+  const r = [
+    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 F.getSymbolSize = function(e) {
+    if (!e) throw new Error('"version" cannot be null or undefined');
+    if (e < 1 || e > 40) throw new Error('"version" should be in range from 1 to 40');
+    return e * 4 + 17;
+  }, F.getSymbolTotalCodewords = function(e) {
+    return r[e];
+  }, F.getBCHDigit = function(i) {
+    let e = 0;
+    for (; i !== 0; )
+      e++, i >>>= 1;
+    return e;
+  }, F.setToSJISFunction = function(e) {
+    if (typeof e != "function")
+      throw new Error('"toSJISFunc" is not a valid function.');
+    o = e;
+  }, F.isKanjiModeEnabled = function() {
+    return typeof o < "u";
+  }, F.toSJIS = function(e) {
+    return o(e);
+  }, F;
+}
+var ot = {}, Ht;
+function bt() {
+  return Ht || (Ht = 1, function(o) {
+    o.L = { bit: 1 }, o.M = { bit: 0 }, o.Q = { bit: 3 }, o.H = { bit: 2 };
+    function r(i) {
+      if (typeof i != "string")
+        throw new Error("Param is not a string");
+      switch (i.toLowerCase()) {
+        case "l":
+        case "low":
+          return o.L;
+        case "m":
+        case "medium":
+          return o.M;
+        case "q":
+        case "quartile":
+          return o.Q;
+        case "h":
+        case "high":
+          return o.H;
+        default:
+          throw new Error("Unknown EC Level: " + i);
+      }
+    }
+    o.isValid = function(e) {
+      return e && typeof e.bit < "u" && e.bit >= 0 && e.bit < 4;
+    }, o.from = function(e, t) {
+      if (o.isValid(e))
+        return e;
+      try {
+        return r(e);
+      } catch {
+        return t;
+      }
+    };
+  }(ot)), ot;
+}
+var it, Jt;
+function De() {
+  if (Jt) return it;
+  Jt = 1;
+  function o() {
+    this.buffer = [], this.length = 0;
+  }
+  return o.prototype = {
+    get: function(r) {
+      const i = Math.floor(r / 8);
+      return (this.buffer[i] >>> 7 - r % 8 & 1) === 1;
+    },
+    put: function(r, i) {
+      for (let e = 0; e < i; e++)
+        this.putBit((r >>> i - e - 1 & 1) === 1);
+    },
+    getLengthInBits: function() {
+      return this.length;
+    },
+    putBit: function(r) {
+      const i = Math.floor(this.length / 8);
+      this.buffer.length <= i && this.buffer.push(0), r && (this.buffer[i] |= 128 >>> this.length % 8), this.length++;
+    }
+  }, it = o, it;
+}
+var st, jt;
+function ke() {
+  if (jt) return st;
+  jt = 1;
+  function o(r) {
+    if (!r || r < 1)
+      throw new Error("BitMatrix size must be defined and greater than 0");
+    this.size = r, this.data = new Uint8Array(r * r), this.reservedBit = new Uint8Array(r * r);
+  }
+  return o.prototype.set = function(r, i, e, t) {
+    const n = r * this.size + i;
+    this.data[n] = e, t && (this.reservedBit[n] = !0);
+  }, o.prototype.get = function(r, i) {
+    return this.data[r * this.size + i];
+  }, o.prototype.xor = function(r, i, e) {
+    this.data[r * this.size + i] ^= e;
+  }, o.prototype.isReserved = function(r, i) {
+    return this.reservedBit[r * this.size + i];
+  }, st = o, st;
+}
+var at = {}, Ot;
+function Ue() {
+  return Ot || (Ot = 1, function(o) {
+    const r = z().getSymbolSize;
+    o.getRowColCoords = function(e) {
+      if (e === 1) return [];
+      const t = Math.floor(e / 7) + 2, n = r(e), s = n === 145 ? 26 : Math.ceil((n - 13) / (2 * t - 2)) * 2, u = [n - 7];
+      for (let a = 1; a < t - 1; a++)
+        u[a] = u[a - 1] - s;
+      return u.push(6), u.reverse();
+    }, o.getPositions = function(e) {
+      const t = [], n = o.getRowColCoords(e), s = n.length;
+      for (let u = 0; u < s; u++)
+        for (let a = 0; a < s; a++)
+          u === 0 && a === 0 || // top-left
+          u === 0 && a === s - 1 || // bottom-left
+          u === s - 1 && a === 0 || t.push([n[u], n[a]]);
+      return t;
+    };
+  }(at)), at;
+}
+var ut = {}, Yt;
+function Fe() {
+  if (Yt) return ut;
+  Yt = 1;
+  const o = z().getSymbolSize, r = 7;
+  return ut.getPositions = function(e) {
+    const t = o(e);
+    return [
+      // top-left
+      [0, 0],
+      // top-right
+      [t - r, 0],
+      // bottom-left
+      [0, t - r]
+    ];
+  }, ut;
+}
+var ct = {}, Qt;
+function ze() {
+  return Qt || (Qt = 1, function(o) {
+    o.Patterns = {
+      PATTERN000: 0,
+      PATTERN001: 1,
+      PATTERN010: 2,
+      PATTERN011: 3,
+      PATTERN100: 4,
+      PATTERN101: 5,
+      PATTERN110: 6,
+      PATTERN111: 7
+    };
+    const r = {
+      N1: 3,
+      N2: 3,
+      N3: 40,
+      N4: 10
+    };
+    o.isValid = function(t) {
+      return t != null && t !== "" && !isNaN(t) && t >= 0 && t <= 7;
+    }, o.from = function(t) {
+      return o.isValid(t) ? parseInt(t, 10) : void 0;
+    }, o.getPenaltyN1 = function(t) {
+      const n = t.size;
+      let s = 0, u = 0, a = 0, c = null, f = null;
+      for (let m = 0; m < n; m++) {
+        u = a = 0, c = f = null;
+        for (let g = 0; g < n; g++) {
+          let l = t.get(m, g);
+          l === c ? u++ : (u >= 5 && (s += r.N1 + (u - 5)), c = l, u = 1), l = t.get(g, m), l === f ? a++ : (a >= 5 && (s += r.N1 + (a - 5)), f = l, a = 1);
+        }
+        u >= 5 && (s += r.N1 + (u - 5)), a >= 5 && (s += r.N1 + (a - 5));
+      }
+      return s;
+    }, o.getPenaltyN2 = function(t) {
+      const n = t.size;
+      let s = 0;
+      for (let u = 0; u < n - 1; u++)
+        for (let a = 0; a < n - 1; a++) {
+          const c = t.get(u, a) + t.get(u, a + 1) + t.get(u + 1, a) + t.get(u + 1, a + 1);
+          (c === 4 || c === 0) && s++;
+        }
+      return s * r.N2;
+    }, o.getPenaltyN3 = function(t) {
+      const n = t.size;
+      let s = 0, u = 0, a = 0;
+      for (let c = 0; c < n; c++) {
+        u = a = 0;
+        for (let f = 0; f < n; f++)
+          u = u << 1 & 2047 | t.get(c, f), f >= 10 && (u === 1488 || u === 93) && s++, a = a << 1 & 2047 | t.get(f, c), f >= 10 && (a === 1488 || a === 93) && s++;
+      }
+      return s * r.N3;
+    }, o.getPenaltyN4 = function(t) {
+      let n = 0;
+      const s = t.data.length;
+      for (let a = 0; a < s; a++) n += t.data[a];
+      return Math.abs(Math.ceil(n * 100 / s / 5) - 10) * r.N4;
+    };
+    function i(e, t, n) {
+      switch (e) {
+        case o.Patterns.PATTERN000:
+          return (t + n) % 2 === 0;
+        case o.Patterns.PATTERN001:
+          return t % 2 === 0;
+        case o.Patterns.PATTERN010:
+          return n % 3 === 0;
+        case o.Patterns.PATTERN011:
+          return (t + n) % 3 === 0;
+        case o.Patterns.PATTERN100:
+          return (Math.floor(t / 2) + Math.floor(n / 3)) % 2 === 0;
+        case o.Patterns.PATTERN101:
+          return t * n % 2 + t * n % 3 === 0;
+        case o.Patterns.PATTERN110:
+          return (t * n % 2 + t * n % 3) % 2 === 0;
+        case o.Patterns.PATTERN111:
+          return (t * n % 3 + (t + n) % 2) % 2 === 0;
+        default:
+          throw new Error("bad maskPattern:" + e);
+      }
+    }
+    o.applyMask = function(t, n) {
+      const s = n.size;
+      for (let u = 0; u < s; u++)
+        for (let a = 0; a < s; a++)
+          n.isReserved(a, u) || n.xor(a, u, i(t, a, u));
+    }, o.getBestMask = function(t, n) {
+      const s = Object.keys(o.Patterns).length;
+      let u = 0, a = 1 / 0;
+      for (let c = 0; c < s; c++) {
+        n(c), o.applyMask(c, t);
+        const f = o.getPenaltyN1(t) + o.getPenaltyN2(t) + o.getPenaltyN3(t) + o.getPenaltyN4(t);
+        o.applyMask(c, t), f < a && (a = f, u = c);
+      }
+      return u;
+    };
+  }(ct)), ct;
+}
+var Q = {}, Gt;
+function ye() {
+  if (Gt) return Q;
+  Gt = 1;
+  const o = bt(), r = [
+    // 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 Q.getBlocksCount = function(t, n) {
+    switch (n) {
+      case o.L:
+        return r[(t - 1) * 4 + 0];
+      case o.M:
+        return r[(t - 1) * 4 + 1];
+      case o.Q:
+        return r[(t - 1) * 4 + 2];
+      case o.H:
+        return r[(t - 1) * 4 + 3];
+      default:
+        return;
+    }
+  }, Q.getTotalCodewordsCount = function(t, n) {
+    switch (n) {
+      case o.L:
+        return i[(t - 1) * 4 + 0];
+      case o.M:
+        return i[(t - 1) * 4 + 1];
+      case o.Q:
+        return i[(t - 1) * 4 + 2];
+      case o.H:
+        return i[(t - 1) * 4 + 3];
+      default:
+        return;
+    }
+  }, Q;
+}
+var lt = {}, j = {}, $t;
+function Ve() {
+  if ($t) return j;
+  $t = 1;
+  const o = new Uint8Array(512), r = new Uint8Array(256);
+  return function() {
+    let e = 1;
+    for (let t = 0; t < 255; t++)
+      o[t] = e, r[e] = t, e <<= 1, e & 256 && (e ^= 285);
+    for (let t = 255; t < 512; t++)
+      o[t] = o[t - 255];
+  }(), j.log = function(e) {
+    if (e < 1) throw new Error("log(" + e + ")");
+    return r[e];
+  }, j.exp = function(e) {
+    return o[e];
+  }, j.mul = function(e, t) {
+    return e === 0 || t === 0 ? 0 : o[r[e] + r[t]];
+  }, j;
+}
+var Wt;
+function Ke() {
+  return Wt || (Wt = 1, function(o) {
+    const r = Ve();
+    o.mul = function(e, t) {
+      const n = new Uint8Array(e.length + t.length - 1);
+      for (let s = 0; s < e.length; s++)
+        for (let u = 0; u < t.length; u++)
+          n[s + u] ^= r.mul(e[s], t[u]);
+      return n;
+    }, o.mod = function(e, t) {
+      let n = new Uint8Array(e);
+      for (; n.length - t.length >= 0; ) {
+        const s = n[0];
+        for (let a = 0; a < t.length; a++)
+          n[a] ^= r.mul(t[a], s);
+        let u = 0;
+        for (; u < n.length && n[u] === 0; ) u++;
+        n = n.slice(u);
+      }
+      return n;
+    }, o.generateECPolynomial = function(e) {
+      let t = new Uint8Array([1]);
+      for (let n = 0; n < e; n++)
+        t = o.mul(t, new Uint8Array([1, r.exp(n)]));
+      return t;
+    };
+  }(lt)), lt;
+}
+var ft, Zt;
+function He() {
+  if (Zt) return ft;
+  Zt = 1;
+  const o = Ke();
+  function r(i) {
+    this.genPoly = void 0, this.degree = i, this.degree && this.initialize(this.degree);
+  }
+  return r.prototype.initialize = function(e) {
+    this.degree = e, this.genPoly = o.generateECPolynomial(this.degree);
+  }, r.prototype.encode = function(e) {
+    if (!this.genPoly)
+      throw new Error("Encoder not initialized");
+    const t = new Uint8Array(e.length + this.degree);
+    t.set(e);
+    const n = o.mod(t, this.genPoly), s = this.degree - n.length;
+    if (s > 0) {
+      const u = new Uint8Array(this.degree);
+      return u.set(n, s), u;
+    }
+    return n;
+  }, ft = r, ft;
+}
+var dt = {}, gt = {}, ht = {}, Xt;
+function Ce() {
+  return Xt || (Xt = 1, ht.isValid = function(r) {
+    return !isNaN(r) && r >= 1 && r <= 40;
+  }), ht;
+}
+var v = {}, xt;
+function Ee() {
+  if (xt) return v;
+  xt = 1;
+  const o = "[0-9]+", r = "[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 e = "(?:(?![A-Z0-9 $%*+\\-./:]|" + i + `)(?:.|[\r
+]))+`;
+  v.KANJI = new RegExp(i, "g"), v.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), v.BYTE = new RegExp(e, "g"), v.NUMERIC = new RegExp(o, "g"), v.ALPHANUMERIC = new RegExp(r, "g");
+  const t = new RegExp("^" + i + "$"), n = new RegExp("^" + o + "$"), s = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+  return v.testKanji = function(a) {
+    return t.test(a);
+  }, v.testNumeric = function(a) {
+    return n.test(a);
+  }, v.testAlphanumeric = function(a) {
+    return s.test(a);
+  }, v;
+}
+var te;
+function V() {
+  return te || (te = 1, function(o) {
+    const r = Ce(), i = Ee();
+    o.NUMERIC = {
+      id: "Numeric",
+      bit: 1,
+      ccBits: [10, 12, 14]
+    }, o.ALPHANUMERIC = {
+      id: "Alphanumeric",
+      bit: 2,
+      ccBits: [9, 11, 13]
+    }, o.BYTE = {
+      id: "Byte",
+      bit: 4,
+      ccBits: [8, 16, 16]
+    }, o.KANJI = {
+      id: "Kanji",
+      bit: 8,
+      ccBits: [8, 10, 12]
+    }, o.MIXED = {
+      bit: -1
+    }, o.getCharCountIndicator = function(n, s) {
+      if (!n.ccBits) throw new Error("Invalid mode: " + n);
+      if (!r.isValid(s))
+        throw new Error("Invalid version: " + s);
+      return s >= 1 && s < 10 ? n.ccBits[0] : s < 27 ? n.ccBits[1] : n.ccBits[2];
+    }, o.getBestModeForData = function(n) {
+      return i.testNumeric(n) ? o.NUMERIC : i.testAlphanumeric(n) ? o.ALPHANUMERIC : i.testKanji(n) ? o.KANJI : o.BYTE;
+    }, o.toString = function(n) {
+      if (n && n.id) return n.id;
+      throw new Error("Invalid mode");
+    }, o.isValid = function(n) {
+      return n && n.bit && n.ccBits;
+    };
+    function e(t) {
+      if (typeof t != "string")
+        throw new Error("Param is not a string");
+      switch (t.toLowerCase()) {
+        case "numeric":
+          return o.NUMERIC;
+        case "alphanumeric":
+          return o.ALPHANUMERIC;
+        case "kanji":
+          return o.KANJI;
+        case "byte":
+          return o.BYTE;
+        default:
+          throw new Error("Unknown mode: " + t);
+      }
+    }
+    o.from = function(n, s) {
+      if (o.isValid(n))
+        return n;
+      try {
+        return e(n);
+      } catch {
+        return s;
+      }
+    };
+  }(gt)), gt;
+}
+var ee;
+function Je() {
+  return ee || (ee = 1, function(o) {
+    const r = z(), i = ye(), e = bt(), t = V(), n = Ce(), s = 7973, u = r.getBCHDigit(s);
+    function a(g, l, A) {
+      for (let I = 1; I <= 40; I++)
+        if (l <= o.getCapacity(I, A, g))
+          return I;
+    }
+    function c(g, l) {
+      return t.getCharCountIndicator(g, l) + 4;
+    }
+    function f(g, l) {
+      let A = 0;
+      return g.forEach(function(I) {
+        const N = c(I.mode, l);
+        A += N + I.getBitsLength();
+      }), A;
+    }
+    function m(g, l) {
+      for (let A = 1; A <= 40; A++)
+        if (f(g, A) <= o.getCapacity(A, l, t.MIXED))
+          return A;
+    }
+    o.from = function(l, A) {
+      return n.isValid(l) ? parseInt(l, 10) : A;
+    }, o.getCapacity = function(l, A, I) {
+      if (!n.isValid(l))
+        throw new Error("Invalid QR Code version");
+      typeof I > "u" && (I = t.BYTE);
+      const N = r.getSymbolTotalCodewords(l), P = i.getTotalCodewordsCount(l, A), S = (N - P) * 8;
+      if (I === t.MIXED) return S;
+      const w = S - c(I, l);
+      switch (I) {
+        case t.NUMERIC:
+          return Math.floor(w / 10 * 3);
+        case t.ALPHANUMERIC:
+          return Math.floor(w / 11 * 2);
+        case t.KANJI:
+          return Math.floor(w / 13);
+        case t.BYTE:
+        default:
+          return Math.floor(w / 8);
+      }
+    }, o.getBestVersionForData = function(l, A) {
+      let I;
+      const N = e.from(A, e.M);
+      if (Array.isArray(l)) {
+        if (l.length > 1)
+          return m(l, N);
+        if (l.length === 0)
+          return 1;
+        I = l[0];
+      } else
+        I = l;
+      return a(I.mode, I.getLength(), N);
+    }, o.getEncodedBits = function(l) {
+      if (!n.isValid(l) || l < 7)
+        throw new Error("Invalid QR Code version");
+      let A = l << 12;
+      for (; r.getBCHDigit(A) - u >= 0; )
+        A ^= s << r.getBCHDigit(A) - u;
+      return l << 12 | A;
+    };
+  }(dt)), dt;
+}
+var mt = {}, ne;
+function je() {
+  if (ne) return mt;
+  ne = 1;
+  const o = z(), r = 1335, i = 21522, e = o.getBCHDigit(r);
+  return mt.getEncodedBits = function(n, s) {
+    const u = n.bit << 3 | s;
+    let a = u << 10;
+    for (; o.getBCHDigit(a) - e >= 0; )
+      a ^= r << o.getBCHDigit(a) - e;
+    return (u << 10 | a) ^ i;
+  }, mt;
+}
+var wt = {}, pt, re;
+function Oe() {
+  if (re) return pt;
+  re = 1;
+  const o = V();
+  function r(i) {
+    this.mode = o.NUMERIC, this.data = i.toString();
+  }
+  return r.getBitsLength = function(e) {
+    return 10 * Math.floor(e / 3) + (e % 3 ? e % 3 * 3 + 1 : 0);
+  }, r.prototype.getLength = function() {
+    return this.data.length;
+  }, r.prototype.getBitsLength = function() {
+    return r.getBitsLength(this.data.length);
+  }, r.prototype.write = function(e) {
+    let t, n, s;
+    for (t = 0; t + 3 <= this.data.length; t += 3)
+      n = this.data.substr(t, 3), s = parseInt(n, 10), e.put(s, 10);
+    const u = this.data.length - t;
+    u > 0 && (n = this.data.substr(t), s = parseInt(n, 10), e.put(s, u * 3 + 1));
+  }, pt = r, pt;
+}
+var yt, oe;
+function Ye() {
+  if (oe) return yt;
+  oe = 1;
+  const o = V(), r = [
+    "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(e) {
+    this.mode = o.ALPHANUMERIC, this.data = e;
+  }
+  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 n;
+    for (n = 0; n + 2 <= this.data.length; n += 2) {
+      let s = r.indexOf(this.data[n]) * 45;
+      s += r.indexOf(this.data[n + 1]), t.put(s, 11);
+    }
+    this.data.length % 2 && t.put(r.indexOf(this.data[n]), 6);
+  }, yt = i, yt;
+}
+var Ct, ie;
+function Qe() {
+  if (ie) return Ct;
+  ie = 1;
+  const o = V();
+  function r(i) {
+    this.mode = o.BYTE, typeof i == "string" ? this.data = new TextEncoder().encode(i) : this.data = new Uint8Array(i);
+  }
+  return r.getBitsLength = function(e) {
+    return e * 8;
+  }, r.prototype.getLength = function() {
+    return this.data.length;
+  }, r.prototype.getBitsLength = function() {
+    return r.getBitsLength(this.data.length);
+  }, r.prototype.write = function(i) {
+    for (let e = 0, t = this.data.length; e < t; e++)
+      i.put(this.data[e], 8);
+  }, Ct = r, Ct;
+}
+var Et, se;
+function Ge() {
+  if (se) return Et;
+  se = 1;
+  const o = V(), r = z();
+  function i(e) {
+    this.mode = o.KANJI, this.data = e;
+  }
+  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(e) {
+    let t;
+    for (t = 0; t < this.data.length; t++) {
+      let n = r.toSJIS(this.data[t]);
+      if (n >= 33088 && n <= 40956)
+        n -= 33088;
+      else if (n >= 57408 && n <= 60351)
+        n -= 49472;
+      else
+        throw new Error(
+          "Invalid SJIS character: " + this.data[t] + `
+Make sure your charset is UTF-8`
+        );
+      n = (n >>> 8 & 255) * 192 + (n & 255), e.put(n, 13);
+    }
+  }, Et = i, Et;
+}
+var Bt = { exports: {} }, ae;
+function $e() {
+  return ae || (ae = 1, function(o) {
+    var r = {
+      single_source_shortest_paths: function(i, e, t) {
+        var n = {}, s = {};
+        s[e] = 0;
+        var u = r.PriorityQueue.make();
+        u.push(e, 0);
+        for (var a, c, f, m, g, l, A, I, N; !u.empty(); ) {
+          a = u.pop(), c = a.value, m = a.cost, g = i[c] || {};
+          for (f in g)
+            g.hasOwnProperty(f) && (l = g[f], A = m + l, I = s[f], N = typeof s[f] > "u", (N || I > A) && (s[f] = A, u.push(f, A), n[f] = c));
+        }
+        if (typeof t < "u" && typeof s[t] > "u") {
+          var P = ["Could not find a path from ", e, " to ", t, "."].join("");
+          throw new Error(P);
+        }
+        return n;
+      },
+      extract_shortest_path_from_predecessor_list: function(i, e) {
+        for (var t = [], n = e; n; )
+          t.push(n), i[n], n = i[n];
+        return t.reverse(), t;
+      },
+      find_path: function(i, e, t) {
+        var n = r.single_source_shortest_paths(i, e, t);
+        return r.extract_shortest_path_from_predecessor_list(
+          n,
+          t
+        );
+      },
+      /**
+       * A very naive priority queue implementation.
+       */
+      PriorityQueue: {
+        make: function(i) {
+          var e = r.PriorityQueue, t = {}, n;
+          i = i || {};
+          for (n in e)
+            e.hasOwnProperty(n) && (t[n] = e[n]);
+          return t.queue = [], t.sorter = i.sorter || e.default_sorter, t;
+        },
+        default_sorter: function(i, e) {
+          return i.cost - e.cost;
+        },
+        /**
+         * Add a new item to the queue and ensure the highest priority element
+         * is at the front of the queue.
+         */
+        push: function(i, e) {
+          var t = { value: i, cost: e };
+          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;
+        }
+      }
+    };
+    o.exports = r;
+  }(Bt)), Bt.exports;
+}
+var ue;
+function We() {
+  return ue || (ue = 1, function(o) {
+    const r = V(), i = Oe(), e = Ye(), t = Qe(), n = Ge(), s = Ee(), u = z(), a = $e();
+    function c(P) {
+      return unescape(encodeURIComponent(P)).length;
+    }
+    function f(P, S, w) {
+      const E = [];
+      let M;
+      for (; (M = P.exec(w)) !== null; )
+        E.push({
+          data: M[0],
+          index: M.index,
+          mode: S,
+          length: M[0].length
+        });
+      return E;
+    }
+    function m(P) {
+      const S = f(s.NUMERIC, r.NUMERIC, P), w = f(s.ALPHANUMERIC, r.ALPHANUMERIC, P);
+      let E, M;
+      return u.isKanjiModeEnabled() ? (E = f(s.BYTE, r.BYTE, P), M = f(s.KANJI, r.KANJI, P)) : (E = f(s.BYTE_KANJI, r.BYTE, P), M = []), S.concat(w, E, M).sort(function(p, B) {
+        return p.index - B.index;
+      }).map(function(p) {
+        return {
+          data: p.data,
+          mode: p.mode,
+          length: p.length
+        };
+      });
+    }
+    function g(P, S) {
+      switch (S) {
+        case r.NUMERIC:
+          return i.getBitsLength(P);
+        case r.ALPHANUMERIC:
+          return e.getBitsLength(P);
+        case r.KANJI:
+          return n.getBitsLength(P);
+        case r.BYTE:
+          return t.getBitsLength(P);
+      }
+    }
+    function l(P) {
+      return P.reduce(function(S, w) {
+        const E = S.length - 1 >= 0 ? S[S.length - 1] : null;
+        return E && E.mode === w.mode ? (S[S.length - 1].data += w.data, S) : (S.push(w), S);
+      }, []);
+    }
+    function A(P) {
+      const S = [];
+      for (let w = 0; w < P.length; w++) {
+        const E = P[w];
+        switch (E.mode) {
+          case r.NUMERIC:
+            S.push([
+              E,
+              { data: E.data, mode: r.ALPHANUMERIC, length: E.length },
+              { data: E.data, mode: r.BYTE, length: E.length }
+            ]);
+            break;
+          case r.ALPHANUMERIC:
+            S.push([
+              E,
+              { data: E.data, mode: r.BYTE, length: E.length }
+            ]);
+            break;
+          case r.KANJI:
+            S.push([
+              E,
+              { data: E.data, mode: r.BYTE, length: c(E.data) }
+            ]);
+            break;
+          case r.BYTE:
+            S.push([
+              { data: E.data, mode: r.BYTE, length: c(E.data) }
+            ]);
+        }
+      }
+      return S;
+    }
+    function I(P, S) {
+      const w = {}, E = { start: {} };
+      let M = ["start"];
+      for (let d = 0; d < P.length; d++) {
+        const p = P[d], B = [];
+        for (let h = 0; h < p.length; h++) {
+          const T = p[h], y = "" + d + h;
+          B.push(y), w[y] = { node: T, lastCount: 0 }, E[y] = {};
+          for (let R = 0; R < M.length; R++) {
+            const C = M[R];
+            w[C] && w[C].node.mode === T.mode ? (E[C][y] = g(w[C].lastCount + T.length, T.mode) - g(w[C].lastCount, T.mode), w[C].lastCount += T.length) : (w[C] && (w[C].lastCount = T.length), E[C][y] = g(T.length, T.mode) + 4 + r.getCharCountIndicator(T.mode, S));
+          }
+        }
+        M = B;
+      }
+      for (let d = 0; d < M.length; d++)
+        E[M[d]].end = 0;
+      return { map: E, table: w };
+    }
+    function N(P, S) {
+      let w;
+      const E = r.getBestModeForData(P);
+      if (w = r.from(S, E), w !== r.BYTE && w.bit < E.bit)
+        throw new Error('"' + P + '" cannot be encoded with mode ' + r.toString(w) + `.
+ Suggested mode is: ` + r.toString(E));
+      switch (w === r.KANJI && !u.isKanjiModeEnabled() && (w = r.BYTE), w) {
+        case r.NUMERIC:
+          return new i(P);
+        case r.ALPHANUMERIC:
+          return new e(P);
+        case r.KANJI:
+          return new n(P);
+        case r.BYTE:
+          return new t(P);
+      }
+    }
+    o.fromArray = function(S) {
+      return S.reduce(function(w, E) {
+        return typeof E == "string" ? w.push(N(E, null)) : E.data && w.push(N(E.data, E.mode)), w;
+      }, []);
+    }, o.fromString = function(S, w) {
+      const E = m(S, u.isKanjiModeEnabled()), M = A(E), d = I(M, w), p = a.find_path(d.map, "start", "end"), B = [];
+      for (let h = 1; h < p.length - 1; h++)
+        B.push(d.table[p[h]].node);
+      return o.fromArray(l(B));
+    }, o.rawSplit = function(S) {
+      return o.fromArray(
+        m(S, u.isKanjiModeEnabled())
+      );
+    };
+  }(wt)), wt;
+}
+var ce;
+function Ze() {
+  if (ce) return rt;
+  ce = 1;
+  const o = z(), r = bt(), i = De(), e = ke(), t = Ue(), n = Fe(), s = ze(), u = ye(), a = He(), c = Je(), f = je(), m = V(), g = We();
+  function l(d, p) {
+    const B = d.size, h = n.getPositions(p);
+    for (let T = 0; T < h.length; T++) {
+      const y = h[T][0], R = h[T][1];
+      for (let C = -1; C <= 7; C++)
+        if (!(y + C <= -1 || B <= y + C))
+          for (let b = -1; b <= 7; b++)
+            R + b <= -1 || B <= R + b || (C >= 0 && C <= 6 && (b === 0 || b === 6) || b >= 0 && b <= 6 && (C === 0 || C === 6) || C >= 2 && C <= 4 && b >= 2 && b <= 4 ? d.set(y + C, R + b, !0, !0) : d.set(y + C, R + b, !1, !0));
+    }
+  }
+  function A(d) {
+    const p = d.size;
+    for (let B = 8; B < p - 8; B++) {
+      const h = B % 2 === 0;
+      d.set(B, 6, h, !0), d.set(6, B, h, !0);
+    }
+  }
+  function I(d, p) {
+    const B = t.getPositions(p);
+    for (let h = 0; h < B.length; h++) {
+      const T = B[h][0], y = B[h][1];
+      for (let R = -2; R <= 2; R++)
+        for (let C = -2; C <= 2; C++)
+          R === -2 || R === 2 || C === -2 || C === 2 || R === 0 && C === 0 ? d.set(T + R, y + C, !0, !0) : d.set(T + R, y + C, !1, !0);
+    }
+  }
+  function N(d, p) {
+    const B = d.size, h = c.getEncodedBits(p);
+    let T, y, R;
+    for (let C = 0; C < 18; C++)
+      T = Math.floor(C / 3), y = C % 3 + B - 8 - 3, R = (h >> C & 1) === 1, d.set(T, y, R, !0), d.set(y, T, R, !0);
+  }
+  function P(d, p, B) {
+    const h = d.size, T = f.getEncodedBits(p, B);
+    let y, R;
+    for (y = 0; y < 15; y++)
+      R = (T >> y & 1) === 1, y < 6 ? d.set(y, 8, R, !0) : y < 8 ? d.set(y + 1, 8, R, !0) : d.set(h - 15 + y, 8, R, !0), y < 8 ? d.set(8, h - y - 1, R, !0) : y < 9 ? d.set(8, 15 - y - 1 + 1, R, !0) : d.set(8, 15 - y - 1, R, !0);
+    d.set(h - 8, 8, 1, !0);
+  }
+  function S(d, p) {
+    const B = d.size;
+    let h = -1, T = B - 1, y = 7, R = 0;
+    for (let C = B - 1; C > 0; C -= 2)
+      for (C === 6 && C--; ; ) {
+        for (let b = 0; b < 2; b++)
+          if (!d.isReserved(T, C - b)) {
+            let U = !1;
+            R < p.length && (U = (p[R] >>> y & 1) === 1), d.set(T, C - b, U), y--, y === -1 && (R++, y = 7);
+          }
+        if (T += h, T < 0 || B <= T) {
+          T -= h, h = -h;
+          break;
+        }
+      }
+  }
+  function w(d, p, B) {
+    const h = new i();
+    B.forEach(function(b) {
+      h.put(b.mode.bit, 4), h.put(b.getLength(), m.getCharCountIndicator(b.mode, d)), b.write(h);
+    });
+    const T = o.getSymbolTotalCodewords(d), y = u.getTotalCodewordsCount(d, p), R = (T - y) * 8;
+    for (h.getLengthInBits() + 4 <= R && h.put(0, 4); h.getLengthInBits() % 8 !== 0; )
+      h.putBit(0);
+    const C = (R - h.getLengthInBits()) / 8;
+    for (let b = 0; b < C; b++)
+      h.put(b % 2 ? 17 : 236, 8);
+    return E(h, d, p);
+  }
+  function E(d, p, B) {
+    const h = o.getSymbolTotalCodewords(p), T = u.getTotalCodewordsCount(p, B), y = h - T, R = u.getBlocksCount(p, B), C = h % R, b = R - C, U = Math.floor(h / R), J = Math.floor(y / R), Re = J + 1, Nt = U - J, Pe = new a(Nt);
+    let $ = 0;
+    const Y = new Array(R), vt = new Array(R);
+    let W = 0;
+    const Se = new Uint8Array(d.buffer);
+    for (let K = 0; K < R; K++) {
+      const X = K < b ? J : Re;
+      Y[K] = Se.slice($, $ + X), vt[K] = Pe.encode(Y[K]), $ += X, W = Math.max(W, X);
+    }
+    const Z = new Uint8Array(h);
+    let _t = 0, _, L;
+    for (_ = 0; _ < W; _++)
+      for (L = 0; L < R; L++)
+        _ < Y[L].length && (Z[_t++] = Y[L][_]);
+    for (_ = 0; _ < Nt; _++)
+      for (L = 0; L < R; L++)
+        Z[_t++] = vt[L][_];
+    return Z;
+  }
+  function M(d, p, B, h) {
+    let T;
+    if (Array.isArray(d))
+      T = g.fromArray(d);
+    else if (typeof d == "string") {
+      let U = p;
+      if (!U) {
+        const J = g.rawSplit(d);
+        U = c.getBestVersionForData(J, B);
+      }
+      T = g.fromString(d, U || 40);
+    } else
+      throw new Error("Invalid data");
+    const y = c.getBestVersionForData(T, B);
+    if (!y)
+      throw new Error("The amount of data is too big to be stored in a QR Code");
+    if (!p)
+      p = y;
+    else if (p < y)
+      throw new Error(
+        `
+The chosen QR Code version cannot contain this amount of data.
+Minimum version required to store current data is: ` + y + `.
+`
+      );
+    const R = w(p, B, T), C = o.getSymbolSize(p), b = new e(C);
+    return l(b, p), A(b), I(b, p), P(b, B, 0), p >= 7 && N(b, p), S(b, R), isNaN(h) && (h = s.getBestMask(
+      b,
+      P.bind(null, b, B)
+    )), s.applyMask(h, b), P(b, B, h), {
+      modules: b,
+      version: p,
+      errorCorrectionLevel: B,
+      maskPattern: h,
+      segments: T
+    };
+  }
+  return rt.create = function(p, B) {
+    if (typeof p > "u" || p === "")
+      throw new Error("No input text");
+    let h = r.M, T, y;
+    return typeof B < "u" && (h = r.from(B.errorCorrectionLevel, r.M), T = c.from(B.version), y = s.from(B.maskPattern), B.toSJISFunc && o.setToSJISFunction(B.toSJISFunc)), M(p, T, h, y);
+  }, rt;
+}
+var At = {}, Rt = {}, le;
+function Be() {
+  return le || (le = 1, function(o) {
+    function r(i) {
+      if (typeof i == "number" && (i = i.toString()), typeof i != "string")
+        throw new Error("Color should be defined as hex string");
+      let e = i.slice().replace("#", "").split("");
+      if (e.length < 3 || e.length === 5 || e.length > 8)
+        throw new Error("Invalid hex color: " + i);
+      (e.length === 3 || e.length === 4) && (e = Array.prototype.concat.apply([], e.map(function(n) {
+        return [n, n];
+      }))), e.length === 6 && e.push("F", "F");
+      const t = parseInt(e.join(""), 16);
+      return {
+        r: t >> 24 & 255,
+        g: t >> 16 & 255,
+        b: t >> 8 & 255,
+        a: t & 255,
+        hex: "#" + e.slice(0, 6).join("")
+      };
+    }
+    o.getOptions = function(e) {
+      e || (e = {}), e.color || (e.color = {});
+      const t = typeof e.margin > "u" || e.margin === null || e.margin < 0 ? 4 : e.margin, n = e.width && e.width >= 21 ? e.width : void 0, s = e.scale || 4;
+      return {
+        width: n,
+        scale: n ? 4 : s,
+        margin: t,
+        color: {
+          dark: r(e.color.dark || "#000000ff"),
+          light: r(e.color.light || "#ffffffff")
+        },
+        type: e.type,
+        rendererOpts: e.rendererOpts || {}
+      };
+    }, o.getScale = function(e, t) {
+      return t.width && t.width >= e + t.margin * 2 ? t.width / (e + t.margin * 2) : t.scale;
+    }, o.getImageWidth = function(e, t) {
+      const n = o.getScale(e, t);
+      return Math.floor((e + t.margin * 2) * n);
+    }, o.qrToImageData = function(e, t, n) {
+      const s = t.modules.size, u = t.modules.data, a = o.getScale(s, n), c = Math.floor((s + n.margin * 2) * a), f = n.margin * a, m = [n.color.light, n.color.dark];
+      for (let g = 0; g < c; g++)
+        for (let l = 0; l < c; l++) {
+          let A = (g * c + l) * 4, I = n.color.light;
+          if (g >= f && l >= f && g < c - f && l < c - f) {
+            const N = Math.floor((g - f) / a), P = Math.floor((l - f) / a);
+            I = m[u[N * s + P] ? 1 : 0];
+          }
+          e[A++] = I.r, e[A++] = I.g, e[A++] = I.b, e[A] = I.a;
+        }
+    };
+  }(Rt)), Rt;
+}
+var fe;
+function Xe() {
+  return fe || (fe = 1, function(o) {
+    const r = Be();
+    function i(t, n, s) {
+      t.clearRect(0, 0, n.width, n.height), n.style || (n.style = {}), n.height = s, n.width = s, n.style.height = s + "px", n.style.width = s + "px";
+    }
+    function e() {
+      try {
+        return document.createElement("canvas");
+      } catch {
+        throw new Error("You need to specify a canvas element");
+      }
+    }
+    o.render = function(n, s, u) {
+      let a = u, c = s;
+      typeof a > "u" && (!s || !s.getContext) && (a = s, s = void 0), s || (c = e()), a = r.getOptions(a);
+      const f = r.getImageWidth(n.modules.size, a), m = c.getContext("2d"), g = m.createImageData(f, f);
+      return r.qrToImageData(g.data, n, a), i(m, c, f), m.putImageData(g, 0, 0), c;
+    }, o.renderToDataURL = function(n, s, u) {
+      let a = u;
+      typeof a > "u" && (!s || !s.getContext) && (a = s, s = void 0), a || (a = {});
+      const c = o.render(n, s, a), f = a.type || "image/png", m = a.rendererOpts || {};
+      return c.toDataURL(f, m.quality);
+    };
+  }(At)), At;
+}
+var Pt = {}, de;
+function xe() {
+  if (de) return Pt;
+  de = 1;
+  const o = Be();
+  function r(t, n) {
+    const s = t.a / 255, u = n + '="' + t.hex + '"';
+    return s < 1 ? u + " " + n + '-opacity="' + s.toFixed(2).slice(1) + '"' : u;
+  }
+  function i(t, n, s) {
+    let u = t + n;
+    return typeof s < "u" && (u += " " + s), u;
+  }
+  function e(t, n, s) {
+    let u = "", a = 0, c = !1, f = 0;
+    for (let m = 0; m < t.length; m++) {
+      const g = Math.floor(m % n), l = Math.floor(m / n);
+      !g && !c && (c = !0), t[m] ? (f++, m > 0 && g > 0 && t[m - 1] || (u += c ? i("M", g + s, 0.5 + l + s) : i("m", a, 0), a = 0, c = !1), g + 1 < n && t[m + 1] || (u += i("h", f), f = 0)) : a++;
+    }
+    return u;
+  }
+  return Pt.render = function(n, s, u) {
+    const a = o.getOptions(s), c = n.modules.size, f = n.modules.data, m = c + a.margin * 2, g = a.color.light.a ? "<path " + r(a.color.light, "fill") + ' d="M0 0h' + m + "v" + m + 'H0z"/>' : "", l = "<path " + r(a.color.dark, "stroke") + ' d="' + e(f, c, a.margin) + '"/>', A = 'viewBox="0 0 ' + m + " " + m + '"', N = '<svg xmlns="http://www.w3.org/2000/svg" ' + (a.width ? 'width="' + a.width + '" height="' + a.width + '" ' : "") + A + ' shape-rendering="crispEdges">' + g + l + `</svg>
+`;
+    return typeof u == "function" && u(null, N), N;
+  }, Pt;
+}
+var ge;
+function tn() {
+  if (ge) return H;
+  ge = 1;
+  const o = qe(), r = Ze(), i = Xe(), e = xe();
+  function t(n, s, u, a, c) {
+    const f = [].slice.call(arguments, 1), m = f.length, g = typeof f[m - 1] == "function";
+    if (!g && !o())
+      throw new Error("Callback required as last argument");
+    if (g) {
+      if (m < 2)
+        throw new Error("Too few arguments provided");
+      m === 2 ? (c = u, u = s, s = a = void 0) : m === 3 && (s.getContext && typeof c > "u" ? (c = a, a = void 0) : (c = a, a = u, u = s, s = void 0));
+    } else {
+      if (m < 1)
+        throw new Error("Too few arguments provided");
+      return m === 1 ? (u = s, s = a = void 0) : m === 2 && !s.getContext && (a = u, u = s, s = void 0), new Promise(function(l, A) {
+        try {
+          const I = r.create(u, a);
+          l(n(I, s, a));
+        } catch (I) {
+          A(I);
+        }
+      });
+    }
+    try {
+      const l = r.create(u, a);
+      c(null, n(l, s, a));
+    } catch (l) {
+      c(l);
+    }
+  }
+  return H.create = r.create, H.toCanvas = t.bind(null, i.render), H.toDataURL = t.bind(null, i.renderToDataURL), H.toString = t.bind(null, function(n, s, u) {
+    return e.render(n, u);
+  }), H;
+}
+var en = tn();
+const nn = /* @__PURE__ */ Ne(en);
+var rn = It('<div class="*:h-[240px] *:w-[240px]"><!></div>'), on = It('<div class="animate-pulse rounded-lg bg-gray-200 dark:bg-gray-700"></div>');
+function Ae(o, r) {
+  me(r, !0);
+  let i = q(r, "dark", 7, !1), e = q(r, "height", 7, 60), t = q(r, "content", 7);
+  const n = (c) => ({
+    type: "svg",
+    margin: 2,
+    width: e(),
+    color: {
+      dark: c ? "#ffffff" : "#000000",
+      light: "#0000"
+    }
+  }), s = async (c, f) => {
+    if (!c) return "Error";
+    try {
+      return await nn.toString(c, n(f));
+    } catch (m) {
+      return console.error("Failed to generate QR code:", m), "Error";
+    }
+  };
+  let u = Dt(""), a = Dt(!0);
+  return Te(() => {
+    x(a, !0), s(t(), i()).then((c) => {
+      x(u, Me(c)), x(a, !1);
+    });
+  }), Mt(o, {
+    get dark() {
+      return i();
+    },
+    children: (c, f) => {
+      ve(c, {
+        id: "modal-qr-code",
+        htmlTitle: "Click to enlarge",
+        title: "Scan the QR code",
+        get dark() {
+          return i();
+        },
+        content: (g) => {
+          var l = rn(), A = St(l);
+          Ft(A, () => k(u)), Tt(l), O(g, l);
+        },
+        children: (g, l) => {
+          var A = Lt(), I = qt(A);
+          {
+            var N = (S) => {
+              var w = on();
+              pe(() => Ie(w, "style", `width: ${e() ?? ""}px; height: ${e() ?? ""}px;`)), O(S, w);
+            }, P = (S) => {
+              var w = Lt(), E = qt(w);
+              Ft(E, () => k(u)), O(S, w);
+            };
+            G(I, (S) => {
+              k(a) ? S(N) : S(P, !1);
+            });
+          }
+          O(g, A);
+        },
+        $$slots: { content: !0, default: !0 }
+      });
+    },
+    $$slots: { default: !0 }
+  }), we({
+    get dark() {
+      return i();
+    },
+    set dark(c = !1) {
+      i(c), D();
+    },
+    get height() {
+      return e();
+    },
+    set height(c = 60) {
+      e(c), D();
+    },
+    get content() {
+      return t();
+    },
+    set content(c) {
+      t(c), D();
+    }
+  });
+}
+he(Ae, { dark: {}, height: {}, content: {} }, [], [], !0);
+var sn = It('<main><div class="flex flex-wrap gap-3"><!> <!> <!></div> <!></main>');
+function an(o, r) {
+  me(r, !0);
+  const i = 200, e = 60;
+  let t = q(r, "theme", 7, "light"), n = q(r, "width", 7, i), s = q(r, "align", 7, "left"), u = q(r, "googlePlay", 7, "https://play.google.com/store/apps/details?id=com.ltech.moneyto"), a = q(r, "appStore", 7, "https://apps.apple.com/us/app/moneyto-money-transfer/id1418940675"), c = q(r, "qr", 7, "https://www.moneyto.co.uk/mobile-app"), f = kt(() => t() === "dark"), m = kt(() => n() * e / i);
+  var g = sn(), l = St(g), A = St(l);
+  {
+    var I = (M) => {
+      Mt(M, {
+        get dark() {
+          return k(f);
+        },
+        get href() {
+          return a();
+        },
+        name: "app-store",
+        children: (d, p) => {
+          _e(d, {
+            get width() {
+              return n();
+            },
+            get height() {
+              return k(m);
+            }
+          });
+        },
+        $$slots: { default: !0 }
+      });
+    };
+    G(A, (M) => {
+      (!et() || zt()) && M(I);
+    });
+  }
+  var N = tt(A, 2);
+  {
+    var P = (M) => {
+      Mt(M, {
+        get dark() {
+          return k(f);
+        },
+        get href() {
+          return u();
+        },
+        name: "google-play",
+        children: (d, p) => {
+          Le(d, {
+            get width() {
+              return n();
+            },
+            get height() {
+              return k(m);
+            }
+          });
+        },
+        $$slots: { default: !0 }
+      });
+    };
+    G(N, (M) => {
+      (!et() || !zt()) && M(P);
+    });
+  }
+  var S = tt(N, 2);
+  {
+    var w = (M) => {
+      Ae(M, {
+        get height() {
+          return k(m);
+        },
+        get dark() {
+          return k(f);
+        },
+        get content() {
+          return c();
+        }
+      });
+    };
+    G(S, (M) => {
+      et() || M(w);
+    });
+  }
+  Tt(l);
+  var E = tt(l, 2);
+  return be(E, { host: r.$$host }), Tt(g), pe(() => {
+    Ut(l, "justify-center", s() === "center"), Ut(l, "justify-end", s() === "right");
+  }), O(o, g), we({
+    get theme() {
+      return t();
+    },
+    set theme(M = "light") {
+      t(M), D();
+    },
+    get width() {
+      return n();
+    },
+    set width(M = i) {
+      n(M), D();
+    },
+    get align() {
+      return s();
+    },
+    set align(M = "left") {
+      s(M), D();
+    },
+    get googlePlay() {
+      return u();
+    },
+    set googlePlay(M = "https://play.google.com/store/apps/details?id=com.ltech.moneyto") {
+      u(M), D();
+    },
+    get appStore() {
+      return a();
+    },
+    set appStore(M = "https://apps.apple.com/us/app/moneyto-money-transfer/id1418940675") {
+      a(M), D();
+    },
+    get qr() {
+      return c();
+    },
+    set qr(M = "https://www.moneyto.co.uk/mobile-app") {
+      c(M), D();
+    }
+  });
+}
+customElements.define("moneyto-mobile-apps", he(
+  an,
+  {
+    theme: { attribute: "theme", type: "String" },
+    googlePlay: { attribute: "google-play", type: "String" },
+    appStore: { attribute: "app-store", type: "String" },
+    qr: { attribute: "qr", type: "String" },
+    width: {},
+    align: {}
+  },
+  [],
+  [],
+  !0
+));
+export {
+  an as default
+};