@fewangsit/wangsvue-fats 1.0.1-rc.5 → 1.0.1-rc.7

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

@@ -0,0 +1,43 @@
+import { r as q } from "./can-promise.es.js";
+import { r as R } from "./core/qrcode.es.js";
+import { r as y } from "./renderer/canvas.es.js";
+import { r as T } from "./renderer/svg-tag.es.js";
+var t = {}, w;
+function B() {
+  if (w) return t;
+  w = 1;
+  const c = q(), f = R(), s = y(), C = T();
+  function a(u, r, e, n, o) {
+    const m = [].slice.call(arguments, 1), i = m.length, g = typeof m[i - 1] == "function";
+    if (!g && !c())
+      throw new Error("Callback required as last argument");
+    if (g) {
+      if (i < 2)
+        throw new Error("Too few arguments provided");
+      i === 2 ? (o = e, e = r, r = n = void 0) : i === 3 && (r.getContext && typeof o > "u" ? (o = n, n = void 0) : (o = n, n = e, e = r, r = void 0));
+    } else {
+      if (i < 1)
+        throw new Error("Too few arguments provided");
+      return i === 1 ? (e = r, r = n = void 0) : i === 2 && !r.getContext && (n = e, e = r, r = void 0), new Promise(function(d, h) {
+        try {
+          const l = f.create(e, n);
+          d(u(l, r, n));
+        } catch (l) {
+          h(l);
+        }
+      });
+    }
+    try {
+      const d = f.create(e, n);
+      o(null, u(d, r, n));
+    } catch (d) {
+      o(d);
+    }
+  }
+  return t.create = f.create, t.toCanvas = a.bind(null, s.render), t.toDataURL = a.bind(null, s.renderToDataURL), t.toString = a.bind(null, function(u, r, e) {
+    return C.render(u, e);
+  }), t;
+}
+export {
+  B as r
+};

package/vendor/qrcode/lib/can-promise.es.js

@@ -0,0 +1,9 @@
+var r, e;
+function o() {
+  return e || (e = 1, r = function() {
+    return typeof Promise == "function" && Promise.prototype && Promise.prototype.then;
+  }), r;
+}
+export {
+  o as r
+};

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

@@ -0,0 +1,25 @@
+import { r as f } from "./utils.es.js";
+var l = {}, u;
+function h() {
+  return u || (u = 1, function(s) {
+    const c = f().getSymbolSize;
+    s.getRowColCoords = function(r) {
+      if (r === 1) return [];
+      const i = Math.floor(r / 7) + 2, n = c(r), e = n === 145 ? 26 : Math.ceil((n - 13) / (2 * i - 2)) * 2, t = [n - 7];
+      for (let o = 1; o < i - 1; o++)
+        t[o] = t[o - 1] - e;
+      return t.push(6), t.reverse();
+    }, s.getPositions = function(r) {
+      const i = [], n = s.getRowColCoords(r), e = n.length;
+      for (let t = 0; t < e; t++)
+        for (let o = 0; o < e; o++)
+          t === 0 && o === 0 || // top-left
+          t === 0 && o === e - 1 || // bottom-left
+          t === e - 1 && o === 0 || i.push([n[t], n[o]]);
+      return i;
+    };
+  }(l)), l;
+}
+export {
+  h as r
+};

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

@@ -0,0 +1,73 @@
+import { r as s } from "./mode.es.js";
+var r, o;
+function d() {
+  if (o) return r;
+  o = 1;
+  const u = s(), i = [
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    " ",
+    "$",
+    "%",
+    "*",
+    "+",
+    "-",
+    ".",
+    "/",
+    ":"
+  ];
+  function t(a) {
+    this.mode = u.ALPHANUMERIC, this.data = a;
+  }
+  return t.getBitsLength = function(n) {
+    return 11 * Math.floor(n / 2) + 6 * (n % 2);
+  }, t.prototype.getLength = function() {
+    return this.data.length;
+  }, t.prototype.getBitsLength = function() {
+    return t.getBitsLength(this.data.length);
+  }, t.prototype.write = function(n) {
+    let e;
+    for (e = 0; e + 2 <= this.data.length; e += 2) {
+      let h = i.indexOf(this.data[e]) * 45;
+      h += i.indexOf(this.data[e + 1]), n.put(h, 11);
+    }
+    this.data.length % 2 && n.put(i.indexOf(this.data[e]), 6);
+  }, r = t, r;
+}
+export {
+  d as r
+};

package/vendor/qrcode/lib/core/bit-buffer.es.js

@@ -0,0 +1,28 @@
+var i, u;
+function n() {
+  if (u) return i;
+  u = 1;
+  function r() {
+    this.buffer = [], this.length = 0;
+  }
+  return r.prototype = {
+    get: function(f) {
+      const t = Math.floor(f / 8);
+      return (this.buffer[t] >>> 7 - f % 8 & 1) === 1;
+    },
+    put: function(f, t) {
+      for (let e = 0; e < t; e++)
+        this.putBit((f >>> t - e - 1 & 1) === 1);
+    },
+    getLengthInBits: function() {
+      return this.length;
+    },
+    putBit: function(f) {
+      const t = Math.floor(this.length / 8);
+      this.buffer.length <= t && this.buffer.push(0), f && (this.buffer[t] |= 128 >>> this.length % 8), this.length++;
+    }
+  }, i = r, i;
+}
+export {
+  n as r
+};

package/vendor/qrcode/lib/core/bit-matrix.es.js

@@ -0,0 +1,23 @@
+var n, s;
+function h() {
+  if (s) return n;
+  s = 1;
+  function i(t) {
+    if (!t || t < 1)
+      throw new Error("BitMatrix size must be defined and greater than 0");
+    this.size = t, this.data = new Uint8Array(t * t), this.reservedBit = new Uint8Array(t * t);
+  }
+  return i.prototype.set = function(t, r, e, o) {
+    const a = t * this.size + r;
+    this.data[a] = e, o && (this.reservedBit[a] = !0);
+  }, i.prototype.get = function(t, r) {
+    return this.data[t * this.size + r];
+  }, i.prototype.xor = function(t, r, e) {
+    this.data[t * this.size + r] ^= e;
+  }, i.prototype.isReserved = function(t, r) {
+    return this.reservedBit[t * this.size + r];
+  }, n = i, n;
+}
+export {
+  h as r
+};

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

@@ -0,0 +1,23 @@
+import { r as g } from "./mode.es.js";
+var r, i;
+function s() {
+  if (i) return r;
+  i = 1;
+  const o = g();
+  function e(t) {
+    this.mode = o.BYTE, typeof t == "string" ? this.data = new TextEncoder().encode(t) : this.data = new Uint8Array(t);
+  }
+  return e.getBitsLength = function(n) {
+    return n * 8;
+  }, e.prototype.getLength = function() {
+    return this.data.length;
+  }, e.prototype.getBitsLength = function() {
+    return e.getBitsLength(this.data.length);
+  }, e.prototype.write = function(t) {
+    for (let n = 0, a = this.data.length; n < a; n++)
+      t.put(this.data[n], 8);
+  }, r = e, r;
+}
+export {
+  s as r
+};

package/vendor/qrcode/lib/core/error-correction-code.es.js

@@ -0,0 +1,361 @@
+import { r as a } from "./error-correction-level.es.js";
+var n = {}, c;
+function s() {
+  if (c) return n;
+  c = 1;
+  const e = a(), t = [
+    // L  M  Q  H
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    1,
+    2,
+    2,
+    4,
+    1,
+    2,
+    4,
+    4,
+    2,
+    4,
+    4,
+    4,
+    2,
+    4,
+    6,
+    5,
+    2,
+    4,
+    6,
+    6,
+    2,
+    5,
+    8,
+    8,
+    4,
+    5,
+    8,
+    8,
+    4,
+    5,
+    8,
+    11,
+    4,
+    8,
+    10,
+    11,
+    4,
+    9,
+    12,
+    16,
+    4,
+    9,
+    16,
+    16,
+    6,
+    10,
+    12,
+    18,
+    6,
+    10,
+    17,
+    16,
+    6,
+    11,
+    16,
+    19,
+    6,
+    13,
+    18,
+    21,
+    7,
+    14,
+    21,
+    25,
+    8,
+    16,
+    20,
+    25,
+    8,
+    17,
+    23,
+    25,
+    9,
+    17,
+    23,
+    34,
+    9,
+    18,
+    25,
+    30,
+    10,
+    20,
+    27,
+    32,
+    12,
+    21,
+    29,
+    35,
+    12,
+    23,
+    34,
+    37,
+    12,
+    25,
+    34,
+    40,
+    13,
+    26,
+    35,
+    42,
+    14,
+    28,
+    38,
+    45,
+    15,
+    29,
+    40,
+    48,
+    16,
+    31,
+    43,
+    51,
+    17,
+    33,
+    45,
+    54,
+    18,
+    35,
+    48,
+    57,
+    19,
+    37,
+    51,
+    60,
+    19,
+    38,
+    53,
+    63,
+    20,
+    40,
+    56,
+    66,
+    21,
+    43,
+    59,
+    70,
+    22,
+    45,
+    62,
+    74,
+    24,
+    47,
+    65,
+    77,
+    25,
+    49,
+    68,
+    81
+  ], o = [
+    // L  M  Q  H
+    7,
+    10,
+    13,
+    17,
+    10,
+    16,
+    22,
+    28,
+    15,
+    26,
+    36,
+    44,
+    20,
+    36,
+    52,
+    64,
+    26,
+    48,
+    72,
+    88,
+    36,
+    64,
+    96,
+    112,
+    40,
+    72,
+    108,
+    130,
+    48,
+    88,
+    132,
+    156,
+    60,
+    110,
+    160,
+    192,
+    72,
+    130,
+    192,
+    224,
+    80,
+    150,
+    224,
+    264,
+    96,
+    176,
+    260,
+    308,
+    104,
+    198,
+    288,
+    352,
+    120,
+    216,
+    320,
+    384,
+    132,
+    240,
+    360,
+    432,
+    144,
+    280,
+    408,
+    480,
+    168,
+    308,
+    448,
+    532,
+    180,
+    338,
+    504,
+    588,
+    196,
+    364,
+    546,
+    650,
+    224,
+    416,
+    600,
+    700,
+    224,
+    442,
+    644,
+    750,
+    252,
+    476,
+    690,
+    816,
+    270,
+    504,
+    750,
+    900,
+    300,
+    560,
+    810,
+    960,
+    312,
+    588,
+    870,
+    1050,
+    336,
+    644,
+    952,
+    1110,
+    360,
+    700,
+    1020,
+    1200,
+    390,
+    728,
+    1050,
+    1260,
+    420,
+    784,
+    1140,
+    1350,
+    450,
+    812,
+    1200,
+    1440,
+    480,
+    868,
+    1290,
+    1530,
+    510,
+    924,
+    1350,
+    1620,
+    540,
+    980,
+    1440,
+    1710,
+    570,
+    1036,
+    1530,
+    1800,
+    570,
+    1064,
+    1590,
+    1890,
+    600,
+    1120,
+    1680,
+    1980,
+    630,
+    1204,
+    1770,
+    2100,
+    660,
+    1260,
+    1860,
+    2220,
+    720,
+    1316,
+    1950,
+    2310,
+    750,
+    1372,
+    2040,
+    2430
+  ];
+  return n.getBlocksCount = function(r, u) {
+    switch (u) {
+      case e.L:
+        return t[(r - 1) * 4 + 0];
+      case e.M:
+        return t[(r - 1) * 4 + 1];
+      case e.Q:
+        return t[(r - 1) * 4 + 2];
+      case e.H:
+        return t[(r - 1) * 4 + 3];
+      default:
+        return;
+    }
+  }, n.getTotalCodewordsCount = function(r, u) {
+    switch (u) {
+      case e.L:
+        return o[(r - 1) * 4 + 0];
+      case e.M:
+        return o[(r - 1) * 4 + 1];
+      case e.Q:
+        return o[(r - 1) * 4 + 2];
+      case e.H:
+        return o[(r - 1) * 4 + 3];
+      default:
+        return;
+    }
+  }, n;
+}
+export {
+  s as r
+};

package/vendor/qrcode/lib/core/error-correction-level.es.js

@@ -0,0 +1,40 @@
+var t = {}, e;
+function u() {
+  return e || (e = 1, function(r) {
+    r.L = { bit: 1 }, r.M = { bit: 0 }, r.Q = { bit: 3 }, r.H = { bit: 2 };
+    function c(n) {
+      if (typeof n != "string")
+        throw new Error("Param is not a string");
+      switch (n.toLowerCase()) {
+        case "l":
+        case "low":
+          return r.L;
+        case "m":
+        case "medium":
+          return r.M;
+        case "q":
+        case "quartile":
+          return r.Q;
+        case "h":
+        case "high":
+          return r.H;
+        default:
+          throw new Error("Unknown EC Level: " + n);
+      }
+    }
+    r.isValid = function(i) {
+      return i && typeof i.bit < "u" && i.bit >= 0 && i.bit < 4;
+    }, r.from = function(i, a) {
+      if (r.isValid(i))
+        return i;
+      try {
+        return c(i);
+      } catch {
+        return a;
+      }
+    };
+  }(t)), t;
+}
+export {
+  u as r
+};

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

@@ -0,0 +1,21 @@
+import { r as s } from "./utils.es.js";
+var r = {}, i;
+function P() {
+  if (i) return r;
+  i = 1;
+  const n = s().getSymbolSize, e = 7;
+  return r.getPositions = function(o) {
+    const t = n(o);
+    return [
+      // top-left
+      [0, 0],
+      // top-right
+      [t - e, 0],
+      // bottom-left
+      [0, t - e]
+    ];
+  }, r;
+}
+export {
+  P as r
+};

package/vendor/qrcode/lib/core/format-info.es.js

@@ -0,0 +1,17 @@
+import { r as g } from "./utils.es.js";
+var e = {}, s;
+function B() {
+  if (s) return e;
+  s = 1;
+  const r = g(), i = 1335, a = 21522, o = r.getBCHDigit(i);
+  return e.getEncodedBits = function(c, f) {
+    const n = c.bit << 3 | f;
+    let t = n << 10;
+    for (; r.getBCHDigit(t) - o >= 0; )
+      t ^= i << r.getBCHDigit(t) - o;
+    return (n << 10 | t) ^ a;
+  }, e;
+}
+export {
+  B as r
+};

package/vendor/qrcode/lib/core/galois-field.es.js

@@ -0,0 +1,23 @@
+var n = {}, l;
+function u() {
+  if (l) return n;
+  l = 1;
+  const i = new Uint8Array(512), t = new Uint8Array(256);
+  return function() {
+    let r = 1;
+    for (let e = 0; e < 255; e++)
+      i[e] = r, t[r] = e, r <<= 1, r & 256 && (r ^= 285);
+    for (let e = 255; e < 512; e++)
+      i[e] = i[e - 255];
+  }(), n.log = function(r) {
+    if (r < 1) throw new Error("log(" + r + ")");
+    return t[r];
+  }, n.exp = function(r) {
+    return i[r];
+  }, n.mul = function(r, e) {
+    return r === 0 || e === 0 ? 0 : i[t[r] + t[e]];
+  }, n;
+}
+export {
+  u as r
+};