@rhino-design/vue 0.2.2 → 0.2.6

package/dist/node_modules/qrcode/lib/core/error-correction-code.js

@@ -0,0 +1,359 @@
+import { __exports as u } from "../../../../_virtual/error-correction-code.js";
+import "./error-correction-level.js";
+import { __exports as a } from "../../../../_virtual/error-correction-level.js";
+const e = a, r = [
+  // 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
+];
+u.getBlocksCount = function(t, n) {
+  switch (n) {
+    case e.L:
+      return r[(t - 1) * 4 + 0];
+    case e.M:
+      return r[(t - 1) * 4 + 1];
+    case e.Q:
+      return r[(t - 1) * 4 + 2];
+    case e.H:
+      return r[(t - 1) * 4 + 3];
+    default:
+      return;
+  }
+};
+u.getTotalCodewordsCount = function(t, n) {
+  switch (n) {
+    case e.L:
+      return o[(t - 1) * 4 + 0];
+    case e.M:
+      return o[(t - 1) * 4 + 1];
+    case e.Q:
+      return o[(t - 1) * 4 + 2];
+    case e.H:
+      return o[(t - 1) * 4 + 3];
+    default:
+      return;
+  }
+};
+export {
+  u as default
+};

package/dist/node_modules/qrcode/lib/core/error-correction-level.js

@@ -0,0 +1,35 @@
+import { __exports as a } from "../../../../_virtual/error-correction-level.js";
+(function(r) {
+  r.L = { bit: 1 }, r.M = { bit: 0 }, r.Q = { bit: 3 }, r.H = { bit: 2 };
+  function t(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, c) {
+    if (r.isValid(i))
+      return i;
+    try {
+      return t(i);
+    } catch {
+      return c;
+    }
+  };
+})(a);

package/dist/node_modules/qrcode/lib/core/finder-pattern.js

@@ -0,0 +1,18 @@
+import { __exports as s } from "../../../../_virtual/finder-pattern.js";
+import "./utils.js";
+import { __exports as i } from "../../../../_virtual/utils.js";
+const r = i.getSymbolSize, o = 7;
+s.getPositions = function(e) {
+  const t = r(e);
+  return [
+    // top-left
+    [0, 0],
+    // top-right
+    [t - o, 0],
+    // bottom-left
+    [0, t - o]
+  ];
+};
+export {
+  s as default
+};

package/dist/node_modules/qrcode/lib/core/format-info.js

@@ -0,0 +1,14 @@
+import { __exports as c } from "../../../../_virtual/format-info.js";
+import "./utils.js";
+import { __exports as g } from "../../../../_virtual/utils.js";
+const o = g, s = 1335, a = 21522, e = o.getBCHDigit(s);
+c.getEncodedBits = function(n, r) {
+  const i = n.bit << 3 | r;
+  let t = i << 10;
+  for (; o.getBCHDigit(t) - e >= 0; )
+    t ^= s << o.getBCHDigit(t) - e;
+  return (i << 10 | t) ^ a;
+};
+export {
+  c as default
+};

package/dist/node_modules/qrcode/lib/core/galois-field.js

@@ -0,0 +1,22 @@
+import { __exports as i } from "../../../../_virtual/galois-field.js";
+const n = new Uint8Array(512), o = new Uint8Array(256);
+(function() {
+  let r = 1;
+  for (let t = 0; t < 255; t++)
+    n[t] = r, o[r] = t, r <<= 1, r & 256 && (r ^= 285);
+  for (let t = 255; t < 512; t++)
+    n[t] = n[t - 255];
+})();
+i.log = function(r) {
+  if (r < 1) throw new Error("log(" + r + ")");
+  return o[r];
+};
+i.exp = function(r) {
+  return n[r];
+};
+i.mul = function(r, t) {
+  return r === 0 || t === 0 ? 0 : n[o[r] + o[t]];
+};
+export {
+  i as default
+};

package/dist/node_modules/qrcode/lib/core/kanji-data.js

@@ -0,0 +1,37 @@
+import "./mode.js";
+import "./utils.js";
+import { __exports as o } from "../../../../_virtual/mode.js";
+import { __exports as r } from "../../../../_virtual/utils.js";
+const a = o, s = r;
+function n(i) {
+  this.mode = a.KANJI, this.data = i;
+}
+n.getBitsLength = function(e) {
+  return e * 13;
+};
+n.prototype.getLength = function() {
+  return this.data.length;
+};
+n.prototype.getBitsLength = function() {
+  return n.getBitsLength(this.data.length);
+};
+n.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);
+  }
+};
+var u = n;
+export {
+  u as k
+};

package/dist/node_modules/qrcode/lib/core/mask-pattern.js

@@ -0,0 +1,96 @@
+import { __exports as T } from "../../../../_virtual/mask-pattern.js";
+(function(r) {
+  r.Patterns = {
+    PATTERN000: 0,
+    PATTERN001: 1,
+    PATTERN010: 2,
+    PATTERN011: 3,
+    PATTERN100: 4,
+    PATTERN101: 5,
+    PATTERN110: 6,
+    PATTERN111: 7
+  };
+  const N = {
+    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, o = null, P = null;
+    for (let u = 0; u < l; u++) {
+      n = e = 0, o = P = null;
+      for (let c = 0; c < l; c++) {
+        let f = t.get(u, c);
+        f === o ? n++ : (n >= 5 && (s += N.N1 + (n - 5)), o = f, n = 1), f = t.get(c, u), f === P ? e++ : (e >= 5 && (s += N.N1 + (e - 5)), P = f, e = 1);
+      }
+      n >= 5 && (s += N.N1 + (n - 5)), e >= 5 && (s += N.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 o = t.get(n, e) + t.get(n, e + 1) + t.get(n + 1, e) + t.get(n + 1, e + 1);
+        (o === 4 || o === 0) && s++;
+      }
+    return s * N.N2;
+  }, r.getPenaltyN3 = function(t) {
+    const l = t.size;
+    let s = 0, n = 0, e = 0;
+    for (let o = 0; o < l; o++) {
+      n = e = 0;
+      for (let P = 0; P < l; P++)
+        n = n << 1 & 2047 | t.get(o, P), P >= 10 && (n === 1488 || n === 93) && s++, e = e << 1 & 2047 | t.get(P, o), P >= 10 && (e === 1488 || e === 93) && s++;
+    }
+    return s * N.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) * N.N4;
+  };
+  function a(i, t, l) {
+    switch (i) {
+      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:" + i);
+    }
+  }
+  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, a(t, e, n));
+  }, r.getBestMask = function(t, l) {
+    const s = Object.keys(r.Patterns).length;
+    let n = 0, e = 1 / 0;
+    for (let o = 0; o < s; o++) {
+      l(o), r.applyMask(o, t);
+      const P = r.getPenaltyN1(t) + r.getPenaltyN2(t) + r.getPenaltyN3(t) + r.getPenaltyN4(t);
+      r.applyMask(o, t), P < e && (e = P, n = o);
+    }
+    return n;
+  };
+})(T);

package/dist/node_modules/qrcode/lib/core/mode.js

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

package/dist/node_modules/qrcode/lib/core/numeric-data.js

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

package/dist/node_modules/qrcode/lib/core/polynomial.js

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