@particle-academy/react-fancy 5.35.1 → 5.36.0

package/CHANGELOG.md

@@ -11,6 +11,57 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [5.36.0] - 2026-10-11
+
+### Added
+
+- **`<QrCode>` — a QR code as an SVG, with no dependencies.** ISO/IEC 18004,
+  versions 1–40, error correction L/M/Q/H, and numeric / alphanumeric / byte
+  modes selected automatically. **Nothing to do** — it is a new component and
+  nothing else changed.
+
+  ```tsx
+  <QrCode value="https://host/pair#482913" size={192} label="Pair this device" />
+  ```
+
+  `label` is required. A QR code is unusable to anyone who cannot point a second
+  device at the screen, so it needs an accessible name describing the
+  *destination* — and the value should also appear as text or a link nearby,
+  which an `aria-label` cannot substitute for.
+
+  Also exported on the `./qr-code` subpath, and **the encoder is exported
+  separately** (`encodeQr`, `selectMode`) for a consumer that needs the modules
+  rather than an SVG — a canvas, a PDF, a thermal printer, a terminal. Without
+  that, getting at them would mean adding a dependency for something already in
+  the package.
+
+  Three notes that decide whether a code actually scans, none of which are
+  visible in a screenshot:
+
+  - **The quiet zone is not padding.** It is how a scanner finds the symbol's
+    edge, so it defaults to the standard's minimum of 4 modules. `quietZone={0}`
+    is allowed and is not a space saving.
+  - **`background` defaults to `"transparent"`**, which inherits whatever is
+    behind it — so on a dark surface the symbol renders dark-on-dark and most
+    scanners refuse it. Set `foreground` and `background` together there.
+  - **`"H"` is not a free upgrade over `"M"`.** It survives more damage and
+    holds a third less, so at the same pixel width the modules are smaller; on a
+    phone screen it can read *worse*. Raise it for print or a covered symbol.
+
+  Rendered as a single `<path>` on a module-unit `viewBox` rather than a `<rect>`
+  per module: a version 10 symbol has over three thousand modules, and the
+  module-unit viewBox is what lets `size` scale with no resampling — a raster
+  code at a non-integer multiple of its module size has blurred module edges,
+  and a scanner reading a blurred edge guesses.
+
+  `encodeQr` throws a `RangeError` rather than truncating a value that will not
+  fit, because a truncated symbol scans cleanly and yields the wrong string.
+  Kanji mode and structured append are not supported; an untested branch in an
+  encoder fails as a code a phone quietly refuses to read.
+
+  Built for `claude · tynn`'s device-pairing panel (Genie 2 §6.8), which
+  previously had only a typed URL.
+
 ## [5.35.1] - 2026-10-10
 
 ### Fixed

package/dist/chunk-6KFCJLJN.cjs

@@ -0,0 +1,630 @@
+'use strict';
+
+var chunkZU5Q77OT_cjs = require('./chunk-ZU5Q77OT.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/QrCode/qr-tables.ts
+var EC_LEVELS = ["L", "M", "Q", "H"];
+var BLOCK_TABLE = [
+  // v1
+  [[19, 7, 1, 19, 0, 0], [16, 10, 1, 16, 0, 0], [13, 13, 1, 13, 0, 0], [9, 17, 1, 9, 0, 0]],
+  [[34, 10, 1, 34, 0, 0], [28, 16, 1, 28, 0, 0], [22, 22, 1, 22, 0, 0], [16, 28, 1, 16, 0, 0]],
+  [[55, 15, 1, 55, 0, 0], [44, 26, 1, 44, 0, 0], [34, 18, 2, 17, 0, 0], [26, 22, 2, 13, 0, 0]],
+  [[80, 20, 1, 80, 0, 0], [64, 18, 2, 32, 0, 0], [48, 26, 2, 24, 0, 0], [36, 16, 4, 9, 0, 0]],
+  [[108, 26, 1, 108, 0, 0], [86, 24, 2, 43, 0, 0], [62, 18, 2, 15, 2, 16], [46, 22, 2, 11, 2, 12]],
+  [[136, 18, 2, 68, 0, 0], [108, 16, 4, 27, 0, 0], [76, 24, 4, 19, 0, 0], [60, 28, 4, 15, 0, 0]],
+  [[156, 20, 2, 78, 0, 0], [124, 18, 4, 31, 0, 0], [88, 18, 2, 14, 4, 15], [66, 26, 4, 13, 1, 14]],
+  [[194, 24, 2, 97, 0, 0], [154, 22, 2, 38, 2, 39], [110, 22, 4, 18, 2, 19], [86, 26, 4, 14, 2, 15]],
+  [[232, 30, 2, 116, 0, 0], [182, 22, 3, 36, 2, 37], [132, 20, 4, 16, 4, 17], [100, 24, 4, 12, 4, 13]],
+  // v10
+  [[274, 18, 2, 68, 2, 69], [216, 26, 4, 43, 1, 44], [154, 24, 6, 19, 2, 20], [122, 28, 6, 15, 2, 16]],
+  [[324, 20, 4, 81, 0, 0], [254, 30, 1, 50, 4, 51], [180, 28, 4, 22, 4, 23], [140, 24, 3, 12, 8, 13]],
+  [[370, 24, 2, 92, 2, 93], [290, 22, 6, 36, 2, 37], [206, 26, 4, 20, 6, 21], [158, 28, 7, 14, 4, 15]],
+  [[428, 26, 4, 107, 0, 0], [334, 22, 8, 37, 1, 38], [244, 24, 8, 20, 4, 21], [180, 22, 12, 11, 4, 12]],
+  [[461, 30, 3, 115, 1, 116], [365, 24, 4, 40, 5, 41], [261, 20, 11, 16, 5, 17], [197, 24, 11, 12, 5, 13]],
+  [[523, 22, 5, 87, 1, 88], [415, 24, 5, 41, 5, 42], [295, 30, 5, 24, 7, 25], [223, 24, 11, 12, 7, 13]],
+  [[589, 24, 5, 98, 1, 99], [453, 28, 7, 45, 3, 46], [325, 24, 15, 19, 2, 20], [253, 30, 3, 15, 13, 16]],
+  [[647, 28, 1, 107, 5, 108], [507, 28, 10, 46, 1, 47], [367, 28, 1, 22, 15, 23], [283, 28, 2, 14, 17, 15]],
+  [[721, 30, 5, 120, 1, 121], [563, 26, 9, 43, 4, 44], [397, 28, 17, 22, 1, 23], [313, 28, 2, 14, 19, 15]],
+  [[795, 28, 3, 113, 4, 114], [627, 26, 3, 44, 11, 45], [445, 26, 17, 21, 4, 22], [341, 26, 9, 13, 16, 14]],
+  // v20
+  [[861, 28, 3, 107, 5, 108], [669, 26, 3, 41, 13, 42], [485, 30, 15, 24, 5, 25], [385, 28, 15, 15, 10, 16]],
+  [[932, 28, 4, 116, 4, 117], [714, 26, 17, 42, 0, 0], [512, 28, 17, 22, 6, 23], [406, 30, 19, 16, 6, 17]],
+  [[1006, 28, 2, 111, 7, 112], [782, 28, 17, 46, 0, 0], [568, 30, 7, 24, 16, 25], [442, 24, 34, 13, 0, 0]],
+  [[1094, 30, 4, 121, 5, 122], [860, 28, 4, 47, 14, 48], [614, 30, 11, 24, 14, 25], [464, 30, 16, 15, 14, 16]],
+  [[1174, 30, 6, 117, 4, 118], [914, 28, 6, 45, 14, 46], [664, 30, 11, 24, 16, 25], [514, 30, 30, 16, 2, 17]],
+  [[1276, 26, 8, 106, 4, 107], [1e3, 28, 8, 47, 13, 48], [718, 30, 7, 24, 22, 25], [538, 30, 22, 15, 13, 16]],
+  [[1370, 28, 10, 114, 2, 115], [1062, 28, 19, 46, 4, 47], [754, 28, 28, 22, 6, 23], [596, 30, 33, 16, 4, 17]],
+  [[1468, 30, 8, 122, 4, 123], [1128, 28, 22, 45, 3, 46], [808, 30, 8, 23, 26, 24], [628, 30, 12, 15, 28, 16]],
+  [[1531, 30, 3, 117, 10, 118], [1193, 28, 3, 45, 23, 46], [871, 30, 4, 24, 31, 25], [661, 30, 11, 15, 31, 16]],
+  [[1631, 30, 7, 116, 7, 117], [1267, 28, 21, 45, 7, 46], [911, 30, 1, 23, 37, 24], [701, 30, 19, 15, 26, 16]],
+  // v30
+  [[1735, 30, 5, 115, 10, 116], [1373, 28, 19, 47, 10, 48], [985, 30, 15, 24, 25, 25], [745, 30, 23, 15, 25, 16]],
+  [[1843, 30, 13, 115, 3, 116], [1455, 28, 2, 46, 29, 47], [1033, 30, 42, 24, 1, 25], [793, 30, 23, 15, 28, 16]],
+  [[1955, 30, 17, 115, 0, 0], [1541, 28, 10, 46, 23, 47], [1115, 30, 10, 24, 35, 25], [845, 30, 19, 15, 35, 16]],
+  [[2071, 30, 17, 115, 1, 116], [1631, 28, 14, 46, 21, 47], [1171, 30, 29, 24, 19, 25], [901, 30, 11, 15, 46, 16]],
+  [[2191, 30, 13, 115, 6, 116], [1725, 28, 14, 46, 23, 47], [1231, 30, 44, 24, 7, 25], [961, 30, 59, 16, 1, 17]],
+  [[2306, 30, 12, 121, 7, 122], [1812, 28, 12, 47, 26, 48], [1286, 30, 39, 24, 14, 25], [986, 30, 22, 15, 41, 16]],
+  [[2434, 30, 6, 121, 14, 122], [1914, 28, 6, 47, 34, 48], [1354, 30, 46, 24, 10, 25], [1054, 30, 2, 15, 64, 16]],
+  [[2566, 30, 17, 122, 4, 123], [1992, 28, 29, 46, 14, 47], [1426, 30, 49, 24, 10, 25], [1096, 30, 24, 15, 46, 16]],
+  [[2702, 30, 4, 122, 18, 123], [2102, 28, 13, 46, 32, 47], [1502, 30, 48, 24, 14, 25], [1142, 30, 42, 15, 32, 16]],
+  [[2812, 30, 20, 117, 4, 118], [2216, 28, 40, 47, 7, 48], [1582, 30, 43, 24, 22, 25], [1222, 30, 10, 15, 67, 16]],
+  // v40
+  [[2956, 30, 19, 118, 6, 119], [2334, 28, 18, 47, 31, 48], [1666, 30, 34, 24, 34, 25], [1276, 30, 20, 15, 61, 16]]
+];
+var MIN_VERSION = 1;
+var MAX_VERSION = 40;
+function blockLayout(version, ec) {
+  const row = BLOCK_TABLE[version - 1]?.[EC_LEVELS.indexOf(ec)];
+  if (!row) {
+    throw new RangeError(`No block layout for version ${version} level ${ec}`);
+  }
+  const [dataCodewords2, ecPerBlock, g1Blocks, g1Size, g2Blocks, g2Size] = row;
+  return { dataCodewords: dataCodewords2, ecPerBlock, g1Blocks, g1Size, g2Blocks, g2Size };
+}
+var FORMAT_BITS = {
+  L: [
+    30660,
+    29427,
+    32170,
+    30877,
+    26159,
+    25368,
+    27713,
+    26998
+  ],
+  M: [
+    21522,
+    20773,
+    24188,
+    23371,
+    17913,
+    16590,
+    20375,
+    19104
+  ],
+  Q: [
+    13663,
+    12392,
+    16177,
+    14854,
+    9396,
+    8579,
+    11994,
+    11245
+  ],
+  H: [
+    5769,
+    5054,
+    7399,
+    6608,
+    1890,
+    597,
+    3340,
+    2107
+  ]
+};
+function versionBits(version) {
+  let remainder = version;
+  for (let i = 0; i < 12; i += 1) {
+    remainder = remainder << 1 ^ (remainder >>> 11) * 7973;
+  }
+  return (version << 12 | remainder) >>> 0;
+}
+function alignmentPositions(version) {
+  if (version === 1) {
+    return [];
+  }
+  const count = Math.floor(version / 7) + 2;
+  const size = version * 4 + 17;
+  const step = version === 32 ? 26 : Math.ceil((size - 13) / (count * 2 - 2)) * 2;
+  const positions = [6];
+  for (let pos = size - 7; positions.length < count; pos -= step) {
+    positions.unshift(pos);
+  }
+  return positions.sort((a, b) => a - b);
+}
+
+// src/components/QrCode/qr-encode.ts
+var MODE_INDICATOR = { numeric: 1, alphanumeric: 2, byte: 4 };
+var ALPHANUMERIC = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+var EXP = new Uint8Array(256);
+var LOG = new Uint8Array(256);
+{
+  let x = 1;
+  for (let i = 0; i < 255; i += 1) {
+    EXP[i] = x;
+    LOG[x] = i;
+    x <<= 1;
+    if (x & 256) {
+      x ^= 285;
+    }
+  }
+  EXP[255] = EXP[0];
+}
+function gfMul(a, b) {
+  if (a === 0 || b === 0) {
+    return 0;
+  }
+  return EXP[(LOG[a] + LOG[b]) % 255];
+}
+function generatorPoly(degree) {
+  let poly = [1];
+  for (let i = 0; i < degree; i += 1) {
+    const next = new Array(poly.length + 1).fill(0);
+    for (let j = 0; j < poly.length; j += 1) {
+      next[j] = next[j] ^ poly[j];
+      next[j + 1] = next[j + 1] ^ gfMul(poly[j], EXP[i]);
+    }
+    poly = next;
+  }
+  return poly;
+}
+function reedSolomon(data, degree) {
+  const generator = generatorPoly(degree);
+  const remainder = new Array(degree).fill(0);
+  for (const byte of data) {
+    const factor = byte ^ remainder.shift();
+    remainder.push(0);
+    for (let i = 0; i < degree; i += 1) {
+      remainder[i] = remainder[i] ^ gfMul(generator[i + 1], factor);
+    }
+  }
+  return remainder;
+}
+function selectMode(value) {
+  if (/^[0-9]*$/.test(value)) {
+    return "numeric";
+  }
+  if ([...value].every((char) => ALPHANUMERIC.includes(char))) {
+    return "alphanumeric";
+  }
+  return "byte";
+}
+function countBits(mode, version) {
+  const tier = version <= 9 ? 0 : version <= 26 ? 1 : 2;
+  if (mode === "numeric") {
+    return [10, 12, 14][tier];
+  }
+  if (mode === "alphanumeric") {
+    return [9, 11, 13][tier];
+  }
+  return [8, 16, 16][tier];
+}
+var BitBuffer = class {
+  constructor() {
+    this.bits = [];
+  }
+  push(value, length) {
+    for (let i = length - 1; i >= 0; i -= 1) {
+      this.bits.push(value >>> i & 1);
+    }
+  }
+};
+function utf8Bytes(value) {
+  const out = [];
+  for (const char of value) {
+    const code = char.codePointAt(0);
+    if (code < 128) {
+      out.push(code);
+    } else if (code < 2048) {
+      out.push(192 | code >> 6, 128 | code & 63);
+    } else if (code < 65536) {
+      out.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+    } else {
+      out.push(
+        240 | code >> 18,
+        128 | code >> 12 & 63,
+        128 | code >> 6 & 63,
+        128 | code & 63
+      );
+    }
+  }
+  return out;
+}
+function encodePayload(value, mode, version) {
+  const buffer = new BitBuffer();
+  buffer.push(MODE_INDICATOR[mode], 4);
+  if (mode === "numeric") {
+    buffer.push(value.length, countBits(mode, version));
+    for (let i = 0; i < value.length; i += 3) {
+      const group = value.slice(i, i + 3);
+      buffer.push(Number.parseInt(group, 10), group.length * 3 + 1);
+    }
+    return buffer;
+  }
+  if (mode === "alphanumeric") {
+    buffer.push(value.length, countBits(mode, version));
+    for (let i = 0; i < value.length; i += 2) {
+      const first = ALPHANUMERIC.indexOf(value[i]);
+      if (i + 1 < value.length) {
+        buffer.push(first * 45 + ALPHANUMERIC.indexOf(value[i + 1]), 11);
+      } else {
+        buffer.push(first, 6);
+      }
+    }
+    return buffer;
+  }
+  const bytes = utf8Bytes(value);
+  buffer.push(bytes.length, countBits(mode, version));
+  for (const byte of bytes) {
+    buffer.push(byte, 8);
+  }
+  return buffer;
+}
+function payloadBits(value, mode, version) {
+  return encodePayload(value, mode, version).bits.length;
+}
+function selectVersion(value, mode, ec, minVersion) {
+  for (let version = Math.max(minVersion, MIN_VERSION); version <= MAX_VERSION; version += 1) {
+    if (payloadBits(value, mode, version) <= blockLayout(version, ec).dataCodewords * 8) {
+      return version;
+    }
+  }
+  return null;
+}
+function dataCodewords(value, mode, version, ec) {
+  const capacity = blockLayout(version, ec).dataCodewords * 8;
+  const buffer = encodePayload(value, mode, version);
+  buffer.push(0, Math.min(4, capacity - buffer.bits.length));
+  buffer.push(0, (8 - buffer.bits.length % 8) % 8);
+  const codewords = [];
+  for (let i = 0; i < buffer.bits.length; i += 8) {
+    let byte = 0;
+    for (let bit = 0; bit < 8; bit += 1) {
+      byte = byte << 1 | buffer.bits[i + bit];
+    }
+    codewords.push(byte);
+  }
+  const target = capacity / 8;
+  for (let i = 0; codewords.length < target; i += 1) {
+    codewords.push(i % 2 === 0 ? 236 : 17);
+  }
+  return codewords;
+}
+function interleave(codewords, version, ec) {
+  const { ecPerBlock, g1Blocks, g1Size, g2Blocks, g2Size } = blockLayout(version, ec);
+  const dataBlocks = [];
+  let offset = 0;
+  for (let i = 0; i < g1Blocks; i += 1) {
+    dataBlocks.push(codewords.slice(offset, offset + g1Size));
+    offset += g1Size;
+  }
+  for (let i = 0; i < g2Blocks; i += 1) {
+    dataBlocks.push(codewords.slice(offset, offset + g2Size));
+    offset += g2Size;
+  }
+  const ecBlocks = dataBlocks.map((block) => reedSolomon(block, ecPerBlock));
+  const result = [];
+  const widest = Math.max(g1Size, g2Blocks > 0 ? g2Size : 0);
+  for (let i = 0; i < widest; i += 1) {
+    for (const block of dataBlocks) {
+      if (i < block.length) {
+        result.push(block[i]);
+      }
+    }
+  }
+  for (let i = 0; i < ecPerBlock; i += 1) {
+    for (const block of ecBlocks) {
+      result.push(block[i]);
+    }
+  }
+  return result;
+}
+function reservedModules(version) {
+  const size = version * 4 + 17;
+  const grid = Array.from({ length: size }, () => new Array(size).fill(null));
+  const set = (row, col, dark) => {
+    grid[row][col] = dark;
+  };
+  for (const [baseRow, baseCol] of [
+    [0, 0],
+    [0, size - 7],
+    [size - 7, 0]
+  ]) {
+    for (let row = -1; row <= 7; row += 1) {
+      for (let col = -1; col <= 7; col += 1) {
+        const r = baseRow + row;
+        const c = baseCol + col;
+        if (r < 0 || r >= size || c < 0 || c >= size) {
+          continue;
+        }
+        const ring = Math.max(Math.abs(row - 3), Math.abs(col - 3));
+        set(r, c, ring !== 2 && ring <= 3);
+      }
+    }
+  }
+  for (let i = 0; i < size; i += 1) {
+    if (grid[6][i] === null) {
+      set(6, i, i % 2 === 0);
+    }
+    if (grid[i][6] === null) {
+      set(i, 6, i % 2 === 0);
+    }
+  }
+  const positions = alignmentPositions(version);
+  for (const row of positions) {
+    for (const col of positions) {
+      const nearFinder = row <= 8 && col <= 8 || row <= 8 && col >= size - 9 || row >= size - 9 && col <= 8;
+      if (nearFinder) {
+        continue;
+      }
+      for (let dr = -2; dr <= 2; dr += 1) {
+        for (let dc = -2; dc <= 2; dc += 1) {
+          const ring = Math.max(Math.abs(dr), Math.abs(dc));
+          set(row + dr, col + dc, ring !== 1);
+        }
+      }
+    }
+  }
+  for (let i = 0; i < 9; i += 1) {
+    if (grid[8][i] === null) {
+      set(8, i, false);
+    }
+    if (grid[i][8] === null) {
+      set(i, 8, false);
+    }
+  }
+  for (let i = 0; i < 8; i += 1) {
+    set(8, size - 1 - i, false);
+    set(size - 1 - i, 8, false);
+  }
+  set(size - 8, 8, true);
+  if (version >= 7) {
+    const bits = versionBits(version);
+    for (let i = 0; i < 18; i += 1) {
+      const bit = (bits >>> i & 1) === 1;
+      set(Math.floor(i / 3), size - 11 + i % 3, bit);
+      set(size - 11 + i % 3, Math.floor(i / 3), bit);
+    }
+  }
+  return grid;
+}
+function placeData(grid, codewords) {
+  const size = grid.length;
+  let bitIndex = 0;
+  const nextBit = () => {
+    const byte = codewords[bitIndex >>> 3];
+    const bit = byte === void 0 ? 0 : byte >>> 7 - (bitIndex & 7) & 1;
+    bitIndex += 1;
+    return bit === 1;
+  };
+  let upward = true;
+  for (let right = size - 1; right >= 1; right -= 2) {
+    const pair = right === 6 ? [5, 4] : [right, right - 1];
+    for (let step = 0; step < size; step += 1) {
+      const row = upward ? size - 1 - step : step;
+      for (const col of pair) {
+        if (grid[row][col] === null) {
+          grid[row][col] = nextBit();
+        }
+      }
+    }
+    if (right === 6) {
+      right -= 1;
+    }
+    upward = !upward;
+  }
+}
+function maskCondition(mask, row, col) {
+  switch (mask) {
+    case 0:
+      return (row + col) % 2 === 0;
+    case 1:
+      return row % 2 === 0;
+    case 2:
+      return col % 3 === 0;
+    case 3:
+      return (row + col) % 3 === 0;
+    case 4:
+      return (Math.floor(row / 2) + Math.floor(col / 3)) % 2 === 0;
+    case 5:
+      return row * col % 2 + row * col % 3 === 0;
+    case 6:
+      return (row * col % 2 + row * col % 3) % 2 === 0;
+    default:
+      return ((row + col) % 2 + row * col % 3) % 2 === 0;
+  }
+}
+function penalty(modules) {
+  const size = modules.length;
+  let score = 0;
+  const scoreLine = (run) => run >= 5 ? run - 2 : 0;
+  for (let i = 0; i < size; i += 1) {
+    for (const horizontal of [true, false]) {
+      let run = 1;
+      for (let j = 1; j < size; j += 1) {
+        const prev = horizontal ? modules[i][j - 1] : modules[j - 1][i];
+        const cur = horizontal ? modules[i][j] : modules[j][i];
+        if (cur === prev) {
+          run += 1;
+        } else {
+          score += scoreLine(run);
+          run = 1;
+        }
+      }
+      score += scoreLine(run);
+    }
+  }
+  for (let row = 0; row < size - 1; row += 1) {
+    for (let col = 0; col < size - 1; col += 1) {
+      const a = modules[row][col];
+      if (a === modules[row][col + 1] && a === modules[row + 1][col] && a === modules[row + 1][col + 1]) {
+        score += 3;
+      }
+    }
+  }
+  const finderish = [true, false, true, true, true, false, true];
+  const light4 = [false, false, false, false];
+  const matches = (line, at, pattern) => pattern.every((want, i) => line[at + i] === want);
+  for (let i = 0; i < size; i += 1) {
+    const row = modules[i];
+    const col = modules.map((r) => r[i]);
+    for (const line of [row, col]) {
+      for (let j = 0; j + 7 <= size; j += 1) {
+        if (!matches(line, j, finderish)) {
+          continue;
+        }
+        if (j >= 4 && matches(line, j - 4, light4)) {
+          score += 40;
+        }
+        if (j + 11 <= size && matches(line, j + 7, light4)) {
+          score += 40;
+        }
+      }
+    }
+  }
+  let dark = 0;
+  for (const row of modules) {
+    for (const cell of row) {
+      if (cell) {
+        dark += 1;
+      }
+    }
+  }
+  const percent = dark * 100 / (size * size);
+  score += Math.floor(Math.abs(percent - 50) / 5) * 10;
+  return score;
+}
+function applyFormat(modules, ec, mask) {
+  const size = modules.length;
+  const bits = FORMAT_BITS[ec][mask] >>> 0;
+  const bit = (i) => (bits >>> i & 1) === 1;
+  for (let i = 0; i <= 5; i += 1) {
+    modules[8][i] = bit(14 - i);
+  }
+  modules[8][7] = bit(8);
+  modules[8][8] = bit(7);
+  modules[7][8] = bit(6);
+  for (let i = 9; i <= 14; i += 1) {
+    modules[14 - i][8] = bit(14 - i);
+  }
+  for (let i = 0; i <= 6; i += 1) {
+    modules[size - 1 - i][8] = bit(i);
+  }
+  for (let i = 7; i <= 14; i += 1) {
+    modules[8][size - 15 + i] = bit(i);
+  }
+  modules[size - 8][8] = true;
+}
+function encodeQr(value, options = {}) {
+  const ec = options.errorCorrection ?? "M";
+  const mode = options.mode ?? selectMode(value);
+  if (mode === "numeric" && !/^[0-9]*$/.test(value)) {
+    throw new RangeError("Numeric mode accepts digits only");
+  }
+  if (mode === "alphanumeric" && ![...value].every((char) => ALPHANUMERIC.includes(char))) {
+    throw new RangeError("Alphanumeric mode accepts 0-9 A-Z space and $%*+-./: only");
+  }
+  let version;
+  if (options.version !== void 0) {
+    if (options.version < MIN_VERSION || options.version > MAX_VERSION) {
+      throw new RangeError(`Version must be ${MIN_VERSION}-${MAX_VERSION}`);
+    }
+    version = options.version;
+    if (payloadBits(value, mode, version) > blockLayout(version, ec).dataCodewords * 8) {
+      throw new RangeError(`Value does not fit in version ${version} at level ${ec}`);
+    }
+  } else {
+    const chosen = selectVersion(value, mode, ec, MIN_VERSION);
+    if (chosen === null) {
+      throw new RangeError(
+        `Value is too long for a QR code at level ${ec} (${value.length} characters)`
+      );
+    }
+    version = chosen;
+  }
+  const codewords = interleave(dataCodewords(value, mode, version, ec), version, ec);
+  const template = reservedModules(version);
+  const candidates = [];
+  const masksToTry = options.mask === void 0 ? [0, 1, 2, 3, 4, 5, 6, 7] : [options.mask];
+  for (const mask of masksToTry) {
+    const grid = template.map((row) => [...row]);
+    placeData(grid, codewords);
+    const modules = grid.map(
+      (row, rowIndex) => row.map((cell, colIndex) => {
+        const value_ = cell;
+        const isData = template[rowIndex][colIndex] === null;
+        return isData && maskCondition(mask, rowIndex, colIndex) ? !value_ : value_;
+      })
+    );
+    applyFormat(modules, ec, mask);
+    candidates.push({ mask, modules });
+  }
+  const best = candidates.reduce((a, b) => penalty(a.modules) <= penalty(b.modules) ? a : b);
+  return {
+    modules: best.modules,
+    size: version * 4 + 17,
+    version,
+    errorCorrection: ec,
+    mode,
+    mask: best.mask
+  };
+}
+var QrCode = react.forwardRef(
+  ({
+    value,
+    size = 192,
+    errorCorrection = "M",
+    label,
+    quietZone = 4,
+    foreground = "currentColor",
+    background = "transparent",
+    mode,
+    version,
+    className,
+    ...props
+  }, ref) => {
+    const symbol = react.useMemo(
+      () => encodeQr(value, { errorCorrection, mode, version }),
+      [value, errorCorrection, mode, version]
+    );
+    const extent = symbol.size + quietZone * 2;
+    const path = react.useMemo(() => {
+      const parts = [];
+      for (let row = 0; row < symbol.size; row += 1) {
+        const line = symbol.modules[row];
+        let col = 0;
+        while (col < symbol.size) {
+          if (!line[col]) {
+            col += 1;
+            continue;
+          }
+          let run = 1;
+          while (col + run < symbol.size && line[col + run]) {
+            run += 1;
+          }
+          parts.push(`M${col + quietZone} ${row + quietZone}h${run}v1h-${run}z`);
+          col += run;
+        }
+      }
+      return parts.join("");
+    }, [symbol, quietZone]);
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "svg",
+      {
+        ref,
+        width: size,
+        height: size,
+        viewBox: `0 0 ${extent} ${extent}`,
+        role: "img",
+        "aria-label": label,
+        shapeRendering: "crispEdges",
+        className: chunkZU5Q77OT_cjs.cn("fa-qr-code", className),
+        ...props,
+        children: [
+          background !== "transparent" && /* @__PURE__ */ jsxRuntime.jsx("rect", { width: extent, height: extent, fill: background }),
+          /* @__PURE__ */ jsxRuntime.jsx("path", { d: path, fill: foreground })
+        ]
+      }
+    );
+  }
+);
+QrCode.displayName = "QrCode";
+
+exports.QrCode = QrCode;
+exports.encodeQr = encodeQr;
+exports.selectMode = selectMode;
+//# sourceMappingURL=chunk-6KFCJLJN.cjs.map
+//# sourceMappingURL=chunk-6KFCJLJN.cjs.map