@fewangsit/wangsvue-fats 1.0.1-alpha.8 → 1.0.1-rc.0

package/vendor/qrcode/lib/core/kanji-data.es.js

@@ -0,0 +1,36 @@
+import { r as h } from "./mode.es.js";
+import { r as u } from "./utils.es.js";
+var a, n;
+function c() {
+  if (n) return a;
+  n = 1;
+  const o = h(), s = u();
+  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 r
+};

package/vendor/qrcode/lib/core/mask-pattern.es.js

@@ -0,0 +1,101 @@
+var c = {}, T;
+function y() {
+  return T || (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, P = null, i = null;
+      for (let N = 0; N < l; N++) {
+        n = e = 0, P = i = null;
+        for (let f = 0; f < l; f++) {
+          let a = t.get(N, f);
+          a === P ? n++ : (n >= 5 && (s += u.N1 + (n - 5)), P = a, n = 1), a = t.get(f, N), a === i ? e++ : (e >= 5 && (s += u.N1 + (e - 5)), i = 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 P = t.get(n, e) + t.get(n, e + 1) + t.get(n + 1, e) + t.get(n + 1, e + 1);
+          (P === 4 || P === 0) && s++;
+        }
+      return s * u.N2;
+    }, r.getPenaltyN3 = function(t) {
+      const l = t.size;
+      let s = 0, n = 0, e = 0;
+      for (let P = 0; P < l; P++) {
+        n = e = 0;
+        for (let i = 0; i < l; i++)
+          n = n << 1 & 2047 | t.get(P, i), i >= 10 && (n === 1488 || n === 93) && s++, e = e << 1 & 2047 | t.get(i, P), i >= 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(o, t, l) {
+      switch (o) {
+        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:" + o);
+      }
+    }
+    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 P = 0; P < s; P++) {
+        l(P), r.applyMask(P, t);
+        const i = r.getPenaltyN1(t) + r.getPenaltyN2(t) + r.getPenaltyN3(t) + r.getPenaltyN4(t);
+        r.applyMask(P, t), i < e && (e = i, n = P);
+      }
+      return n;
+    };
+  }(c)), c;
+}
+export {
+  y as r
+};

package/vendor/qrcode/lib/core/mode.es.js

@@ -0,0 +1,67 @@
+import { r as o } from "./version-check.es.js";
+import { r as s } from "./regex.es.js";
+var c = {}, u;
+function B() {
+  return u || (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 {
+  B as r
+};

package/vendor/qrcode/lib/core/numeric-data.es.js

@@ -0,0 +1,26 @@
+import { r as h } from "./mode.es.js";
+var o, u;
+function c() {
+  if (u) return o;
+  u = 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 s = this.data.length - r;
+    s > 0 && (n = this.data.substr(r), a = parseInt(n, 10), e.put(a, s * 3 + 1));
+  }, o = t, o;
+}
+export {
+  c as r
+};

package/vendor/qrcode/lib/core/polynomial.es.js

@@ -0,0 +1,33 @@
+import { r as c } from "./galois-field.es.js";
+var a = {}, m;
+function g() {
+  return m || (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;
+    };
+  }(a)), a;
+}
+export {
+  g as r
+};

package/vendor/qrcode/lib/core/qrcode.es.js

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

package/vendor/qrcode/lib/core/reed-solomon-encoder.es.js

@@ -0,0 +1,27 @@
+import { r as h } from "./polynomial.es.js";
+var r, a;
+function g() {
+  if (a) return r;
+  a = 1;
+  const t = h();
+  function n(o) {
+    this.genPoly = void 0, this.degree = o, 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 i = t.mod(d, this.genPoly), s = this.degree - i.length;
+    if (s > 0) {
+      const l = new Uint8Array(this.degree);
+      return l.set(i, s), l;
+    }
+    return i;
+  }, r = n, r;
+}
+export {
+  g as r
+};

package/vendor/qrcode/lib/core/regex.es.js

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

package/vendor/qrcode/lib/core/segments.es.js

@@ -0,0 +1,145 @@
+import { r as L } from "./mode.es.js";
+import { r as q } from "./numeric-data.es.js";
+import { r as y } from "./alphanumeric-data.es.js";
+import { r as D } from "./byte-data.es.js";
+import { r as j } from "./kanji-data.es.js";
+import { r as k } from "./regex.es.js";
+import { r as J } from "./utils.es.js";
+import { r as H } from "../../../dijkstrajs/dijkstra.es.js";
+var N = {}, U;
+function Q() {
+  return U || (U = 1, function(m) {
+    const r = L(), I = q(), B = y(), C = D(), M = j(), c = k(), p = J(), w = H();
+    function S(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 b(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(i, l) {
+        return i.index - l.index;
+      }).map(function(i) {
+        return {
+          data: i.data,
+          mode: i.mode,
+          length: i.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 M.getBitsLength(n);
+        case r.BYTE:
+          return C.getBitsLength(n);
+      }
+    }
+    function K(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 T(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: S(e.data) }
+            ]);
+            break;
+          case r.BYTE:
+            o.push([
+              { data: e.data, mode: r.BYTE, length: S(e.data) }
+            ]);
+        }
+      }
+      return o;
+    }
+    function Y(n, o) {
+      const t = {}, e = { start: {} };
+      let s = ["start"];
+      for (let a = 0; a < n.length; a++) {
+        const i = n[a], l = [];
+        for (let g = 0; g < i.length; g++) {
+          const u = i[g], f = "" + a + 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 a = 0; a < s.length; a++)
+        e[s[a]].end = 0;
+      return { map: e, table: t };
+    }
+    function R(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 M(n);
+        case r.BYTE:
+          return new C(n);
+      }
+    }
+    m.fromArray = function(o) {
+      return o.reduce(function(t, e) {
+        return typeof e == "string" ? t.push(R(e, null)) : e.data && t.push(R(e.data, e.mode)), t;
+      }, []);
+    }, m.fromString = function(o, t) {
+      const e = b(o, p.isKanjiModeEnabled()), s = T(e), a = Y(s, t), i = w.find_path(a.map, "start", "end"), l = [];
+      for (let g = 1; g < i.length - 1; g++)
+        l.push(a.table[i[g]].node);
+      return m.fromArray(K(l));
+    }, m.rawSplit = function(o) {
+      return m.fromArray(
+        b(o, p.isKanjiModeEnabled())
+      );
+    };
+  }(N)), N;
+}
+export {
+  Q as r
+};

package/vendor/qrcode/lib/core/utils.es.js

@@ -0,0 +1,73 @@
+var n = {}, r;
+function u() {
+  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 {
+  u as r
+};

package/vendor/qrcode/lib/core/version-check.es.js

@@ -0,0 +1,9 @@
+var e = {}, i;
+function a() {
+  return i || (i = 1, e.isValid = function(r) {
+    return !isNaN(r) && r >= 1 && r <= 40;
+  }), e;
+}
+export {
+  a as r
+};