@xiping/react-components 1.0.18 → 1.0.19

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/kanji-data.js

@@ -0,0 +1,36 @@
+import { __require as u } from "./mode.js";
+import { __require as h } from "./utils.js";
+var a, n;
+function c() {
+  if (n) return a;
+  n = 1;
+  const o = u(), s = h();
+  function r(i) {
+    this.mode = o.KANJI, this.data = i;
+  }
+  return r.getBitsLength = function(e) {
+    return e * 13;
+  }, r.prototype.getLength = function() {
+    return this.data.length;
+  }, r.prototype.getBitsLength = function() {
+    return r.getBitsLength(this.data.length);
+  }, r.prototype.write = function(i) {
+    let e;
+    for (e = 0; e < this.data.length; e++) {
+      let t = s.toSJIS(this.data[e]);
+      if (t >= 33088 && t <= 40956)
+        t -= 33088;
+      else if (t >= 57408 && t <= 60351)
+        t -= 49472;
+      else
+        throw new Error(
+          "Invalid SJIS character: " + this.data[e] + `
+Make sure your charset is UTF-8`
+        );
+      t = (t >>> 8 & 255) * 192 + (t & 255), i.put(t, 13);
+    }
+  }, a = r, a;
+}
+export {
+  c as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/mask-pattern.js

@@ -0,0 +1,102 @@
+import { __exports as c } from "../../../../../../../_virtual/mask-pattern.js";
+var T;
+function R() {
+  return T ? c : (T = 1, function(r) {
+    r.Patterns = {
+      PATTERN000: 0,
+      PATTERN001: 1,
+      PATTERN010: 2,
+      PATTERN011: 3,
+      PATTERN100: 4,
+      PATTERN101: 5,
+      PATTERN110: 6,
+      PATTERN111: 7
+    };
+    const u = {
+      N1: 3,
+      N2: 3,
+      N3: 40,
+      N4: 10
+    };
+    r.isValid = function(t) {
+      return t != null && t !== "" && !isNaN(t) && t >= 0 && t <= 7;
+    }, r.from = function(t) {
+      return r.isValid(t) ? parseInt(t, 10) : void 0;
+    }, r.getPenaltyN1 = function(t) {
+      const l = t.size;
+      let s = 0, n = 0, e = 0, i = null, o = null;
+      for (let f = 0; f < l; f++) {
+        n = e = 0, i = o = null;
+        for (let N = 0; N < l; N++) {
+          let a = t.get(f, N);
+          a === i ? n++ : (n >= 5 && (s += u.N1 + (n - 5)), i = a, n = 1), a = t.get(N, f), a === o ? e++ : (e >= 5 && (s += u.N1 + (e - 5)), o = a, e = 1);
+        }
+        n >= 5 && (s += u.N1 + (n - 5)), e >= 5 && (s += u.N1 + (e - 5));
+      }
+      return s;
+    }, r.getPenaltyN2 = function(t) {
+      const l = t.size;
+      let s = 0;
+      for (let n = 0; n < l - 1; n++)
+        for (let e = 0; e < l - 1; e++) {
+          const i = t.get(n, e) + t.get(n, e + 1) + t.get(n + 1, e) + t.get(n + 1, e + 1);
+          (i === 4 || i === 0) && s++;
+        }
+      return s * u.N2;
+    }, r.getPenaltyN3 = function(t) {
+      const l = t.size;
+      let s = 0, n = 0, e = 0;
+      for (let i = 0; i < l; i++) {
+        n = e = 0;
+        for (let o = 0; o < l; o++)
+          n = n << 1 & 2047 | t.get(i, o), o >= 10 && (n === 1488 || n === 93) && s++, e = e << 1 & 2047 | t.get(o, i), o >= 10 && (e === 1488 || e === 93) && s++;
+      }
+      return s * u.N3;
+    }, r.getPenaltyN4 = function(t) {
+      let l = 0;
+      const s = t.data.length;
+      for (let e = 0; e < s; e++) l += t.data[e];
+      return Math.abs(Math.ceil(l * 100 / s / 5) - 10) * u.N4;
+    };
+    function g(P, t, l) {
+      switch (P) {
+        case r.Patterns.PATTERN000:
+          return (t + l) % 2 === 0;
+        case r.Patterns.PATTERN001:
+          return t % 2 === 0;
+        case r.Patterns.PATTERN010:
+          return l % 3 === 0;
+        case r.Patterns.PATTERN011:
+          return (t + l) % 3 === 0;
+        case r.Patterns.PATTERN100:
+          return (Math.floor(t / 2) + Math.floor(l / 3)) % 2 === 0;
+        case r.Patterns.PATTERN101:
+          return t * l % 2 + t * l % 3 === 0;
+        case r.Patterns.PATTERN110:
+          return (t * l % 2 + t * l % 3) % 2 === 0;
+        case r.Patterns.PATTERN111:
+          return (t * l % 3 + (t + l) % 2) % 2 === 0;
+        default:
+          throw new Error("bad maskPattern:" + P);
+      }
+    }
+    r.applyMask = function(t, l) {
+      const s = l.size;
+      for (let n = 0; n < s; n++)
+        for (let e = 0; e < s; e++)
+          l.isReserved(e, n) || l.xor(e, n, g(t, e, n));
+    }, r.getBestMask = function(t, l) {
+      const s = Object.keys(r.Patterns).length;
+      let n = 0, e = 1 / 0;
+      for (let i = 0; i < s; i++) {
+        l(i), r.applyMask(i, t);
+        const o = r.getPenaltyN1(t) + r.getPenaltyN2(t) + r.getPenaltyN3(t) + r.getPenaltyN4(t);
+        r.applyMask(i, t), o < e && (e = o, n = i);
+      }
+      return n;
+    };
+  }(c), c);
+}
+export {
+  R as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/mode.js

@@ -0,0 +1,68 @@
+import { __exports as c } from "../../../../../../../_virtual/mode.js";
+import { __require as o } from "./version-check.js";
+import { __require as s } from "./regex.js";
+var u;
+function E() {
+  return u ? c : (u = 1, function(i) {
+    const a = o(), e = s();
+    i.NUMERIC = {
+      id: "Numeric",
+      bit: 1,
+      ccBits: [10, 12, 14]
+    }, i.ALPHANUMERIC = {
+      id: "Alphanumeric",
+      bit: 2,
+      ccBits: [9, 11, 13]
+    }, i.BYTE = {
+      id: "Byte",
+      bit: 4,
+      ccBits: [8, 16, 16]
+    }, i.KANJI = {
+      id: "Kanji",
+      bit: 8,
+      ccBits: [8, 10, 12]
+    }, i.MIXED = {
+      bit: -1
+    }, i.getCharCountIndicator = function(r, n) {
+      if (!r.ccBits) throw new Error("Invalid mode: " + r);
+      if (!a.isValid(n))
+        throw new Error("Invalid version: " + n);
+      return n >= 1 && n < 10 ? r.ccBits[0] : n < 27 ? r.ccBits[1] : r.ccBits[2];
+    }, i.getBestModeForData = function(r) {
+      return e.testNumeric(r) ? i.NUMERIC : e.testAlphanumeric(r) ? i.ALPHANUMERIC : e.testKanji(r) ? i.KANJI : i.BYTE;
+    }, i.toString = function(r) {
+      if (r && r.id) return r.id;
+      throw new Error("Invalid mode");
+    }, i.isValid = function(r) {
+      return r && r.bit && r.ccBits;
+    };
+    function f(t) {
+      if (typeof t != "string")
+        throw new Error("Param is not a string");
+      switch (t.toLowerCase()) {
+        case "numeric":
+          return i.NUMERIC;
+        case "alphanumeric":
+          return i.ALPHANUMERIC;
+        case "kanji":
+          return i.KANJI;
+        case "byte":
+          return i.BYTE;
+        default:
+          throw new Error("Unknown mode: " + t);
+      }
+    }
+    i.from = function(r, n) {
+      if (i.isValid(r))
+        return r;
+      try {
+        return f(r);
+      } catch {
+        return n;
+      }
+    };
+  }(c), c);
+}
+export {
+  E as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/numeric-data.js

@@ -0,0 +1,26 @@
+import { __require as h } from "./mode.js";
+var u, s;
+function c() {
+  if (s) return u;
+  s = 1;
+  const g = h();
+  function t(i) {
+    this.mode = g.NUMERIC, this.data = i.toString();
+  }
+  return t.getBitsLength = function(e) {
+    return 10 * Math.floor(e / 3) + (e % 3 ? e % 3 * 3 + 1 : 0);
+  }, t.prototype.getLength = function() {
+    return this.data.length;
+  }, t.prototype.getBitsLength = function() {
+    return t.getBitsLength(this.data.length);
+  }, t.prototype.write = function(e) {
+    let r, n, a;
+    for (r = 0; r + 3 <= this.data.length; r += 3)
+      n = this.data.substr(r, 3), a = parseInt(n, 10), e.put(a, 10);
+    const o = this.data.length - r;
+    o > 0 && (n = this.data.substr(r), a = parseInt(n, 10), e.put(a, o * 3 + 1));
+  }, u = t, u;
+}
+export {
+  c as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/polynomial.js

@@ -0,0 +1,34 @@
+import { __exports as f } from "../../../../../../../_virtual/polynomial.js";
+import { __require as c } from "./galois-field.js";
+var m;
+function y() {
+  return m ? f : (m = 1, function(o) {
+    const u = c();
+    o.mul = function(t, n) {
+      const e = new Uint8Array(t.length + n.length - 1);
+      for (let r = 0; r < t.length; r++)
+        for (let l = 0; l < n.length; l++)
+          e[r + l] ^= u.mul(t[r], n[l]);
+      return e;
+    }, o.mod = function(t, n) {
+      let e = new Uint8Array(t);
+      for (; e.length - n.length >= 0; ) {
+        const r = e[0];
+        for (let i = 0; i < n.length; i++)
+          e[i] ^= u.mul(n[i], r);
+        let l = 0;
+        for (; l < e.length && e[l] === 0; ) l++;
+        e = e.slice(l);
+      }
+      return e;
+    }, o.generateECPolynomial = function(t) {
+      let n = new Uint8Array([1]);
+      for (let e = 0; e < t; e++)
+        n = o.mul(n, new Uint8Array([1, u.exp(e)]));
+      return n;
+    };
+  }(f), f);
+}
+export {
+  y as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/qrcode.js

@@ -0,0 +1,154 @@
+import { __exports as M } from "../../../../../../../_virtual/qrcode.js";
+import { __require as Y } from "./utils.js";
+import { __require as Z } from "./error-correction-level.js";
+import { __require as $ } from "./bit-buffer.js";
+import { __require as x } from "./bit-matrix.js";
+import { __require as v } from "./alignment-pattern.js";
+import { __require as ee } from "./finder-pattern.js";
+import { __require as te } from "./mask-pattern.js";
+import { __require as oe } from "./error-correction-code.js";
+import { __require as re } from "./reed-solomon-encoder.js";
+import { __require as ne } from "./version.js";
+import { __require as se } from "./format-info.js";
+import { __require as ie } from "./mode.js";
+import { __require as ue } from "./segments.js";
+var F;
+function Be() {
+  if (F) return M;
+  F = 1;
+  const g = Y(), q = Z(), A = $(), k = x(), P = v(), D = ee(), _ = te(), h = oe(), V = re(), w = ne(), R = se(), G = ie(), C = ue();
+  function Q(r, u) {
+    const n = r.size, e = D.getPositions(u);
+    for (let c = 0; c < e.length; c++) {
+      const t = e[c][0], o = e[c][1];
+      for (let i = -1; i <= 7; i++)
+        if (!(t + i <= -1 || n <= t + i))
+          for (let s = -1; s <= 7; s++)
+            o + s <= -1 || n <= o + s || (i >= 0 && i <= 6 && (s === 0 || s === 6) || s >= 0 && s <= 6 && (i === 0 || i === 6) || i >= 2 && i <= 4 && s >= 2 && s <= 4 ? r.set(t + i, o + s, !0, !0) : r.set(t + i, o + s, !1, !0));
+    }
+  }
+  function U(r) {
+    const u = r.size;
+    for (let n = 8; n < u - 8; n++) {
+      const e = n % 2 === 0;
+      r.set(n, 6, e, !0), r.set(6, n, e, !0);
+    }
+  }
+  function J(r, u) {
+    const n = P.getPositions(u);
+    for (let e = 0; e < n.length; e++) {
+      const c = n[e][0], t = n[e][1];
+      for (let o = -2; o <= 2; o++)
+        for (let i = -2; i <= 2; i++)
+          o === -2 || o === 2 || i === -2 || i === 2 || o === 0 && i === 0 ? r.set(c + o, t + i, !0, !0) : r.set(c + o, t + i, !1, !0);
+    }
+  }
+  function N(r, u) {
+    const n = r.size, e = w.getEncodedBits(u);
+    let c, t, o;
+    for (let i = 0; i < 18; i++)
+      c = Math.floor(i / 3), t = i % 3 + n - 8 - 3, o = (e >> i & 1) === 1, r.set(c, t, o, !0), r.set(t, c, o, !0);
+  }
+  function b(r, u, n) {
+    const e = r.size, c = R.getEncodedBits(u, n);
+    let t, o;
+    for (t = 0; t < 15; t++)
+      o = (c >> t & 1) === 1, t < 6 ? r.set(t, 8, o, !0) : t < 8 ? r.set(t + 1, 8, o, !0) : r.set(e - 15 + t, 8, o, !0), t < 8 ? r.set(8, e - t - 1, o, !0) : t < 9 ? r.set(8, 15 - t - 1 + 1, o, !0) : r.set(8, 15 - t - 1, o, !0);
+    r.set(e - 8, 8, 1, !0);
+  }
+  function L(r, u) {
+    const n = r.size;
+    let e = -1, c = n - 1, t = 7, o = 0;
+    for (let i = n - 1; i > 0; i -= 2)
+      for (i === 6 && i--; ; ) {
+        for (let s = 0; s < 2; s++)
+          if (!r.isReserved(c, i - s)) {
+            let a = !1;
+            o < u.length && (a = (u[o] >>> t & 1) === 1), r.set(c, i - s, a), t--, t === -1 && (o++, t = 7);
+          }
+        if (c += e, c < 0 || n <= c) {
+          c -= e, e = -e;
+          break;
+        }
+      }
+  }
+  function j(r, u, n) {
+    const e = new A();
+    n.forEach(function(s) {
+      e.put(s.mode.bit, 4), e.put(s.getLength(), G.getCharCountIndicator(s.mode, r)), s.write(e);
+    });
+    const c = g.getSymbolTotalCodewords(r), t = h.getTotalCodewordsCount(r, u), o = (c - t) * 8;
+    for (e.getLengthInBits() + 4 <= o && e.put(0, 4); e.getLengthInBits() % 8 !== 0; )
+      e.putBit(0);
+    const i = (o - e.getLengthInBits()) / 8;
+    for (let s = 0; s < i; s++)
+      e.put(s % 2 ? 17 : 236, 8);
+    return H(e, r, u);
+  }
+  function H(r, u, n) {
+    const e = g.getSymbolTotalCodewords(u), c = h.getTotalCodewordsCount(u, n), t = e - c, o = h.getBlocksCount(u, n), i = e % o, s = o - i, a = Math.floor(e / o), m = Math.floor(t / o), O = m + 1, E = a - m, W = new V(E);
+    let B = 0;
+    const p = new Array(o), z = new Array(o);
+    let S = 0;
+    const X = new Uint8Array(r.buffer);
+    for (let d = 0; d < o; d++) {
+      const y = d < s ? m : O;
+      p[d] = X.slice(B, B + y), z[d] = W.encode(p[d]), B += y, S = Math.max(S, y);
+    }
+    const I = new Uint8Array(e);
+    let T = 0, f, l;
+    for (f = 0; f < S; f++)
+      for (l = 0; l < o; l++)
+        f < p[l].length && (I[T++] = p[l][f]);
+    for (f = 0; f < E; f++)
+      for (l = 0; l < o; l++)
+        I[T++] = z[l][f];
+    return I;
+  }
+  function K(r, u, n, e) {
+    let c;
+    if (Array.isArray(r))
+      c = C.fromArray(r);
+    else if (typeof r == "string") {
+      let a = u;
+      if (!a) {
+        const m = C.rawSplit(r);
+        a = w.getBestVersionForData(m, n);
+      }
+      c = C.fromString(r, a || 40);
+    } else
+      throw new Error("Invalid data");
+    const t = w.getBestVersionForData(c, n);
+    if (!t)
+      throw new Error("The amount of data is too big to be stored in a QR Code");
+    if (!u)
+      u = t;
+    else if (u < t)
+      throw new Error(
+        `
+The chosen QR Code version cannot contain this amount of data.
+Minimum version required to store current data is: ` + t + `.
+`
+      );
+    const o = j(u, n, c), i = g.getSymbolSize(u), s = new k(i);
+    return Q(s, u), U(s), J(s, u), b(s, n, 0), u >= 7 && N(s, u), L(s, o), isNaN(e) && (e = _.getBestMask(
+      s,
+      b.bind(null, s, n)
+    )), _.applyMask(e, s), b(s, n, e), {
+      modules: s,
+      version: u,
+      errorCorrectionLevel: n,
+      maskPattern: e,
+      segments: c
+    };
+  }
+  return M.create = function(u, n) {
+    if (typeof u > "u" || u === "")
+      throw new Error("No input text");
+    let e = q.M, c, t;
+    return typeof n < "u" && (e = q.from(n.errorCorrectionLevel, q.M), c = w.from(n.version), t = _.from(n.maskPattern), n.toSJISFunc && g.setToSJISFunction(n.toSJISFunc)), K(u, c, e, t);
+  }, M;
+}
+export {
+  Be as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/reed-solomon-encoder.js

@@ -0,0 +1,27 @@
+import { __require as h } from "./polynomial.js";
+var o, a;
+function g() {
+  if (a) return o;
+  a = 1;
+  const t = h();
+  function n(i) {
+    this.genPoly = void 0, this.degree = i, this.degree && this.initialize(this.degree);
+  }
+  return n.prototype.initialize = function(e) {
+    this.degree = e, this.genPoly = t.generateECPolynomial(this.degree);
+  }, n.prototype.encode = function(e) {
+    if (!this.genPoly)
+      throw new Error("Encoder not initialized");
+    const d = new Uint8Array(e.length + this.degree);
+    d.set(e);
+    const r = t.mod(d, this.genPoly), s = this.degree - r.length;
+    if (s > 0) {
+      const l = new Uint8Array(this.degree);
+      return l.set(r, s), l;
+    }
+    return r;
+  }, o = n, o;
+}
+export {
+  g as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/regex.js

@@ -0,0 +1,23 @@
+import { __exports as e } from "../../../../../../../_virtual/regex.js";
+var s;
+function R() {
+  if (s) return e;
+  s = 1;
+  const n = "[0-9]+", E = "[A-Z $%*+\\-./:]+";
+  let u = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+  u = u.replace(/u/g, "\\u");
+  const i = "(?:(?![A-Z0-9 $%*+\\-./:]|" + u + `)(?:.|[\r
+]))+`;
+  e.KANJI = new RegExp(u, "g"), e.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g"), e.BYTE = new RegExp(i, "g"), e.NUMERIC = new RegExp(n, "g"), e.ALPHANUMERIC = new RegExp(E, "g");
+  const c = new RegExp("^" + u + "$"), g = new RegExp("^" + n + "$"), A = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+  return e.testKanji = function(t) {
+    return c.test(t);
+  }, e.testNumeric = function(t) {
+    return g.test(t);
+  }, e.testAlphanumeric = function(t) {
+    return A.test(t);
+  }, e;
+}
+export {
+  R as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/segments.js

@@ -0,0 +1,146 @@
+import { __exports as N } from "../../../../../../../_virtual/segments.js";
+import { __require as T } from "./mode.js";
+import { __require as Y } from "./numeric-data.js";
+import { __require as L } from "./alphanumeric-data.js";
+import { __require as y } from "./byte-data.js";
+import { __require as D } from "./kanji-data.js";
+import { __require as j } from "./regex.js";
+import { __require as k } from "./utils.js";
+import { __require as J } from "../../../../../dijkstrajs@1.0.3/node_modules/dijkstrajs/dijkstra.js";
+var b;
+function V() {
+  return b ? N : (b = 1, function(m) {
+    const r = T(), I = Y(), B = L(), _ = y(), q = D(), c = j(), p = k(), R = J();
+    function C(n) {
+      return unescape(encodeURIComponent(n)).length;
+    }
+    function h(n, o, t) {
+      const e = [];
+      let s;
+      for (; (s = n.exec(t)) !== null; )
+        e.push({
+          data: s[0],
+          index: s.index,
+          mode: o,
+          length: s[0].length
+        });
+      return e;
+    }
+    function M(n) {
+      const o = h(c.NUMERIC, r.NUMERIC, n), t = h(c.ALPHANUMERIC, r.ALPHANUMERIC, n);
+      let e, s;
+      return p.isKanjiModeEnabled() ? (e = h(c.BYTE, r.BYTE, n), s = h(c.KANJI, r.KANJI, n)) : (e = h(c.BYTE_KANJI, r.BYTE, n), s = []), o.concat(t, e, s).sort(function(a, l) {
+        return a.index - l.index;
+      }).map(function(a) {
+        return {
+          data: a.data,
+          mode: a.mode,
+          length: a.length
+        };
+      });
+    }
+    function E(n, o) {
+      switch (o) {
+        case r.NUMERIC:
+          return I.getBitsLength(n);
+        case r.ALPHANUMERIC:
+          return B.getBitsLength(n);
+        case r.KANJI:
+          return q.getBitsLength(n);
+        case r.BYTE:
+          return _.getBitsLength(n);
+      }
+    }
+    function U(n) {
+      return n.reduce(function(o, t) {
+        const e = o.length - 1 >= 0 ? o[o.length - 1] : null;
+        return e && e.mode === t.mode ? (o[o.length - 1].data += t.data, o) : (o.push(t), o);
+      }, []);
+    }
+    function w(n) {
+      const o = [];
+      for (let t = 0; t < n.length; t++) {
+        const e = n[t];
+        switch (e.mode) {
+          case r.NUMERIC:
+            o.push([
+              e,
+              { data: e.data, mode: r.ALPHANUMERIC, length: e.length },
+              { data: e.data, mode: r.BYTE, length: e.length }
+            ]);
+            break;
+          case r.ALPHANUMERIC:
+            o.push([
+              e,
+              { data: e.data, mode: r.BYTE, length: e.length }
+            ]);
+            break;
+          case r.KANJI:
+            o.push([
+              e,
+              { data: e.data, mode: r.BYTE, length: C(e.data) }
+            ]);
+            break;
+          case r.BYTE:
+            o.push([
+              { data: e.data, mode: r.BYTE, length: C(e.data) }
+            ]);
+        }
+      }
+      return o;
+    }
+    function K(n, o) {
+      const t = {}, e = { start: {} };
+      let s = ["start"];
+      for (let i = 0; i < n.length; i++) {
+        const a = n[i], l = [];
+        for (let g = 0; g < a.length; g++) {
+          const u = a[g], f = "" + i + g;
+          l.push(f), t[f] = { node: u, lastCount: 0 }, e[f] = {};
+          for (let A = 0; A < s.length; A++) {
+            const d = s[A];
+            t[d] && t[d].node.mode === u.mode ? (e[d][f] = E(t[d].lastCount + u.length, u.mode) - E(t[d].lastCount, u.mode), t[d].lastCount += u.length) : (t[d] && (t[d].lastCount = u.length), e[d][f] = E(u.length, u.mode) + 4 + r.getCharCountIndicator(u.mode, o));
+          }
+        }
+        s = l;
+      }
+      for (let i = 0; i < s.length; i++)
+        e[s[i]].end = 0;
+      return { map: e, table: t };
+    }
+    function S(n, o) {
+      let t;
+      const e = r.getBestModeForData(n);
+      if (t = r.from(o, e), t !== r.BYTE && t.bit < e.bit)
+        throw new Error('"' + n + '" cannot be encoded with mode ' + r.toString(t) + `.
+ Suggested mode is: ` + r.toString(e));
+      switch (t === r.KANJI && !p.isKanjiModeEnabled() && (t = r.BYTE), t) {
+        case r.NUMERIC:
+          return new I(n);
+        case r.ALPHANUMERIC:
+          return new B(n);
+        case r.KANJI:
+          return new q(n);
+        case r.BYTE:
+          return new _(n);
+      }
+    }
+    m.fromArray = function(o) {
+      return o.reduce(function(t, e) {
+        return typeof e == "string" ? t.push(S(e, null)) : e.data && t.push(S(e.data, e.mode)), t;
+      }, []);
+    }, m.fromString = function(o, t) {
+      const e = M(o, p.isKanjiModeEnabled()), s = w(e), i = K(s, t), a = R.find_path(i.map, "start", "end"), l = [];
+      for (let g = 1; g < a.length - 1; g++)
+        l.push(i.table[a[g]].node);
+      return m.fromArray(U(l));
+    }, m.rawSplit = function(o) {
+      return m.fromArray(
+        M(o, p.isKanjiModeEnabled())
+      );
+    };
+  }(N), N);
+}
+export {
+  V as __require
+};

package/dist/es/node_modules/.pnpm/qrcode@1.5.4/node_modules/qrcode/lib/core/utils.js

@@ -0,0 +1,74 @@
+import { __exports as n } from "../../../../../../../_virtual/utils.js";
+var r;
+function S() {
+  if (r) return n;
+  r = 1;
+  let e;
+  const i = [
+    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 n.getSymbolSize = function(t) {
+    if (!t) throw new Error('"version" cannot be null or undefined');
+    if (t < 1 || t > 40) throw new Error('"version" should be in range from 1 to 40');
+    return t * 4 + 17;
+  }, n.getSymbolTotalCodewords = function(t) {
+    return i[t];
+  }, n.getBCHDigit = function(o) {
+    let t = 0;
+    for (; o !== 0; )
+      t++, o >>>= 1;
+    return t;
+  }, n.setToSJISFunction = function(t) {
+    if (typeof t != "function")
+      throw new Error('"toSJISFunc" is not a valid function.');
+    e = t;
+  }, n.isKanjiModeEnabled = function() {
+    return typeof e < "u";
+  }, n.toSJIS = function(t) {
+    return e(t);
+  }, n;
+}
+export {
+  S as __require
+};