@sythos/js_barcode_universal 0.1.0 → 1.1.0

package/bundle/sythos-barcode.esm.js

@@ -1,5 +1,5 @@
 /*!
- * Sythos Barcode Suite v0.1.0
+ * Sythos Barcode Suite v1.1.0
  *
  * MIT License
  *
@@ -2751,155 +2751,6 @@ __modules["oned/index.js"] = function (__require, __exports) {
 __exports.ONED_FORMATS = ONED_FORMATS;
 };
 
-__modules["core/bit-buffer.js"] = function (__require, __exports) {
-/**
- * Bit-level writing and reading, MSB-first.
- *
- * Every 2D symbology serialises its payload as a bitstream that does not
- * respect byte boundaries — QR alone mixes 4-bit mode indicators, 10-bit
- * character-count fields and 11-bit alphanumeric pairs. These two classes are
- * the write and read halves of that.
- *
- * @module core/bit-buffer
- */
-const { FormatError } = __require("core/errors.js");
-
-/** Growable MSB-first bit writer. */
-class BitWriter {
-  constructor() {
-    /** @type {number[]} Packed bytes; the last one may be partially filled. */
-    this.bytes = [];
-    this.bitLength = 0;
-  }
-
-  /** @returns {number} Bits written so far. */
-  get length() {
-    return this.bitLength;
-  }
-
-  /**
-   * Append the low `count` bits of `value`, most significant first.
-   *
-   * @param {number} value
-   * @param {number} count
-   */
-  put(value, count) {
-    for (let i = count - 1; i >= 0; i--) {
-      this.putBit(((value >>> i) & 1) === 1);
-    }
-  }
-
-  /** @param {boolean} bit */
-  putBit(bit) {
-    const idx = this.bitLength >>> 3;
-    if (this.bytes.length <= idx) this.bytes.push(0);
-    if (bit) this.bytes[idx] |= 0x80 >>> (this.bitLength & 7);
-    this.bitLength++;
-  }
-
-  /** @param {ArrayLike<number>} data */
-  putBytes(data) {
-    for (let i = 0; i < data.length; i++) this.put(data[i], 8);
-  }
-
-  /** Pad with zero bits until the length is a multiple of 8. */
-  padToByte() {
-    while (this.bitLength & 7) this.putBit(false);
-  }
-
-  /**
-   * @returns {Uint8Array} Byte view; trailing bits of the final byte are zero.
-   */
-  toBytes() {
-    return Uint8Array.from(this.bytes);
-  }
-
-  /** @returns {string} Debug view, e.g. "0100 0011 0101". */
-  toString() {
-    let s = '';
-    for (let i = 0; i < this.bitLength; i++) {
-      if (i && i % 4 === 0) s += ' ';
-      s += (this.bytes[i >>> 3] >>> (7 - (i & 7))) & 1;
-    }
-    return s;
-  }
-}
-
-/** MSB-first bit reader over a byte array. */
-class BitReader {
-  /** @param {ArrayLike<number>} bytes */
-  constructor(bytes) {
-    this.bytes = bytes;
-    this.byteOffset = 0;
-    this.bitOffset = 0;
-  }
-
-  /** @returns {number} Bits not yet consumed. */
-  available() {
-    return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;
-  }
-
-  /**
-   * Read `count` bits (1..32) as an unsigned integer, most significant first.
-   *
-   * @param {number} count
-   * @returns {number}
-   * @throws {FormatError} If the stream is exhausted.
-   */
-  read(count) {
-    if (count < 1 || count > 32) {
-      throw new FormatError(`BitReader: cannot read ${count} bits`);
-    }
-    if (count > this.available()) {
-      throw new FormatError(
-        `BitReader: needed ${count} bits, ${this.available()} remain`
-      );
-    }
-
-    let result = 0;
-    let remaining = count;
-
-    // Finish the partially consumed byte first, then take whole bytes.
-    if (this.bitOffset > 0) {
-      const inCurrent = 8 - this.bitOffset;
-      const take = Math.min(remaining, inCurrent);
-      const shift = inCurrent - take;
-      const mask = (0xff >> this.bitOffset) & ~((1 << shift) - 1);
-      result = (this.bytes[this.byteOffset] & mask) >> shift;
-      remaining -= take;
-      this.bitOffset += take;
-      if (this.bitOffset === 8) {
-        this.bitOffset = 0;
-        this.byteOffset++;
-      }
-    }
-
-    while (remaining >= 8) {
-      result = (result << 8) | (this.bytes[this.byteOffset] & 0xff);
-      this.byteOffset++;
-      remaining -= 8;
-    }
-
-    if (remaining > 0) {
-      const shift = 8 - remaining;
-      const mask = ~((1 << shift) - 1) & 0xff;
-      result = (result << remaining) | ((this.bytes[this.byteOffset] & mask) >> shift);
-      this.bitOffset += remaining;
-    }
-
-    return result >>> 0;
-  }
-
-  /** @returns {boolean} */
-  readBit() {
-    return this.read(1) === 1;
-  }
-}
-
-__exports.BitWriter = BitWriter;
-__exports.BitReader = BitReader;
-};
-
 __modules["core/galois-field.js"] = function (__require, __exports) {
 /**
  * Finite field arithmetic.
@@ -3066,6 +2917,9 @@ const GF256_QR = new GaloisField({ size: 256, primitive: 0x011d, name: 'GF(256)/
 /** Data Matrix ECC200. x^8 + x^5 + x^3 + x^2 + 1 */
 const GF256_DM = new GaloisField({ size: 256, primitive: 0x012d, name: 'GF(256)/DataMatrix' });
 
+/** Aztec's eight-bit data field is algebraically identical to Data Matrix's. */
+const GF256_AZTEC = GF256_DM;
+
 /** PDF417. Prime field; 3 is a primitive root modulo 929. */
 const GF929 = new GaloisField({ size: 929, prime: true, generator: 3, name: 'GF(929)' });
 
@@ -3078,6 +2932,7 @@ const GF4096 = new GaloisField({ size: 4096, primitive: 0x1069, name: 'GF(4096)'
 __exports.GaloisField = GaloisField;
 __exports.GF256_QR = GF256_QR;
 __exports.GF256_DM = GF256_DM;
+__exports.GF256_AZTEC = GF256_AZTEC;
 __exports.GF929 = GF929;
 __exports.GF16 = GF16;
 __exports.GF64 = GF64;
@@ -3113,7 +2968,7 @@ const { ChecksumError } = __require("core/errors.js");
  *
  *   g(x) = product over i of (x - a^(base + i)),  i = 0 .. eccLen-1
  *
- * `base` is 0 for QR, Data Matrix and Aztec; 1 for PDF417.
+ * `base` is 0 for QR; 1 for Aztec, Data Matrix and PDF417.
  *
  * @param {number} eccLen
  * @param {import('./galois-field.js').GaloisField} field
@@ -3374,349 +3229,1521 @@ __exports.rsEncode = rsEncode;
 __exports.rsDecode = rsDecode;
 };
 
-__modules["qr/tables.js"] = function (__require, __exports) {
+__modules["datamatrix/tables.js"] = function (__require, __exports) {
 /**
- * QR Code structural tables.
- *
- * The design principle here is that as little as possible is *recalled* and as
- * much as possible is *derived*, because a barcode table is the one place where
- * a single mistyped digit produces a symbol that looks perfect and scans as
- * garbage — or, worse, scans correctly for the payload you tested and fails for
- * the payload your user sends.
- *
- * So:
+ * Data Matrix ECC 200 symbol parameters.
  *
- *   - Symbol size, function-pattern layout and total codeword capacity are
- *     computed from geometry. Nothing is tabulated that the module grid already
- *     knows.
- *   - Alignment centres come from the spec's spacing rule, not a 40-row table.
- *   - The group-1 / group-2 block split is arithmetic, not data.
- *
- * That leaves exactly three recalled numbers per (version, level): the error
- * correction codewords per block, the block count, and the total data codeword
- * count. Those three are deliberately redundant — they must satisfy
- *
- *     blocks * eccPerBlock + totalDataCodewords === geometricTotalCodewords(v)
- *
- * for all 160 combinations, where the right-hand side is counted off the module
- * grid. Any single typo on either side breaks the identity. {@link validateTables}
- * enforces it, and the test suite asserts it returns no problems.
+ * Width and height include finder borders. `regionWidth` and `regionHeight`
+ * describe the usable modules inside one data region. The last three columns
+ * make the Reed-Solomon block split explicit instead of hiding the 144x144
+ * exception in encoder control flow.
  *
- * @module qr/tables
+ * @module datamatrix/tables
  */
+
+function symbol(width, height, dataRegionWidth, dataRegionHeight, dataCodewords, errorCodewords, dataBlockLengths) {
+  const blockCount = dataBlockLengths.length;
+  return Object.freeze({
+    width, height, rows: height, columns: width,
+    // Region dimensions include their one-module finder border on each side;
+    // dataRegion* expose the inner placement lattice explicitly.
+    regionWidth: dataRegionWidth + 2, regionHeight: dataRegionHeight + 2,
+    dataRegionWidth, dataRegionHeight,
+    dataRegionRows: dataRegionHeight, dataRegionColumns: dataRegionWidth,
+    dataCodewords, errorCodewords, blockCount,
+    eccPerBlock: errorCodewords / blockCount,
+    dataBlockLengths: Object.freeze(dataBlockLengths),
+  });
+}
+
+/** Classic ISO/IEC 16022 ECC 200 symbols; DMRE is deliberately excluded. */
+const DATAMATRIX_SYMBOLS = Object.freeze([
+  symbol(10, 10, 8, 8, 3, 5, [3]),
+  symbol(12, 12, 10, 10, 5, 7, [5]),
+  symbol(14, 14, 12, 12, 8, 10, [8]),
+  symbol(16, 16, 14, 14, 12, 12, [12]),
+  symbol(18, 18, 16, 16, 18, 14, [18]),
+  symbol(20, 20, 18, 18, 22, 18, [22]),
+  symbol(22, 22, 20, 20, 30, 20, [30]),
+  symbol(24, 24, 22, 22, 36, 24, [36]),
+  symbol(26, 26, 24, 24, 44, 28, [44]),
+  symbol(32, 32, 14, 14, 62, 36, [62]),
+  symbol(36, 36, 16, 16, 86, 42, [86]),
+  symbol(40, 40, 18, 18, 114, 48, [114]),
+  symbol(44, 44, 20, 20, 144, 56, [144]),
+  symbol(48, 48, 22, 22, 174, 68, [174]),
+  symbol(52, 52, 24, 24, 204, 84, [102, 102]),
+  symbol(64, 64, 14, 14, 280, 112, [140, 140]),
+  symbol(72, 72, 16, 16, 368, 144, [92, 92, 92, 92]),
+  symbol(80, 80, 18, 18, 456, 192, [114, 114, 114, 114]),
+  symbol(88, 88, 20, 20, 576, 224, [144, 144, 144, 144]),
+  symbol(96, 96, 22, 22, 696, 272, [174, 174, 174, 174]),
+  symbol(104, 104, 24, 24, 816, 336, [136, 136, 136, 136, 136, 136]),
+  symbol(120, 120, 18, 18, 1050, 408, [175, 175, 175, 175, 175, 175]),
+  symbol(132, 132, 20, 20, 1304, 496, [163, 163, 163, 163, 163, 163, 163, 163]),
+  symbol(144, 144, 22, 22, 1558, 620, [156, 156, 156, 156, 156, 156, 156, 156, 155, 155]),
+  symbol(18, 8, 16, 6, 5, 7, [5]),
+  symbol(32, 8, 14, 6, 10, 11, [10]),
+  symbol(26, 12, 24, 10, 16, 14, [16]),
+  symbol(36, 12, 16, 10, 22, 18, [22]),
+  symbol(36, 16, 16, 14, 32, 24, [32]),
+  symbol(48, 16, 22, 14, 49, 28, [49]),
+]);
+
+/** Compatibility alias. */
+const SYMBOLS = DATAMATRIX_SYMBOLS;
+
+/** Return the smallest permitted symbol that holds `count` data codewords. */
+function symbolForDataCodewords(count, shape = 'any') {
+  for (const s of DATAMATRIX_SYMBOLS) {
+    const rectangular = s.width !== s.height;
+    if ((shape === 'square' && rectangular) || (shape === 'rectangular' && !rectangular)) continue;
+    if (count <= s.dataCodewords) return s;
+  }
+  throw new RangeError(`Data Matrix: ${count} data codewords do not fit an ECC 200 ${shape} symbol`);
+}
+
+/** Check redundant geometry and block identities in the static table. */
+function validateDataMatrixTables() {
+  const issues = [];
+  for (const s of DATAMATRIX_SYMBOLS) {
+    const regionsX = s.width / s.regionWidth;
+    const regionsY = s.height / s.regionHeight;
+    if (!Number.isInteger(regionsX) || !Number.isInteger(regionsY)) issues.push(`${s.width}x${s.height}: non-integral regions`);
+    const modules = regionsX * regionsY * s.dataRegionWidth * s.dataRegionHeight;
+    // Annex F reserves four terminal modules on a few lattice dimensions.
+    // They are set to dark after codeword placement and do not carry data.
+    const unused = modules - (s.dataCodewords + s.errorCodewords) * 8;
+    if (unused !== 0 && unused !== 4) issues.push(`${s.width}x${s.height}: geometry/codeword mismatch`);
+    if (s.dataBlockLengths.reduce((a, b) => a + b, 0) !== s.dataCodewords) issues.push(`${s.width}x${s.height}: data block mismatch`);
+    if (s.eccPerBlock * s.blockCount !== s.errorCodewords) issues.push(`${s.width}x${s.height}: ecc block mismatch`);
+  }
+  return issues;
+}
+
+/** Compatibility alias. */
+const validateTables = validateDataMatrixTables;
+
+__exports.DATAMATRIX_SYMBOLS = DATAMATRIX_SYMBOLS;
+__exports.SYMBOLS = SYMBOLS;
+__exports.symbolForDataCodewords = symbolForDataCodewords;
+__exports.validateDataMatrixTables = validateDataMatrixTables;
+__exports.validateTables = validateTables;
+};
+
+__modules["datamatrix/encoder.js"] = function (__require, __exports) {
+/** Data Matrix ECC 200 encoder: ASCII/Base256, RS interleaving and Annex F placement. */
 const { BitMatrix } = __require("core/bit-matrix.js");
+const { EncodeError } = __require("core/errors.js");
+const { GF256_DM } = __require("core/galois-field.js");
+const { rsEncode } = __require("core/reed-solomon.js");
+const { symbolForDataCodewords } = __require("datamatrix/tables.js");
 
-/** Error correction levels, weakest to strongest. */
-const ECC_LEVELS = ['L', 'M', 'Q', 'H'];
+function asciiCodewords(text) {
+  const out = [];
+  for (let i = 0; i < text.length;) {
+    const a = text.charCodeAt(i);
+    if (a > 255) throw new EncodeError('Data Matrix ASCII: characters must fit ISO-8859-1; use Base256 for UTF-8');
+    if (i + 1 < text.length) {
+      const b = text.charCodeAt(i + 1);
+      if (a >= 48 && a <= 57 && b >= 48 && b <= 57) { out.push(130 + (a - 48) * 10 + b - 48); i += 2; continue; }
+    }
+    if (a <= 127) out.push(a + 1);
+    else out.push(235, a - 127);
+    i++;
+  }
+  return out;
+}
 
-/**
- * Two-bit level indicator used in the format information.
- * Note this is *not* the L/M/Q/H ordering — the spec assigns them out of order.
- */
-const ECC_LEVEL_BITS = { L: 0b01, M: 0b00, Q: 0b11, H: 0b10 };
+function bytesFor(value) {
+  if (value instanceof Uint8Array) return value;
+  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  if (typeof value !== 'string') throw new EncodeError('Data Matrix: value must be a string or byte array');
+  return new TextEncoder().encode(value);
+}
 
-/** Inverse of {@link ECC_LEVEL_BITS}, indexed by the 2-bit value. */
-const ECC_LEVEL_BY_BITS = ['M', 'L', 'H', 'Q'];
-const MIN_VERSION = 1;
-const MAX_VERSION = 40;
+function randomize255(value, position) {
+  const pseudo = (149 * position) % 255 + 1;
+  return value + pseudo <= 255 ? value + pseudo : value + pseudo - 256;
+}
 
-/** Version at and above which an 18-bit version information block is carried. */
-const VERSION_INFO_MIN = 7;
+function base256Codewords(value, prefixLength = 0) {
+  const bytes = bytesFor(value);
+  if (bytes.length > 1555) throw new EncodeError('Data Matrix Base256: payload exceeds ECC 200 capacity');
+  const out = [231];
+  if (bytes.length <= 249) out.push(bytes.length);
+  else out.push(Math.floor(bytes.length / 250) + 249, bytes.length % 250);
+  // Base256 randomization uses the absolute 1-based codeword position in the
+  // symbol. A leading GS1 FNC1 therefore shifts every randomized codeword.
+  for (let i = 1; i < out.length; i++) out[i] = randomize255(out[i], prefixLength + i + 1);
+  for (const b of bytes) out.push(randomize255(b, prefixLength + out.length + 1));
+  return out;
+}
 
-/** Mode indicator nibbles. */
-const MODE = {
-  TERMINATOR: 0x0,
-  NUMERIC: 0x1,
-  ALPHANUMERIC: 0x2,
-  STRUCTURED_APPEND: 0x3,
-  BYTE: 0x4,
-  FNC1_FIRST: 0x5,
-  ECI: 0x7,
-  KANJI: 0x8,
-  FNC1_SECOND: 0x9,
-};
+function pad(data, capacity) {
+  const out = data.slice();
+  if (out.length < capacity) out.push(129);
+  while (out.length < capacity) {
+    const position = out.length + 1;
+    const pseudo = (149 * position) % 253 + 1;
+    const v = 129 + pseudo;
+    out.push(v <= 254 ? v : v - 254);
+  }
+  return out;
+}
 
-/**
- * Character count indicator width, in bits, by mode and version band.
- *
- * The bands are versions 1-9, 10-26 and 27-40. They are the reason segment
- * selection and version selection are mutually dependent: widening the count
- * field can push a payload over a version boundary, which widens it again.
- */
-const COUNT_BITS = {
-  [MODE.NUMERIC]: [10, 12, 14],
-  [MODE.ALPHANUMERIC]: [9, 11, 13],
-  [MODE.BYTE]: [8, 16, 16],
-  [MODE.KANJI]: [8, 10, 12],
-};
+function interleave(data, symbol) {
+  const blocks = symbol.dataBlockLengths.map((length) => ({ data: new Array(length), ecc: null }));
+  let at = 0;
+  const longest = Math.max(...symbol.dataBlockLengths);
+  // Data codewords are dealt across the RS blocks by column. Splitting the
+  // stream into consecutive chunks and then interleaving those chunks looks
+  // self-consistent to a decoder doing the same inverse operation, but it is
+  // not ECC 200's wire order once a symbol has multiple blocks.
+  for (let i = 0; i < longest; i++) {
+    for (const block of blocks) if (i < block.data.length) block.data[i] = data[at++];
+  }
+  for (const block of blocks) {
+    // ECC 200 starts its generator roots at alpha^1 (generator base 1).
+    block.ecc = rsEncode(block.data, symbol.eccPerBlock, GF256_DM, 1);
+  }
 
-/**
- * @param {number} version 1-40
- * @returns {number} Modules per side.
- */
-function versionSize(version) {
-  return 17 + 4 * version;
+  const out = [];
+  for (let i = 0; i < longest; i++) for (const b of blocks) if (i < b.data.length) out.push(b.data[i]);
+  // The 144x144 symbol has eight long and two short data blocks. Its parity
+  // interleave begins with the first short block; deriving the rotation from
+  // the declarative lengths keeps that exception out of a size-specific test.
+  const eccOffset = blocks.findIndex((block) => block.data.length < longest);
+  const rotation = eccOffset < 0 ? 0 : eccOffset;
+  for (let i = 0; i < symbol.eccPerBlock; i++) {
+    for (let b = 0; b < blocks.length; b++) out.push(blocks[(b + rotation) % blocks.length].ecc[i]);
+  }
+  return out;
 }
 
+function place(codewords, rows, cols) {
+  const cells = new Int8Array(rows * cols).fill(-1);
+  const bit = (row, col, pos, n) => {
+    if (row < 0) { row += rows; col += 4 - ((rows + 4) % 8); }
+    if (col < 0) { col += cols; row += 4 - ((cols + 4) % 8); }
+    cells[row * cols + col] = (codewords[pos] >>> (8 - n)) & 1;
+  };
+  const utah = (r, c, p) => { bit(r - 2, c - 2, p, 1); bit(r - 2, c - 1, p, 2); bit(r - 1, c - 2, p, 3); bit(r - 1, c - 1, p, 4); bit(r - 1, c, p, 5); bit(r, c - 2, p, 6); bit(r, c - 1, p, 7); bit(r, c, p, 8); };
+  const corner1 = (p) => { bit(rows - 1, 0, p, 1); bit(rows - 1, 1, p, 2); bit(rows - 1, 2, p, 3); bit(0, cols - 2, p, 4); bit(0, cols - 1, p, 5); bit(1, cols - 1, p, 6); bit(2, cols - 1, p, 7); bit(3, cols - 1, p, 8); };
+  const corner2 = (p) => { bit(rows - 3, 0, p, 1); bit(rows - 2, 0, p, 2); bit(rows - 1, 0, p, 3); bit(0, cols - 4, p, 4); bit(0, cols - 3, p, 5); bit(0, cols - 2, p, 6); bit(0, cols - 1, p, 7); bit(1, cols - 1, p, 8); };
+  const corner3 = (p) => { bit(rows - 3, 0, p, 1); bit(rows - 2, 0, p, 2); bit(rows - 1, 0, p, 3); bit(0, cols - 2, p, 4); bit(0, cols - 1, p, 5); bit(1, cols - 1, p, 6); bit(2, cols - 1, p, 7); bit(3, cols - 1, p, 8); };
+  const corner4 = (p) => { bit(rows - 1, 0, p, 1); bit(rows - 1, cols - 1, p, 2); bit(0, cols - 3, p, 3); bit(0, cols - 2, p, 4); bit(0, cols - 1, p, 5); bit(1, cols - 3, p, 6); bit(1, cols - 2, p, 7); bit(1, cols - 1, p, 8); };
+  let row = 4, col = 0, pos = 0;
+  do {
+    if (row === rows && col === 0) corner1(pos++);
+    if (row === rows - 2 && col === 0 && cols % 4 !== 0) corner2(pos++);
+    if (row === rows - 2 && col === 0 && cols % 8 === 4) corner3(pos++);
+    if (row === rows + 4 && col === 2 && cols % 8 === 0) corner4(pos++);
+    do { if (row < rows && col >= 0 && cells[row * cols + col] < 0) utah(row, col, pos++); row -= 2; col += 2; } while (row >= 0 && col < cols);
+    row += 1; col += 3;
+    do { if (row >= 0 && col < cols && cells[row * cols + col] < 0) utah(row, col, pos++); row += 2; col -= 2; } while (row < rows && col >= 0);
+    row += 3; col += 1;
+  } while (row < rows || col < cols);
+  if (cells[cells.length - 1] < 0) { cells[cells.length - 1] = 1; cells[cells.length - cols - 2] = 1; }
+  if (pos !== codewords.length) throw new EncodeError(`Data Matrix: placement consumed ${pos} of ${codewords.length} codewords`);
+  return cells;
+}
+
+function buildMatrix(codewords, symbol) {
+  const regionCols = symbol.width / symbol.regionWidth;
+  const regionRows = symbol.height / symbol.regionHeight;
+  const dataWidth = symbol.dataRegionColumns;
+  const dataHeight = symbol.dataRegionRows;
+  const data = place(codewords, regionRows * dataHeight, regionCols * dataWidth);
+  const matrix = new BitMatrix(symbol.width, symbol.height);
+  for (let ry = 0; ry < regionRows; ry++) for (let rx = 0; rx < regionCols; rx++) {
+    const x0 = rx * symbol.regionWidth, y0 = ry * symbol.regionHeight;
+    for (let x = 0; x < symbol.regionWidth; x++) { if ((x & 1) === 0) matrix.set(x0 + x, y0); matrix.set(x0 + x, y0 + dataHeight + 1); }
+    // The top and right timing borders are complementary: top-left is dark,
+    // top-right is light, and the solid bottom-right corner remains dark.
+    for (let y = 0; y < symbol.regionHeight; y++) { matrix.set(x0, y0 + y); if ((y & 1) === 1) matrix.set(x0 + dataWidth + 1, y0 + y); }
+    for (let y = 0; y < dataHeight; y++) for (let x = 0; x < dataWidth; x++) if (data[(ry * dataHeight + y) * (regionCols * dataWidth) + rx * dataWidth + x]) matrix.set(x0 + 1 + x, y0 + 1 + y);
+  }
+  return matrix;
+}
+
+/** Encode a string (ASCII mode) or byte payload (Base256) into Data Matrix ECC 200. */
+function encodeDataMatrix(value, options = {}) {
+  const encoding = options.encoding ?? (value instanceof Uint8Array ? 'base256' : 'ascii');
+  let raw;
+  if (encoding === 'ascii') {
+    if (typeof value !== 'string') throw new EncodeError('Data Matrix ASCII: value must be a string');
+    raw = asciiCodewords(value);
+  } else if (encoding === 'base256') raw = base256Codewords(value, options.gs1 === true ? 1 : 0);
+  else throw new EncodeError(`Data Matrix: unsupported encoding "${encoding}"`);
+  // GS1 DataMatrix is ECC 200 with FNC1 in the first codeword position.
+  if (options.gs1 === true) raw.unshift(232);
+  const shape = options.shape ?? 'any';
+  if (shape !== 'any' && shape !== 'square' && shape !== 'rectangular') throw new EncodeError(`Data Matrix: invalid shape "${shape}"`);
+  const symbol = symbolForDataCodewords(raw.length, shape);
+  if (!symbol) throw new EncodeError(`Data Matrix: ${raw.length} data codewords do not fit an ECC 200 ${shape} symbol`);
+  return buildMatrix(interleave(pad(raw, symbol.dataCodewords), symbol), symbol);
+}
+
+/** Encode already compacted ASCII/Base256 codewords, primarily for conformance tests. */
+function encodeDataMatrixCodewords(codewords, options = {}) {
+  if (!Array.isArray(codewords) && !(codewords instanceof Uint8Array)) throw new EncodeError('Data Matrix: codewords must be an array');
+  for (const c of codewords) if (!Number.isInteger(c) || c < 0 || c > 255) throw new EncodeError('Data Matrix: codewords must be bytes');
+  const symbol = symbolForDataCodewords(codewords.length, options.shape ?? 'any');
+  if (!symbol) throw new EncodeError('Data Matrix: codewords do not fit ECC 200');
+  return buildMatrix(interleave(pad(Array.from(codewords), symbol.dataCodewords), symbol), symbol);
+}
+
+__exports.encodeDataMatrix = encodeDataMatrix;
+__exports.encodeDataMatrixCodewords = encodeDataMatrixCodewords;
+};
+
+__modules["datamatrix/decoder.js"] = function (__require, __exports) {
 /**
- * Bits in the character count indicator.
+ * Data Matrix ECC 200 decoder for an already sampled symbol.
  *
- * @param {number} mode One of {@link MODE}.
- * @param {number} version
- * @returns {number}
+ * The detector owns locating, perspective correction and orientation. This
+ * module starts with the complete, upright symbol including its finder borders.
+ * The table entry is deliberately read through a small normalizer so table data
+ * remains declarative: it needs total rows/columns, one data-region's rows and
+ * columns, data/ECC codeword counts, and either a block count or data block
+ * lengths. The standard 144x144 uneven data blocks are supported.
+ *
+ * @module datamatrix/decoder
  */
-function countBits(mode, version) {
-  const widths = COUNT_BITS[mode];
-  if (!widths) return 0;
-  if (version <= 9) return widths[0];
-  if (version <= 26) return widths[1];
-  return widths[2];
-}
-
-/**
- * Centre coordinates of the alignment patterns for a version.
- *
- * The spec's rule: the first centre is always 6 and the last is always
- * `size - 7`; the count grows by one every seven versions; and the centres are
- * evenly spaced with the *first* gap absorbing the rounding slack. Expressing
- * that as arithmetic rather than a 40-row table means there is no table to
- * mistype, and {@link validateTables} can then assert the shape of the result.
- *
- * @param {number} version
- * @returns {number[]} Ascending centres. Empty for version 1.
- */
-function alignmentCoordinates(version) {
-  if (version < 2) return [];
-
-  const size = versionSize(version);
-  const count = Math.floor(version / 7) + 2;
-  const last = size - 7;
-
-  // Spacing is rounded up to an even number of modules so every centre lands on
-  // the same parity as the timing pattern, which is what keeps the patterns
-  // aligned with the module grid rather than straddling it.
-  const step = Math.ceil((size - 13) / (2 * count - 2)) * 2;
-
-  const coords = [6];
-  // Walk backwards from the final centre so the slack lands in the first gap.
-  for (let i = count - 1; i >= 1; i--) coords.push(last - (count - 1 - i) * step);
-  coords.sort((a, b) => a - b);
-  return coords;
+const { ChecksumError, FormatError } = __require("core/errors.js");
+const { GF256_DM } = __require("core/galois-field.js");
+const { rsDecode } = __require("core/reed-solomon.js");
+const { SYMBOLS } = __require("datamatrix/tables.js");
+
+const CW_PAD = 129;
+const CW_BASE256 = 231;
+
+/** @param {object} entry @param {...string} names @returns {number | undefined} */
+function numberField(entry, ...names) {
+  for (const name of names) if (Number.isInteger(entry[name])) return entry[name];
+  return undefined;
+}
+
+/** Normalize the public table entry into the decoder's geometry contract. */
+function layoutFor(width, height) {
+  const entry = SYMBOLS.find((s) =>
+    numberField(s, 'columns', 'cols', 'matrixColumns', 'width') === width &&
+    numberField(s, 'rows', 'matrixRows', 'height') === height);
+  if (!entry) throw new FormatError(`Data Matrix: ${width}x${height} is not an ECC 200 symbol size`);
+
+  const regionRows = numberField(entry, 'dataRegionRows', 'regionRows') ??
+    (numberField(entry, 'regionHeight') ? numberField(entry, 'regionHeight') - 2 : undefined);
+  const regionCols = numberField(entry, 'dataRegionColumns', 'dataRegionCols', 'regionColumns') ??
+    (numberField(entry, 'regionWidth') ? numberField(entry, 'regionWidth') - 2 : undefined);
+  const dataCount = numberField(entry, 'dataCodewords', 'dataCapacity');
+  const eccCount = numberField(entry, 'errorCodewords', 'eccCodewords');
+  const blockCount = numberField(entry, 'interleavedBlocks', 'interleavedBlockCount', 'blockCount', 'rsBlocks') || 1;
+  if (!regionRows || !regionCols || dataCount === undefined || eccCount === undefined ||
+      height % (regionRows + 2) || width % (regionCols + 2) || eccCount % blockCount) {
+    throw new FormatError(`Data Matrix: invalid table layout for ${width}x${height}`);
+  }
+
+  const rows = height / (regionRows + 2);
+  const cols = width / (regionCols + 2);
+  const blockData = Array.isArray(entry.blockDataCodewords) ? entry.blockDataCodewords.slice() :
+    Array.isArray(entry.dataCodewordsPerBlock) ? entry.dataCodewordsPerBlock.slice() : null;
+  let dataLengths;
+  if (blockData) {
+    dataLengths = blockData;
+  } else {
+    // The sole uneven ECC 200 distribution is 144x144: its first eight of ten
+    // blocks contain one extra data codeword. This derives it instead of hiding
+    // a magic size check in the deinterleaver.
+    const short = Math.floor(dataCount / blockCount);
+    dataLengths = new Array(blockCount).fill(short);
+    for (let i = 0; i < dataCount % blockCount; i++) dataLengths[i]++;
+  }
+  if (dataLengths.length !== blockCount || dataLengths.reduce((a, b) => a + b, 0) !== dataCount) {
+    throw new FormatError(`Data Matrix: inconsistent block layout for ${width}x${height}`);
+  }
+  return { entry, regionRows, regionCols, regionRowCount: rows, regionColCount: cols,
+    dataRows: rows * regionRows, dataCols: cols * regionCols, dataCount, eccCount,
+    blockCount, eccPerBlock: eccCount / blockCount, dataLengths };
+}
+
+/** Remove the L/finders from every data region, retaining only placement modules. */
+function extractDataModules(matrix, layout) {
+  const data = new Uint8Array(layout.dataRows * layout.dataCols);
+  for (let regionY = 0; regionY < layout.regionRowCount; regionY++) {
+    for (let regionX = 0; regionX < layout.regionColCount; regionX++) {
+      const sourceX = regionX * (layout.regionCols + 2) + 1;
+      const sourceY = regionY * (layout.regionRows + 2) + 1;
+      for (let y = 0; y < layout.regionRows; y++) {
+        const targetY = regionY * layout.regionRows + y;
+        for (let x = 0; x < layout.regionCols; x++) {
+          data[targetY * layout.dataCols + regionX * layout.regionCols + x] =
+            matrix.get(sourceX + x, sourceY + y) ? 1 : 0;
+        }
+      }
+    }
+  }
+  return data;
 }
 
-/**
- * Centres of the alignment patterns actually drawn, as [x, y] pairs.
- *
- * The three combinations that would sit on top of a finder pattern are omitted.
- *
- * @param {number} version
- * @returns {Array<[number, number]>}
- */
-function alignmentCentres(version) {
-  const coords = alignmentCoordinates(version);
-  if (coords.length === 0) return [];
-
-  const size = versionSize(version);
-  const lo = 6;
-  const hi = size - 7;
-  const out = [];
-  for (let i = 0; i < coords.length; i++) {
-    for (let j = 0; j < coords.length; j++) {
-      const x = coords[j];
-      const y = coords[i];
-      // Skip the three finder corners.
-      if (x === lo && y === lo) continue;
-      if (x === lo && y === hi) continue;
-      if (x === hi && y === lo) continue;
-      out.push([x, y]);
+/** Read placement codewords using the ECC 200 Utah sweep (the inverse writer path). */
+function readPlacement(modules, rows, cols, count) {
+  const seen = new Uint8Array(rows * cols);
+  const out = new Uint8Array(count);
+  const get = (row, col) => modules[row * cols + col] !== 0;
+  const module = (row, col) => {
+    if (row < 0) { row += rows; col += 4 - ((rows + 4) % 8); }
+    if (col < 0) { col += cols; row += 4 - ((cols + 4) % 8); }
+    if (row < 0 || row >= rows || col < 0 || col >= cols) {
+      throw new FormatError('Data Matrix: placement coordinate escaped data region');
     }
-  }
+    seen[row * cols + col] = 1;
+    return get(row, col) ? 1 : 0;
+  };
+  const bits = (coords) => coords.reduce((value, p) => (value << 1) | module(p[0], p[1]), 0);
+  const utah = (row, col) => bits([[row - 2, col - 2], [row - 2, col - 1], [row - 1, col - 2], [row - 1, col - 1],
+    [row - 1, col], [row, col - 2], [row, col - 1], [row, col]]);
+  const corner1 = () => bits([[rows - 1, 0], [rows - 1, 1], [rows - 1, 2], [0, cols - 2], [0, cols - 1], [1, cols - 1], [2, cols - 1], [3, cols - 1]]);
+  const corner2 = () => bits([[rows - 3, 0], [rows - 2, 0], [rows - 1, 0], [0, cols - 4], [0, cols - 3], [0, cols - 2], [0, cols - 1], [1, cols - 1]]);
+  const corner3 = () => bits([[rows - 3, 0], [rows - 2, 0], [rows - 1, 0], [0, cols - 2], [0, cols - 1], [1, cols - 1], [2, cols - 1], [3, cols - 1]]);
+  const corner4 = () => bits([[rows - 1, 0], [rows - 1, cols - 1], [0, cols - 3], [0, cols - 2], [0, cols - 1], [1, cols - 3], [1, cols - 2], [1, cols - 1]]);
+
+  let row = 4, col = 0, n = 0;
+  const put = (value) => { if (n < count) out[n++] = value; };
+  do {
+    if (row === rows && col === 0) put(corner1());
+    if (row === rows - 2 && col === 0 && cols % 4 !== 0) put(corner2());
+    if (row === rows - 2 && col === 0 && cols % 8 === 4) put(corner3());
+    if (row === rows + 4 && col === 2 && cols % 8 === 0) put(corner4());
+    do { if (row < rows && col >= 0 && !seen[row * cols + col]) put(utah(row, col)); row -= 2; col += 2; } while (row >= 0 && col < cols);
+    row += 1; col += 3;
+    do { if (row >= 0 && col < cols && !seen[row * cols + col]) put(utah(row, col)); row += 2; col -= 2; } while (row < rows && col >= 0);
+    row += 3; col += 1;
+  } while (row < rows || col < cols);
+  if (n !== count) throw new FormatError(`Data Matrix: placement yielded ${n}, expected ${count} codewords`);
   return out;
 }
 
-const reservedCache = new Map();
-
-/**
- * Map of modules that carry function patterns rather than payload.
- *
- * A set bit means "reserved": finder, separator, timing, alignment, format
- * information, the dark module, and the version information blocks. This is the
- * single source of truth used by the encoder to skip modules while laying out
- * the bitstream, by the decoder to read them back in the same order, and by
- * {@link geometricTotalCodewords} to count what is left.
- *
- * Deriving capacity this way rather than by hand arithmetic is what makes the
- * awkward cases free: an alignment pattern that overlaps the timing pattern is
- * counted once because it is the same set of modules, not because anyone
- * remembered to subtract five.
- *
- * @param {number} version
- * @returns {BitMatrix} Shared, cached — treat as immutable.
- */
-function reservedModules(version) {
-  const cached = reservedCache.get(version);
-  if (cached) return cached;
-
-  const size = versionSize(version);
-  const m = new BitMatrix(size, size);
-
-  // Finder patterns with their separators: an 8x8 reserved block at each of
-  // three corners (7x7 pattern plus a one-module light border on the inner
-  // sides, which the corner blocks absorb).
-  m.setRegion(0, 0, 8, 8);
-  m.setRegion(size - 8, 0, 8, 8);
-  m.setRegion(0, size - 8, 8, 8);
-
-  // Timing patterns, spanning the gap between the separators.
-  for (let i = 8; i < size - 8; i++) {
-    m.set(i, 6);
-    m.set(6, i);
-  }
-
-  // Alignment patterns, 5x5 each.
-  const centres = alignmentCentres(version);
-  for (let i = 0; i < centres.length; i++) {
-    m.setRegion(centres[i][0] - 2, centres[i][1] - 2, 5, 5);
+/** Restore RS blocks, correct them, then concatenate their data portions. */
+function deinterleaveAndCorrect(codewords, layout) {
+  if (codewords.length !== layout.dataCount + layout.eccCount) throw new FormatError('Data Matrix: codeword count mismatch');
+  const blocks = layout.dataLengths.map((len) => new Uint8Array(len + layout.eccPerBlock));
+  // Data codewords arrive in their original stream order. ECC 200 deals that
+  // stream round-robin across the RS blocks, so the inverse is determined by
+  // the wire index rather than by splitting it into consecutive block-sized
+  // chunks. For 144x144, indices 1550..1557 naturally land in the eight long
+  // blocks while the two short blocks remain at 155 data codewords.
+  for (let i = 0; i < layout.dataCount; i++) {
+    blocks[i % layout.blockCount][Math.floor(i / layout.blockCount)] = codewords[i];
+  }
+
+  // Parity normally begins with block zero. The uneven 144x144 layout rotates
+  // the parity wire order to begin with its first short block; derive the same
+  // mapping from the declarative lengths instead of keying it to dimensions.
+  const longest = Math.max(...layout.dataLengths);
+  const firstShort = layout.dataLengths.findIndex((length) => length < longest);
+  const rotation = firstShort < 0 ? 0 : firstShort;
+  let at = layout.dataCount;
+  for (let i = 0; i < layout.eccPerBlock; i++) {
+    for (let slot = 0; slot < layout.blockCount; slot++) {
+      const block = (slot + rotation) % layout.blockCount;
+      blocks[block][layout.dataLengths[block] + i] = codewords[at++];
+    }
   }
 
-  // Format information: two copies plus the dark module. The copies partly
-  // fall inside the 8x8 finder blocks already reserved; setting them again is
-  // harmless and keeps the intent explicit.
-  const [copyA, copyB] = formatInfoPositions(size);
-  for (let i = 0; i < 15; i++) {
-    m.set(copyA[i][0], copyA[i][1]);
-    m.set(copyB[i][0], copyB[i][1]);
+  let corrections = 0;
+  const data = new Uint8Array(layout.dataCount);
+  for (let b = 0; b < blocks.length; b++) {
+    corrections += rsDecode(blocks[b], layout.eccPerBlock, GF256_DM, 1);
   }
-  m.set(8, size - 8); // dark module
-
-  // Version information, two 6x3 blocks.
-  if (version >= VERSION_INFO_MIN) {
-    m.setRegion(size - 11, 0, 3, 6);
-    m.setRegion(0, size - 11, 6, 3);
+  // Rebuild the original high-level codeword stream after correction. Keeping
+  // this in wire-index order is essential: concatenating block data passes
+  // single-block round trips but scrambles every multi-block payload.
+  for (let i = 0; i < layout.dataCount; i++) {
+    data[i] = blocks[i % layout.blockCount][Math.floor(i / layout.blockCount)];
   }
-
-  reservedCache.set(version, m);
-  return m;
+  return { data, corrections };
 }
 
-/**
- * Module positions of the two format information copies.
- *
- * Index `i` in each array is bit `i` of the 15-bit format value, bit 0 being
- * the least significant.
- *
- * CAVEAT WORTH READING: the *direction* of this numbering is the one thing in
- * this file that a round-trip test cannot falsify. Encoder and decoder share
- * these tables, so a mirrored layout would pass every test in the suite and
- * fail only against a real scanner. The layout below is the standard one; both
- * sides deliberately consume this single definition so there is no second place
- * for the convention to drift.
- *
- * @param {number} size Modules per side.
- * @returns {[Array<[number, number]>, Array<[number, number]>]} [copyA, copyB]
- */
-function formatInfoPositions(size) {
-  /** @type {Array<[number, number]>} */
-  const a = [];
-  /** @type {Array<[number, number]>} */
-  const b = [];
-
-  for (let i = 0; i < 15; i++) {
-    // Copy A wraps the top-left finder: down column 8, then left along row 8,
-    // stepping over the two timing modules.
-    if (i < 6) a.push([8, i]);
-    else if (i === 6) a.push([8, 7]);
-    else if (i === 7) a.push([8, 8]);
-    else if (i === 8) a.push([7, 8]);
-    else a.push([14 - i, 8]);
-
-    // Copy B is split: the low bits run right-to-left along row 8 beside the
-    // top-right finder, the high bits run bottom-up beside the bottom-left one.
-    if (i < 8) b.push([size - 1 - i, 8]);
-    else b.push([8, size - 15 + i]);
-  }
-
-  return [a, b];
+function unrandomize(value, position) {
+  const pseudo = ((149 * position) % 255) + 1;
+  return value - pseudo >= 0 ? value - pseudo : value - pseudo + 256;
 }
 
-/**
- * Modules available to data and error correction, counted off the grid.
- *
- * @param {number} version
- * @returns {number}
- */
-function freeModuleCount(version) {
-  const reserved = reservedModules(version);
-  const size = versionSize(version);
-  let free = 0;
-  for (let y = 0; y < size; y++) {
-    for (let x = 0; x < size; x++) {
-      if (!reserved.get(x, y)) free++;
+/** Decode ASCII plus Base 256, preserving semantic bytes alongside text. */
+function parseData(data) {
+  let text = '';
+  const bytes = [];
+  let upperShift = false;
+  let gs1 = false;
+  for (let i = 0; i < data.length;) {
+    const cw = data[i++];
+    if (cw === CW_PAD) break;
+    if (cw <= 128) {
+      const value = cw - 1 + (upperShift ? 128 : 0);
+      upperShift = false;
+      text += String.fromCharCode(value); bytes.push(value); continue;
+    }
+    if (cw <= 229) {
+      const pair = cw - 130;
+      const digits = String(pair).padStart(2, '0'); text += digits; bytes.push(digits.charCodeAt(0), digits.charCodeAt(1)); continue;
+    }
+    if (cw === 232) {
+      if (i === 1) gs1 = true;
+      else { text += '\x1d'; bytes.push(29); }
+      continue;
+    }
+    if (cw === 235) { upperShift = true; continue; }
+    if (cw === CW_BASE256) {
+      if (i >= data.length) throw new FormatError('Data Matrix: Base 256 length is missing');
+      let length = unrandomize(data[i], i + 1); i++;
+      if (length === 0) length = data.length - i;
+      else if (length >= 250) {
+        if (i >= data.length) throw new FormatError('Data Matrix: Base 256 extended length is missing');
+        length = 250 * (length - 249) + unrandomize(data[i], i + 1); i++;
+      }
+      if (i + length > data.length) throw new FormatError('Data Matrix: Base 256 segment exceeds data capacity');
+      const segment = new Uint8Array(length);
+      for (let n = 0; n < length; n++, i++) segment[n] = unrandomize(data[i], i + 1);
+      bytes.push(...segment);
+      for (let n = 0; n < segment.length; n++) text += String.fromCharCode(segment[n]);
+      continue;
     }
+    throw new FormatError(`Data Matrix: unsupported encoding codeword ${cw}`);
   }
-  return free;
-}
-
-/**
- * Total codewords (data + error correction) a version holds.
- *
- * Geometric, not tabulated — this is the reference the ECC table is checked
- * against.
- *
- * @param {number} version
- * @returns {number}
- */
-function geometricTotalCodewords(version) {
-  return Math.floor(freeModuleCount(version) / 8);
+  return { text, bytes: Uint8Array.from(bytes), gs1 };
 }
 
 /**
- * Bits left over after the last whole codeword, written as zeroes.
+ * Decode an upright, sampled Data Matrix ECC 200 symbol.
  *
- * @param {number} version
- * @returns {number} 0, 3, 4 or 7.
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix Full symbol, no quiet zone.
+ * @returns {{text: string, bytes: Uint8Array, correctedErrors: number, symbol: object}}
  */
-function remainderBits(version) {
-  return freeModuleCount(version) % 8;
+function decodeDataMatrix(matrix) {
+  if (!matrix || !Number.isInteger(matrix.width) || !Number.isInteger(matrix.height)) throw new FormatError('Data Matrix: no matrix supplied');
+  const layout = layoutFor(matrix.width, matrix.height);
+  const placement = readPlacement(extractDataModules(matrix, layout), layout.dataRows, layout.dataCols, layout.dataCount + layout.eccCount);
+  const { data, corrections } = deinterleaveAndCorrect(placement, layout);
+  const result = parseData(data);
+  return { ...result, corrections, correctedErrors: corrections, symbol: layout.entry };
 }
+__exports.ChecksumError = ChecksumError;
 
-const orderCache = new Map();
+__exports.decodeDataMatrix = decodeDataMatrix;
+};
 
+__modules["image/perspective.js"] = function (__require, __exports) {
 /**
- * Module positions in bitstream order, as interleaved x, y pairs.
+ * Projective (perspective) transforms.
  *
- * The layout walks two-module-wide columns from the bottom-right corner
- * leftward, alternating upward and downward, right module of the pair before
- * the left, skipping the vertical timing column and every reserved module.
+ * A 2D symbol photographed off-axis is not a rotated square — it is a
+ * quadrilateral with converging edges. Correcting that needs a full projective
+ * map, not an affine one; an affine approximation reads the near edge of a
+ * tilted symbol correctly and drifts a module or more by the far edge.
  *
- * Encoder and decoder both consume this one function. That is not tidiness: a
- * placement order that disagrees between the two would still round-trip
- * perfectly within this library while producing symbols no scanner can read.
- * There is only one order because there is only one implementation of it.
+ * The map is a 3x3 homogeneous matrix. Points are transformed as
+ * (x, y, 1) * M, then divided through by the resulting w.
  *
- * @param {number} version
- * @returns {Int32Array} Shared, cached — treat as immutable. Length is
- *   `2 * freeModuleCount(version)`.
+ * @module image/perspective
  */
-function dataModuleOrder(version) {
-  const cached = orderCache.get(version);
-  if (cached) return cached;
-
-  const size = versionSize(version);
-  const reserved = reservedModules(version);
-  const out = new Int32Array(freeModuleCount(version) * 2);
-  let n = 0;
+class PerspectiveTransform {
+  /* eslint-disable-next-line max-params */
+  constructor(a11, a21, a31, a12, a22, a32, a13, a23, a33) {
+    this.a11 = a11; this.a21 = a21; this.a31 = a31;
+    this.a12 = a12; this.a22 = a22; this.a32 = a32;
+    this.a13 = a13; this.a23 = a23; this.a33 = a33;
+  }
 
-  let upward = true;
-  for (let col = size - 1; col > 0; col -= 2) {
-    // Column 6 is the vertical timing pattern. Stepping over it shifts the
-    // whole remaining schedule left by one, so the loop variable itself has to
-    // move — adjusting only the current pair would visit column 4 twice and
-    // column 0 never, which is self-consistent between encoder and decoder and
-    // therefore invisible to a round-trip test.
-    if (col === 6) col--;
-    for (let i = 0; i < size; i++) {
-      const y = upward ? size - 1 - i : i;
+  /**
+   * Transform points in place.
+   *
+   * @param {Float32Array | number[]} points Interleaved [x0, y0, x1, y1, ...].
+   * @returns {Float32Array | number[]} The same array.
+   */
+  transform(points) {
+    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+    for (let i = 0; i < points.length; i += 2) {
+      const x = points[i];
+      const y = points[i + 1];
+      const w = a13 * x + a23 * y + a33;
+      points[i] = (a11 * x + a21 * y + a31) / w;
+      points[i + 1] = (a12 * x + a22 * y + a32) / w;
+    }
+    return points;
+  }
+
+  /**
+   * Transform a single point.
+   *
+   * @param {number} x @param {number} y
+   * @returns {{x: number, y: number}}
+   */
+  transformPoint(x, y) {
+    const w = this.a13 * x + this.a23 * y + this.a33;
+    return {
+      x: (this.a11 * x + this.a21 * y + this.a31) / w,
+      y: (this.a12 * x + this.a22 * y + this.a32) / w,
+    };
+  }
+
+  /**
+   * Map the unit square — (0,0), (1,0), (1,1), (0,1) — onto an arbitrary quad.
+   *
+   * Corners are given in that same order, i.e. going around the quad, not
+   * as opposite pairs.
+   *
+   * @returns {PerspectiveTransform}
+   */
+  /* eslint-disable-next-line max-params */
+  static squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3) {
+    const dx3 = x0 - x1 + x2 - x3;
+    const dy3 = y0 - y1 + y2 - y3;
+
+    if (dx3 === 0 && dy3 === 0) {
+      // The quad is a parallelogram, so the map is affine and the projective
+      // terms vanish. Worth special-casing: it is the common case for flat
+      // scans, and the general solution divides by zero here.
+      return new PerspectiveTransform(
+        x1 - x0, x2 - x1, x0,
+        y1 - y0, y2 - y1, y0,
+        0, 0, 1
+      );
+    }
+
+    const dx1 = x1 - x2;
+    const dx2 = x3 - x2;
+    const dy1 = y1 - y2;
+    const dy2 = y3 - y2;
+    const denominator = dx1 * dy2 - dx2 * dy1;
+    const a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
+    const a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
+
+    return new PerspectiveTransform(
+      x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0,
+      y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0,
+      a13, a23, 1
+    );
+  }
+
+  /**
+   * Map an arbitrary quad onto the unit square — the inverse of
+   * {@link squareToQuad}, via the adjugate.
+   *
+   * @returns {PerspectiveTransform}
+   */
+  /* eslint-disable-next-line max-params */
+  static quadToSquare(x0, y0, x1, y1, x2, y2, x3, y3) {
+    return PerspectiveTransform.squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3).inverse();
+  }
+
+  /**
+   * Map one quad onto another, corner for corner.
+   *
+   * This is what turns four detected finder corners into a sampling grid:
+   * compose "detected quad -> unit square" with "unit square -> ideal grid".
+   *
+   * @returns {PerspectiveTransform}
+   */
+  /* eslint-disable-next-line max-params */
+  static quadToQuad(
+    sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3,
+    dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3
+  ) {
+    const toSquare = PerspectiveTransform.quadToSquare(sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
+    const toQuad = PerspectiveTransform.squareToQuad(dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3);
+    return toSquare.times(toQuad);
+  }
+
+  /**
+   * Adjugate — the inverse up to a scale factor, which is irrelevant in
+   * homogeneous coordinates because the division by w cancels it.
+   *
+   * @returns {PerspectiveTransform}
+   */
+  inverse() {
+    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+    return new PerspectiveTransform(
+      a22 * a33 - a23 * a32,
+      a23 * a31 - a21 * a33,
+      a21 * a32 - a22 * a31,
+      a13 * a32 - a12 * a33,
+      a11 * a33 - a13 * a31,
+      a12 * a31 - a11 * a32,
+      a12 * a23 - a13 * a22,
+      a13 * a21 - a11 * a23,
+      a11 * a22 - a12 * a21
+    );
+  }
+
+  /**
+   * Matrix product: apply `this` first, then `other`.
+   *
+   * @param {PerspectiveTransform} other
+   * @returns {PerspectiveTransform}
+   */
+  times(other) {
+    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+    const o = other;
+    return new PerspectiveTransform(
+      o.a11 * a11 + o.a21 * a12 + o.a31 * a13,
+      o.a11 * a21 + o.a21 * a22 + o.a31 * a23,
+      o.a11 * a31 + o.a21 * a32 + o.a31 * a33,
+      o.a12 * a11 + o.a22 * a12 + o.a32 * a13,
+      o.a12 * a21 + o.a22 * a22 + o.a32 * a23,
+      o.a12 * a31 + o.a22 * a32 + o.a32 * a33,
+      o.a13 * a11 + o.a23 * a12 + o.a33 * a13,
+      o.a13 * a21 + o.a23 * a22 + o.a33 * a23,
+      o.a13 * a31 + o.a23 * a32 + o.a33 * a33
+    );
+  }
+}
+
+__exports.PerspectiveTransform = PerspectiveTransform;
+};
+
+__modules["image/grid-sampler.js"] = function (__require, __exports) {
+/**
+ * Resample a distorted symbol in the image into an upright module grid.
+ *
+ * Given a transform that maps grid coordinates to image coordinates, this
+ * samples the centre of every module. Sampling centres rather than averaging
+ * whole cells is deliberate: module edges are where blur and bleed live, and
+ * including them turns a marginal symbol into an unreadable one.
+ *
+ * @module image/grid-sampler
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { NotFoundError } = __require("core/errors.js");
+const { PerspectiveTransform } = __require("image/perspective.js");
+
+/**
+ * Sample a `dimension` x `dimension` grid (or `width` x `height`).
+ *
+ * @param {BitMatrix} image Binarized source image.
+ * @param {number} width Modules across.
+ * @param {number} height Modules down.
+ * @param {PerspectiveTransform} transform Grid space -> image space.
+ * @returns {BitMatrix}
+ * @throws {NotFoundError} If the grid falls outside the image.
+ */
+function sampleGrid(image, width, height, transform) {
+  const out = new BitMatrix(width, height);
+  const points = new Float32Array(width * 2);
+
+  for (let y = 0; y < height; y++) {
+    // Module centres: offset by half a module in both axes.
+    const gridY = y + 0.5;
+    for (let x = 0; x < width; x++) {
+      points[x * 2] = x + 0.5;
+      points[x * 2 + 1] = gridY;
+    }
+    transform.transform(points);
+
+    for (let x = 0; x < width; x++) {
+      const px = points[x * 2] | 0;
+      const py = points[x * 2 + 1] | 0;
+      if (px < 0 || py < 0 || px >= image.width || py >= image.height) {
+        throw new NotFoundError(
+          `Sampling grid escapes the image at module (${x}, ${y})`
+        );
+      }
+      if (image.get(px, py)) out.set(x, y);
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Sample with a 3x3 majority vote per module.
+ *
+ * Slower, and worth it when a single-point sample lands on a speck of noise or
+ * a JPEG artefact. Readers fall back to this after a clean sample fails to
+ * decode, rather than paying for it on every attempt.
+ *
+ * @param {BitMatrix} image
+ * @param {number} width
+ * @param {number} height
+ * @param {PerspectiveTransform} transform
+ * @returns {BitMatrix}
+ */
+function sampleGridVoting(image, width, height, transform) {
+  const out = new BitMatrix(width, height);
+
+  // Spacing between module centres, measured in image pixels, so the vote
+  // spreads across the module rather than a fixed pixel radius that would be
+  // meaningless at a different scale.
+  const p0 = transform.transformPoint(0.5, 0.5);
+  const p1 = transform.transformPoint(1.5, 0.5);
+  const p2 = transform.transformPoint(0.5, 1.5);
+  const stepX = Math.hypot(p1.x - p0.x, p1.y - p0.y);
+  const stepY = Math.hypot(p2.x - p0.x, p2.y - p0.y);
+  const rx = Math.max(1, Math.round(stepX / 4));
+  const ry = Math.max(1, Math.round(stepY / 4));
+
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const c = transform.transformPoint(x + 0.5, y + 0.5);
+      const cx = c.x | 0;
+      const cy = c.y | 0;
+      if (cx < 0 || cy < 0 || cx >= image.width || cy >= image.height) {
+        throw new NotFoundError(
+          `Sampling grid escapes the image at module (${x}, ${y})`
+        );
+      }
+
+      let dark = 0;
+      let total = 0;
+      for (let dy = -1; dy <= 1; dy++) {
+        for (let dx = -1; dx <= 1; dx++) {
+          const sx = cx + dx * rx;
+          const sy = cy + dy * ry;
+          if (sx < 0 || sy < 0 || sx >= image.width || sy >= image.height) continue;
+          total++;
+          if (image.get(sx, sy)) dark++;
+        }
+      }
+      if (total > 0 && dark * 2 > total) out.set(x, y);
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Build the transform for a symbol whose four corners are known, and sample it.
+ *
+ * Corners are in reading order: top-left, top-right, bottom-right, bottom-left.
+ *
+ * @param {BitMatrix} image
+ * @param {number} dimension Modules per side.
+ * @param {Array<{x: number, y: number}>} corners
+ * @param {boolean} [voting]
+ * @returns {BitMatrix}
+ */
+function sampleQuad(image, dimension, corners, voting = false) {
+  if (corners.length !== 4) throw new NotFoundError('sampleQuad needs exactly 4 corners');
+  const [tl, tr, br, bl] = corners;
+  const d = dimension;
+
+  const transform = PerspectiveTransform.quadToQuad(
+    0, 0, d, 0, d, d, 0, d,
+    tl.x, tl.y, tr.x, tr.y, br.x, br.y, bl.x, bl.y
+  );
+
+  return voting
+    ? sampleGridVoting(image, d, d, transform)
+    : sampleGrid(image, d, d, transform);
+}
+
+__exports.sampleGrid = sampleGrid;
+__exports.sampleGridVoting = sampleGridVoting;
+__exports.sampleQuad = sampleQuad;
+};
+
+__modules["datamatrix/detector.js"] = function (__require, __exports) {
+/**
+ * Data Matrix ECC 200 detection in a binarized image.
+ *
+ * An ECC 200 symbol is distinguished by two neighbouring solid finder borders
+ * (the L) and two alternating clock borders.  The detector first finds dark
+ * connected components, then scores every legal ECC 200 size and every
+ * quarter-turn of the component's bounding quadrilateral against those four
+ * borders.  This deliberately verifies the complete border rather than merely
+ * looking for an L: ordinary text and table rules produce L shapes often.
+ *
+ * The resulting quadrilateral is sampled back into the canonical orientation:
+ * solid borders at left and bottom.  It is intentionally independent of the
+ * payload decoder, so geometry can be used by callers that need the matrix.
+ *
+ * @module datamatrix/detector
+ */
+const { NotFoundError } = __require("core/errors.js");
+const { sampleGrid, sampleQuad } = __require("image/grid-sampler.js");
+const { PerspectiveTransform } = __require("image/perspective.js");
+const { decodeDataMatrix } = __require("datamatrix/decoder.js");
+
+// ECC 200 dimensions.  DMRE is deliberately not included: it uses a separate
+// size table and is not part of the original ECC 200 family implemented here.
+const SIZES = [
+  [10, 10], [12, 12], [14, 14], [16, 16], [18, 18], [20, 20], [22, 22], [24, 24], [26, 26],
+  [32, 32], [36, 36], [40, 40], [44, 44], [48, 48], [52, 52], [64, 64], [72, 72], [80, 80],
+  [88, 88], [96, 96], [104, 104], [120, 120], [132, 132], [144, 144],
+  [18, 8], [32, 8], [26, 12], [36, 12], [36, 16], [48, 16],
+];
+
+/** @typedef {{x:number, y:number}} Point */
+/** @typedef {{corners: Point[], dimension: number, width: number, height: number, moduleSize: number, matrix: import('../core/bit-matrix.js').BitMatrix}} Detection */
+
+function dark(image, x, y) {
+  return image.get(Math.max(0, Math.min(image.width - 1, Math.round(x))),
+    Math.max(0, Math.min(image.height - 1, Math.round(y))));
+}
+
+/** Return components which are large enough to plausibly contain a symbol. */
+function components(image) {
+  const seen = new Uint8Array(image.width * image.height);
+  const out = [];
+  const push = (x, y, xs, ys) => { xs.push(x); ys.push(y); };
+  for (let y = 0; y < image.height; y++) for (let x = 0; x < image.width; x++) {
+    const start = y * image.width + x;
+    if (seen[start] || !image.get(x, y)) continue;
+    const xs = [x], ys = [y]; seen[start] = 1;
+    let head = 0, minX = x, maxX = x, minY = y, maxY = y;
+    while (head < xs.length) {
+      const px = xs[head], py = ys[head++];
+      if (px < minX) minX = px; if (px > maxX) maxX = px;
+      if (py < minY) minY = py; if (py > maxY) maxY = py;
+      for (const [nx, ny] of [[px - 1, py], [px + 1, py], [px, py - 1], [px, py + 1]]) {
+        if (nx < 0 || ny < 0 || nx >= image.width || ny >= image.height) continue;
+        const at = ny * image.width + nx;
+        if (!seen[at] && image.get(nx, ny)) { seen[at] = 1; push(nx, ny, xs, ys); }
+      }
+    }
+    if (maxX - minX >= 7 && maxY - minY >= 7) out.push({ minX, minY, maxX, maxY, pixels: xs.length });
+  }
+  return out.sort((a, b) => b.pixels - a.pixels).slice(0, 40);
+}
+
+/** Sample a physical edge at module centres. */
+function edge(image, a, b, count) {
+  const values = [];
+  for (let i = 0; i < count; i++) {
+    const t = (i + 0.5) / count;
+    values.push(dark(image, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t));
+  }
+  return values;
+}
+
+function solidScore(values) {
+  let n = 0; for (const value of values) if (value) n++;
+  return n / values.length;
+}
+
+function clockScore(values, startsDark) {
+  let n = 0;
+  for (let i = 0; i < values.length; i++) if (values[i] === ((i & 1) === 0 ? startsDark : !startsDark)) n++;
+  return n / values.length;
+}
+
+/** Count light/dark changes along a physical edge at approximately one-pixel intervals. */
+function edgeTransitions(image, a, b) {
+  const steps = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y)));
+  let previous = dark(image, a.x, a.y);
+  let changes = 0;
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps;
+    const value = dark(image, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+    if (value !== previous) changes++;
+    previous = value;
+  }
+  return changes;
+}
+
+/** Reject a smaller harmonic whose module-centre samples happen to alternate. */
+function transitionCountFits(observed, modules) {
+  const expected = modules - 1;
+  const tolerance = Math.max(2, Math.floor(expected * 0.08));
+  return Math.abs(observed - expected) <= tolerance;
+}
+
+function sample(image, width, height, corners, voting) {
+  if (width === height) return sampleQuad(image, width, corners, voting);
+  const [tl, tr, br, bl] = corners;
+  const transform = PerspectiveTransform.quadToQuad(0, 0, width, 0, width, height, 0, height,
+    tl.x, tl.y, tr.x, tr.y, br.x, br.y, bl.x, bl.y);
+  return sampleGrid(image, width, height, transform);
+}
+
+/**
+ * Find Data Matrix symbols in a binarized image.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage Set bit = dark.
+ * @returns {Detection | null} The strongest candidate, or null when absent.
+ */
+function detectDataMatrix(binaryImage) {
+  if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+    throw new NotFoundError('detectDataMatrix: no image supplied');
+  }
+  const detections = [];
+  const used = new Set();
+  for (const box of components(binaryImage)) {
+    const base = [
+      { x: box.minX, y: box.minY }, { x: box.maxX + 1, y: box.minY },
+      { x: box.maxX + 1, y: box.maxY + 1 }, { x: box.minX, y: box.maxY + 1 },
+    ];
+    // Profile the actual ink, rather than the outer sampling quadrilateral:
+    // its far x/y boundary lies one pixel beyond the last dark pixel.
+    const ink = [
+      { x: box.minX, y: box.minY }, { x: box.maxX, y: box.minY },
+      { x: box.maxX, y: box.maxY }, { x: box.minX, y: box.maxY },
+    ];
+    for (const [w, h] of SIZES) for (let turn = 0; turn < 4; turn++) {
+      // A 90 degree turn swaps physical width and height.
+      const physicalW = (turn & 1) ? h : w, physicalH = (turn & 1) ? w : h;
+      const pitchX = (box.maxX - box.minX + 1) / physicalW;
+      const pitchY = (box.maxY - box.minY + 1) / physicalH;
+      if (Math.min(pitchX, pitchY) < 1 || Math.abs(pitchX - pitchY) > Math.max(pitchX, pitchY) * 0.22) continue;
+      const corners = base.slice(turn).concat(base.slice(0, turn));
+      const profile = ink.slice(turn).concat(ink.slice(0, turn));
+      // Canonical edge order: top clock, right clock, bottom solid, left solid.
+      const top = edge(binaryImage, profile[0], profile[1], w);
+      const right = edge(binaryImage, profile[1], profile[2], h);
+      const bottom = edge(binaryImage, profile[2], profile[3], w);
+      const left = edge(binaryImage, profile[3], profile[0], h);
+      // Sampling only the proposed module centres aliases exact harmonics: an
+      // 80-module clock border, for example, can look like a perfect 16-module
+      // border.  Count transitions at image-pixel resolution as an independent
+      // dimension measurement before accepting the candidate.
+      if (!transitionCountFits(edgeTransitions(binaryImage, profile[0], profile[1]), w) ||
+          !transitionCountFits(edgeTransitions(binaryImage, profile[1], profile[2]), h)) continue;
+      // The top clock starts dark at the solid left border.  The right clock is
+      // anchored dark at the solid bottom border instead, so its top phase
+      // depends on the symbol height (all ECC 200 heights are even and
+      // therefore start light).
+      const score = (clockScore(top, true) + clockScore(right, (h & 1) === 1) +
+        solidScore(bottom) + solidScore(left)) / 4;
+      if (score < 0.88) continue;
+      const key = `${box.minX},${box.minY},${box.maxX},${box.maxY}`;
+      if (used.has(key)) continue;
+      let matrix;
+      try { matrix = sample(binaryImage, w, h, corners, false); } catch (e) { continue; }
+      used.add(key);
+      detections.push({ corners, dimension: w === h ? w : 0, width: w, height: h,
+        moduleSize: (pitchX + pitchY) / 2, matrix, score });
+    }
+  }
+  detections.sort((a, b) => b.score - a.score || b.moduleSize - a.moduleSize);
+  return detections[0] ?? null;
+}
+
+/**
+ * Detect and decode Data Matrix symbols.  Detection failure is normal for an
+ * image without a symbol, so candidates that cannot decode are skipped.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @returns {(import('./decoder.js').DecodeResult & {corners: Point[]}) | null}
+ */
+function detectAndDecodeDataMatrix(binaryImage) {
+  let detection;
+  try { detection = detectDataMatrix(binaryImage); } catch (e) { return null; }
+  if (!detection) return null;
+  for (const voting of [false, true]) {
+    let matrix = detection.matrix;
+    try { if (voting) matrix = sample(binaryImage, detection.width, detection.height, detection.corners, true); } catch (e) { continue; }
+    try { return Object.assign({ corners: detection.corners }, decodeDataMatrix(matrix)); }
+    catch (e) { /* A geometric candidate is not necessarily a symbol. */ }
+  }
+  return null;
+}
+
+__exports.detectDataMatrix = detectDataMatrix;
+__exports.detectAndDecodeDataMatrix = detectAndDecodeDataMatrix;
+};
+
+__modules["datamatrix/index.js"] = function (__require, __exports) {
+/** Data Matrix ECC 200 entry points. @module datamatrix */
+const __reexport0 = __require("datamatrix/encoder.js"); __exports.encodeDataMatrix = __reexport0.encodeDataMatrix; __exports.encodeDataMatrixCodewords = __reexport0.encodeDataMatrixCodewords;
+const __reexport1 = __require("datamatrix/decoder.js"); __exports.decodeDataMatrix = __reexport1.decodeDataMatrix;
+const __reexport2 = __require("datamatrix/detector.js"); __exports.detectDataMatrix = __reexport2.detectDataMatrix; __exports.detectAndDecodeDataMatrix = __reexport2.detectAndDecodeDataMatrix;
+const __reexport3 = __require("datamatrix/tables.js"); __exports.DATAMATRIX_SYMBOLS = __reexport3.DATAMATRIX_SYMBOLS; __exports.SYMBOLS = __reexport3.SYMBOLS; __exports.symbolForDataCodewords = __reexport3.symbolForDataCodewords; __exports.validateDataMatrixTables = __reexport3.validateDataMatrixTables; __exports.validateTables = __reexport3.validateTables;
+
+
+};
+
+__modules["core/bit-buffer.js"] = function (__require, __exports) {
+/**
+ * Bit-level writing and reading, MSB-first.
+ *
+ * Every 2D symbology serialises its payload as a bitstream that does not
+ * respect byte boundaries — QR alone mixes 4-bit mode indicators, 10-bit
+ * character-count fields and 11-bit alphanumeric pairs. These two classes are
+ * the write and read halves of that.
+ *
+ * @module core/bit-buffer
+ */
+const { FormatError } = __require("core/errors.js");
+
+/** Growable MSB-first bit writer. */
+class BitWriter {
+  constructor() {
+    /** @type {number[]} Packed bytes; the last one may be partially filled. */
+    this.bytes = [];
+    this.bitLength = 0;
+  }
+
+  /** @returns {number} Bits written so far. */
+  get length() {
+    return this.bitLength;
+  }
+
+  /**
+   * Append the low `count` bits of `value`, most significant first.
+   *
+   * @param {number} value
+   * @param {number} count
+   */
+  put(value, count) {
+    for (let i = count - 1; i >= 0; i--) {
+      this.putBit(((value >>> i) & 1) === 1);
+    }
+  }
+
+  /** @param {boolean} bit */
+  putBit(bit) {
+    const idx = this.bitLength >>> 3;
+    if (this.bytes.length <= idx) this.bytes.push(0);
+    if (bit) this.bytes[idx] |= 0x80 >>> (this.bitLength & 7);
+    this.bitLength++;
+  }
+
+  /** @param {ArrayLike<number>} data */
+  putBytes(data) {
+    for (let i = 0; i < data.length; i++) this.put(data[i], 8);
+  }
+
+  /** Pad with zero bits until the length is a multiple of 8. */
+  padToByte() {
+    while (this.bitLength & 7) this.putBit(false);
+  }
+
+  /**
+   * @returns {Uint8Array} Byte view; trailing bits of the final byte are zero.
+   */
+  toBytes() {
+    return Uint8Array.from(this.bytes);
+  }
+
+  /** @returns {string} Debug view, e.g. "0100 0011 0101". */
+  toString() {
+    let s = '';
+    for (let i = 0; i < this.bitLength; i++) {
+      if (i && i % 4 === 0) s += ' ';
+      s += (this.bytes[i >>> 3] >>> (7 - (i & 7))) & 1;
+    }
+    return s;
+  }
+}
+
+/** MSB-first bit reader over a byte array. */
+class BitReader {
+  /** @param {ArrayLike<number>} bytes */
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.byteOffset = 0;
+    this.bitOffset = 0;
+  }
+
+  /** @returns {number} Bits not yet consumed. */
+  available() {
+    return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;
+  }
+
+  /**
+   * Read `count` bits (1..32) as an unsigned integer, most significant first.
+   *
+   * @param {number} count
+   * @returns {number}
+   * @throws {FormatError} If the stream is exhausted.
+   */
+  read(count) {
+    if (count < 1 || count > 32) {
+      throw new FormatError(`BitReader: cannot read ${count} bits`);
+    }
+    if (count > this.available()) {
+      throw new FormatError(
+        `BitReader: needed ${count} bits, ${this.available()} remain`
+      );
+    }
+
+    let result = 0;
+    let remaining = count;
+
+    // Finish the partially consumed byte first, then take whole bytes.
+    if (this.bitOffset > 0) {
+      const inCurrent = 8 - this.bitOffset;
+      const take = Math.min(remaining, inCurrent);
+      const shift = inCurrent - take;
+      const mask = (0xff >> this.bitOffset) & ~((1 << shift) - 1);
+      result = (this.bytes[this.byteOffset] & mask) >> shift;
+      remaining -= take;
+      this.bitOffset += take;
+      if (this.bitOffset === 8) {
+        this.bitOffset = 0;
+        this.byteOffset++;
+      }
+    }
+
+    while (remaining >= 8) {
+      result = (result << 8) | (this.bytes[this.byteOffset] & 0xff);
+      this.byteOffset++;
+      remaining -= 8;
+    }
+
+    if (remaining > 0) {
+      const shift = 8 - remaining;
+      const mask = ~((1 << shift) - 1) & 0xff;
+      result = (result << remaining) | ((this.bytes[this.byteOffset] & mask) >> shift);
+      this.bitOffset += remaining;
+    }
+
+    return result >>> 0;
+  }
+
+  /** @returns {boolean} */
+  readBit() {
+    return this.read(1) === 1;
+  }
+}
+
+__exports.BitWriter = BitWriter;
+__exports.BitReader = BitReader;
+};
+
+__modules["qr/tables.js"] = function (__require, __exports) {
+/**
+ * QR Code structural tables.
+ *
+ * The design principle here is that as little as possible is *recalled* and as
+ * much as possible is *derived*, because a barcode table is the one place where
+ * a single mistyped digit produces a symbol that looks perfect and scans as
+ * garbage — or, worse, scans correctly for the payload you tested and fails for
+ * the payload your user sends.
+ *
+ * So:
+ *
+ *   - Symbol size, function-pattern layout and total codeword capacity are
+ *     computed from geometry. Nothing is tabulated that the module grid already
+ *     knows.
+ *   - Alignment centres come from the spec's spacing rule, not a 40-row table.
+ *   - The group-1 / group-2 block split is arithmetic, not data.
+ *
+ * That leaves exactly three recalled numbers per (version, level): the error
+ * correction codewords per block, the block count, and the total data codeword
+ * count. Those three are deliberately redundant — they must satisfy
+ *
+ *     blocks * eccPerBlock + totalDataCodewords === geometricTotalCodewords(v)
+ *
+ * for all 160 combinations, where the right-hand side is counted off the module
+ * grid. Any single typo on either side breaks the identity. {@link validateTables}
+ * enforces it, and the test suite asserts it returns no problems.
+ *
+ * @module qr/tables
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+
+/** Error correction levels, weakest to strongest. */
+const ECC_LEVELS = ['L', 'M', 'Q', 'H'];
+
+/**
+ * Two-bit level indicator used in the format information.
+ * Note this is *not* the L/M/Q/H ordering — the spec assigns them out of order.
+ */
+const ECC_LEVEL_BITS = { L: 0b01, M: 0b00, Q: 0b11, H: 0b10 };
+
+/** Inverse of {@link ECC_LEVEL_BITS}, indexed by the 2-bit value. */
+const ECC_LEVEL_BY_BITS = ['M', 'L', 'H', 'Q'];
+const MIN_VERSION = 1;
+const MAX_VERSION = 40;
+
+/** Version at and above which an 18-bit version information block is carried. */
+const VERSION_INFO_MIN = 7;
+
+/** Mode indicator nibbles. */
+const MODE = {
+  TERMINATOR: 0x0,
+  NUMERIC: 0x1,
+  ALPHANUMERIC: 0x2,
+  STRUCTURED_APPEND: 0x3,
+  BYTE: 0x4,
+  FNC1_FIRST: 0x5,
+  ECI: 0x7,
+  KANJI: 0x8,
+  FNC1_SECOND: 0x9,
+};
+
+/**
+ * Character count indicator width, in bits, by mode and version band.
+ *
+ * The bands are versions 1-9, 10-26 and 27-40. They are the reason segment
+ * selection and version selection are mutually dependent: widening the count
+ * field can push a payload over a version boundary, which widens it again.
+ */
+const COUNT_BITS = {
+  [MODE.NUMERIC]: [10, 12, 14],
+  [MODE.ALPHANUMERIC]: [9, 11, 13],
+  [MODE.BYTE]: [8, 16, 16],
+  [MODE.KANJI]: [8, 10, 12],
+};
+
+/**
+ * @param {number} version 1-40
+ * @returns {number} Modules per side.
+ */
+function versionSize(version) {
+  return 17 + 4 * version;
+}
+
+/**
+ * Bits in the character count indicator.
+ *
+ * @param {number} mode One of {@link MODE}.
+ * @param {number} version
+ * @returns {number}
+ */
+function countBits(mode, version) {
+  const widths = COUNT_BITS[mode];
+  if (!widths) return 0;
+  if (version <= 9) return widths[0];
+  if (version <= 26) return widths[1];
+  return widths[2];
+}
+
+/**
+ * Centre coordinates of the alignment patterns for a version.
+ *
+ * The spec's rule: the first centre is always 6 and the last is always
+ * `size - 7`; the count grows by one every seven versions; and the centres are
+ * evenly spaced with the *first* gap absorbing the rounding slack. Expressing
+ * that as arithmetic rather than a 40-row table means there is no table to
+ * mistype, and {@link validateTables} can then assert the shape of the result.
+ *
+ * @param {number} version
+ * @returns {number[]} Ascending centres. Empty for version 1.
+ */
+function alignmentCoordinates(version) {
+  if (version < 2) return [];
+
+  const size = versionSize(version);
+  const count = Math.floor(version / 7) + 2;
+  const last = size - 7;
+
+  // Spacing is rounded up to an even number of modules so every centre lands on
+  // the same parity as the timing pattern, which is what keeps the patterns
+  // aligned with the module grid rather than straddling it.
+  const step = Math.ceil((size - 13) / (2 * count - 2)) * 2;
+
+  const coords = [6];
+  // Walk backwards from the final centre so the slack lands in the first gap.
+  for (let i = count - 1; i >= 1; i--) coords.push(last - (count - 1 - i) * step);
+  coords.sort((a, b) => a - b);
+  return coords;
+}
+
+/**
+ * Centres of the alignment patterns actually drawn, as [x, y] pairs.
+ *
+ * The three combinations that would sit on top of a finder pattern are omitted.
+ *
+ * @param {number} version
+ * @returns {Array<[number, number]>}
+ */
+function alignmentCentres(version) {
+  const coords = alignmentCoordinates(version);
+  if (coords.length === 0) return [];
+
+  const size = versionSize(version);
+  const lo = 6;
+  const hi = size - 7;
+  const out = [];
+  for (let i = 0; i < coords.length; i++) {
+    for (let j = 0; j < coords.length; j++) {
+      const x = coords[j];
+      const y = coords[i];
+      // Skip the three finder corners.
+      if (x === lo && y === lo) continue;
+      if (x === lo && y === hi) continue;
+      if (x === hi && y === lo) continue;
+      out.push([x, y]);
+    }
+  }
+  return out;
+}
+
+const reservedCache = new Map();
+
+/**
+ * Map of modules that carry function patterns rather than payload.
+ *
+ * A set bit means "reserved": finder, separator, timing, alignment, format
+ * information, the dark module, and the version information blocks. This is the
+ * single source of truth used by the encoder to skip modules while laying out
+ * the bitstream, by the decoder to read them back in the same order, and by
+ * {@link geometricTotalCodewords} to count what is left.
+ *
+ * Deriving capacity this way rather than by hand arithmetic is what makes the
+ * awkward cases free: an alignment pattern that overlaps the timing pattern is
+ * counted once because it is the same set of modules, not because anyone
+ * remembered to subtract five.
+ *
+ * @param {number} version
+ * @returns {BitMatrix} Shared, cached — treat as immutable.
+ */
+function reservedModules(version) {
+  const cached = reservedCache.get(version);
+  if (cached) return cached;
+
+  const size = versionSize(version);
+  const m = new BitMatrix(size, size);
+
+  // Finder patterns with their separators: an 8x8 reserved block at each of
+  // three corners (7x7 pattern plus a one-module light border on the inner
+  // sides, which the corner blocks absorb).
+  m.setRegion(0, 0, 8, 8);
+  m.setRegion(size - 8, 0, 8, 8);
+  m.setRegion(0, size - 8, 8, 8);
+
+  // Timing patterns, spanning the gap between the separators.
+  for (let i = 8; i < size - 8; i++) {
+    m.set(i, 6);
+    m.set(6, i);
+  }
+
+  // Alignment patterns, 5x5 each.
+  const centres = alignmentCentres(version);
+  for (let i = 0; i < centres.length; i++) {
+    m.setRegion(centres[i][0] - 2, centres[i][1] - 2, 5, 5);
+  }
+
+  // Format information: two copies plus the dark module. The copies partly
+  // fall inside the 8x8 finder blocks already reserved; setting them again is
+  // harmless and keeps the intent explicit.
+  const [copyA, copyB] = formatInfoPositions(size);
+  for (let i = 0; i < 15; i++) {
+    m.set(copyA[i][0], copyA[i][1]);
+    m.set(copyB[i][0], copyB[i][1]);
+  }
+  m.set(8, size - 8); // dark module
+
+  // Version information, two 6x3 blocks.
+  if (version >= VERSION_INFO_MIN) {
+    m.setRegion(size - 11, 0, 3, 6);
+    m.setRegion(0, size - 11, 6, 3);
+  }
+
+  reservedCache.set(version, m);
+  return m;
+}
+
+/**
+ * Module positions of the two format information copies.
+ *
+ * Index `i` in each array is bit `i` of the 15-bit format value, bit 0 being
+ * the least significant.
+ *
+ * CAVEAT WORTH READING: the *direction* of this numbering is the one thing in
+ * this file that a round-trip test cannot falsify. Encoder and decoder share
+ * these tables, so a mirrored layout would pass every test in the suite and
+ * fail only against a real scanner. The layout below is the standard one; both
+ * sides deliberately consume this single definition so there is no second place
+ * for the convention to drift.
+ *
+ * @param {number} size Modules per side.
+ * @returns {[Array<[number, number]>, Array<[number, number]>]} [copyA, copyB]
+ */
+function formatInfoPositions(size) {
+  /** @type {Array<[number, number]>} */
+  const a = [];
+  /** @type {Array<[number, number]>} */
+  const b = [];
+
+  for (let i = 0; i < 15; i++) {
+    // Copy A wraps the top-left finder: down column 8, then left along row 8,
+    // stepping over the two timing modules.
+    if (i < 6) a.push([8, i]);
+    else if (i === 6) a.push([8, 7]);
+    else if (i === 7) a.push([8, 8]);
+    else if (i === 8) a.push([7, 8]);
+    else a.push([14 - i, 8]);
+
+    // Copy B is split: the low bits run right-to-left along row 8 beside the
+    // top-right finder, the high bits run bottom-up beside the bottom-left one.
+    if (i < 8) b.push([size - 1 - i, 8]);
+    else b.push([8, size - 15 + i]);
+  }
+
+  return [a, b];
+}
+
+/**
+ * Modules available to data and error correction, counted off the grid.
+ *
+ * @param {number} version
+ * @returns {number}
+ */
+function freeModuleCount(version) {
+  const reserved = reservedModules(version);
+  const size = versionSize(version);
+  let free = 0;
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      if (!reserved.get(x, y)) free++;
+    }
+  }
+  return free;
+}
+
+/**
+ * Total codewords (data + error correction) a version holds.
+ *
+ * Geometric, not tabulated — this is the reference the ECC table is checked
+ * against.
+ *
+ * @param {number} version
+ * @returns {number}
+ */
+function geometricTotalCodewords(version) {
+  return Math.floor(freeModuleCount(version) / 8);
+}
+
+/**
+ * Bits left over after the last whole codeword, written as zeroes.
+ *
+ * @param {number} version
+ * @returns {number} 0, 3, 4 or 7.
+ */
+function remainderBits(version) {
+  return freeModuleCount(version) % 8;
+}
+
+const orderCache = new Map();
+
+/**
+ * Module positions in bitstream order, as interleaved x, y pairs.
+ *
+ * The layout walks two-module-wide columns from the bottom-right corner
+ * leftward, alternating upward and downward, right module of the pair before
+ * the left, skipping the vertical timing column and every reserved module.
+ *
+ * Encoder and decoder both consume this one function. That is not tidiness: a
+ * placement order that disagrees between the two would still round-trip
+ * perfectly within this library while producing symbols no scanner can read.
+ * There is only one order because there is only one implementation of it.
+ *
+ * @param {number} version
+ * @returns {Int32Array} Shared, cached — treat as immutable. Length is
+ *   `2 * freeModuleCount(version)`.
+ */
+function dataModuleOrder(version) {
+  const cached = orderCache.get(version);
+  if (cached) return cached;
+
+  const size = versionSize(version);
+  const reserved = reservedModules(version);
+  const out = new Int32Array(freeModuleCount(version) * 2);
+  let n = 0;
+
+  let upward = true;
+  for (let col = size - 1; col > 0; col -= 2) {
+    // Column 6 is the vertical timing pattern. Stepping over it shifts the
+    // whole remaining schedule left by one, so the loop variable itself has to
+    // move — adjusting only the current pair would visit column 4 twice and
+    // column 0 never, which is self-consistent between encoder and decoder and
+    // therefore invisible to a round-trip test.
+    if (col === 6) col--;
+    for (let i = 0; i < size; i++) {
+      const y = upward ? size - 1 - i : i;
       for (let c = 0; c < 2; c++) {
         const x = col - c;
         if (reserved.get(x, y)) continue;
@@ -5564,934 +6591,1741 @@ __exports.ChecksumError = ChecksumError;
 __exports.decodeQR = decodeQR;
 };
 
-__modules["image/perspective.js"] = function (__require, __exports) {
+__modules["qr/detector.js"] = function (__require, __exports) {
 /**
- * Projective (perspective) transforms.
- *
- * A 2D symbol photographed off-axis is not a rotated square — it is a
- * quadrilateral with converging edges. Correcting that needs a full projective
- * map, not an affine one; an affine approximation reads the near edge of a
- * tilted symbol correctly and drifts a module or more by the far edge.
+ * QR Code detection — finding symbols in a binarized image.
  *
- * The map is a 3x3 homogeneous matrix. Points are transformed as
- * (x, y, 1) * M, then divided through by the resulting w.
+ * The whole thing hangs off one property of the finder pattern: along any line
+ * through its centre, in any direction, the dark and light runs are in the
+ * ratio 1:1:3:1:1. That is true horizontally, vertically and diagonally, it is
+ * scale-independent, and no ordinary printed matter reproduces it by accident.
+ * So the search is: scan rows for that ratio, confirm each hit by scanning the
+ * column through it, cluster what survives, and look for three clusters
+ * arranged in a right isoceles triangle.
  *
- * @module image/perspective
- */
-class PerspectiveTransform {
-  /* eslint-disable-next-line max-params */
-  constructor(a11, a21, a31, a12, a22, a32, a13, a23, a33) {
-    this.a11 = a11; this.a21 = a21; this.a31 = a31;
-    this.a12 = a12; this.a22 = a22; this.a32 = a32;
-    this.a13 = a13; this.a23 = a23; this.a33 = a33;
-  }
-
-  /**
-   * Transform points in place.
-   *
-   * @param {Float32Array | number[]} points Interleaved [x0, y0, x1, y1, ...].
-   * @returns {Float32Array | number[]} The same array.
-   */
-  transform(points) {
-    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
-    for (let i = 0; i < points.length; i += 2) {
-      const x = points[i];
-      const y = points[i + 1];
-      const w = a13 * x + a23 * y + a33;
-      points[i] = (a11 * x + a21 * y + a31) / w;
-      points[i + 1] = (a12 * x + a22 * y + a32) / w;
-    }
-    return points;
-  }
-
-  /**
-   * Transform a single point.
-   *
-   * @param {number} x @param {number} y
-   * @returns {{x: number, y: number}}
-   */
-  transformPoint(x, y) {
-    const w = this.a13 * x + this.a23 * y + this.a33;
-    return {
-      x: (this.a11 * x + this.a21 * y + this.a31) / w,
-      y: (this.a12 * x + this.a22 * y + this.a32) / w,
-    };
-  }
-
-  /**
-   * Map the unit square — (0,0), (1,0), (1,1), (0,1) — onto an arbitrary quad.
-   *
-   * Corners are given in that same order, i.e. going around the quad, not
-   * as opposite pairs.
-   *
-   * @returns {PerspectiveTransform}
-   */
-  /* eslint-disable-next-line max-params */
-  static squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3) {
-    const dx3 = x0 - x1 + x2 - x3;
-    const dy3 = y0 - y1 + y2 - y3;
-
-    if (dx3 === 0 && dy3 === 0) {
-      // The quad is a parallelogram, so the map is affine and the projective
-      // terms vanish. Worth special-casing: it is the common case for flat
-      // scans, and the general solution divides by zero here.
-      return new PerspectiveTransform(
-        x1 - x0, x2 - x1, x0,
-        y1 - y0, y2 - y1, y0,
-        0, 0, 1
-      );
-    }
-
-    const dx1 = x1 - x2;
-    const dx2 = x3 - x2;
-    const dy1 = y1 - y2;
-    const dy2 = y3 - y2;
-    const denominator = dx1 * dy2 - dx2 * dy1;
-    const a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
-    const a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
-
-    return new PerspectiveTransform(
-      x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0,
-      y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0,
-      a13, a23, 1
-    );
-  }
-
-  /**
-   * Map an arbitrary quad onto the unit square — the inverse of
-   * {@link squareToQuad}, via the adjugate.
-   *
-   * @returns {PerspectiveTransform}
-   */
-  /* eslint-disable-next-line max-params */
-  static quadToSquare(x0, y0, x1, y1, x2, y2, x3, y3) {
-    return PerspectiveTransform.squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3).inverse();
-  }
-
-  /**
-   * Map one quad onto another, corner for corner.
-   *
-   * This is what turns four detected finder corners into a sampling grid:
-   * compose "detected quad -> unit square" with "unit square -> ideal grid".
-   *
-   * @returns {PerspectiveTransform}
-   */
-  /* eslint-disable-next-line max-params */
-  static quadToQuad(
-    sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3,
-    dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3
-  ) {
-    const toSquare = PerspectiveTransform.quadToSquare(sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
-    const toQuad = PerspectiveTransform.squareToQuad(dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3);
-    return toSquare.times(toQuad);
-  }
-
-  /**
-   * Adjugate — the inverse up to a scale factor, which is irrelevant in
-   * homogeneous coordinates because the division by w cancels it.
-   *
-   * @returns {PerspectiveTransform}
-   */
-  inverse() {
-    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
-    return new PerspectiveTransform(
-      a22 * a33 - a23 * a32,
-      a23 * a31 - a21 * a33,
-      a21 * a32 - a22 * a31,
-      a13 * a32 - a12 * a33,
-      a11 * a33 - a13 * a31,
-      a12 * a31 - a11 * a32,
-      a12 * a23 - a13 * a22,
-      a13 * a21 - a11 * a23,
-      a11 * a22 - a12 * a21
-    );
-  }
-
-  /**
-   * Matrix product: apply `this` first, then `other`.
-   *
-   * @param {PerspectiveTransform} other
-   * @returns {PerspectiveTransform}
-   */
-  times(other) {
-    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
-    const o = other;
-    return new PerspectiveTransform(
-      o.a11 * a11 + o.a21 * a12 + o.a31 * a13,
-      o.a11 * a21 + o.a21 * a22 + o.a31 * a23,
-      o.a11 * a31 + o.a21 * a32 + o.a31 * a33,
-      o.a12 * a11 + o.a22 * a12 + o.a32 * a13,
-      o.a12 * a21 + o.a22 * a22 + o.a32 * a23,
-      o.a12 * a31 + o.a22 * a32 + o.a32 * a33,
-      o.a13 * a11 + o.a23 * a12 + o.a33 * a13,
-      o.a13 * a21 + o.a23 * a22 + o.a33 * a23,
-      o.a13 * a31 + o.a23 * a32 + o.a33 * a33
-    );
-  }
-}
+ * Three finders give three corners. The fourth is the problem: extrapolating
+ * `topRight + bottomLeft - topLeft` assumes the symbol is a parallelogram,
+ * which is only true if it was photographed square-on. For version 2 and up the
+ * bottom-right alignment pattern pins that corner down properly, which is what
+ * makes a tilted symbol readable. When the alignment pattern cannot be found,
+ * detection degrades to the parallelogram estimate rather than failing — a
+ * slightly wrong corner still decodes on a flat image, and Reed-Solomon absorbs
+ * the rest.
+ *
+ * @module qr/detector
+ */
+const { NotFoundError } = __require("core/errors.js");
+const { PerspectiveTransform } = __require("image/perspective.js");
+const { sampleQuad } = __require("image/grid-sampler.js");
+const { decodeQR } = __require("qr/decoder.js");
 
-__exports.PerspectiveTransform = PerspectiveTransform;
-};
+/** Finder pattern run ratios, centre run first in the array's own order. */
+const FINDER_RATIOS = [1, 1, 3, 1, 1];
+
+/** Alignment pattern run ratios. */
+const ALIGNMENT_RATIOS = [1, 1, 1, 1, 1];
+
+/** Smallest and largest legal symbol dimensions, in modules. */
+const MIN_DIMENSION = 21;
+const MAX_DIMENSION = 177;
 
-__modules["image/grid-sampler.js"] = function (__require, __exports) {
 /**
- * Resample a distorted symbol in the image into an upright module grid.
+ * Do five alternating runs match the expected ratios?
  *
- * Given a transform that maps grid coordinates to image coordinates, this
- * samples the centre of every module. Sampling centres rather than averaging
- * whole cells is deliberate: module edges are where blur and bleed live, and
- * including them turns a marginal symbol into an unreadable one.
+ * Tolerance is half a module, scaled by the ratio, which is the widest band
+ * that still rejects ordinary text and rules while accepting the blur and
+ * rounding of a real scan.
  *
- * @module image/grid-sampler
+ * @param {number[]} counts Five run lengths, dark first.
+ * @param {number[]} ratios
+ * @returns {number} The implied module size, or 0 if the ratios do not match.
  */
-const { BitMatrix } = __require("core/bit-matrix.js");
-const { NotFoundError } = __require("core/errors.js");
-const { PerspectiveTransform } = __require("image/perspective.js");
+function matchRatios(counts, ratios) {
+  let total = 0;
+  let units = 0;
+  for (let i = 0; i < 5; i++) {
+    if (counts[i] === 0) return 0;
+    total += counts[i];
+    units += ratios[i];
+  }
+  if (total < units) return 0;
+
+  const moduleSize = total / units;
+  const tolerance = moduleSize / 2;
+  for (let i = 0; i < 5; i++) {
+    if (Math.abs(counts[i] - moduleSize * ratios[i]) > tolerance * ratios[i]) return 0;
+  }
+  return moduleSize;
+}
 
 /**
- * Sample a `dimension` x `dimension` grid (or `width` x `height`).
+ * Scan one row for the finder run ratio.
  *
- * @param {BitMatrix} image Binarized source image.
- * @param {number} width Modules across.
- * @param {number} height Modules down.
- * @param {PerspectiveTransform} transform Grid space -> image space.
- * @returns {BitMatrix}
- * @throws {NotFoundError} If the grid falls outside the image.
+ * @param {import('../core/bit-matrix.js').BitMatrix} image
+ * @param {number} y
+ * @param {number[]} ratios
+ * @param {(centreX: number, moduleSize: number) => void} onHit
  */
-function sampleGrid(image, width, height, transform) {
-  const out = new BitMatrix(width, height);
-  const points = new Float32Array(width * 2);
+function scanRow(image, y, ratios, onHit) {
+  const width = image.width;
+  const counts = [0, 0, 0, 0, 0];
+  let state = 0;
 
-  for (let y = 0; y < height; y++) {
-    // Module centres: offset by half a module in both axes.
-    const gridY = y + 0.5;
-    for (let x = 0; x < width; x++) {
-      points[x * 2] = x + 0.5;
-      points[x * 2 + 1] = gridY;
+  for (let x = 0; x < width; x++) {
+    const dark = image.get(x, y);
+
+    // Even states are dark runs, odd states light.
+    if (dark === ((state & 1) === 0)) {
+      counts[state]++;
+      continue;
     }
-    transform.transform(points);
 
-    for (let x = 0; x < width; x++) {
-      const px = points[x * 2] | 0;
-      const py = points[x * 2 + 1] | 0;
-      if (px < 0 || py < 0 || px >= image.width || py >= image.height) {
-        throw new NotFoundError(
-          `Sampling grid escapes the image at module (${x}, ${y})`
-        );
-      }
-      if (image.get(px, py)) out.set(x, y);
+    // A leading light margin is not part of any pattern.
+    if (state === 0 && counts[0] === 0) continue;
+
+    if (state < 4) {
+      state++;
+      counts[state] = 1;
+      continue;
+    }
+
+    // Five runs complete, and the sixth has begun.
+    const moduleSize = matchRatios(counts, ratios);
+    if (moduleSize > 0) {
+      onHit(x - counts[4] - counts[3] - counts[2] / 2, moduleSize);
     }
+
+    // Slide the window on by two runs: the trailing dark run of a rejected
+    // candidate is often the leading dark run of the real one.
+    counts[0] = counts[2];
+    counts[1] = counts[3];
+    counts[2] = counts[4];
+    counts[3] = 1;
+    counts[4] = 0;
+    state = 3;
   }
 
-  return out;
+  if (state === 4) {
+    const moduleSize = matchRatios(counts, ratios);
+    if (moduleSize > 0) {
+      onHit(width - counts[4] - counts[3] - counts[2] / 2, moduleSize);
+    }
+  }
 }
 
 /**
- * Sample with a 3x3 majority vote per module.
+ * Walk a line through a candidate centre and confirm the ratio holds there too.
  *
- * Slower, and worth it when a single-point sample lands on a speck of noise or
- * a JPEG artefact. Readers fall back to this after a clean sample fails to
- * decode, rather than paying for it on every attempt.
+ * @param {import('../core/bit-matrix.js').BitMatrix} image
+ * @param {number} x @param {number} y
+ * @param {number} dx @param {number} dy Unit step defining the line.
+ * @param {number[]} ratios
+ * @param {number} maxRun Guard against running the length of a dark image.
+ * @returns {number} Refined centre offset along the line, or NaN.
+ */
+function crossCheck(image, x, y, dx, dy, ratios, maxRun) {
+  const width = image.width;
+  const height = image.height;
+
+  /** @returns {boolean | null} Null when the sample falls outside the image. */
+  const at = (i) => {
+    const px = x + dx * i;
+    const py = y + dy * i;
+    if (px < 0 || py < 0 || px >= width || py >= height) return null;
+    return image.get(px, py);
+  };
+
+  if (at(0) !== true) return NaN;
+
+  const counts = [0, 0, 0, 0, 0];
+  let i = 0;
+
+  // Forward from the centre: rest of the centre run, then light, then dark.
+  while (at(i) === true && counts[2] < maxRun) { counts[2]++; i++; }
+  if (at(i) === null) return NaN;
+  const centreForward = counts[2];
+
+  while (at(i) === false && counts[3] < maxRun) { counts[3]++; i++; }
+  if (at(i) === null || counts[3] === 0) return NaN;
+
+  while (at(i) === true && counts[4] < maxRun) { counts[4]++; i++; }
+  if (counts[4] === 0) return NaN;
+
+  // Backward from the centre.
+  i = -1;
+  while (at(i) === true && counts[2] < maxRun * 2) { counts[2]++; i--; }
+  if (at(i) === null) return NaN;
+  const centreBackward = counts[2] - centreForward;
+
+  while (at(i) === false && counts[1] < maxRun) { counts[1]++; i--; }
+  if (at(i) === null || counts[1] === 0) return NaN;
+
+  while (at(i) === true && counts[0] < maxRun) { counts[0]++; i--; }
+  if (counts[0] === 0) return NaN;
+
+  if (matchRatios(counts, ratios) === 0) return NaN;
+
+  // The centre run spans offsets [-centreBackward, centreForward - 1].
+  return (centreForward - 1 - centreBackward) / 2;
+}
+
+/**
+ * @typedef {object} Candidate
+ * @property {number} x
+ * @property {number} y
+ * @property {number} moduleSize
+ * @property {number} hits
+ */
+
+/**
+ * Locate pattern centres of a given run ratio.
  *
- * @param {BitMatrix} image
- * @param {number} width
- * @param {number} height
- * @param {PerspectiveTransform} transform
- * @returns {BitMatrix}
+ * @param {import('../core/bit-matrix.js').BitMatrix} image
+ * @param {number[]} ratios
+ * @param {number} unitsWide Modules the pattern spans (7 or 5).
+ * @param {{x0: number, y0: number, x1: number, y1: number}} [region]
+ * @returns {Candidate[]}
  */
-function sampleGridVoting(image, width, height, transform) {
-  const out = new BitMatrix(width, height);
+function findPatterns(image, ratios, unitsWide, region) {
+  /** @type {Candidate[]} */
+  const found = [];
 
-  // Spacing between module centres, measured in image pixels, so the vote
-  // spreads across the module rather than a fixed pixel radius that would be
-  // meaningless at a different scale.
-  const p0 = transform.transformPoint(0.5, 0.5);
-  const p1 = transform.transformPoint(1.5, 0.5);
-  const p2 = transform.transformPoint(0.5, 1.5);
-  const stepX = Math.hypot(p1.x - p0.x, p1.y - p0.y);
-  const stepY = Math.hypot(p2.x - p0.x, p2.y - p0.y);
-  const rx = Math.max(1, Math.round(stepX / 4));
-  const ry = Math.max(1, Math.round(stepY / 4));
+  const y0 = region ? Math.max(0, region.y0) : 0;
+  const y1 = region ? Math.min(image.height, region.y1) : image.height;
 
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const c = transform.transformPoint(x + 0.5, y + 0.5);
-      const cx = c.x | 0;
-      const cy = c.y | 0;
-      if (cx < 0 || cy < 0 || cx >= image.width || cy >= image.height) {
-        throw new NotFoundError(
-          `Sampling grid escapes the image at module (${x}, ${y})`
-        );
-      }
+  for (let y = y0; y < y1; y++) {
+    scanRow(image, y, ratios, (centreX, moduleSize) => {
+      if (region && (centreX < region.x0 || centreX > region.x1)) return;
 
-      let dark = 0;
-      let total = 0;
-      for (let dy = -1; dy <= 1; dy++) {
-        for (let dx = -1; dx <= 1; dx++) {
-          const sx = cx + dx * rx;
-          const sy = cy + dy * ry;
-          if (sx < 0 || sy < 0 || sx >= image.width || sy >= image.height) continue;
-          total++;
-          if (image.get(sx, sy)) dark++;
+      const px = Math.floor(centreX);
+      const maxRun = Math.ceil(moduleSize * unitsWide);
+      const offsetY = crossCheck(image, px, y, 0, 1, ratios, maxRun);
+      if (Number.isNaN(offsetY)) return;
+
+      const cy = y + offsetY;
+      // Re-check horizontally at the refined row, which both confirms the hit
+      // and gives a better x than the original scan line did.
+      const offsetX = crossCheck(image, px, Math.round(cy), 1, 0, ratios, maxRun);
+      if (Number.isNaN(offsetX)) return;
+
+      const cx = px + offsetX;
+
+      // Merge with an existing centre when they describe the same pattern.
+      for (let i = 0; i < found.length; i++) {
+        const c = found[i];
+        if (
+          Math.abs(c.x - cx) <= c.moduleSize &&
+          Math.abs(c.y - cy) <= c.moduleSize &&
+          Math.abs(c.moduleSize - moduleSize) <= Math.max(1, c.moduleSize / 2)
+        ) {
+          const n = c.hits + 1;
+          c.x = (c.x * c.hits + cx) / n;
+          c.y = (c.y * c.hits + cy) / n;
+          c.moduleSize = (c.moduleSize * c.hits + moduleSize) / n;
+          c.hits = n;
+          return;
         }
       }
-      if (total > 0 && dark * 2 > total) out.set(x, y);
-    }
+
+      found.push({ x: cx, y: cy, moduleSize, hits: 1 });
+    });
   }
 
-  return out;
+  return found;
 }
 
 /**
- * Build the transform for a symbol whose four corners are known, and sample it.
+ * @param {{x: number, y: number}} a @param {{x: number, y: number}} b
+ * @returns {number}
+ */
+function distance(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+
+/**
+ * Order three finder centres as top-left, top-right, bottom-left.
  *
- * Corners are in reading order: top-left, top-right, bottom-right, bottom-left.
+ * The corner is the centre opposite the longest side. Which of the remaining
+ * two is "top right" follows from the sign of the cross product: in image
+ * coordinates, with y increasing downward, a symbol the right way round has
+ * (topRight - topLeft) x (bottomLeft - topLeft) positive.
  *
- * @param {BitMatrix} image
- * @param {number} dimension Modules per side.
- * @param {Array<{x: number, y: number}>} corners
- * @param {boolean} [voting]
- * @returns {BitMatrix}
+ * @param {Candidate[]} three
+ * @returns {{tl: Candidate, tr: Candidate, bl: Candidate} | null}
  */
-function sampleQuad(image, dimension, corners, voting = false) {
-  if (corners.length !== 4) throw new NotFoundError('sampleQuad needs exactly 4 corners');
-  const [tl, tr, br, bl] = corners;
-  const d = dimension;
+function orientFinders(three) {
+  const [a, b, c] = three;
+  const ab = distance(a, b);
+  const bc = distance(b, c);
+  const ca = distance(c, a);
 
-  const transform = PerspectiveTransform.quadToQuad(
-    0, 0, d, 0, d, d, 0, d,
-    tl.x, tl.y, tr.x, tr.y, br.x, br.y, bl.x, bl.y
-  );
+  let tl, p, q, hypotenuse, leg1, leg2;
+  if (ab >= bc && ab >= ca) {
+    tl = c; p = a; q = b; hypotenuse = ab; leg1 = ca; leg2 = bc;
+  } else if (bc >= ab && bc >= ca) {
+    tl = a; p = b; q = c; hypotenuse = bc; leg1 = ab; leg2 = ca;
+  } else {
+    tl = b; p = c; q = a; hypotenuse = ca; leg1 = bc; leg2 = ab;
+  }
 
-  return voting
-    ? sampleGridVoting(image, d, d, transform)
-    : sampleGrid(image, d, d, transform);
+  if (leg1 === 0 || leg2 === 0) return null;
+
+  // The two legs must be near enough equal, and Pythagoras must hold: this is
+  // what rejects three unrelated finder-lookalikes that happen to co-occur.
+  const ratio = leg1 / leg2;
+  if (ratio < 0.7 || ratio > 1.4) return null;
+  const expected = Math.hypot(leg1, leg2);
+  if (Math.abs(hypotenuse - expected) > expected * 0.25) return null;
+
+  const cross = (p.x - tl.x) * (q.y - tl.y) - (p.y - tl.y) * (q.x - tl.x);
+  return cross >= 0 ? { tl, tr: p, bl: q } : { tl, tr: q, bl: p };
 }
 
-__exports.sampleGrid = sampleGrid;
-__exports.sampleGridVoting = sampleGridVoting;
-__exports.sampleQuad = sampleQuad;
-};
+/**
+ * Snap a measured dimension to a legal symbol size.
+ *
+ * Every QR dimension is 17 + 4v, so `dimension % 4 === 1`. A measurement one
+ * off is rounding; two off means the module size estimate is wrong and the
+ * candidate is not worth pursuing.
+ *
+ * @param {number} raw
+ * @returns {number} 0 if it cannot be reconciled.
+ */
+function snapDimension(raw) {
+  let d = Math.round(raw);
+  switch (d & 3) {
+    case 0: d--; break;
+    case 2: d++; break;
+    case 3: return 0;
+    default: break;
+  }
+  if (d < MIN_DIMENSION || d > MAX_DIMENSION) return 0;
+  return d;
+}
+
+/** The alignment pattern, as modules. 1 is dark. */
+const ALIGNMENT_MODULES = [
+  [1, 1, 1, 1, 1],
+  [1, 0, 0, 0, 1],
+  [1, 0, 1, 0, 1],
+  [1, 0, 0, 0, 1],
+  [1, 1, 1, 1, 1],
+];
 
-__modules["qr/detector.js"] = function (__require, __exports) {
 /**
- * QR Code detection — finding symbols in a binarized image.
+ * Confirm a candidate by reading the 5x5 module block it claims to be.
  *
- * The whole thing hangs off one property of the finder pattern: along any line
- * through its centre, in any direction, the dark and light runs are in the
- * ratio 1:1:3:1:1. That is true horizontally, vertically and diagonally, it is
- * scale-independent, and no ordinary printed matter reproduces it by accident.
- * So the search is: scan rows for that ratio, confirm each hit by scanning the
- * column through it, cluster what survives, and look for three clusters
- * arranged in a right isoceles triangle.
+ * The run-ratio scan alone is not enough here. A finder pattern's 1:1:3:1:1 is
+ * rare enough to stand on its own, but an alignment pattern's 1:1:1:1:1 occurs
+ * constantly in ordinary data modules, so an unverified match near the expected
+ * position is more likely to be payload than pattern — and a false match drags
+ * the fourth corner off by several modules, which is worse than having no
+ * alignment pattern at all.
  *
- * Three finders give three corners. The fourth is the problem: extrapolating
- * `topRight + bottomLeft - topLeft` assumes the symbol is a parallelogram,
- * which is only true if it was photographed square-on. For version 2 and up the
- * bottom-right alignment pattern pins that corner down properly, which is what
- * makes a tilted symbol readable. When the alignment pattern cannot be found,
- * detection degrades to the parallelogram estimate rather than failing — a
- * slightly wrong corner still decodes on a flat image, and Reed-Solomon absorbs
- * the rest.
+ * @param {import('../core/bit-matrix.js').BitMatrix} image
+ * @param {number} cx @param {number} cy @param {number} moduleSize
+ * @returns {boolean}
+ */
+function verifyAlignment(image, cx, cy, moduleSize) {
+  let good = 0;
+  for (let j = 0; j < 5; j++) {
+    for (let i = 0; i < 5; i++) {
+      const px = Math.round(cx + (i - 2) * moduleSize);
+      const py = Math.round(cy + (j - 2) * moduleSize);
+      if (px < 0 || py < 0 || px >= image.width || py >= image.height) return false;
+      if (image.get(px, py) === (ALIGNMENT_MODULES[j][i] === 1)) good++;
+    }
+  }
+  // Allow two modules of slop for blur and sampling, but no more.
+  return good >= 23;
+}
+
+/**
+ * Look for the bottom-right alignment pattern near where the geometry predicts.
  *
- * @module qr/detector
+ * @param {import('../core/bit-matrix.js').BitMatrix} image
+ * @param {{x: number, y: number}} expected
+ * @param {number} moduleSize
+ * @returns {{x: number, y: number} | null}
  */
-const { NotFoundError } = __require("core/errors.js");
-const { PerspectiveTransform } = __require("image/perspective.js");
-const { sampleQuad } = __require("image/grid-sampler.js");
-const { decodeQR } = __require("qr/decoder.js");
+function findAlignment(image, expected, moduleSize) {
+  // Three modules of slack. The parallelogram estimate is good to well under
+  // that on any symbol flat enough to decode, and a wider net only admits more
+  // data modules as candidates.
+  const radius = Math.max(3, Math.ceil(moduleSize * 3));
+  const region = {
+    x0: expected.x - radius,
+    x1: expected.x + radius,
+    y0: Math.floor(expected.y - radius),
+    y1: Math.ceil(expected.y + radius),
+  };
 
-/** Finder pattern run ratios, centre run first in the array's own order. */
-const FINDER_RATIOS = [1, 1, 3, 1, 1];
+  const found = findPatterns(image, ALIGNMENT_RATIOS, 5, region);
 
-/** Alignment pattern run ratios. */
-const ALIGNMENT_RATIOS = [1, 1, 1, 1, 1];
+  let best = null;
+  let bestDistance = Infinity;
+  for (let i = 0; i < found.length; i++) {
+    // The alignment pattern is 5 modules across, so its implied module size
+    // should agree with the one the finders reported.
+    if (found[i].moduleSize > moduleSize * 1.5 || found[i].moduleSize < moduleSize / 1.5) continue;
+    if (!verifyAlignment(image, found[i].x, found[i].y, moduleSize)) continue;
+    const d = distance(found[i], expected);
+    if (d < bestDistance) {
+      bestDistance = d;
+      best = found[i];
+    }
+  }
 
-/** Smallest and largest legal symbol dimensions, in modules. */
-const MIN_DIMENSION = 21;
-const MAX_DIMENSION = 177;
+  // Last resort: the pattern is exactly where predicted but its runs were
+  // mangled by blur. Reading the modules directly still confirms it.
+  if (!best && verifyAlignment(image, expected.x, expected.y, moduleSize)) {
+    best = { x: expected.x, y: expected.y };
+  }
+
+  return best;
+}
 
 /**
- * Do five alternating runs match the expected ratios?
- *
- * Tolerance is half a module, scaled by the ratio, which is the widest band
- * that still rejects ordinary text and rules while accepting the blur and
- * rounding of a real scan.
+ * @typedef {object} Detection
+ * @property {Array<{x: number, y: number}>} corners Outer corners of the
+ *   symbol, ordered top-left, top-right, bottom-right, bottom-left.
+ * @property {number} dimension Modules per side.
+ * @property {number} version
+ * @property {number} moduleSize Estimated pixels per module.
+ * @property {boolean} alignmentFound
+ */
+
+/**
+ * Find QR Code symbols in a binarized image.
  *
- * @param {number[]} counts Five run lengths, dark first.
- * @param {number[]} ratios
- * @returns {number} The implied module size, or 0 if the ratios do not match.
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage Set bit = dark.
+ * @returns {Detection[]} Possibly empty; ordered by descending module size, so
+ *   the most prominent symbol comes first.
  */
-function matchRatios(counts, ratios) {
-  let total = 0;
-  let units = 0;
-  for (let i = 0; i < 5; i++) {
-    if (counts[i] === 0) return 0;
-    total += counts[i];
-    units += ratios[i];
+function detectQR(binaryImage) {
+  if (!binaryImage || !binaryImage.width) {
+    throw new NotFoundError('detectQR: no image supplied');
   }
-  if (total < units) return 0;
 
-  const moduleSize = total / units;
-  const tolerance = moduleSize / 2;
-  for (let i = 0; i < 5; i++) {
-    if (Math.abs(counts[i] - moduleSize * ratios[i]) > tolerance * ratios[i]) return 0;
-  }
-  return moduleSize;
-}
+  const finders = findPatterns(binaryImage, FINDER_RATIOS, 7);
+  // A single stray row hit is noise; a real finder is crossed many times.
+  const solid = finders.filter((f) => f.hits >= 2);
+  const pool = solid.length >= 3 ? solid : finders;
+  if (pool.length < 3) return [];
+
+  // Prefer the largest patterns, and cap the combinatorics on noisy images.
+  pool.sort((a, b) => b.moduleSize - a.moduleSize || b.hits - a.hits);
+  const limit = Math.min(pool.length, 12);
 
-/**
- * Scan one row for the finder run ratio.
- *
- * @param {import('../core/bit-matrix.js').BitMatrix} image
- * @param {number} y
- * @param {number[]} ratios
- * @param {(centreX: number, moduleSize: number) => void} onHit
- */
-function scanRow(image, y, ratios, onHit) {
-  const width = image.width;
-  const counts = [0, 0, 0, 0, 0];
-  let state = 0;
+  /** @type {Detection[]} */
+  const detections = [];
+  const used = new Set();
 
-  for (let x = 0; x < width; x++) {
-    const dark = image.get(x, y);
+  for (let i = 0; i < limit; i++) {
+    for (let j = i + 1; j < limit; j++) {
+      for (let k = j + 1; k < limit; k++) {
+        const three = [pool[i], pool[j], pool[k]];
 
-    // Even states are dark runs, odd states light.
-    if (dark === ((state & 1) === 0)) {
-      counts[state]++;
-      continue;
-    }
+        // All three finders belong to one symbol, so they share a module size.
+        const sizes = three.map((f) => f.moduleSize);
+        if (Math.max(...sizes) > Math.min(...sizes) * 1.6) continue;
 
-    // A leading light margin is not part of any pattern.
-    if (state === 0 && counts[0] === 0) continue;
+        const oriented = orientFinders(three);
+        if (!oriented) continue;
 
-    if (state < 4) {
-      state++;
-      counts[state] = 1;
-      continue;
-    }
+        const { tl, tr, bl } = oriented;
+        const moduleSize = (tl.moduleSize + tr.moduleSize + bl.moduleSize) / 3;
+        if (moduleSize <= 0) continue;
 
-    // Five runs complete, and the sixth has begun.
-    const moduleSize = matchRatios(counts, ratios);
-    if (moduleSize > 0) {
-      onHit(x - counts[4] - counts[3] - counts[2] / 2, moduleSize);
-    }
+        // Centre-to-centre spans dimension - 7 modules.
+        const across = (distance(tl, tr) + distance(tl, bl)) / 2;
+        const dimension = snapDimension(across / moduleSize + 7);
+        if (dimension === 0) continue;
 
-    // Slide the window on by two runs: the trailing dark run of a rejected
-    // candidate is often the leading dark run of the real one.
-    counts[0] = counts[2];
-    counts[1] = counts[3];
-    counts[2] = counts[4];
-    counts[3] = 1;
-    counts[4] = 0;
-    state = 3;
-  }
+        const version = (dimension - 17) / 4;
+        if (version < 1 || version > 40) continue;
 
-  if (state === 4) {
-    const moduleSize = matchRatios(counts, ratios);
-    if (moduleSize > 0) {
-      onHit(width - counts[4] - counts[3] - counts[2] / 2, moduleSize);
+        const key = `${Math.round(tl.x)},${Math.round(tl.y)},${dimension}`;
+        if (used.has(key)) continue;
+        used.add(key);
+
+        detections.push(
+          buildDetection(binaryImage, tl, tr, bl, dimension, version, moduleSize)
+        );
+      }
     }
   }
+
+  detections.sort((a, b) => b.moduleSize - a.moduleSize);
+  return detections;
 }
 
 /**
- * Walk a line through a candidate centre and confirm the ratio holds there too.
+ * Turn three finder centres into four symbol corners.
  *
  * @param {import('../core/bit-matrix.js').BitMatrix} image
- * @param {number} x @param {number} y
- * @param {number} dx @param {number} dy Unit step defining the line.
- * @param {number[]} ratios
- * @param {number} maxRun Guard against running the length of a dark image.
- * @returns {number} Refined centre offset along the line, or NaN.
+ * @param {Candidate} tl @param {Candidate} tr @param {Candidate} bl
+ * @param {number} dimension @param {number} version @param {number} moduleSize
+ * @returns {Detection}
  */
-function crossCheck(image, x, y, dx, dy, ratios, maxRun) {
-  const width = image.width;
-  const height = image.height;
-
-  /** @returns {boolean | null} Null when the sample falls outside the image. */
-  const at = (i) => {
-    const px = x + dx * i;
-    const py = y + dy * i;
-    if (px < 0 || py < 0 || px >= width || py >= height) return null;
-    return image.get(px, py);
-  };
-
-  if (at(0) !== true) return NaN;
-
-  const counts = [0, 0, 0, 0, 0];
-  let i = 0;
-
-  // Forward from the centre: rest of the centre run, then light, then dark.
-  while (at(i) === true && counts[2] < maxRun) { counts[2]++; i++; }
-  if (at(i) === null) return NaN;
-  const centreForward = counts[2];
+function buildDetection(image, tl, tr, bl, dimension, version, moduleSize) {
+  const d = dimension;
+  // Finder centres sit on module (3, 3) and friends, so at grid coordinate 3.5.
+  const gridTl = [3.5, 3.5];
+  const gridTr = [d - 3.5, 3.5];
+  const gridBl = [3.5, d - 3.5];
 
-  while (at(i) === false && counts[3] < maxRun) { counts[3]++; i++; }
-  if (at(i) === null || counts[3] === 0) return NaN;
+  // Parallelogram estimate of the far corner, used both as the search seed for
+  // the alignment pattern and as the fallback when it is not there.
+  const guess = { x: tr.x + bl.x - tl.x, y: tr.y + bl.y - tl.y };
 
-  while (at(i) === true && counts[4] < maxRun) { counts[4]++; i++; }
-  if (counts[4] === 0) return NaN;
+  /** @type {PerspectiveTransform | null} */
+  let transform = null;
+  let alignmentFound = false;
 
-  // Backward from the centre.
-  i = -1;
-  while (at(i) === true && counts[2] < maxRun * 2) { counts[2]++; i--; }
-  if (at(i) === null) return NaN;
-  const centreBackward = counts[2] - centreForward;
+  if (version >= 2) {
+    // The bottom-right alignment pattern is centred on module (d - 7, d - 7).
+    const gridAlign = [d - 6.5, d - 6.5];
+    // Where that module lands under the parallelogram assumption.
+    const seed = {
+      x: tl.x + ((gridAlign[0] - 3.5) / (d - 7)) * (tr.x - tl.x) +
+        ((gridAlign[1] - 3.5) / (d - 7)) * (bl.x - tl.x),
+      y: tl.y + ((gridAlign[0] - 3.5) / (d - 7)) * (tr.y - tl.y) +
+        ((gridAlign[1] - 3.5) / (d - 7)) * (bl.y - tl.y),
+    };
 
-  while (at(i) === false && counts[1] < maxRun) { counts[1]++; i--; }
-  if (at(i) === null || counts[1] === 0) return NaN;
+    const align = findAlignment(image, seed, moduleSize);
+    if (align) {
+      alignmentFound = true;
+      transform = PerspectiveTransform.quadToQuad(
+        gridTl[0], gridTl[1], gridTr[0], gridTr[1], gridAlign[0], gridAlign[1], gridBl[0], gridBl[1],
+        tl.x, tl.y, tr.x, tr.y, align.x, align.y, bl.x, bl.y
+      );
+    }
+  }
 
-  while (at(i) === true && counts[0] < maxRun) { counts[0]++; i--; }
-  if (counts[0] === 0) return NaN;
+  const plain = PerspectiveTransform.quadToQuad(
+    gridTl[0], gridTl[1], gridTr[0], gridTr[1], d - 3.5, d - 3.5, gridBl[0], gridBl[1],
+    tl.x, tl.y, tr.x, tr.y, guess.x, guess.y, bl.x, bl.y
+  );
 
-  if (matchRatios(counts, ratios) === 0) return NaN;
+  const corners = cornersOf(transform ?? plain, d);
+  // Keep the parallelogram corners as a second opinion whenever an alignment
+  // pattern steered the first set. Verification makes a false match unlikely,
+  // not impossible, and one extra sampling attempt is far cheaper than losing
+  // a symbol to it.
+  const altCorners = transform ? cornersOf(plain, d) : null;
 
-  // The centre run spans offsets [-centreBackward, centreForward - 1].
-  return (centreForward - 1 - centreBackward) / 2;
+  return { corners, altCorners, dimension, version, moduleSize, alignmentFound };
 }
 
 /**
- * @typedef {object} Candidate
- * @property {number} x
- * @property {number} y
- * @property {number} moduleSize
- * @property {number} hits
+ * The four outer corners of the symbol under a grid-to-image transform.
+ *
+ * @param {PerspectiveTransform} transform @param {number} d
+ * @returns {Array<{x: number, y: number}>}
  */
+function cornersOf(transform, d) {
+  return [
+    transform.transformPoint(0, 0),
+    transform.transformPoint(d, 0),
+    transform.transformPoint(d, d),
+    transform.transformPoint(0, d),
+  ];
+}
 
 /**
- * Locate pattern centres of a given run ratio.
+ * Find and decode every QR Code in a binarized image.
  *
- * @param {import('../core/bit-matrix.js').BitMatrix} image
- * @param {number[]} ratios
- * @param {number} unitsWide Modules the pattern spans (7 or 5).
- * @param {{x0: number, y0: number, x1: number, y1: number}} [region]
- * @returns {Candidate[]}
+ * Each candidate gets up to four attempts: a plain centre sample, a 3x3
+ * majority vote for noisy input, and both of those rotated 180 degrees. The
+ * rotation retry matters because three finders in a right isoceles triangle
+ * look identical to the same three rotated half a turn — the orientation is
+ * only settled once the format information reads cleanly, which is to say once
+ * the decode succeeds.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @returns {Array<import('./decoder.js').DecodeResult & {corners: Array<{x: number, y: number}>}>}
+ *   Empty when nothing decodes; never throws for "no symbol here".
  */
-function findPatterns(image, ratios, unitsWide, region) {
-  /** @type {Candidate[]} */
-  const found = [];
-
-  const y0 = region ? Math.max(0, region.y0) : 0;
-  const y1 = region ? Math.min(image.height, region.y1) : image.height;
+function detectAndDecodeQR(binaryImage) {
+  let detections;
+  try {
+    detections = detectQR(binaryImage);
+  } catch (e) {
+    return [];
+  }
 
-  for (let y = y0; y < y1; y++) {
-    scanRow(image, y, ratios, (centreX, moduleSize) => {
-      if (region && (centreX < region.x0 || centreX > region.x1)) return;
+  const results = [];
+  const seen = new Set();
 
-      const px = Math.floor(centreX);
-      const maxRun = Math.ceil(moduleSize * unitsWide);
-      const offsetY = crossCheck(image, px, y, 0, 1, ratios, maxRun);
-      if (Number.isNaN(offsetY)) return;
+  for (let i = 0; i < detections.length; i++) {
+    const det = detections[i];
 
-      const cy = y + offsetY;
-      // Re-check horizontally at the refined row, which both confirms the hit
-      // and gives a better x than the original scan line did.
-      const offsetX = crossCheck(image, px, Math.round(cy), 1, 0, ratios, maxRun);
-      if (Number.isNaN(offsetX)) return;
+    for (let attempt = 0; attempt < 4; attempt++) {
+      const voting = attempt === 1 || attempt === 3;
+      const rotated = attempt >= 2;
 
-      const cx = px + offsetX;
+      let matrix;
+      try {
+        matrix = sampleQuad(binaryImage, det.dimension, det.corners, voting);
+      } catch (e) {
+        continue;
+      }
+      if (rotated) matrix.rotate180();
 
-      // Merge with an existing centre when they describe the same pattern.
-      for (let i = 0; i < found.length; i++) {
-        const c = found[i];
-        if (
-          Math.abs(c.x - cx) <= c.moduleSize &&
-          Math.abs(c.y - cy) <= c.moduleSize &&
-          Math.abs(c.moduleSize - moduleSize) <= Math.max(1, c.moduleSize / 2)
-        ) {
-          const n = c.hits + 1;
-          c.x = (c.x * c.hits + cx) / n;
-          c.y = (c.y * c.hits + cy) / n;
-          c.moduleSize = (c.moduleSize * c.hits + moduleSize) / n;
-          c.hits = n;
-          return;
+      try {
+        const result = decodeQR(matrix);
+        // The same symbol can be detected through more than one finder triple.
+        const key = `${result.version}|${result.text}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          results.push(Object.assign({ corners: det.corners }, result));
         }
+        break;
+      } catch (e) {
+        /* Try the next sampling strategy. */
       }
-
-      found.push({ x: cx, y: cy, moduleSize, hits: 1 });
-    });
+    }
   }
 
-  return found;
+  return results;
 }
 
-/**
- * @param {{x: number, y: number}} a @param {{x: number, y: number}} b
- * @returns {number}
- */
-function distance(a, b) {
-  return Math.hypot(a.x - b.x, a.y - b.y);
-}
+__exports.detectQR = detectQR;
+__exports.detectAndDecodeQR = detectAndDecodeQR;
+};
 
+__modules["qr/index.js"] = function (__require, __exports) {
 /**
- * Order three finder centres as top-left, top-right, bottom-left.
+ * QR Code, re-exported.
  *
- * The corner is the centre opposite the longest side. Which of the remaining
- * two is "top right" follows from the sign of the cross product: in image
- * coordinates, with y increasing downward, a symbol the right way round has
- * (topRight - topLeft) x (bottomLeft - topLeft) positive.
+ * `QR_PLACEHOLDER` is deliberately absent: `src/index.js` probes for it to
+ * decide whether this build can read and write QR, and its absence is what
+ * reports the format as available.
  *
- * @param {Candidate[]} three
- * @returns {{tl: Candidate, tr: Candidate, bl: Candidate} | null}
+ * @module qr
  */
-function orientFinders(three) {
-  const [a, b, c] = three;
-  const ab = distance(a, b);
-  const bc = distance(b, c);
-  const ca = distance(c, a);
+const __reexport0 = __require("qr/encoder.js"); __exports.encodeQR = __reexport0.encodeQR;
+const __reexport1 = __require("qr/decoder.js"); __exports.decodeQR = __reexport1.decodeQR;
+const __reexport2 = __require("qr/detector.js"); __exports.detectQR = __reexport2.detectQR; __exports.detectAndDecodeQR = __reexport2.detectAndDecodeQR;
+const __reexport3 = __require("qr/tables.js"); __exports.validateTables = __reexport3.validateTables;
 
-  let tl, p, q, hypotenuse, leg1, leg2;
-  if (ab >= bc && ab >= ca) {
-    tl = c; p = a; q = b; hypotenuse = ab; leg1 = ca; leg2 = bc;
-  } else if (bc >= ab && bc >= ca) {
-    tl = a; p = b; q = c; hypotenuse = bc; leg1 = ab; leg2 = ca;
-  } else {
-    tl = b; p = c; q = a; hypotenuse = ca; leg1 = bc; leg2 = ab;
-  }
 
-  if (leg1 === 0 || leg2 === 0) return null;
+};
 
-  // The two legs must be near enough equal, and Pythagoras must hold: this is
-  // what rejects three unrelated finder-lookalikes that happen to co-occur.
-  const ratio = leg1 / leg2;
-  if (ratio < 0.7 || ratio > 1.4) return null;
-  const expected = Math.hypot(leg1, leg2);
-  if (Math.abs(hypotenuse - expected) > expected * 0.25) return null;
+__modules["aztec/high-level.js"] = function (__require, __exports) {
+/**
+ * Aztec high-level stream writer.
+ *
+ * The output is deliberately a `BitWriter`, rather than a byte array: Aztec's
+ * text controls and binary-shift lengths are not byte aligned.  This module is
+ * also the boundary where JavaScript strings become UTF-8.  Passing a byte
+ * view bypasses that conversion and preserves every octet unchanged.
+ *
+ * The initial state mandated by the symbology is UPPER.  The greedy text pass
+ * uses UPPER, LOWER, DIGIT and PUNCT tables, selecting the shortest available
+ * latch at each byte.  Bytes without a text-table representation are emitted
+ * through the standard B/S (binary shift) escape.  B/S is available from
+ * UPPER and makes this a complete, lossless representation of UTF-8 payloads.
+ *
+ * @module aztec/high-level
+ */
+const { BitWriter } = __require("core/bit-buffer.js");
+const { EncodeError } = __require("core/errors.js");
 
-  const cross = (p.x - tl.x) * (q.y - tl.y) - (p.y - tl.y) * (q.x - tl.x);
-  return cross >= 0 ? { tl, tr: p, bl: q } : { tl, tr: q, bl: p };
-}
+/** Aztec high-level table identifiers, exposed for decoder/API symmetry. */
+const HIGH_LEVEL_MODE = Object.freeze({
+  UPPER: 0,
+  LOWER: 1,
+  DIGIT: 2,
+  MIXED: 3,
+  PUNCT: 4,
+});
+
+/** Maximum number of bytes represented by one B/S escape. */
+const MAX_BINARY_SHIFT = 2078;
 
 /**
- * Snap a measured dimension to a legal symbol size.
- *
- * Every QR dimension is 17 + 4v, so `dimension % 4 === 1`. A measurement one
- * off is rounding; two off means the module size estimate is wrong and the
- * candidate is not worth pursuing.
+ * Convert accepted public input to its encoded octets.
  *
- * @param {number} raw
- * @returns {number} 0 if it cannot be reconciled.
+ * @param {string|ArrayBuffer|ArrayBufferView} value
+ * @param {'utf-8'} [charset]
+ * @returns {Uint8Array}
  */
-function snapDimension(raw) {
-  let d = Math.round(raw);
-  switch (d & 3) {
-    case 0: d--; break;
-    case 2: d++; break;
-    case 3: return 0;
-    default: break;
+function aztecBytes(value, charset = 'utf-8') {
+  if (charset !== 'utf-8') throw new EncodeError(`Aztec: unsupported charset "${charset}"`);
+  if (typeof value === 'string') return new TextEncoder().encode(value);
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new EncodeError('Aztec: value must be a string, ArrayBuffer, or byte view');
+}
+
+/** @param {number} byte @returns {number} UPPER-table value, or -1. */
+function upperValue(byte) {
+  if (byte === 0x20) return 1;
+  if (byte >= 0x41 && byte <= 0x5a) return byte - 0x41 + 2;
+  return -1;
+}
+
+/** Aztec's latch table, packed as `(bitCount << 16) | bits`. */
+const LATCH = Object.freeze([
+  [0, 327708, 327710, 327709, 656318],
+  [590318, 0, 327710, 327709, 656318],
+  [262158, 590300, 0, 590301, 932798],
+  [327709, 327708, 656322, 0, 327710],
+  [327711, 656380, 656382, 656381, 0],
+]);
+
+/** @param {number} byte @returns {number} */
+function lowerValue(byte) {
+  if (byte === 0x20) return 1;
+  if (byte >= 0x61 && byte <= 0x7a) return byte - 0x61 + 2;
+  return -1;
+}
+
+/** @param {number} byte @returns {number} */
+function digitValue(byte) {
+  if (byte === 0x20) return 1;
+  if (byte >= 0x30 && byte <= 0x39) return byte - 0x30 + 2;
+  if (byte === 0x2c) return 12;
+  if (byte === 0x2e) return 13;
+  return -1;
+}
+
+const PUNCT = new Map([
+  [0x0d, 1], [0x21, 6], [0x22, 7], [0x23, 8], [0x24, 9], [0x25, 10],
+  [0x26, 11], [0x27, 12], [0x28, 13], [0x29, 14], [0x2a, 15], [0x2b, 16],
+  [0x2c, 17], [0x2d, 18], [0x2e, 19], [0x2f, 20], [0x3a, 21], [0x3b, 22],
+  [0x3c, 23], [0x3d, 24], [0x3e, 25], [0x3f, 26], [0x5b, 27], [0x5d, 28],
+  [0x7b, 29], [0x7d, 30],
+]);
+
+/** @param {number} byte @param {number} mode @returns {number} */
+function textValue(byte, mode) {
+  switch (mode) {
+    case HIGH_LEVEL_MODE.UPPER: return upperValue(byte);
+    case HIGH_LEVEL_MODE.LOWER: return lowerValue(byte);
+    case HIGH_LEVEL_MODE.DIGIT: return digitValue(byte);
+    case HIGH_LEVEL_MODE.PUNCT: return PUNCT.get(byte) ?? -1;
+    default: return -1;
   }
-  if (d < MIN_DIMENSION || d > MAX_DIMENSION) return 0;
-  return d;
 }
 
-/** The alignment pattern, as modules. 1 is dark. */
-const ALIGNMENT_MODULES = [
-  [1, 1, 1, 1, 1],
-  [1, 0, 0, 0, 1],
-  [1, 0, 1, 0, 1],
-  [1, 0, 0, 0, 1],
-  [1, 1, 1, 1, 1],
-];
+/** @param {BitWriter} writer @param {number} from @param {number} to */
+function latch(writer, from, to) {
+  if (from === to) return;
+  const packed = LATCH[from][to];
+  writer.put(packed & 0xffff, packed >>> 16);
+}
+
+/** @param {number} mode @returns {number} */
+function characterWidth(mode) {
+  return mode === HIGH_LEVEL_MODE.DIGIT ? 4 : 5;
+}
 
 /**
- * Confirm a candidate by reading the 5x5 module block it claims to be.
+ * Write an Aztec binary-shift segment while in UPPER mode.
  *
- * The run-ratio scan alone is not enough here. A finder pattern's 1:1:3:1:1 is
- * rare enough to stand on its own, but an alignment pattern's 1:1:1:1:1 occurs
- * constantly in ordinary data modules, so an unverified match near the expected
- * position is more likely to be payload than pattern — and a false match drags
- * the fourth corner off by several modules, which is worse than having no
- * alignment pattern at all.
+ * B/S is `11111`; its five-bit length directly covers 1..31 bytes.  A zero
+ * length selects the extended eleven-bit form, whose stored value is n - 31.
+ * Splitting at 2078 keeps each control representable and makes arbitrarily
+ * long byte input well-defined.
  *
- * @param {import('../core/bit-matrix.js').BitMatrix} image
- * @param {number} cx @param {number} cy @param {number} moduleSize
- * @returns {boolean}
+ * @param {BitWriter} writer
+ * @param {Uint8Array} bytes
+ * @param {number} start
+ * @param {number} length
  */
-function verifyAlignment(image, cx, cy, moduleSize) {
-  let good = 0;
-  for (let j = 0; j < 5; j++) {
-    for (let i = 0; i < 5; i++) {
-      const px = Math.round(cx + (i - 2) * moduleSize);
-      const py = Math.round(cy + (j - 2) * moduleSize);
-      if (px < 0 || py < 0 || px >= image.width || py >= image.height) return false;
-      if (image.get(px, py) === (ALIGNMENT_MODULES[j][i] === 1)) good++;
+function writeBinaryShift(writer, bytes, start, length) {
+  let at = start;
+  let left = length;
+  while (left > 0) {
+    const count = Math.min(left, MAX_BINARY_SHIFT);
+    writer.put(31, 5); // UPPER B/S
+    if (count <= 31) writer.put(count, 5);
+    else {
+      writer.put(0, 5);
+      writer.put(count - 31, 11);
     }
+    for (let i = 0; i < count; i++) writer.put(bytes[at + i], 8);
+    at += count;
+    left -= count;
   }
-  // Allow two modules of slop for blur and sampling, but no more.
-  return good >= 23;
 }
 
 /**
- * Look for the bottom-right alignment pattern near where the geometry predicts.
+ * Build a valid Aztec high-level bitstream.
  *
- * @param {import('../core/bit-matrix.js').BitMatrix} image
- * @param {{x: number, y: number}} expected
- * @param {number} moduleSize
- * @returns {{x: number, y: number} | null}
+ * @param {string|ArrayBuffer|ArrayBufferView} value
+ * @param {{charset?: 'utf-8'}} [options]
+ * @returns {BitWriter}
  */
-function findAlignment(image, expected, moduleSize) {
-  // Three modules of slack. The parallelogram estimate is good to well under
-  // that on any symbol flat enough to decode, and a wider net only admits more
-  // data modules as candidates.
-  const radius = Math.max(3, Math.ceil(moduleSize * 3));
-  const region = {
-    x0: expected.x - radius,
-    x1: expected.x + radius,
-    y0: Math.floor(expected.y - radius),
-    y1: Math.ceil(expected.y + radius),
-  };
-
-  const found = findPatterns(image, ALIGNMENT_RATIOS, 5, region);
-
-  let best = null;
-  let bestDistance = Infinity;
-  for (let i = 0; i < found.length; i++) {
-    // The alignment pattern is 5 modules across, so its implied module size
-    // should agree with the one the finders reported.
-    if (found[i].moduleSize > moduleSize * 1.5 || found[i].moduleSize < moduleSize / 1.5) continue;
-    if (!verifyAlignment(image, found[i].x, found[i].y, moduleSize)) continue;
-    const d = distance(found[i], expected);
-    if (d < bestDistance) {
-      bestDistance = d;
-      best = found[i];
+function encodeHighLevel(value, options = {}) {
+  const bytes = aztecBytes(value, options.charset ?? 'utf-8');
+  const writer = new BitWriter();
+  let mode = HIGH_LEVEL_MODE.UPPER;
+
+  for (let at = 0; at < bytes.length;) {
+    let bestMode = -1;
+    let bestValue = -1;
+    let bestCost = Number.POSITIVE_INFINITY;
+    for (const candidate of [HIGH_LEVEL_MODE.UPPER, HIGH_LEVEL_MODE.LOWER, HIGH_LEVEL_MODE.DIGIT, HIGH_LEVEL_MODE.PUNCT]) {
+      const value = textValue(bytes[at], candidate);
+      if (value < 0) continue;
+      const latchCost = candidate === mode ? 0 : LATCH[mode][candidate] >>> 16;
+      const cost = latchCost + characterWidth(candidate);
+      if (cost < bestCost) { bestCost = cost; bestMode = candidate; bestValue = value; }
+    }
+    if (bestMode >= 0) {
+      latch(writer, mode, bestMode);
+      writer.put(bestValue, characterWidth(bestMode));
+      mode = bestMode;
+      at++;
+    } else {
+      // B/S is defined from UPPER; the latch is retained after the shift.
+      latch(writer, mode, HIGH_LEVEL_MODE.UPPER);
+      mode = HIGH_LEVEL_MODE.UPPER;
+      const start = at;
+      while (at < bytes.length && ![HIGH_LEVEL_MODE.UPPER, HIGH_LEVEL_MODE.LOWER, HIGH_LEVEL_MODE.DIGIT, HIGH_LEVEL_MODE.PUNCT].some((m) => textValue(bytes[at], m) >= 0)) at++;
+      writeBinaryShift(writer, bytes, start, at - start);
     }
   }
+  return writer;
+}
 
-  // Last resort: the pattern is exactly where predicted but its runs were
-  // mangled by blur. Reading the modules directly still confirms it.
-  if (!best && verifyAlignment(image, expected.x, expected.y, moduleSize)) {
-    best = { x: expected.x, y: expected.y };
-  }
+__exports.HIGH_LEVEL_MODE = HIGH_LEVEL_MODE;
+__exports.MAX_BINARY_SHIFT = MAX_BINARY_SHIFT;
+__exports.aztecBytes = aztecBytes;
+__exports.writeBinaryShift = writeBinaryShift;
+__exports.encodeHighLevel = encodeHighLevel;
+};
 
-  return best;
+__modules["aztec/tables.js"] = function (__require, __exports) {
+/**
+ * Aztec Code layer geometry and Reed-Solomon parameters.
+ *
+ * `totalBits` counts the payload ring before its leading pad bits are added;
+ * consequently only `usableBits` can be partitioned into codewords. Compact
+ * symbols have no reference grid. Full symbols insert alternating reference
+ * rows and columns every 16 modules around the centre.
+ *
+ * The five data fields use generator base 1. GF(256)/DataMatrix is also the
+ * Aztec 8-bit field: both use primitive polynomial 0x12d.
+ *
+ * @module aztec/tables
+ */
+const { GF16, GF64, GF256_AZTEC, GF1024, GF4096 } = __require("core/galois-field.js");
+
+/** Reed-Solomon generator base defined for Aztec parameter and data fields. */
+const AZTEC_RS_GENERATOR_BASE = 1;
+
+/** Minimum recommended error correction: 23 percent plus three codewords. */
+const AZTEC_DEFAULT_ECC_PERCENT = 23;
+const AZTEC_MIN_ECC_WORDS = 3;
+
+/** Word size selected solely by the number of layers. */
+function wordSizeForLayers(layers) {
+  if (!Number.isInteger(layers) || layers < 1 || layers > 32) {
+    throw new RangeError(`Aztec: layers must be an integer from 1 to 32 (got ${layers})`);
+  }
+  if (layers <= 2) return 6;
+  if (layers <= 8) return 8;
+  if (layers <= 22) return 10;
+  return 12;
+}
+
+/** Return the field used by Aztec codewords of `wordSize` bits. */
+function fieldForWordSize(wordSize) {
+  switch (wordSize) {
+    case 4: return GF16; // Mode message only.
+    case 6: return GF64;
+    case 8: return GF256_AZTEC;
+    case 10: return GF1024;
+    case 12: return GF4096;
+    default: throw new RangeError(`Aztec: unsupported codeword size ${wordSize}`);
+  }
+}
+
+/** Return the data field selected for a symbol with `layers` layers. */
+function fieldForLayers(layers) {
+  return fieldForWordSize(wordSizeForLayers(layers));
+}
+
+/** Matrix side length, including Full-mode reference grid lines. */
+function aztecSymbolSize(layers, compact = false) {
+  if (!Number.isInteger(layers) || layers < 1 || layers > (compact ? 4 : 32)) {
+    throw new RangeError(`Aztec: ${compact ? 'Compact' : 'Full'} layers out of range: ${layers}`);
+  }
+  if (compact) return 11 + 4 * layers;
+  const baseMatrixSize = 14 + 4 * layers;
+  return baseMatrixSize + 1 + 2 * Math.floor((baseMatrixSize / 2 - 1) / 15);
+}
+
+function layer(layers, compact) {
+  const wordSize = wordSizeForLayers(layers);
+  const totalBits = ((compact ? 88 : 112) + 16 * layers) * layers;
+  const usableBits = totalBits - totalBits % wordSize;
+  const totalCodewords = usableBits / wordSize;
+  const baseMatrixSize = (compact ? 11 : 14) + 4 * layers;
+  return Object.freeze({
+    compact,
+    layers,
+    wordSize,
+    totalBits,
+    usableBits,
+    totalCodewords,
+    // Compact mode encodes the count in six bits and can therefore hold no
+    // more than 64 data codewords even where the ring itself is larger.
+    maxDataCodewords: compact ? Math.min(totalCodewords, 64) : totalCodewords,
+    baseMatrixSize,
+    symbolSize: aztecSymbolSize(layers, compact),
+    modeMessageDataWords: compact ? 2 : 4,
+    modeMessageWords: compact ? 7 : 10,
+    modeMessageBits: compact ? 28 : 40,
+    rsGeneratorBase: AZTEC_RS_GENERATOR_BASE,
+  });
+}
+
+/** Compact Aztec layers 1 through 4, in encoding preference order. */
+const AZTEC_COMPACT_LAYERS = Object.freeze(
+  Array.from({ length: 4 }, (_, i) => layer(i + 1, true)),
+);
+
+/** Full Aztec layers 1 through 32, in ascending layer order. */
+const AZTEC_FULL_LAYERS = Object.freeze(
+  Array.from({ length: 32 }, (_, i) => layer(i + 1, false)),
+);
+
+/** All allowed symbols. Compact entries precede Full entries for automatic selection. */
+const AZTEC_LAYERS = Object.freeze([
+  ...AZTEC_COMPACT_LAYERS,
+  ...AZTEC_FULL_LAYERS,
+]);
+
+/** Return one immutable layer record. */
+function aztecLayer(layers, compact = false) {
+  if (!Number.isInteger(layers) || layers < 1 || layers > (compact ? 4 : 32)) {
+    throw new RangeError(`Aztec: ${compact ? 'Compact' : 'Full'} layers out of range: ${layers}`);
+  }
+  return (compact ? AZTEC_COMPACT_LAYERS : AZTEC_FULL_LAYERS)[layers - 1];
 }
 
 /**
- * @typedef {object} Detection
- * @property {Array<{x: number, y: number}>} corners Outer corners of the
- *   symbol, ordered top-left, top-right, bottom-right, bottom-left.
- * @property {number} dimension Modules per side.
- * @property {number} version
- * @property {number} moduleSize Estimated pixels per module.
- * @property {boolean} alignmentFound
+ * Calculate the minimum parity count for a data word count.
+ *
+ * The percentage is rounded up because a fractional codeword cannot be
+ * emitted. The mandatory three words protect short payloads, where a bare
+ * percentage would otherwise round to zero.
  */
+function eccCodewordsFor(dataCodewords, eccPercent = AZTEC_DEFAULT_ECC_PERCENT) {
+  if (!Number.isInteger(dataCodewords) || dataCodewords < 0) {
+    throw new RangeError(`Aztec: data codewords must be a non-negative integer (got ${dataCodewords})`);
+  }
+  if (!Number.isFinite(eccPercent) || eccPercent < 0 || eccPercent > 100) {
+    throw new RangeError(`Aztec: ECC percent must be between 0 and 100 (got ${eccPercent})`);
+  }
+  return Math.ceil(dataCodewords * eccPercent / 100) + AZTEC_MIN_ECC_WORDS;
+}
 
 /**
- * Find QR Code symbols in a binarized image.
+ * Choose the first symbol which holds an already stuffed payload.
  *
- * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage Set bit = dark.
- * @returns {Detection[]} Possibly empty; ordered by descending module size, so
- *   the most prominent symbol comes first.
+ * `dataBits` must be a multiple of the candidate word size; callers which
+ * start from high-level bits must stuff separately per candidate word size.
  */
-function detectQR(binaryImage) {
-  if (!binaryImage || !binaryImage.width) {
-    throw new NotFoundError('detectQR: no image supplied');
+function selectAztecLayer(dataBits, {
+  eccPercent = AZTEC_DEFAULT_ECC_PERCENT,
+  layers = null,
+  compact = null,
+} = {}) {
+  if (!Number.isInteger(dataBits) || dataBits < 0) {
+    throw new RangeError(`Aztec: data bits must be a non-negative integer (got ${dataBits})`);
+  }
+  if (compact !== null && typeof compact !== 'boolean') {
+    throw new TypeError('Aztec: compact must be true, false or null');
   }
 
-  const finders = findPatterns(binaryImage, FINDER_RATIOS, 7);
-  // A single stray row hit is noise; a real finder is crossed many times.
-  const solid = finders.filter((f) => f.hits >= 2);
-  const pool = solid.length >= 3 ? solid : finders;
-  if (pool.length < 3) return [];
+  let candidates;
+  if (layers !== null) {
+    if (compact === null) throw new TypeError('Aztec: compact must be specified when layers is specified');
+    candidates = [aztecLayer(layers, compact)];
+  } else if (compact === null) {
+    candidates = AZTEC_LAYERS;
+  } else {
+    candidates = compact ? AZTEC_COMPACT_LAYERS : AZTEC_FULL_LAYERS;
+  }
 
-  // Prefer the largest patterns, and cap the combinatorics on noisy images.
-  pool.sort((a, b) => b.moduleSize - a.moduleSize || b.hits - a.hits);
-  const limit = Math.min(pool.length, 12);
+  for (const candidate of candidates) {
+    if (dataBits % candidate.wordSize !== 0) continue;
+    const dataCodewords = dataBits / candidate.wordSize;
+    const eccCodewords = eccCodewordsFor(dataCodewords, eccPercent);
+    if (dataCodewords <= candidate.maxDataCodewords &&
+        dataCodewords + eccCodewords <= candidate.totalCodewords) {
+      return Object.freeze({ ...candidate, dataCodewords, eccCodewords });
+    }
+  }
 
-  /** @type {Detection[]} */
-  const detections = [];
-  const used = new Set();
+  throw new RangeError('Aztec: payload and requested error correction do not fit an available symbol');
+}
 
-  for (let i = 0; i < limit; i++) {
-    for (let j = i + 1; j < limit; j++) {
-      for (let k = j + 1; k < limit; k++) {
-        const three = [pool[i], pool[j], pool[k]];
+/** Check static identities so table corruption fails explicitly in tests. */
+function validateAztecTables() {
+  const issues = [];
+  for (const entry of AZTEC_LAYERS) {
+    if (entry.usableBits % entry.wordSize !== 0) issues.push(`${entry.compact ? 'C' : 'F'}${entry.layers}: unaligned usable bits`);
+    if (entry.totalCodewords !== entry.usableBits / entry.wordSize) issues.push(`${entry.compact ? 'C' : 'F'}${entry.layers}: codeword mismatch`);
+    if (entry.symbolSize !== aztecSymbolSize(entry.layers, entry.compact)) issues.push(`${entry.compact ? 'C' : 'F'}${entry.layers}: matrix size mismatch`);
+    if (entry.rsGeneratorBase !== AZTEC_RS_GENERATOR_BASE) issues.push(`${entry.compact ? 'C' : 'F'}${entry.layers}: generator base mismatch`);
+    if (entry.compact && entry.maxDataCodewords > 64) issues.push(`C${entry.layers}: Compact data-word limit exceeded`);
+  }
+  return issues;
+}
 
-        // All three finders belong to one symbol, so they share a module size.
-        const sizes = three.map((f) => f.moduleSize);
-        if (Math.max(...sizes) > Math.min(...sizes) * 1.6) continue;
+__exports.AZTEC_RS_GENERATOR_BASE = AZTEC_RS_GENERATOR_BASE;
+__exports.AZTEC_DEFAULT_ECC_PERCENT = AZTEC_DEFAULT_ECC_PERCENT;
+__exports.AZTEC_MIN_ECC_WORDS = AZTEC_MIN_ECC_WORDS;
+__exports.wordSizeForLayers = wordSizeForLayers;
+__exports.fieldForWordSize = fieldForWordSize;
+__exports.fieldForLayers = fieldForLayers;
+__exports.aztecSymbolSize = aztecSymbolSize;
+__exports.AZTEC_COMPACT_LAYERS = AZTEC_COMPACT_LAYERS;
+__exports.AZTEC_FULL_LAYERS = AZTEC_FULL_LAYERS;
+__exports.AZTEC_LAYERS = AZTEC_LAYERS;
+__exports.aztecLayer = aztecLayer;
+__exports.eccCodewordsFor = eccCodewordsFor;
+__exports.selectAztecLayer = selectAztecLayer;
+__exports.validateAztecTables = validateAztecTables;
+};
 
-        const oriented = orientFinders(three);
-        if (!oriented) continue;
+__modules["aztec/encoder.js"] = function (__require, __exports) {
+/**
+ * Aztec encoder: high-level bits, bit stuffing, Reed-Solomon and matrix layout.
+ *
+ * `tables.js` is intentionally the source of geometry and field selection.
+ * Its `aztecLayer(layers, compact)` entries must expose `totalBits`,
+ * `totalCodewords`, `baseMatrixSize` and `symbolSize`; `fieldForLayers()` must
+ * return the matching binary field.  All Aztec Reed-Solomon generators start
+ * at alpha^1, hence the explicit base `1` in both data and mode messages.
+ *
+ * @module aztec/encoder
+ */
+const { BitWriter } = __require("core/bit-buffer.js");
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { EncodeError } = __require("core/errors.js");
+const { rsEncode } = __require("core/reed-solomon.js");
+const { encodeHighLevel } = __require("aztec/high-level.js");
+const { AZTEC_COMPACT_LAYERS, AZTEC_FULL_LAYERS, aztecLayer, eccCodewordsFor, fieldForLayers, fieldForWordSize, wordSizeForLayers } = __require("aztec/tables.js");
 
-        const { tl, tr, bl } = oriented;
-        const moduleSize = (tl.moduleSize + tr.moduleSize + bl.moduleSize) / 3;
-        if (moduleSize <= 0) continue;
+/** @param {BitWriter} bits @param {number} at @returns {boolean} */
+function bitAt(bits, at) {
+  return at >= 0 && at < bits.length && ((bits.bytes[at >>> 3] >>> (7 - (at & 7))) & 1) !== 0;
+}
 
-        // Centre-to-centre spans dimension - 7 modules.
-        const across = (distance(tl, tr) + distance(tl, bl)) / 2;
-        const dimension = snapDimension(across / moduleSize + 7);
-        if (dimension === 0) continue;
+/** @param {BitWriter} bits @param {number} from @param {number} count @returns {number} */
+function readBits(bits, from, count) {
+  let value = 0;
+  for (let i = 0; i < count; i++) value = (value << 1) | (bitAt(bits, from + i) ? 1 : 0);
+  return value;
+}
+
+/**
+ * Prevent all-zero and all-one codewords except their final bit.  The final
+ * bit is intentionally re-consumed after a stuffed word; it is the mechanism
+ * that makes the transform injective and reversible.
+ *
+ * @param {BitWriter} bits @param {number} wordSize @returns {BitWriter}
+ */
+function stuffBits(bits, wordSize) {
+  const out = new BitWriter();
+  const reserved = (1 << wordSize) - 2;
+  for (let at = 0; at < bits.length; at += wordSize) {
+    const word = readBits(bits, at, wordSize);
+    if ((word & reserved) === reserved) {
+      out.put(word & reserved, wordSize);
+      at--;
+    } else if ((word & reserved) === 0) {
+      out.put(word | 1, wordSize);
+      at--;
+    } else {
+      out.put(word, wordSize);
+    }
+  }
+  return out;
+}
+
+/**
+ * Add systematic Aztec Reed-Solomon parity and the leading alignment bits.
+ * @param {BitWriter} data @param {number} totalBits @param {number} wordSize
+ * @param {import('../core/galois-field.js').GaloisField} field
+ * @returns {{bits: BitWriter, dataWords: number, eccWords: number}}
+ */
+function addCheckWords(data, totalBits, wordSize, field) {
+  const totalWords = Math.floor(totalBits / wordSize);
+  const dataWords = Math.ceil(data.length / wordSize);
+  if (dataWords > totalWords) throw new EncodeError('Aztec: data codewords exceed layer capacity');
+  const eccWords = totalWords - dataWords;
+  const words = new Array(dataWords);
+  for (let i = 0; i < dataWords; i++) words[i] = readBits(data, i * wordSize, wordSize);
+  const ecc = rsEncode(words, eccWords, field, 1);
+  const out = new BitWriter();
+  out.put(0, totalBits % wordSize);
+  for (const word of words) out.put(word, wordSize);
+  for (const word of ecc) out.put(word, wordSize);
+  return { bits: out, dataWords, eccWords };
+}
+
+/** @param {number} layers @param {number} dataWords @param {boolean} compact @returns {BitWriter} */
+function modeMessage(layers, dataWords, compact) {
+  const raw = new BitWriter();
+  if (compact) {
+    raw.put(layers - 1, 2);
+    raw.put(dataWords - 1, 6);
+    return addCheckWords(raw, 28, 4, fieldForWordSize(4)).bits;
+  }
+  raw.put(layers - 1, 5);
+  raw.put(dataWords - 1, 11);
+  return addCheckWords(raw, 40, 4, fieldForWordSize(4)).bits;
+}
+
+/** @param {BitMatrix} matrix @param {number} center @param {number} size */
+function drawBullsEye(matrix, center, size) {
+  for (let ring = 0; ring < size; ring += 2) {
+    for (let p = center - ring; p <= center + ring; p++) {
+      matrix.set(p, center - ring); matrix.set(p, center + ring);
+      matrix.set(center - ring, p); matrix.set(center + ring, p);
+    }
+  }
+  matrix.set(center - size, center - size);
+  matrix.set(center - size + 1, center - size);
+  matrix.set(center - size, center - size + 1);
+  matrix.set(center + size, center - size);
+  matrix.set(center + size, center - size + 1);
+  matrix.set(center + size, center + size - 1);
+}
+
+/** @param {BitMatrix} matrix @param {BitWriter} message @param {boolean} compact @param {number} center */
+function drawModeMessage(matrix, message, compact, center) {
+  if (compact) {
+    for (let i = 0; i < 7; i++) {
+      const offset = center - 3 + i;
+      if (bitAt(message, i)) matrix.set(offset, center - 5);
+      if (bitAt(message, i + 7)) matrix.set(center + 5, offset);
+      if (bitAt(message, 20 - i)) matrix.set(offset, center + 5);
+      if (bitAt(message, 27 - i)) matrix.set(center - 5, offset);
+    }
+  } else {
+    for (let i = 0; i < 10; i++) {
+      const offset = center - 5 + i + Math.floor(i / 5);
+      if (bitAt(message, i)) matrix.set(offset, center - 7);
+      if (bitAt(message, i + 10)) matrix.set(center + 7, offset);
+      if (bitAt(message, 29 - i)) matrix.set(offset, center + 7);
+      if (bitAt(message, 39 - i)) matrix.set(center - 7, offset);
+    }
+  }
+}
 
-        const version = (dimension - 17) / 4;
-        if (version < 1 || version > 40) continue;
+/**
+ * Lay low-level bits in the four-sided, inward Aztec spiral.
+ * @param {BitWriter} bits @param {{layers:number,compact:boolean,baseMatrixSize:number,symbolSize:number}} symbol
+ * @returns {BitMatrix}
+ */
+function buildAztecMatrix(bits, symbol) {
+  const { layers, compact, baseMatrixSize, symbolSize } = symbol;
+  const matrix = new BitMatrix(symbolSize);
+  const alignment = new Int32Array(baseMatrixSize);
+  const center = Math.floor(symbolSize / 2);
 
-        const key = `${Math.round(tl.x)},${Math.round(tl.y)},${dimension}`;
-        if (used.has(key)) continue;
-        used.add(key);
+  if (compact) {
+    for (let i = 0; i < baseMatrixSize; i++) alignment[i] = i;
+  } else {
+    const originalCenter = Math.floor(baseMatrixSize / 2);
+    for (let i = 0; i < originalCenter; i++) {
+      const offset = i + Math.floor(i / 15);
+      alignment[originalCenter - i - 1] = center - offset - 1;
+      alignment[originalCenter + i] = center + offset + 1;
+    }
+  }
+
+  let bit = 0;
+  for (let layer = 0; layer < layers; layer++) {
+    const rowSize = (layers - layer) * 4 + (compact ? 9 : 12);
+    const low = layer * 2;
+    const high = baseMatrixSize - 1 - low;
+    for (let j = 0; j < rowSize; j++) {
+      const offset = j * 2;
+      for (let k = 0; k < 2; k++) {
+        if (bitAt(bits, bit + offset + k)) matrix.set(alignment[low + k], alignment[low + j]);
+        if (bitAt(bits, bit + rowSize * 2 + offset + k)) matrix.set(alignment[low + j], alignment[high - k]);
+        if (bitAt(bits, bit + rowSize * 4 + offset + k)) matrix.set(alignment[high - k], alignment[high - j]);
+        if (bitAt(bits, bit + rowSize * 6 + offset + k)) matrix.set(alignment[high - j], alignment[low + k]);
+      }
+    }
+    bit += rowSize * 8;
+  }
+  if (bit !== bits.length) throw new EncodeError(`Aztec: layout consumed ${bit} of ${bits.length} bits`);
 
-        detections.push(
-          buildDetection(binaryImage, tl, tr, bl, dimension, version, moduleSize)
-        );
+  const mode = modeMessage(layers, symbol.dataWords, compact);
+  drawModeMessage(matrix, mode, compact, center);
+  drawBullsEye(matrix, center, compact ? 5 : 7);
+
+  if (!compact) {
+    for (let i = 0, offset = 0; i < Math.floor(baseMatrixSize / 2) - 1; i += 15, offset += 16) {
+      for (let p = center & 1; p < symbolSize; p += 2) {
+        matrix.set(center - offset, p); matrix.set(center + offset, p);
+        matrix.set(p, center - offset); matrix.set(p, center + offset);
       }
     }
   }
+  return matrix;
+}
 
-  detections.sort((a, b) => b.moduleSize - a.moduleSize);
-  return detections;
+/** @param {number | undefined} layers @param {boolean | undefined} compact */
+function candidates(layers, compact) {
+  if (layers !== undefined) {
+    if (!Number.isInteger(layers) || layers < 1 || layers > 32) throw new EncodeError('Aztec: layers must be an integer 1..32');
+    if (compact === true && layers > 4) throw new EncodeError('Aztec: compact symbols support layers 1..4');
+    return [aztecLayer(layers, compact === true)];
+  }
+  if (compact === true) return AZTEC_COMPACT_LAYERS;
+  if (compact === false) return AZTEC_FULL_LAYERS;
+  return [...AZTEC_COMPACT_LAYERS, ...AZTEC_FULL_LAYERS];
 }
 
 /**
- * Turn three finder centres into four symbol corners.
+ * Encode a UTF-8 string or bytes into an Aztec Code matrix.
  *
- * @param {import('../core/bit-matrix.js').BitMatrix} image
- * @param {Candidate} tl @param {Candidate} tr @param {Candidate} bl
- * @param {number} dimension @param {number} version @param {number} moduleSize
- * @returns {Detection}
+ * @param {string|ArrayBuffer|ArrayBufferView} value
+ * @param {{layers?:number,compact?:boolean,eccPercent?:number,charset?:'utf-8'}} [options]
+ * @returns {BitMatrix & {format?:string,layers?:number,compact?:boolean,eccPercent?:number,dataCodewords?:number}}
  */
-function buildDetection(image, tl, tr, bl, dimension, version, moduleSize) {
-  const d = dimension;
-  // Finder centres sit on module (3, 3) and friends, so at grid coordinate 3.5.
-  const gridTl = [3.5, 3.5];
-  const gridTr = [d - 3.5, 3.5];
-  const gridBl = [3.5, d - 3.5];
+function encodeAztec(value, options = {}) {
+  const eccPercent = options.eccPercent ?? 23;
+  if (!Number.isFinite(eccPercent) || eccPercent < 5 || eccPercent > 95) {
+    throw new EncodeError('Aztec: eccPercent must be between 5 and 95');
+  }
+  const high = encodeHighLevel(value, { charset: options.charset ?? 'utf-8' });
+  for (const candidate of candidates(options.layers, options.compact)) {
+    if (!candidate) continue;
+    const wordSize = wordSizeForLayers(candidate.layers);
+    const stuffed = stuffBits(high, wordSize);
+    const dataWords = Math.ceil(stuffed.length / wordSize);
+    const eccWords = eccCodewordsFor(dataWords, eccPercent);
+    if (dataWords > candidate.maxDataCodewords || dataWords + eccWords > candidate.totalCodewords) continue;
+    const checked = addCheckWords(stuffed, candidate.totalBits, wordSize, fieldForLayers(candidate.layers));
+    // `addCheckWords` uses every remaining word as parity.  This is stronger
+    // than the requested percentage, never weaker, and canonical for a chosen
+    // layer/data-word combination.
+    const symbol = { ...candidate, dataWords: checked.dataWords };
+    const matrix = buildAztecMatrix(checked.bits, symbol);
+    matrix.format = 'aztec'; matrix.layers = candidate.layers; matrix.compact = candidate.compact;
+    matrix.eccPercent = Math.round(checked.eccWords * wordSize * 100 / Math.max(1, stuffed.length));
+    matrix.dataCodewords = checked.dataWords;
+    return matrix;
+  }
+  throw new EncodeError('Aztec: payload does not fit the requested layers and error correction');
+}
 
-  // Parallelogram estimate of the far corner, used both as the search seed for
-  // the alignment pattern and as the fallback when it is not there.
-  const guess = { x: tr.x + bl.x - tl.x, y: tr.y + bl.y - tl.y };
+__exports.stuffBits = stuffBits;
+__exports.addCheckWords = addCheckWords;
+__exports.modeMessage = modeMessage;
+__exports.buildAztecMatrix = buildAztecMatrix;
+__exports.encodeAztec = encodeAztec;
+};
 
-  /** @type {PerspectiveTransform | null} */
-  let transform = null;
-  let alignmentFound = false;
+__modules["aztec/decoder.js"] = function (__require, __exports) {
+/**
+ * Decoder for a sampled Aztec symbol.
+ *
+ * This module deliberately accepts only a square, module-aligned BitMatrix.
+ * Locating a bull's-eye in a photograph and perspective sampling are detector
+ * concerns. Keeping the two stages apart makes all bit order and ECC rules
+ * testable without image-processing noise.
+ *
+ * Contract with tables.js:
+ *   - aztecSymbolForLayers(compact, layers) returns the nominal symbol data;
+ *   - aztecWordSizeForLayers(layers) returns 6, 8, 10 or 12;
+ *   - aztecFieldForLayers(layers) returns the matching binary Galois field;
+ *   - aztecMatrixSize(compact, layers) returns the rendered square size.
+ *
+ * @module aztec/decoder
+ */
+const { FormatError } = __require("core/errors.js");
+const { rsDecode } = __require("core/reed-solomon.js");
+const { aztecLayer: aztecSymbolForLayers, wordSizeForLayers: aztecWordSizeForLayers, fieldForLayers: aztecFieldForLayers, fieldForWordSize, aztecSymbolSize: aztecMatrixSize } = __require("aztec/tables.js");
 
-  if (version >= 2) {
-    // The bottom-right alignment pattern is centred on module (d - 7, d - 7).
-    const gridAlign = [d - 6.5, d - 6.5];
-    // Where that module lands under the parallelogram assumption.
-    const seed = {
-      x: tl.x + ((gridAlign[0] - 3.5) / (d - 7)) * (tr.x - tl.x) +
-        ((gridAlign[1] - 3.5) / (d - 7)) * (bl.x - tl.x),
-      y: tl.y + ((gridAlign[0] - 3.5) / (d - 7)) * (tr.y - tl.y) +
-        ((gridAlign[1] - 3.5) / (d - 7)) * (bl.y - tl.y),
-    };
+const UPPER = ['CTRL_PS', ' ', ...'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'CTRL_LL', 'CTRL_ML', 'CTRL_DL', 'CTRL_BS'];
+const LOWER = ['CTRL_PS', ' ', ...'abcdefghijklmnopqrstuvwxyz', 'CTRL_US', 'CTRL_ML', 'CTRL_DL', 'CTRL_BS'];
+const MIXED = [
+  'CTRL_PS', ' ', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07', '\b', '\t', '\n', '\x0b', '\f', '\r', '\x1b',
+  '\x1c', '\x1d', '\x1e', '\x1f', '@', '\\', '^', '_', '`', '|', '~', '\x7f', 'CTRL_LL', 'CTRL_UL', 'CTRL_PL', 'CTRL_BS',
+];
+const PUNCT = ['FLG(n)', '\r', '\r\n', '. ', ', ', ': ', '!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '[', ']', '{', '}', 'CTRL_UL'];
+const DIGIT = ['CTRL_PS', ' ', ...'0123456789', ',', '.', 'CTRL_UL'];
+const TABLES = { UPPER, LOWER, MIXED, PUNCT, DIGIT };
 
-    const align = findAlignment(image, seed, moduleSize);
-    if (align) {
-      alignmentFound = true;
-      transform = PerspectiveTransform.quadToQuad(
-        gridTl[0], gridTl[1], gridTr[0], gridTr[1], gridAlign[0], gridAlign[1], gridBl[0], gridBl[1],
-        tl.x, tl.y, tr.x, tr.y, align.x, align.y, bl.x, bl.y
-      );
+/** @param {boolean[]} bits @param {number} offset @param {number} count */
+function readBits(bits, offset, count) {
+  if (offset + count > bits.length) throw new FormatError('Aztec: truncated high-level stream');
+  let value = 0;
+  for (let i = 0; i < count; i++) value = (value << 1) | (bits[offset + i] ? 1 : 0);
+  return value;
+}
+
+/** @param {number} value @param {number} count @param {boolean[]} out */
+function appendBits(value, count, out) {
+  for (let i = count - 1; i >= 0; i--) out.push(((value >>> i) & 1) !== 0);
+}
+
+/**
+ * Decode an Aztec high-level bit stream to its exact byte payload.
+ *
+ * Text tables contribute their ISO-8859-1 byte values; Binary Shift appends
+ * raw bytes. ECI markers are consumed but intentionally not emitted: callers
+ * receive the transported byte payload and may select their own charset.
+ *
+ * @param {boolean[]} bits
+ * @returns {Uint8Array}
+ */
+function decodeHighLevelBits(bits) {
+  const output = [];
+  let latch = 'UPPER';
+  let shift = 'UPPER';
+  let offset = 0;
+
+  while (offset < bits.length) {
+    if (shift === 'BINARY') {
+      if (offset + 5 > bits.length) break; // legal trailing pad
+      let length = readBits(bits, offset, 5);
+      offset += 5;
+      if (length === 0) {
+        if (offset + 11 > bits.length) throw new FormatError('Aztec: truncated Binary Shift length');
+        length = readBits(bits, offset, 11) + 31;
+        offset += 11;
+      }
+      if (offset + length * 8 > bits.length) throw new FormatError('Aztec: truncated Binary Shift data');
+      for (let i = 0; i < length; i++) {
+        output.push(readBits(bits, offset, 8));
+        offset += 8;
+      }
+      shift = latch;
+      continue;
+    }
+
+    const size = shift === 'DIGIT' ? 4 : 5;
+    if (offset + size > bits.length) break; // trailing pad after unstuffing
+    const code = readBits(bits, offset, size);
+    offset += size;
+    const table = TABLES[shift];
+    const token = table[code];
+    if (token === undefined) throw new FormatError(`Aztec: invalid ${shift} code ${code}`);
+
+    if (token === 'FLG(n)') {
+      if (offset + 3 > bits.length) throw new FormatError('Aztec: truncated FLG(n)');
+      const count = readBits(bits, offset, 3);
+      offset += 3;
+      if (count === 0) output.push(0x1d); // FNC1 / GS
+      else if (count <= 6) {
+        // ECI assignment number, encoded as count decimal digits. It changes
+        // interpretation, not the wire bytes, so consume it without output.
+        for (let i = 0; i < count; i++) {
+          if (offset + 4 > bits.length) throw new FormatError('Aztec: truncated ECI');
+          const digit = readBits(bits, offset, 4);
+          offset += 4;
+          if (digit < 2 || digit > 11) throw new FormatError('Aztec: invalid ECI digit');
+        }
+      } else {
+        throw new FormatError(`Aztec: unsupported FLG(${count})`);
+      }
+      shift = latch;
+      continue;
+    }
+
+    if (token.startsWith('CTRL_')) {
+      const targetCode = token.slice(5, -1);
+      const latchMode = token.endsWith('L');
+      const target = ({ P: 'PUNCT', L: 'LOWER', M: 'MIXED', D: 'DIGIT', U: 'UPPER', B: 'BINARY' })[targetCode];
+      if (!target) throw new FormatError(`Aztec: invalid control ${token}`);
+      shift = target;
+      if (latchMode) latch = shift;
+      continue;
     }
+
+    for (let i = 0; i < token.length; i++) output.push(token.charCodeAt(i));
+    shift = latch;
   }
+  return Uint8Array.from(output);
+}
 
-  const plain = PerspectiveTransform.quadToQuad(
-    gridTl[0], gridTl[1], gridTr[0], gridTr[1], d - 3.5, d - 3.5, gridBl[0], gridBl[1],
-    tl.x, tl.y, tr.x, tr.y, guess.x, guess.y, bl.x, bl.y
+/** @param {boolean} compact @param {number} layers */
+function alignmentMap(compact, layers) {
+  const baseSize = (compact ? 11 : 14) + layers * 4;
+  if (compact) return Array.from({ length: baseSize }, (_, i) => i);
+  const size = aztecMatrixSize(layers, false);
+  const map = new Array(baseSize);
+  const baseCenter = baseSize >> 1;
+  const center = size >> 1;
+  for (let i = 0; i < baseCenter; i++) {
+    const offset = i + Math.floor(i / 15);
+    map[baseCenter - i - 1] = center - offset - 1;
+    map[baseCenter + i] = center + offset + 1;
+  }
+  return map;
+}
+
+/**
+ * Read the four sides of the parameter message. The order mirrors the
+ * clockwise write order and is independent of the data spiral.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {boolean} compact
+ * @returns {boolean[]}
+ */
+function readModeBits(matrix, compact) {
+  const center = matrix.width >> 1;
+  const side = compact ? 7 : 10;
+  const offset = compact ? 5 : 7;
+  // Full symbols skip the reference grid line through the bull's-eye. This
+  // exact sequence is also used by drawModeMessage() in encoder.js.
+  const positions = Array.from(
+    { length: side },
+    (_, i) => compact ? center - 3 + i : center - 5 + i + Math.floor(i / 5),
   );
+  const bits = [];
+  for (let i = 0; i < side; i++) bits.push(matrix.get(positions[i], center - offset));
+  for (let i = 0; i < side; i++) bits.push(matrix.get(center + offset, positions[i]));
+  for (let i = 0; i < side; i++) bits.push(matrix.get(positions[side - 1 - i], center + offset));
+  for (let i = 0; i < side; i++) bits.push(matrix.get(center - offset, positions[side - 1 - i]));
+  return bits;
+}
 
-  const corners = cornersOf(transform ?? plain, d);
-  // Keep the parallelogram corners as a second opinion whenever an alignment
-  // pattern steered the first set. Verification makes a false match unlikely,
-  // not impossible, and one extra sampling attempt is far cheaper than losing
-  // a symbol to it.
-  const altCorners = transform ? cornersOf(plain, d) : null;
+/** @param {boolean[]} bits @param {boolean} compact */
+function decodeModeMessage(bits, compact) {
+  const total = compact ? 7 : 10;
+  const dataWords = compact ? 2 : 4;
+  const words = new Array(total);
+  for (let i = 0; i < total; i++) words[i] = readBits(bits, i * 4, 4);
+  const corrections = rsDecode(words, total - dataWords, fieldForWordSize(4), 1);
+  let data = 0;
+  for (let i = 0; i < dataWords; i++) data = (data << 4) | words[i];
+  const layers = compact ? (data >>> 6) + 1 : (data >>> 11) + 1;
+  const dataCodewords = compact ? (data & 0x3f) + 1 : (data & 0x7ff) + 1;
+  return { layers, dataCodewords, corrections };
+}
 
-  return { corners, altCorners, dimension, version, moduleSize, alignmentFound };
+/** @param {boolean} compact @param {number} layers */
+function totalBitsInLayers(compact, layers) {
+  return ((compact ? 88 : 112) + 16 * layers) * layers;
 }
 
 /**
- * The four outer corners of the symbol under a grid-to-image transform.
+ * Extract raw, stuffed codeword bits in logical ring order.
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {boolean} compact @param {number} layers
+ * @returns {boolean[]}
+ */
+function extractBits(matrix, compact, layers) {
+  const baseSize = (compact ? 11 : 14) + layers * 4;
+  const map = alignmentMap(compact, layers);
+  const raw = new Array(totalBitsInLayers(compact, layers));
+  let offset = 0;
+  for (let layer = 0; layer < layers; layer++) {
+    const rowSize = (layers - layer) * 4 + (compact ? 9 : 12);
+    for (let j = 0; j < rowSize; j++) {
+      const col = j * 2;
+      for (let k = 0; k < 2; k++) {
+        raw[offset + col + k] = matrix.get(map[layer * 2 + k], map[layer * 2 + j]);
+        raw[offset + rowSize * 2 + col + k] = matrix.get(map[layer * 2 + j], map[baseSize - 1 - layer * 2 - k]);
+        raw[offset + rowSize * 4 + col + k] = matrix.get(map[baseSize - 1 - layer * 2 - k], map[baseSize - 1 - layer * 2 - j]);
+        raw[offset + rowSize * 6 + col + k] = matrix.get(map[baseSize - 1 - layer * 2 - j], map[layer * 2 + k]);
+      }
+    }
+    offset += rowSize * 8;
+  }
+  return raw;
+}
+
+/** @param {boolean[]} raw @param {number} layers @param {number} dataCodewords */
+function correctAndUnstuff(raw, layers, dataCodewords) {
+  const wordSize = aztecWordSizeForLayers(layers);
+  const totalWords = Math.floor(raw.length / wordSize);
+  if (dataCodewords <= 0 || dataCodewords > totalWords) throw new FormatError('Aztec: invalid data word count');
+  const start = raw.length % wordSize;
+  const words = new Array(totalWords);
+  for (let i = 0; i < totalWords; i++) words[i] = readBits(raw, start + i * wordSize, wordSize);
+  const corrections = rsDecode(words, totalWords - dataCodewords, aztecFieldForLayers(layers), 1);
+  const mask = (1 << wordSize) - 1;
+  const corrected = [];
+  for (let i = 0; i < dataCodewords; i++) {
+    const word = words[i];
+    if (word === 0 || word === mask) throw new FormatError('Aztec: invalid stuffed codeword');
+    if (word === 1 || word === mask - 1) {
+      for (let j = 0; j < wordSize - 1; j++) corrected.push(word === mask - 1);
+    } else {
+      appendBits(word, wordSize, corrected);
+    }
+  }
+  return { bits: corrected, corrections };
+}
+
+/** @param {Uint8Array} bytes */
+function bytesToText(bytes) {
+  try { return new TextDecoder('utf-8', { fatal: true }).decode(bytes); }
+  catch { return new TextDecoder('latin1').decode(bytes); }
+}
+
+/**
+ * Decode a square Aztec symbol with one bit per module and no quiet zone.
+ * The matrix must already be oriented with the mode message at the top.
  *
- * @param {PerspectiveTransform} transform @param {number} d
- * @returns {Array<{x: number, y: number}>}
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @returns {{text: string, bytes: Uint8Array, compact: boolean, layers: number, corrections: number, eccPercent: number}}
  */
-function cornersOf(transform, d) {
-  return [
-    transform.transformPoint(0, 0),
-    transform.transformPoint(d, 0),
-    transform.transformPoint(d, d),
-    transform.transformPoint(0, d),
-  ];
+function decodeAztec(matrix) {
+  if (!matrix || matrix.width !== matrix.height) throw new FormatError('Aztec: expected a square BitMatrix');
+  let compact;
+  let mode;
+  // Compact and full dimensions are disjoint; trying both also makes malformed
+  // candidate handling deterministic for the future image detector.
+  for (const candidate of [true, false]) {
+    try {
+      const value = decodeModeMessage(readModeBits(matrix, candidate), candidate);
+      if (value.layers < 1 || value.layers > (candidate ? 4 : 32)) continue;
+      if (aztecMatrixSize(value.layers, candidate) !== matrix.width) continue;
+      compact = candidate;
+      mode = value;
+      break;
+    } catch { /* Try the other family. */ }
+  }
+  if (compact === undefined || !mode) throw new FormatError('Aztec: invalid mode message or dimensions');
+  // Ensure the declared layer data agrees with the table module, so a future
+  // tables refactor cannot silently make decoder capacity calculations stale.
+  aztecSymbolForLayers(mode.layers, compact);
+  const raw = extractBits(matrix, compact, mode.layers);
+  const payload = correctAndUnstuff(raw, mode.layers, mode.dataCodewords);
+  const bytes = decodeHighLevelBits(payload.bits);
+  const totalWords = Math.floor(raw.length / aztecWordSizeForLayers(mode.layers));
+  return {
+    text: bytesToText(bytes),
+    bytes,
+    compact,
+    layers: mode.layers,
+    corrections: mode.corrections + payload.corrections,
+    eccPercent: Math.round(((totalWords - mode.dataCodewords) * 100) / totalWords),
+  };
 }
 
+__exports.decodeHighLevelBits = decodeHighLevelBits;
+__exports.decodeAztec = decodeAztec;
+};
+
+__modules["aztec/detector.js"] = function (__require, __exports) {
 /**
- * Find and decode every QR Code in a binarized image.
+ * Aztec image detection.
  *
- * Each candidate gets up to four attempts: a plain centre sample, a 3x3
- * majority vote for noisy input, and both of those rotated 180 degrees. The
- * rotation retry matters because three finders in a right isoceles triangle
- * look identical to the same three rotated half a turn — the orientation is
- * only settled once the format information reads cleanly, which is to say once
- * the decode succeeds.
+ * Aztec has no finder pattern at its outer border. Its reliable geometric
+ * anchor is instead the alternating square bull's-eye in the centre: five
+ * rings in Compact symbols, seven rings in Full symbols. The detector finds
+ * isolated central modules, verifies those rings at module centres, then
+ * samples each legal symbol dimension. The decoder is deliberately the final
+ * arbiter: its mode-message Reed--Solomon check rejects accidental concentric
+ * artwork and tells us which of the compact/full dimensions is real.
  *
- * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
- * @returns {Array<import('./decoder.js').DecodeResult & {corners: Array<{x: number, y: number}>}>}
- *   Empty when nothing decodes; never throws for "no symbol here".
+ * Sampling uses a quadrilateral, not a cropped bitmap, so the detected
+ * rotation is corrected before decoding. The ring search covers arbitrary
+ * in-plane rotations (four-degree coarse search; at normal camera scales its
+ * positional error remains well inside a module). The optional inverse pass
+ * supports light modules on a dark field.
+ *
+ * @module aztec/detector
  */
-function detectAndDecodeQR(binaryImage) {
-  let detections;
-  try {
-    detections = detectQR(binaryImage);
-  } catch (e) {
-    return [];
+const { NotFoundError } = __require("core/errors.js");
+const { sampleQuad } = __require("image/grid-sampler.js");
+const { decodeAztec } = __require("aztec/decoder.js");
+
+/** @typedef {{x:number, y:number}} Point */
+/** @typedef {{corners: Point[], dimension: number, compact: boolean, moduleSize: number, matrix: import('../core/bit-matrix.js').BitMatrix}} Detection */
+
+// Compact: 11 + 4 layers. Full symbols add reference-grid rows/columns every
+// 15 modules measured from their central 14-module base, not every 15 layers.
+const DIMENSIONS = [
+  ...[1, 2, 3, 4].map((layers) => ({ compact: true, dimension: 11 + 4 * layers })),
+  ...Array.from({ length: 32 }, (_, index) => {
+    const layers = index + 1;
+    return { compact: false, dimension: 15 + 4 * layers + 2 * Math.floor((2 * layers + 6) / 15) };
+  }),
+];
+
+function pixel(image, x, y) {
+  const ix = Math.round(x);
+  const iy = Math.round(y);
+  return ix >= 0 && iy >= 0 && ix < image.width && iy < image.height && image.get(ix, iy);
+}
+
+/** Connected components of either polarity, retaining only plausible modules. */
+function components(image, value) {
+  const seen = new Uint8Array(image.width * image.height);
+  const out = [];
+  const maximumArea = Math.max(4, Math.floor(image.width * image.height * 0.08));
+  for (let y = 0; y < image.height; y++) for (let x = 0; x < image.width; x++) {
+    const start = y * image.width + x;
+    if (seen[start] || image.get(x, y) !== value) continue;
+    const xs = [x];
+    const ys = [y];
+    seen[start] = 1;
+    let head = 0;
+    let minX = x; let maxX = x; let minY = y; let maxY = y;
+    while (head < xs.length) {
+      const px = xs[head]; const py = ys[head++];
+      if (px < minX) minX = px; if (px > maxX) maxX = px;
+      if (py < minY) minY = py; if (py > maxY) maxY = py;
+      for (const [nx, ny] of [[px - 1, py], [px + 1, py], [px, py - 1], [px, py + 1]]) {
+        if (nx < 0 || ny < 0 || nx >= image.width || ny >= image.height) continue;
+        const at = ny * image.width + nx;
+        if (!seen[at] && image.get(nx, ny) === value) {
+          seen[at] = 1; xs.push(nx); ys.push(ny);
+        }
+      }
+    }
+    const width = maxX - minX + 1;
+    const height = maxY - minY + 1;
+    const area = width * height;
+    // The central module is solid and approximately square. This filter is
+    // intentionally permissive because a rotated raster module is diamond-ish.
+    if (xs.length <= maximumArea && Math.abs(width - height) <= Math.max(1, Math.ceil(Math.max(width, height) * 0.35)) &&
+      xs.length >= area * 0.45) {
+      out.push({ x: (minX + maxX) / 2, y: (minY + maxY) / 2, width, height, pixels: xs.length });
+    }
   }
+  return out.sort((a, b) => b.pixels - a.pixels).slice(0, 2000);
+}
 
-  const results = [];
-  const seen = new Set();
+function expectedDark(ring, inverted) {
+  return inverted ? (ring & 1) === 1 : (ring & 1) === 0;
+}
 
-  for (let i = 0; i < detections.length; i++) {
-    const det = detections[i];
+/** Score one square bull's-eye at an angle and a candidate module pitch. */
+function ringScore(image, centre, pitch, angle, inverted, rings) {
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  let correct = 0;
+  let total = 0;
+  for (let ring = 0; ring < rings; ring++) {
+    const wanted = expectedDark(ring, inverted);
+    for (let j = -ring; j <= ring; j++) for (let i = -ring; i <= ring; i++) {
+      if (ring && Math.abs(i) !== ring && Math.abs(j) !== ring) continue;
+      const x = centre.x + (i * cos - j * sin) * pitch;
+      const y = centre.y + (i * sin + j * cos) * pitch;
+      if (pixel(image, x, y) === wanted) correct++;
+      total++;
+    }
+  }
+  return correct / total;
+}
 
-    for (let attempt = 0; attempt < 4; attempt++) {
-      const voting = attempt === 1 || attempt === 3;
-      const rotated = attempt >= 2;
+function rotateCorners(corners, turn) {
+  return corners.slice(turn).concat(corners.slice(0, turn));
+}
 
-      let matrix;
-      try {
-        matrix = sampleQuad(binaryImage, det.dimension, det.corners, voting);
-      } catch (e) {
-        continue;
-      }
-      if (rotated) matrix.rotate180();
+function invert(matrix) {
+  const out = matrix.clone();
+  for (let y = 0; y < out.height; y++) for (let x = 0; x < out.width; x++) out.flip(x, y);
+  return out;
+}
 
-      try {
-        const result = decodeQR(matrix);
-        // The same symbol can be detected through more than one finder triple.
-        const key = `${result.version}|${result.text}`;
-        if (!seen.has(key)) {
-          seen.add(key);
-          results.push(Object.assign({ corners: det.corners }, result));
+function cornersFor(centre, pitch, angle, dimension) {
+  const half = dimension * pitch / 2;
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  const point = (x, y) => ({ x: centre.x + x * cos - y * sin, y: centre.y + x * sin + y * cos });
+  return [point(-half, -half), point(half, -half), point(half, half), point(-half, half)];
+}
+
+/**
+ * Find an Aztec symbol in a binarized image.
+ *
+ * The returned matrix is in the orientation accepted by the Aztec decoder.
+ * A valid mode message is required before a geometric candidate is returned,
+ * making false positives from decorative concentric squares very unlikely.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage Set bit = dark.
+ * @returns {Detection | null}
+ */
+function detectAztec(binaryImage) {
+  if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+    throw new NotFoundError('detectAztec: no image supplied');
+  }
+  const candidates = [];
+  for (const inverted of [false, true]) {
+    for (const core of components(binaryImage, !inverted)) {
+      // A non-rotated one-module component directly gives its pitch. For
+      // rotated modules its bounding box grows by |sin| + |cos|, compensated
+      // below for every tested angle.
+      for (let degrees = 0; degrees < 180; degrees += 4) {
+        const angle = degrees * Math.PI / 180;
+        const scale = Math.abs(Math.cos(angle)) + Math.abs(Math.sin(angle));
+        const pitch = ((core.width + core.height) / 2) / scale;
+        if (pitch < 0.8) continue;
+        // Test Full first: its seven rings also exclude Compact candidates.
+        const fullScore = ringScore(binaryImage, core, pitch, angle, inverted, 7);
+        const rings = fullScore >= 0.88 ? 7 : 5;
+        const score = rings === 7 ? fullScore : ringScore(binaryImage, core, pitch, angle, inverted, 5);
+        if (score < 0.91) continue;
+        const symbolKinds = rings === 7 ? DIMENSIONS.filter((item) => !item.compact) : DIMENSIONS.filter((item) => item.compact);
+        for (const kind of symbolKinds) {
+          const baseCorners = cornersFor(core, pitch, angle, kind.dimension);
+          for (let turn = 0; turn < 4; turn++) {
+            const corners = rotateCorners(baseCorners, turn);
+            let matrix;
+            try { matrix = sampleQuad(binaryImage, kind.dimension, corners); } catch (e) { continue; }
+            if (inverted) matrix = invert(matrix);
+            try {
+              // The decoder verifies the mode-message ECC and exact geometry.
+              // We do not expose its result here so callers can use pure
+              // detection without treating payload decoding as an API contract.
+              decodeAztec(matrix);
+              candidates.push({ corners, dimension: kind.dimension, compact: kind.compact,
+                moduleSize: pitch, matrix, score });
+            } catch (e) { /* Not an Aztec mode message at this dimension. */ }
+          }
         }
-        break;
-      } catch (e) {
-        /* Try the next sampling strategy. */
       }
     }
   }
-
-  return results;
+  candidates.sort((a, b) => b.score - a.score || b.moduleSize - a.moduleSize);
+  const best = candidates[0];
+  if (!best) return null;
+  delete best.score;
+  return best;
 }
 
-__exports.detectQR = detectQR;
-__exports.detectAndDecodeQR = detectAndDecodeQR;
-};
-
-__modules["qr/index.js"] = function (__require, __exports) {
 /**
- * QR Code, re-exported.
- *
- * `QR_PLACEHOLDER` is deliberately absent: `src/index.js` probes for it to
- * decide whether this build can read and write QR, and its absence is what
- * reports the format as available.
+ * Detect then decode an Aztec symbol. Detection failure is a normal result for
+ * images without an Aztec code, therefore invalid candidates return null.
  *
- * @module qr
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @returns {(import('./decoder.js').DecodeResult & {corners: Point[]}) | null}
  */
-const __reexport0 = __require("qr/encoder.js"); __exports.encodeQR = __reexport0.encodeQR;
-const __reexport1 = __require("qr/decoder.js"); __exports.decodeQR = __reexport1.decodeQR;
-const __reexport2 = __require("qr/detector.js"); __exports.detectQR = __reexport2.detectQR; __exports.detectAndDecodeQR = __reexport2.detectAndDecodeQR;
-const __reexport3 = __require("qr/tables.js"); __exports.validateTables = __reexport3.validateTables;
+function detectAndDecodeAztec(binaryImage) {
+  let detection;
+  try { detection = detectAztec(binaryImage); } catch (e) { return null; }
+  if (!detection) return null;
+  try { return Object.assign({ corners: detection.corners }, decodeAztec(detection.matrix)); }
+  catch (e) { return null; }
+}
+
+__exports.detectAztec = detectAztec;
+__exports.detectAndDecodeAztec = detectAndDecodeAztec;
+};
+
+__modules["aztec/index.js"] = function (__require, __exports) {
+/** Aztec Code entry points. @module aztec */
+const __reexport0 = __require("aztec/encoder.js"); __exports.encodeAztec = __reexport0.encodeAztec;
+const __reexport1 = __require("aztec/decoder.js"); __exports.decodeAztec = __reexport1.decodeAztec;
+const __reexport2 = __require("aztec/detector.js"); __exports.detectAztec = __reexport2.detectAztec; __exports.detectAndDecodeAztec = __reexport2.detectAndDecodeAztec;
+const __reexport3 = __require("aztec/tables.js"); __exports.AZTEC_COMPACT_LAYERS = __reexport3.AZTEC_COMPACT_LAYERS; __exports.AZTEC_FULL_LAYERS = __reexport3.AZTEC_FULL_LAYERS; __exports.AZTEC_LAYERS = __reexport3.AZTEC_LAYERS; __exports.AZTEC_DEFAULT_ECC_PERCENT = __reexport3.AZTEC_DEFAULT_ECC_PERCENT; __exports.AZTEC_RS_GENERATOR_BASE = __reexport3.AZTEC_RS_GENERATOR_BASE; __exports.aztecLayer = __reexport3.aztecLayer; __exports.aztecSymbolSize = __reexport3.aztecSymbolSize; __exports.validateAztecTables = __reexport3.validateAztecTables;
 
 
 };
@@ -7749,7 +9583,9 @@ const { LuminanceSource } = __require("image/luminance.js");
 const { binarize } = __require("image/binarizer.js");
 const { ONED_FORMATS } = __require("oned/index.js");
 const { decodeOneD } = __require("oned/reader.js");
+const datamatrix = __require("datamatrix/index.js");
 const qr = __require("qr/index.js");
+const aztec = __require("aztec/index.js");
 __exports.BitMatrix = BitMatrix;
 const __reexport0 = __require("core/errors.js"); __exports.BarcodeError = __reexport0.BarcodeError; __exports.EncodeError = __reexport0.EncodeError; __exports.NotFoundError = __reexport0.NotFoundError; __exports.FormatError = __reexport0.FormatError; __exports.ChecksumError = __reexport0.ChecksumError;
 const __reexport1 = __require("image/luminance.js"); __exports.LuminanceSource = __reexport1.LuminanceSource;
@@ -7761,6 +9597,8 @@ const __reexport5 = __require("render/png.js"); __exports.toPNG = __reexport5.to
 const __reexport6 = __require("render/index.js"); __exports.renderToCanvasAuto = __reexport6.renderToCanvasAuto; __exports.isWebGL2Available = __reexport6.isWebGL2Available;
 const __reexport7 = __require("render/index.js"); __exports.renderToCanvasAutoAsync = __reexport7.renderToCanvasAutoAsync; __exports.isWebGPUAvailable = __reexport7.isWebGPUAvailable;
 const __reexport8 = __require("qr/index.js"); __exports.encodeQR = __reexport8.encodeQR; __exports.decodeQR = __reexport8.decodeQR; __exports.detectQR = __reexport8.detectQR; __exports.detectAndDecodeQR = __reexport8.detectAndDecodeQR;
+const __reexport9 = __require("datamatrix/index.js"); __exports.encodeDataMatrix = __reexport9.encodeDataMatrix; __exports.decodeDataMatrix = __reexport9.decodeDataMatrix; __exports.detectDataMatrix = __reexport9.detectDataMatrix; __exports.detectAndDecodeDataMatrix = __reexport9.detectAndDecodeDataMatrix;
+const __reexport10 = __require("aztec/index.js"); __exports.encodeAztec = __reexport10.encodeAztec; __exports.decodeAztec = __reexport10.decodeAztec; __exports.detectAztec = __reexport10.detectAztec; __exports.detectAndDecodeAztec = __reexport10.detectAndDecodeAztec;
 
 /**
  * @typedef {object} FormatInfo
@@ -7784,6 +9622,10 @@ const qrCanEncode = qrPresent &&
   typeof qr.encodeQR === 'function' && qr.QR_CAN_ENCODE !== false;
 const qrCanDecode = qrPresent &&
   typeof qr.detectAndDecodeQR === 'function' && qr.QR_CAN_DECODE !== false;
+const dataMatrixCanEncode = typeof datamatrix.encodeDataMatrix === 'function';
+const dataMatrixCanDecode = typeof datamatrix.detectAndDecodeDataMatrix === 'function';
+const aztecCanEncode = typeof aztec.encodeAztec === 'function';
+const aztecCanDecode = typeof aztec.detectAndDecodeAztec === 'function';
 
 /**
  * Every format this build supports.
@@ -7811,6 +9653,20 @@ function listFormats() {
     canRead: qrCanDecode,
     kind: /** @type {'2D'} */ ('2D'),
   });
+  formats.push({
+    id: 'datamatrix',
+    label: 'Data Matrix ECC 200',
+    canWrite: dataMatrixCanEncode,
+    canRead: dataMatrixCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
+  formats.push({
+    id: 'aztec',
+    label: 'Aztec Code',
+    canWrite: aztecCanEncode,
+    canRead: aztecCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
 
   return formats;
 }
@@ -7831,6 +9687,9 @@ function listFormats() {
  * @param {boolean} [options.checkDigit] Append a check digit, where optional.
  * @param {boolean} [options.fullAscii] Code 39 extended encoding.
  * @param {boolean} [options.gs1] Emit a leading FNC1.
+ * @param {number} [options.layers] Aztec layer count; automatic if omitted.
+ * @param {boolean} [options.compact] Force an Aztec Compact or Full symbol.
+ * @param {number} [options.eccPercent] Requested Aztec error-correction percentage.
  * @returns {BitMatrix}
  */
 function encode(text, options = {}) {
@@ -7840,10 +9699,16 @@ function encode(text, options = {}) {
   if (format === 'qr' || format === 'qrcode') {
     return qr.encodeQR(value, options);
   }
+  if (format === 'datamatrix' || format === 'data-matrix') {
+    return datamatrix.encodeDataMatrix(value, options);
+  }
+  if (format === 'aztec' || format === 'aztec-code') {
+    return aztec.encodeAztec(value, options);
+  }
 
   const entry = ONED_FORMATS[format];
   if (!entry) {
-    const known = [...Object.keys(ONED_FORMATS), 'qr'].join(', ');
+    const known = [...Object.keys(ONED_FORMATS), 'qr', 'datamatrix', 'aztec'].join(', ');
     throw new EncodeError(`Unknown format "${format}". Known formats: ${known}`);
   }
   return entry.encode(value, options);
@@ -7856,6 +9721,9 @@ function encode(text, options = {}) {
  * @property {Uint8Array} [bytes] Raw payload, before text decoding.
  * @property {number} [version] QR version.
  * @property {string} [ecc] QR error-correction level.
+ * @property {number} [layers] Aztec layer count.
+ * @property {boolean} [compact] Whether an Aztec symbol is Compact.
+ * @property {number} [corrections] Reed–Solomon corrections applied by an Aztec decode.
  */
 
 /**
@@ -7876,6 +9744,8 @@ function decode(image, options = {}) {
   const { formats = null, tryHarder = true, binarizer = 'auto' } = options;
   const want = formats ? new Set(formats.map((f) => f.toLowerCase())) : null;
   const wantQR = !want || want.has('qr') || want.has('qrcode');
+  const wantDataMatrix = !want || want.has('datamatrix') || want.has('data-matrix');
+  const wantAztec = !want || want.has('aztec') || want.has('aztec-code');
   const wantOneD = !want || [...want].some((f) => f in ONED_FORMATS);
 
   const source = LuminanceSource.fromImageData(image);
@@ -7898,6 +9768,36 @@ function decode(image, options = {}) {
       }
     }
 
+    if (wantDataMatrix && dataMatrixCanDecode) {
+      // Hybrid thresholding can erase the interior of very large, perfectly
+      // uniform modules. In auto mode keep the local-threshold attempt, then
+      // retry Data Matrix once with the global threshold before giving up.
+      const dataMatrixBits = binarizer === 'auto' ? [bits, binarize(pass, 'global')] : [bits];
+      for (const candidateBits of dataMatrixBits) {
+        try {
+          const found = datamatrix.detectAndDecodeDataMatrix(candidateBits);
+          if (found) { results.push({ ...found, format: 'datamatrix' }); break; }
+        } catch {
+          /* no Data Matrix with this threshold */
+        }
+      }
+    }
+
+    if (wantAztec && aztecCanDecode) {
+      // The central bull's-eye is a small, high-contrast target. Hybrid
+      // thresholding can flatten it on clean rendered symbols, so mirror the
+      // Data Matrix global fallback in auto mode.
+      const aztecBits = binarizer === 'auto' ? [bits, binarize(pass, 'global')] : [bits];
+      for (const candidateBits of aztecBits) {
+        try {
+          const found = aztec.detectAndDecodeAztec(candidateBits);
+          if (found) { results.push({ ...found, format: 'aztec' }); break; }
+        } catch {
+          /* no Aztec code with this threshold */
+        }
+      }
+    }
+
     if (wantOneD) {
       const oneDFormats = want ? [...want].filter((f) => f in ONED_FORMATS) : null;
       for (const found of decodeOneD(bits, { formats: oneDFormats, tryHarder })) {
@@ -7932,7 +9832,7 @@ function decodeStrict(image, options) {
 }
 
 /** Library version, matching package.json. */
-const VERSION = '0.1.0';
+const VERSION = '1.1.0';
 
 __exports.listFormats = listFormats;
 __exports.encode = encode;
@@ -7957,19 +9857,27 @@ export const {
   binarizeGlobal,
   binarizeHybrid,
   decode,
+  decodeAztec,
+  decodeDataMatrix,
   decodeOneD,
   decodeOneDStrict,
   decodeQR,
   decodeStrict,
+  detectAndDecodeAztec,
+  detectAndDecodeDataMatrix,
   detectAndDecodeQR,
+  detectAztec,
+  detectDataMatrix,
   detectQR,
   ean13CheckDigit,
   encode,
+  encodeAztec,
   encodeCodabar,
   encodeCode11,
   encodeCode128,
   encodeCode39,
   encodeCode93,
+  encodeDataMatrix,
   encodeEAN13,
   encodeEAN8,
   encodeISBN,