@rhino-design/vue 0.2.1 → 0.2.3

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

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

package/dist/node_modules/qrcode/lib/core/reed-solomon-encoder.js

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

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

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

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

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

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

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

package/dist/node_modules/qrcode/lib/core/version-check.js

@@ -0,0 +1,7 @@
+import { __exports as i } from "../../../../_virtual/version-check.js";
+i.isValid = function(a) {
+  return !isNaN(a) && a >= 1 && a <= 40;
+};
+export {
+  i as default
+};

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

@@ -0,0 +1,74 @@
+import { __exports as _ } from "../../../../_virtual/version.js";
+import "./utils.js";
+import "./error-correction-code.js";
+import "./error-correction-level.js";
+import "./mode.js";
+import "./version-check.js";
+import { __exports as w } from "../../../../_virtual/utils.js";
+import { __exports as M } from "../../../../_virtual/version-check.js";
+import { __exports as D } from "../../../../_virtual/mode.js";
+import { __exports as V } from "../../../../_virtual/error-correction-code.js";
+import { __exports as y } from "../../../../_virtual/error-correction-level.js";
+(function(i) {
+  const c = w, m = V, u = y, n = D, f = M, l = 7973, g = c.getBCHDigit(l);
+  function h(o, t, r) {
+    for (let e = 1; e <= 40; e++)
+      if (t <= i.getCapacity(e, r, o))
+        return e;
+  }
+  function d(o, t) {
+    return n.getCharCountIndicator(o, t) + 4;
+  }
+  function B(o, t) {
+    let r = 0;
+    return o.forEach(function(e) {
+      const s = d(e.mode, t);
+      r += s + e.getBitsLength();
+    }), r;
+  }
+  function p(o, t) {
+    for (let r = 1; r <= 40; r++)
+      if (B(o, r) <= i.getCapacity(r, t, n.MIXED))
+        return r;
+  }
+  i.from = function(t, r) {
+    return f.isValid(t) ? parseInt(t, 10) : r;
+  }, i.getCapacity = function(t, r, e) {
+    if (!f.isValid(t))
+      throw new Error("Invalid QR Code version");
+    typeof e > "u" && (e = n.BYTE);
+    const s = c.getSymbolTotalCodewords(t), E = m.getTotalCodewordsCount(t, r), C = (s - E) * 8;
+    if (e === n.MIXED) return C;
+    const a = C - d(e, t);
+    switch (e) {
+      case n.NUMERIC:
+        return Math.floor(a / 10 * 3);
+      case n.ALPHANUMERIC:
+        return Math.floor(a / 11 * 2);
+      case n.KANJI:
+        return Math.floor(a / 13);
+      case n.BYTE:
+      default:
+        return Math.floor(a / 8);
+    }
+  }, i.getBestVersionForData = function(t, r) {
+    let e;
+    const s = u.from(r, u.M);
+    if (Array.isArray(t)) {
+      if (t.length > 1)
+        return p(t, s);
+      if (t.length === 0)
+        return 1;
+      e = t[0];
+    } else
+      e = t;
+    return h(e.mode, e.getLength(), s);
+  }, i.getEncodedBits = function(t) {
+    if (!f.isValid(t) || t < 7)
+      throw new Error("Invalid QR Code version");
+    let r = t << 12;
+    for (; c.getBCHDigit(r) - g >= 0; )
+      r ^= l << c.getBCHDigit(r) - g;
+    return t << 12 | r;
+  };
+})(_);

package/dist/node_modules/qrcode/lib/renderer/canvas.js

@@ -0,0 +1,27 @@
+import { __exports as h } from "../../../../_virtual/canvas.js";
+import "./utils.js";
+import { __exports as s } from "../../../../_virtual/utils2.js";
+(function(f) {
+  const l = s;
+  function g(d, n, e) {
+    d.clearRect(0, 0, n.width, n.height), n.style || (n.style = {}), n.height = e, n.width = e, n.style.height = e + "px", n.style.width = e + "px";
+  }
+  function m() {
+    try {
+      return document.createElement("canvas");
+    } catch {
+      throw new Error("You need to specify a canvas element");
+    }
+  }
+  f.render = function(n, e, u) {
+    let t = u, r = e;
+    typeof t > "u" && (!e || !e.getContext) && (t = e, e = void 0), e || (r = m()), t = l.getOptions(t);
+    const o = l.getImageWidth(n.modules.size, t), i = r.getContext("2d"), p = i.createImageData(o, o);
+    return l.qrToImageData(p.data, n, t), g(i, r, o), i.putImageData(p, 0, 0), r;
+  }, f.renderToDataURL = function(n, e, u) {
+    let t = u;
+    typeof t > "u" && (!e || !e.getContext) && (t = e, e = void 0), t || (t = {});
+    const r = f.render(n, e, t), o = t.type || "image/png", i = t.rendererOpts || {};
+    return r.toDataURL(o, i.quality);
+  };
+})(h);

package/dist/node_modules/qrcode/lib/renderer/svg-tag.js

@@ -0,0 +1,28 @@
+import { __exports as a } from "../../../../_virtual/svg-tag.js";
+import "./utils.js";
+import { __exports as u } from "../../../../_virtual/utils2.js";
+const w = u;
+function g(s, n) {
+  const i = s.a / 255, o = n + '="' + s.hex + '"';
+  return i < 1 ? o + " " + n + '-opacity="' + i.toFixed(2).slice(1) + '"' : o;
+}
+function f(s, n, i) {
+  let o = s + n;
+  return typeof i < "u" && (o += " " + i), o;
+}
+function m(s, n, i) {
+  let o = "", e = 0, r = !1, c = 0;
+  for (let t = 0; t < s.length; t++) {
+    const l = Math.floor(t % n), h = Math.floor(t / n);
+    !l && !r && (r = !0), s[t] ? (c++, t > 0 && l > 0 && s[t - 1] || (o += r ? f("M", l + i, 0.5 + h + i) : f("m", e, 0), e = 0, r = !1), l + 1 < n && s[t + 1] || (o += f("h", c), c = 0)) : e++;
+  }
+  return o;
+}
+a.render = function(n, i, o) {
+  const e = w.getOptions(i), r = n.modules.size, c = n.modules.data, t = r + e.margin * 2, l = e.color.light.a ? "<path " + g(e.color.light, "fill") + ' d="M0 0h' + t + "v" + t + 'H0z"/>' : "", h = "<path " + g(e.color.dark, "stroke") + ' d="' + m(c, r, e.margin) + '"/>', p = 'viewBox="0 0 ' + t + " " + t + '"', d = '<svg xmlns="http://www.w3.org/2000/svg" ' + (e.width ? 'width="' + e.width + '" height="' + e.width + '" ' : "") + p + ' shape-rendering="crispEdges">' + l + h + `</svg>
+`;
+  return typeof o == "function" && o(null, d), d;
+};
+export {
+  a as default
+};

package/dist/node_modules/qrcode/lib/renderer/utils.js

@@ -0,0 +1,52 @@
+import { __exports as b } from "../../../../_virtual/utils2.js";
+(function(n) {
+  function u(l) {
+    if (typeof l == "number" && (l = l.toString()), typeof l != "string")
+      throw new Error("Color should be defined as hex string");
+    let e = l.slice().replace("#", "").split("");
+    if (e.length < 3 || e.length === 5 || e.length > 8)
+      throw new Error("Invalid hex color: " + l);
+    (e.length === 3 || e.length === 4) && (e = Array.prototype.concat.apply([], e.map(function(t) {
+      return [t, t];
+    }))), e.length === 6 && e.push("F", "F");
+    const r = parseInt(e.join(""), 16);
+    return {
+      r: r >> 24 & 255,
+      g: r >> 16 & 255,
+      b: r >> 8 & 255,
+      a: r & 255,
+      hex: "#" + e.slice(0, 6).join("")
+    };
+  }
+  n.getOptions = function(e) {
+    e || (e = {}), e.color || (e.color = {});
+    const r = typeof e.margin > "u" || e.margin === null || e.margin < 0 ? 4 : e.margin, t = e.width && e.width >= 21 ? e.width : void 0, f = e.scale || 4;
+    return {
+      width: t,
+      scale: t ? 4 : f,
+      margin: r,
+      color: {
+        dark: u(e.color.dark || "#000000ff"),
+        light: u(e.color.light || "#ffffffff")
+      },
+      type: e.type,
+      rendererOpts: e.rendererOpts || {}
+    };
+  }, n.getScale = function(e, r) {
+    return r.width && r.width >= e + r.margin * 2 ? r.width / (e + r.margin * 2) : r.scale;
+  }, n.getImageWidth = function(e, r) {
+    const t = n.getScale(e, r);
+    return Math.floor((e + r.margin * 2) * t);
+  }, n.qrToImageData = function(e, r, t) {
+    const f = r.modules.size, m = r.modules.data, d = n.getScale(f, t), g = Math.floor((f + t.margin * 2) * d), a = t.margin * d, s = [t.color.light, t.color.dark];
+    for (let c = 0; c < g; c++)
+      for (let i = 0; i < g; i++) {
+        let h = (c * g + i) * 4, o = t.color.light;
+        if (c >= a && i >= a && c < g - a && i < g - a) {
+          const w = Math.floor((c - a) / d), y = Math.floor((i - a) / d);
+          o = s[m[w * f + y] ? 1 : 0];
+        }
+        e[h++] = o.r, e[h++] = o.g, e[h++] = o.b, e[h] = o.a;
+      }
+  };
+})(b);