@manzanohq/components 0.1.1 → 0.1.4

package/dist/components/qr-code/qr-encoder.js

@@ -0,0 +1,710 @@
+const EC_LEVEL_BITS = { M: 0, L: 1, H: 2, Q: 3 };
+const ALPHANUMERIC_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+const DATA_CAPACITY = [
+  [19, 16, 13, 9],
+  [34, 28, 22, 16],
+  [55, 44, 34, 26],
+  [80, 64, 48, 36],
+  [108, 86, 62, 46],
+  [136, 108, 76, 60],
+  [156, 124, 88, 66],
+  [194, 154, 110, 86],
+  [232, 182, 132, 100],
+  [274, 216, 154, 122],
+  [324, 254, 180, 140],
+  [370, 290, 206, 158],
+  [428, 334, 244, 180],
+  [461, 365, 261, 197],
+  [523, 415, 295, 223],
+  [589, 453, 325, 253],
+  [647, 507, 367, 283],
+  [721, 563, 397, 313],
+  [795, 627, 445, 341],
+  [861, 669, 485, 385],
+  [932, 714, 512, 406],
+  [1006, 782, 568, 442],
+  [1094, 860, 614, 464],
+  [1174, 914, 664, 514],
+  [1276, 1e3, 718, 538],
+  [1370, 1062, 754, 596],
+  [1468, 1128, 808, 628],
+  [1531, 1193, 871, 661],
+  [1631, 1267, 911, 701],
+  [1735, 1373, 985, 745],
+  [1843, 1455, 1033, 793],
+  [1955, 1541, 1115, 845],
+  [2071, 1631, 1171, 901],
+  [2191, 1725, 1231, 961],
+  [2306, 1812, 1286, 986],
+  [2434, 1914, 1354, 1054],
+  [2566, 1992, 1426, 1096],
+  [2702, 2102, 1502, 1142],
+  [2812, 2216, 1582, 1222],
+  [2956, 2334, 1666, 1276]
+];
+const EC_CODEWORDS_PER_BLOCK = [
+  [7, 10, 13, 17],
+  [10, 16, 22, 28],
+  [15, 26, 18, 22],
+  [20, 18, 26, 16],
+  [26, 24, 18, 22],
+  [18, 16, 24, 28],
+  [20, 18, 18, 26],
+  [24, 22, 22, 26],
+  [30, 22, 20, 24],
+  [18, 26, 24, 28],
+  [20, 30, 28, 24],
+  [24, 22, 26, 28],
+  [26, 22, 24, 22],
+  [30, 24, 20, 24],
+  [22, 24, 30, 24],
+  [24, 28, 24, 30],
+  [28, 28, 28, 28],
+  [30, 26, 28, 28],
+  [28, 26, 26, 26],
+  [28, 26, 28, 28],
+  [28, 26, 30, 28],
+  [28, 28, 24, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [26, 28, 30, 30],
+  [28, 28, 28, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30],
+  [30, 28, 30, 30]
+];
+const EC_BLOCKS = [
+  [[1, 19, 0, 0], [1, 16, 0, 0], [1, 13, 0, 0], [1, 9, 0, 0]],
+  [[1, 34, 0, 0], [1, 28, 0, 0], [1, 22, 0, 0], [1, 16, 0, 0]],
+  [[1, 55, 0, 0], [1, 44, 0, 0], [2, 17, 0, 0], [2, 13, 0, 0]],
+  [[1, 80, 0, 0], [2, 32, 0, 0], [2, 24, 0, 0], [4, 9, 0, 0]],
+  [[1, 108, 0, 0], [2, 43, 0, 0], [2, 15, 2, 16], [2, 11, 2, 12]],
+  [[2, 68, 0, 0], [4, 27, 0, 0], [4, 19, 0, 0], [4, 15, 0, 0]],
+  [[2, 78, 0, 0], [4, 31, 0, 0], [2, 14, 4, 15], [4, 13, 1, 14]],
+  [[2, 97, 0, 0], [2, 38, 2, 39], [4, 18, 2, 19], [4, 14, 2, 15]],
+  [[2, 116, 0, 0], [3, 36, 2, 37], [4, 16, 4, 17], [4, 12, 4, 13]],
+  [[2, 68, 2, 69], [4, 43, 1, 44], [6, 19, 2, 20], [6, 15, 2, 16]],
+  [[4, 81, 0, 0], [1, 50, 4, 51], [4, 22, 4, 23], [3, 12, 8, 13]],
+  [[2, 92, 2, 93], [6, 36, 2, 37], [4, 20, 6, 21], [7, 14, 4, 15]],
+  [[4, 107, 0, 0], [8, 37, 1, 38], [8, 20, 4, 21], [12, 11, 4, 12]],
+  [[3, 115, 1, 116], [4, 40, 5, 41], [11, 16, 5, 17], [11, 12, 5, 13]],
+  [[5, 87, 1, 88], [5, 41, 5, 42], [5, 24, 7, 25], [11, 12, 7, 13]],
+  [[5, 98, 1, 99], [7, 45, 3, 46], [15, 19, 2, 20], [3, 15, 13, 16]],
+  [[1, 107, 5, 108], [10, 46, 1, 47], [1, 22, 15, 23], [2, 14, 17, 15]],
+  [[5, 120, 1, 121], [9, 43, 4, 44], [17, 22, 1, 23], [2, 14, 19, 15]],
+  [[3, 113, 4, 114], [3, 44, 11, 45], [17, 21, 4, 22], [9, 13, 16, 14]],
+  [[3, 107, 5, 108], [3, 41, 13, 42], [15, 24, 5, 25], [15, 15, 10, 16]],
+  [[4, 116, 4, 117], [17, 42, 0, 0], [17, 22, 6, 23], [19, 16, 6, 17]],
+  [[2, 111, 7, 112], [17, 46, 0, 0], [7, 24, 16, 25], [34, 13, 0, 0]],
+  [[4, 121, 5, 122], [4, 47, 14, 48], [11, 24, 14, 25], [16, 15, 14, 16]],
+  [[6, 117, 4, 118], [6, 45, 14, 46], [11, 24, 16, 25], [30, 16, 2, 17]],
+  [[8, 106, 4, 107], [8, 47, 13, 48], [7, 24, 22, 25], [22, 15, 13, 16]],
+  [[10, 114, 2, 115], [19, 46, 4, 47], [28, 22, 6, 23], [33, 16, 4, 17]],
+  [[8, 122, 4, 123], [22, 45, 3, 46], [8, 23, 26, 24], [12, 15, 28, 16]],
+  [[3, 117, 10, 118], [3, 45, 23, 46], [4, 24, 31, 25], [11, 15, 31, 16]],
+  [[7, 116, 7, 117], [21, 45, 7, 46], [1, 23, 37, 24], [19, 15, 26, 16]],
+  [[5, 115, 10, 116], [19, 47, 10, 48], [15, 24, 25, 25], [23, 15, 25, 16]],
+  [[13, 115, 3, 116], [2, 46, 29, 47], [42, 24, 1, 25], [23, 15, 28, 16]],
+  [[17, 115, 0, 0], [10, 46, 23, 47], [10, 24, 35, 25], [19, 15, 35, 16]],
+  [[17, 115, 1, 116], [14, 46, 21, 47], [29, 24, 19, 25], [11, 15, 46, 16]],
+  [[13, 115, 6, 116], [14, 46, 23, 47], [44, 24, 7, 25], [59, 16, 1, 17]],
+  [[12, 121, 7, 122], [12, 47, 26, 48], [39, 24, 14, 25], [22, 15, 41, 16]],
+  [[6, 121, 14, 122], [6, 47, 34, 48], [46, 24, 10, 25], [2, 15, 64, 16]],
+  [[17, 122, 4, 123], [29, 46, 14, 47], [49, 24, 10, 25], [24, 15, 46, 16]],
+  [[4, 122, 18, 123], [13, 46, 32, 47], [48, 24, 14, 25], [42, 15, 32, 16]],
+  [[20, 117, 4, 118], [40, 47, 7, 48], [43, 24, 22, 25], [10, 15, 67, 16]],
+  [[19, 118, 6, 119], [18, 47, 31, 48], [34, 24, 34, 25], [20, 15, 61, 16]]
+];
+const ALIGNMENT_POSITIONS = [
+  [],
+  [6, 18],
+  [6, 22],
+  [6, 26],
+  [6, 30],
+  [6, 34],
+  [6, 22, 38],
+  [6, 24, 42],
+  [6, 26, 46],
+  [6, 28, 50],
+  [6, 30, 54],
+  [6, 32, 58],
+  [6, 34, 62],
+  [6, 26, 46, 66],
+  [6, 26, 48, 70],
+  [6, 26, 50, 74],
+  [6, 30, 54, 78],
+  [6, 30, 56, 82],
+  [6, 30, 58, 86],
+  [6, 34, 62, 90],
+  [6, 28, 50, 72, 94],
+  [6, 26, 50, 74, 98],
+  [6, 30, 54, 78, 102],
+  [6, 28, 54, 80, 106],
+  [6, 32, 58, 84, 110],
+  [6, 30, 58, 86, 114],
+  [6, 34, 62, 90, 118],
+  [6, 26, 50, 74, 98, 122],
+  [6, 30, 54, 78, 102, 126],
+  [6, 26, 52, 78, 104, 130],
+  [6, 30, 56, 82, 108, 134],
+  [6, 34, 60, 86, 112, 138],
+  [6, 30, 58, 86, 114, 142],
+  [6, 34, 62, 90, 118, 146],
+  [6, 30, 54, 78, 102, 126, 150],
+  [6, 24, 50, 76, 102, 128, 154],
+  [6, 28, 54, 80, 106, 132, 158],
+  [6, 32, 58, 84, 110, 136, 162],
+  [6, 26, 54, 82, 110, 138, 166],
+  [6, 30, 58, 86, 114, 142, 170]
+];
+const GF_EXP = new Uint8Array(512);
+const GF_LOG = new Uint8Array(256);
+(function initGaloisField() {
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    GF_EXP[i] = x;
+    GF_LOG[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+  for (let i = 255; i < 512; i++) {
+    GF_EXP[i] = GF_EXP[i - 255];
+  }
+})();
+function gfMultiply(a, b) {
+  if (a === 0 || b === 0) return 0;
+  return GF_EXP[GF_LOG[a] + GF_LOG[b]];
+}
+function rsGeneratorPoly(degree) {
+  let gen = new Uint8Array([1]);
+  for (let i = 0; i < degree; i++) {
+    const next = new Uint8Array(gen.length + 1);
+    for (let j = 0; j < gen.length; j++) {
+      next[j] ^= gen[j];
+      next[j + 1] ^= gfMultiply(gen[j], GF_EXP[i]);
+    }
+    gen = next;
+  }
+  return gen;
+}
+function rsEncode(data, ecCount) {
+  const gen = rsGeneratorPoly(ecCount);
+  const result = new Uint8Array(ecCount);
+  for (let i = 0; i < data.length; i++) {
+    const coeff = data[i] ^ result[0];
+    for (let j = 0; j < ecCount - 1; j++) {
+      result[j] = result[j + 1];
+    }
+    result[ecCount - 1] = 0;
+    for (let j = 0; j < gen.length; j++) {
+      result[j] ^= gfMultiply(gen[j], coeff);
+    }
+  }
+  return result;
+}
+const EC_LEVEL_INDEX = { L: 0, M: 1, Q: 2, H: 3 };
+function getMode(text) {
+  if (/^\d+$/.test(text)) return "numeric";
+  if ([...text].every((c) => ALPHANUMERIC_CHARS.includes(c))) return "alphanumeric";
+  return "byte";
+}
+function getCharCountBits(version, mode) {
+  if (version <= 9) {
+    return mode === "numeric" ? 10 : mode === "alphanumeric" ? 9 : 8;
+  } else if (version <= 26) {
+    return mode === "numeric" ? 12 : mode === "alphanumeric" ? 11 : 16;
+  } else {
+    return mode === "numeric" ? 14 : mode === "alphanumeric" ? 13 : 16;
+  }
+}
+function selectVersion(dataBytes, mode, ecLevel) {
+  const ecIdx = EC_LEVEL_INDEX[ecLevel];
+  for (let v = 1; v <= 40; v++) {
+    const capacity = DATA_CAPACITY[v - 1][ecIdx];
+    const charCountBits = getCharCountBits(v, mode);
+    let modeBits;
+    let dataBits;
+    if (mode === "numeric") {
+      modeBits = 4;
+      const len = dataBytes.length;
+      dataBits = modeBits + charCountBits + Math.floor(len / 3) * 10 + (len % 3 === 2 ? 7 : len % 3 === 1 ? 4 : 0);
+    } else if (mode === "alphanumeric") {
+      modeBits = 4;
+      const len = dataBytes.length;
+      dataBits = modeBits + charCountBits + Math.floor(len / 2) * 11 + (len % 2 === 1 ? 6 : 0);
+    } else {
+      modeBits = 4;
+      dataBits = modeBits + charCountBits + dataBytes.length * 8;
+    }
+    const totalBytes = Math.ceil(dataBits / 8);
+    if (totalBytes <= capacity) return v;
+  }
+  throw new Error("Data too long for QR code");
+}
+class BitBuffer {
+  constructor() {
+    this.buffer = [];
+    this.length = 0;
+  }
+  put(num, bitLength) {
+    for (let i = bitLength - 1; i >= 0; i--) {
+      this.buffer.push(num >>> i & 1);
+      this.length++;
+    }
+  }
+  getBit(index) {
+    return this.buffer[index];
+  }
+  getLengthInBits() {
+    return this.length;
+  }
+  toBytes() {
+    const byteCount = Math.ceil(this.length / 8);
+    const result = new Uint8Array(byteCount);
+    for (let i = 0; i < this.length; i++) {
+      if (this.buffer[i]) {
+        result[i >>> 3] |= 128 >>> (i & 7);
+      }
+    }
+    return result;
+  }
+}
+function encodeData(text, mode, version, ecLevel) {
+  const ecIdx = EC_LEVEL_INDEX[ecLevel];
+  const capacity = DATA_CAPACITY[version - 1][ecIdx];
+  const buffer = new BitBuffer();
+  const modeIndicator = mode === "numeric" ? 1 : mode === "alphanumeric" ? 2 : 4;
+  buffer.put(modeIndicator, 4);
+  const charCountBits = getCharCountBits(version, mode);
+  if (mode === "numeric") {
+    buffer.put(text.length, charCountBits);
+    for (let i = 0; i < text.length; i += 3) {
+      const group = text.substring(i, Math.min(i + 3, text.length));
+      const num = parseInt(group, 10);
+      if (group.length === 3) buffer.put(num, 10);
+      else if (group.length === 2) buffer.put(num, 7);
+      else buffer.put(num, 4);
+    }
+  } else if (mode === "alphanumeric") {
+    buffer.put(text.length, charCountBits);
+    for (let i = 0; i < text.length; i += 2) {
+      if (i + 1 < text.length) {
+        const val = ALPHANUMERIC_CHARS.indexOf(text[i]) * 45 + ALPHANUMERIC_CHARS.indexOf(text[i + 1]);
+        buffer.put(val, 11);
+      } else {
+        buffer.put(ALPHANUMERIC_CHARS.indexOf(text[i]), 6);
+      }
+    }
+  } else {
+    const encoder = new TextEncoder();
+    const bytes = encoder.encode(text);
+    buffer.put(bytes.length, charCountBits);
+    for (const b of bytes) {
+      buffer.put(b, 8);
+    }
+  }
+  const terminatorLength = Math.min(4, capacity * 8 - buffer.getLengthInBits());
+  buffer.put(0, terminatorLength);
+  while (buffer.getLengthInBits() % 8 !== 0) {
+    buffer.put(0, 1);
+  }
+  const padBytes = [236, 17];
+  let padIndex = 0;
+  while (buffer.getLengthInBits() < capacity * 8) {
+    buffer.put(padBytes[padIndex % 2], 8);
+    padIndex++;
+  }
+  return buffer.toBytes();
+}
+function createBlocks(data, version, ecLevel) {
+  const ecIdx = EC_LEVEL_INDEX[ecLevel];
+  const ecPerBlock = EC_CODEWORDS_PER_BLOCK[version - 1][ecIdx];
+  const [g1Count, g1DataCw, g2Count, g2DataCw] = EC_BLOCKS[version - 1][ecIdx];
+  const dataBlocks = [];
+  const ecBlocks = [];
+  let offset = 0;
+  for (let i = 0; i < g1Count; i++) {
+    const block = data.slice(offset, offset + g1DataCw);
+    dataBlocks.push(block);
+    ecBlocks.push(rsEncode(block, ecPerBlock));
+    offset += g1DataCw;
+  }
+  for (let i = 0; i < g2Count; i++) {
+    const block = data.slice(offset, offset + g2DataCw);
+    dataBlocks.push(block);
+    ecBlocks.push(rsEncode(block, ecPerBlock));
+    offset += g2DataCw;
+  }
+  return { dataBlocks, ecBlocks };
+}
+function interleaveBlocks(dataBlocks, ecBlocks) {
+  const result = [];
+  const maxDataLen = Math.max(...dataBlocks.map((b) => b.length));
+  for (let i = 0; i < maxDataLen; i++) {
+    for (const block of dataBlocks) {
+      if (i < block.length) result.push(block[i]);
+    }
+  }
+  const maxEcLen = Math.max(...ecBlocks.map((b) => b.length));
+  for (let i = 0; i < maxEcLen; i++) {
+    for (const block of ecBlocks) {
+      if (i < block.length) result.push(block[i]);
+    }
+  }
+  return new Uint8Array(result);
+}
+function getModuleCount(version) {
+  return version * 4 + 17;
+}
+function createMatrix(size) {
+  const matrix = Array.from({ length: size }, () => Array(size).fill(null));
+  const reserved = Array.from({ length: size }, () => Array(size).fill(false));
+  return { matrix, reserved };
+}
+function placeFinderPattern(matrix, reserved, row, col) {
+  for (let r = -1; r <= 7; r++) {
+    for (let c = -1; c <= 7; c++) {
+      const mr = row + r;
+      const mc = col + c;
+      if (mr < 0 || mr >= matrix.length || mc < 0 || mc >= matrix.length) continue;
+      let val;
+      if (r === -1 || r === 7 || c === -1 || c === 7) {
+        val = 0;
+      } else if ((r === 0 || r === 6) && c >= 0 && c <= 6) {
+        val = 1;
+      } else if ((c === 0 || c === 6) && r >= 0 && r <= 6) {
+        val = 1;
+      } else if (r >= 2 && r <= 4 && c >= 2 && c <= 4) {
+        val = 1;
+      } else {
+        val = 0;
+      }
+      matrix[mr][mc] = val;
+      reserved[mr][mc] = true;
+    }
+  }
+}
+function placeAlignmentPattern(matrix, reserved, row, col) {
+  for (let r = -2; r <= 2; r++) {
+    for (let c = -2; c <= 2; c++) {
+      const mr = row + r;
+      const mc = col + c;
+      if (mr < 0 || mr >= matrix.length || mc < 0 || mc >= matrix.length) continue;
+      if (reserved[mr][mc]) return;
+    }
+  }
+  for (let r = -2; r <= 2; r++) {
+    for (let c = -2; c <= 2; c++) {
+      const mr = row + r;
+      const mc = col + c;
+      let val;
+      if (r === -2 || r === 2 || c === -2 || c === 2 || r === 0 && c === 0) {
+        val = 1;
+      } else {
+        val = 0;
+      }
+      matrix[mr][mc] = val;
+      reserved[mr][mc] = true;
+    }
+  }
+}
+function placeTimingPatterns(matrix, reserved) {
+  const size = matrix.length;
+  for (let i = 8; i < size - 8; i++) {
+    if (!reserved[6][i]) {
+      matrix[6][i] = i % 2 === 0 ? 1 : 0;
+      reserved[6][i] = true;
+    }
+    if (!reserved[i][6]) {
+      matrix[i][6] = i % 2 === 0 ? 1 : 0;
+      reserved[i][6] = true;
+    }
+  }
+}
+function placeDarkModule(matrix, reserved, version) {
+  const row = 4 * version + 9;
+  matrix[row][8] = 1;
+  reserved[row][8] = true;
+}
+function reserveFormatArea(matrix, reserved) {
+  const size = matrix.length;
+  for (let i = 0; i <= 8; i++) {
+    if (!reserved[8][i]) reserved[8][i] = true;
+    if (!reserved[i][8]) reserved[i][8] = true;
+  }
+  for (let i = 0; i <= 7; i++) {
+    if (!reserved[8][size - 1 - i]) reserved[8][size - 1 - i] = true;
+  }
+  for (let i = 0; i <= 7; i++) {
+    if (!reserved[size - 1 - i][8]) reserved[size - 1 - i][8] = true;
+  }
+}
+function reserveVersionArea(reserved, version) {
+  if (version < 7) return;
+  const size = reserved.length;
+  for (let i = 0; i < 6; i++) {
+    for (let j = 0; j < 3; j++) {
+      reserved[size - 11 + j][i] = true;
+    }
+  }
+  for (let i = 0; i < 6; i++) {
+    for (let j = 0; j < 3; j++) {
+      reserved[i][size - 11 + j] = true;
+    }
+  }
+}
+function placeDataBits(matrix, reserved, data) {
+  const size = matrix.length;
+  let bitIndex = 0;
+  const totalBits = data.length * 8;
+  let upward = true;
+  for (let right = size - 1; right >= 1; right -= 2) {
+    if (right === 6) right = 5;
+    for (let i = 0; i < size; i++) {
+      const row = upward ? size - 1 - i : i;
+      for (let dx = 0; dx <= 1; dx++) {
+        const col = right - dx;
+        if (col < 0 || col >= size) continue;
+        if (reserved[row][col]) continue;
+        if (bitIndex < totalBits) {
+          const byteIdx = bitIndex >>> 3;
+          const bitIdx = 7 - (bitIndex & 7);
+          matrix[row][col] = data[byteIdx] >>> bitIdx & 1;
+          bitIndex++;
+        } else {
+          matrix[row][col] = 0;
+        }
+      }
+    }
+    upward = !upward;
+  }
+}
+const MASK_FUNCTIONS = [
+  (r, c) => (r + c) % 2 === 0,
+  (r) => r % 2 === 0,
+  (_, c) => c % 3 === 0,
+  (r, c) => (r + c) % 3 === 0,
+  (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+  (r, c) => r * c % 2 + r * c % 3 === 0,
+  (r, c) => (r * c % 2 + r * c % 3) % 2 === 0,
+  (r, c) => ((r + c) % 2 + r * c % 3) % 2 === 0
+];
+function applyMask(matrix, reserved, maskIndex) {
+  const size = matrix.length;
+  const result = Array.from(
+    { length: size },
+    (_, r) => Array.from({ length: size }, (_2, c) => matrix[r][c] ?? 0)
+  );
+  const maskFn = MASK_FUNCTIONS[maskIndex];
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) {
+      if (!reserved[r][c] && maskFn(r, c)) {
+        result[r][c] = result[r][c] ? 0 : 1;
+      }
+    }
+  }
+  return result;
+}
+function getFormatBits(ecLevel, maskIndex) {
+  const data = EC_LEVEL_BITS[ecLevel] << 3 | maskIndex;
+  let bits = data << 10;
+  let gen = 1335;
+  for (let i = 14; i >= 10; i--) {
+    if (bits & 1 << i) {
+      bits ^= gen << i - 10;
+    }
+  }
+  const result = data << 10 | bits;
+  return result ^ 21522;
+}
+function placeFormatBits(matrix, ecLevel, maskIndex) {
+  const size = matrix.length;
+  const formatBits = getFormatBits(ecLevel, maskIndex);
+  const positions = [];
+  for (let i = 0; i <= 7; i++) {
+    const col = i <= 5 ? i : i + 1;
+    positions.push([8, col]);
+  }
+  const hCols = [0, 1, 2, 3, 4, 5, 7, 8];
+  for (let i = 0; i < 8; i++) {
+    matrix[8][hCols[i]] = formatBits >>> 14 - i & 1;
+  }
+  const vRows = [7, 5, 4, 3, 2, 1, 0];
+  for (let i = 0; i < 7; i++) {
+    matrix[vRows[i]][8] = formatBits >>> 14 - 8 - i & 1;
+  }
+  for (let i = 0; i < 8; i++) {
+    matrix[8][size - 8 + i] = formatBits >>> 7 - i & 1;
+  }
+  for (let i = 0; i < 7; i++) {
+    matrix[size - 7 + i][8] = formatBits >>> 6 - i & 1;
+  }
+}
+function getVersionBits(version) {
+  if (version < 7) return 0;
+  let bits = version << 12;
+  const gen = 7973;
+  for (let i = 17; i >= 12; i--) {
+    if (bits & 1 << i) {
+      bits ^= gen << i - 12;
+    }
+  }
+  return version << 12 | bits;
+}
+function placeVersionBits(matrix, version) {
+  if (version < 7) return;
+  const size = matrix.length;
+  const versionBits = getVersionBits(version);
+  for (let i = 0; i < 6; i++) {
+    for (let j = 0; j < 3; j++) {
+      const bit = versionBits >>> i * 3 + j & 1;
+      matrix[size - 11 + j][i] = bit;
+      matrix[i][size - 11 + j] = bit;
+    }
+  }
+}
+function calculatePenalty(matrix) {
+  const size = matrix.length;
+  let penalty = 0;
+  for (let r = 0; r < size; r++) {
+    let count = 1;
+    for (let c = 1; c < size; c++) {
+      if (matrix[r][c] === matrix[r][c - 1]) {
+        count++;
+      } else {
+        if (count >= 5) penalty += count - 2;
+        count = 1;
+      }
+    }
+    if (count >= 5) penalty += count - 2;
+  }
+  for (let c = 0; c < size; c++) {
+    let count = 1;
+    for (let r = 1; r < size; r++) {
+      if (matrix[r][c] === matrix[r - 1][c]) {
+        count++;
+      } else {
+        if (count >= 5) penalty += count - 2;
+        count = 1;
+      }
+    }
+    if (count >= 5) penalty += count - 2;
+  }
+  for (let r = 0; r < size - 1; r++) {
+    for (let c = 0; c < size - 1; c++) {
+      const val = matrix[r][c];
+      if (val === matrix[r][c + 1] && val === matrix[r + 1][c] && val === matrix[r + 1][c + 1]) {
+        penalty += 3;
+      }
+    }
+  }
+  const pattern1 = [1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0];
+  const pattern2 = [0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1];
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c <= size - 11; c++) {
+      let match1 = true;
+      let match2 = true;
+      for (let k = 0; k < 11; k++) {
+        if (matrix[r][c + k] !== pattern1[k]) match1 = false;
+        if (matrix[r][c + k] !== pattern2[k]) match2 = false;
+      }
+      if (match1 || match2) penalty += 40;
+    }
+  }
+  for (let c = 0; c < size; c++) {
+    for (let r = 0; r <= size - 11; r++) {
+      let match1 = true;
+      let match2 = true;
+      for (let k = 0; k < 11; k++) {
+        if (matrix[r + k][c] !== pattern1[k]) match1 = false;
+        if (matrix[r + k][c] !== pattern2[k]) match2 = false;
+      }
+      if (match1 || match2) penalty += 40;
+    }
+  }
+  let darkCount = 0;
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) {
+      if (matrix[r][c] === 1) darkCount++;
+    }
+  }
+  const total = size * size;
+  const percentage = darkCount / total * 100;
+  const prevMultiple = Math.floor(percentage / 5) * 5;
+  const nextMultiple = prevMultiple + 5;
+  const p1 = Math.abs(prevMultiple - 50) / 5;
+  const p2 = Math.abs(nextMultiple - 50) / 5;
+  penalty += Math.min(p1, p2) * 10;
+  return penalty;
+}
+function generateQR(text, ecLevel = "M") {
+  if (!text) return [];
+  const mode = getMode(text);
+  let dataForSizing;
+  if (mode === "byte") {
+    dataForSizing = new TextEncoder().encode(text);
+  } else {
+    dataForSizing = new Uint8Array(text.length);
+  }
+  const version = selectVersion(
+    mode === "byte" ? dataForSizing : new Uint8Array([...text].map((_, i) => i)),
+    mode,
+    ecLevel
+  );
+  const size = getModuleCount(version);
+  const encodedData = encodeData(text, mode, version, ecLevel);
+  const { dataBlocks, ecBlocks } = createBlocks(encodedData, version, ecLevel);
+  const finalData = interleaveBlocks(dataBlocks, ecBlocks);
+  const { matrix, reserved } = createMatrix(size);
+  placeFinderPattern(matrix, reserved, 0, 0);
+  placeFinderPattern(matrix, reserved, 0, size - 7);
+  placeFinderPattern(matrix, reserved, size - 7, 0);
+  if (version >= 2) {
+    const positions = ALIGNMENT_POSITIONS[version - 1];
+    for (let i = 0; i < positions.length; i++) {
+      for (let j = 0; j < positions.length; j++) {
+        placeAlignmentPattern(matrix, reserved, positions[i], positions[j]);
+      }
+    }
+  }
+  placeTimingPatterns(matrix, reserved);
+  placeDarkModule(matrix, reserved, version);
+  reserveFormatArea(matrix, reserved);
+  reserveVersionArea(reserved, version);
+  placeDataBits(matrix, reserved, finalData);
+  let bestMask = 0;
+  let bestPenalty = Infinity;
+  let bestMatrix = null;
+  for (let m = 0; m < 8; m++) {
+    const masked = applyMask(matrix, reserved, m);
+    placeFormatBits(masked, ecLevel, m);
+    placeVersionBits(masked, version);
+    const penalty = calculatePenalty(masked);
+    if (penalty < bestPenalty) {
+      bestPenalty = penalty;
+      bestMask = m;
+      bestMatrix = masked;
+    }
+  }
+  if (!bestMatrix) {
+    bestMatrix = applyMask(matrix, reserved, bestMask);
+    placeFormatBits(bestMatrix, ecLevel, bestMask);
+    placeVersionBits(bestMatrix, version);
+  }
+  return bestMatrix.map((row) => row.map((cell) => cell === 1));
+}
+export {
+  generateQR
+};
+//# sourceMappingURL=qr-encoder.js.map