@sythos/js_barcode_universal 1.0.0 → 1.2.5

package/bundle/sythos-barcode.js

@@ -1,5 +1,5 @@
 /*!
- * Sythos Barcode Suite v1.0.0
+ * Sythos Barcode Suite v1.2.5
  *
  * MIT License
  *
@@ -2918,6 +2918,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)' });
 
@@ -2930,6 +2933,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;
@@ -2965,7 +2969,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 and Aztec; 1 for Data Matrix and PDF417.
+ * `base` is 0 for QR; 1 for Aztec, Data Matrix and PDF417.
  *
  * @param {number} eccLen
  * @param {import('./galois-field.js').GaloisField} field
@@ -3062,6 +3066,44 @@ function evalPoly(poly, x, field) {
   return acc;
 }
 
+function multiplyAscending(left, right, field, limit) {
+  const out = new Array(Math.min(limit, left.length + right.length - 1)).fill(0);
+  for (let i = 0; i < left.length; i++) for (let j = 0; j < right.length && i + j < out.length; j++) {
+    out[i + j] = field.add(out[i + j], field.mul(left[i], right[j]));
+  }
+  return out;
+}
+
+function berlekampMassey(syndromes, field) {
+  const limit = syndromes.length;
+  const lambda = new Array(limit + 1).fill(0);
+  const previous = new Array(limit + 1).fill(0);
+  const temporary = new Array(limit + 1).fill(0);
+  lambda[0] = 1;
+  previous[0] = 1;
+  let errorCount = 0;
+  let shift = 1;
+  let lastDiscrepancy = 1;
+
+  for (let step = 0; step < limit; step++) {
+    let discrepancy = syndromes[step];
+    for (let i = 1; i <= errorCount; i++) discrepancy = field.add(discrepancy, field.mul(lambda[i], syndromes[step - i]));
+    if (discrepancy === 0) { shift++; continue; }
+    const scale = field.div(discrepancy, lastDiscrepancy);
+    for (let i = 0; i <= limit; i++) temporary[i] = lambda[i];
+    for (let i = 0; i + shift <= limit; i++) if (previous[i] !== 0) {
+      lambda[i + shift] = field.sub(lambda[i + shift], field.mul(scale, previous[i]));
+    }
+    if (2 * errorCount <= step) {
+      errorCount = step + 1 - errorCount;
+      for (let i = 0; i <= limit; i++) previous[i] = temporary[i];
+      lastDiscrepancy = discrepancy;
+      shift = 1;
+    } else shift++;
+  }
+  return { locator: lambda.slice(0, errorCount + 1), errorCount };
+}
+
 /**
  * Correct errors in a received codeword, in place.
  *
@@ -3069,11 +3111,16 @@ function evalPoly(poly, x, field) {
  * @param {number} eccLen
  * @param {import('./galois-field.js').GaloisField} field
  * @param {number} [base]
+ * @param {number[]} [erasures] Known damaged indexes, counted from wire order.
  * @returns {number} Number of symbols corrected.
  * @throws {ChecksumError} If the damage exceeds the correction capacity.
  */
-function rsDecode(received, eccLen, field, base = 0) {
+function rsDecode(received, eccLen, field, base = 0, erasures = []) {
   const n = received.length;
+  if (!Array.isArray(erasures) || new Set(erasures).size !== erasures.length || erasures.some((index) => !Number.isInteger(index) || index < 0 || index >= n)) {
+    throw new ChecksumError('Reed-Solomon: erasure positions must be unique codeword indexes');
+  }
+  if (erasures.length > eccLen) throw new ChecksumError(`Reed-Solomon: ${erasures.length} erasures exceeds correction capacity ${eccLen} (${field.name})`);
 
   // --- Syndromes. S[i] = R(a^(base+i)); all zero means an intact codeword.
   const syn = new Array(eccLen).fill(0);
@@ -3085,53 +3132,24 @@ function rsDecode(received, eccLen, field, base = 0) {
   }
   if (!damaged) return 0;
 
-  // --- Berlekamp-Massey. Degree-ascending here: lambda[k] is the coefficient
-  // of x^k, which is how the recurrence is naturally stated.
-  const lambda = new Array(eccLen + 1).fill(0);
-  const prev = new Array(eccLen + 1).fill(0);
-  const tmp = new Array(eccLen + 1).fill(0);
-  lambda[0] = 1;
-  prev[0] = 1;
-  let errCount = 0;   // current LFSR length
-  let shift = 1;      // steps since `prev` was last updated
-  let lastDisc = 1;   // discrepancy at that update
-
-  for (let step = 0; step < eccLen; step++) {
-    let disc = syn[step];
-    for (let i = 1; i <= errCount; i++) {
-      disc = field.add(disc, field.mul(lambda[i], syn[step - i]));
-    }
-
-    if (disc === 0) {
-      shift++;
-      continue;
-    }
-
-    const scale = field.div(disc, lastDisc);
-    tmp.fill(0);
-    for (let i = 0; i <= eccLen; i++) tmp[i] = lambda[i];
-
-    for (let i = 0; i + shift <= eccLen; i++) {
-      if (prev[i] === 0) continue;
-      lambda[i + shift] = field.sub(lambda[i + shift], field.mul(scale, prev[i]));
-    }
-
-    if (2 * errCount <= step) {
-      errCount = step + 1 - errCount;
-      for (let i = 0; i <= eccLen; i++) prev[i] = tmp[i];
-      lastDisc = disc;
-      shift = 1;
-    } else {
-      shift++;
-    }
-  }
-
-  if (errCount === 0 || errCount > eccLen / 2) {
+  // Remove the known roots before locating unknown errors. The leading
+  // erasureCount terms contain only the known-location transient and are not
+  // part of the error-only recurrence.
+  let erasureLocator = [1];
+  for (const index of erasures) {
+    const location = field.exp(n - 1 - index);
+    erasureLocator = multiplyAscending(erasureLocator, [1, field.neg(location)], field, eccLen + 1);
+  }
+  const modified = multiplyAscending(syn, erasureLocator, field, eccLen).slice(erasures.length);
+  const { locator: errorLocator, errorCount } = berlekampMassey(modified, field);
+  if (2 * errorCount + erasures.length > eccLen) {
     throw new ChecksumError(
-      `Reed-Solomon: ${errCount} errors exceeds correction capacity ` +
-      `${Math.floor(eccLen / 2)} (${field.name})`
+      `Reed-Solomon: ${errorCount} errors and ${erasures.length} erasures exceed correction capacity ` +
+      `${eccLen} (${field.name})`
     );
   }
+  const lambda = multiplyAscending(erasureLocator, errorLocator, field, eccLen + 1);
+  const totalCount = errorCount + erasures.length;
 
   // --- Chien search. Position p (counted from the low-order end) is in error
   // when lambda(a^-p) == 0.
@@ -3140,16 +3158,16 @@ function rsDecode(received, eccLen, field, base = 0) {
     const xInv = field.exp(-p);
     let acc = 0;
     let term = 1;
-    for (let i = 0; i <= errCount; i++) {
+    for (let i = 0; i <= totalCount; i++) {
       acc = field.add(acc, field.mul(lambda[i], term));
       term = field.mul(term, xInv);
     }
     if (acc === 0) positions.push(p);
   }
 
-  if (positions.length !== errCount) {
+  if (positions.length !== totalCount) {
     throw new ChecksumError(
-      `Reed-Solomon: located ${positions.length} of ${errCount} error positions`
+      `Reed-Solomon: located ${positions.length} of ${totalCount} error positions`
     );
   }
 
@@ -3158,7 +3176,7 @@ function rsDecode(received, eccLen, field, base = 0) {
   const omega = new Array(eccLen).fill(0);
   for (let i = 0; i < eccLen; i++) {
     let acc = 0;
-    for (let j = 0; j <= i && j <= errCount; j++) {
+    for (let j = 0; j <= i && j <= totalCount; j++) {
       acc = field.add(acc, field.mul(lambda[j], syn[i - j]));
     }
     omega[i] = acc;
@@ -3182,7 +3200,7 @@ function rsDecode(received, eccLen, field, base = 0) {
     // in a prime field every term contributes with an integer multiplier.
     let den = 0;
     term = 1;
-    for (let i = 1; i <= errCount; i++) {
+    for (let i = 1; i <= totalCount; i++) {
       if (field.prime) {
         // i * lambda[i] * x^(i-1), where `i` is repeated addition.
         let mult = 0;
@@ -7211,218 +7229,3244 @@ const __reexport3 = __require("qr/tables.js"); __exports.validateTables = __reex
 
 };
 
-__modules["render/options.js"] = function (__require, __exports) {
+__modules["aztec/high-level.js"] = function (__require, __exports) {
 /**
- * Shared render options, normalised once so every backend agrees.
+ * Aztec high-level stream writer.
  *
- * @module render/options
+ * 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 { BitMatrix } = __require("core/bit-matrix.js");
+const { BitWriter } = __require("core/bit-buffer.js");
+const { EncodeError } = __require("core/errors.js");
 
-/**
- * @typedef {object} RenderOptions
- * @property {number} [scale] Pixels per module. Default 8.
- * @property {number} [margin] Quiet-zone modules on every side. Default 4.
- * @property {string} [dark] Colour of set modules. Default '#000000'.
- * @property {string} [light] Colour of clear modules, or 'none' for transparent.
- * @property {number} [barHeight] For 1D symbols: total bar height in pixels.
- */
+/** 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;
 
 /**
- * Expand and pad the matrix, and resolve every dimension.
- *
- * Linear symbols arrive one module tall. They are stretched to `barHeight`
- * *before* the quiet zone is applied, so the margin ends up uniform on all
- * four sides — padding first would leave a quiet zone one module tall against
- * bars a hundred pixels tall, which no scanner would accept.
+ * Convert accepted public input to its encoded octets.
  *
- * @param {BitMatrix} matrix
- * @param {RenderOptions} options
+ * @param {string|ArrayBuffer|ArrayBufferView} value
+ * @param {'utf-8'} [charset]
+ * @returns {Uint8Array}
  */
-function normalizeOptions(matrix, options = {}) {
-  const scale = Math.max(1, Math.floor(options.scale ?? 8));
-  const margin = Math.max(0, Math.floor(options.margin ?? 4));
-  const dark = options.dark ?? '#000000';
-  const light = options.light ?? '#ffffff';
-  const barHeight = options.barHeight ?? null;
+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');
+}
 
-  let base = matrix;
-  const is1D = matrix.height === 1;
+/** @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;
+}
 
-  if (is1D) {
-    // Default to a bar height that stays scannable: tall enough that a laser
-    // crossing at a slight angle still passes through the whole symbol.
-    const targetPixels = barHeight ?? Math.max(40, Math.round(matrix.width * scale * 0.15));
-    const rows = Math.max(1, Math.round(targetPixels / scale));
-    base = new BitMatrix(matrix.width, rows);
-    for (let x = 0; x < matrix.width; x++) {
-      if (!matrix.get(x, 0)) continue;
-      for (let y = 0; y < rows; y++) base.set(x, y);
-    }
+/** 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;
   }
+}
 
-  const source = margin > 0 ? base.withMargin(margin) : base;
+/** @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);
+}
 
-  return {
-    scale,
-    margin,
-    dark,
-    light,
-    is1D,
-    source,
-    rowHeight: scale,
-    pixelWidth: source.width * scale,
-    pixelHeight: source.height * scale,
-  };
+/** @param {number} mode @returns {number} */
+function characterWidth(mode) {
+  return mode === HIGH_LEVEL_MODE.DIGIT ? 4 : 5;
 }
 
 /**
- * Parse a CSS colour into RGBA bytes.
+ * Write an Aztec binary-shift segment while in UPPER mode.
  *
- * Supports the forms a barcode actually needs: #rgb, #rgba, #rrggbb,
- * #rrggbbaa, rgb(), rgba(), plus 'none' and 'transparent'.
+ * 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 {string} colour
- * @returns {[number, number, number, number]}
+ * @param {BitWriter} writer
+ * @param {Uint8Array} bytes
+ * @param {number} start
+ * @param {number} length
  */
-function parseColor(colour) {
-  const value = String(colour).trim().toLowerCase();
-
-  if (value === 'none' || value === 'transparent') return [0, 0, 0, 0];
-  if (value === 'white') return [255, 255, 255, 255];
-  if (value === 'black') return [0, 0, 0, 255];
-
-  if (value[0] === '#') {
-    const hex = value.slice(1);
-    const expand = (c) => parseInt(c + c, 16);
-    if (hex.length === 3) {
-      return [expand(hex[0]), expand(hex[1]), expand(hex[2]), 255];
-    }
-    if (hex.length === 4) {
-      return [expand(hex[0]), expand(hex[1]), expand(hex[2]), expand(hex[3])];
-    }
-    if (hex.length === 6) {
-      return [
-        parseInt(hex.slice(0, 2), 16),
-        parseInt(hex.slice(2, 4), 16),
-        parseInt(hex.slice(4, 6), 16),
-        255,
-      ];
-    }
-    if (hex.length === 8) {
-      return [
-        parseInt(hex.slice(0, 2), 16),
-        parseInt(hex.slice(2, 4), 16),
-        parseInt(hex.slice(4, 6), 16),
-        parseInt(hex.slice(6, 8), 16),
-      ];
+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;
   }
+}
 
-  const fn = value.match(/^rgba?\(([^)]+)\)$/);
-  if (fn) {
-    const parts = fn[1].split(/[,/\s]+/).filter(Boolean);
-    const channel = (s) => (s.endsWith('%')
-      ? Math.round((parseFloat(s) / 100) * 255)
-      : Math.round(parseFloat(s)));
-    const r = channel(parts[0]);
-    const g = channel(parts[1]);
-    const b = channel(parts[2]);
-    let a = 255;
-    if (parts.length > 3) {
-      a = parts[3].endsWith('%')
-        ? Math.round((parseFloat(parts[3]) / 100) * 255)
-        : Math.round(parseFloat(parts[3]) * 255);
+/**
+ * Build a valid Aztec high-level bitstream.
+ *
+ * @param {string|ArrayBuffer|ArrayBufferView} value
+ * @param {{charset?: 'utf-8'}} [options]
+ * @returns {BitWriter}
+ */
+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 [r, g, b, a];
   }
-
-  // Unrecognised: fall back to opaque black rather than throwing, so an
-  // unusual colour never costs someone a barcode.
-  return [0, 0, 0, 255];
+  return writer;
 }
 
-__exports.normalizeOptions = normalizeOptions;
-__exports.parseColor = parseColor;
+__exports.HIGH_LEVEL_MODE = HIGH_LEVEL_MODE;
+__exports.MAX_BINARY_SHIFT = MAX_BINARY_SHIFT;
+__exports.aztecBytes = aztecBytes;
+__exports.writeBinaryShift = writeBinaryShift;
+__exports.encodeHighLevel = encodeHighLevel;
 };
 
-__modules["render/svg.js"] = function (__require, __exports) {
+__modules["aztec/tables.js"] = function (__require, __exports) {
 /**
- * SVG output.
+ * Aztec Code layer geometry and Reed-Solomon parameters.
  *
- * Dark modules are emitted as a single `<path>` with horizontal runs merged,
- * not as one `<rect>` per module. A version 40 QR symbol has 31329 modules; the
- * naive rendering is a megabyte of XML that browsers choke on, while the merged
- * path is a few kilobytes and draws identically.
+ * `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.
  *
- * @module render/svg
+ * 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 { normalizeOptions } = __require("render/options.js");
+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];
+}
 
 /**
- * @param {string} value
- * @returns {string}
+ * 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 escapeAttr(value) {
-  return String(value)
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;');
+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;
 }
 
 /**
- * Render to an SVG document.
+ * Choose the first symbol which holds an already stuffed payload.
  *
- * @param {import('../core/bit-matrix.js').BitMatrix} matrix
- * @param {import('./options.js').RenderOptions} [options]
- * @returns {string}
+ * `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 toSVG(matrix, options = {}) {
-  const opts = normalizeOptions(matrix, options);
-  const { scale, source, pixelWidth, pixelHeight, rowHeight } = opts;
+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');
+  }
 
-  let path = '';
-  for (let y = 0; y < source.height; y++) {
-    let x = 0;
-    while (x < source.width) {
-      if (!source.get(x, y)) { x++; continue; }
-      let run = 1;
-      while (x + run < source.width && source.get(x + run, y)) run++;
-      // Relative horizontal-vertical path commands: shorter than rects and
-      // free of the seams that appear between adjacent rects at some zooms.
-      path += `M${x * scale} ${y * rowHeight}h${run * scale}v${rowHeight}h${-run * scale}z`;
-      x += run;
+  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;
+  }
+
+  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 });
     }
   }
 
-  const bg = opts.light === 'none'
-    ? ''
-    : `<rect width="${pixelWidth}" height="${pixelHeight}" fill="${escapeAttr(opts.light)}"/>`;
+  throw new RangeError('Aztec: payload and requested error correction do not fit an available symbol');
+}
 
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${pixelWidth}" height="${pixelHeight}" ` +
-    `viewBox="0 0 ${pixelWidth} ${pixelHeight}" shape-rendering="crispEdges">` +
-    bg +
-    `<path d="${path}" fill="${escapeAttr(opts.dark)}"/>` +
-    '</svg>';
+/** 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;
 }
 
+__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;
+};
+
+__modules["aztec/encoder.js"] = function (__require, __exports) {
 /**
- * Base64 that works identically in Node and the browser.
+ * Aztec encoder: high-level bits, bit stuffing, Reed-Solomon and matrix layout.
  *
- * `btoa` is byte-oriented, so the UTF-8 encoding has to happen first — passing
- * it a string with any character above U+00FF throws.
+ * `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.
  *
- * @param {string} text
- * @returns {string}
+ * @module aztec/encoder
  */
-function toBase64(text) {
-  const bytes = new TextEncoder().encode(text);
-  let binary = '';
-  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
-  if (typeof btoa === 'function') return btoa(binary);
-  // Node before btoa was global, and non-browser embedders.
-  /* eslint-disable-next-line no-undef */
+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");
+
+/** @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;
+}
+
+/** @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);
+    }
+  }
+}
+
+/**
+ * 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);
+
+  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`);
+
+  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;
+}
+
+/** @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];
+}
+
+/**
+ * Encode a UTF-8 string or bytes into an Aztec Code matrix.
+ *
+ * @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 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');
+}
+
+__exports.stuffBits = stuffBits;
+__exports.addCheckWords = addCheckWords;
+__exports.modeMessage = modeMessage;
+__exports.buildAztecMatrix = buildAztecMatrix;
+__exports.encodeAztec = encodeAztec;
+};
+
+__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");
+
+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 };
+
+/** @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);
+}
+
+/** @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;
+}
+
+/** @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 };
+}
+
+/** @param {boolean} compact @param {number} layers */
+function totalBitsInLayers(compact, layers) {
+  return ((compact ? 88 : 112) + 16 * layers) * layers;
+}
+
+/**
+ * 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 {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @returns {{text: string, bytes: Uint8Array, compact: boolean, layers: number, corrections: number, eccPercent: number}}
+ */
+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) {
+/**
+ * Aztec image detection.
+ *
+ * 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.
+ *
+ * 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
+ */
+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);
+}
+
+function expectedDark(ring, inverted) {
+  return inverted ? (ring & 1) === 1 : (ring & 1) === 0;
+}
+
+/** 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;
+}
+
+function rotateCorners(corners, turn) {
+  return corners.slice(turn).concat(corners.slice(0, turn));
+}
+
+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;
+}
+
+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. */ }
+          }
+        }
+      }
+    }
+  }
+  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;
+}
+
+/**
+ * Detect then decode an Aztec symbol. Detection failure is a normal result for
+ * images without an Aztec code, therefore invalid candidates return null.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @returns {(import('./decoder.js').DecodeResult & {corners: Point[]}) | null}
+ */
+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;
+
+
+};
+
+__modules["pdf417/compaction.js"] = function (__require, __exports) {
+/** PDF417 high-level text, byte and numeric compaction. @module pdf417/compaction */
+const { EncodeError, FormatError } = __require("core/errors.js");
+
+const ALPHA = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ ';
+const LOWER = 'abcdefghijklmnopqrstuvwxyz ';
+const MIXED = '0123456789&\r\t,:#-.$/+%*=^';
+const PUNCT = ';<>@[\\]_`~!\r\t,:\n-.$/"|*()?{}\'';
+
+function packBase30(values) {
+  const out = [];
+  for (let i = 0; i < values.length; i += 2) out.push(values[i] * 30 + (i + 1 < values.length ? values[i + 1] : 29));
+  return out;
+}
+
+/** Compact a value using the PDF417 Text Compaction alphabet. */
+function compactPdf417Text(value) {
+  if (typeof value !== 'string') throw new EncodeError('PDF417 text: value must be a string');
+  const values = [];
+  let submode = 'alpha';
+  for (const character of value) {
+    const inAlpha = ALPHA.indexOf(character), inLower = LOWER.indexOf(character);
+    const inMixed = MIXED.indexOf(character), inPunct = PUNCT.indexOf(character);
+    if (submode === 'alpha') {
+      if (inAlpha >= 0) values.push(inAlpha);
+      else if (inLower >= 0) { values.push(27, inLower); submode = 'lower'; }
+      else if (inMixed >= 0 || character === ' ') { values.push(28, character === ' ' ? 26 : inMixed); submode = 'mixed'; }
+      else if (inPunct >= 0) values.push(29, inPunct);
+      else throw new EncodeError(`PDF417 text: unsupported character ${JSON.stringify(character)}`);
+    } else if (submode === 'lower') {
+      if (inLower >= 0) values.push(inLower);
+      else if (inAlpha >= 0) values.push(27, inAlpha);
+      else if (inMixed >= 0 || character === ' ') { values.push(28, character === ' ' ? 26 : inMixed); submode = 'mixed'; }
+      else if (inPunct >= 0) values.push(29, inPunct);
+      else throw new EncodeError(`PDF417 text: unsupported character ${JSON.stringify(character)}`);
+    } else {
+      if (inMixed >= 0) values.push(inMixed);
+      else if (character === ' ') values.push(26);
+      else if (inAlpha >= 0) { values.push(28); submode = 'alpha'; values.push(inAlpha); }
+      else if (inLower >= 0) { values.push(27); submode = 'lower'; values.push(inLower); }
+      else if (inPunct >= 0) values.push(29, inPunct);
+      else throw new EncodeError(`PDF417 text: unsupported character ${JSON.stringify(character)}`);
+    }
+  }
+  return packBase30(values);
+}
+
+function asBytes(value) {
+  if (value instanceof Uint8Array) return value;
+  if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  if (typeof value === 'string') return new TextEncoder().encode(value);
+  throw new EncodeError('PDF417 byte: value must be text or a byte array');
+}
+
+/** Compact bytes using latch 924 for exact six-byte blocks and 901 otherwise. */
+function compactPdf417Bytes(value) {
+  const bytes = asBytes(value);
+  const utf8 = typeof value === 'string' && /[^\x00-\x7f]/.test(value);
+  const out = utf8 ? [927, 26] : [];
+  out.push(bytes.length > 0 && bytes.length % 6 === 0 ? 924 : 901);
+  let at = 0;
+  while (at + 6 <= bytes.length) {
+    let number = 0n;
+    for (let i = 0; i < 6; i++) number = (number << 8n) | BigInt(bytes[at++]);
+    const group = new Array(5);
+    for (let i = 4; i >= 0; i--) { group[i] = Number(number % 900n); number /= 900n; }
+    out.push(...group);
+  }
+  while (at < bytes.length) out.push(bytes[at++]);
+  return out;
+}
+
+/** Compact decimal digits using latch 902 and groups of at most 44 digits. */
+function compactPdf417Numeric(value) {
+  if (typeof value !== 'string' || !/^\d+$/.test(value)) throw new EncodeError('PDF417 numeric: value must contain decimal digits only');
+  const out = [902];
+  for (let at = 0; at < value.length; at += 44) {
+    let number = BigInt(`1${value.slice(at, at + 44)}`);
+    const group = [];
+    do { group.unshift(Number(number % 900n)); number /= 900n; } while (number > 0n);
+    out.push(...group);
+  }
+  return out;
+}
+
+/** Compact a single value, selecting text, numeric or byte mode. */
+function compactPdf417(value, options = {}) {
+  const mode = options.compaction ?? 'auto';
+  if (mode === 'text') return compactPdf417Text(value);
+  if (mode === 'byte') return compactPdf417Bytes(value);
+  if (mode === 'numeric') return compactPdf417Numeric(value);
+  if (mode !== 'auto') throw new EncodeError(`PDF417: unsupported compaction mode ${JSON.stringify(mode)}`);
+  if (typeof value === 'string' && /^\d{13,}$/.test(value)) return compactPdf417Numeric(value);
+  if (typeof value === 'string') {
+    try { return compactPdf417Text(value); } catch (error) { if (!(error instanceof EncodeError)) throw error; }
+  }
+  return compactPdf417Bytes(value);
+}
+
+function assertCodeword(codeword) {
+  if (!Number.isInteger(codeword) || codeword < 0 || codeword > 928) throw new FormatError('PDF417: codeword is outside 0..928');
+}
+
+function decodeUtf8(bytes, eci) {
+  if (eci === 3) return Array.from(bytes, (byte) => String.fromCharCode(byte)).join('');
+  if (eci !== 26) throw new FormatError(`PDF417 ECI: unsupported assignment number ${eci}`);
+  try { return new TextDecoder('utf-8', { fatal: true }).decode(new Uint8Array(bytes)); }
+  catch { throw new FormatError('PDF417 byte: invalid UTF-8 sequence'); }
+}
+
+function decodeByteSegment(codewords, at, eci, sixOnly = false) {
+  const values = [];
+  while (at < codewords.length && codewords[at] < 900) values.push(codewords[at++]);
+  if (sixOnly && values.length % 5) throw new FormatError('PDF417 byte: 924 segment must contain complete six-byte groups');
+  const bytes = [];
+  // In 901 mode an encoder can use five terminal literal codewords. The
+  // unambiguous groups are therefore the ones followed by another codeword;
+  // 924 is available whenever a segment consists exclusively of six-byte groups.
+  const groupCount = sixOnly ? values.length / 5 : Math.max(0, Math.floor((values.length - 1) / 5));
+  for (let groupAt = 0; groupAt < groupCount * 5; groupAt += 5) {
+    let number = 0n;
+    for (let i = 0; i < 5; i++) number = number * 900n + BigInt(values[groupAt + i]);
+    const group = new Uint8Array(6);
+    for (let i = 5; i >= 0; i--) { group[i] = Number(number & 255n); number >>= 8n; }
+    if (number !== 0n) throw new FormatError('PDF417 byte: base-900 group exceeds six bytes');
+    bytes.push(...group);
+  }
+  for (let i = groupCount * 5; i < values.length; i++) {
+    if (values[i] > 255) throw new FormatError('PDF417 byte: literal tail is outside 0..255');
+    bytes.push(values[i]);
+  }
+  return { at, text: decodeUtf8(bytes, eci), bytes: Uint8Array.from(bytes) };
+}
+
+function decodeTextSegment(codewords, at, eci) {
+  let mode = 'alpha';
+  let output = '';
+  let shift = null;
+  let shiftedBytes = [];
+  const bytes = [];
+  const flushShiftedBytes = () => {
+    if (shiftedBytes.length) {
+      output += decodeUtf8(shiftedBytes, eci);
+      bytes.push(...shiftedBytes);
+      shiftedBytes = [];
+    }
+  };
+  const emit = (alphabet, value) => {
+    if (value < 0 || value >= alphabet.length) throw new FormatError('PDF417 text: invalid submode value');
+    output += alphabet[value];
+  };
+  const process = (value) => {
+    if (shift) { emit(shift === 'alpha' ? ALPHA : PUNCT, value); shift = null; return; }
+    if (mode === 'alpha') {
+      if (value < 26) emit(ALPHA, value);
+      else if (value === 26) output += ' ';
+      else if (value === 27) mode = 'lower';
+      else if (value === 28) mode = 'mixed';
+      else if (value === 29) shift = 'punct';
+    } else if (mode === 'lower') {
+      if (value < 26) emit(LOWER, value);
+      else if (value === 26) output += ' ';
+      else if (value === 27) shift = 'alpha';
+      else if (value === 28) mode = 'mixed';
+      else if (value === 29) shift = 'punct';
+    } else if (mode === 'mixed') {
+      if (value < 25) emit(MIXED, value);
+      else if (value === 25) mode = 'punct';
+      else if (value === 26) output += ' ';
+      else if (value === 27) mode = 'lower';
+      else if (value === 28) mode = 'alpha';
+      else if (value === 29) shift = 'punct';
+    } else {
+      if (value < 29) emit(PUNCT, value);
+      else if (value === 29) mode = 'alpha';
+    }
+  };
+  while (at < codewords.length) {
+    const codeword = codewords[at];
+    if (codeword >= 900 && codeword !== 913) break;
+    at++;
+    if (codeword === 913) {
+      if (at >= codewords.length || codewords[at] > 255) throw new FormatError('PDF417 text: invalid byte shift');
+      shiftedBytes.push(codewords[at++]);
+      continue;
+    }
+    flushShiftedBytes();
+    process(Math.floor(codeword / 30));
+    process(codeword % 30);
+  }
+  flushShiftedBytes();
+  return { at, text: output, bytes: Uint8Array.from(bytes) };
+}
+
+function decodeNumericSegment(codewords, at) {
+  let output = '';
+  while (at < codewords.length && codewords[at] < 900) {
+    const end = Math.min(at + 15, codewords.length);
+    let number = 0n;
+    for (; at < end && codewords[at] < 900; at++) number = number * 900n + BigInt(codewords[at]);
+    const decimal = number.toString();
+    if (!decimal.startsWith('1')) throw new FormatError('PDF417 numeric: missing leading sentinel');
+    output += decimal.slice(1);
+  }
+  return { at, text: output, bytes: new Uint8Array(0) };
+}
+
+/**
+ * Decode PDF417 compaction while preserving raw Byte Compaction and byte-shift
+ * payloads. Text and Numeric Compaction do not manufacture bytes: their text
+ * is available on each segment, while `bytes` contains only octets carried by
+ * modes that encode octets explicitly.
+ */
+function decodePdf417CompactionDetailed(codewords) {
+  if (!Array.isArray(codewords) && !ArrayBuffer.isView(codewords)) throw new FormatError('PDF417: codewords must be an array');
+  for (const codeword of codewords) assertCodeword(codeword);
+  let at = 0;
+  // ISO/IEC 8859-1 is the PDF417 default; UTF-8 is selected explicitly with ECI 26.
+  let eci = 3;
+  let output = '';
+  const bytes = [];
+  const segments = [];
+  while (at < codewords.length) {
+    const codeword = codewords[at];
+    if (codeword < 900 || codeword === 900 || codeword === 913) {
+      const start = at;
+      const latch = codeword === 900 ? codeword : null;
+      if (latch !== null) at++;
+      const segment = decodeTextSegment(codewords, at, eci);
+      at = segment.at;
+      output += segment.text;
+      bytes.push(...segment.bytes);
+      if (segment.text.length || segment.bytes.length) segments.push({ mode: 'text', text: segment.text, bytes: segment.bytes, eci, latch, codewordStart: start, codewordEnd: at });
+      continue;
+    }
+    const start = at;
+    at++;
+    if (codeword === 901) {
+      const segment = decodeByteSegment(codewords, at, eci);
+      at = segment.at;
+      output += segment.text;
+      bytes.push(...segment.bytes);
+      segments.push({ mode: 'byte', text: segment.text, bytes: segment.bytes, eci, latch: codeword, codewordStart: start, codewordEnd: at });
+    } else if (codeword === 924) {
+      const segment = decodeByteSegment(codewords, at, eci, true);
+      at = segment.at;
+      output += segment.text;
+      bytes.push(...segment.bytes);
+      segments.push({ mode: 'byte', text: segment.text, bytes: segment.bytes, eci, latch: codeword, codewordStart: start, codewordEnd: at });
+    } else if (codeword === 902) {
+      const segment = decodeNumericSegment(codewords, at);
+      at = segment.at;
+      output += segment.text;
+      segments.push({ mode: 'numeric', text: segment.text, bytes: segment.bytes, eci, latch: codeword, codewordStart: start, codewordEnd: at });
+    } else if (codeword === 927) {
+      if (at >= codewords.length || codewords[at] > 899) throw new FormatError('PDF417 ECI: missing assignment number');
+      eci = codewords[at++];
+    } else {
+      throw new FormatError(`PDF417: unsupported compaction codeword ${codeword}`);
+    }
+  }
+  return { text: output, bytes: Uint8Array.from(bytes), segments };
+}
+
+/** Decode PDF417 Text, Byte, Numeric and UTF-8 ECI compaction segments in source order. */
+function decodePdf417Compaction(codewords) {
+  return decodePdf417CompactionDetailed(codewords).text;
+}
+
+__exports.compactPdf417Text = compactPdf417Text;
+__exports.compactPdf417Bytes = compactPdf417Bytes;
+__exports.compactPdf417Numeric = compactPdf417Numeric;
+__exports.compactPdf417 = compactPdf417;
+__exports.decodePdf417CompactionDetailed = decodePdf417CompactionDetailed;
+__exports.decodePdf417Compaction = decodePdf417Compaction;
+};
+
+__modules["pdf417/error-correction.js"] = function (__require, __exports) {
+const { EncodeError } = __require("core/errors.js");
+const { GF929 } = __require("core/galois-field.js");
+const { rsDecode, rsEncode } = __require("core/reed-solomon.js");
+function pdf417EccLength(level) {
+  if (!Number.isInteger(level) || level < 0 || level > 8) throw new EncodeError('PDF417: error correction level must be in 0..8');
+  return 1 << (level + 1);
+}
+function pdf417ErrorCorrection(data, level) {
+  return rsEncode(data, pdf417EccLength(level), GF929, 1);
+}
+
+/** Correct PDF417 codewords, optionally marking unreadable codewords as erasures. */
+function pdf417CorrectErrors(codewords, level, erasures = []) {
+  return rsDecode(codewords, pdf417EccLength(level), GF929, 1, erasures);
+}
+
+__exports.pdf417EccLength = pdf417EccLength;
+__exports.pdf417ErrorCorrection = pdf417ErrorCorrection;
+__exports.pdf417CorrectErrors = pdf417CorrectErrors;
+};
+
+__modules["pdf417/tables.js"] = function (__require, __exports) {
+/** PDF417 symbol-character pattern table. @module pdf417/tables */
+const PDF417_CLUSTER_NUMBERS = Object.freeze([0, 3, 6]);
+const PDF417_CODEWORDS_PER_CLUSTER = 929;
+
+// Transcribed from the normative AIM USS PDF417 specification, Appendix H,
+// Table H1 (Bar-Space Sequence Table), from a publicly accessible copy hosted
+// at https://expresscorp.com/wp-content/uploads/2023/02/USS-PDF-417.pdf.
+// ISO/IEC 15438:2015 is the current ISO specification for PDF417.
+// Each eight-digit sequence is ordered bar, space, bar, space, bar, space,
+// bar, space and is indexed by its codeword value from 0 through 928.
+const WIDTH_SEQUENCES = Object.freeze([
+  '3111113641111144511111523111123541111243511112512111132631111334211114251111151621111524111116152111213631112144' +
+  '4111215221112235311122434111225111112326211123341111242511113136211131443111315211113235211132433111325111113334' +
+  '2111334211114144211141521111424321114251111151525111611131121135411211435112115121121226311212344112124221121325' +
+  '3112133311121416211214243112143211121515211215231112161421122135311221434112215111122226211222343112224211122325' +
+  '2112233331122341111224242112243211123135211231433112315111123234211232421112333321123341111241432112415111124242' +
+  '1112434121131126311311344113114221131225311312334113124111131316211313243113133211131415211314231113151411131613' +
+  '1113212621132134311321421113222521132233311322411113232421132332111324231113252211133134211331421113323321133241' +
+  '1113333211134142211411253114113341141141111412162114122431141232111413152114132331141331111414142114142211141513' +
+  '2114152111142125211421333114214111142224211422321114232321142331111424221114252121143141111433311115111621151124' +
+  '3115113211151215211512233115123111151314211513221115141321151421111515121115212411152223111523221116111531161131' +
+  '2116122221161321111615113211113542111143521111512211122632111234421112422211132532111333421113411211141622111424' +
+  '1211151522112135321121434211215112112226221122343211224212112325221123331211242412112523121131352211314332113151' +
+  '1211323422113242121133331211343212114143221141511211424212115151312111264121113451211142312112254121123351211241' +
+  '2121131631211324412113322121141531211423412114312121151431211522221211263212113442121142212121262212122532121233' +
+  '4212124121212225312122334121224111212316121214152212142332121431112124152121242311212514121221262212213432122142' +
+  '1121312612122225221222333212224111213225212132333121324111213324121224231121342312123134221231421121413412123233' +
+  '2212324111214233212142411121433212124142112151421212424111215241312211254122113351221141212212163122122441221232' +
+  '2122131531221323412213312122141431221422212215132122161222131125321311334213114121222125221312243213123211222216' +
+  '1213131531222232321313311122231512131414221314221122241421222422221315211213161212132125221321333213214111223125' +
+  '1213222422132232112232242122323222132331112233231213242212132521121331332213314111224133121332321122423212133331' +
+  '1122433111225141212311163123112441231132212312153123122341231231212313143123132221231413312314212123151221231611' +
+  '1214111622141124321411321123211612141215221412233214123111232215212322233123223111232314121414132214142111232413' +
+  '2123242111232512121421242214213211233124121422232214223111233223212332311123332212142421112334211123413211234231' +
+  '2124111531241123412411312124121431241222212413133124132121241412212415111215111522151123321511311124211512151214' +
+  '2215122211242214212422222215132111242313121514121124241212151511121521231124312311243222112433213125112231251221' +
+  '2125141122161122121612131125221311252312112524112311112633111134431111422311122533111233131113162311132433111332' +
+  '1311141523111423131115141311161313112126231121343311214213112225231122333311224113112324231123321311242313112522' +
+  '1311313423113142131132332311324113113332131141421311424132211125422111335221114122211216322112244221123222211315' +
+  '3221132342211331222114143221142222211513322115212312112533121133431211412221212523121224331212321221221613121315' +
+  '3221223233121331122123152221232323121422122124141312151312212513131221252312213333122141122131251312222432213141' +
+  '1221322422213232231223311221332313122422122134221312313323123141122141331312323212214232131233311312414112215141' +
+  '3131111641311124513111323131121541311223513112313131131441311322313114134131142131311512222211163222112442221132' +
+  '2131211622221215413121324222123121312215313122234131223121312314222214133222142121312413313124212222161113131116' +
+  '2313112433131132122221161313121523131223331312311131311612222215222222233222223111313215213132233131323123131421' +
+  '1131331412222413222224211131341313131611131321242313213212223124131322232313223111314124122232232222323111314223' +
+  '2131423113132421122234211313313212224132131332311131513212224231313211154132112351321131313212144132122231321313' +
+  '4132132131321412313215112223111532231123422311312132211522231214413221312132221431322222322313212132231322231412' +
+  '2132241222231511213225111314111523141123331411311223211513141214231412221132311512232214222322222314132111323214' +
+  '2132322213141412113233131223241213141511122325111314212323142131122331231314222211324123122332221314232111324222' +
+  '1223332113143131113251313133111441331122313312134133122131331312313314112224111432241122213321142224121332241221' +
+  '2133221331332221213323122224141121332411131511142315112212242114131512132315122111333114122422132224222111333213' +
+  '2133322113151411113333121224241111333411122431221133412211334221413411213134131132251121222512122225131113161113' +
+  '1225211311343113131613111225231124111125141112162411122414111315241113233411133114111414241114221411151324111521' +
+  '1411212524112133341121411411222424112232141123232411233114112422141125211411313324113141141132321411333114114141' +
+  '2321111633211124432111322321121533211223232113143321132223211413332114212321151214121116241211243412113213212116' +
+  '1412121533212132341212311321221523212223332122311321231414121413241214211321241323212421141216111412212424122132' +
+  '1321312414122223241222311321322323213231132133221412242114123132132141321412323113214231323111154231112352311131' +
+  '3231121442311222323113134231132132311412323115112322111533221123223121152322121433221222223122143231222233221321' +
+  '2231231323221412223124122322151122312511141311152413112313222115141312143322213112313115132222142322222224131321' +
+  '1231321422313222141314121231331313222412141315111322251114132123241321311322312314132222123141231322322214132321' +
+  '1231422213223321141331311322413112315131414111145141112241411213514112214141131241411411323211144232112231412114' +
+  '4141212242321221314122134141222131412312323214113141241123231114332311222232211423231213332312212141311422322213' +
+  '3232222121413213314132212323141121413312223224112141341114141114241411221323211414141213241412211232311413232213' +
+  '2323222111414114123232132232322114141411114142132141422113232411114143121414212213233122141422211232412213233221' +
+  '1141512212324221114152214142111351421121414212124142131132331113423311213142211341422121314222123233131131422311' +
+  '2324111333241121223321132324121221423113223322122324131121423212223323112142331114151113241511211324211323242121' +
+  '1233311313242212141513111142411312333212132423111142421212333311114243111324312111425121414312113143211231432211' +
+  '2234211221433112214332111325211212343112114341121143421115111116151112152511122315111314151114131511151215112124' +
+  '1511222315112322151124211511313215113231242111152421121434211222242113133421132124211412242115111512111525121123' +
+  '1421211524212123251212221421221424212222142123132421232114212412151215111421251115122123251221311421312324213131' +
+  '1421322215122321142133211512313114214131333111143331121333311312333114112422111423312114333121223422122123312213' +
+  '3331222123312312242214112331241115131114142221141513121325131221133131141422221315131312133132131422231215131411' +
+  '1331331214222411151321221422312215132221133141221422322113314221424111134241121242411311333211133241211342412121' +
+  '3241221233321311324123112423111334231121233221133332212122413113233222122423131122413212233223112241331115141113' +
+  '2514112114232113242321211332311314232212151413111241411313323212142323111241421213323311151421211423312113324121' +
+  '1241512151511112515112114242111241512112424212114151221133331112324221123333121131513112324222113151321124241112' +
+  '2333211224241211224231122333221121514112',
+  '5111112561111133411112165111122461111232411113155111132361111331411114145111142241111513511115214111161241112125' +
+  '5111213361112141311122164111222451112232311123154111232351112331311124144111242231112513411125213111261231113125' +
+  '4111313351113141211132163111322441113232211133153111332341113331211134143111342221113513311135212111361221114125' +
+  '3111413341114141111142162111422431114232111143152111432331114331111144142111442211114513211145211111512521115133' +
+  '3111514111115224211152321111532321115331111154221111613321116141111162321111633141121116511211246112113241121215' +
+  '5112122361121231411213145112132241121413511214214112151241121611311221164112212451122132311222154112222351122231' +
+  '3112231441122322311224134112242131122512311226112112311631123124411231322112321531123223411232312112331431123322' +
+  '2112341331123421211235122112361111124116211241243112413211124215211242233112423111124314211243221112441321124421' +
+  '1112451211125124211251321112522321125231111253221112542111126132111262314113111551131123611311314113121451131222' +
+  '4113131351131321411314124113151131132115411321235113213131132214411322223113231341132321311324123113251121133115' +
+  '3113312341133131211332143113322221133313311333212113341221133511111341152113412331134131111342142113422211134313' +
+  '2113432111134412111345111113512321135131111352221113532111136131411411145114112241141213511412214114131241141411' +
+  '3114211441142122311422134114222131142312311424112114311431143122211432133114322121143312211434111114411421144122' +
+  '1114421321144221111443121114441111145122111452214115111351151121411512124115131131152113411521213115221231152311' +
+  '2115311331153121211532122115331111154113211541211115421211154311411611124116121131162112311622112116311221163211' +
+  '4211111652111124621111324211121552111223621112314211131452111322421114135211142142111512421116113211211642112124' +
+  '5211213232112215421122235211223132112314421123223211241342112421321125123211261122113116321131244211313222113215' +
+  '3211322342113231221133143211332222113413321134212211351222113611121141162211412432114132121142152211422332114231' +
+  '1211431422114322121144132211442112114512121151242211513212115223221152311211532212115421121161321211623151211115' +
+  '6121112311211164512112146121122211211263512113136121132111211362512114125121151142121115521211236212113141212115' +
+  '4212121461212131412122145121222252121321412123134212141241212412421215114121251132122115421221235212213131213115' +
+  '3212221442122222312132144121322242122321312133133212241231213412321225113121351122123115321231234212313121214115' +
+  '2212321432123222212142143121422232123321212143132212341221214412221235112121451112124115221241233212413111215115' +
+  '1212421422124222112152142121522222124321112153131212441211215412121245111212512322125131112161231212522211216222' +
+  '1212532111216321121261315122111461221122112211635122121361221221112212625122131211221361512214114213111452131122' +
+  '4122211442131213521312214122221351222221412223124213141141222411321321144213212231223114321322134213222131223213' +
+  '4122322131223312321324113122341122133114321331222122411422133213321332212122421331224221212243122213341121224411' +
+  '1213411422134122112251141213421322134221112252132122522111225312121344111122541112135122112261221213522111226221' +
+  '5123111361231121112311625123121211231261512313114214111352141121412321135123212141232212421413114123231132142113' +
+  '4214212131233113321422123123321232142311312333112214311332143121212341133123412121234212221433112123431112144113' +
+  '2214412111235113121442121123521212144311112353111214512111236121512411121124116151241211421511124124211242151211' +
+  '4124221132152112312431123215221131243211221531122124411222153211212442111215411211245112121542111124521151251111' +
+  '4216111141252111321621113125311122163111212541114311111553111123631111314311121453111222431113135311132143111412' +
+  '4311151133112115431121235311213133112214431122223311231343112321331124123311251123113115331131234311313123113214' +
+  '3311322223113313331133212311341223113511131141152311412333114131131142142311422213114313231143211311441213114511' +
+  '1311512323115131131152221311532113116131522111146221112212211163522112136221122112211262522113121221136152211411' +
+  '4312111453121122422121144312121353121221422122135221222142212312431214114221241133122114431221223221311433122213' +
+  '4312222132213213422132213221331233122411322134112312311433123122222141142312321333123221222142133221422122214312' +
+  '2312341122214411131241142312412212215114131242132312422112215213222152211221531213124411122154111312512212216122' +
+  '1312522112216221613111131131115421311162613112121131125321311261613113111131135211311451522211136222112112221162' +
+  '5131211361312121113121621222126151312212522213111131226151312311431311135313112142222113431312124131311351313121' +
+  '4313131141313212422223114131331133132113431321213222311333132212313141133222321233132311313142123222331131314311' +
+  '2313311333133121222241132313321221315113222242122313331121315212222243112131531113134113231341211222511313134212' +
+  '1131611312225212131343111131621212225311113163111313512112226121613211121132115321321161613212111132125211321351' +
+  '5223111212231161513221125223121111322161513222114314111242232112431412114132311242232211413232113314211232233112' +
+  '3314221131324112322332113132421123143112222341122314321121325112222342112132521113144112122351121314421111326112' +
+  '1223521111326211613311111133115211331251522411115133211143151111422421114133311133152111322431113133411123153111' +
+  '2224411121335111131541111224511111336111113411514411111454111122441112135411122144111312441114113411211444112122' +
+  '3411221344112221341123123411241124113114341131222411321334113221241133122411341114114114241141221411421324114221' +
+  '1411431214114411141151221411522153211113632111211321116253211212132112615321131144121113541211214321211344121212' +
+  '4321221244121311432123113412211344122121332131133412221233213212341223113321331124123113341231212321411324123212' +
+  '2321421224123311232143111412411324124121132151131412421213215212141243111321531114125121132161216231111212311153' +
+  '2231116162311211123112521231135153221112132211615231211253221211123121615231221144131112432221124413121142313112' +
+  '4322221142313211341321123322311234132211323141123322321132314211241331122322411224133211223151122322421122315211' +
+  '1413411213225112141342111231611213225211123162111141114421411152114112432141125111411342114114416232111112321152' +
+  '6141211111412152123212511141225153231111523221115141311144141111432321114232311141414111341421113323311132324111' +
+  '3141511124143111232341112232511121416111141441111323511112326111114211432142115111421242114213411233115111422151' +
+  '1143114211431241114411414511111345111212451113113511211345112121351122123511231125113113351131212511321225113311' +
+  '1511411325114121151142121511431115115121542111121421116154211211451211124421211245121211442122113512211234213112' +
+  '3512221134213211251231122421411225123211242142111512411214215112151242111421521163311111133111521331125154221111' +
+  '5331211145131111442221114331311135132111342231113331411125133111242241112331511115134111142251111331611112411143' +
+  '2241115112411242124113411332115112412151115111342151114211511233215112411151133211511431124211421151214212421241' +
+  '1151224111521133215211411152123211521331124311411152214111531132115312311154113136112112361122112611311226113211' +
+  '1611411216114211452121113612211135213111261231112521411116124111152151111431115113411142134112411251113322511141' +
+  '1251123212511331134211411251214111611124216111321161122321611231116113221161142112521132116121321252123111612231' +
+  '1162112321621131116212221162132112531131116221311163112211631221144111411351113213511231126111232261113112611222' +
+  '1261132113521131126121311262112212621221',
+  '2111115531111163111112462111125431111262111113452111135331111361111114442111145211111543611121141111215521112163' +
+  '6111221311112254211122626111231211112353211123616111241111112452511131146111312211113163511132136111322111113262' +
+  '5111331211113361511134114111411451114122411142135111422141114312411144113111511441115122311152134111522131115312' +
+  '3111541121116114311161222111621331116221211163121112114621121154311211621112124521121253311212611112134421121352' +
+  '1112144321121451111215426112211311122154211221626112221211122253211222616112231111122352111224515112311361123121' +
+  '1112316251123212111232615112331141124113511241214112421241124311311251134112512131125212311253112112611331126121' +
+  '2112621221126311111311452113115331131161111312442113125211131343211313511113144211131541611321121113215321132161' +
+  '6113221111132252111323515113311211133161511332114113411241134211311351123113521121136112211362111114114421141152' +
+  '1114124321141251111413421114144161142111111421521114225151143111411441113114511111151143211511511115124211151341' +
+  '1115215111161142111612411211114622111154321111621211124522111253321112611211134422111352121114432211145112111542' +
+  '6211211312112154221121626211221212112253221122616211231112112352121124515211311362113121121131625211321212113261' +
+  '5211331142114113521141214211421242114311321151134211512132115212321153112211611332116121221162122211631121211145' +
+  '3121115341211161112112362121124431211252112113352121134331211351112114342121144211211533212115411121163212121145' +
+  '2212115332121161112121451212124422121252112122442121225222121351112123431212144211212442121215411121254162122112' +
+  '1212215322122161612131126212221111213153121222526121321111213252121223511121335152123112121231615121411252123211' +
+  '1121416151214211421241124121511242124211412152113212511231216112321252113121621122126112221262111122113621221144' +
+  '3122115211221235212212433122125111221334212213421122143321221441112215321122163112131144221311521122214412131243' +
+  '2213125111222243212222511122234212131441112224416213211112132152612231111122315212132251112232515213311151224111' +
+  '4213411141225111321351113122611122136111112311352123114331231151112312342123124211231333212313411123143211231531' +
+  '1214114322141151112321431214124211232242121413411123234112142151112331511124113421241142112412332124124111241332' +
+  '1124143112151142112421421215124111242241112511332125114111251232112513311216114111252141112611321126123113111145' +
+  '2311115333111161131112442311125213111343231113511311144213111541631121121311215323112161631122111311225213112351' +
+  '5311311213113161531132114311411243114211331151123311521123116112231162111221113622211144322111521221123522211243' +
+  '3221125112211334222113421221143322211441122115321221163113121144231211521221214413121243231212511221224322212251' +
+  '1221234213121441122124416312211113122152622131111221315213122251122132515312311152214111431241114221511133125111' +
+  '3221611123126111213111353131114341311151113112262131123431311242113113252131133331311341113114242131143211311523' +
+  '2131153111311622122211352222114332221151113121351222123422221242113122342131224222221341113123331222143211312432' +
+  '1222153111312531131311432313115112222143131312421131314312222242131313411131324212222341113133411313215112223151' +
+  '1131415111321126213211343132114211321225213212333132124111321324213213321132142321321431113215221132162112231134' +
+  '2223114211322134122312332223124111322233213222411132233212231431113224311314114212232142131412411132314212232241' +
+  '1132324111331125213311333133114111331224213312321133132321331331113314221133152112241133222411411133213312241232' +
+  '1133223212241331113323311315114112242141113331411134112421341132113412232134123111341322113414211225113211342132' +
+  '1225123111342231113511232135113111351222113513211226113111352131113611221136122114111144241111521411124324111251' +
+  '1411134214111441141121521411225154113111441141113411511124116111132111352321114333211151132112342321124213211333' +
+  '2321134113211432132115311412114324121151132121431412124213212242141213411321234114122151132131511231112622311134' +
+  '3231114212311225223112333231124112311324223113321231142322311431123115221231162113221134232211421231213413221233' +
+  '2322124112312233132213321231233213221431123124311413114213222142141312411231314213222241123132412141112531411133' +
+  '4141114111411216214112243141123211411315214113233141133111411414214114221141151321411521114116121232112522321133' +
+  '3232114111412125123212242232123211412224214122322232133111412323123214221141242212321521114125211323113323231141' +
+  '1232213313231232114131331232223213231331114132321232233111413331141411411323214112323141114141411142111621421124' +
+  '3142113211421215214212233142123111421314214213221142141321421421114215121142161112331124223311321142212412331223' +
+  '2233123111422223214222311142232212331421114224211324113212332132132412311142313212332231114232311143111521431123' +
+  '3143113111431214214312221143131321431321114314121143151112341123223411311143212312341222114322221234132111432321' +
+  '1325113112342131114331311144111421441122114412132144122111441312114414111235112211442122123512211144222111451113' +
+  '2145112111451212114513111236112111452121151111432511115115111242151113411511215114211134242111421421123324211241' +
+  '1421133214211431151211421421214215121241142122411331112523311133333111411331122423311232133113232331133113311422' +
+  '1331152114221133242211411331213314221232133122321422133113312331151311411422214113313141124111162241112432411132' +
+  '1241121522411223324112311241131422411322124114132241142112411512124116111332112423321132124121241332122323321231' +
+  '1241222322412231124123221332142112412421142311321332213214231231124131321332223112413231215111153151112341511131' +
+  '2151121431511222215113133151132121511412215115111242111522421123324211311151211512421214224212221151221421512222' +
+  '2242132111512313124214121151241212421511115125111333112323331131124221231333122211513123124222221333132111513222' +
+  '1242232111513321142411311333213112423131115141312152111431521122215212133152122121521312215214111243111422431122' +
+  '1152211412431213224312211152221321522221115223121243141111522411133411221243212213341221115231221243222111523221' +
+  '2153111331531121215312122153131112441113224411211153211312441212115322121244131111532311133511211244212111533121' +
+  '2154111221541211124511121154211212451211115422111611114216111241152111332521114115211232152113311612114115212141' +
+  '1431112424311132143112232431123114311322143114211522113214312132152212311431223113411115234111233341113113411214' +
+  '2341122213411313234113211341141213411511143211232432113113412123234121311341222214321321134123211523113114322131' +
+  '1341313122511114325111222251121332511221225113122251141113421114234211221251211422512122234212211251221313421312' +
+  '1251231213421411125124111433112213422122143312211251312213422221125132213161111341611121316112123161131122521113' +
+  '3252112121612113225212122161221222521311216123111343111323431121125221131343121211613113125222121343131111613212' +
+  '1252231111613311143411211343212112523121116141213162111231621211225311122162211222531211216222111344111212532112' +
+  '1344121111623112125322111162321131631111225411112163211113451111125421111163311116211132162112311531112325311131' +
+  '1531122215311321162211311531213114411114244111221441121324411221144113121441141115321122144121221532122114412221' +
+  '2351111333511121235112122351131114421113244211211351211323512121135122121442131113512311153311211442212113513121' +
+  '3261111232611211235211122261211223521211226122111443111213522112144312111261311213522211126132113262111123531111' +
+  '2262211114441111135321111262311116311122163112211541111325411121154112121541131116321121154121212451111224511211' +
+  '1542111214512112154212111451221133611111',
+]);
+
+function patternFromWidths(sequence) {
+  let pattern = 0;
+  for (let element = 0; element < 8; element++) {
+    const width = sequence.charCodeAt(element) - 48;
+    const dark = (element & 1) === 0;
+    for (let i = 0; i < width; i++) pattern = (pattern << 1) | (dark ? 1 : 0);
+  }
+  return pattern;
+}
+
+/** Return the cluster discriminator for an eight-element bar/space sequence. */
+function pdf417ClusterForWidths(widths) {
+  if (!widths || widths.length !== 8) throw new Error('PDF417: a character requires eight element widths');
+  return ((widths[0] - widths[2] + widths[4] - widths[6]) % 9 + 9) % 9;
+}
+
+function buildPatternTable() {
+  const tables = WIDTH_SEQUENCES.map((source, tableIndex) => {
+    if (source.length !== PDF417_CODEWORDS_PER_CLUSTER * 8) throw new Error('PDF417: corrupt pattern-table length');
+    const expectedCluster = PDF417_CLUSTER_NUMBERS[tableIndex];
+    const table = new Int32Array(PDF417_CODEWORDS_PER_CLUSTER);
+    const seen = new Set();
+    for (let codeword = 0; codeword < PDF417_CODEWORDS_PER_CLUSTER; codeword++) {
+      const sequence = source.slice(codeword * 8, codeword * 8 + 8);
+      const widths = Array.from(sequence, (digit) => digit.charCodeAt(0) - 48);
+      if (widths.some((width) => width < 1 || width > 6) || widths.reduce((sum, width) => sum + width, 0) !== 17) {
+        throw new Error('PDF417: corrupt pattern-table width');
+      }
+      if (pdf417ClusterForWidths(widths) !== expectedCluster) throw new Error('PDF417: corrupt pattern-table cluster');
+      const pattern = patternFromWidths(sequence);
+      if (seen.has(pattern)) throw new Error('PDF417: duplicate pattern in cluster');
+      seen.add(pattern);
+      table[codeword] = pattern;
+    }
+    return Object.freeze(Array.from(table));
+  });
+  return Object.freeze(tables);
+}
+
+/** Pattern table indexed by cluster index (0, 1, 2) and codeword value. */
+const PDF417_PATTERN_TABLE = buildPatternTable();
+const PATTERN_TO_CODEWORD = new Map();
+for (let index = 0; index < PDF417_PATTERN_TABLE.length; index++) {
+  for (let codeword = 0; codeword < PDF417_CODEWORDS_PER_CLUSTER; codeword++) {
+    PATTERN_TO_CODEWORD.set(PDF417_PATTERN_TABLE[index][codeword], Object.freeze({
+      codeword, cluster: PDF417_CLUSTER_NUMBERS[index],
+    }));
+  }
+}
+
+/**
+ * Return the 17-bit bar/space pattern for a codeword in a row cluster.
+ * @param {number} codeword
+ * @param {number} cluster Cluster number 0, 3 or 6.
+ * @returns {number}
+ */
+function pdf417PatternForCodeword(codeword, cluster) {
+  if (!Number.isInteger(codeword) || codeword < 0 || codeword >= PDF417_CODEWORDS_PER_CLUSTER) throw new Error('PDF417: codeword must be in 0..928');
+  const index = PDF417_CLUSTER_NUMBERS.indexOf(cluster);
+  if (index < 0) throw new Error('PDF417: cluster must be 0, 3 or 6');
+  return PDF417_PATTERN_TABLE[index][codeword];
+}
+
+/**
+ * Decode an exact 17-bit symbol-character pattern to its codeword and cluster.
+ * @param {number} pattern
+ * @returns {{codeword: number, cluster: number} | null}
+ */
+function pdf417CodewordForPattern(pattern) {
+  const result = PATTERN_TO_CODEWORD.get(pattern);
+  return result ? { ...result } : null;
+}
+
+__exports.PDF417_CLUSTER_NUMBERS = PDF417_CLUSTER_NUMBERS;
+__exports.PDF417_CODEWORDS_PER_CLUSTER = PDF417_CODEWORDS_PER_CLUSTER;
+__exports.pdf417ClusterForWidths = pdf417ClusterForWidths;
+__exports.PDF417_PATTERN_TABLE = PDF417_PATTERN_TABLE;
+__exports.pdf417PatternForCodeword = pdf417PatternForCodeword;
+__exports.pdf417CodewordForPattern = pdf417CodewordForPattern;
+};
+
+__modules["pdf417/encoder.js"] = function (__require, __exports) {
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { EncodeError } = __require("core/errors.js");
+const { compactPdf417 } = __require("pdf417/compaction.js");
+const { pdf417ErrorCorrection, pdf417EccLength } = __require("pdf417/error-correction.js");
+const { pdf417PatternForCodeword } = __require("pdf417/tables.js");
+
+const START = '81111113';
+const STOP = '711311121';
+
+function append(matrix, y, x, sequence, height) {
+  let dark = true;
+  for (const digit of sequence) {
+    const width = digit.charCodeAt(0) - 48;
+    if (dark) matrix.setRegion(x, y, width, height);
+    x += width; dark = !dark;
+  }
+  return x;
+}
+function patternSequence(pattern) { return pattern.toString(2).padStart(17, '0').replace(/0+|1+/g, (run) => String(run.length)); }
+function indicators(row, rows, cols, level) {
+  const group = Math.floor(row / 3), y = Math.floor((rows - 1) / 3), z = level * 3 + (rows - 1) % 3, v = cols - 1;
+  if (row % 3 === 0) return [30 * group + y, 30 * group + v];
+  if (row % 3 === 1) return [30 * group + z, 30 * group + y];
+  return [30 * group + v, 30 * group + z];
+}
+function dimensions(needed, level, options) {
+  for (const [name, value, min, max] of [['rows', options.rows, 3, 90], ['columns', options.columns, 1, 30]]) {
+    if (value !== undefined && (!Number.isInteger(value) || value < min || value > max)) throw new EncodeError(`PDF417: ${name} must be an integer in ${min}..${max}`);
+  }
+  if (options.aspectRatio !== undefined && (!Number.isFinite(options.aspectRatio) || options.aspectRatio <= 0)) throw new EncodeError('PDF417: aspectRatio must be positive');
+  const ecc = pdf417EccLength(level); let best = null;
+  for (let rows = options.rows ?? 3; rows <= (options.rows ?? 90); rows++) for (let cols = options.columns ?? 1; cols <= (options.columns ?? 30); cols++) {
+    if (rows < 3 || rows * cols > 928 || rows * cols - ecc < needed) continue;
+    const ratio = (69 + cols * 17) / (rows * (options.rowHeight ?? 3));
+    const score = (rows * cols - ecc - needed) * 10 + Math.abs(ratio - (options.aspectRatio ?? 3));
+    if (!best || score < best.score) best = { rows, cols, score };
+  }
+  if (!best) throw new EncodeError('PDF417: payload does not fit the requested dimensions and error correction level');
+  return best;
+}
+function encodePDF417(value, options = {}) {
+  const level = options.eccLevel ?? 2, rowHeight = options.rowHeight ?? 3;
+  if (!Number.isInteger(rowHeight) || rowHeight < 3) throw new EncodeError('PDF417: rowHeight must be an integer of at least 3');
+  const payload = compactPdf417(value, { compaction: options.compaction });
+  const { rows, cols } = dimensions(payload.length + 1, level, { ...options, rowHeight });
+  const eccLength = pdf417EccLength(level), dataLength = rows * cols - eccLength;
+  const data = [dataLength, ...payload]; while (data.length < dataLength) data.push(900);
+  const codewords = data.concat(pdf417ErrorCorrection(data, level));
+  const matrix = new BitMatrix(69 + cols * 17, rows * rowHeight);
+  for (let row = 0; row < rows; row++) {
+    const y = row * rowHeight, cluster = (row % 3) * 3, [left, right] = indicators(row, rows, cols, level);
+    let x = append(matrix, y, 0, START, rowHeight);
+    x = append(matrix, y, x, patternSequence(pdf417PatternForCodeword(left, cluster)), rowHeight);
+    for (let col = 0; col < cols; col++) x = append(matrix, y, x, patternSequence(pdf417PatternForCodeword(codewords[row * cols + col], cluster)), rowHeight);
+    x = append(matrix, y, x, patternSequence(pdf417PatternForCodeword(right, cluster)), rowHeight);
+    append(matrix, y, x, STOP, rowHeight);
+  }
+  matrix.pdf417 = { rows, columns: cols, eccLevel: level, rowHeight, codewords };
+  return matrix;
+}
+
+__exports.encodePDF417 = encodePDF417;
+};
+
+__modules["pdf417/decoder.js"] = function (__require, __exports) {
+const { FormatError } = __require("core/errors.js");
+const { decodePdf417CompactionDetailed } = __require("pdf417/compaction.js");
+const { pdf417CorrectErrors, pdf417EccLength } = __require("pdf417/error-correction.js");
+const { pdf417CodewordForPattern } = __require("pdf417/tables.js");
+
+const START = '11111111010101000';
+const STOP = '111111101000101001';
+function bits(matrix, y, x, width) { let value = 0; for (let i = 0; i < width; i++) value = (value << 1) | (matrix.get(x + i, y) ? 1 : 0); return value; }
+function indicators(row, rows, cols, level) { const group = Math.floor(row / 3), y = Math.floor((rows - 1) / 3), z = level * 3 + (rows - 1) % 3, v = cols - 1; return row % 3 === 0 ? [30 * group + y, 30 * group + v] : row % 3 === 1 ? [30 * group + z, 30 * group + y] : [30 * group + v, 30 * group + z]; }
+function decodePDF417(matrix, options = {}) {
+  if (!matrix?.width || !matrix?.height || (matrix.width - 69) % 17) throw new FormatError('PDF417: invalid matrix dimensions');
+  const cols = (matrix.width - 69) / 17, rowHeight = options.rowHeight ?? matrix.pdf417?.rowHeight ?? 3;
+  if (!Number.isInteger(rowHeight) || matrix.height % rowHeight) throw new FormatError('PDF417: invalid row height');
+  const rows = matrix.height / rowHeight;
+  if (rows < 3 || rows > 90 || cols < 1 || cols > 30) throw new FormatError('PDF417: dimensions outside the standard range');
+  const all = [];
+  const erasures = [];
+  for (let row = 0; row < rows; row++) {
+    const y = row * rowHeight, cluster = (row % 3) * 3;
+    if (bits(matrix, y, 0, 17).toString(2).padStart(17, '0') !== START || bits(matrix, y, matrix.width - 18, 18).toString(2).padStart(18, '0') !== STOP) throw new FormatError('PDF417: missing start or stop pattern');
+    const read = (x) => { const result = pdf417CodewordForPattern(bits(matrix, y, x, 17)); if (!result || result.cluster !== cluster) throw new FormatError('PDF417: invalid codeword pattern'); return result.codeword; };
+    const left = read(17), right = read(34 + cols * 17);
+    let matched = false; for (let level = 0; level <= 8; level++) { const expected = indicators(row, rows, cols, level); if (left === expected[0] && right === expected[1]) { matched = true; break; } }
+    if (!matched) throw new FormatError('PDF417: row indicator mismatch');
+    for (let col = 0; col < cols; col++) {
+      try { all.push(read(34 + col * 17)); }
+      catch {
+        erasures.push(all.length);
+        all.push(0);
+      }
+    }
+  }
+  let level = -1; for (let candidate = 0; candidate <= 8; candidate++) if (all.length > pdf417EccLength(candidate)) { level = candidate; break; }
+  // The row indicators determine the level uniquely across the symbol.
+  for (let candidate = 0; candidate <= 8; candidate++) {
+    let ok = true; for (let row = 0; row < rows; row++) { const y = row * rowHeight, cluster = (row % 3) * 3, expected = indicators(row, rows, cols, candidate); const left = pdf417CodewordForPattern(bits(matrix, y, 17, 17)); const right = pdf417CodewordForPattern(bits(matrix, y, 34 + cols * 17, 17)); if (!left || !right || left.cluster !== cluster || right.cluster !== cluster || left.codeword !== expected[0] || right.codeword !== expected[1]) { ok = false; break; } } if (ok) { level = candidate; break; }
+  }
+  if (level < 0) throw new FormatError('PDF417: could not determine error correction level');
+  const corrected = all.slice(); const corrections = pdf417CorrectErrors(corrected, level, erasures);
+  const length = corrected[0]; if (length < 1 || length > corrected.length - pdf417EccLength(level)) throw new FormatError('PDF417: invalid symbol length descriptor');
+  const payload = corrected.slice(1, length);
+  const decoded = decodePdf417CompactionDetailed(payload);
+  return { ...decoded, codewords: corrected, rows, columns: cols, eccLevel: level, corrections };
+}
+
+__exports.decodePDF417 = decodePDF417;
+};
+
+__modules["pdf417/detector.js"] = function (__require, __exports) {
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { sampleGrid, sampleGridVoting } = __require("image/grid-sampler.js");
+const { PerspectiveTransform } = __require("image/perspective.js");
+const { decodePDF417 } = __require("pdf417/decoder.js");
+
+const START_PATTERN = [8, 1, 1, 1, 1, 1, 1, 3];
+const STOP_PATTERN = [7, 1, 1, 3, 1, 1, 1, 2, 1];
+const SCAN_ANGLES = [0, -4, 4, -8, 8, -14, 14, -22, 22, -32, 32]
+  .map((degrees) => degrees * Math.PI / 180);
+
+function rotateClockwise(source) {
+  const rotated = new BitMatrix(source.height, source.width);
+  for (let y = 0; y < source.height; y++) for (let x = 0; x < source.width; x++) {
+    if (source.get(x, y)) rotated.set(source.height - 1 - y, x);
+  }
+  return rotated;
+}
+
+function scanGeometry(angle) {
+  return {
+    along: { x: Math.cos(angle), y: Math.sin(angle) },
+    across: { x: -Math.sin(angle), y: Math.cos(angle) },
+  };
+}
+
+function projectionRange(image, vector) {
+  const points = [
+    { x: 0, y: 0 }, { x: image.width - 1, y: 0 },
+    { x: image.width - 1, y: image.height - 1 }, { x: 0, y: image.height - 1 },
+  ];
+  const values = points.map((point) => point.x * vector.x + point.y * vector.y);
+  return { min: Math.min(...values), max: Math.max(...values) };
+}
+
+function lineRange(image, geometry, across) {
+  const { along, across: normal } = geometry;
+  let min = -Infinity, max = Infinity;
+  const constrain = (low, high, step, offset) => {
+    if (Math.abs(step) < 1e-9) return offset >= low && offset <= high;
+    const first = (low - offset) / step, second = (high - offset) / step;
+    min = Math.max(min, Math.min(first, second));
+    max = Math.min(max, Math.max(first, second));
+    return min <= max;
+  };
+  if (!constrain(0, image.width - 1, along.x, normal.x * across) ||
+      !constrain(0, image.height - 1, along.y, normal.y * across)) return null;
+  return { min: Math.ceil(min), max: Math.floor(max) };
+}
+
+function runsInLine(image, geometry, across) {
+  const range = lineRange(image, geometry, across);
+  if (!range || range.max < range.min) return [];
+  const { along, across: normal } = geometry;
+  const runs = [];
+  const valueAt = (position) => image.get(
+    Math.round(along.x * position + normal.x * across),
+    Math.round(along.y * position + normal.y * across),
+  );
+  let dark = valueAt(range.min), start = range.min;
+  for (let position = range.min + 1; position <= range.max + 1; position++) {
+    const value = position <= range.max ? valueAt(position) : !dark;
+    if (value !== dark) {
+      runs.push({ dark, start, end: position, length: position - start });
+      start = position; dark = value;
+    }
+  }
+  return runs;
+}
+
+function removeSinglePixelSpecks(runs) {
+  const clean = runs.map((run) => ({ ...run }));
+  for (let index = 1; index < clean.length - 1;) {
+    if (clean[index].length > 1) { index++; continue; }
+    const merged = {
+      dark: clean[index - 1].dark,
+      start: clean[index - 1].start,
+      end: clean[index + 1].end,
+      length: clean[index - 1].length + clean[index].length + clean[index + 1].length,
+    };
+    clean.splice(index - 1, 3, merged);
+    index = Math.max(1, index - 2);
+  }
+  return clean;
+}
+
+function matchPattern(runs, at, expected) {
+  if (at + expected.length > runs.length || !runs[at].dark) return null;
+  let observed = 0, modules = 0;
+  for (let i = 0; i < expected.length; i++) { observed += runs[at + i].length; modules += expected[i]; }
+  const scale = observed / modules;
+  if (scale < 0.65) return null;
+  let error = 0;
+  for (let i = 0; i < expected.length; i++) {
+    const delta = Math.abs(runs[at + i].length - expected[i] * scale);
+    if (delta > Math.max(1.15, scale * 0.62)) return null;
+    error += delta / scale;
+  }
+  if (error / expected.length > 0.48) return null;
+  return { start: runs[at].start, end: runs[at + expected.length - 1].end, scale, error, at };
+}
+
+function quietPenalty(runs, start, stop) {
+  const before = start.at > 0 ? runs[start.at - 1].length / start.scale : 0;
+  const afterIndex = stop.at + STOP_PATTERN.length;
+  const after = afterIndex < runs.length ? runs[afterIndex].length / stop.scale : 0;
+  return Math.max(0, 2 - before) + Math.max(0, 2 - after);
+}
+
+function patternPairs(runs) {
+  const starts = [], stops = [];
+  for (let at = 0; at < runs.length; at++) {
+    const start = matchPattern(runs, at, START_PATTERN); if (start) starts.push(start);
+    const stop = matchPattern(runs, at, STOP_PATTERN); if (stop) stops.push(stop);
+  }
+  const pairs = [];
+  for (const start of starts) for (const stop of stops) {
+    if (stop.start <= start.end) continue;
+    const measured = stop.end - start.start;
+    const localScale = Math.sqrt(start.scale * stop.scale);
+    const roughColumns = Math.round((measured / localScale - 69) / 17);
+    for (let columns = Math.max(1, roughColumns - 2); columns <= Math.min(30, roughColumns + 2); columns++) {
+      const width = 69 + columns * 17;
+      const globalScale = measured / width;
+      const ratio = Math.max(start.scale, stop.scale, globalScale) /
+        Math.min(start.scale, stop.scale, globalScale);
+      if (ratio > 1.85) continue;
+      const scaleError = Math.abs(Math.log(start.scale / globalScale)) +
+        Math.abs(Math.log(stop.scale / globalScale));
+      pairs.push({ start, stop, columns, width, scale: globalScale,
+        startScale: start.scale, stopScale: stop.scale,
+        error: start.error + stop.error + scaleError * 4 + quietPenalty(runs, start, stop) * 0.15 });
+    }
+  }
+  pairs.sort((a, b) => a.error - b.error);
+  const used = new Set();
+  return pairs.filter((pair) => {
+    if (used.has(pair.columns)) return false;
+    used.add(pair.columns);
+    return used.size <= 3;
+  });
+}
+
+function pointAt(geometry, along, across) {
+  return {
+    x: geometry.along.x * along + geometry.across.x * across,
+    y: geometry.along.y * along + geometry.across.y * across,
+  };
+}
+
+function scanHits(image, angle) {
+  const geometry = scanGeometry(angle);
+  const range = projectionRange(image, geometry.across);
+  const hits = [];
+  for (let across = Math.ceil(range.min); across <= Math.floor(range.max); across++) {
+    const raw = runsInLine(image, geometry, across);
+    let pairs = patternPairs(raw);
+    if (!pairs.length) pairs = patternPairs(removeSinglePixelSpecks(raw));
+    for (const pair of pairs) {
+      hits.push({ across, left: pair.start.start, right: pair.stop.end,
+        leftPoint: pointAt(geometry, pair.start.start, across),
+        rightPoint: pointAt(geometry, pair.stop.end, across),
+        scale: pair.scale, startScale: pair.startScale, stopScale: pair.stopScale,
+        columns: pair.columns, width: pair.width, error: pair.error,
+        geometry });
+    }
+  }
+  return hits;
+}
+
+function fittedLine(hits, key) {
+  const meanX = hits.reduce((sum, hit) => sum + hit.across, 0) / hits.length;
+  const meanY = hits.reduce((sum, hit) => sum + hit[key], 0) / hits.length;
+  let covariance = 0, variance = 0;
+  for (const hit of hits) {
+    const delta = hit.across - meanX;
+    covariance += delta * (hit[key] - meanY);
+    variance += delta * delta;
+  }
+  const slope = variance ? covariance / variance : 0;
+  return { slope, intercept: meanY - slope * meanX };
+}
+
+function lineValue(line, at) {
+  return line.intercept + line.slope * at;
+}
+
+function finderExtent(image, hits, edgeKey, scaleKey, centreModules, fallback) {
+  const geometry = hits[0].geometry;
+  const edge = fittedLine(hits, edgeKey), scale = fittedLine(hits, scaleKey);
+  const span = fallback.bottom - fallback.top;
+  const projection = projectionRange(image, geometry.across);
+  const margin = Math.max(6, span * 0.35, hits[0].scale * 4);
+  const start = Math.max(Math.ceil(projection.min), Math.floor(fallback.top - margin));
+  const end = Math.min(Math.floor(projection.max), Math.ceil(fallback.bottom + margin));
+  const values = [];
+  for (let across = start; across <= end; across++) {
+    const localScale = Math.max(0.5, lineValue(scale, across));
+    const centre = lineValue(edge, across) + localScale * centreModules;
+    let dark = 0;
+    for (const offset of [-0.75, 0, 0.75]) {
+      const point = pointAt(geometry, centre + localScale * offset, across);
+      if (image.get(Math.round(point.x), Math.round(point.y))) dark++;
+    }
+    values.push({ across, dark: dark >= 2 });
+  }
+  const segments = [];
+  let first = null, lastDark = null, gap = 0;
+  for (const value of values) {
+    if (value.dark) {
+      if (first === null) first = value.across;
+      lastDark = value.across; gap = 0;
+    } else if (first !== null && ++gap > 2) {
+      segments.push({ top: first, bottom: lastDark + 1 });
+      first = null; lastDark = null; gap = 0;
+    }
+  }
+  if (first !== null) segments.push({ top: first, bottom: lastDark + 1 });
+  let best = null, bestScore = -Infinity;
+  for (const segment of segments) {
+    const overlap = Math.max(0, Math.min(segment.bottom, fallback.bottom) - Math.max(segment.top, fallback.top));
+    const score = overlap * 4 + (segment.bottom - segment.top) -
+      Math.abs((segment.top + segment.bottom) / 2 - (fallback.top + fallback.bottom) / 2);
+    if (overlap >= span * 0.55 && score > bestScore) { best = segment; bestScore = score; }
+  }
+  return best ?? fallback;
+}
+
+function intersectBoundary(leftAcross, rightAcross, leftCentre, rightCentre, leftEdge, rightEdge) {
+  const delta = rightCentre - leftCentre;
+  if (Math.abs(delta) < 1e-6) return { left: leftAcross, right: rightAcross };
+  const slope = (rightAcross - leftAcross) / delta;
+  const intercept = leftAcross - slope * leftCentre;
+  const atEdge = (edge, fallback) => {
+    const denominator = 1 - slope * edge.slope;
+    return Math.abs(denominator) < 1e-6 ? fallback :
+      (slope * edge.intercept + intercept) / denominator;
+  };
+  return { left: atEdge(leftEdge, leftAcross), right: atEdge(rightEdge, rightAcross) };
+}
+
+function groupHits(hits, image) {
+  const groups = [];
+  for (const hit of hits.sort((a, b) => a.across - b.across || a.error - b.error)) {
+    let best = null, bestDistance = Infinity;
+    for (const group of groups) {
+      const last = group.hits[group.hits.length - 1];
+      const gap = hit.across - last.across;
+      if (hit.columns !== last.columns || gap <= 0 || gap > Math.max(5, hit.scale * 3)) continue;
+      const scaleRatio = Math.max(hit.scale, last.scale) / Math.min(hit.scale, last.scale);
+      if (scaleRatio > 1.45) continue;
+      const tolerance = Math.max(5, hit.scale * 4 + gap);
+      const distance = Math.abs(hit.left - last.left) + Math.abs(hit.right - last.right);
+      if (distance > tolerance * 2 || distance >= bestDistance) continue;
+      best = group; bestDistance = distance;
+    }
+    if (best) best.hits.push(hit); else groups.push({ hits: [hit] });
+  }
+  const candidates = [];
+  for (const group of groups) {
+    const rows = group.hits;
+    const scale = rows.reduce((sum, hit) => sum + hit.scale, 0) / rows.length;
+    const top = rows[0].across, bottom = rows[rows.length - 1].across + 1;
+    const span = bottom - top;
+    if (rows.length < 4 || span < Math.max(6, scale * 4) || rows.length / span < 0.28) continue;
+    const geometry = rows[0].geometry;
+    const left = fittedLine(rows, 'left'), right = fittedLine(rows, 'right');
+    const startScale = fittedLine(rows, 'startScale'), stopScale = fittedLine(rows, 'stopScale');
+    const fallback = { top, bottom };
+    const leftExtent = image ? finderExtent(image, rows, 'left', 'startScale', 4, fallback) : fallback;
+    const rightExtent = image ? finderExtent(image, rows, 'right', 'stopScale', -14.5, fallback) : fallback;
+    const boundary = (leftAcross, rightAcross) => intersectBoundary(
+      leftAcross,
+      rightAcross,
+      lineValue(left, leftAcross) + lineValue(startScale, leftAcross) * 4,
+      lineValue(right, rightAcross) - lineValue(stopScale, rightAcross) * 14.5,
+      left,
+      right,
+    );
+    const topBoundary = boundary(leftExtent.top, rightExtent.top);
+    const bottomBoundary = boundary(leftExtent.bottom, rightExtent.bottom);
+    candidates.push({
+      width: rows[0].width, scale,
+      corners: [
+        pointAt(geometry, lineValue(left, topBoundary.left), topBoundary.left),
+        pointAt(geometry, lineValue(right, topBoundary.right), topBoundary.right),
+        pointAt(geometry, lineValue(right, bottomBoundary.right), bottomBoundary.right),
+        pointAt(geometry, lineValue(left, bottomBoundary.left), bottomBoundary.left),
+      ],
+      score: rows.length / span * 8 + Math.log2(rows.length + 1) * 2 -
+        rows.reduce((sum, hit) => sum + hit.error, 0) / rows.length,
+    });
+  }
+  return candidates.sort((a, b) => b.score - a.score);
+}
+
+function validQuadrilateral(value) {
+  return Array.isArray(value) && value.length === 4 &&
+    value.every((point) => Number.isFinite(point?.x) && Number.isFinite(point?.y));
+}
+
+function manualCandidate(corners) {
+  const horizontal = (Math.hypot(corners[1].x - corners[0].x, corners[1].y - corners[0].y) +
+    Math.hypot(corners[2].x - corners[3].x, corners[2].y - corners[3].y)) / 2;
+  const vertical = (Math.hypot(corners[3].x - corners[0].x, corners[3].y - corners[0].y) +
+    Math.hypot(corners[2].x - corners[1].x, corners[2].y - corners[1].y)) / 2;
+  const out = [];
+  for (let columns = 1; columns <= 30; columns++) {
+    const width = 69 + columns * 17, scale = horizontal / width;
+    if (scale < 0.65) continue;
+    const moduleHeight = vertical / scale;
+    let plausibility = Infinity;
+    for (let rowHeight = 3; rowHeight <= 12; rowHeight++) {
+      const rows = Math.round(moduleHeight / rowHeight);
+      if (rows >= 3 && rows <= 90) plausibility = Math.min(plausibility,
+        Math.abs(moduleHeight - rows * rowHeight) / rowHeight);
+    }
+    out.push({ width, scale, corners, score: Number.isFinite(plausibility) ? 2 - plausibility : 0 });
+  }
+  return out.sort((a, b) => b.score - a.score);
+}
+
+function edgeLength(first, second) {
+  return Math.hypot(second.x - first.x, second.y - first.y);
+}
+
+function rowCandidates(candidate, options) {
+  const vertical = (edgeLength(candidate.corners[0], candidate.corners[3]) +
+    edgeLength(candidate.corners[1], candidate.corners[2])) / 2;
+  const allowedHeights = Number.isInteger(options.rowHeight) ? [options.rowHeight] :
+    Array.from({ length: 10 }, (_, index) => index + 3);
+  const rows = [];
+  for (let value = 3; value <= 90; value++) {
+    let score = Infinity;
+    for (const rowHeight of allowedHeights) {
+      score = Math.min(score, Math.abs(Math.log(vertical / (candidate.scale * value * rowHeight))));
+    }
+    rows.push({ value, score });
+  }
+  return rows.sort((a, b) => a.score - b.score).map((entry) => entry.value);
+}
+
+function shiftedCandidate(candidate, amount) {
+  if (!amount) return candidate;
+  const topDx = candidate.corners[3].x - candidate.corners[0].x;
+  const topDy = candidate.corners[3].y - candidate.corners[0].y;
+  const bottomDx = candidate.corners[2].x - candidate.corners[1].x;
+  const bottomDy = candidate.corners[2].y - candidate.corners[1].y;
+  const topLength = Math.hypot(topDx, topDy) || 1;
+  const bottomLength = Math.hypot(bottomDx, bottomDy) || 1;
+  return { ...candidate, corners: [
+    { x: candidate.corners[0].x - topDx / topLength * amount, y: candidate.corners[0].y - topDy / topLength * amount },
+    { x: candidate.corners[1].x - bottomDx / bottomLength * amount, y: candidate.corners[1].y - bottomDy / bottomLength * amount },
+    { x: candidate.corners[2].x + bottomDx / bottomLength * amount, y: candidate.corners[2].y + bottomDy / bottomLength * amount },
+    { x: candidate.corners[3].x + topDx / topLength * amount, y: candidate.corners[3].y + topDy / topLength * amount },
+  ] };
+}
+
+function canonicalRows(matrix) {
+  const rowHeight = 3;
+  const out = new BitMatrix(matrix.width, matrix.height * rowHeight);
+  for (let y = 0; y < matrix.height; y++) for (let x = 0; x < matrix.width; x++) {
+    if (matrix.get(x, y)) out.setRegion(x, y * rowHeight, 1, rowHeight);
+  }
+  return out;
+}
+
+function sampleCandidate(image, candidate, options) {
+  for (const edgeShift of [0, candidate.scale * 0.35, -candidate.scale * 0.25]) {
+    const geometry = shiftedCandidate(candidate, edgeShift);
+    for (const rows of rowCandidates(geometry, options)) {
+      const transform = PerspectiveTransform.quadToQuad(0, 0, geometry.width, 0, geometry.width, rows, 0, rows,
+      geometry.corners[0].x, geometry.corners[0].y, geometry.corners[1].x, geometry.corners[1].y,
+      geometry.corners[2].x, geometry.corners[2].y, geometry.corners[3].x, geometry.corners[3].y);
+      for (const voting of [false, true]) {
+        let matrix;
+        try { matrix = voting ? sampleGridVoting(image, geometry.width, rows, transform) : sampleGrid(image, geometry.width, rows, transform); }
+        catch { continue; }
+        try {
+          const result = decodePDF417(matrix, { ...options, rowHeight: 1 });
+          return { matrix: canonicalRows(matrix), result, corners: geometry.corners };
+        }
+        catch { /* Try the next geometry. */ }
+      }
+    }
+  }
+  return null;
+}
+
+function automaticCandidates(image) {
+  const out = [];
+  for (const angle of SCAN_ANGLES) {
+    out.push(...groupHits(scanHits(image, angle), image));
+    if (out.length) break;
+  }
+  return out;
+}
+
+function detectInOrientation(image, options, supplied) {
+  for (const candidate of [...supplied, ...automaticCandidates(image)]) {
+    const decoded = sampleCandidate(image, candidate, options);
+    if (decoded) return { candidate, decoded };
+  }
+  if (supplied.length) return null;
+  for (const angle of SCAN_ANGLES.slice(1)) {
+    const candidates = groupHits(scanHits(image, angle), image);
+    for (const candidate of candidates) {
+      const decoded = sampleCandidate(image, candidate, options);
+      if (decoded) return { candidate, decoded };
+    }
+  }
+  return null;
+}
+
+/*
+ * Locate a binarized raster symbol from its repeated start and stop patterns.
+ * The detector estimates a projective quadrilateral; grayscale binarization
+ * remains the caller's responsibility.
+ */
+function detectPDF417(binaryImage, options = {}) {
+  if (!binaryImage?.width || !binaryImage?.height || typeof binaryImage.get !== 'function') return null;
+  let oriented = binaryImage;
+  let toOriginal = (point) => ({ x: point.x, y: point.y });
+  for (let turns = 0; turns < 4; turns++) {
+    const supplied = turns === 0 && validQuadrilateral(options.quadrilateral)
+      ? manualCandidate(options.quadrilateral.map(({ x, y }) => ({ x, y }))) : [];
+    const found = detectInOrientation(oriented, options, supplied);
+    if (found) {
+      return { matrix: found.decoded.matrix, rotation: turns * 90,
+        corners: found.decoded.corners.map(toOriginal), ...found.decoded.result };
+    }
+    const previous = oriented, previousToOriginal = toOriginal;
+    oriented = rotateClockwise(previous);
+    toOriginal = (point) => previousToOriginal({ x: point.y, y: previous.height - point.x });
+  }
+  return null;
+}
+function detectAndDecodePDF417(binaryImage, options = {}) { return detectPDF417(binaryImage, options); }
+
+__exports.detectPDF417 = detectPDF417;
+__exports.detectAndDecodePDF417 = detectAndDecodePDF417;
+};
+
+__modules["pdf417/index.js"] = function (__require, __exports) {
+const __reexport0 = __require("pdf417/compaction.js"); __exports.compactPdf417 = __reexport0.compactPdf417; __exports.compactPdf417Text = __reexport0.compactPdf417Text; __exports.compactPdf417Bytes = __reexport0.compactPdf417Bytes; __exports.compactPdf417Numeric = __reexport0.compactPdf417Numeric; __exports.decodePdf417Compaction = __reexport0.decodePdf417Compaction; __exports.decodePdf417CompactionDetailed = __reexport0.decodePdf417CompactionDetailed;
+const __reexport1 = __require("pdf417/encoder.js"); __exports.encodePDF417 = __reexport1.encodePDF417;
+const __reexport2 = __require("pdf417/decoder.js"); __exports.decodePDF417 = __reexport2.decodePDF417;
+const __reexport3 = __require("pdf417/detector.js"); __exports.detectPDF417 = __reexport3.detectPDF417; __exports.detectAndDecodePDF417 = __reexport3.detectAndDecodePDF417;
+const __reexport4 = __require("pdf417/error-correction.js"); __exports.pdf417EccLength = __reexport4.pdf417EccLength; __exports.pdf417ErrorCorrection = __reexport4.pdf417ErrorCorrection; __exports.pdf417CorrectErrors = __reexport4.pdf417CorrectErrors;
+const __reexport5 = __require("pdf417/tables.js"); __exports.PDF417_PATTERN_TABLE = __reexport5.PDF417_PATTERN_TABLE; __exports.PDF417_CLUSTER_NUMBERS = __reexport5.PDF417_CLUSTER_NUMBERS; __exports.pdf417PatternForCodeword = __reexport5.pdf417PatternForCodeword; __exports.pdf417CodewordForPattern = __reexport5.pdf417CodewordForPattern;
+
+
+};
+
+__modules["micropdf417/tables.js"] = function (__require, __exports) {
+/**
+ * MicroPDF417 format facts and Row Address Pattern (RAP) helpers.
+ *
+ * The tables are represented as compact, immutable data and are guarded by
+ * {@link validateMicroPdf417Tables}. They are deliberately separate from the
+ * PDF417 symbol-character table: MicroPDF417 has a fixed family of symbols and
+ * its own row-address system.
+ *
+ * Values are derived from publicly available symbology documentation and
+ * independently checked against black-box reference output. This module makes
+ * no certification or conformance claim.
+ *
+ * @module micropdf417/tables
+ */
+
+const variant = (id, columns, rows, eccCodewords, rapStart, rapRotation) => Object.freeze({
+  id,
+  columns,
+  rows,
+  totalCodewords: columns * rows,
+  dataCodewords: columns * rows - eccCodewords,
+  eccCodewords,
+  rapStart,
+  rapRotation,
+});
+
+/** All 34 predefined MicroPDF417 symbol variants, in format-table order. */
+const MICROPDF417_VARIANTS = Object.freeze([
+  variant(1, 1, 11, 7, 1, 8), variant(2, 1, 14, 7, 8, 0),
+  variant(3, 1, 17, 7, 36, 0), variant(4, 1, 20, 8, 19, 0),
+  variant(5, 1, 24, 8, 9, 8), variant(6, 1, 28, 8, 25, 8),
+  variant(7, 2, 8, 8, 1, 0), variant(8, 2, 11, 9, 1, 8),
+  variant(9, 2, 14, 9, 8, 0), variant(10, 2, 17, 10, 36, 0),
+  variant(11, 2, 20, 11, 19, 0), variant(12, 2, 23, 13, 9, 8),
+  variant(13, 2, 26, 15, 27, 8),
+  variant(14, 3, 6, 12, 1, 0), variant(15, 3, 8, 14, 7, 0),
+  variant(16, 3, 10, 16, 15, 0), variant(17, 3, 12, 18, 25, 0),
+  variant(18, 3, 15, 21, 37, 0), variant(19, 3, 20, 26, 1, 16),
+  variant(20, 3, 26, 32, 1, 8), variant(21, 3, 32, 38, 21, 8),
+  variant(22, 3, 38, 44, 15, 16), variant(23, 3, 44, 50, 1, 24),
+  variant(24, 4, 4, 8, 47, 24), variant(25, 4, 6, 12, 1, 0),
+  variant(26, 4, 8, 14, 7, 0), variant(27, 4, 10, 16, 15, 0),
+  variant(28, 4, 12, 18, 25, 0), variant(29, 4, 15, 21, 37, 0),
+  variant(30, 4, 20, 26, 1, 16), variant(31, 4, 26, 32, 1, 8),
+  variant(32, 4, 32, 38, 21, 8), variant(33, 4, 38, 44, 15, 16),
+  variant(34, 4, 44, 50, 1, 24),
+]);
+
+const byId = new Map(MICROPDF417_VARIANTS.map((entry) => [entry.id, entry]));
+
+// Six run widths, ordered bar-space-bar-space-bar-space.  A RAP is ten
+// modules wide; the right RAP has one additional one-module stop bar when
+// rendered. Keeping runs rather than bitmap literals makes each invariant
+// inspectable and avoids a rendering-specific representation here.
+const SIDE_RAP_RUNS = Object.freeze([
+  '221311', '311311', '312211', '222211', '213211', '214111', '223111', '313111',
+  '322111', '412111', '421111', '331111', '241111', '232111', '231211', '321211',
+  '411211', '411121', '411112', '321112', '312112', '311212', '311221', '311131',
+  '311122', '311113', '221113', '221122', '221131', '221221', '222121', '312121',
+  '321121', '231121', '231112', '222112', '213112', '212212', '212221', '212131',
+  '212122', '212113', '211213', '211123', '211132', '211141', '211231', '211222',
+  '211312', '211321', '211411', '212311',
+]);
+
+const CENTER_RAP_RUNS = Object.freeze([
+  '112231', '121231', '122131', '131131', '131221', '132121', '141121', '141211',
+  '142111', '133111', '132211', '131311', '122311', '123211', '124111', '115111',
+  '114211', '114121', '123121', '123112', '122212', '122221', '121321', '121411',
+  '112411', '113311', '113221', '113212', '113122', '122122', '131122', '131113',
+  '122113', '113113', '112213', '112222', '112312', '112321', '111421', '111331',
+  '111322', '111232', '111223', '111133', '111124', '111214', '112114', '121114',
+  '121123', '121132', '112132', '112141',
+]);
+
+/** @param {number} value @param {number} offset @returns {number} */
+function microPdf417NextRap(value, offset = 1) {
+  if (!Number.isInteger(value) || value < 1 || value > 52) throw new RangeError('MicroPDF417: RAP number must be in 1..52');
+  if (!Number.isInteger(offset)) throw new RangeError('MicroPDF417: RAP offset must be an integer');
+  return ((value - 1 + offset) % 52 + 52) % 52 + 1;
+}
+
+/** @param {number} id @returns {Readonly<typeof MICROPDF417_VARIANTS[number]>} */
+function microPdf417VariantByNumber(id) {
+  const entry = byId.get(id);
+  if (!entry) throw new RangeError('MicroPDF417: variant must be an integer in 1..34');
+  return entry;
+}
+
+/**
+ * Return the smallest data-region candidate that fits `codewords`.
+ * Ties are resolved by width, then height, so selection is deterministic.
+ */
+function microPdf417VariantForCapacity(codewords) {
+  if (!Number.isInteger(codewords) || codewords < 1) throw new RangeError('MicroPDF417: codeword capacity must be a positive integer');
+  const candidates = MICROPDF417_VARIANTS.filter((entry) => entry.dataCodewords >= codewords);
+  if (!candidates.length) throw new RangeError('MicroPDF417: payload exceeds the largest symbol data region');
+  return candidates.slice().sort((a, b) => a.totalCodewords - b.totalCodewords || a.columns - b.columns || a.rows - b.rows)[0];
+}
+
+/** Return the six bar/space run widths for a numbered side or center RAP. */
+function microPdf417RapSequence(number, kind = 'side') {
+  if (!Number.isInteger(number) || number < 1 || number > 52) throw new RangeError('MicroPDF417: RAP number must be in 1..52');
+  if (kind === 'side') return SIDE_RAP_RUNS[number - 1];
+  if (kind === 'center') return CENTER_RAP_RUNS[number - 1];
+  throw new RangeError('MicroPDF417: RAP kind must be side or center');
+}
+
+/**
+ * Resolve all row-address data for a zero-based row within a variant.
+ * @returns {{left: number, center: number|null, right: number, cluster: 0|3|6}}
+ */
+function microPdf417RowAddress(entry, row) {
+  if (!entry || !Number.isInteger(entry.columns) || !Number.isInteger(entry.rows)) throw new TypeError('MicroPDF417: a variant entry is required');
+  if (!Number.isInteger(row) || row < 0 || row >= entry.rows) throw new RangeError(`MicroPDF417: row must be in 0..${entry.rows - 1}`);
+  const left = microPdf417NextRap(entry.rapStart, row);
+  const cluster = /** @type {0|3|6} */ (((left - 1) % 3) * 3);
+  if (entry.columns < 3) return { left, center: null, right: microPdf417NextRap(left, entry.rapRotation), cluster };
+  const center = microPdf417NextRap(left, entry.rapRotation);
+  return { left, center, right: microPdf417NextRap(center, entry.rapRotation), cluster };
+}
+
+const validRuns = (runs) => runs.length === 6 && /^[1-9]{6}$/.test(runs) && [...runs].reduce((sum, digit) => sum + Number(digit), 0) === 10;
+const oneEdgeShift = (from, to) => [...from].reduce((sum, digit, index) => sum + Math.abs(Number(digit) - Number(to[index])), 0) === 2;
+
+/** Return any table-invariant failures; an empty result means the table is coherent. */
+function validateMicroPdf417Tables() {
+  const issues = [];
+  if (MICROPDF417_VARIANTS.length !== 34) issues.push('expected 34 variants');
+  const ids = new Set();
+  const formats = new Set();
+  for (const entry of MICROPDF417_VARIANTS) {
+    if (ids.has(entry.id)) issues.push(`duplicate variant ${entry.id}`); ids.add(entry.id);
+    const format = `${entry.columns}x${entry.rows}`;
+    if (formats.has(format)) issues.push(`duplicate format ${format}`); formats.add(format);
+    if (entry.totalCodewords !== entry.columns * entry.rows) issues.push(`${format}: total codeword geometry mismatch`);
+    if (entry.dataCodewords + entry.eccCodewords !== entry.totalCodewords) issues.push(`${format}: data/ECC capacity mismatch`);
+    if (entry.eccCodewords < 7 || entry.eccCodewords > 50) issues.push(`${format}: invalid ECC length`);
+    if (entry.rapStart < 1 || entry.rapStart > 52 || entry.rapRotation < 0 || entry.rapRotation > 51) issues.push(`${format}: invalid RAP assignment`);
+    for (let row = 0; row < entry.rows; row++) {
+      const address = microPdf417RowAddress(entry, row);
+      if (address.cluster !== ((address.left - 1) % 3) * 3) issues.push(`${format}: cluster mismatch at row ${row}`);
+      if ((entry.columns < 3) !== (address.center === null)) issues.push(`${format}: center RAP layout mismatch`);
+    }
+  }
+  for (const [kind, runs] of [['side', SIDE_RAP_RUNS], ['center', CENTER_RAP_RUNS]]) {
+    if (runs.length !== 52) issues.push(`${kind}: expected 52 RAPs`);
+    if (new Set(runs).size !== runs.length) issues.push(`${kind}: duplicate RAP`);
+    for (let i = 0; i < runs.length; i++) {
+      if (!validRuns(runs[i])) issues.push(`${kind}: invalid RAP ${i + 1}`);
+      if (runs.length && !oneEdgeShift(runs[i], runs[(i + 1) % runs.length])) issues.push(`${kind}: RAP ${i + 1} is not adjacent to its successor`);
+    }
+  }
+  return issues;
+}
+
+__exports.MICROPDF417_VARIANTS = MICROPDF417_VARIANTS;
+__exports.microPdf417NextRap = microPdf417NextRap;
+__exports.microPdf417VariantByNumber = microPdf417VariantByNumber;
+__exports.microPdf417VariantForCapacity = microPdf417VariantForCapacity;
+__exports.microPdf417RapSequence = microPdf417RapSequence;
+__exports.microPdf417RowAddress = microPdf417RowAddress;
+__exports.validateMicroPdf417Tables = validateMicroPdf417Tables;
+};
+
+__modules["micropdf417/error-correction.js"] = function (__require, __exports) {
+/** MicroPDF417 error correction over the existing GF(929) core. @module micropdf417/error-correction */
+const { EncodeError } = __require("core/errors.js");
+const { GF929 } = __require("core/galois-field.js");
+const { generatorPoly, rsDecode, rsEncode } = __require("core/reed-solomon.js");
+
+function eccLength(entry) {
+  if (!entry || !Number.isInteger(entry.eccCodewords)) throw new EncodeError('MicroPDF417: a variant with an ECC length is required');
+  if (entry.eccCodewords < 1 || entry.eccCodewords >= GF929.size) throw new EncodeError('MicroPDF417: ECC length is outside GF(929) bounds');
+  return entry.eccCodewords;
+}
+
+/** Return the fixed number of parity codewords for a MicroPDF417 variant. */
+function microPdf417EccLength(entry) { return eccLength(entry); }
+
+/** Build the MicroPDF417 generator polynomial for a variant's fixed ECC length. */
+function microPdf417Generator(entry) { return generatorPoly(eccLength(entry), GF929, 1); }
+
+/** Compute systematic MicroPDF417 parity codewords. `data` must already include padding. */
+function microPdf417ErrorCorrection(data, entry) { return rsEncode(data, eccLength(entry), GF929, 1); }
+
+/** Correct a complete MicroPDF417 codeword stream, optionally marking erasures. */
+function microPdf417CorrectErrors(codewords, entry, erasures = []) {
+  return rsDecode(codewords, eccLength(entry), GF929, 1, erasures);
+}
+
+__exports.microPdf417EccLength = microPdf417EccLength;
+__exports.microPdf417Generator = microPdf417Generator;
+__exports.microPdf417ErrorCorrection = microPdf417ErrorCorrection;
+__exports.microPdf417CorrectErrors = microPdf417CorrectErrors;
+};
+
+__modules["micropdf417/compaction.js"] = function (__require, __exports) {
+/** MicroPDF417 high-level compaction adapter. @module micropdf417/compaction */
+const { EncodeError } = __require("core/errors.js");
+const { compactPdf417Bytes, compactPdf417Numeric, compactPdf417Text } = __require("pdf417/compaction.js");
+
+function byteLength(value) {
+  if (value instanceof Uint8Array) return value.byteLength;
+  if (ArrayBuffer.isView(value)) return value.byteLength;
+  return -1;
+}
+
+function assertNotEmpty(value) {
+  if ((typeof value === 'string' && value.length === 0) || byteLength(value) === 0) {
+    throw new EncodeError('MicroPDF417: value must not be empty');
+  }
+}
+
+function latin1Bytes(value) {
+  if (typeof value !== 'string') return value;
+  const bytes = [];
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint > 255) {
+      throw new EncodeError('MicroPDF417 ECI 3: string contains a character outside ISO-8859-1');
+    }
+    bytes.push(codePoint);
+  }
+  return Uint8Array.from(bytes);
+}
+
+function compactByte(value, eci) {
+  if (eci === undefined) return compactPdf417Bytes(value);
+  if (eci === 3) return compactPdf417Bytes(latin1Bytes(value));
+  if (eci === 26) {
+    if (typeof value !== 'string') {
+      throw new EncodeError('MicroPDF417 ECI 26: value must be a string so UTF-8 validity is known');
+    }
+    const encoded = compactPdf417Bytes(value);
+    return encoded[0] === 927 && encoded[1] === 26 ? encoded : [927, 26, ...encoded];
+  }
+  throw new EncodeError('MicroPDF417: supported ECI assignment numbers are 3 and 26');
+}
+
+/**
+ * Compact one MicroPDF417 value.
+ *
+ * Unlike PDF417, MicroPDF417 starts in Byte Compaction. Text therefore needs
+ * an explicit 900 latch. Byte compaction always emits 901 or 924 so its start
+ * state is unambiguous, including when an ECI designator precedes it.
+ */
+function compactMicroPDF417(value, options = {}) {
+  assertNotEmpty(value);
+  const mode = options.compaction ?? 'auto';
+  const eci = options.eci;
+  if (eci !== undefined && eci !== 3 && eci !== 26) {
+    throw new EncodeError('MicroPDF417: supported ECI assignment numbers are 3 and 26');
+  }
+
+  if (mode === 'text') {
+    if (eci !== undefined) throw new EncodeError('MicroPDF417: explicit ECI is supported only with byte compaction');
+    return [900, ...compactPdf417Text(value)];
+  }
+  if (mode === 'numeric') {
+    if (eci !== undefined) throw new EncodeError('MicroPDF417: explicit ECI is supported only with byte compaction');
+    return compactPdf417Numeric(value);
+  }
+  if (mode === 'byte') return compactByte(value, eci);
+  if (mode !== 'auto') {
+    throw new EncodeError(`MicroPDF417: unsupported compaction mode ${JSON.stringify(mode)}`);
+  }
+
+  if (eci !== undefined) return compactByte(value, eci);
+  if (typeof value === 'string' && /^\d{13,}$/.test(value)) return compactPdf417Numeric(value);
+  if (typeof value === 'string') {
+    try {
+      return [900, ...compactPdf417Text(value)];
+    } catch (error) {
+      if (!(error instanceof EncodeError)) throw error;
+    }
+  }
+  return compactPdf417Bytes(value);
+}
+
+__exports.compactMicroPDF417 = compactMicroPDF417;
+};
+
+__modules["micropdf417/encoder.js"] = function (__require, __exports) {
+/** MicroPDF417 encoder. @module micropdf417/encoder */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { EncodeError } = __require("core/errors.js");
+const { pdf417PatternForCodeword } = __require("pdf417/tables.js");
+const { compactMicroPDF417 } = __require("micropdf417/compaction.js");
+const { microPdf417ErrorCorrection } = __require("micropdf417/error-correction.js");
+const { MICROPDF417_VARIANTS, microPdf417RapSequence, microPdf417RowAddress, microPdf417VariantByNumber, microPdf417VariantForCapacity } = __require("micropdf417/tables.js");
+
+function appendWidths(matrix, y, x, sequence, height) {
+  let dark = true;
+  for (const digit of sequence) {
+    const width = digit.charCodeAt(0) - 48;
+    if (!Number.isInteger(width) || width < 1 || width > 6) {
+      throw new EncodeError('MicroPDF417: invalid module-width sequence');
+    }
+    if (dark) matrix.setRegion(x, y, width, height);
+    x += width;
+    dark = !dark;
+  }
+  return x;
+}
+
+function codewordSequence(codeword, cluster) {
+  return pdf417PatternForCodeword(codeword, cluster)
+    .toString(2)
+    .padStart(17, '0')
+    .replace(/0+|1+/g, (run) => String(run.length));
+}
+
+function symbolWidth(columns) {
+  return 21 + columns * 17 + (columns > 2 ? 10 : 0);
+}
+
+function validateOptions(options) {
+  const rowHeight = options.rowHeight ?? 2;
+  if (!Number.isInteger(rowHeight) || rowHeight < 2) {
+    throw new EncodeError('MicroPDF417: rowHeight must be an integer of at least 2');
+  }
+  if (options.columns !== undefined &&
+      (!Number.isInteger(options.columns) || options.columns < 1 || options.columns > 4)) {
+    throw new EncodeError('MicroPDF417: columns must be an integer in 1..4');
+  }
+  if (options.variant !== undefined &&
+      (!Number.isInteger(options.variant) || options.variant < 1 || options.variant > 34)) {
+    throw new EncodeError('MicroPDF417: variant must be an integer in 1..34');
+  }
+  if (options.aspectRatio !== undefined &&
+      (!Number.isFinite(options.aspectRatio) || options.aspectRatio <= 0)) {
+    throw new EncodeError('MicroPDF417: aspectRatio must be positive');
+  }
+  if (options.rows !== undefined) {
+    throw new EncodeError('MicroPDF417: rows are fixed by the selected variant');
+  }
+  if (options.eccLevel !== undefined) {
+    throw new EncodeError('MicroPDF417: error correction is fixed by the selected variant');
+  }
+  for (const feature of [
+    'structuredAppend', 'macro', 'macroPdf417', 'macroControlBlock',
+    'readerInit', 'gs1', 'hibc', 'linkage',
+  ]) {
+    if (options[feature] !== undefined) {
+      throw new EncodeError(`MicroPDF417: ${feature} is not implemented`);
+    }
+  }
+  return rowHeight;
+}
+
+function chooseVariant(codewordCount, rowHeight, options) {
+  if (options.variant !== undefined) {
+    const variant = microPdf417VariantByNumber(options.variant);
+    if (!variant) throw new EncodeError(`MicroPDF417: unknown variant ${options.variant}`);
+    if (options.columns !== undefined && variant.columns !== options.columns) {
+      throw new EncodeError(`MicroPDF417: variant ${variant.id} has ${variant.columns} columns`);
+    }
+    if (codewordCount > variant.dataCodewords) {
+      throw new EncodeError(
+        `MicroPDF417: payload requires ${codewordCount} data codewords, variant ${variant.id} holds ${variant.dataCodewords}`
+      );
+    }
+    return variant;
+  }
+
+  if (options.columns === undefined && options.aspectRatio === undefined) {
+    try {
+      return microPdf417VariantForCapacity(codewordCount);
+    } catch (error) {
+      if (!(error instanceof RangeError)) throw error;
+      throw new EncodeError(`MicroPDF417: payload requires ${codewordCount} data codewords and exceeds every variant`);
+    }
+  }
+
+  const candidates = MICROPDF417_VARIANTS.filter((variant) =>
+    variant.dataCodewords >= codewordCount &&
+    (options.columns === undefined || variant.columns === options.columns)
+  );
+  if (!candidates.length) {
+    const columnText = options.columns === undefined ? '' : ` with ${options.columns} columns`;
+    throw new EncodeError(`MicroPDF417: payload does not fit any supported variant${columnText}`);
+  }
+  if (options.aspectRatio === undefined) {
+    return candidates.reduce((best, variant) =>
+      variant.dataCodewords < best.dataCodewords ||
+      (variant.dataCodewords === best.dataCodewords && variant.totalCodewords < best.totalCodewords)
+        ? variant : best
+    );
+  }
+
+  const target = options.aspectRatio;
+  return candidates.reduce((best, variant) => {
+    const ratio = symbolWidth(variant.columns) / (variant.rows * rowHeight);
+    const score = Math.abs(Math.log(ratio / target)) +
+      (variant.dataCodewords - codewordCount) / 10000;
+    return !best || score < best.score ? { variant, score } : best;
+  }, null).variant;
+}
+
+/** Encode a value as one of the 34 fixed MicroPDF417 variants. */
+function encodeMicroPDF417(value, options = {}) {
+  const rowHeight = validateOptions(options);
+  const payload = compactMicroPDF417(value, options);
+  const variant = chooseVariant(payload.length, rowHeight, options);
+  const data = payload.slice();
+  while (data.length < variant.dataCodewords) data.push(900);
+  const ecc = microPdf417ErrorCorrection(data, variant);
+  if (ecc.length !== variant.eccCodewords) {
+    throw new EncodeError('MicroPDF417: error-correction length does not match the selected variant');
+  }
+  const codewords = data.concat(ecc);
+  if (codewords.length !== variant.totalCodewords || codewords.length !== variant.rows * variant.columns) {
+    throw new EncodeError('MicroPDF417: selected variant has inconsistent codeword dimensions');
+  }
+
+  const matrix = new BitMatrix(symbolWidth(variant.columns), variant.rows * rowHeight);
+  for (let row = 0; row < variant.rows; row++) {
+    const y = row * rowHeight;
+    const address = microPdf417RowAddress(variant, row);
+    let x = appendWidths(matrix, y, 0, microPdf417RapSequence(address.left, 'side'), rowHeight);
+    for (let column = 0; column < variant.columns; column++) {
+      x = appendWidths(
+        matrix,
+        y,
+        x,
+        codewordSequence(codewords[row * variant.columns + column], address.cluster),
+        rowHeight
+      );
+      const hasCentralRap = (variant.columns === 3 && column === 0) ||
+        (variant.columns === 4 && column === 1);
+      if (hasCentralRap) {
+        if (address.center === null) {
+          throw new EncodeError('MicroPDF417: selected variant is missing its centre row address');
+        }
+        x = appendWidths(matrix, y, x, microPdf417RapSequence(address.center, 'center'), rowHeight);
+      }
+    }
+    x = appendWidths(matrix, y, x, microPdf417RapSequence(address.right, 'side'), rowHeight);
+    matrix.setRegion(x, y, 1, rowHeight);
+    x++;
+    if (x !== matrix.width) throw new EncodeError('MicroPDF417: row width does not match the selected variant');
+  }
+
+  matrix.micropdf417 = {
+    variant: variant.id,
+    rows: variant.rows,
+    columns: variant.columns,
+    eccCodewords: variant.eccCodewords,
+    rowHeight,
+    payloadCodewords: payload.length,
+    dataCodewords: data,
+    codewords,
+  };
+  return matrix;
+}
+
+__exports.encodeMicroPDF417 = encodeMicroPDF417;
+};
+
+__modules["micropdf417/decoder.js"] = function (__require, __exports) {
+/**
+ * Direct-module MicroPDF417 decoder.
+ *
+ * This module reads an already sampled, axis-aligned `BitMatrix`. Image finding,
+ * perspective correction, and recognition from photographic pixels are deliberately
+ * outside this first decoder boundary. The RAP sequence is authoritative for format
+ * detection; matrix metadata is used only as an optional row-height hint.
+ *
+ * @module micropdf417/decoder
+ */
+const { FormatError } = __require("core/errors.js");
+const { decodePdf417CompactionDetailed } = __require("pdf417/compaction.js");
+const { pdf417CodewordForPattern } = __require("pdf417/tables.js");
+const { microPdf417CorrectErrors } = __require("micropdf417/error-correction.js");
+const { MICROPDF417_VARIANTS, microPdf417RapSequence, microPdf417RowAddress, microPdf417VariantByNumber } = __require("micropdf417/tables.js");
+
+function symbolWidth(columns) {
+  return 21 + columns * 17 + (columns > 2 ? 10 : 0);
+}
+
+function bits(matrix, y, x, width) {
+  let value = 0;
+  for (let i = 0; i < width; i++) value = (value << 1) | (matrix.get(x + i, y) ? 1 : 0);
+  return value;
+}
+
+function widthsToBits(widths) {
+  let dark = true;
+  let out = '';
+  for (const digit of widths) {
+    out += (dark ? '1' : '0').repeat(digit.charCodeAt(0) - 48);
+    dark = !dark;
+  }
+  return out;
+}
+
+function hasExpectedBits(matrix, y, x, sequence) {
+  const expected = widthsToBits(sequence);
+  for (let i = 0; i < expected.length; i++) {
+    if ((matrix.get(x + i, y) ? '1' : '0') !== expected[i]) return false;
+  }
+  return true;
+}
+
+function centralRapAfter(entry, column) {
+  return (entry.columns === 3 && column === 0) ||
+    (entry.columns === 4 && column === 1);
+}
+
+/** Return true when all address patterns for this format candidate agree. */
+function hasValidRowAddresses(matrix, entry, rowHeight) {
+  for (let row = 0; row < entry.rows; row++) {
+    const y = row * rowHeight;
+    const address = microPdf417RowAddress(entry, row);
+    let x = 0;
+    if (!hasExpectedBits(matrix, y, x, microPdf417RapSequence(address.left, 'side'))) return false;
+    x += 10;
+    for (let column = 0; column < entry.columns; column++) {
+      x += 17;
+      if (centralRapAfter(entry, column)) {
+        if (address.center === null ||
+            !hasExpectedBits(matrix, y, x, microPdf417RapSequence(address.center, 'center'))) return false;
+        x += 10;
+      }
+    }
+    if (!hasExpectedBits(matrix, y, x, microPdf417RapSequence(address.right, 'side'))) return false;
+    x += 10;
+    if (!matrix.get(x, y) || x + 1 !== matrix.width) return false;
+  }
+  return true;
+}
+
+function candidateFormats(matrix, options) {
+  const metadataHeight = matrix.micropdf417?.rowHeight;
+  const requestedHeight = options.rowHeight ?? metadataHeight;
+  if (requestedHeight !== undefined && (!Number.isInteger(requestedHeight) || requestedHeight < 1)) {
+    throw new FormatError('MicroPDF417: rowHeight must be a positive integer');
+  }
+  const requestedVariant = options.variant === undefined ? null : microPdf417VariantByNumber(options.variant);
+  const pool = requestedVariant ? [requestedVariant] : MICROPDF417_VARIANTS;
+  const candidates = [];
+  for (const entry of pool) {
+    if (matrix.width !== symbolWidth(entry.columns)) continue;
+    if (matrix.height % entry.rows) continue;
+    const rowHeight = matrix.height / entry.rows;
+    if (requestedHeight !== undefined && rowHeight !== requestedHeight) continue;
+    if (hasValidRowAddresses(matrix, entry, rowHeight)) candidates.push({ entry, rowHeight });
+  }
+  return candidates;
+}
+
+function resolveFormat(matrix, options) {
+  if (!matrix?.width || !matrix?.height || typeof matrix.get !== 'function') {
+    throw new FormatError('MicroPDF417: matrix with width, height and get() is required');
+  }
+  const candidates = candidateFormats(matrix, options);
+  if (!candidates.length) throw new FormatError('MicroPDF417: no variant matches matrix geometry and row-address patterns');
+  if (candidates.length > 1) throw new FormatError('MicroPDF417: row-address patterns do not identify a unique variant');
+  return candidates[0];
+}
+
+function readCodewords(matrix, entry, rowHeight) {
+  const codewords = [];
+  const erasures = [];
+  for (let row = 0; row < entry.rows; row++) {
+    const y = row * rowHeight;
+    const address = microPdf417RowAddress(entry, row);
+    let x = 10;
+    for (let column = 0; column < entry.columns; column++) {
+      const decoded = pdf417CodewordForPattern(bits(matrix, y, x, 17));
+      if (!decoded || decoded.cluster !== address.cluster) {
+        erasures.push(codewords.length);
+        codewords.push(0);
+      } else {
+        codewords.push(decoded.codeword);
+      }
+      x += 17;
+      if (centralRapAfter(entry, column)) x += 10;
+    }
+  }
+  return { codewords, erasures };
+}
+
+/**
+ * Decode a sampled MicroPDF417 matrix.
+ *
+ * The complete fixed data region is compacted after correction. Encoder padding
+ * is PDF417 Text latch 900, which contributes no characters at the end of the
+ * payload. This avoids relying on non-symbol metadata for payload length.
+ */
+function decodeMicroPDF417(matrix, options = {}) {
+  const { entry, rowHeight } = resolveFormat(matrix, options);
+  const { codewords, erasures } = readCodewords(matrix, entry, rowHeight);
+  const corrections = microPdf417CorrectErrors(codewords, entry, erasures);
+  const data = codewords.slice(0, entry.dataCodewords);
+  const decoded = decodePdf417CompactionDetailed(data);
+  return {
+    ...decoded,
+    codewords,
+    rows: entry.rows,
+    columns: entry.columns,
+    variant: entry.id,
+    eccCodewords: entry.eccCodewords,
+    rowHeight,
+    corrections,
+  };
+}
+
+__exports.decodeMicroPDF417 = decodeMicroPDF417;
+};
+
+__modules["micropdf417/detector.js"] = function (__require, __exports) {
+/**
+ * Axis-aligned MicroPDF417 raster detection.
+ *
+ * A MicroPDF417 symbol has a fixed module width for each column count and a
+ * dark leading and trailing module in every row.  Consequently the bounding
+ * rectangle of dark pixels identifies the complete symbol even when a light
+ * quiet zone surrounds it.  Its width determines the integer raster scale;
+ * the existing direct-module decoder then verifies every row-address pattern
+ * and selects the exact variant.  This is intentionally narrower than the
+ * PDF417 photo detector: it handles clean binarized rasters only, not skew or
+ * projective camera images.
+ *
+ * @module micropdf417/detector
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+const { decodeMicroPDF417 } = __require("micropdf417/decoder.js");
+
+/** @typedef {{x:number, y:number}} Point */
+
+// Each row has two 10-module side RAPs, a final separator, and 17 modules for
+// each data column. Three and four columns also contain one central RAP.
+function symbolWidth(columns) { return 21 + columns * 17 + (columns > 2 ? 10 : 0); }
+const WIDTHS = [1, 2, 3, 4].map(symbolWidth);
+
+function rotateClockwise(source) {
+  const rotated = new BitMatrix(source.height, source.width);
+  for (let y = 0; y < source.height; y++) for (let x = 0; x < source.width; x++) {
+    if (source.get(x, y)) rotated.set(source.height - 1 - y, x);
+  }
+  return rotated;
+}
+
+function integerScale(width, modules) {
+  if (width % modules) return 0;
+  const scale = width / modules;
+  return Number.isInteger(scale) && scale > 0 ? scale : 0;
+}
+
+/** Collapse exact integer scale blocks using a majority vote. */
+function sampleRaster(image, bounds, modulesWide, scale) {
+  const modulesHigh = bounds.height / scale;
+  if (!Number.isInteger(modulesHigh) || modulesHigh < 1) return null;
+  const matrix = new BitMatrix(modulesWide, modulesHigh);
+  for (let y = 0; y < modulesHigh; y++) for (let x = 0; x < modulesWide; x++) {
+    let dark = 0;
+    for (let py = 0; py < scale; py++) for (let px = 0; px < scale; px++) {
+      if (image.get(bounds.x + x * scale + px, bounds.y + y * scale + py)) dark++;
+    }
+    if (dark * 2 >= scale * scale) matrix.set(x, y);
+  }
+  return matrix;
+}
+
+function rectangle(bounds) {
+  return [
+    { x: bounds.x, y: bounds.y },
+    { x: bounds.x + bounds.width, y: bounds.y },
+    { x: bounds.x + bounds.width, y: bounds.y + bounds.height },
+    { x: bounds.x, y: bounds.y + bounds.height },
+  ];
+}
+
+function detectAxisAligned(image, options) {
+  const bounds = image.getBounds();
+  if (!bounds) return null;
+  for (const width of WIDTHS) {
+    const scale = integerScale(bounds.width, width);
+    if (!scale || bounds.height % scale) continue;
+    const matrix = sampleRaster(image, bounds, width, scale);
+    if (!matrix) continue;
+    try {
+      const decoded = decodeMicroPDF417(matrix, options);
+      return { matrix, corners: rectangle(bounds), moduleSize: scale, ...decoded };
+    } catch { /* The RAP sequence is not a MicroPDF417 symbol of this width. */ }
+  }
+  return null;
+}
+
+/**
+ * Detect and decode one clean, binarized MicroPDF417 raster.
+ *
+ * Integer upscaling and quiet zones are accepted. The image is retried at all
+ * quarter-turns, but arbitrary angles and perspective require caller-side
+ * rectification before this function is used. `rotation` reports the clockwise
+ * orientation of the supplied input relative to a normally oriented symbol;
+ * it is not the inverse correction applied internally while searching.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage Set bit = dark.
+ * @param {object} [options] Passed to {@link decodeMicroPDF417}.
+ * @returns {(ReturnType<typeof decodeMicroPDF417> & {matrix: BitMatrix, corners: Point[], moduleSize: number, rotation: number}) | null}
+ */
+function detectMicroPDF417(binaryImage, options = {}) {
+  if (!binaryImage?.width || !binaryImage?.height || typeof binaryImage.get !== 'function') return null;
+  let oriented = binaryImage;
+  let toOriginal = (point) => ({ x: point.x, y: point.y });
+  for (let turns = 0; turns < 4; turns++) {
+    const found = detectAxisAligned(oriented, options);
+    // Search rotates clockwise to normalize the input. Public rotation has the
+    // opposite meaning: it describes how the input itself was rotated.
+    if (found) return {
+      ...found,
+      rotation: (360 - turns * 90) % 360,
+      corners: found.corners.map(toOriginal),
+    };
+    const previous = oriented;
+    const previousToOriginal = toOriginal;
+    oriented = rotateClockwise(previous);
+    // Boundary coordinates (rather than just pixel centres) are transformed
+    // here, so callers can draw the returned rectangle directly on the input.
+    toOriginal = (point) => previousToOriginal({ x: point.y, y: previous.height - point.x });
+  }
+  return null;
+}
+
+/** Alias kept symmetric with the other 2D readers. */
+function detectAndDecodeMicroPDF417(binaryImage, options = {}) {
+  return detectMicroPDF417(binaryImage, options);
+}
+
+__exports.detectMicroPDF417 = detectMicroPDF417;
+__exports.detectAndDecodeMicroPDF417 = detectAndDecodeMicroPDF417;
+};
+
+__modules["micropdf417/index.js"] = function (__require, __exports) {
+const __reexport0 = __require("micropdf417/tables.js"); __exports.MICROPDF417_VARIANTS = __reexport0.MICROPDF417_VARIANTS; __exports.microPdf417NextRap = __reexport0.microPdf417NextRap; __exports.microPdf417VariantByNumber = __reexport0.microPdf417VariantByNumber; __exports.microPdf417VariantForCapacity = __reexport0.microPdf417VariantForCapacity; __exports.microPdf417RapSequence = __reexport0.microPdf417RapSequence; __exports.microPdf417RowAddress = __reexport0.microPdf417RowAddress; __exports.validateMicroPdf417Tables = __reexport0.validateMicroPdf417Tables;
+const __reexport1 = __require("micropdf417/error-correction.js"); __exports.microPdf417EccLength = __reexport1.microPdf417EccLength; __exports.microPdf417Generator = __reexport1.microPdf417Generator; __exports.microPdf417ErrorCorrection = __reexport1.microPdf417ErrorCorrection; __exports.microPdf417CorrectErrors = __reexport1.microPdf417CorrectErrors;
+const __reexport2 = __require("micropdf417/compaction.js"); __exports.compactMicroPDF417 = __reexport2.compactMicroPDF417;
+const __reexport3 = __require("micropdf417/encoder.js"); __exports.encodeMicroPDF417 = __reexport3.encodeMicroPDF417;
+const __reexport4 = __require("micropdf417/decoder.js"); __exports.decodeMicroPDF417 = __reexport4.decodeMicroPDF417;
+const __reexport5 = __require("micropdf417/detector.js"); __exports.detectMicroPDF417 = __reexport5.detectMicroPDF417; __exports.detectAndDecodeMicroPDF417 = __reexport5.detectAndDecodeMicroPDF417;
+
+
+};
+
+__modules["render/options.js"] = function (__require, __exports) {
+/**
+ * Shared render options, normalised once so every backend agrees.
+ *
+ * @module render/options
+ */
+const { BitMatrix } = __require("core/bit-matrix.js");
+
+/**
+ * @typedef {object} RenderOptions
+ * @property {number} [scale] Pixels per module. Default 8.
+ * @property {number} [margin] Quiet-zone modules on every side. Default 4.
+ * @property {string} [dark] Colour of set modules. Default '#000000'.
+ * @property {string} [light] Colour of clear modules, or 'none' for transparent.
+ * @property {number} [barHeight] For 1D symbols: total bar height in pixels.
+ */
+
+/**
+ * Expand and pad the matrix, and resolve every dimension.
+ *
+ * Linear symbols arrive one module tall. They are stretched to `barHeight`
+ * *before* the quiet zone is applied, so the margin ends up uniform on all
+ * four sides — padding first would leave a quiet zone one module tall against
+ * bars a hundred pixels tall, which no scanner would accept.
+ *
+ * @param {BitMatrix} matrix
+ * @param {RenderOptions} options
+ */
+function normalizeOptions(matrix, options = {}) {
+  const scale = Math.max(1, Math.floor(options.scale ?? 8));
+  const margin = Math.max(0, Math.floor(options.margin ?? 4));
+  const dark = options.dark ?? '#000000';
+  const light = options.light ?? '#ffffff';
+  const barHeight = options.barHeight ?? null;
+
+  let base = matrix;
+  const is1D = matrix.height === 1;
+
+  if (is1D) {
+    // Default to a bar height that stays scannable: tall enough that a laser
+    // crossing at a slight angle still passes through the whole symbol.
+    const targetPixels = barHeight ?? Math.max(40, Math.round(matrix.width * scale * 0.15));
+    const rows = Math.max(1, Math.round(targetPixels / scale));
+    base = new BitMatrix(matrix.width, rows);
+    for (let x = 0; x < matrix.width; x++) {
+      if (!matrix.get(x, 0)) continue;
+      for (let y = 0; y < rows; y++) base.set(x, y);
+    }
+  }
+
+  const source = margin > 0 ? base.withMargin(margin) : base;
+
+  return {
+    scale,
+    margin,
+    dark,
+    light,
+    is1D,
+    source,
+    rowHeight: scale,
+    pixelWidth: source.width * scale,
+    pixelHeight: source.height * scale,
+  };
+}
+
+/**
+ * Parse a CSS colour into RGBA bytes.
+ *
+ * Supports the forms a barcode actually needs: #rgb, #rgba, #rrggbb,
+ * #rrggbbaa, rgb(), rgba(), plus 'none' and 'transparent'.
+ *
+ * @param {string} colour
+ * @returns {[number, number, number, number]}
+ */
+function parseColor(colour) {
+  const value = String(colour).trim().toLowerCase();
+
+  if (value === 'none' || value === 'transparent') return [0, 0, 0, 0];
+  if (value === 'white') return [255, 255, 255, 255];
+  if (value === 'black') return [0, 0, 0, 255];
+
+  if (value[0] === '#') {
+    const hex = value.slice(1);
+    const expand = (c) => parseInt(c + c, 16);
+    if (hex.length === 3) {
+      return [expand(hex[0]), expand(hex[1]), expand(hex[2]), 255];
+    }
+    if (hex.length === 4) {
+      return [expand(hex[0]), expand(hex[1]), expand(hex[2]), expand(hex[3])];
+    }
+    if (hex.length === 6) {
+      return [
+        parseInt(hex.slice(0, 2), 16),
+        parseInt(hex.slice(2, 4), 16),
+        parseInt(hex.slice(4, 6), 16),
+        255,
+      ];
+    }
+    if (hex.length === 8) {
+      return [
+        parseInt(hex.slice(0, 2), 16),
+        parseInt(hex.slice(2, 4), 16),
+        parseInt(hex.slice(4, 6), 16),
+        parseInt(hex.slice(6, 8), 16),
+      ];
+    }
+  }
+
+  const fn = value.match(/^rgba?\(([^)]+)\)$/);
+  if (fn) {
+    const parts = fn[1].split(/[,/\s]+/).filter(Boolean);
+    const channel = (s) => (s.endsWith('%')
+      ? Math.round((parseFloat(s) / 100) * 255)
+      : Math.round(parseFloat(s)));
+    const r = channel(parts[0]);
+    const g = channel(parts[1]);
+    const b = channel(parts[2]);
+    let a = 255;
+    if (parts.length > 3) {
+      a = parts[3].endsWith('%')
+        ? Math.round((parseFloat(parts[3]) / 100) * 255)
+        : Math.round(parseFloat(parts[3]) * 255);
+    }
+    return [r, g, b, a];
+  }
+
+  // Unrecognised: fall back to opaque black rather than throwing, so an
+  // unusual colour never costs someone a barcode.
+  return [0, 0, 0, 255];
+}
+
+__exports.normalizeOptions = normalizeOptions;
+__exports.parseColor = parseColor;
+};
+
+__modules["render/svg.js"] = function (__require, __exports) {
+/**
+ * SVG output.
+ *
+ * Dark modules are emitted as a single `<path>` with horizontal runs merged,
+ * not as one `<rect>` per module. A version 40 QR symbol has 31329 modules; the
+ * naive rendering is a megabyte of XML that browsers choke on, while the merged
+ * path is a few kilobytes and draws identically.
+ *
+ * @module render/svg
+ */
+const { normalizeOptions } = __require("render/options.js");
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeAttr(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/**
+ * Render to an SVG document.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {import('./options.js').RenderOptions} [options]
+ * @returns {string}
+ */
+function toSVG(matrix, options = {}) {
+  const opts = normalizeOptions(matrix, options);
+  const { scale, source, pixelWidth, pixelHeight, rowHeight } = opts;
+
+  let path = '';
+  for (let y = 0; y < source.height; y++) {
+    let x = 0;
+    while (x < source.width) {
+      if (!source.get(x, y)) { x++; continue; }
+      let run = 1;
+      while (x + run < source.width && source.get(x + run, y)) run++;
+      // Relative horizontal-vertical path commands: shorter than rects and
+      // free of the seams that appear between adjacent rects at some zooms.
+      path += `M${x * scale} ${y * rowHeight}h${run * scale}v${rowHeight}h${-run * scale}z`;
+      x += run;
+    }
+  }
+
+  const bg = opts.light === 'none'
+    ? ''
+    : `<rect width="${pixelWidth}" height="${pixelHeight}" fill="${escapeAttr(opts.light)}"/>`;
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${pixelWidth}" height="${pixelHeight}" ` +
+    `viewBox="0 0 ${pixelWidth} ${pixelHeight}" shape-rendering="crispEdges">` +
+    bg +
+    `<path d="${path}" fill="${escapeAttr(opts.dark)}"/>` +
+    '</svg>';
+}
+
+/**
+ * Base64 that works identically in Node and the browser.
+ *
+ * `btoa` is byte-oriented, so the UTF-8 encoding has to happen first — passing
+ * it a string with any character above U+00FF throws.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function toBase64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  if (typeof btoa === 'function') return btoa(binary);
+  // Node before btoa was global, and non-browser embedders.
+  /* eslint-disable-next-line no-undef */
   return Buffer.from(bytes).toString('base64');
 }
 
@@ -8466,6 +11510,9 @@ 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");
+const pdf417 = __require("pdf417/index.js");
+const micropdf417 = __require("micropdf417/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;
@@ -8478,6 +11525,9 @@ const __reexport6 = __require("render/index.js"); __exports.renderToCanvasAuto =
 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;
+const __reexport11 = __require("pdf417/index.js"); __exports.encodePDF417 = __reexport11.encodePDF417; __exports.decodePDF417 = __reexport11.decodePDF417; __exports.detectPDF417 = __reexport11.detectPDF417; __exports.detectAndDecodePDF417 = __reexport11.detectAndDecodePDF417;
+const __reexport12 = __require("micropdf417/index.js"); __exports.encodeMicroPDF417 = __reexport12.encodeMicroPDF417; __exports.decodeMicroPDF417 = __reexport12.decodeMicroPDF417; __exports.detectMicroPDF417 = __reexport12.detectMicroPDF417; __exports.detectAndDecodeMicroPDF417 = __reexport12.detectAndDecodeMicroPDF417;
 
 /**
  * @typedef {object} FormatInfo
@@ -8503,6 +11553,16 @@ 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';
+const pdf417CanEncode = typeof pdf417.encodePDF417 === 'function';
+// The matrix decoder is complete, but automatic image localization is still
+// limited to clean module-aligned symbols or an application-supplied
+// quadrilateral. Keep the generic scanner capability opt-in until a
+// perspective/noise corpus is passed.
+const pdf417CanDecode = typeof pdf417.detectAndDecodePDF417 === 'function';
+const microPdf417CanEncode = typeof micropdf417.encodeMicroPDF417 === 'function';
+const microPdf417CanDecode = typeof micropdf417.detectAndDecodeMicroPDF417 === 'function';
 
 /**
  * Every format this build supports.
@@ -8537,6 +11597,27 @@ function listFormats() {
     canRead: dataMatrixCanDecode,
     kind: /** @type {'2D'} */ ('2D'),
   });
+  formats.push({
+    id: 'aztec',
+    label: 'Aztec Code',
+    canWrite: aztecCanEncode,
+    canRead: aztecCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
+  formats.push({
+    id: 'pdf417',
+    label: 'PDF417',
+    canWrite: pdf417CanEncode,
+    canRead: pdf417CanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
+  formats.push({
+    id: 'micropdf417',
+    label: 'MicroPDF417',
+    canWrite: microPdf417CanEncode,
+    canRead: microPdf417CanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
 
   return formats;
 }
@@ -8557,6 +11638,16 @@ 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.
+ * @param {number} [options.eccLevel] PDF417 error-correction level, 0-8.
+ * @param {number} [options.columns] PDF417 columns, 1-30.
+ * @param {number} [options.rows] PDF417 rows, 3-90.
+ * @param {number} [options.rowHeight] PDF417 row height in modules.
+ * @param {'auto'|'text'|'byte'|'numeric'} [options.compaction] PDF417 compaction mode.
+ * @param {number} [options.eci] MicroPDF417 byte-compaction ECI assignment (3 or 26).
+ * @param {number} [options.aspectRatio] Preferred MicroPDF417 symbol aspect ratio.
  * @returns {BitMatrix}
  */
 function encode(text, options = {}) {
@@ -8569,10 +11660,19 @@ function encode(text, options = {}) {
   if (format === 'datamatrix' || format === 'data-matrix') {
     return datamatrix.encodeDataMatrix(value, options);
   }
+  if (format === 'aztec' || format === 'aztec-code') {
+    return aztec.encodeAztec(value, options);
+  }
+  if (format === 'pdf417' || format === 'pdf-417') {
+    return pdf417.encodePDF417(value, options);
+  }
+  if (format === 'micropdf417' || format === 'micro-pdf417' || format === 'micro-pdf-417') {
+    return micropdf417.encodeMicroPDF417(value, options);
+  }
 
   const entry = ONED_FORMATS[format];
   if (!entry) {
-    const known = [...Object.keys(ONED_FORMATS), 'qr', 'datamatrix'].join(', ');
+    const known = [...Object.keys(ONED_FORMATS), 'qr', 'datamatrix', 'aztec', 'pdf417', 'micropdf417'].join(', ');
     throw new EncodeError(`Unknown format "${format}". Known formats: ${known}`);
   }
   return entry.encode(value, options);
@@ -8582,9 +11682,19 @@ function encode(text, options = {}) {
  * @typedef {object} DecodeResult
  * @property {string} text
  * @property {string} format
- * @property {Uint8Array} [bytes] Raw payload, before text decoding.
+ * @property {Uint8Array} [bytes] Raw octets exposed by byte-oriented payload modes, before text decoding.
+ * @property {{mode: 'text'|'byte'|'numeric', text: string, bytes: Uint8Array, eci: number, latch: number|null, codewordStart: number, codewordEnd: number}[]} [segments] PDF417 compaction segments in source order.
  * @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.
+ * @property {number} [rows] PDF417 row count.
+ * @property {number} [columns] PDF417 column count.
+ * @property {number} [eccLevel] PDF417 error-correction level.
+ * @property {number} [rowHeight] PDF417 row height in modules.
+ * @property {number} [variant] MicroPDF417 predefined variant number.
+ * @property {number} [eccCodewords] MicroPDF417 fixed error-correction codewords.
  */
 
 /**
@@ -8606,6 +11716,9 @@ function decode(image, 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 wantPDF417 = !want || want.has('pdf417') || want.has('pdf-417');
+  const wantMicroPDF417 = !want || want.has('micropdf417') || want.has('micro-pdf417') || want.has('micro-pdf-417');
   const wantOneD = !want || [...want].some((f) => f in ONED_FORMATS);
 
   const source = LuminanceSource.fromImageData(image);
@@ -8643,6 +11756,45 @@ function decode(image, options = {}) {
       }
     }
 
+    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 (wantPDF417 && pdf417CanDecode) {
+      try {
+        const found = pdf417.detectAndDecodePDF417(bits);
+        if (found) results.push({ ...found, format: 'pdf417' });
+      } catch {
+        /* no PDF417 in this pass */
+      }
+    }
+
+    if (wantMicroPDF417 && microPdf417CanDecode) {
+      // MicroPDF417 detection measures runs across the whole raster. Hybrid
+      // thresholding can alter uniform modules near local-window boundaries,
+      // so retry the global threshold in auto mode as for the other 2D codes.
+      const microPdf417Bits = binarizer === 'auto' ? [bits, binarize(pass, 'global')] : [bits];
+      for (const candidateBits of microPdf417Bits) {
+        try {
+          const found = micropdf417.detectAndDecodeMicroPDF417(candidateBits);
+          if (found) { results.push({ ...found, format: 'micropdf417' }); break; }
+        } catch {
+          /* no MicroPDF417 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 })) {
@@ -8677,7 +11829,7 @@ function decodeStrict(image, options) {
 }
 
 /** Library version, matching package.json. */
-const VERSION = '1.0.0';
+const VERSION = '1.2.5';
 
 __exports.listFormats = listFormats;
 __exports.encode = encode;