@sythos/js_barcode_universal 1.5.7 → 1.5.9

package/src/js/aztecrune/tables.js

@@ -0,0 +1,142 @@
+/*!
+ * 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.
+ */
+/**
+ * Aztec Rune geometry.
+ *
+ * Aztec Rune is the 11x11, one-byte member of the Aztec family. Two 4-bit
+ * data words and five 4-bit Reed-Solomon check words are XORed with the fixed
+ * Aztec Rune mask and written clockwise on the outer data ring. The finder and
+ * corner orientation marks are independent of the value.
+ *
+ * The constants below are derived from the public Aztec Code specification and
+ * are kept separate from the general Aztec implementation so a normal Aztec
+ * decoder can never accidentally treat an 11x11 Rune as a regular symbol.
+ *
+ * @module aztecrune/tables
+ */
+import { BitMatrix } from '../core/bit-matrix.js';
+import { fieldForWordSize } from '../aztec/tables.js';
+export const AZTEC_RUNE_SIZE = 11;
+export const AZTEC_RUNE_DATA_BITS = 8;
+export const AZTEC_RUNE_WORD_SIZE = 4;
+export const AZTEC_RUNE_DATA_CODEWORDS = 2;
+export const AZTEC_RUNE_ECC_CODEWORDS = 5;
+export const AZTEC_RUNE_TOTAL_CODEWORDS = AZTEC_RUNE_DATA_CODEWORDS + AZTEC_RUNE_ECC_CODEWORDS;
+export const AZTEC_RUNE_MASK = 0b1010;
+/**
+ * Data-module coordinates in wire order: clockwise, starting at the top.
+ * Every side contributes seven modules, for 28 bits in total.
+ */
+export const AZTEC_RUNE_DATA_POSITIONS = Object.freeze([
+    ...Array.from({ length: 7 }, (_, i) => [i + 2, 0]),
+    ...Array.from({ length: 7 }, (_, i) => [10, i + 2]),
+    ...Array.from({ length: 7 }, (_, i) => [8 - i, 10]),
+    ...Array.from({ length: 7 }, (_, i) => [0, 8 - i]),
+].map(([x, y]) => Object.freeze([x, y])));
+const DATA_KEYS = new Set(AZTEC_RUNE_DATA_POSITIONS.map(([x, y]) => `${x},${y}`));
+/** @param {number} x @param {number} y @returns {boolean} */
+export function isAztecRuneDataPosition(x, y) {
+    return DATA_KEYS.has(`${x},${y}`);
+}
+/**
+ * Return the value of a structural module. Data positions return `null`.
+ * The bull's-eye has five square rings including its one-module centre; its
+ * even-radius rings are dark. The four corner groups are the orientation marks
+ * described by the Aztec Rune specification.
+ *
+ * @param {number} x @param {number} y
+ * @returns {boolean|null}
+ */
+export function aztecRuneStructuralValue(x, y) {
+    if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || x >= AZTEC_RUNE_SIZE || y >= AZTEC_RUNE_SIZE) {
+        return null;
+    }
+    if (isAztecRuneDataPosition(x, y))
+        return null;
+    const distance = Math.max(Math.abs(x - 5), Math.abs(y - 5));
+    if (distance <= 4)
+        return (distance & 1) === 0;
+    // Corner orientation groups, clockwise from the upper-left corner:
+    // three dark, white-dark-dark, dark-white-white, three white.
+    if ((x === 0 && y <= 1) || (y === 0 && x <= 1))
+        return true;
+    if ((x === 10 && y <= 1) || (y === 0 && x === 10))
+        return true;
+    if (x === 9 && y === 0)
+        return false;
+    if (x === 10 && y === 10)
+        return false;
+    if (y === 10 && x >= 0 && x <= 1)
+        return false;
+    if (x === 0 && y >= 9)
+        return false;
+    if (x === 10 && y === 9)
+        return true;
+    // All non-data cells are covered by the bull's-eye or the four corners.
+    return false;
+}
+/** Build only the fixed finder/orientation structure. */
+export function buildAztecRuneStructure() {
+    const matrix = new BitMatrix(AZTEC_RUNE_SIZE);
+    for (let y = 0; y < AZTEC_RUNE_SIZE; y++) {
+        for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
+            const value = aztecRuneStructuralValue(x, y);
+            if (value === true)
+                matrix.set(x, y);
+        }
+    }
+    return matrix;
+}
+/** Return the field used by Rune data/check words. */
+export function aztecRuneField() {
+    return fieldForWordSize(AZTEC_RUNE_WORD_SIZE);
+}
+/** Validate the fixed Rune contract and coordinate layout. */
+export function validateAztecRuneTables() {
+    const problems = [];
+    if (AZTEC_RUNE_SIZE !== 11)
+        problems.push('Rune symbol size must be 11');
+    if (AZTEC_RUNE_TOTAL_CODEWORDS * AZTEC_RUNE_WORD_SIZE !== 28)
+        problems.push('Rune outer ring must carry 28 bits');
+    if (AZTEC_RUNE_DATA_POSITIONS.length !== 28)
+        problems.push('Rune data ring must contain 28 modules');
+    if (new Set(AZTEC_RUNE_DATA_POSITIONS.map(([x, y]) => `${x},${y}`)).size !== 28)
+        problems.push('Rune data coordinates must be unique');
+    const structure = buildAztecRuneStructure();
+    for (let y = 0; y < AZTEC_RUNE_SIZE; y++)
+        for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
+            if (isAztecRuneDataPosition(x, y))
+                continue;
+            const expected = aztecRuneStructuralValue(x, y) === true;
+            if (structure.get(x, y) !== expected)
+                problems.push(`Rune structure mismatch at ${x},${y}`);
+        }
+    return problems;
+}

package/src/js/compactpdf417/decoder.js

@@ -0,0 +1,123 @@
+/*!
+ * 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.
+ */
+/** Compact PDF417 decoder. @module compactpdf417/decoder */
+import { FormatError } from '../core/errors.js';
+import { decodePdf417CompactionDetailed } from '../pdf417/compaction.js';
+import { pdf417CorrectErrors, pdf417EccLength } from '../pdf417/error-correction.js';
+import { pdf417CodewordForPattern } from '../pdf417/tables.js';
+import { COMPACT_PDF417_START_BITS, compactPdf417Geometry, compactPdf417MatchingLevels, } from './tables.js';
+function bits(matrix, y, x, width) {
+    let value = 0;
+    for (let index = 0; index < width; index++)
+        value = (value << 1) | (matrix.get(x + index, y) ? 1 : 0);
+    return value;
+}
+function patternString(matrix, y, x, width) {
+    return bits(matrix, y, x, width).toString(2).padStart(width, '0');
+}
+/**
+ * Decode a compact/truncated PDF417 module matrix.
+ *
+ * The high-level payload uses the normal PDF417 Text/Byte/Numeric compaction
+ * rules. This function only changes the physical row parser: no right row
+ * indicator is expected and the final module of each row must be dark.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {object} [options]
+ * @param {number} [options.rowHeight]
+ */
+export function decodeCompactPDF417(matrix, options = {}) {
+    if (!matrix?.width || !matrix?.height)
+        throw new FormatError('Compact PDF417: no matrix supplied');
+    const rowHeight = options.rowHeight ?? matrix.compactPdf417?.rowHeight ?? 3;
+    let geometry;
+    try {
+        geometry = compactPdf417Geometry(matrix.width, matrix.height, rowHeight);
+    }
+    catch (error) {
+        throw new FormatError(error.message);
+    }
+    const { rows, columns } = geometry;
+    const all = [];
+    const erasures = [];
+    const leftIndicators = [];
+    for (let row = 0; row < rows; row++) {
+        const y = row * rowHeight;
+        if (patternString(matrix, y, 0, 17) !== COMPACT_PDF417_START_BITS) {
+            throw new FormatError('Compact PDF417: missing start pattern');
+        }
+        const cluster = (row % 3) * 3;
+        const leftDecoded = pdf417CodewordForPattern(bits(matrix, y, 17, 17));
+        if (!leftDecoded || leftDecoded.cluster !== cluster) {
+            throw new FormatError('Compact PDF417: invalid left row indicator');
+        }
+        leftIndicators.push(leftDecoded.codeword);
+        const dataStart = 34;
+        const stopX = dataStart + columns * 17;
+        if (!matrix.get(stopX, y))
+            throw new FormatError('Compact PDF417: missing reduced stop module');
+        for (let column = 0; column < columns; column++) {
+            const decoded = pdf417CodewordForPattern(bits(matrix, y, dataStart + column * 17, 17));
+            if (!decoded || decoded.cluster !== cluster) {
+                erasures.push(all.length);
+                all.push(0);
+            }
+            else {
+                all.push(decoded.codeword);
+            }
+        }
+    }
+    const levels = compactPdf417MatchingLevels(leftIndicators, rows, columns);
+    if (levels.length !== 1)
+        throw new FormatError('Compact PDF417: row indicator mismatch');
+    const level = levels[0];
+    const eccLength = pdf417EccLength(level);
+    if (all.length <= eccLength)
+        throw new FormatError('Compact PDF417: insufficient codewords for ECC');
+    const corrected = all.slice();
+    const corrections = pdf417CorrectErrors(corrected, level, erasures);
+    const length = corrected[0];
+    if (length < 1 || length > corrected.length - eccLength) {
+        throw new FormatError('Compact PDF417: invalid symbol length descriptor');
+    }
+    const payload = corrected.slice(1, length);
+    const decoded = decodePdf417CompactionDetailed(payload);
+    return {
+        ...decoded,
+        format: 'compact-pdf417',
+        compact: true,
+        codewords: corrected,
+        rows,
+        columns,
+        eccLevel: level,
+        rowHeight,
+        corrections,
+    };
+}

package/src/js/compactpdf417/detector.js

@@ -0,0 +1,138 @@
+/*!
+ * 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.
+ */
+/** Compact PDF417 detector for clean, integer-scaled rasters. @module compactpdf417/detector */
+import { BitMatrix } from '../core/bit-matrix.js';
+import { compactPdf417Width } from './tables.js';
+import { decodeCompactPDF417 } from './decoder.js';
+function rotateClockwise(source) {
+    const out = 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))
+                out.set(source.height - 1 - y, x);
+        }
+    }
+    return out;
+}
+function cropAndDownsample(source, box, width, height, scale) {
+    const out = new BitMatrix(width, height);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let dark = 0;
+            for (let dy = 0; dy < scale; dy++) {
+                for (let dx = 0; dx < scale; dx++) {
+                    if (source.get(box.x + x * scale + dx, box.y + y * scale + dy))
+                        dark++;
+                }
+            }
+            if (dark * 2 >= scale * scale)
+                out.set(x, y);
+        }
+    }
+    return out;
+}
+function cornersFor(box) {
+    return [
+        { x: box.x, y: box.y },
+        { x: box.x + box.width, y: box.y },
+        { x: box.x + box.width, y: box.y + box.height },
+        { x: box.x, y: box.y + box.height },
+    ];
+}
+function mapCorners(corners, toOriginal) {
+    return corners.map((point) => toOriginal(point));
+}
+/**
+ * Detect one Compact PDF417 symbol in a binarized raster.
+ *
+ * The clean-raster detector uses the dark bounding box and enumerates legal
+ * compact widths, integer module scales, row counts and row heights. It is
+ * deliberately conservative: arbitrary perspective, non-integer resampling,
+ * grayscale thresholding and damaged stop bars belong to a future photo
+ * detector and are not claimed here.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @param {object} [options]
+ * @param {number} [options.rowHeight] Restrict the row-height search.
+ * @returns {object|null}
+ */
+export function detectCompactPDF417(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 rotation = 0; rotation < 4; rotation++) {
+        const bounds = oriented.getBounds();
+        if (bounds) {
+            for (let columns = 1; columns <= 30; columns++) {
+                const width = compactPdf417Width(columns);
+                const scale = bounds.width / width;
+                if (!Number.isInteger(scale) || scale < 1)
+                    continue;
+                const baseHeight = bounds.height / scale;
+                const rowHeights = Number.isInteger(options.rowHeight)
+                    ? [options.rowHeight]
+                    : Array.from({ length: 18 }, (_, index) => index + 3);
+                for (const rowHeight of rowHeights) {
+                    if (!Number.isInteger(baseHeight / rowHeight))
+                        continue;
+                    const rows = baseHeight / rowHeight;
+                    if (rows < 3 || rows > 90)
+                        continue;
+                    const matrix = cropAndDownsample(oriented, bounds, width, baseHeight, scale);
+                    try {
+                        const result = decodeCompactPDF417(matrix, { rowHeight });
+                        const corners = mapCorners(cornersFor(bounds), toOriginal);
+                        return {
+                            ...result,
+                            matrix,
+                            corners,
+                            rotation: rotation * 90,
+                            moduleSize: scale,
+                            compact: true,
+                        };
+                    }
+                    catch {
+                        // Try another geometry; a standard PDF417 or random artwork should
+                        // never be accepted unless the compact decoder validates every row.
+                    }
+                }
+            }
+        }
+        const previous = oriented;
+        const previousToOriginal = toOriginal;
+        oriented = rotateClockwise(previous);
+        toOriginal = (point) => previousToOriginal({ x: point.y, y: previous.height - point.x });
+    }
+    return null;
+}
+export function detectAndDecodeCompactPDF417(binaryImage, options = {}) {
+    return detectCompactPDF417(binaryImage, options);
+}

package/src/js/compactpdf417/encoder.js

@@ -0,0 +1,127 @@
+/*!
+ * 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.
+ */
+/** Compact PDF417 (truncated PDF417) encoder. @module compactpdf417/encoder */
+import { BitMatrix } from '../core/bit-matrix.js';
+import { EncodeError } from '../core/errors.js';
+import { compactPdf417 } from '../pdf417/compaction.js';
+import { pdf417ErrorCorrection, pdf417EccLength } from '../pdf417/error-correction.js';
+import { pdf417PatternForCodeword } from '../pdf417/tables.js';
+import { COMPACT_PDF417_START, compactPdf417Indicators, compactPdf417Width, validateCompactPdf417Options, } from './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 > 8) {
+            throw new EncodeError('Compact PDF417: invalid module-width sequence');
+        }
+        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 dimensions(needed, level, options, rowHeight) {
+    const ecc = pdf417EccLength(level);
+    let best = null;
+    for (let rows = options.rows ?? 3; rows <= (options.rows ?? 90); rows++) {
+        for (let columns = options.columns ?? 1; columns <= (options.columns ?? 30); columns++) {
+            if (rows * columns > 928 || rows * columns - ecc < needed)
+                continue;
+            const ratio = compactPdf417Width(columns) / (rows * rowHeight);
+            const score = (rows * columns - ecc - needed) * 10 +
+                Math.abs(ratio - (options.aspectRatio ?? 3));
+            if (!best || score < best.score)
+                best = { rows, columns, score };
+        }
+    }
+    if (!best) {
+        throw new EncodeError('Compact PDF417: payload does not fit the requested dimensions and error correction level');
+    }
+    return best;
+}
+/**
+ * Encode Compact PDF417.
+ *
+ * High-level Text/Byte/Numeric compaction is intentionally delegated to the
+ * existing PDF417 compaction implementation. `compact` here describes only
+ * the physical truncated layout: right row indicators are omitted and the
+ * stop pattern is reduced to one dark module.
+ *
+ * @param {string|Uint8Array|number[]} value
+ * @param {object} [options]
+ * @returns {import('../core/bit-matrix.js').BitMatrix}
+ */
+export function encodeCompactPDF417(value, options = {}) {
+    const rowHeight = validateCompactPdf417Options(options);
+    const level = options.eccLevel ?? 2;
+    if (!Number.isInteger(level) || level < 0 || level > 8) {
+        throw new EncodeError('Compact PDF417: eccLevel must be an integer in 0..8');
+    }
+    const payload = compactPdf417(value, { compaction: options.compaction, charset: options.charset });
+    const { rows, columns } = dimensions(payload.length + 1, level, options, rowHeight);
+    const eccLength = pdf417EccLength(level);
+    const dataLength = rows * columns - eccLength;
+    const data = [dataLength, ...payload];
+    while (data.length < dataLength)
+        data.push(900);
+    const codewords = data.concat(pdf417ErrorCorrection(data, level));
+    const matrix = new BitMatrix(compactPdf417Width(columns), rows * rowHeight);
+    for (let row = 0; row < rows; row++) {
+        const y = row * rowHeight;
+        const cluster = (row % 3) * 3;
+        let x = appendWidths(matrix, y, 0, COMPACT_PDF417_START, rowHeight);
+        const left = compactPdf417Indicators(row, rows, columns, level);
+        x = appendWidths(matrix, y, x, patternSequence(pdf417PatternForCodeword(left, cluster)), rowHeight);
+        for (let column = 0; column < columns; column++) {
+            const codeword = codewords[row * columns + column];
+            x = appendWidths(matrix, y, x, patternSequence(pdf417PatternForCodeword(codeword, cluster)), rowHeight);
+        }
+        // Compact PDF417 terminates every row with one dark module, not the normal
+        // right indicator plus 18-module stop pattern.
+        matrix.setRegion(x, y, 1, rowHeight);
+        x++;
+        if (x !== matrix.width)
+            throw new EncodeError('Compact PDF417: internal row width mismatch');
+    }
+    matrix.compactPdf417 = {
+        rows,
+        columns,
+        eccLevel: level,
+        rowHeight,
+        codewords,
+        layout: 'compact',
+    };
+    return matrix;
+}
+export { dimensions as compactPdf417Dimensions };

package/src/js/compactpdf417/index.js

@@ -0,0 +1,5 @@
+/* Compact PDF417 public module exports. */
+export { COMPACT_PDF417_START, COMPACT_PDF417_START_BITS, COMPACT_PDF417_STOP_MODULES, COMPACT_PDF417_LIMITS, compactPdf417Width, compactPdf417Geometry, compactPdf417Indicators, compactPdf417MatchingLevels, validateCompactPdf417Options, validateCompactPdf417Tables, } from './tables.js';
+export { encodeCompactPDF417, compactPdf417Dimensions } from './encoder.js';
+export { decodeCompactPDF417 } from './decoder.js';
+export { detectCompactPDF417, detectAndDecodeCompactPDF417 } from './detector.js';