@sythos/js_barcode_universal 1.1.0 → 1.2.5

package/bundle/sythos-barcode.js

@@ -1,5 +1,5 @@
 /*!
- * Sythos Barcode Suite v1.1.0
+ * Sythos Barcode Suite v1.2.5
  *
  * MIT License
  *
@@ -3066,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.
  *
@@ -3073,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);
@@ -3089,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.
@@ -3144,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`
     );
   }
 
@@ -3162,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;
@@ -3186,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;
@@ -8329,6 +8343,1916 @@ const __reexport2 = __require("aztec/detector.js"); __exports.detectAztec = __re
 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) {
@@ -9587,6 +11511,8 @@ 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;
@@ -9600,6 +11526,8 @@ const __reexport7 = __require("render/index.js"); __exports.renderToCanvasAutoAs
 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
@@ -9627,6 +11555,14 @@ 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.
@@ -9668,6 +11604,20 @@ function listFormats() {
     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;
 }
@@ -9691,6 +11641,13 @@ function listFormats() {
  * @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 = {}) {
@@ -9706,10 +11663,16 @@ function encode(text, 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', 'aztec'].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);
@@ -9719,12 +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.
  */
 
 /**
@@ -9747,6 +11717,8 @@ function decode(image, options = {}) {
   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);
@@ -9799,6 +11771,30 @@ function decode(image, options = {}) {
       }
     }
 
+    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 })) {
@@ -9833,7 +11829,7 @@ function decodeStrict(image, options) {
 }
 
 /** Library version, matching package.json. */
-const VERSION = '1.1.0';
+const VERSION = '1.2.5';
 
 __exports.listFormats = listFormats;
 __exports.encode = encode;