@levischuck/tiny-qr 0.0.1

package/dist/index.js

@@ -0,0 +1,1466 @@
+var a = /* @__PURE__ */ ((t) => (t[t.Light = 0] = "Light", t[t.Dark = 1] = "Dark", t))(a || {}), T = /* @__PURE__ */ ((t) => (t[t.L = 0] = "L", t[t.M = 1] = "M", t[t.Q = 2] = "Q", t[t.H = 3] = "H", t))(T || {}), f = /* @__PURE__ */ ((t) => (t[t.Numeric = 0] = "Numeric", t[t.Alphanumeric = 1] = "Alphanumeric", t[t.Byte = 2] = "Byte", t))(f || {});
+function x(t, e) {
+  if (e >= 1 && e <= 9)
+    switch (t) {
+      case f.Numeric:
+        return 10;
+      case f.Alphanumeric:
+        return 9;
+      case f.Byte:
+        return 8;
+    }
+  else if (e >= 10 && e <= 26)
+    switch (t) {
+      case f.Numeric:
+        return 12;
+      case f.Alphanumeric:
+        return 11;
+      case f.Byte:
+        return 16;
+    }
+  else
+    switch (t) {
+      case f.Numeric:
+        return 14;
+      case f.Alphanumeric:
+        return 13;
+      case f.Byte:
+        return 16;
+    }
+}
+function G(t, e) {
+  switch (t) {
+    case f.Numeric:
+      return Math.floor((e * 10 + 2) / 3);
+    case f.Alphanumeric:
+      return Math.floor((e * 11 + 1) / 2);
+    case f.Byte:
+      return e * 8;
+  }
+}
+function V(t, e) {
+  const r = R(t, e);
+  return r === null ? f.Byte : r > 0 ? t : e;
+}
+function R(t, e) {
+  return t === e ? 0 : t === f.Numeric && e === f.Alphanumeric ? -1 : t === f.Alphanumeric && e === f.Numeric ? 1 : e === f.Byte ? -1 : t === f.Byte ? 1 : null;
+}
+function O(t) {
+  return t * 4 + 17;
+}
+function z(t) {
+  return 4;
+}
+function S(t, e, r) {
+  if (t < 1 || t > 40)
+    throw new Error("Invalid version");
+  return r[t - 1][e];
+}
+function b(t, e) {
+  const n = t.end - t.begin, i = z(), o = x(t.mode, e), s = G(t.mode, n);
+  return i + o + s;
+}
+function Y(t) {
+  return t === 32 || t === 36 || t === 37 || t === 42 || t === 43 || t >= 45 && t <= 47 || t === 58 ? 1 : t >= 48 && t <= 57 ? 2 : t >= 65 && t <= 90 ? 3 : 4;
+}
+const F = [
+  // Init state:
+  [
+    0,
+    0
+    /* Idle */
+  ],
+  // End
+  [
+    10,
+    0
+    /* Idle */
+  ],
+  // Symbol
+  [
+    5,
+    0
+    /* Idle */
+  ],
+  // Numeric
+  [
+    10,
+    0
+    /* Idle */
+  ],
+  // Alpha
+  [
+    15,
+    0
+    /* Idle */
+  ],
+  // Byte
+  // Numeric state:
+  [
+    0,
+    1
+    /* Numeric */
+  ],
+  // End
+  [
+    10,
+    1
+    /* Numeric */
+  ],
+  // Symbol
+  [
+    5,
+    0
+    /* Idle */
+  ],
+  // Numeric
+  [
+    10,
+    1
+    /* Numeric */
+  ],
+  // Alpha
+  [
+    15,
+    1
+    /* Numeric */
+  ],
+  // Byte
+  // Alpha state:
+  [
+    0,
+    2
+    /* Alpha */
+  ],
+  // End
+  [
+    10,
+    0
+    /* Idle */
+  ],
+  // Symbol
+  [
+    5,
+    2
+    /* Alpha */
+  ],
+  // Numeric
+  [
+    10,
+    0
+    /* Idle */
+  ],
+  // Alpha
+  [
+    15,
+    2
+    /* Alpha */
+  ],
+  // Byte
+  // Byte state:
+  [
+    0,
+    3
+    /* Byte */
+  ],
+  // End
+  [
+    10,
+    3
+    /* Byte */
+  ],
+  // Symbol
+  [
+    5,
+    3
+    /* Byte */
+  ],
+  // Numeric
+  [
+    10,
+    3
+    /* Byte */
+  ],
+  // Alpha
+  [
+    15,
+    0
+    /* Idle */
+  ]
+  // Byte
+];
+function j(t) {
+  return {
+    data: t,
+    index: 0,
+    ended: !1,
+    state: 0,
+    begin: 0
+  };
+}
+function E(t) {
+  let e = t;
+  for (; ; ) {
+    if (e.ended) return [null, e];
+    const r = e.index;
+    let n, i = e.ended, o = e.index;
+    r >= e.data.length ? (n = 0, i = !0) : (n = Y(e.data[r]), o++);
+    const [s, u] = F[e.state + n], l = e.begin;
+    let c;
+    switch (u) {
+      case 0:
+        e = {
+          ...e,
+          index: o,
+          ended: i,
+          state: s
+        };
+        continue;
+      case 1:
+        c = f.Numeric;
+        break;
+      case 2:
+        c = f.Alphanumeric;
+        break;
+      case 3:
+        c = f.Byte;
+        break;
+    }
+    const w = {
+      ...e,
+      index: o,
+      ended: i,
+      state: s,
+      begin: r
+    };
+    return [{ mode: c, begin: l, end: r }, w];
+  }
+}
+function H(t, e) {
+  const [r, n] = E(t);
+  return r === null ? {
+    parser: n,
+    lastSegment: null,
+    lastSegmentSize: 0,
+    version: e,
+    ended: !0
+  } : {
+    parser: n,
+    lastSegment: r,
+    lastSegmentSize: b(r, e),
+    version: e,
+    ended: !1
+  };
+}
+function X(t) {
+  if (t.ended) return [null, t];
+  let e = t;
+  for (; ; ) {
+    const [r, n] = E(e.parser);
+    if (r === null)
+      return [
+        e.lastSegment,
+        {
+          ...e,
+          parser: n,
+          ended: !0
+        }
+      ];
+    const i = b(r, e.version), o = {
+      mode: V(e.lastSegment.mode, r.mode),
+      begin: e.lastSegment.begin,
+      end: r.end
+    }, s = b(o, e.version);
+    if (e.lastSegmentSize + i >= s)
+      e = {
+        ...e,
+        parser: n,
+        lastSegment: o,
+        lastSegmentSize: s
+      };
+    else
+      return [
+        e.lastSegment,
+        {
+          ...e,
+          parser: n,
+          lastSegment: r,
+          lastSegmentSize: i
+        }
+      ];
+  }
+}
+function K(t) {
+  const e = [];
+  let r = t;
+  for (; ; ) {
+    const [n, i] = X(r);
+    if (n === null) break;
+    e.push(n), r = i;
+  }
+  return e;
+}
+function Q(t, e) {
+  return t.reduce((r, n) => r + b(n, e), 0);
+}
+function p(t) {
+  return t & 255;
+}
+const k = [
+  // Normal versions 1-40
+  [152, 128, 104, 72],
+  [272, 224, 176, 128],
+  [440, 352, 272, 208],
+  [640, 512, 384, 288],
+  [864, 688, 496, 368],
+  [1088, 864, 608, 480],
+  [1248, 992, 704, 528],
+  [1552, 1232, 880, 688],
+  [1856, 1456, 1056, 800],
+  [2192, 1728, 1232, 976],
+  [2592, 2032, 1440, 1120],
+  [2960, 2320, 1648, 1264],
+  [3424, 2672, 1952, 1440],
+  [3688, 2920, 2088, 1576],
+  [4184, 3320, 2360, 1784],
+  [4712, 3624, 2600, 2024],
+  [5176, 4056, 2936, 2264],
+  [5768, 4504, 3176, 2504],
+  [6360, 5016, 3560, 2728],
+  [6888, 5352, 3880, 3080],
+  [7456, 5712, 4096, 3248],
+  [8048, 6256, 4544, 3536],
+  [8752, 6880, 4912, 3712],
+  [9392, 7312, 5312, 4112],
+  [10208, 8e3, 5744, 4304],
+  [10960, 8496, 6032, 4768],
+  [11744, 9024, 6464, 5024],
+  [12248, 9544, 6968, 5288],
+  [13048, 10136, 7288, 5608],
+  [13880, 10984, 7880, 5960],
+  [14744, 11640, 8264, 6344],
+  [15640, 12328, 8920, 6760],
+  [16568, 13048, 9368, 7208],
+  [17528, 13800, 9848, 7688],
+  [18448, 14496, 10288, 7888],
+  [19472, 15312, 10832, 8432],
+  [20528, 15936, 11408, 8768],
+  [21616, 16816, 12016, 9136],
+  [22496, 17728, 12656, 9776],
+  [23648, 18672, 13328, 10208]
+];
+function W(t) {
+  return {
+    data: [],
+    bitOffset: 0,
+    version: t
+  };
+}
+function J(t) {
+  return t.version;
+}
+function B(t, e, r) {
+  const n = t.bitOffset + e, i = t.data.length - 1, o = [...t.data];
+  return t.bitOffset === 0 ? n <= 8 ? o.push(p(r << 8 - n)) : (o.push(p(r >> n - 8)), o.push(p(r << 16 - n))) : n <= 8 ? o[i] |= p(r << 8 - n) : n <= 16 ? (o[i] |= p(r >> n - 8), o.push(p(r << 16 - n))) : (o[i] |= p(r >> n - 8), o.push(p(r >> n - 16)), o.push(p(r << 24 - n))), {
+    ...t,
+    data: o,
+    bitOffset: n & 7
+  };
+}
+function _(t, e, r) {
+  if (e > 16 || r >= 1 << e)
+    throw new Error("Data too long");
+  return B(t, e, r);
+}
+function Z(t) {
+  return new Uint8Array(t.data);
+}
+function M(t) {
+  return t.bitOffset === 0 ? t.data.length * 8 : (t.data.length - 1) * 8 + t.bitOffset;
+}
+function $(t, e) {
+  return S(t.version, e, k);
+}
+function q(t, e) {
+  const r = z(t.version);
+  let n;
+  switch (e) {
+    case f.Numeric:
+      n = 1;
+      break;
+    case f.Alphanumeric:
+      n = 2;
+      break;
+    case f.Byte:
+      n = 4;
+      break;
+  }
+  return _(t, r, n);
+}
+function L(t, e, r) {
+  const n = x(e, t.version);
+  let i = q(t, e);
+  return _(i, n, r);
+}
+function v(t, e) {
+  let r = L(t, f.Numeric, e.length);
+  for (let n = 0; n < e.length; n += 3) {
+    const i = e.slice(n, Math.min(n + 3, e.length));
+    let o = 0;
+    for (const u of i)
+      o = o * 10 + (u - 48);
+    const s = i.length * 3 + 1;
+    r = B(r, s, o);
+  }
+  return r;
+}
+function t1(t, e) {
+  let r = L(t, f.Alphanumeric, e.length);
+  for (let n = 0; n < e.length; n += 2) {
+    const i = e.slice(n, Math.min(n + 2, e.length));
+    let o = 0;
+    for (const u of i)
+      o = o * 45 + o1(u);
+    const s = i.length * 5 + 1;
+    r = B(r, s, o);
+  }
+  return r;
+}
+function e1(t, e) {
+  let r = L(t, f.Byte, e.length);
+  for (const n of e)
+    r = B(r, 8, n);
+  return r;
+}
+function n1(t, e) {
+  const n = M(t), i = $(t, e);
+  if (n > i)
+    throw new Error("Data too long");
+  let o = t;
+  const s = Math.min(4, i - n);
+  if (s > 0 && (o = B(o, s, 0)), M(o) < i) {
+    const u = [236, 17], l = [...o.data], w = Math.floor(i / 8) - l.length;
+    for (let g = 0; g < w; g++)
+      l.push(u[g % 2]);
+    o = {
+      ...o,
+      data: l,
+      bitOffset: 0
+    };
+  }
+  if (M(o) < i) {
+    const u = [...o.data];
+    u.push(0), o = {
+      ...o,
+      data: u
+    };
+  }
+  return o;
+}
+function r1(t, e, r) {
+  let n = t;
+  for (const i of r) {
+    const o = e.slice(i.begin, i.end);
+    switch (i.mode) {
+      case f.Numeric:
+        n = v(n, o);
+        break;
+      case f.Alphanumeric:
+        n = t1(n, o);
+        break;
+      case f.Byte:
+        n = e1(n, o);
+        break;
+    }
+  }
+  return n;
+}
+function o1(t) {
+  return t >= 48 && t <= 57 ? t - 48 : t >= 65 && t <= 90 ? t - 65 + 10 : t === 32 ? 36 : t === 36 ? 37 : t === 37 ? 38 : t === 42 ? 39 : t === 43 ? 40 : t === 45 ? 41 : t === 46 ? 42 : t === 47 ? 43 : t === 58 ? 44 : 0;
+}
+function i1(t, e) {
+  let r = 0, n = 39;
+  for (; n > 1; ) {
+    const i = Math.floor(n / 2), o = r + i;
+    r = k[o][e] > t ? r : o, n -= i;
+  }
+  return r = k[r][e] >= t ? r : r + 1, r + 1;
+}
+function s1(t, e) {
+  for (const r of [9, 26, 40]) {
+    const n = j(t), i = H(n, r), o = K(i), s = Q(o, r), u = S(r, e, k);
+    if (s <= u) {
+      const l = i1(s, e);
+      let c = W(l);
+      return c = r1(c, t, o), c = n1(c, e), c;
+    }
+  }
+  throw new Error("Data too long");
+}
+const u1 = new Uint8Array([
+  1,
+  2,
+  4,
+  8,
+  16,
+  32,
+  64,
+  128,
+  29,
+  58,
+  116,
+  232,
+  205,
+  135,
+  19,
+  38,
+  76,
+  152,
+  45,
+  90,
+  180,
+  117,
+  234,
+  201,
+  143,
+  3,
+  6,
+  12,
+  24,
+  48,
+  96,
+  192,
+  157,
+  39,
+  78,
+  156,
+  37,
+  74,
+  148,
+  53,
+  106,
+  212,
+  181,
+  119,
+  238,
+  193,
+  159,
+  35,
+  70,
+  140,
+  5,
+  10,
+  20,
+  40,
+  80,
+  160,
+  93,
+  186,
+  105,
+  210,
+  185,
+  111,
+  222,
+  161,
+  95,
+  190,
+  97,
+  194,
+  153,
+  47,
+  94,
+  188,
+  101,
+  202,
+  137,
+  15,
+  30,
+  60,
+  120,
+  240,
+  253,
+  231,
+  211,
+  187,
+  107,
+  214,
+  177,
+  127,
+  254,
+  225,
+  223,
+  163,
+  91,
+  182,
+  113,
+  226,
+  217,
+  175,
+  67,
+  134,
+  17,
+  34,
+  68,
+  136,
+  13,
+  26,
+  52,
+  104,
+  208,
+  189,
+  103,
+  206,
+  129,
+  31,
+  62,
+  124,
+  248,
+  237,
+  199,
+  147,
+  59,
+  118,
+  236,
+  197,
+  151,
+  51,
+  102,
+  204,
+  133,
+  23,
+  46,
+  92,
+  184,
+  109,
+  218,
+  169,
+  79,
+  158,
+  33,
+  66,
+  132,
+  21,
+  42,
+  84,
+  168,
+  77,
+  154,
+  41,
+  82,
+  164,
+  85,
+  170,
+  73,
+  146,
+  57,
+  114,
+  228,
+  213,
+  183,
+  115,
+  230,
+  209,
+  191,
+  99,
+  198,
+  145,
+  63,
+  126,
+  252,
+  229,
+  215,
+  179,
+  123,
+  246,
+  241,
+  255,
+  227,
+  219,
+  171,
+  75,
+  150,
+  49,
+  98,
+  196,
+  149,
+  55,
+  110,
+  220,
+  165,
+  87,
+  174,
+  65,
+  130,
+  25,
+  50,
+  100,
+  200,
+  141,
+  7,
+  14,
+  28,
+  56,
+  112,
+  224,
+  221,
+  167,
+  83,
+  166,
+  81,
+  162,
+  89,
+  178,
+  121,
+  242,
+  249,
+  239,
+  195,
+  155,
+  43,
+  86,
+  172,
+  69,
+  138,
+  9,
+  18,
+  36,
+  72,
+  144,
+  61,
+  122,
+  244,
+  245,
+  247,
+  243,
+  251,
+  235,
+  203,
+  139,
+  11,
+  22,
+  44,
+  88,
+  176,
+  125,
+  250,
+  233,
+  207,
+  131,
+  27,
+  54,
+  108,
+  216,
+  173,
+  71,
+  142,
+  1
+]), l1 = new Uint8Array([
+  255,
+  0,
+  1,
+  25,
+  2,
+  50,
+  26,
+  198,
+  3,
+  223,
+  51,
+  238,
+  27,
+  104,
+  199,
+  75,
+  4,
+  100,
+  224,
+  14,
+  52,
+  141,
+  239,
+  129,
+  28,
+  193,
+  105,
+  248,
+  200,
+  8,
+  76,
+  113,
+  5,
+  138,
+  101,
+  47,
+  225,
+  36,
+  15,
+  33,
+  53,
+  147,
+  142,
+  218,
+  240,
+  18,
+  130,
+  69,
+  29,
+  181,
+  194,
+  125,
+  106,
+  39,
+  249,
+  185,
+  201,
+  154,
+  9,
+  120,
+  77,
+  228,
+  114,
+  166,
+  6,
+  191,
+  139,
+  98,
+  102,
+  221,
+  48,
+  253,
+  226,
+  152,
+  37,
+  179,
+  16,
+  145,
+  34,
+  136,
+  54,
+  208,
+  148,
+  206,
+  143,
+  150,
+  219,
+  189,
+  241,
+  210,
+  19,
+  92,
+  131,
+  56,
+  70,
+  64,
+  30,
+  66,
+  182,
+  163,
+  195,
+  72,
+  126,
+  110,
+  107,
+  58,
+  40,
+  84,
+  250,
+  133,
+  186,
+  61,
+  202,
+  94,
+  155,
+  159,
+  10,
+  21,
+  121,
+  43,
+  78,
+  212,
+  229,
+  172,
+  115,
+  243,
+  167,
+  87,
+  7,
+  112,
+  192,
+  247,
+  140,
+  128,
+  99,
+  13,
+  103,
+  74,
+  222,
+  237,
+  49,
+  197,
+  254,
+  24,
+  227,
+  165,
+  153,
+  119,
+  38,
+  184,
+  180,
+  124,
+  17,
+  68,
+  146,
+  217,
+  35,
+  32,
+  137,
+  46,
+  55,
+  63,
+  209,
+  91,
+  149,
+  188,
+  207,
+  205,
+  144,
+  135,
+  151,
+  178,
+  220,
+  252,
+  190,
+  97,
+  242,
+  86,
+  211,
+  171,
+  20,
+  42,
+  93,
+  158,
+  132,
+  60,
+  57,
+  83,
+  71,
+  109,
+  65,
+  162,
+  31,
+  45,
+  67,
+  216,
+  183,
+  123,
+  164,
+  118,
+  196,
+  23,
+  73,
+  236,
+  127,
+  12,
+  111,
+  246,
+  108,
+  161,
+  59,
+  82,
+  41,
+  157,
+  85,
+  170,
+  251,
+  96,
+  134,
+  177,
+  187,
+  204,
+  62,
+  90,
+  203,
+  89,
+  95,
+  176,
+  156,
+  169,
+  160,
+  81,
+  11,
+  245,
+  22,
+  235,
+  122,
+  117,
+  44,
+  215,
+  79,
+  174,
+  213,
+  233,
+  230,
+  231,
+  173,
+  232,
+  116,
+  214,
+  244,
+  234,
+  168,
+  80,
+  88,
+  175
+]), m = [];
+function f1() {
+  if (!(m.length > 0)) {
+    m.push(new Uint8Array([])), m.push(new Uint8Array([0])), m.push(new Uint8Array([25, 1])), m.push(new Uint8Array([198, 199, 3])), m.push(new Uint8Array([75, 249, 78, 6])), m.push(new Uint8Array([113, 164, 166, 119, 10])), m.push(new Uint8Array([166, 0, 134, 5, 176, 15])), m.push(new Uint8Array([87, 229, 146, 149, 238, 102, 21])), m.push(new Uint8Array([175, 238, 208, 249, 215, 252, 196, 28])), m.push(new Uint8Array([95, 246, 137, 231, 235, 149, 11, 123, 36])), m.push(new Uint8Array([251, 67, 46, 61, 118, 70, 64, 94, 32, 45]));
+    for (let t = 11; t <= 68; t++)
+      m.push(new Uint8Array(t));
+  }
+}
+f1();
+const c1 = [
+  [7, 10, 13, 17],
+  [10, 16, 22, 28],
+  [15, 26, 18, 22],
+  [20, 18, 26, 16],
+  [26, 24, 18, 22],
+  [18, 16, 24, 28],
+  [20, 18, 18, 26],
+  [24, 22, 22, 26],
+  [30, 22, 20, 24],
+  [18, 26, 24, 28],
+  [20, 30, 28, 24],
+  [24, 22, 26, 28],
+  [26, 22, 24, 22],
+  [30, 24, 20, 24],
+  [22, 24, 30, 24],
+  [24, 28, 24, 30],
+  [28, 28, 28, 28],
+  [30, 26, 28, 28],
+  [28, 26, 26, 26],
+  [28, 26, 30, 28],
+  [28, 26, 28, 30],
+  [28, 28, 30, 24],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [26, 28, 30, 30],
+  [28, 28, 28, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30]
+], a1 = [
+  [[19, 1, 0, 0], [16, 1, 0, 0], [13, 1, 0, 0], [9, 1, 0, 0]],
+  [[34, 1, 0, 0], [28, 1, 0, 0], [22, 1, 0, 0], [16, 1, 0, 0]],
+  [[55, 1, 0, 0], [44, 1, 0, 0], [17, 2, 0, 0], [13, 2, 0, 0]],
+  [[80, 1, 0, 0], [32, 2, 0, 0], [24, 2, 0, 0], [9, 4, 0, 0]],
+  [[108, 1, 0, 0], [43, 2, 0, 0], [15, 2, 16, 2], [11, 2, 12, 2]],
+  [[68, 2, 0, 0], [27, 4, 0, 0], [19, 4, 0, 0], [15, 4, 0, 0]],
+  [[78, 2, 0, 0], [31, 4, 0, 0], [14, 2, 15, 4], [13, 4, 14, 1]],
+  [[97, 2, 0, 0], [38, 2, 39, 2], [18, 4, 19, 2], [14, 4, 15, 2]],
+  [[116, 2, 0, 0], [36, 3, 37, 2], [16, 4, 17, 4], [12, 4, 13, 4]],
+  [[68, 2, 69, 2], [43, 4, 44, 1], [19, 6, 20, 2], [15, 6, 16, 2]],
+  [[81, 4, 0, 0], [50, 1, 51, 4], [22, 4, 23, 4], [12, 3, 13, 8]],
+  [[92, 2, 93, 2], [36, 6, 37, 2], [20, 4, 21, 6], [14, 7, 15, 4]],
+  [[107, 4, 0, 0], [37, 8, 38, 1], [20, 8, 21, 4], [11, 12, 12, 4]],
+  [[115, 3, 116, 1], [40, 4, 41, 5], [16, 11, 17, 5], [12, 11, 13, 5]],
+  [[87, 5, 88, 1], [41, 5, 42, 5], [24, 5, 25, 7], [12, 11, 13, 7]],
+  [[98, 5, 99, 1], [45, 7, 46, 3], [19, 15, 20, 2], [15, 3, 16, 13]],
+  [[107, 1, 108, 5], [46, 10, 47, 1], [22, 1, 23, 15], [14, 2, 15, 17]],
+  [[120, 5, 121, 1], [43, 9, 44, 4], [22, 17, 23, 1], [14, 2, 15, 19]],
+  [[113, 3, 114, 4], [44, 3, 45, 11], [21, 17, 22, 4], [13, 9, 14, 16]],
+  [[107, 3, 108, 5], [41, 3, 42, 13], [24, 15, 25, 5], [15, 15, 16, 10]],
+  [[116, 4, 117, 4], [42, 17, 0, 0], [22, 17, 23, 6], [16, 19, 17, 6]],
+  [[111, 2, 112, 7], [46, 17, 0, 0], [24, 7, 25, 16], [13, 34, 0, 0]],
+  [[121, 4, 122, 5], [47, 4, 48, 14], [24, 11, 25, 14], [15, 16, 16, 14]],
+  [[117, 6, 118, 4], [45, 6, 46, 14], [24, 11, 25, 16], [16, 30, 17, 2]],
+  [[106, 8, 107, 4], [47, 8, 48, 13], [24, 7, 25, 22], [15, 22, 16, 13]],
+  [[114, 10, 115, 2], [46, 19, 47, 4], [22, 28, 23, 6], [16, 33, 17, 4]],
+  [[122, 8, 123, 4], [45, 22, 46, 3], [23, 8, 24, 26], [15, 12, 16, 28]],
+  [[117, 3, 118, 10], [45, 3, 46, 23], [24, 4, 25, 31], [15, 11, 16, 31]],
+  [[116, 7, 117, 7], [45, 21, 46, 7], [23, 1, 24, 37], [15, 19, 16, 26]],
+  [[115, 5, 116, 10], [47, 19, 48, 10], [24, 15, 25, 25], [15, 23, 16, 25]],
+  [[115, 13, 116, 3], [46, 2, 47, 29], [24, 42, 25, 1], [15, 23, 16, 28]],
+  [[115, 17, 0, 0], [46, 10, 47, 23], [24, 10, 25, 35], [15, 19, 16, 35]],
+  [[115, 17, 116, 1], [46, 14, 47, 21], [24, 29, 25, 19], [15, 11, 16, 46]],
+  [[115, 13, 116, 6], [46, 14, 47, 23], [24, 44, 25, 7], [16, 59, 17, 1]],
+  [[121, 12, 122, 7], [47, 12, 48, 26], [24, 39, 25, 14], [15, 22, 16, 41]],
+  [[121, 6, 122, 14], [47, 6, 48, 34], [24, 46, 25, 10], [15, 2, 16, 64]],
+  [[122, 17, 123, 4], [46, 29, 47, 14], [24, 49, 25, 10], [15, 24, 16, 46]],
+  [[122, 4, 123, 18], [46, 13, 47, 32], [24, 48, 25, 14], [15, 42, 16, 32]],
+  [[117, 20, 118, 4], [47, 40, 48, 7], [24, 43, 25, 22], [15, 10, 16, 67]],
+  [[118, 19, 119, 6], [47, 18, 48, 31], [24, 34, 25, 34], [15, 20, 16, 61]]
+];
+function h1(t, e) {
+  const r = t.length, n = m[e], i = new Uint8Array(e + r);
+  i.set(t);
+  for (let o = 0; o < r; o++) {
+    const s = i[o];
+    if (s === 0) continue;
+    const u = l1[s];
+    for (let l = 0; l < n.length; l++)
+      i[o + 1 + l] ^= u1[(n[l] + u) % 255];
+  }
+  return i.slice(r);
+}
+function I(t) {
+  const e = t[t.length - 1].length, r = [];
+  for (let n = 0; n < e; n++)
+    for (const i of t)
+      n < i.length && r.push(i[n]);
+  return r;
+}
+function d1(t, e, r) {
+  const [n, i, o] = S(e, r, a1), s = n * i, u = [];
+  for (let h = 0; h < s; h += n)
+    u.push(t.slice(h, h + n));
+  if (o > 0)
+    for (let h = s; h < t.length; h += o)
+      u.push(t.slice(h, h + o));
+  const l = S(e, r, c1), c = u.map((h) => Array.from(h1(h, l))), w = new Uint8Array(I(u.map((h) => Array.from(h)))), g = new Uint8Array(I(c));
+  return [w, g];
+}
+function y(t) {
+  return t === 2 || t === 4;
+}
+function w1(t) {
+  return y(t) ? a.Dark : a.Light;
+}
+function m1(t, e) {
+  return t === 0 || t === 3 ? e ? 2 : 1 : t === 4 ? e ? 1 : 2 : t;
+}
+function g1(t, e) {
+  const r = O(t);
+  return {
+    version: t,
+    ecLevel: e,
+    width: r,
+    modules: new Array(r * r).fill(
+      0
+      /* Empty */
+    )
+  };
+}
+function N(t, e, r) {
+  const n = e < 0 ? e + t.width : e;
+  return (r < 0 ? r + t.width : r) * t.width + n;
+}
+function A(t, e, r) {
+  return t.modules[N(t, e, r)];
+}
+function d(t, e, r, n) {
+  const i = n === a.Dark ? 2 : 1, o = [...t.modules];
+  return o[N(t, e, r)] = i, {
+    ...t,
+    modules: o
+  };
+}
+function p1(t, e, r, n) {
+  const i = n === a.Dark ? 4 : 3, o = [...t.modules];
+  return o[N(t, e, r)] = i, {
+    ...t,
+    modules: o
+  };
+}
+function C(t, e, r) {
+  const n = e >= 0 ? -3 : -4, i = e >= 0 ? 4 : 3, o = r >= 0 ? -3 : -4, s = r >= 0 ? 4 : 3;
+  let u = t;
+  for (let l = o; l <= s; l++)
+    for (let c = n; c <= i; c++) {
+      let w;
+      Math.abs(c) === 4 || Math.abs(l) === 4 ? w = a.Light : Math.abs(c) === 3 || Math.abs(l) === 3 ? w = a.Dark : Math.abs(c) === 2 || Math.abs(l) === 2 ? w = a.Light : w = a.Dark, u = d(u, e + c, r + l, w);
+    }
+  return u;
+}
+function y1(t, e, r) {
+  let n = t;
+  for (let i = -2; i <= 2; i++)
+    for (let o = -2; o <= 2; o++) {
+      const s = Math.abs(o) === 2 || Math.abs(i) === 2 || o === 0 && i === 0 ? a.Dark : a.Light;
+      n = d(n, e + o, r + i, s);
+    }
+  return n;
+}
+function A1(t) {
+  let e = t;
+  e = C(e, 3, 3), e = C(e, -4, 3), e = C(e, 3, -4);
+  for (let n = 8; n < t.width - 8; n++) {
+    const i = n % 2 === 0 ? a.Dark : a.Light;
+    e = d(e, n, 6, i), e = d(e, 6, n, i);
+  }
+  e = d(e, 8, t.width - 8, a.Dark);
+  const r = N1(t.version);
+  for (const n of r)
+    for (const i of r)
+      A(e, i, n) === 0 && (e = y1(e, i, n));
+  for (let n = 0; n <= 8; n++)
+    A(e, n, 8) === 0 && (e = d(e, n, 8, a.Light)), A(e, 8, n) === 0 && (e = d(e, 8, n, a.Light));
+  for (let n = 0; n < 7; n++)
+    A(e, 8, t.width - 1 - n) === 0 && (e = d(e, 8, t.width - 1 - n, a.Light));
+  for (let n = 0; n < 8; n++)
+    A(e, t.width - 8 + n, 8) === 0 && (e = d(e, t.width - 8 + n, 8, a.Light));
+  if (t.version >= 7)
+    for (let n = 0; n < 6; n++)
+      for (let i = 0; i < 3; i++)
+        e = d(e, n, t.width - 11 + i, a.Light), e = d(e, t.width - 11 + i, n, a.Light);
+  return e;
+}
+function B1(t, e, r) {
+  const n = new Uint8Array(e.length + r.length);
+  n.set(e), n.set(r, e.length);
+  let i = t, o = 0, s = !0, u = t.width - 1;
+  for (; u > 0; ) {
+    u === 6 && u--;
+    for (let l = 0; l < t.width; l++) {
+      const c = s ? t.width - 1 - l : l;
+      for (const w of [0, -1]) {
+        const g = u + w;
+        if (A(i, g, c) === 0) {
+          const h = o < n.length * 8 ? n[Math.floor(o / 8)] >> 7 - o % 8 & 1 : 0;
+          i = p1(i, g, c, h === 1 ? a.Dark : a.Light), o++;
+        }
+      }
+    }
+    s = !s, u -= 2;
+  }
+  return i;
+}
+function U(t, e) {
+  const r = [...t.modules];
+  for (let o = 0; o < t.width; o++)
+    for (let s = 0; s < t.width; s++) {
+      const u = r[o * t.width + s];
+      if (u === 3 || u === 4) {
+        const l = C1(e, s, o);
+        r[o * t.width + s] = m1(u, l);
+      }
+    }
+  let n = {
+    ...t,
+    modules: r
+  };
+  const i = P1(t.ecLevel, e);
+  if (n = S1(n, i), t.version >= 7) {
+    const o = I1(t.version);
+    n = b1(n, o);
+  }
+  return n;
+}
+function S1(t, e) {
+  let r = t;
+  for (let n = 0; n < 15; n++) {
+    const o = (e >> 14 - n & 1) === 1 ? a.Dark : a.Light;
+    n < 6 ? r = d(r, n, 8, o) : n < 8 ? r = d(r, n + 1, 8, o) : n === 8 ? r = d(r, 8, 7, o) : r = d(r, 8, 14 - n, o), n < 7 ? r = d(r, 8, t.width - 1 - n, o) : r = d(r, t.width - 15 + n, 8, o);
+  }
+  return r;
+}
+function b1(t, e) {
+  let r = t;
+  for (let n = 0; n < 18; n++) {
+    const o = (e >> 17 - n & 1) === 1 ? a.Dark : a.Light, s = 5 - Math.floor(n / 3), u = t.width - 9 - n % 3, l = t.width - 9 - n % 3, c = 5 - Math.floor(n / 3);
+    r = d(r, s, u, o), r = d(r, l, c, o);
+  }
+  return r;
+}
+function k1(t) {
+  let e = 0, r = 1 / 0;
+  for (let n = 0; n < 8; n++) {
+    const i = U(t, n), o = D1(i);
+    o < r && (r = o, e = n);
+  }
+  return U(t, e);
+}
+function D1(t) {
+  let e = 0;
+  for (let r = 0; r < t.width; r++) {
+    let n = null, i = 0;
+    for (let o = 0; o < t.width; o++) {
+      const s = y(t.modules[r * t.width + o]);
+      s === n ? i++ : (i >= 5 && (e += i - 2), n = s, i = 1);
+    }
+    i >= 5 && (e += i - 2);
+  }
+  for (let r = 0; r < t.width; r++) {
+    let n = null, i = 0;
+    for (let o = 0; o < t.width; o++) {
+      const s = y(t.modules[o * t.width + r]);
+      s === n ? i++ : (i >= 5 && (e += i - 2), n = s, i = 1);
+    }
+    i >= 5 && (e += i - 2);
+  }
+  for (let r = 0; r < t.width - 1; r++)
+    for (let n = 0; n < t.width - 1; n++) {
+      const i = y(t.modules[r * t.width + n]), o = y(t.modules[r * t.width + n + 1]), s = y(t.modules[(r + 1) * t.width + n]), u = y(t.modules[(r + 1) * t.width + n + 1]);
+      i === o && o === s && s === u && (e += 3);
+    }
+  return e += Math.floor(t.width * t.width * 0.5), e;
+}
+function M1(t) {
+  return t.modules.map(w1);
+}
+function C1(t, e, r) {
+  switch (t) {
+    case 0:
+      return (e + r) % 2 === 0;
+    case 1:
+      return r % 2 === 0;
+    case 2:
+      return e % 3 === 0;
+    case 3:
+      return (e + r) % 3 === 0;
+    case 4:
+      return (Math.floor(r / 2) + Math.floor(e / 3)) % 2 === 0;
+    case 5:
+      return e * r % 2 + e * r % 3 === 0;
+    case 6:
+      return (e * r % 2 + e * r % 3) % 2 === 0;
+    case 7:
+      return ((e + r) % 2 + e * r % 3) % 2 === 0;
+    default:
+      return !1;
+  }
+}
+const L1 = [
+  null,
+  // version 0 (doesn't exist)
+  null,
+  // version 1 (no alignment patterns)
+  [6, 18],
+  [6, 22],
+  [6, 26],
+  [6, 30],
+  [6, 34],
+  [6, 22, 38],
+  [6, 24, 42],
+  [6, 26, 46],
+  [6, 28, 50],
+  [6, 30, 54],
+  [6, 32, 58],
+  [6, 34, 62],
+  [6, 26, 46, 66],
+  [6, 26, 48, 70],
+  [6, 26, 50, 74],
+  [6, 30, 54, 78],
+  [6, 30, 56, 82],
+  [6, 30, 58, 86],
+  [6, 34, 62, 90],
+  [6, 28, 50, 72, 94],
+  [6, 26, 50, 74, 98],
+  [6, 30, 54, 78, 102],
+  [6, 28, 54, 80, 106],
+  [6, 32, 58, 84, 110],
+  [6, 30, 58, 86, 114],
+  [6, 34, 62, 90, 118],
+  [6, 26, 50, 74, 98, 122],
+  [6, 30, 54, 78, 102, 126],
+  [6, 26, 52, 78, 104, 130],
+  [6, 30, 56, 82, 108, 134],
+  [6, 34, 60, 86, 112, 138],
+  [6, 30, 58, 86, 114, 142],
+  [6, 34, 62, 90, 118, 146],
+  [6, 30, 54, 78, 102, 126, 150],
+  [6, 24, 50, 76, 102, 128, 154],
+  [6, 28, 54, 80, 106, 132, 158],
+  [6, 32, 58, 84, 110, 136, 162],
+  [6, 26, 54, 82, 110, 138, 166],
+  [6, 30, 58, 86, 114, 142, 170]
+];
+function N1(t) {
+  return L1[t] ?? [];
+}
+function P1(t, e) {
+  const r = (t ^ 1) << 3 | e;
+  let n = r << 10;
+  for (let i = 0; i < 5; i++)
+    n & 1 << 14 - i && (n ^= 1335 << 4 - i);
+  return (r << 10 | n) ^ 21522;
+}
+function I1(t) {
+  return [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    31892,
+    34236,
+    39577,
+    42195,
+    48118,
+    51042,
+    55367,
+    58893,
+    63784,
+    68472,
+    70749,
+    76311,
+    79154,
+    84390,
+    87683,
+    92361,
+    96236,
+    102084,
+    102881,
+    110507,
+    110734,
+    117786,
+    119615,
+    126325,
+    127568,
+    133589,
+    136944,
+    141498,
+    145311,
+    150283,
+    152622,
+    158308,
+    161089,
+    167017
+  ][t] || 0;
+}
+function U1(t) {
+  const { data: e, ec: r = T.M } = t, n = typeof e == "string" ? new TextEncoder().encode(e) : e, i = s1(n, r), o = J(i), [s, u] = d1(Z(i), o, r);
+  let l = g1(o, r);
+  l = A1(l), l = B1(l, s, u), l = k1(l);
+  const c = O(o), w = M1(l), g = [];
+  for (let h = 0; h < c; h++) {
+    const P = [];
+    for (let D = 0; D < c; D++)
+      P.push(w[h * c + D] === a.Dark);
+    g.push(P);
+  }
+  return {
+    matrix: g,
+    width: c,
+    version: o,
+    ec: r
+  };
+}
+function T1(t, e = "#", r = ".") {
+  let n = "";
+  for (let i = 0; i < t.width; i++) {
+    for (let o = 0; o < t.width; o++)
+      n += t.matrix[i][o] ? e : r;
+    n += `
+`;
+  }
+  return n;
+}
+export {
+  T as EcLevel,
+  T1 as debugString,
+  U1 as qrCode
+};