@sythos/js_barcode_universal 1.1.0 → 1.3.1

package/src/index.js

@@ -54,6 +54,11 @@ import { decodeOneD } from './oned/reader.js';
 import * as datamatrix from './datamatrix/index.js';
 import * as qr from './qr/index.js';
 import * as aztec from './aztec/index.js';
+import * as pdf417 from './pdf417/index.js';
+import * as micropdf417 from './micropdf417/index.js';
+import * as microqr from './microqr/index.js';
+import * as rmqr from './rmqr/index.js';
+import * as frameqr from './frameqr/index.js';
 
 export { BitMatrix };
 export {
@@ -72,6 +77,15 @@ export {
   encodeDataMatrix, decodeDataMatrix, detectDataMatrix, detectAndDecodeDataMatrix,
 } from './datamatrix/index.js';
 export { encodeAztec, decodeAztec, detectAztec, detectAndDecodeAztec } from './aztec/index.js';
+export { encodePDF417, decodePDF417, detectPDF417, detectAndDecodePDF417 } from './pdf417/index.js';
+export {
+  encodeMicroPDF417, decodeMicroPDF417, detectMicroPDF417, detectAndDecodeMicroPDF417,
+} from './micropdf417/index.js';
+export { encodeMicroQR, decodeMicroQR, detectMicroQR, detectAndDecodeMicroQR } from './microqr/index.js';
+export { encodeRMQR, decodeRMQR, detectRMQR, detectAndDecodeRMQR } from './rmqr/index.js';
+export {
+  encodeFrameQR, decodeFrameQR, detectFrameQR, detectAndDecodeFrameQR,
+} from './frameqr/index.js';
 
 /**
  * @typedef {object} FormatInfo
@@ -99,6 +113,20 @@ 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';
+const microQrCanEncode = typeof microqr.encodeMicroQR === 'function';
+const microQrCanDecode = typeof microqr.detectAndDecodeMicroQR === 'function';
+const rmqrCanEncode = typeof rmqr.encodeRMQR === 'function';
+const rmqrCanDecode = typeof rmqr.detectAndDecodeRMQR === 'function';
+const frameQrCanEncode = typeof frameqr.encodeFrameQR === 'function';
+const frameQrCanDecode = typeof frameqr.detectAndDecodeFrameQR === 'function';
 
 /**
  * Every format this build supports.
@@ -140,6 +168,41 @@ export 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'),
+  });
+  formats.push({
+    id: 'microqr',
+    label: 'Micro QR Code',
+    canWrite: microQrCanEncode,
+    canRead: microQrCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
+  formats.push({
+    id: 'rmqr',
+    label: 'rMQR Code',
+    canWrite: rmqrCanEncode,
+    canRead: rmqrCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
+  formats.push({
+    id: 'frameqr',
+    label: 'Sythos Canvas QR profile',
+    canWrite: frameQrCanEncode,
+    canRead: frameQrCanDecode,
+    kind: /** @type {'2D'} */ ('2D'),
+  });
 
   return formats;
 }
@@ -163,6 +226,21 @@ export 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.
+ * @param {object} [options.canvas] Sythos Canvas QR artwork reservation.
+ * @param {'square'|'circle'|'diamond'} [options.canvas.shape] Canvas shape.
+ * @param {number} [options.canvas.size] Odd canvas size in QR modules.
+ * @param {number} [options.canvas.width] Canvas width in QR modules.
+ * @param {number} [options.canvas.height] Canvas height in QR modules.
+ * @param {number} [options.canvas.centerX] Canvas centre X in QR modules.
+ * @param {number} [options.canvas.centerY] Canvas centre Y in QR modules.
+ * @param {0|90|180|270} [options.canvas.angle] Canvas quarter-turn.
  * @returns {BitMatrix}
  */
 export function encode(text, options = {}) {
@@ -178,10 +256,25 @@ export 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);
+  }
+  if (format === 'microqr' || format === 'micro-qr') {
+    return microqr.encodeMicroQR(value, options);
+  }
+  if (format === 'rmqr' || format === 'r-mqr' || format === 'rectangular-micro-qr') {
+    return rmqr.encodeRMQR(value, options);
+  }
+  if (format === 'frameqr' || format === 'frame-qr' || format === 'canvas-qr') {
+    return frameqr.encodeFrameQR(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', 'microqr', 'rmqr', 'frameqr'].join(', ');
     throw new EncodeError(`Unknown format "${format}". Known formats: ${known}`);
   }
   return entry.encode(value, options);
@@ -191,12 +284,22 @@ export 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.
+ * @property {string} [profile] Sythos Canvas QR profile identifier.
+ * @property {boolean} [certified] Whether the profile is certified by its originator.
+ * @property {object} [canvas] Canvas reservation metadata for the Sythos profile.
  */
 
 /**
@@ -211,6 +314,8 @@ export function encode(text, options = {}) {
  * @param {string[]} [options.formats] Restrict to these format ids.
  * @param {boolean} [options.tryHarder] Retry inverted and rotated. Default true.
  * @param {'global'|'hybrid'|'auto'} [options.binarizer]
+ * @param {object} [options.frameqr] Sythos Canvas QR detector options when
+ *   the profile marker is not preserved through image rendering.
  * @returns {DecodeResult[]}
  */
 export function decode(image, options = {}) {
@@ -219,6 +324,11 @@ export 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 wantMicroQR = !want || want.has('microqr') || want.has('micro-qr');
+  const wantRMQR = !want || want.has('rmqr') || want.has('r-mqr') || want.has('rectangular-micro-qr');
+  const wantFrameQR = !want || want.has('frameqr') || want.has('frame-qr') || want.has('canvas-qr');
   const wantOneD = !want || [...want].some((f) => f in ONED_FORMATS);
 
   const source = LuminanceSource.fromImageData(image);
@@ -271,6 +381,59 @@ export 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 (wantMicroQR && microQrCanDecode) {
+      try {
+        for (const found of microqr.detectAndDecodeMicroQR(bits)) {
+          results.push({ ...found, format: 'microqr' });
+        }
+      } catch {
+        /* no Micro QR in this pass */
+      }
+    }
+
+    if (wantRMQR && rmqrCanDecode) {
+      try {
+        const found = rmqr.detectAndDecodeRMQR(bits);
+        if (found) results.push({ ...found, format: 'rmqr' });
+      } catch {
+        /* no rMQR in this pass */
+      }
+    }
+
+    if (wantFrameQR && frameQrCanDecode) {
+      try {
+        for (const found of frameqr.detectAndDecodeFrameQR(bits, options.frameqr ?? {})) {
+          results.push({ ...found, format: 'frameqr' });
+        }
+      } catch {
+        /* no Sythos Canvas QR profile in this pass */
+      }
+    }
+
     if (wantOneD) {
       const oneDFormats = want ? [...want].filter((f) => f in ONED_FORMATS) : null;
       for (const found of decodeOneD(bits, { formats: oneDFormats, tryHarder })) {
@@ -305,4 +468,4 @@ export function decodeStrict(image, options) {
 }
 
 /** Library version, matching package.json. */
-export const VERSION = '1.1.0';
+export const VERSION = '1.3.1';

package/src/micropdf417/compaction.js

@@ -0,0 +1,116 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/** MicroPDF417 high-level compaction adapter. @module micropdf417/compaction */
+
+import { EncodeError } from '../core/errors.js';
+import {
+  compactPdf417Bytes,
+  compactPdf417Numeric,
+  compactPdf417Text,
+} from '../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.
+ */
+export 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);
+}

package/src/micropdf417/decoder.js

@@ -0,0 +1,183 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * 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
+ */
+
+import { FormatError } from '../core/errors.js';
+import { decodePdf417CompactionDetailed } from '../pdf417/compaction.js';
+import { pdf417CodewordForPattern } from '../pdf417/tables.js';
+import { microPdf417CorrectErrors } from './error-correction.js';
+import {
+  MICROPDF417_VARIANTS,
+  microPdf417RapSequence,
+  microPdf417RowAddress,
+  microPdf417VariantByNumber,
+} from './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.
+ */
+export 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,
+  };
+}