@memobit/libs 3.0.0 → 3.1.0

package/dist/node_modules/qrcode.react/lib/esm/index.js

@@ -0,0 +1,979 @@
+import w from "react";
+var ie = Object.defineProperty, D = Object.getOwnPropertySymbols, Y = Object.prototype.hasOwnProperty, V = Object.prototype.propertyIsEnumerable, G = (u, l, s) => l in u ? ie(u, l, {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value: s
+}) : u[l] = s, z = (u, l) => {
+  for (var s in l || (l = {})) Y.call(l, s) && G(u, s, l[s]);
+  if (D)
+    for (var s of D(l)) V.call(l, s) && G(u, s, l[s]);
+  return u;
+}, U = (u, l) => {
+  var s = {};
+  for (var c in u) Y.call(u, c) && l.indexOf(c) < 0 && (s[c] = u[c]);
+  if (u != null && D)
+    for (var c of D(u)) l.indexOf(c) < 0 && V.call(u, c) && (s[c] = u[c]);
+  return s;
+}, S;
+((u) => {
+  const l = class m {
+    constructor(e, n, t, r) {
+      if (this.version = e, this.errorCorrectionLevel = n, this.modules = [], this.isFunction = [], e < m.MIN_VERSION || e > m.MAX_VERSION) throw new RangeError("Version value out of range");
+      if (r < -1 || r > 7) throw new RangeError("Mask value out of range");
+      this.size = e * 4 + 17;
+      let o = [];
+      for (let i = 0; i < this.size; i++) o.push(!1);
+      for (let i = 0; i < this.size; i++)
+        this.modules.push(o.slice()), this.isFunction.push(o.slice());
+      this.drawFunctionPatterns();
+      const a = this.addEccAndInterleave(t);
+      if (this.drawCodewords(a), r == -1) {
+        let i = 1e9;
+        for (let E = 0; E < 8; E++) {
+          this.applyMask(E), this.drawFormatBits(E);
+          const f = this.getPenaltyScore();
+          f < i && (r = E, i = f), this.applyMask(E);
+        }
+      }
+      g(0 <= r && r <= 7), this.mask = r, this.applyMask(r), this.drawFormatBits(r), this.isFunction = [];
+    }
+    static encodeText(e, n) {
+      const t = u.QrSegment.makeSegments(e);
+      return m.encodeSegments(t, n);
+    }
+    static encodeBinary(e, n) {
+      const t = u.QrSegment.makeBytes(e);
+      return m.encodeSegments([t], n);
+    }
+    static encodeSegments(e, n, t = 1, r = 40, o = -1, a = !0) {
+      if (!(m.MIN_VERSION <= t && t <= r && r <= m.MAX_VERSION) || o < -1 || o > 7) throw new RangeError("Invalid value");
+      let i, E;
+      for (i = t; ; i++) {
+        const d = m.getNumDataCodewords(i, n) * 8, R = p.getTotalBits(e, i);
+        if (R <= d) {
+          E = R;
+          break;
+        }
+        if (i >= r) throw new RangeError("Data too long");
+      }
+      for (const d of [
+        m.Ecc.MEDIUM,
+        m.Ecc.QUARTILE,
+        m.Ecc.HIGH
+      ]) a && E <= m.getNumDataCodewords(i, d) * 8 && (n = d);
+      let f = [];
+      for (const d of e) {
+        s(d.mode.modeBits, 4, f), s(d.numChars, d.mode.numCharCountBits(i), f);
+        for (const R of d.getData()) f.push(R);
+      }
+      g(f.length == E);
+      const N = m.getNumDataCodewords(i, n) * 8;
+      g(f.length <= N), s(0, Math.min(4, N - f.length), f), s(0, (8 - f.length % 8) % 8, f), g(f.length % 8 == 0);
+      for (let d = 236; f.length < N; d ^= 253) s(d, 8, f);
+      let A = [];
+      for (; A.length * 8 < f.length; ) A.push(0);
+      return f.forEach((d, R) => A[R >>> 3] |= d << 7 - (R & 7)), new m(i, n, A, o);
+    }
+    getModule(e, n) {
+      return 0 <= e && e < this.size && 0 <= n && n < this.size && this.modules[n][e];
+    }
+    getModules() {
+      return this.modules;
+    }
+    drawFunctionPatterns() {
+      for (let t = 0; t < this.size; t++)
+        this.setFunctionModule(6, t, t % 2 == 0), this.setFunctionModule(t, 6, t % 2 == 0);
+      this.drawFinderPattern(3, 3), this.drawFinderPattern(this.size - 4, 3), this.drawFinderPattern(3, this.size - 4);
+      const e = this.getAlignmentPatternPositions(), n = e.length;
+      for (let t = 0; t < n; t++) for (let r = 0; r < n; r++) t == 0 && r == 0 || t == 0 && r == n - 1 || t == n - 1 && r == 0 || this.drawAlignmentPattern(e[t], e[r]);
+      this.drawFormatBits(0), this.drawVersion();
+    }
+    drawFormatBits(e) {
+      const n = this.errorCorrectionLevel.formatBits << 3 | e;
+      let t = n;
+      for (let o = 0; o < 10; o++) t = t << 1 ^ (t >>> 9) * 1335;
+      const r = (n << 10 | t) ^ 21522;
+      g(r >>> 15 == 0);
+      for (let o = 0; o <= 5; o++) this.setFunctionModule(8, o, c(r, o));
+      this.setFunctionModule(8, 7, c(r, 6)), this.setFunctionModule(8, 8, c(r, 7)), this.setFunctionModule(7, 8, c(r, 8));
+      for (let o = 9; o < 15; o++) this.setFunctionModule(14 - o, 8, c(r, o));
+      for (let o = 0; o < 8; o++) this.setFunctionModule(this.size - 1 - o, 8, c(r, o));
+      for (let o = 8; o < 15; o++) this.setFunctionModule(8, this.size - 15 + o, c(r, o));
+      this.setFunctionModule(8, this.size - 8, !0);
+    }
+    drawVersion() {
+      if (this.version < 7) return;
+      let e = this.version;
+      for (let t = 0; t < 12; t++) e = e << 1 ^ (e >>> 11) * 7973;
+      const n = this.version << 12 | e;
+      g(n >>> 18 == 0);
+      for (let t = 0; t < 18; t++) {
+        const r = c(n, t), o = this.size - 11 + t % 3, a = Math.floor(t / 3);
+        this.setFunctionModule(o, a, r), this.setFunctionModule(a, o, r);
+      }
+    }
+    drawFinderPattern(e, n) {
+      for (let t = -4; t <= 4; t++) for (let r = -4; r <= 4; r++) {
+        const o = Math.max(Math.abs(r), Math.abs(t)), a = e + r, i = n + t;
+        0 <= a && a < this.size && 0 <= i && i < this.size && this.setFunctionModule(a, i, o != 2 && o != 4);
+      }
+    }
+    drawAlignmentPattern(e, n) {
+      for (let t = -2; t <= 2; t++) for (let r = -2; r <= 2; r++) this.setFunctionModule(e + r, n + t, Math.max(Math.abs(r), Math.abs(t)) != 1);
+    }
+    setFunctionModule(e, n, t) {
+      this.modules[n][e] = t, this.isFunction[n][e] = !0;
+    }
+    addEccAndInterleave(e) {
+      const n = this.version, t = this.errorCorrectionLevel;
+      if (e.length != m.getNumDataCodewords(n, t)) throw new RangeError("Invalid argument");
+      const r = m.NUM_ERROR_CORRECTION_BLOCKS[t.ordinal][n], o = m.ECC_CODEWORDS_PER_BLOCK[t.ordinal][n], a = Math.floor(m.getNumRawDataModules(n) / 8), i = r - a % r, E = Math.floor(a / r);
+      let f = [];
+      const N = m.reedSolomonComputeDivisor(o);
+      for (let d = 0, R = 0; d < r; d++) {
+        let v = e.slice(R, R + E - o + (d < i ? 0 : 1));
+        R += v.length;
+        const O = m.reedSolomonComputeRemainder(v, N);
+        d < i && v.push(0), f.push(v.concat(O));
+      }
+      let A = [];
+      for (let d = 0; d < f[0].length; d++) f.forEach((R, v) => {
+        (d != E - o || v >= i) && A.push(R[d]);
+      });
+      return g(A.length == a), A;
+    }
+    drawCodewords(e) {
+      if (e.length != Math.floor(m.getNumRawDataModules(this.version) / 8)) throw new RangeError("Invalid argument");
+      let n = 0;
+      for (let t = this.size - 1; t >= 1; t -= 2) {
+        t == 6 && (t = 5);
+        for (let r = 0; r < this.size; r++) for (let o = 0; o < 2; o++) {
+          const a = t - o, i = (t + 1 & 2) == 0 ? this.size - 1 - r : r;
+          !this.isFunction[i][a] && n < e.length * 8 && (this.modules[i][a] = c(e[n >>> 3], 7 - (n & 7)), n++);
+        }
+      }
+      g(n == e.length * 8);
+    }
+    applyMask(e) {
+      if (e < 0 || e > 7) throw new RangeError("Mask value out of range");
+      for (let n = 0; n < this.size; n++) for (let t = 0; t < this.size; t++) {
+        let r;
+        switch (e) {
+          case 0:
+            r = (t + n) % 2 == 0;
+            break;
+          case 1:
+            r = n % 2 == 0;
+            break;
+          case 2:
+            r = t % 3 == 0;
+            break;
+          case 3:
+            r = (t + n) % 3 == 0;
+            break;
+          case 4:
+            r = (Math.floor(t / 3) + Math.floor(n / 2)) % 2 == 0;
+            break;
+          case 5:
+            r = t * n % 2 + t * n % 3 == 0;
+            break;
+          case 6:
+            r = (t * n % 2 + t * n % 3) % 2 == 0;
+            break;
+          case 7:
+            r = ((t + n) % 2 + t * n % 3) % 2 == 0;
+            break;
+          default:
+            throw new Error("Unreachable");
+        }
+        !this.isFunction[n][t] && r && (this.modules[n][t] = !this.modules[n][t]);
+      }
+    }
+    getPenaltyScore() {
+      let e = 0;
+      for (let o = 0; o < this.size; o++) {
+        let a = !1, i = 0, E = [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ];
+        for (let f = 0; f < this.size; f++) this.modules[o][f] == a ? (i++, i == 5 ? e += m.PENALTY_N1 : i > 5 && e++) : (this.finderPenaltyAddHistory(i, E), a || (e += this.finderPenaltyCountPatterns(E) * m.PENALTY_N3), a = this.modules[o][f], i = 1);
+        e += this.finderPenaltyTerminateAndCount(a, i, E) * m.PENALTY_N3;
+      }
+      for (let o = 0; o < this.size; o++) {
+        let a = !1, i = 0, E = [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ];
+        for (let f = 0; f < this.size; f++) this.modules[f][o] == a ? (i++, i == 5 ? e += m.PENALTY_N1 : i > 5 && e++) : (this.finderPenaltyAddHistory(i, E), a || (e += this.finderPenaltyCountPatterns(E) * m.PENALTY_N3), a = this.modules[f][o], i = 1);
+        e += this.finderPenaltyTerminateAndCount(a, i, E) * m.PENALTY_N3;
+      }
+      for (let o = 0; o < this.size - 1; o++) for (let a = 0; a < this.size - 1; a++) {
+        const i = this.modules[o][a];
+        i == this.modules[o][a + 1] && i == this.modules[o + 1][a] && i == this.modules[o + 1][a + 1] && (e += m.PENALTY_N2);
+      }
+      let n = 0;
+      for (const o of this.modules) n = o.reduce((a, i) => a + (i ? 1 : 0), n);
+      const t = this.size * this.size, r = Math.ceil(Math.abs(n * 20 - t * 10) / t) - 1;
+      return g(0 <= r && r <= 9), e += r * m.PENALTY_N4, g(0 <= e && e <= 2568888), e;
+    }
+    getAlignmentPatternPositions() {
+      if (this.version == 1) return [];
+      {
+        const e = Math.floor(this.version / 7) + 2, n = this.version == 32 ? 26 : Math.ceil((this.version * 4 + 4) / (e * 2 - 2)) * 2;
+        let t = [6];
+        for (let r = this.size - 7; t.length < e; r -= n) t.splice(1, 0, r);
+        return t;
+      }
+    }
+    static getNumRawDataModules(e) {
+      if (e < m.MIN_VERSION || e > m.MAX_VERSION) throw new RangeError("Version number out of range");
+      let n = (16 * e + 128) * e + 64;
+      if (e >= 2) {
+        const t = Math.floor(e / 7) + 2;
+        n -= (25 * t - 10) * t - 55, e >= 7 && (n -= 36);
+      }
+      return g(208 <= n && n <= 29648), n;
+    }
+    static getNumDataCodewords(e, n) {
+      return Math.floor(m.getNumRawDataModules(e) / 8) - m.ECC_CODEWORDS_PER_BLOCK[n.ordinal][e] * m.NUM_ERROR_CORRECTION_BLOCKS[n.ordinal][e];
+    }
+    static reedSolomonComputeDivisor(e) {
+      if (e < 1 || e > 255) throw new RangeError("Degree out of range");
+      let n = [];
+      for (let r = 0; r < e - 1; r++) n.push(0);
+      n.push(1);
+      let t = 1;
+      for (let r = 0; r < e; r++) {
+        for (let o = 0; o < n.length; o++)
+          n[o] = m.reedSolomonMultiply(n[o], t), o + 1 < n.length && (n[o] ^= n[o + 1]);
+        t = m.reedSolomonMultiply(t, 2);
+      }
+      return n;
+    }
+    static reedSolomonComputeRemainder(e, n) {
+      let t = n.map((r) => 0);
+      for (const r of e) {
+        const o = r ^ t.shift();
+        t.push(0), n.forEach((a, i) => t[i] ^= m.reedSolomonMultiply(a, o));
+      }
+      return t;
+    }
+    static reedSolomonMultiply(e, n) {
+      if (e >>> 8 || n >>> 8) throw new RangeError("Byte out of range");
+      let t = 0;
+      for (let r = 7; r >= 0; r--)
+        t = t << 1 ^ (t >>> 7) * 285, t ^= (n >>> r & 1) * e;
+      return g(t >>> 8 == 0), t;
+    }
+    finderPenaltyCountPatterns(e) {
+      const n = e[1];
+      g(n <= this.size * 3);
+      const t = n > 0 && e[2] == n && e[3] == n * 3 && e[4] == n && e[5] == n;
+      return (t && e[0] >= n * 4 && e[6] >= n ? 1 : 0) + (t && e[6] >= n * 4 && e[0] >= n ? 1 : 0);
+    }
+    finderPenaltyTerminateAndCount(e, n, t) {
+      return e && (this.finderPenaltyAddHistory(n, t), n = 0), n += this.size, this.finderPenaltyAddHistory(n, t), this.finderPenaltyCountPatterns(t);
+    }
+    finderPenaltyAddHistory(e, n) {
+      n[0] == 0 && (e += this.size), n.pop(), n.unshift(e);
+    }
+  };
+  l.MIN_VERSION = 1, l.MAX_VERSION = 40, l.PENALTY_N1 = 3, l.PENALTY_N2 = 3, l.PENALTY_N3 = 40, l.PENALTY_N4 = 10, l.ECC_CODEWORDS_PER_BLOCK = [
+    [
+      -1,
+      7,
+      10,
+      15,
+      20,
+      26,
+      18,
+      20,
+      24,
+      30,
+      18,
+      20,
+      24,
+      26,
+      30,
+      22,
+      24,
+      28,
+      30,
+      28,
+      28,
+      28,
+      28,
+      30,
+      30,
+      26,
+      28,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30
+    ],
+    [
+      -1,
+      10,
+      16,
+      26,
+      18,
+      24,
+      16,
+      18,
+      22,
+      22,
+      26,
+      30,
+      22,
+      22,
+      24,
+      24,
+      28,
+      28,
+      26,
+      26,
+      26,
+      26,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28,
+      28
+    ],
+    [
+      -1,
+      13,
+      22,
+      18,
+      26,
+      18,
+      24,
+      18,
+      22,
+      20,
+      24,
+      28,
+      26,
+      24,
+      20,
+      30,
+      24,
+      28,
+      28,
+      26,
+      30,
+      28,
+      30,
+      30,
+      30,
+      30,
+      28,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30
+    ],
+    [
+      -1,
+      17,
+      28,
+      22,
+      16,
+      22,
+      28,
+      26,
+      26,
+      24,
+      28,
+      24,
+      28,
+      22,
+      24,
+      24,
+      30,
+      28,
+      28,
+      26,
+      28,
+      30,
+      24,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30,
+      30
+    ]
+  ], l.NUM_ERROR_CORRECTION_BLOCKS = [
+    [
+      -1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      2,
+      2,
+      4,
+      4,
+      4,
+      4,
+      4,
+      6,
+      6,
+      6,
+      6,
+      7,
+      8,
+      8,
+      9,
+      9,
+      10,
+      12,
+      12,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      19,
+      20,
+      21,
+      22,
+      24,
+      25
+    ],
+    [
+      -1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      4,
+      4,
+      4,
+      5,
+      5,
+      5,
+      8,
+      9,
+      9,
+      10,
+      10,
+      11,
+      13,
+      14,
+      16,
+      17,
+      17,
+      18,
+      20,
+      21,
+      23,
+      25,
+      26,
+      28,
+      29,
+      31,
+      33,
+      35,
+      37,
+      38,
+      40,
+      43,
+      45,
+      47,
+      49
+    ],
+    [
+      -1,
+      1,
+      1,
+      2,
+      2,
+      4,
+      4,
+      6,
+      6,
+      8,
+      8,
+      8,
+      10,
+      12,
+      16,
+      12,
+      17,
+      16,
+      18,
+      21,
+      20,
+      23,
+      23,
+      25,
+      27,
+      29,
+      34,
+      34,
+      35,
+      38,
+      40,
+      43,
+      45,
+      48,
+      51,
+      53,
+      56,
+      59,
+      62,
+      65,
+      68
+    ],
+    [
+      -1,
+      1,
+      1,
+      2,
+      4,
+      4,
+      4,
+      5,
+      6,
+      8,
+      8,
+      11,
+      11,
+      16,
+      16,
+      18,
+      16,
+      19,
+      21,
+      25,
+      25,
+      25,
+      34,
+      30,
+      32,
+      35,
+      37,
+      40,
+      42,
+      45,
+      48,
+      51,
+      54,
+      57,
+      60,
+      63,
+      66,
+      70,
+      74,
+      77,
+      81
+    ]
+  ], u.QrCode = l;
+  function s(C, e, n) {
+    if (e < 0 || e > 31 || C >>> e) throw new RangeError("Value out of range");
+    for (let t = e - 1; t >= 0; t--) n.push(C >>> t & 1);
+  }
+  function c(C, e) {
+    return (C >>> e & 1) != 0;
+  }
+  function g(C) {
+    if (!C) throw new Error("Assertion error");
+  }
+  const h = class M {
+    constructor(e, n, t) {
+      if (this.mode = e, this.numChars = n, this.bitData = t, n < 0) throw new RangeError("Invalid argument");
+      this.bitData = t.slice();
+    }
+    static makeBytes(e) {
+      let n = [];
+      for (const t of e) s(t, 8, n);
+      return new M(M.Mode.BYTE, e.length, n);
+    }
+    static makeNumeric(e) {
+      if (!M.isNumeric(e)) throw new RangeError("String contains non-numeric characters");
+      let n = [];
+      for (let t = 0; t < e.length; ) {
+        const r = Math.min(e.length - t, 3);
+        s(parseInt(e.substring(t, t + r), 10), r * 3 + 1, n), t += r;
+      }
+      return new M(M.Mode.NUMERIC, e.length, n);
+    }
+    static makeAlphanumeric(e) {
+      if (!M.isAlphanumeric(e)) throw new RangeError("String contains unencodable characters in alphanumeric mode");
+      let n = [], t;
+      for (t = 0; t + 2 <= e.length; t += 2) {
+        let r = M.ALPHANUMERIC_CHARSET.indexOf(e.charAt(t)) * 45;
+        r += M.ALPHANUMERIC_CHARSET.indexOf(e.charAt(t + 1)), s(r, 11, n);
+      }
+      return t < e.length && s(M.ALPHANUMERIC_CHARSET.indexOf(e.charAt(t)), 6, n), new M(M.Mode.ALPHANUMERIC, e.length, n);
+    }
+    static makeSegments(e) {
+      return e == "" ? [] : M.isNumeric(e) ? [M.makeNumeric(e)] : M.isAlphanumeric(e) ? [M.makeAlphanumeric(e)] : [M.makeBytes(M.toUtf8ByteArray(e))];
+    }
+    static makeEci(e) {
+      let n = [];
+      if (e < 0) throw new RangeError("ECI assignment value out of range");
+      if (e < 128) s(e, 8, n);
+      else if (e < 16384)
+        s(2, 2, n), s(e, 14, n);
+      else if (e < 1e6)
+        s(6, 3, n), s(e, 21, n);
+      else throw new RangeError("ECI assignment value out of range");
+      return new M(M.Mode.ECI, 0, n);
+    }
+    static isNumeric(e) {
+      return M.NUMERIC_REGEX.test(e);
+    }
+    static isAlphanumeric(e) {
+      return M.ALPHANUMERIC_REGEX.test(e);
+    }
+    getData() {
+      return this.bitData.slice();
+    }
+    static getTotalBits(e, n) {
+      let t = 0;
+      for (const r of e) {
+        const o = r.mode.numCharCountBits(n);
+        if (r.numChars >= 1 << o) return 1 / 0;
+        t += 4 + o + r.bitData.length;
+      }
+      return t;
+    }
+    static toUtf8ByteArray(e) {
+      e = encodeURI(e);
+      let n = [];
+      for (let t = 0; t < e.length; t++) e.charAt(t) != "%" ? n.push(e.charCodeAt(t)) : (n.push(parseInt(e.substring(t + 1, t + 3), 16)), t += 2);
+      return n;
+    }
+  };
+  h.NUMERIC_REGEX = /^[0-9]*$/, h.ALPHANUMERIC_REGEX = /^[A-Z0-9 $%*+.\/:-]*$/, h.ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+  let p = h;
+  u.QrSegment = h;
+})(S || (S = {}));
+((u) => {
+  ((l) => {
+    const s = class {
+      constructor(g, h) {
+        this.ordinal = g, this.formatBits = h;
+      }
+    };
+    s.LOW = new s(0, 1), s.MEDIUM = new s(1, 0), s.QUARTILE = new s(2, 3), s.HIGH = new s(3, 2), l.Ecc = s;
+  })(u.QrCode || (u.QrCode = {}));
+})(S || (S = {}));
+((u) => {
+  ((l) => {
+    const s = class {
+      constructor(g, h) {
+        this.modeBits = g, this.numBitsCharCount = h;
+      }
+      numCharCountBits(g) {
+        return this.numBitsCharCount[Math.floor((g + 7) / 17)];
+      }
+    };
+    s.NUMERIC = new s(1, [
+      10,
+      12,
+      14
+    ]), s.ALPHANUMERIC = new s(2, [
+      9,
+      11,
+      13
+    ]), s.BYTE = new s(4, [
+      8,
+      16,
+      16
+    ]), s.KANJI = new s(8, [
+      8,
+      10,
+      12
+    ]), s.ECI = new s(7, [
+      0,
+      0,
+      0
+    ]), l.Mode = s;
+  })(u.QrSegment || (u.QrSegment = {}));
+})(S || (S = {}));
+var L = S, le = {
+  L: L.QrCode.Ecc.LOW,
+  M: L.QrCode.Ecc.MEDIUM,
+  Q: L.QrCode.Ecc.QUARTILE,
+  H: L.QrCode.Ecc.HIGH
+}, x = 128, X = "L", K = "#FFFFFF", j = "#000000", W = !1, Z = 1, ae = 4, ce = 0, ue = 0.1;
+function J(u, l = 0) {
+  const s = [];
+  return u.forEach(function(c, g) {
+    let h = null;
+    c.forEach(function(p, C) {
+      if (!p && h !== null) {
+        s.push(`M${h + l} ${g + l}h${C - h}v1H${h + l}z`), h = null;
+        return;
+      }
+      if (C === c.length - 1) {
+        if (!p) return;
+        h === null ? s.push(`M${C + l},${g + l} h1v1H${C + l}z`) : s.push(`M${h + l},${g + l} h${C + 1 - h}v1H${h + l}z`);
+        return;
+      }
+      p && h === null && (h = C);
+    });
+  }), s.join("");
+}
+function q(u, l) {
+  return u.slice().map((s, c) => c < l.y || c >= l.y + l.h ? s : s.map((g, h) => h < l.x || h >= l.x + l.w ? g : !1));
+}
+function he(u, l, s, c) {
+  if (c == null) return null;
+  const g = u.length + s * 2, h = Math.floor(l * ue), p = g / l, C = (c.width || h) * p, e = (c.height || h) * p, n = c.x == null ? u.length / 2 - C / 2 : c.x * p, t = c.y == null ? u.length / 2 - e / 2 : c.y * p, r = c.opacity == null ? 1 : c.opacity;
+  let o = null;
+  if (c.excavate) {
+    let i = Math.floor(n), E = Math.floor(t);
+    o = {
+      x: i,
+      y: E,
+      w: Math.ceil(C + n - i),
+      h: Math.ceil(e + t - E)
+    };
+  }
+  const a = c.crossOrigin;
+  return {
+    x: n,
+    y: t,
+    h: e,
+    w: C,
+    excavation: o,
+    opacity: r,
+    crossOrigin: a
+  };
+}
+function fe(u, l) {
+  return l != null ? Math.max(Math.floor(l), 0) : u ? ae : ce;
+}
+function ee({ value: u, level: l, minVersion: s, includeMargin: c, marginSize: g, imageSettings: h, size: p, boostLevel: C }) {
+  let e = w.useMemo(() => {
+    const a = (Array.isArray(u) ? u : [u]).reduce((i, E) => (i.push(...L.QrSegment.makeSegments(E)), i), []);
+    return L.QrCode.encodeSegments(a, le[l], s, void 0, void 0, C);
+  }, [
+    u,
+    l,
+    s,
+    C
+  ]);
+  const { cells: n, margin: t, numCells: r, calculatedImageSettings: o } = w.useMemo(() => {
+    let a = e.getModules();
+    const i = fe(c, g);
+    return {
+      cells: a,
+      margin: i,
+      numCells: a.length + i * 2,
+      calculatedImageSettings: he(a, p, i, h)
+    };
+  }, [
+    e,
+    p,
+    h,
+    c,
+    g
+  ]);
+  return {
+    qrcode: e,
+    margin: t,
+    cells: n,
+    numCells: r,
+    calculatedImageSettings: o
+  };
+}
+var de = (function() {
+  try {
+    new Path2D().addPath(new Path2D());
+  } catch {
+    return !1;
+  }
+  return !0;
+})(), me = w.forwardRef(function(l, s) {
+  const c = l, { value: g, size: h = x, level: p = X, bgColor: C = K, fgColor: e = j, includeMargin: n = W, minVersion: t = Z, boostLevel: r, marginSize: o, imageSettings: a } = c, i = U(c, [
+    "value",
+    "size",
+    "level",
+    "bgColor",
+    "fgColor",
+    "includeMargin",
+    "minVersion",
+    "boostLevel",
+    "marginSize",
+    "imageSettings"
+  ]), { style: E } = i, f = U(i, ["style"]), N = a?.src, A = w.useRef(null), d = w.useRef(null), R = w.useCallback((y) => {
+    A.current = y, typeof s == "function" ? s(y) : s && (s.current = y);
+  }, [s]), [v, O] = w.useState(!1), { margin: b, cells: T, numCells: B, calculatedImageSettings: P } = ee({
+    value: g,
+    level: p,
+    minVersion: t,
+    boostLevel: r,
+    includeMargin: n,
+    marginSize: o,
+    imageSettings: a,
+    size: h
+  });
+  w.useEffect(() => {
+    if (A.current != null) {
+      const y = A.current, I = y.getContext("2d");
+      if (!I) return;
+      let Q = T;
+      const F = d.current, k = P != null && F !== null && F.complete && F.naturalHeight !== 0 && F.naturalWidth !== 0;
+      k && P.excavation != null && (Q = q(T, P.excavation));
+      const H = window.devicePixelRatio || 1;
+      y.height = y.width = h * H;
+      const $ = h / B * H;
+      I.scale($, $), I.fillStyle = C, I.fillRect(0, 0, B, B), I.fillStyle = e, de ? I.fill(new Path2D(J(Q, b))) : T.forEach(function(ne, re) {
+        ne.forEach(function(oe, se) {
+          oe && I.fillRect(se + b, re + b, 1, 1);
+        });
+      }), P && (I.globalAlpha = P.opacity), k && I.drawImage(F, P.x + b, P.y + b, P.w, P.h);
+    }
+  }), w.useEffect(() => {
+    O(!1);
+  }, [N]);
+  const te = z({
+    height: h,
+    width: h
+  }, E);
+  let _ = null;
+  return N != null && (_ = /* @__PURE__ */ w.createElement("img", {
+    src: N,
+    key: N,
+    style: { display: "none" },
+    onLoad: () => {
+      O(!0);
+    },
+    ref: d,
+    crossOrigin: P?.crossOrigin
+  })), /* @__PURE__ */ w.createElement(w.Fragment, null, /* @__PURE__ */ w.createElement("canvas", z({
+    style: te,
+    height: h,
+    width: h,
+    ref: R,
+    role: "img"
+  }, f)), _);
+});
+me.displayName = "QRCodeCanvas";
+var ge = w.forwardRef(function(l, s) {
+  const c = l, { value: g, size: h = x, level: p = X, bgColor: C = K, fgColor: e = j, includeMargin: n = W, minVersion: t = Z, boostLevel: r, title: o, marginSize: a, imageSettings: i } = c, E = U(c, [
+    "value",
+    "size",
+    "level",
+    "bgColor",
+    "fgColor",
+    "includeMargin",
+    "minVersion",
+    "boostLevel",
+    "title",
+    "marginSize",
+    "imageSettings"
+  ]), { margin: f, cells: N, numCells: A, calculatedImageSettings: d } = ee({
+    value: g,
+    level: p,
+    minVersion: t,
+    boostLevel: r,
+    includeMargin: n,
+    marginSize: a,
+    imageSettings: i,
+    size: h
+  });
+  let R = N, v = null;
+  i != null && d != null && (d.excavation != null && (R = q(N, d.excavation)), v = /* @__PURE__ */ w.createElement("image", {
+    href: i.src,
+    height: d.h,
+    width: d.w,
+    x: d.x + f,
+    y: d.y + f,
+    preserveAspectRatio: "none",
+    opacity: d.opacity,
+    crossOrigin: d.crossOrigin
+  }));
+  const O = J(R, f);
+  return /* @__PURE__ */ w.createElement("svg", z({
+    height: h,
+    width: h,
+    viewBox: `0 0 ${A} ${A}`,
+    ref: s,
+    role: "img"
+  }, E), !!o && /* @__PURE__ */ w.createElement("title", null, o), /* @__PURE__ */ w.createElement("path", {
+    fill: C,
+    d: `M0,0 h${A}v${A}H0z`,
+    shapeRendering: "crispEdges"
+  }), /* @__PURE__ */ w.createElement("path", {
+    fill: e,
+    d: O,
+    shapeRendering: "crispEdges"
+  }), v);
+});
+ge.displayName = "QRCodeSVG";
+export {
+  me as QRCodeCanvas,
+  ge as QRCodeSVG
+};