@sythos/js_barcode_universal 1.5.7 → 1.5.9

package/src/js/image/luminance.js

@@ -0,0 +1,185 @@
+/*!
+ * 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.
+ */
+/**
+ * Greyscale conversion — the boundary between "an image" and "our problem".
+ *
+ * The whole library accepts exactly one image shape: `{ data, width, height }`
+ * with `data` in RGBA order. That is what `ImageData` is, so a `<canvas>`, an
+ * `OffscreenCanvas`, `createImageBitmap`, sharp, jimp and node-canvas all
+ * satisfy it without an adapter. Nothing below this file knows about the DOM,
+ * the filesystem, or any image codec.
+ *
+ * @module image/luminance
+ */
+import { NotFoundError } from '../core/errors.js';
+/**
+ * @typedef {object} ImageLike
+ * @property {Uint8ClampedArray | Uint8Array | number[]} data RGBA, 4 bytes per pixel.
+ * @property {number} width
+ * @property {number} height
+ */
+export class LuminanceSource {
+    /**
+     * @param {Uint8Array} grey One byte per pixel.
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(grey, width, height) {
+        this.grey = grey;
+        this.width = width;
+        this.height = height;
+    }
+    /**
+     * Build from any ImageData-shaped object.
+     *
+     * Transparent pixels are composited over white rather than read as black:
+     * a PNG barcode with a transparent background is common, and treating alpha
+     * as ink turns the entire quiet zone into a solid dark field.
+     *
+     * @param {ImageLike} image
+     * @returns {LuminanceSource}
+     */
+    static fromImageData(image) {
+        const { data, width, height } = image;
+        if (!data || !width || !height) {
+            throw new NotFoundError('Image must be { data, width, height } with RGBA data');
+        }
+        if (data.length < width * height * 4) {
+            throw new NotFoundError(`Image data too short: ${data.length} bytes for ${width}x${height} RGBA ` +
+                `(expected ${width * height * 4})`);
+        }
+        const grey = new Uint8Array(width * height);
+        for (let i = 0, p = 0; i < grey.length; i++, p += 4) {
+            const a = data[p + 3];
+            let r = data[p], g = data[p + 1], b = data[p + 2];
+            if (a !== 255) {
+                // Composite over white.
+                const inv = 255 - a;
+                r = (r * a + 255 * inv) / 255;
+                g = (g * a + 255 * inv) / 255;
+                b = (b * a + 255 * inv) / 255;
+            }
+            // Integer luma approximation of Rec. 601: 0.299/0.587/0.114 scaled by 256.
+            grey[i] = (r * 77 + g * 150 + b * 29) >> 8;
+        }
+        return new LuminanceSource(grey, width, height);
+    }
+    /**
+     * Build directly from single-channel data, skipping conversion.
+     *
+     * @param {Uint8Array} grey
+     * @param {number} width
+     * @param {number} height
+     * @returns {LuminanceSource}
+     */
+    static fromGrey(grey, width, height) {
+        if (grey.length < width * height) {
+            throw new NotFoundError('Greyscale buffer shorter than width * height');
+        }
+        return new LuminanceSource(grey, width, height);
+    }
+    /**
+     * @param {number} x @param {number} y
+     * @returns {number} 0-255.
+     */
+    get(x, y) {
+        return this.grey[y * this.width + x];
+    }
+    /**
+     * @param {number} y
+     * @param {Uint8Array} [out]
+     * @returns {Uint8Array}
+     */
+    getRow(y, out) {
+        const row = out && out.length >= this.width ? out : new Uint8Array(this.width);
+        row.set(this.grey.subarray(y * this.width, (y + 1) * this.width));
+        return row;
+    }
+    /**
+     * Rotate 90 degrees clockwise.
+     *
+     * The 1D readers scan horizontally, so this is how they find vertically
+     * oriented barcodes: scan, rotate, scan again.
+     *
+     * @returns {LuminanceSource}
+     */
+    rotate90() {
+        const { width: w, height: h, grey } = this;
+        const out = new Uint8Array(grey.length);
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                out[x * h + (h - 1 - y)] = grey[y * w + x];
+            }
+        }
+        return new LuminanceSource(out, h, w);
+    }
+    /**
+     * Downscale by an integer factor with box averaging.
+     *
+     * Large camera frames are slow to scan and no more informative than a
+     * half-size copy; detectors use this to find candidates cheaply.
+     *
+     * @param {number} factor
+     * @returns {LuminanceSource}
+     */
+    downscale(factor) {
+        const f = Math.max(1, Math.floor(factor));
+        if (f === 1)
+            return this;
+        const w = Math.floor(this.width / f);
+        const h = Math.floor(this.height / f);
+        const out = new Uint8Array(w * h);
+        const area = f * f;
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                let sum = 0;
+                for (let dy = 0; dy < f; dy++) {
+                    const base = (y * f + dy) * this.width + x * f;
+                    for (let dx = 0; dx < f; dx++)
+                        sum += this.grey[base + dx];
+                }
+                out[y * w + x] = (sum / area) | 0;
+            }
+        }
+        return new LuminanceSource(out, w, h);
+    }
+    /**
+     * Invert. Some symbols are printed light-on-dark, and readers retry inverted
+     * when a first pass finds nothing.
+     *
+     * @returns {LuminanceSource}
+     */
+    invert() {
+        const out = new Uint8Array(this.grey.length);
+        for (let i = 0; i < out.length; i++)
+            out[i] = 255 - this.grey[i];
+        return new LuminanceSource(out, this.width, this.height);
+    }
+}

package/src/js/image/perspective.js

@@ -0,0 +1,158 @@
+/*!
+ * 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.
+ */
+/**
+ * Projective (perspective) transforms.
+ *
+ * A 2D symbol photographed off-axis is not a rotated square — it is a
+ * quadrilateral with converging edges. Correcting that needs a full projective
+ * map, not an affine one; an affine approximation reads the near edge of a
+ * tilted symbol correctly and drifts a module or more by the far edge.
+ *
+ * The map is a 3x3 homogeneous matrix. Points are transformed as
+ * (x, y, 1) * M, then divided through by the resulting w.
+ *
+ * @module image/perspective
+ */
+export class PerspectiveTransform {
+    /* eslint-disable-next-line max-params */
+    constructor(a11, a21, a31, a12, a22, a32, a13, a23, a33) {
+        this.a11 = a11;
+        this.a21 = a21;
+        this.a31 = a31;
+        this.a12 = a12;
+        this.a22 = a22;
+        this.a32 = a32;
+        this.a13 = a13;
+        this.a23 = a23;
+        this.a33 = a33;
+    }
+    /**
+     * Transform points in place.
+     *
+     * @param {Float32Array | number[]} points Interleaved [x0, y0, x1, y1, ...].
+     * @returns {Float32Array | number[]} The same array.
+     */
+    transform(points) {
+        const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+        for (let i = 0; i < points.length; i += 2) {
+            const x = points[i];
+            const y = points[i + 1];
+            const w = a13 * x + a23 * y + a33;
+            points[i] = (a11 * x + a21 * y + a31) / w;
+            points[i + 1] = (a12 * x + a22 * y + a32) / w;
+        }
+        return points;
+    }
+    /**
+     * Transform a single point.
+     *
+     * @param {number} x @param {number} y
+     * @returns {{x: number, y: number}}
+     */
+    transformPoint(x, y) {
+        const w = this.a13 * x + this.a23 * y + this.a33;
+        return {
+            x: (this.a11 * x + this.a21 * y + this.a31) / w,
+            y: (this.a12 * x + this.a22 * y + this.a32) / w,
+        };
+    }
+    /**
+     * Map the unit square — (0,0), (1,0), (1,1), (0,1) — onto an arbitrary quad.
+     *
+     * Corners are given in that same order, i.e. going around the quad, not
+     * as opposite pairs.
+     *
+     * @returns {PerspectiveTransform}
+     */
+    /* eslint-disable-next-line max-params */
+    static squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3) {
+        const dx3 = x0 - x1 + x2 - x3;
+        const dy3 = y0 - y1 + y2 - y3;
+        if (dx3 === 0 && dy3 === 0) {
+            // The quad is a parallelogram, so the map is affine and the projective
+            // terms vanish. Worth special-casing: it is the common case for flat
+            // scans, and the general solution divides by zero here.
+            return new PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0, 0, 1);
+        }
+        const dx1 = x1 - x2;
+        const dx2 = x3 - x2;
+        const dy1 = y1 - y2;
+        const dy2 = y3 - y2;
+        const denominator = dx1 * dy2 - dx2 * dy1;
+        const a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
+        const a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
+        return new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1);
+    }
+    /**
+     * Map an arbitrary quad onto the unit square — the inverse of
+     * {@link squareToQuad}, via the adjugate.
+     *
+     * @returns {PerspectiveTransform}
+     */
+    /* eslint-disable-next-line max-params */
+    static quadToSquare(x0, y0, x1, y1, x2, y2, x3, y3) {
+        return PerspectiveTransform.squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3).inverse();
+    }
+    /**
+     * Map one quad onto another, corner for corner.
+     *
+     * This is what turns four detected finder corners into a sampling grid:
+     * compose "detected quad -> unit square" with "unit square -> ideal grid".
+     *
+     * @returns {PerspectiveTransform}
+     */
+    /* eslint-disable-next-line max-params */
+    static quadToQuad(sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3, dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3) {
+        const toSquare = PerspectiveTransform.quadToSquare(sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
+        const toQuad = PerspectiveTransform.squareToQuad(dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3);
+        return toSquare.times(toQuad);
+    }
+    /**
+     * Adjugate — the inverse up to a scale factor, which is irrelevant in
+     * homogeneous coordinates because the division by w cancels it.
+     *
+     * @returns {PerspectiveTransform}
+     */
+    inverse() {
+        const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+        return new PerspectiveTransform(a22 * a33 - a23 * a32, a23 * a31 - a21 * a33, a21 * a32 - a22 * a31, a13 * a32 - a12 * a33, a11 * a33 - a13 * a31, a12 * a31 - a11 * a32, a12 * a23 - a13 * a22, a13 * a21 - a11 * a23, a11 * a22 - a12 * a21);
+    }
+    /**
+     * Matrix product: apply `this` first, then `other`.
+     *
+     * @param {PerspectiveTransform} other
+     * @returns {PerspectiveTransform}
+     */
+    times(other) {
+        const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+        const o = other;
+        return new PerspectiveTransform(o.a11 * a11 + o.a21 * a12 + o.a31 * a13, o.a11 * a21 + o.a21 * a22 + o.a31 * a23, o.a11 * a31 + o.a21 * a32 + o.a31 * a33, o.a12 * a11 + o.a22 * a12 + o.a32 * a13, o.a12 * a21 + o.a22 * a22 + o.a32 * a23, o.a12 * a31 + o.a22 * a32 + o.a32 * a33, o.a13 * a11 + o.a23 * a12 + o.a33 * a13, o.a13 * a21 + o.a23 * a22 + o.a33 * a23, o.a13 * a31 + o.a23 * a32 + o.a33 * a33);
+    }
+}

package/src/js/micropdf417/compaction.js

@@ -0,0 +1,115 @@
+/*!
+ * 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/js/micropdf417/decoder.js

@@ -0,0 +1,180 @@
+/*!
+ * 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,
+    };
+}