@directcryptopay/sdk 0.1.0

package/dist/index-B7K86vWu.js

@@ -0,0 +1,1742 @@
+import { dJ as de, cy as x, cz as he, cC as ge, cA as me, cB as j } from "./index-DiHImG4L.js";
+import { n as z, c as we } from "./if-defined-BciplFKz.js";
+import "./index-CUdQyyFn.js";
+var K = {}, tt, Tt;
+function pe() {
+  return Tt || (Tt = 1, tt = function() {
+    return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+  }), tt;
+}
+var et = {}, k = {}, Pt;
+function $() {
+  if (Pt) return k;
+  Pt = 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 k.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;
+  }, k.getSymbolTotalCodewords = function(n) {
+    return r[n];
+  }, k.getBCHDigit = function(i) {
+    let n = 0;
+    for (; i !== 0; )
+      n++, i >>>= 1;
+    return n;
+  }, k.setToSJISFunction = function(n) {
+    if (typeof n != "function")
+      throw new Error('"toSJISFunc" is not a valid function.');
+    o = n;
+  }, k.isKanjiModeEnabled = function() {
+    return typeof o < "u";
+  }, k.toSJIS = function(n) {
+    return o(n);
+  }, k;
+}
+var nt = {}, vt;
+function Nt() {
+  return vt || (vt = 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(n) {
+      return n && typeof n.bit < "u" && n.bit >= 0 && n.bit < 4;
+    }, o.from = function(n, t) {
+      if (o.isValid(n))
+        return n;
+      try {
+        return r(n);
+      } catch {
+        return t;
+      }
+    };
+  })(nt)), nt;
+}
+var rt, Lt;
+function ye() {
+  if (Lt) return rt;
+  Lt = 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 n = 0; n < i; n++)
+        this.putBit((r >>> i - n - 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++;
+    }
+  }, rt = o, rt;
+}
+var ot, Dt;
+function Ce() {
+  if (Dt) return ot;
+  Dt = 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, n, t) {
+    const e = r * this.size + i;
+    this.data[e] = n, t && (this.reservedBit[e] = !0);
+  }, o.prototype.get = function(r, i) {
+    return this.data[r * this.size + i];
+  }, o.prototype.xor = function(r, i, n) {
+    this.data[r * this.size + i] ^= n;
+  }, o.prototype.isReserved = function(r, i) {
+    return this.reservedBit[r * this.size + i];
+  }, ot = o, ot;
+}
+var it = {}, _t;
+function Ee() {
+  return _t || (_t = 1, (function(o) {
+    const r = $().getSymbolSize;
+    o.getRowColCoords = function(n) {
+      if (n === 1) return [];
+      const t = Math.floor(n / 7) + 2, e = r(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();
+    }, o.getPositions = function(n) {
+      const t = [], e = o.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;
+    };
+  })(it)), it;
+}
+var st = {}, qt;
+function Be() {
+  if (qt) return st;
+  qt = 1;
+  const o = $().getSymbolSize, r = 7;
+  return st.getPositions = function(n) {
+    const t = o(n);
+    return [
+      // top-left
+      [0, 0],
+      // top-right
+      [t - r, 0],
+      // bottom-left
+      [0, t - r]
+    ];
+  }, st;
+}
+var ut = {}, Ut;
+function Re() {
+  return Ut || (Ut = 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 e = t.size;
+      let s = 0, a = 0, u = 0, c = null, m = null;
+      for (let A = 0; A < e; A++) {
+        a = u = 0, c = m = null;
+        for (let C = 0; C < e; C++) {
+          let h = t.get(A, C);
+          h === c ? a++ : (a >= 5 && (s += r.N1 + (a - 5)), c = h, a = 1), h = t.get(C, A), h === m ? u++ : (u >= 5 && (s += r.N1 + (u - 5)), m = h, u = 1);
+        }
+        a >= 5 && (s += r.N1 + (a - 5)), u >= 5 && (s += r.N1 + (u - 5));
+      }
+      return s;
+    }, o.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 * r.N2;
+    }, o.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 m = 0; m < e; m++)
+          a = a << 1 & 2047 | t.get(c, m), m >= 10 && (a === 1488 || a === 93) && s++, u = u << 1 & 2047 | t.get(m, c), m >= 10 && (u === 1488 || u === 93) && s++;
+      }
+      return s * r.N3;
+    }, o.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) * r.N4;
+    };
+    function i(n, t, e) {
+      switch (n) {
+        case o.Patterns.PATTERN000:
+          return (t + e) % 2 === 0;
+        case o.Patterns.PATTERN001:
+          return t % 2 === 0;
+        case o.Patterns.PATTERN010:
+          return e % 3 === 0;
+        case o.Patterns.PATTERN011:
+          return (t + e) % 3 === 0;
+        case o.Patterns.PATTERN100:
+          return (Math.floor(t / 2) + Math.floor(e / 3)) % 2 === 0;
+        case o.Patterns.PATTERN101:
+          return t * e % 2 + t * e % 3 === 0;
+        case o.Patterns.PATTERN110:
+          return (t * e % 2 + t * e % 3) % 2 === 0;
+        case o.Patterns.PATTERN111:
+          return (t * e % 3 + (t + e) % 2) % 2 === 0;
+        default:
+          throw new Error("bad maskPattern:" + n);
+      }
+    }
+    o.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));
+    }, o.getBestMask = function(t, e) {
+      const s = Object.keys(o.Patterns).length;
+      let a = 0, u = 1 / 0;
+      for (let c = 0; c < s; c++) {
+        e(c), o.applyMask(c, t);
+        const m = o.getPenaltyN1(t) + o.getPenaltyN2(t) + o.getPenaltyN3(t) + o.getPenaltyN4(t);
+        o.applyMask(c, t), m < u && (u = m, a = c);
+      }
+      return a;
+    };
+  })(ut)), ut;
+}
+var Q = {}, Ft;
+function ie() {
+  if (Ft) return Q;
+  Ft = 1;
+  const o = Nt(), 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, e) {
+    switch (e) {
+      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, e) {
+    switch (e) {
+      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 at = {}, J = {}, kt;
+function Ae() {
+  if (kt) return J;
+  kt = 1;
+  const o = new Uint8Array(512), r = new Uint8Array(256);
+  return (function() {
+    let n = 1;
+    for (let t = 0; t < 255; t++)
+      o[t] = n, r[n] = t, n <<= 1, n & 256 && (n ^= 285);
+    for (let t = 255; t < 512; t++)
+      o[t] = o[t - 255];
+  })(), J.log = function(n) {
+    if (n < 1) throw new Error("log(" + n + ")");
+    return r[n];
+  }, J.exp = function(n) {
+    return o[n];
+  }, J.mul = function(n, t) {
+    return n === 0 || t === 0 ? 0 : o[r[n] + r[t]];
+  }, J;
+}
+var zt;
+function Ie() {
+  return zt || (zt = 1, (function(o) {
+    const r = Ae();
+    o.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] ^= r.mul(n[s], t[a]);
+      return e;
+    }, o.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] ^= r.mul(t[u], s);
+        let a = 0;
+        for (; a < e.length && e[a] === 0; ) a++;
+        e = e.slice(a);
+      }
+      return e;
+    }, o.generateECPolynomial = function(n) {
+      let t = new Uint8Array([1]);
+      for (let e = 0; e < n; e++)
+        t = o.mul(t, new Uint8Array([1, r.exp(e)]));
+      return t;
+    };
+  })(at)), at;
+}
+var ct, $t;
+function Ne() {
+  if ($t) return ct;
+  $t = 1;
+  const o = Ie();
+  function r(i) {
+    this.genPoly = void 0, this.degree = i, this.degree && this.initialize(this.degree);
+  }
+  return r.prototype.initialize = function(n) {
+    this.degree = n, this.genPoly = o.generateECPolynomial(this.degree);
+  }, r.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 = o.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;
+  }, ct = r, ct;
+}
+var lt = {}, ft = {}, dt = {}, Vt;
+function se() {
+  return Vt || (Vt = 1, dt.isValid = function(r) {
+    return !isNaN(r) && r >= 1 && r <= 40;
+  }), dt;
+}
+var L = {}, Ot;
+function ue() {
+  if (Ot) return L;
+  Ot = 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 n = "(?:(?![A-Z0-9 $%*+\\-./:]|" + i + `)(?:.|[\r
+]))+`;
+  L.KANJI = new RegExp(i, "g"), L.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), L.BYTE = new RegExp(n, "g"), L.NUMERIC = new RegExp(o, "g"), L.ALPHANUMERIC = new RegExp(r, "g");
+  const t = new RegExp("^" + i + "$"), e = new RegExp("^" + o + "$"), s = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+  return L.testKanji = function(u) {
+    return t.test(u);
+  }, L.testNumeric = function(u) {
+    return e.test(u);
+  }, L.testAlphanumeric = function(u) {
+    return s.test(u);
+  }, L;
+}
+var Kt;
+function V() {
+  return Kt || (Kt = 1, (function(o) {
+    const r = se(), i = ue();
+    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(e, s) {
+      if (!e.ccBits) throw new Error("Invalid mode: " + e);
+      if (!r.isValid(s))
+        throw new Error("Invalid version: " + s);
+      return s >= 1 && s < 10 ? e.ccBits[0] : s < 27 ? e.ccBits[1] : e.ccBits[2];
+    }, o.getBestModeForData = function(e) {
+      return i.testNumeric(e) ? o.NUMERIC : i.testAlphanumeric(e) ? o.ALPHANUMERIC : i.testKanji(e) ? o.KANJI : o.BYTE;
+    }, o.toString = function(e) {
+      if (e && e.id) return e.id;
+      throw new Error("Invalid mode");
+    }, o.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 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(e, s) {
+      if (o.isValid(e))
+        return e;
+      try {
+        return n(e);
+      } catch {
+        return s;
+      }
+    };
+  })(ft)), ft;
+}
+var Ht;
+function be() {
+  return Ht || (Ht = 1, (function(o) {
+    const r = $(), i = ie(), n = Nt(), t = V(), e = se(), s = 7973, a = r.getBCHDigit(s);
+    function u(C, h, S) {
+      for (let w = 1; w <= 40; w++)
+        if (h <= o.getCapacity(w, S, C))
+          return w;
+    }
+    function c(C, h) {
+      return t.getCharCountIndicator(C, h) + 4;
+    }
+    function m(C, h) {
+      let S = 0;
+      return C.forEach(function(w) {
+        const I = c(w.mode, h);
+        S += I + w.getBitsLength();
+      }), S;
+    }
+    function A(C, h) {
+      for (let S = 1; S <= 40; S++)
+        if (m(C, S) <= o.getCapacity(S, h, t.MIXED))
+          return S;
+    }
+    o.from = function(h, S) {
+      return e.isValid(h) ? parseInt(h, 10) : S;
+    }, o.getCapacity = function(h, S, w) {
+      if (!e.isValid(h))
+        throw new Error("Invalid QR Code version");
+      typeof w > "u" && (w = t.BYTE);
+      const I = r.getSymbolTotalCodewords(h), d = i.getTotalCodewordsCount(h, S), f = (I - d) * 8;
+      if (w === t.MIXED) return f;
+      const g = f - c(w, h);
+      switch (w) {
+        case t.NUMERIC:
+          return Math.floor(g / 10 * 3);
+        case t.ALPHANUMERIC:
+          return Math.floor(g / 11 * 2);
+        case t.KANJI:
+          return Math.floor(g / 13);
+        case t.BYTE:
+        default:
+          return Math.floor(g / 8);
+      }
+    }, o.getBestVersionForData = function(h, S) {
+      let w;
+      const I = n.from(S, n.M);
+      if (Array.isArray(h)) {
+        if (h.length > 1)
+          return A(h, I);
+        if (h.length === 0)
+          return 1;
+        w = h[0];
+      } else
+        w = h;
+      return u(w.mode, w.getLength(), I);
+    }, o.getEncodedBits = function(h) {
+      if (!e.isValid(h) || h < 7)
+        throw new Error("Invalid QR Code version");
+      let S = h << 12;
+      for (; r.getBCHDigit(S) - a >= 0; )
+        S ^= s << r.getBCHDigit(S) - a;
+      return h << 12 | S;
+    };
+  })(lt)), lt;
+}
+var ht = {}, Jt;
+function Se() {
+  if (Jt) return ht;
+  Jt = 1;
+  const o = $(), r = 1335, i = 21522, n = o.getBCHDigit(r);
+  return ht.getEncodedBits = function(e, s) {
+    const a = e.bit << 3 | s;
+    let u = a << 10;
+    for (; o.getBCHDigit(u) - n >= 0; )
+      u ^= r << o.getBCHDigit(u) - n;
+    return (a << 10 | u) ^ i;
+  }, ht;
+}
+var gt = {}, mt, Yt;
+function Me() {
+  if (Yt) return mt;
+  Yt = 1;
+  const o = V();
+  function r(i) {
+    this.mode = o.NUMERIC, this.data = i.toString();
+  }
+  return r.getBitsLength = function(n) {
+    return 10 * Math.floor(n / 3) + (n % 3 ? n % 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(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));
+  }, mt = r, mt;
+}
+var wt, jt;
+function Te() {
+  if (jt) return wt;
+  jt = 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(n) {
+    this.mode = o.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 = r.indexOf(this.data[e]) * 45;
+      s += r.indexOf(this.data[e + 1]), t.put(s, 11);
+    }
+    this.data.length % 2 && t.put(r.indexOf(this.data[e]), 6);
+  }, wt = i, wt;
+}
+var pt, Qt;
+function Pe() {
+  return Qt || (Qt = 1, pt = function(r) {
+    for (var i = [], n = r.length, t = 0; t < n; t++) {
+      var e = r.charCodeAt(t);
+      if (e >= 55296 && e <= 56319 && n > t + 1) {
+        var s = r.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;
+  }), pt;
+}
+var yt, xt;
+function ve() {
+  if (xt) return yt;
+  xt = 1;
+  const o = Pe(), r = V();
+  function i(n) {
+    this.mode = r.BYTE, typeof n == "string" && (n = o(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);
+  }, yt = i, yt;
+}
+var Ct, Gt;
+function Le() {
+  if (Gt) return Ct;
+  Gt = 1;
+  const o = V(), r = $();
+  function i(n) {
+    this.mode = o.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 = r.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);
+    }
+  }, Ct = i, Ct;
+}
+var Et = { exports: {} }, Wt;
+function De() {
+  return Wt || (Wt = 1, (function(o) {
+    var r = {
+      single_source_shortest_paths: function(i, n, t) {
+        var e = {}, s = {};
+        s[n] = 0;
+        var a = r.PriorityQueue.make();
+        a.push(n, 0);
+        for (var u, c, m, A, C, h, S, w, I; !a.empty(); ) {
+          u = a.pop(), c = u.value, A = u.cost, C = i[c] || {};
+          for (m in C)
+            C.hasOwnProperty(m) && (h = C[m], S = A + h, w = s[m], I = typeof s[m] > "u", (I || w > S) && (s[m] = S, a.push(m, S), e[m] = c));
+        }
+        if (typeof t < "u" && typeof s[t] > "u") {
+          var d = ["Could not find a path from ", n, " to ", t, "."].join("");
+          throw new Error(d);
+        }
+        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 = r.single_source_shortest_paths(i, n, t);
+        return r.extract_shortest_path_from_predecessor_list(
+          e,
+          t
+        );
+      },
+      /**
+       * A very naive priority queue implementation.
+       */
+      PriorityQueue: {
+        make: function(i) {
+          var n = r.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;
+        }
+      }
+    };
+    o.exports = r;
+  })(Et)), Et.exports;
+}
+var Xt;
+function _e() {
+  return Xt || (Xt = 1, (function(o) {
+    const r = V(), i = Me(), n = Te(), t = ve(), e = Le(), s = ue(), a = $(), u = De();
+    function c(d) {
+      return unescape(encodeURIComponent(d)).length;
+    }
+    function m(d, f, g) {
+      const l = [];
+      let P;
+      for (; (P = d.exec(g)) !== null; )
+        l.push({
+          data: P[0],
+          index: P.index,
+          mode: f,
+          length: P[0].length
+        });
+      return l;
+    }
+    function A(d) {
+      const f = m(s.NUMERIC, r.NUMERIC, d), g = m(s.ALPHANUMERIC, r.ALPHANUMERIC, d);
+      let l, P;
+      return a.isKanjiModeEnabled() ? (l = m(s.BYTE, r.BYTE, d), P = m(s.KANJI, r.KANJI, d)) : (l = m(s.BYTE_KANJI, r.BYTE, d), P = []), f.concat(g, l, P).sort(function(N, R) {
+        return N.index - R.index;
+      }).map(function(N) {
+        return {
+          data: N.data,
+          mode: N.mode,
+          length: N.length
+        };
+      });
+    }
+    function C(d, f) {
+      switch (f) {
+        case r.NUMERIC:
+          return i.getBitsLength(d);
+        case r.ALPHANUMERIC:
+          return n.getBitsLength(d);
+        case r.KANJI:
+          return e.getBitsLength(d);
+        case r.BYTE:
+          return t.getBitsLength(d);
+      }
+    }
+    function h(d) {
+      return d.reduce(function(f, g) {
+        const l = f.length - 1 >= 0 ? f[f.length - 1] : null;
+        return l && l.mode === g.mode ? (f[f.length - 1].data += g.data, f) : (f.push(g), f);
+      }, []);
+    }
+    function S(d) {
+      const f = [];
+      for (let g = 0; g < d.length; g++) {
+        const l = d[g];
+        switch (l.mode) {
+          case r.NUMERIC:
+            f.push([
+              l,
+              { data: l.data, mode: r.ALPHANUMERIC, length: l.length },
+              { data: l.data, mode: r.BYTE, length: l.length }
+            ]);
+            break;
+          case r.ALPHANUMERIC:
+            f.push([
+              l,
+              { data: l.data, mode: r.BYTE, length: l.length }
+            ]);
+            break;
+          case r.KANJI:
+            f.push([
+              l,
+              { data: l.data, mode: r.BYTE, length: c(l.data) }
+            ]);
+            break;
+          case r.BYTE:
+            f.push([
+              { data: l.data, mode: r.BYTE, length: c(l.data) }
+            ]);
+        }
+      }
+      return f;
+    }
+    function w(d, f) {
+      const g = {}, l = { start: {} };
+      let P = ["start"];
+      for (let y = 0; y < d.length; y++) {
+        const N = d[y], R = [];
+        for (let p = 0; p < N.length; p++) {
+          const M = N[p], E = "" + y + p;
+          R.push(E), g[E] = { node: M, lastCount: 0 }, l[E] = {};
+          for (let b = 0; b < P.length; b++) {
+            const B = P[b];
+            g[B] && g[B].node.mode === M.mode ? (l[B][E] = C(g[B].lastCount + M.length, M.mode) - C(g[B].lastCount, M.mode), g[B].lastCount += M.length) : (g[B] && (g[B].lastCount = M.length), l[B][E] = C(M.length, M.mode) + 4 + r.getCharCountIndicator(M.mode, f));
+          }
+        }
+        P = R;
+      }
+      for (let y = 0; y < P.length; y++)
+        l[P[y]].end = 0;
+      return { map: l, table: g };
+    }
+    function I(d, f) {
+      let g;
+      const l = r.getBestModeForData(d);
+      if (g = r.from(f, l), g !== r.BYTE && g.bit < l.bit)
+        throw new Error('"' + d + '" cannot be encoded with mode ' + r.toString(g) + `.
+ Suggested mode is: ` + r.toString(l));
+      switch (g === r.KANJI && !a.isKanjiModeEnabled() && (g = r.BYTE), g) {
+        case r.NUMERIC:
+          return new i(d);
+        case r.ALPHANUMERIC:
+          return new n(d);
+        case r.KANJI:
+          return new e(d);
+        case r.BYTE:
+          return new t(d);
+      }
+    }
+    o.fromArray = function(f) {
+      return f.reduce(function(g, l) {
+        return typeof l == "string" ? g.push(I(l, null)) : l.data && g.push(I(l.data, l.mode)), g;
+      }, []);
+    }, o.fromString = function(f, g) {
+      const l = A(f, a.isKanjiModeEnabled()), P = S(l), y = w(P, g), N = u.find_path(y.map, "start", "end"), R = [];
+      for (let p = 1; p < N.length - 1; p++)
+        R.push(y.table[N[p]].node);
+      return o.fromArray(h(R));
+    }, o.rawSplit = function(f) {
+      return o.fromArray(
+        A(f, a.isKanjiModeEnabled())
+      );
+    };
+  })(gt)), gt;
+}
+var Zt;
+function qe() {
+  if (Zt) return et;
+  Zt = 1;
+  const o = $(), r = Nt(), i = ye(), n = Ce(), t = Ee(), e = Be(), s = Re(), a = ie(), u = Ne(), c = be(), m = Se(), A = V(), C = _e();
+  function h(y, N) {
+    const R = y.size, p = e.getPositions(N);
+    for (let M = 0; M < p.length; M++) {
+      const E = p[M][0], b = p[M][1];
+      for (let B = -1; B <= 7; B++)
+        if (!(E + B <= -1 || R <= E + B))
+          for (let T = -1; T <= 7; T++)
+            b + T <= -1 || R <= b + T || (B >= 0 && B <= 6 && (T === 0 || T === 6) || T >= 0 && T <= 6 && (B === 0 || B === 6) || B >= 2 && B <= 4 && T >= 2 && T <= 4 ? y.set(E + B, b + T, !0, !0) : y.set(E + B, b + T, !1, !0));
+    }
+  }
+  function S(y) {
+    const N = y.size;
+    for (let R = 8; R < N - 8; R++) {
+      const p = R % 2 === 0;
+      y.set(R, 6, p, !0), y.set(6, R, p, !0);
+    }
+  }
+  function w(y, N) {
+    const R = t.getPositions(N);
+    for (let p = 0; p < R.length; p++) {
+      const M = R[p][0], E = R[p][1];
+      for (let b = -2; b <= 2; b++)
+        for (let B = -2; B <= 2; B++)
+          b === -2 || b === 2 || B === -2 || B === 2 || b === 0 && B === 0 ? y.set(M + b, E + B, !0, !0) : y.set(M + b, E + B, !1, !0);
+    }
+  }
+  function I(y, N) {
+    const R = y.size, p = c.getEncodedBits(N);
+    let M, E, b;
+    for (let B = 0; B < 18; B++)
+      M = Math.floor(B / 3), E = B % 3 + R - 8 - 3, b = (p >> B & 1) === 1, y.set(M, E, b, !0), y.set(E, M, b, !0);
+  }
+  function d(y, N, R) {
+    const p = y.size, M = m.getEncodedBits(N, R);
+    let E, b;
+    for (E = 0; E < 15; E++)
+      b = (M >> E & 1) === 1, E < 6 ? y.set(E, 8, b, !0) : E < 8 ? y.set(E + 1, 8, b, !0) : y.set(p - 15 + E, 8, b, !0), E < 8 ? y.set(8, p - E - 1, b, !0) : E < 9 ? y.set(8, 15 - E - 1 + 1, b, !0) : y.set(8, 15 - E - 1, b, !0);
+    y.set(p - 8, 8, 1, !0);
+  }
+  function f(y, N) {
+    const R = y.size;
+    let p = -1, M = R - 1, E = 7, b = 0;
+    for (let B = R - 1; B > 0; B -= 2)
+      for (B === 6 && B--; ; ) {
+        for (let T = 0; T < 2; T++)
+          if (!y.isReserved(M, B - T)) {
+            let F = !1;
+            b < N.length && (F = (N[b] >>> E & 1) === 1), y.set(M, B - T, F), E--, E === -1 && (b++, E = 7);
+          }
+        if (M += p, M < 0 || R <= M) {
+          M -= p, p = -p;
+          break;
+        }
+      }
+  }
+  function g(y, N, R) {
+    const p = new i();
+    R.forEach(function(T) {
+      p.put(T.mode.bit, 4), p.put(T.getLength(), A.getCharCountIndicator(T.mode, y)), T.write(p);
+    });
+    const M = o.getSymbolTotalCodewords(y), E = a.getTotalCodewordsCount(y, N), b = (M - E) * 8;
+    for (p.getLengthInBits() + 4 <= b && p.put(0, 4); p.getLengthInBits() % 8 !== 0; )
+      p.putBit(0);
+    const B = (b - p.getLengthInBits()) / 8;
+    for (let T = 0; T < B; T++)
+      p.put(T % 2 ? 17 : 236, 8);
+    return l(p, y, N);
+  }
+  function l(y, N, R) {
+    const p = o.getSymbolTotalCodewords(N), M = a.getTotalCodewordsCount(N, R), E = p - M, b = a.getBlocksCount(N, R), B = p % b, T = b - B, F = Math.floor(p / b), H = Math.floor(E / b), ce = H + 1, bt = F - H, le = new u(bt);
+    let G = 0;
+    const Y = new Array(b), St = new Array(b);
+    let W = 0;
+    const fe = new Uint8Array(y.buffer);
+    for (let O = 0; O < b; O++) {
+      const Z = O < T ? H : ce;
+      Y[O] = fe.slice(G, G + Z), St[O] = le.encode(Y[O]), G += Z, W = Math.max(W, Z);
+    }
+    const X = new Uint8Array(p);
+    let Mt = 0, D, _;
+    for (D = 0; D < W; D++)
+      for (_ = 0; _ < b; _++)
+        D < Y[_].length && (X[Mt++] = Y[_][D]);
+    for (D = 0; D < bt; D++)
+      for (_ = 0; _ < b; _++)
+        X[Mt++] = St[_][D];
+    return X;
+  }
+  function P(y, N, R, p) {
+    let M;
+    if (Array.isArray(y))
+      M = C.fromArray(y);
+    else if (typeof y == "string") {
+      let F = N;
+      if (!F) {
+        const H = C.rawSplit(y);
+        F = c.getBestVersionForData(H, R);
+      }
+      M = C.fromString(y, F || 40);
+    } else
+      throw new Error("Invalid data");
+    const E = c.getBestVersionForData(M, R);
+    if (!E)
+      throw new Error("The amount of data is too big to be stored in a QR Code");
+    if (!N)
+      N = E;
+    else if (N < E)
+      throw new Error(
+        `
+The chosen QR Code version cannot contain this amount of data.
+Minimum version required to store current data is: ` + E + `.
+`
+      );
+    const b = g(N, R, M), B = o.getSymbolSize(N), T = new n(B);
+    return h(T, N), S(T), w(T, N), d(T, R, 0), N >= 7 && I(T, N), f(T, b), isNaN(p) && (p = s.getBestMask(
+      T,
+      d.bind(null, T, R)
+    )), s.applyMask(p, T), d(T, R, p), {
+      modules: T,
+      version: N,
+      errorCorrectionLevel: R,
+      maskPattern: p,
+      segments: M
+    };
+  }
+  return et.create = function(N, R) {
+    if (typeof N > "u" || N === "")
+      throw new Error("No input text");
+    let p = r.M, M, E;
+    return typeof R < "u" && (p = r.from(R.errorCorrectionLevel, r.M), M = c.from(R.version), E = s.from(R.maskPattern), R.toSJISFunc && o.setToSJISFunction(R.toSJISFunc)), P(N, M, p, E);
+  }, et;
+}
+var Bt = {}, Rt = {}, te;
+function ae() {
+  return te || (te = 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 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("")
+      };
+    }
+    o.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: r(n.color.dark || "#000000ff"),
+          light: r(n.color.light || "#ffffffff")
+        },
+        type: n.type,
+        rendererOpts: n.rendererOpts || {}
+      };
+    }, o.getScale = function(n, t) {
+      return t.width && t.width >= n + t.margin * 2 ? t.width / (n + t.margin * 2) : t.scale;
+    }, o.getImageWidth = function(n, t) {
+      const e = o.getScale(n, t);
+      return Math.floor((n + t.margin * 2) * e);
+    }, o.qrToImageData = function(n, t, e) {
+      const s = t.modules.size, a = t.modules.data, u = o.getScale(s, e), c = Math.floor((s + e.margin * 2) * u), m = e.margin * u, A = [e.color.light, e.color.dark];
+      for (let C = 0; C < c; C++)
+        for (let h = 0; h < c; h++) {
+          let S = (C * c + h) * 4, w = e.color.light;
+          if (C >= m && h >= m && C < c - m && h < c - m) {
+            const I = Math.floor((C - m) / u), d = Math.floor((h - m) / u);
+            w = A[a[I * s + d] ? 1 : 0];
+          }
+          n[S++] = w.r, n[S++] = w.g, n[S++] = w.b, n[S] = w.a;
+        }
+    };
+  })(Rt)), Rt;
+}
+var ee;
+function Ue() {
+  return ee || (ee = 1, (function(o) {
+    const r = ae();
+    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");
+      }
+    }
+    o.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 = r.getOptions(u);
+      const m = r.getImageWidth(e.modules.size, u), A = c.getContext("2d"), C = A.createImageData(m, m);
+      return r.qrToImageData(C.data, e, u), i(A, c, m), A.putImageData(C, 0, 0), c;
+    }, o.renderToDataURL = function(e, s, a) {
+      let u = a;
+      typeof u > "u" && (!s || !s.getContext) && (u = s, s = void 0), u || (u = {});
+      const c = o.render(e, s, u), m = u.type || "image/png", A = u.rendererOpts || {};
+      return c.toDataURL(m, A.quality);
+    };
+  })(Bt)), Bt;
+}
+var At = {}, ne;
+function Fe() {
+  if (ne) return At;
+  ne = 1;
+  const o = ae();
+  function r(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, m = 0;
+    for (let A = 0; A < t.length; A++) {
+      const C = Math.floor(A % e), h = Math.floor(A / e);
+      !C && !c && (c = !0), t[A] ? (m++, A > 0 && C > 0 && t[A - 1] || (a += c ? i("M", C + s, 0.5 + h + s) : i("m", u, 0), u = 0, c = !1), C + 1 < e && t[A + 1] || (a += i("h", m), m = 0)) : u++;
+    }
+    return a;
+  }
+  return At.render = function(e, s, a) {
+    const u = o.getOptions(s), c = e.modules.size, m = e.modules.data, A = c + u.margin * 2, C = u.color.light.a ? "<path " + r(u.color.light, "fill") + ' d="M0 0h' + A + "v" + A + 'H0z"/>' : "", h = "<path " + r(u.color.dark, "stroke") + ' d="' + n(m, c, u.margin) + '"/>', S = 'viewBox="0 0 ' + A + " " + A + '"', I = '<svg xmlns="http://www.w3.org/2000/svg" ' + (u.width ? 'width="' + u.width + '" height="' + u.width + '" ' : "") + S + ' shape-rendering="crispEdges">' + C + h + `</svg>
+`;
+    return typeof a == "function" && a(null, I), I;
+  }, At;
+}
+var re;
+function ke() {
+  if (re) return K;
+  re = 1;
+  const o = pe(), r = qe(), i = Ue(), n = Fe();
+  function t(e, s, a, u, c) {
+    const m = [].slice.call(arguments, 1), A = m.length, C = typeof m[A - 1] == "function";
+    if (!C && !o())
+      throw new Error("Callback required as last argument");
+    if (C) {
+      if (A < 2)
+        throw new Error("Too few arguments provided");
+      A === 2 ? (c = a, a = s, s = u = void 0) : A === 3 && (s.getContext && typeof c > "u" ? (c = u, u = void 0) : (c = u, u = a, a = s, s = void 0));
+    } else {
+      if (A < 1)
+        throw new Error("Too few arguments provided");
+      return A === 1 ? (a = s, s = u = void 0) : A === 2 && !s.getContext && (u = a, a = s, s = void 0), new Promise(function(h, S) {
+        try {
+          const w = r.create(a, u);
+          h(e(w, s, u));
+        } catch (w) {
+          S(w);
+        }
+      });
+    }
+    try {
+      const h = r.create(a, u);
+      c(null, e(h, s, u));
+    } catch (h) {
+      c(h);
+    }
+  }
+  return K.create = r.create, K.toCanvas = t.bind(null, i.render), K.toDataURL = t.bind(null, i.renderToDataURL), K.toString = t.bind(null, function(e, s, a) {
+    return n.render(e, a);
+  }), K;
+}
+var ze = ke();
+const $e = /* @__PURE__ */ de(ze), Ve = 0.1, oe = 2.5, q = 7;
+function It(o, r, i) {
+  return o === r ? !1 : (o - r < 0 ? r - o : o - r) <= i + Ve;
+}
+function Oe(o, r) {
+  const i = Array.prototype.slice.call($e.create(o, { errorCorrectionLevel: r }).modules.data, 0), n = Math.sqrt(i.length);
+  return i.reduce((t, e, s) => (s % n === 0 ? t.push([e]) : t[t.length - 1].push(e)) && t, []);
+}
+const Ke = {
+  generate({ uri: o, size: r, logoSize: i, dotColor: n = "#141414" }) {
+    const t = "transparent", s = [], a = Oe(o, "Q"), u = r / a.length, c = [
+      { x: 0, y: 0 },
+      { x: 1, y: 0 },
+      { x: 0, y: 1 }
+    ];
+    c.forEach(({ x: w, y: I }) => {
+      const d = (a.length - q) * u * w, f = (a.length - q) * u * I, g = 0.45;
+      for (let l = 0; l < c.length; l += 1) {
+        const P = u * (q - l * 2);
+        s.push(x`
+            <rect
+              fill=${l === 2 ? n : t}
+              width=${l === 0 ? P - 5 : P}
+              rx= ${l === 0 ? (P - 5) * g : P * g}
+              ry= ${l === 0 ? (P - 5) * g : P * g}
+              stroke=${n}
+              stroke-width=${l === 0 ? 5 : 0}
+              height=${l === 0 ? P - 5 : P}
+              x= ${l === 0 ? f + u * l + 5 / 2 : f + u * l}
+              y= ${l === 0 ? d + u * l + 5 / 2 : d + u * l}
+            />
+          `);
+      }
+    });
+    const m = Math.floor((i + 25) / u), A = a.length / 2 - m / 2, C = a.length / 2 + m / 2 - 1, h = [];
+    a.forEach((w, I) => {
+      w.forEach((d, f) => {
+        if (a[I][f] && !(I < q && f < q || I > a.length - (q + 1) && f < q || I < q && f > a.length - (q + 1)) && !(I > A && I < C && f > A && f < C)) {
+          const g = I * u + u / 2, l = f * u + u / 2;
+          h.push([g, l]);
+        }
+      });
+    });
+    const S = {};
+    return h.forEach(([w, I]) => {
+      var d;
+      S[w] ? (d = S[w]) == null || d.push(I) : S[w] = [I];
+    }), Object.entries(S).map(([w, I]) => {
+      const d = I.filter((f) => I.every((g) => !It(f, g, u)));
+      return [Number(w), d];
+    }).forEach(([w, I]) => {
+      I.forEach((d) => {
+        s.push(x`<circle cx=${w} cy=${d} fill=${n} r=${u / oe} />`);
+      });
+    }), Object.entries(S).filter(([w, I]) => I.length > 1).map(([w, I]) => {
+      const d = I.filter((f) => I.some((g) => It(f, g, u)));
+      return [Number(w), d];
+    }).map(([w, I]) => {
+      I.sort((f, g) => f < g ? -1 : 1);
+      const d = [];
+      for (const f of I) {
+        const g = d.find((l) => l.some((P) => It(f, P, u)));
+        g ? g.push(f) : d.push([f]);
+      }
+      return [w, d.map((f) => [f[0], f[f.length - 1]])];
+    }).forEach(([w, I]) => {
+      I.forEach(([d, f]) => {
+        s.push(x`
+              <line
+                x1=${w}
+                x2=${w}
+                y1=${d}
+                y2=${f}
+                stroke=${n}
+                stroke-width=${u / (oe / 2)}
+                stroke-linecap="round"
+              />
+            `);
+      });
+    }), s;
+  }
+}, He = he`
+  :host {
+    position: relative;
+    user-select: none;
+    display: block;
+    overflow: hidden;
+    aspect-ratio: 1 / 1;
+    width: var(--local-size);
+  }
+
+  :host([data-theme='dark']) {
+    border-radius: clamp(0px, var(--wui-border-radius-l), 40px);
+    background-color: var(--wui-color-inverse-100);
+    padding: var(--wui-spacing-l);
+  }
+
+  :host([data-theme='light']) {
+    box-shadow: 0 0 0 1px var(--wui-color-bg-125);
+    background-color: var(--wui-color-bg-125);
+  }
+
+  :host([data-clear='true']) > wui-icon {
+    display: none;
+  }
+
+  svg:first-child,
+  wui-image,
+  wui-icon {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translateY(-50%) translateX(-50%);
+  }
+
+  wui-image {
+    width: 25%;
+    height: 25%;
+    border-radius: var(--wui-border-radius-xs);
+  }
+
+  wui-icon {
+    width: 100%;
+    height: 100%;
+    color: var(--local-icon-color) !important;
+    transform: translateY(-50%) translateX(-50%) scale(0.25);
+  }
+`;
+var U = function(o, r, i, n) {
+  var t = arguments.length, e = t < 3 ? r : n === null ? n = Object.getOwnPropertyDescriptor(r, i) : n, s;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") e = Reflect.decorate(o, r, i, n);
+  else for (var a = o.length - 1; a >= 0; a--) (s = o[a]) && (e = (t < 3 ? s(e) : t > 3 ? s(r, i, e) : s(r, i)) || e);
+  return t > 3 && e && Object.defineProperty(r, i, e), e;
+};
+const Je = "#3396ff";
+let v = class extends me {
+  constructor() {
+    super(...arguments), this.uri = "", this.size = 0, this.theme = "dark", this.imageSrc = void 0, this.alt = void 0, this.arenaClear = void 0, this.farcaster = void 0;
+  }
+  render() {
+    return this.dataset.theme = this.theme, this.dataset.clear = String(this.arenaClear), this.style.cssText = `
+     --local-size: ${this.size}px;
+     --local-icon-color: ${this.color ?? Je}
+    `, j`${this.templateVisual()} ${this.templateSvg()}`;
+  }
+  templateSvg() {
+    const r = this.theme === "light" ? this.size : this.size - 32;
+    return x`
+      <svg height=${r} width=${r}>
+        ${Ke.generate({
+      uri: this.uri,
+      size: r,
+      logoSize: this.arenaClear ? 0 : r / 4,
+      dotColor: this.color
+    })}
+      </svg>
+    `;
+  }
+  templateVisual() {
+    return this.imageSrc ? j`<wui-image src=${this.imageSrc} alt=${this.alt ?? "logo"}></wui-image>` : this.farcaster ? j`<wui-icon
+        class="farcaster"
+        size="inherit"
+        color="inherit"
+        name="farcaster"
+      ></wui-icon>` : j`<wui-icon size="inherit" color="inherit" name="walletConnect"></wui-icon>`;
+  }
+};
+v.styles = [ge, He];
+U([
+  z()
+], v.prototype, "uri", void 0);
+U([
+  z({ type: Number })
+], v.prototype, "size", void 0);
+U([
+  z()
+], v.prototype, "theme", void 0);
+U([
+  z()
+], v.prototype, "imageSrc", void 0);
+U([
+  z()
+], v.prototype, "alt", void 0);
+U([
+  z()
+], v.prototype, "color", void 0);
+U([
+  z({ type: Boolean })
+], v.prototype, "arenaClear", void 0);
+U([
+  z({ type: Boolean })
+], v.prototype, "farcaster", void 0);
+v = U([
+  we("wui-qr-code")
+], v);