@alfadocs/ui-kit-debug 1.31.0 → 1.33.0

package/dist/_chunks/qr-code-DOJs4suh.js

@@ -0,0 +1,750 @@
+var rt = Object.defineProperty;
+var ot = (r, t, e) => t in r ? rt(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var A = (r, t, e) => ot(r, typeof t != "symbol" ? t + "" : t, e);
+import { jsxs as F, jsx as b } from "react/jsx-runtime";
+import { forwardRef as nt, useMemo as it } from "react";
+import { c as O } from "./index-D2ZczOXr.js";
+import { useTranslation as at } from "react-i18next";
+import { u as lt } from "./registry-DvAUVLHh.js";
+import { A as ct } from "./Alfadocs_Logo_Mark-7o3L3WBI.js";
+const dt = {
+  id: "qr-code",
+  capabilities: [],
+  state: {
+    value: {
+      type: "string",
+      descriptionKey: "ui.agent.qrCode.state.value",
+      description: "The string (typically an https URL) encoded into the QR.",
+      read: (r) => r
+    }
+  },
+  actions: {},
+  domHooks: {
+    root: {
+      attr: "data-component",
+      value: "qr-code",
+      description: "Marks the element as a kit QrCode renderer."
+    },
+    instanceId: {
+      attr: "data-component-id",
+      sourceProp: "id",
+      description: "Sourced from the id prop."
+    }
+  }
+};
+var M = /* @__PURE__ */ ((r) => (r[r.Border = -1] = "Border", r[r.Data = 0] = "Data", r[r.Function = 1] = "Function", r[r.Position = 2] = "Position", r[r.Timing = 3] = "Timing", r[r.Alignment = 4] = "Alignment", r))(M || {});
+const ft = [0, 1], G = [1, 0], j = [2, 3], K = [3, 2], ht = {
+  L: ft,
+  M: G,
+  Q: j,
+  H: K
+}, ut = /^\d*$/, mt = /^[A-Z0-9 $%*+./:-]*$/, I = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:", L = 1, S = 40, Y = 3, gt = 3, z = 40, pt = 10, H = [
+  // Version: (note that index 0 is for padding, and is set to an illegal value)
+  // 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+  [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+  // Low
+  [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+  // Medium
+  [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+  // Quartile
+  [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30]
+  // High
+], X = [
+  // Version: (note that index 0 is for padding, and is set to an illegal value)
+  // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40    Error correction level
+  [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+  // Low
+  [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+  // Medium
+  [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+  // Quartile
+  [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81]
+  // High
+];
+let wt = class {
+  /* -- Constructor (low level) and fields -- */
+  // Creates a new QR Code with the given version number,
+  // error correction level, data codeword bytes, and mask number.
+  // This is a low-level API that most users should not use directly.
+  // A mid-level API is the encodeSegments() function.
+  constructor(t, e, s, o) {
+    /* -- Fields -- */
+    // The width and height of this QR Code, measured in modules, between
+    // 21 and 177 (inclusive). This is equal to version * 4 + 17.
+    A(this, "size");
+    // The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
+    // Even if a QR Code is created with automatic masking requested (mask = -1),
+    // the resulting object still has a mask value between 0 and 7.
+    A(this, "mask");
+    // The modules of this QR Code (false = light, true = dark).
+    // Immutable after constructor finishes. Accessed through getModule().
+    A(this, "modules", []);
+    A(this, "types", []);
+    if (this.version = t, this.ecc = e, t < L || t > S)
+      throw new RangeError("Version value out of range");
+    if (o < -1 || o > 7)
+      throw new RangeError("Mask value out of range");
+    this.size = t * 4 + 17;
+    const n = Array.from({ length: this.size }).fill(!1);
+    for (let a = 0; a < this.size; a++)
+      this.modules.push(n.slice()), this.types.push(n.map(() => 0));
+    this.drawFunctionPatterns();
+    const i = this.addEccAndInterleave(s);
+    if (this.drawCodewords(i), o === -1) {
+      let a = 1e9;
+      for (let l = 0; l < 8; l++) {
+        this.applyMask(l), this.drawFormatBits(l);
+        const c = this.getPenaltyScore();
+        c < a && (o = l, a = c), this.applyMask(l);
+      }
+    }
+    this.mask = o, this.applyMask(o), this.drawFormatBits(o);
+  }
+  /* -- Accessor methods -- */
+  // Returns the color of the module (pixel) at the given coordinates, which is false
+  // for light or true for dark. The top left corner has the coordinates (x=0, y=0).
+  // If the given coordinates are out of bounds, then false (light) is returned.
+  getModule(t, e) {
+    return t >= 0 && t < this.size && e >= 0 && e < this.size && this.modules[e][t];
+  }
+  /* -- Private helper methods for constructor: Drawing function modules -- */
+  // Reads this object's version field, and draws and marks all function modules.
+  drawFunctionPatterns() {
+    for (let s = 0; s < this.size; s++)
+      this.setFunctionModule(6, s, s % 2 === 0, M.Timing), this.setFunctionModule(s, 6, s % 2 === 0, M.Timing);
+    this.drawFinderPattern(3, 3), this.drawFinderPattern(this.size - 4, 3), this.drawFinderPattern(3, this.size - 4);
+    const t = this.getAlignmentPatternPositions(), e = t.length;
+    for (let s = 0; s < e; s++)
+      for (let o = 0; o < e; o++)
+        s === 0 && o === 0 || s === 0 && o === e - 1 || s === e - 1 && o === 0 || this.drawAlignmentPattern(t[s], t[o]);
+    this.drawFormatBits(0), this.drawVersion();
+  }
+  // Draws two copies of the format bits (with its own error correction code)
+  // based on the given mask and this object's error correction level field.
+  drawFormatBits(t) {
+    const e = this.ecc[1] << 3 | t;
+    let s = e;
+    for (let n = 0; n < 10; n++)
+      s = s << 1 ^ (s >>> 9) * 1335;
+    const o = (e << 10 | s) ^ 21522;
+    for (let n = 0; n <= 5; n++)
+      this.setFunctionModule(8, n, p(o, n));
+    this.setFunctionModule(8, 7, p(o, 6)), this.setFunctionModule(8, 8, p(o, 7)), this.setFunctionModule(7, 8, p(o, 8));
+    for (let n = 9; n < 15; n++)
+      this.setFunctionModule(14 - n, 8, p(o, n));
+    for (let n = 0; n < 8; n++)
+      this.setFunctionModule(this.size - 1 - n, 8, p(o, n));
+    for (let n = 8; n < 15; n++)
+      this.setFunctionModule(8, this.size - 15 + n, p(o, n));
+    this.setFunctionModule(8, this.size - 8, !0);
+  }
+  // Draws two copies of the version bits (with its own error correction code),
+  // based on this object's version field, iff 7 <= version <= 40.
+  drawVersion() {
+    if (this.version < 7)
+      return;
+    let t = this.version;
+    for (let s = 0; s < 12; s++)
+      t = t << 1 ^ (t >>> 11) * 7973;
+    const e = this.version << 12 | t;
+    for (let s = 0; s < 18; s++) {
+      const o = p(e, s), n = this.size - 11 + s % 3, i = Math.floor(s / 3);
+      this.setFunctionModule(n, i, o), this.setFunctionModule(i, n, o);
+    }
+  }
+  // Draws a 9*9 finder pattern including the border separator,
+  // with the center module at (x, y). Modules can be out of bounds.
+  drawFinderPattern(t, e) {
+    for (let s = -4; s <= 4; s++)
+      for (let o = -4; o <= 4; o++) {
+        const n = Math.max(Math.abs(o), Math.abs(s)), i = t + o, a = e + s;
+        i >= 0 && i < this.size && a >= 0 && a < this.size && this.setFunctionModule(i, a, n !== 2 && n !== 4, M.Position);
+      }
+  }
+  // Draws a 5*5 alignment pattern, with the center module
+  // at (x, y). All modules must be in bounds.
+  drawAlignmentPattern(t, e) {
+    for (let s = -2; s <= 2; s++)
+      for (let o = -2; o <= 2; o++)
+        this.setFunctionModule(
+          t + o,
+          e + s,
+          Math.max(Math.abs(o), Math.abs(s)) !== 1,
+          M.Alignment
+        );
+  }
+  // Sets the color of a module and marks it as a function module.
+  // Only used by the constructor. Coordinates must be in bounds.
+  setFunctionModule(t, e, s, o = M.Function) {
+    this.modules[e][t] = s, this.types[e][t] = o;
+  }
+  /* -- Private helper methods for constructor: Codewords and masking -- */
+  // Returns a new byte string representing the given data with the appropriate error correction
+  // codewords appended to it, based on this object's version and error correction level.
+  addEccAndInterleave(t) {
+    const e = this.version, s = this.ecc;
+    if (t.length !== C(e, s))
+      throw new RangeError("Invalid argument");
+    const o = X[s[0]][e], n = H[s[0]][e], i = Math.floor(q(e) / 8), a = o - i % o, l = Math.floor(i / o), c = [], h = Ct(n);
+    for (let f = 0, m = 0; f < o; f++) {
+      const u = t.slice(m, m + l - n + (f < a ? 0 : 1));
+      m += u.length;
+      const y = Nt(u, h);
+      f < a && u.push(0), c.push(u.concat(y));
+    }
+    const d = [];
+    for (let f = 0; f < c[0].length; f++)
+      c.forEach((m, u) => {
+        (f !== l - n || u >= a) && d.push(m[f]);
+      });
+    return d;
+  }
+  // Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
+  // data area of this QR Code. Function modules need to be marked off before this is called.
+  drawCodewords(t) {
+    if (t.length !== Math.floor(q(this.version) / 8))
+      throw new RangeError("Invalid argument");
+    let e = 0;
+    for (let s = this.size - 1; s >= 1; s -= 2) {
+      s === 6 && (s = 5);
+      for (let o = 0; o < this.size; o++)
+        for (let n = 0; n < 2; n++) {
+          const i = s - n, l = (s + 1 & 2) === 0 ? this.size - 1 - o : o;
+          !this.types[l][i] && e < t.length * 8 && (this.modules[l][i] = p(t[e >>> 3], 7 - (e & 7)), e++);
+        }
+    }
+  }
+  // XORs the codeword modules in this QR Code with the given mask pattern.
+  // The function modules must be marked and the codeword bits must be drawn
+  // before masking. Due to the arithmetic of XOR, calling applyMask() with
+  // the same mask value a second time will undo the mask. A final well-formed
+  // QR Code needs exactly one (not zero, two, etc.) mask applied.
+  applyMask(t) {
+    if (t < 0 || t > 7)
+      throw new RangeError("Mask value out of range");
+    for (let e = 0; e < this.size; e++)
+      for (let s = 0; s < this.size; s++) {
+        let o;
+        switch (t) {
+          case 0:
+            o = (s + e) % 2 === 0;
+            break;
+          case 1:
+            o = e % 2 === 0;
+            break;
+          case 2:
+            o = s % 3 === 0;
+            break;
+          case 3:
+            o = (s + e) % 3 === 0;
+            break;
+          case 4:
+            o = (Math.floor(s / 3) + Math.floor(e / 2)) % 2 === 0;
+            break;
+          case 5:
+            o = s * e % 2 + s * e % 3 === 0;
+            break;
+          case 6:
+            o = (s * e % 2 + s * e % 3) % 2 === 0;
+            break;
+          case 7:
+            o = ((s + e) % 2 + s * e % 3) % 2 === 0;
+            break;
+          default:
+            throw new Error("Unreachable");
+        }
+        !this.types[e][s] && o && (this.modules[e][s] = !this.modules[e][s]);
+      }
+  }
+  // Calculates and returns the penalty score based on state of this QR Code's current modules.
+  // This is used by the automatic mask choice algorithm to find the mask pattern that yields the lowest score.
+  getPenaltyScore() {
+    let t = 0;
+    for (let n = 0; n < this.size; n++) {
+      let i = !1, a = 0;
+      const l = [0, 0, 0, 0, 0, 0, 0];
+      for (let c = 0; c < this.size; c++)
+        this.modules[n][c] === i ? (a++, a === 5 ? t += Y : a > 5 && t++) : (this.finderPenaltyAddHistory(a, l), i || (t += this.finderPenaltyCountPatterns(l) * z), i = this.modules[n][c], a = 1);
+      t += this.finderPenaltyTerminateAndCount(i, a, l) * z;
+    }
+    for (let n = 0; n < this.size; n++) {
+      let i = !1, a = 0;
+      const l = [0, 0, 0, 0, 0, 0, 0];
+      for (let c = 0; c < this.size; c++)
+        this.modules[c][n] === i ? (a++, a === 5 ? t += Y : a > 5 && t++) : (this.finderPenaltyAddHistory(a, l), i || (t += this.finderPenaltyCountPatterns(l) * z), i = this.modules[c][n], a = 1);
+      t += this.finderPenaltyTerminateAndCount(i, a, l) * z;
+    }
+    for (let n = 0; n < this.size - 1; n++)
+      for (let i = 0; i < this.size - 1; i++) {
+        const a = this.modules[n][i];
+        a === this.modules[n][i + 1] && a === this.modules[n + 1][i] && a === this.modules[n + 1][i + 1] && (t += gt);
+      }
+    let e = 0;
+    for (const n of this.modules)
+      e = n.reduce((i, a) => i + (a ? 1 : 0), e);
+    const s = this.size * this.size, o = Math.ceil(Math.abs(e * 20 - s * 10) / s) - 1;
+    return t += o * pt, t;
+  }
+  /* -- Private helper functions -- */
+  // Returns an ascending list of positions of alignment patterns for this version number.
+  // Each position is in the range [0,177), and are used on both the x and y axes.
+  // This could be implemented as lookup table of 40 variable-length lists of integers.
+  getAlignmentPatternPositions() {
+    if (this.version === 1)
+      return [];
+    {
+      const t = Math.floor(this.version / 7) + 2, e = this.version === 32 ? 26 : Math.ceil((this.version * 4 + 4) / (t * 2 - 2)) * 2, s = [6];
+      for (let o = this.size - 7; s.length < t; o -= e)
+        s.splice(1, 0, o);
+      return s;
+    }
+  }
+  // Can only be called immediately after a light run is added, and
+  // returns either 0, 1, or 2. A helper function for getPenaltyScore().
+  finderPenaltyCountPatterns(t) {
+    const e = t[1], s = e > 0 && t[2] === e && t[3] === e * 3 && t[4] === e && t[5] === e;
+    return (s && t[0] >= e * 4 && t[6] >= e ? 1 : 0) + (s && t[6] >= e * 4 && t[0] >= e ? 1 : 0);
+  }
+  // Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
+  finderPenaltyTerminateAndCount(t, e, s) {
+    return t && (this.finderPenaltyAddHistory(e, s), e = 0), e += this.size, this.finderPenaltyAddHistory(e, s), this.finderPenaltyCountPatterns(s);
+  }
+  // Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
+  finderPenaltyAddHistory(t, e) {
+    e[0] === 0 && (t += this.size), e.pop(), e.unshift(t);
+  }
+};
+function w(r, t, e) {
+  if (t < 0 || t > 31 || r >>> t)
+    throw new RangeError("Value out of range");
+  for (let s = t - 1; s >= 0; s--)
+    e.push(r >>> s & 1);
+}
+function p(r, t) {
+  return (r >>> t & 1) !== 0;
+}
+class U {
+  // Creates a new QR Code segment with the given attributes and data.
+  // The character count (numChars) must agree with the mode and the bit buffer length,
+  // but the constraint isn't checked. The given bit buffer is cloned and stored.
+  constructor(t, e, s) {
+    if (this.mode = t, this.numChars = e, this.bitData = s, e < 0)
+      throw new RangeError("Invalid argument");
+    this.bitData = s.slice();
+  }
+  /* -- Methods -- */
+  // Returns a new copy of the data bits of this segment.
+  getData() {
+    return this.bitData.slice();
+  }
+}
+const bt = [1, 10, 12, 14], Mt = [2, 9, 11, 13], Et = [4, 8, 16, 16];
+function Q(r, t) {
+  return r[Math.floor((t + 7) / 17) + 1];
+}
+function W(r) {
+  const t = [];
+  for (const e of r)
+    w(e, 8, t);
+  return new U(Et, r.length, t);
+}
+function vt(r) {
+  if (!Z(r))
+    throw new RangeError("String contains non-numeric characters");
+  const t = [];
+  for (let e = 0; e < r.length; ) {
+    const s = Math.min(r.length - e, 3);
+    w(Number.parseInt(r.substring(e, e + s), 10), s * 3 + 1, t), e += s;
+  }
+  return new U(bt, r.length, t);
+}
+function At(r) {
+  if (!J(r))
+    throw new RangeError("String contains unencodable characters in alphanumeric mode");
+  const t = [];
+  let e;
+  for (e = 0; e + 2 <= r.length; e += 2) {
+    let s = I.indexOf(r.charAt(e)) * 45;
+    s += I.indexOf(r.charAt(e + 1)), w(s, 11, t);
+  }
+  return e < r.length && w(I.indexOf(r.charAt(e)), 6, t), new U(Mt, r.length, t);
+}
+function yt(r) {
+  return r === "" ? [] : Z(r) ? [vt(r)] : J(r) ? [At(r)] : [W(Pt(r))];
+}
+function Z(r) {
+  return ut.test(r);
+}
+function J(r) {
+  return mt.test(r);
+}
+function zt(r, t) {
+  let e = 0;
+  for (const s of r) {
+    const o = Q(s.mode, t);
+    if (s.numChars >= 1 << o)
+      return Number.POSITIVE_INFINITY;
+    e += 4 + o + s.bitData.length;
+  }
+  return e;
+}
+function Pt(r) {
+  r = encodeURI(r);
+  const t = [];
+  for (let e = 0; e < r.length; e++)
+    r.charAt(e) !== "%" ? t.push(r.charCodeAt(e)) : (t.push(Number.parseInt(r.substring(e + 1, e + 3), 16)), e += 2);
+  return t;
+}
+function q(r) {
+  if (r < L || r > S)
+    throw new RangeError("Version number out of range");
+  let t = (16 * r + 128) * r + 64;
+  if (r >= 2) {
+    const e = Math.floor(r / 7) + 2;
+    t -= (25 * e - 10) * e - 55, r >= 7 && (t -= 36);
+  }
+  return t;
+}
+function C(r, t) {
+  return Math.floor(q(r) / 8) - H[t[0]][r] * X[t[0]][r];
+}
+function Ct(r) {
+  if (r < 1 || r > 255)
+    throw new RangeError("Degree out of range");
+  const t = [];
+  for (let s = 0; s < r - 1; s++)
+    t.push(0);
+  t.push(1);
+  let e = 1;
+  for (let s = 0; s < r; s++) {
+    for (let o = 0; o < t.length; o++)
+      t[o] = B(t[o], e), o + 1 < t.length && (t[o] ^= t[o + 1]);
+    e = B(e, 2);
+  }
+  return t;
+}
+function Nt(r, t) {
+  const e = t.map((s) => 0);
+  for (const s of r) {
+    const o = s ^ e.shift();
+    e.push(0), t.forEach((n, i) => e[i] ^= B(n, o));
+  }
+  return e;
+}
+function B(r, t) {
+  if (r >>> 8 || t >>> 8)
+    throw new RangeError("Byte out of range");
+  let e = 0;
+  for (let s = 7; s >= 0; s--)
+    e = e << 1 ^ (e >>> 7) * 285, e ^= (t >>> s & 1) * r;
+  return e;
+}
+function Rt(r, t, e = 1, s = 40, o = -1, n = !0) {
+  if (!(L <= e && e <= s && s <= S) || o < -1 || o > 7)
+    throw new RangeError("Invalid value");
+  let i, a;
+  for (i = e; ; i++) {
+    const d = C(i, t) * 8, f = zt(r, i);
+    if (f <= d) {
+      a = f;
+      break;
+    }
+    if (i >= s)
+      throw new RangeError("Data too long");
+  }
+  for (const d of [G, j, K])
+    n && a <= C(i, d) * 8 && (t = d);
+  const l = [];
+  for (const d of r) {
+    w(d.mode[0], 4, l), w(d.numChars, Q(d.mode, i), l);
+    for (const f of d.getData())
+      l.push(f);
+  }
+  const c = C(i, t) * 8;
+  w(0, Math.min(4, c - l.length), l), w(0, (8 - l.length % 8) % 8, l);
+  for (let d = 236; l.length < c; d ^= 253)
+    w(d, 8, l);
+  const h = Array.from({ length: Math.ceil(l.length / 8) }, () => 0);
+  return l.forEach((d, f) => h[f >>> 3] |= d << 7 - (f & 7)), new wt(i, t, h, o);
+}
+function _t(r, t) {
+  var d;
+  const {
+    ecc: e = "L",
+    boostEcc: s = !1,
+    minVersion: o = 1,
+    maxVersion: n = 40,
+    maskPattern: i = -1,
+    border: a = 1
+  } = t || {}, l = typeof r == "string" ? yt(r) : Array.isArray(r) ? [W(r)] : void 0;
+  if (!l)
+    throw new Error(`uqr only supports encoding string and binary data, but got: ${typeof r}`);
+  const c = Rt(
+    l,
+    ht[e],
+    o,
+    n,
+    i,
+    s
+  ), h = kt({
+    version: c.version,
+    maskPattern: c.mask,
+    size: c.size,
+    data: c.modules,
+    types: c.types
+  }, a);
+  return t != null && t.invert && (h.data = h.data.map((f) => f.map((m) => !m))), (d = t == null ? void 0 : t.onEncoded) == null || d.call(t, h), h;
+}
+function kt(r, t = 1) {
+  if (!t)
+    return r;
+  const { size: e } = r, s = e + t * 2;
+  r.size = s, r.data.forEach((n) => {
+    for (let i = 0; i < t; i++)
+      n.unshift(!1), n.push(!1);
+  });
+  for (let n = 0; n < t; n++)
+    r.data.unshift(Array.from({ length: s }, (i) => !1)), r.data.push(Array.from({ length: s }, (i) => !1));
+  const o = M.Border;
+  r.types.forEach((n) => {
+    for (let i = 0; i < t; i++)
+      n.unshift(o), n.push(o);
+  });
+  for (let n = 0; n < t; n++)
+    r.types.unshift(Array.from({ length: s }, (i) => o)), r.types.push(Array.from({ length: s }, (i) => o));
+  return r;
+}
+let x = null;
+function Ht(r) {
+  x = r;
+}
+function Ft(r, t) {
+  if (x) {
+    const o = x(r, { errorCorrectionLevel: t }), { size: n, data: i } = o.modules, a = [];
+    for (let l = 0; l < i.length; l++) a.push(i[l] === 1);
+    return { size: n, modules: a };
+  }
+  const e = _t(r, {
+    ecc: t,
+    border: 0,
+    boostEcc: !1
+  }), s = [];
+  for (const o of e.data) for (const n of o) s.push(n);
+  return { size: e.size, modules: s };
+}
+const It = O(
+  [
+    "ds:inline-flex ds:flex-col ds:items-center ds:shrink-0",
+    "ds:gap-[var(--spacing-sm)]",
+    // The matrix must never mirror in RTL — a mirrored QR is unscannable —
+    // so the wrapper pins LTR while caption/label text still flips via the
+    // logical `text-*` utilities. Mirrors Sparkline's `dir="ltr"` pin.
+    "ds:leading-none"
+  ],
+  {
+    variants: {
+      variant: {
+        plain: "",
+        framed: [
+          "ds:bg-[var(--card)] ds:text-[var(--card-foreground)]",
+          "ds:border ds:border-[color:var(--border)]",
+          // Accessible theme thickens the boundary in step with Card / Stat.
+          "ds:[.theme-accessible_&]:border-2",
+          "ds:rounded-[var(--radius-lg)]",
+          "ds:p-[var(--spacing-md)]",
+          // Forced-colors: the UA strips background; keep a CanvasText
+          // boundary so the frame survives Windows High Contrast Mode.
+          "ds:forced-colors:border ds:forced-colors:border-[CanvasText]"
+        ],
+        "with-caption": [
+          "ds:bg-[var(--card)] ds:text-[var(--card-foreground)]",
+          "ds:border ds:border-[color:var(--border)]",
+          "ds:[.theme-accessible_&]:border-2",
+          "ds:rounded-[var(--radius-lg)]",
+          "ds:p-[var(--spacing-md)]",
+          "ds:forced-colors:border ds:forced-colors:border-[CanvasText]"
+        ]
+      },
+      // Edge length of the matrix box, driven by dedicated tokens
+      // (`--qr-code-size-*`, parallel to `--logo-size-*`). The token owner
+      // controls the scale and the accessible theme can lift it; the
+      // var() fallback is only a graceful default so the box renders before
+      // those token rows land — the token wins whenever it is defined.
+      size: {
+        sm: "ds:[--qr-edge:var(--qr-code-size-sm,8rem)]",
+        md: "ds:[--qr-edge:var(--qr-code-size-md,12rem)]",
+        lg: "ds:[--qr-edge:var(--qr-code-size-lg,16rem)]"
+      },
+      tone: {
+        default: "",
+        // Light modules on a dark quiet zone. The chrome inverts via tokens;
+        // the matrix colours themselves are swapped in the SVG (scanner
+        // constraint — see the literal note below).
+        inverted: ""
+      }
+    },
+    defaultVariants: { variant: "framed", size: "md", tone: "default" }
+  }
+), qt = O(
+  [
+    "type-body-sm",
+    "ds:text-[color:var(--card-foreground)]",
+    // Caption flips with reading direction; the matrix above stays LTR.
+    "ds:text-center"
+  ],
+  {
+    variants: {
+      tone: {
+        default: "",
+        inverted: ""
+      }
+    },
+    defaultVariants: { tone: "default" }
+  }
+), Bt = O(
+  [
+    "ds:pointer-events-none ds:absolute ds:inset-0 ds:m-auto",
+    "ds:flex ds:items-center ds:justify-center",
+    "ds:rounded-[var(--radius-sm)] ds:p-[var(--spacing-2xs)]",
+    "ds:bg-[var(--background)]",
+    // Clamp to the published LOGO_EDGE_FRACTION of the matrix edge.
+    "ds:[block-size:calc(var(--qr-edge)*var(--qr-logo-edge))]",
+    "ds:[inline-size:calc(var(--qr-edge)*var(--qr-logo-edge))]",
+    // The mark/custom node fills the padded knockout box.
+    "ds:[&>*]:h-full ds:[&>*]:w-full",
+    "ds:[&>*]:max-h-full ds:[&>*]:max-w-full"
+  ],
+  {
+    variants: {
+      tone: {
+        default: "ds:text-[color:var(--primary)]",
+        inverted: "ds:text-[color:var(--foreground)]"
+      }
+    },
+    defaultVariants: { tone: "default" }
+  }
+), P = 4, xt = "ds:[--qr-logo-edge:0.22]", Ot = /* @__PURE__ */ b(ct, { "aria-hidden": !0, focusable: "false" });
+function Lt(r, t) {
+  if (!r) return null;
+  try {
+    return Ft(r, t);
+  } catch {
+    return null;
+  }
+}
+const St = nt(
+  ({
+    value: r,
+    variant: t = "framed",
+    size: e = "md",
+    tone: s = "default",
+    errorCorrectionLevel: o,
+    logo: n,
+    caption: i,
+    quietZone: a = P,
+    label: l,
+    decorative: c,
+    className: h,
+    id: d,
+    ...f
+  }, m) => {
+    const { t: u } = at(), y = n !== !1, N = y ? n ?? Ot : null, R = o ?? (y ? "H" : "M"), g = it(() => Lt(r, R), [r, R]), _ = Math.max(P, Math.floor(a)), tt = g ? l ? u("qrCode.ariaLabelNamed", { label: l }) : u("qrCode.ariaLabel") : u("qrCode.empty"), et = c ? { role: "presentation", "aria-hidden": !0 } : { role: "img", "aria-label": tt }, T = t === "with-caption" ? i ?? u("qrCode.caption") : void 0, st = s === "inverted" ? "#fff" : "#000", V = s === "inverted" ? "#000" : "#fff", D = [];
+    let k = `0 0 ${(P * 2 + 1) * 1} ${(P * 2 + 1) * 1}`;
+    if (g) {
+      const $ = g.size + _ * 2;
+      k = `0 0 ${$} ${$}`;
+      for (let E = 0; E < g.size; E++)
+        for (let v = 0; v < g.size; v++)
+          g.modules[E * g.size + v] && D.push(
+            /* @__PURE__ */ b(
+              "rect",
+              {
+                x: v + _,
+                y: E + _,
+                width: 1,
+                height: 1,
+                fill: st
+              },
+              `${E}-${v}`
+            )
+          );
+    }
+    return lt(dt, r, d), /* @__PURE__ */ F(
+      "div",
+      {
+        ref: m,
+        ...et,
+        ...f,
+        id: d,
+        dir: "ltr",
+        "data-component": "qr-code",
+        "data-component-id": d,
+        "data-tone": s,
+        "data-ec": R,
+        "data-logo": N ? "true" : "false",
+        className: It({ variant: t, size: e, tone: s, className: h }),
+        children: [
+          /* @__PURE__ */ F(
+            "div",
+            {
+              className: `ds:relative ds:w-[var(--qr-edge)] ds:h-[var(--qr-edge)] ds:max-w-full ${xt}`,
+              children: [
+                g ? /* @__PURE__ */ F(
+                  "svg",
+                  {
+                    "aria-hidden": "true",
+                    focusable: "false",
+                    viewBox: k,
+                    shapeRendering: "crispEdges",
+                    className: "ds:block ds:h-full ds:w-full",
+                    children: [
+                      /* @__PURE__ */ b("rect", { x: 0, y: 0, width: "100%", height: "100%", fill: V }),
+                      D
+                    ]
+                  }
+                ) : /* @__PURE__ */ b(
+                  "svg",
+                  {
+                    "aria-hidden": "true",
+                    focusable: "false",
+                    viewBox: k,
+                    className: "ds:block ds:h-full ds:w-full",
+                    children: /* @__PURE__ */ b(
+                      "rect",
+                      {
+                        x: 0,
+                        y: 0,
+                        width: "100%",
+                        height: "100%",
+                        fill: V,
+                        className: "ds:opacity-0"
+                      }
+                    )
+                  }
+                ),
+                g && N ? /* @__PURE__ */ b(
+                  "span",
+                  {
+                    "aria-hidden": "true",
+                    "data-slot": "qr-center-logo",
+                    className: Bt({ tone: s }),
+                    children: N
+                  }
+                ) : null
+              ]
+            }
+          ),
+          T ? /* @__PURE__ */ b("p", { className: qt({ tone: s }), children: T }) : null
+        ]
+      }
+    );
+  }
+);
+St.displayName = "QrCode";
+export {
+  St as Q,
+  Ft as c,
+  dt as q,
+  Ht as s
+};
+//# sourceMappingURL=qr-code-DOJs4suh.js.map