@sythos/js_barcode_universal 1.5.7 → 1.5.9

package/src/js/compactpdf417/tables.js

@@ -0,0 +1,164 @@
+/*!
+ * 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 (truncated) PDF417 layout.
+ *
+ * Compact PDF417 is a geometric variant of PDF417, not a new high-level
+ * compaction mode. It keeps the same codeword, cluster, row-indicator,
+ * Reed–Solomon and Text/Byte/Numeric compaction rules, while omitting each
+ * row's right row indicator and replacing the normal stop pattern with a
+ * single dark module. The resulting symbol remains distinguishable from the
+ * ordinary PDF417 layout by its width and row terminator.
+ *
+ * @module compactpdf417/tables
+ */
+import { EncodeError } from '../core/errors.js';
+/** PDF417 start pattern, in module widths. */
+export const COMPACT_PDF417_START = '81111113';
+/** Binary module representation of the start pattern. */
+export const COMPACT_PDF417_START_BITS = '11111111010101000';
+/** Compact PDF417's reduced stop is one dark module. */
+export const COMPACT_PDF417_STOP_MODULES = 1;
+/** Minimum/maximum number of rows and data columns. */
+export const COMPACT_PDF417_LIMITS = Object.freeze({
+    minRows: 3,
+    maxRows: 90,
+    minColumns: 1,
+    maxColumns: 30,
+    maxCodewords: 928,
+});
+/**
+ * Return the printed width in modules for a compact symbol.
+ *
+ * 17 start + 17 left indicator + 17 per codeword column + 1 reduced stop.
+ * @param {number} columns
+ */
+export function compactPdf417Width(columns) {
+    if (!Number.isInteger(columns) || columns < 1 || columns > 30) {
+        throw new RangeError(`Compact PDF417: columns must be an integer in 1..30, got ${columns}`);
+    }
+    return 35 + columns * 17;
+}
+/**
+ * Validate a compact matrix geometry and return its dimensions.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {number} rowHeight
+ */
+export function compactPdf417Geometry(width, height, rowHeight = 3) {
+    if (!Number.isInteger(width) || !Number.isInteger(height)) {
+        throw new RangeError('Compact PDF417: matrix dimensions must be integers');
+    }
+    if (!Number.isInteger(rowHeight) || rowHeight < 1) {
+        throw new RangeError('Compact PDF417: rowHeight must be a positive integer');
+    }
+    if ((width - 35) % 17 !== 0) {
+        throw new RangeError(`Compact PDF417: width ${width} does not match the compact layout`);
+    }
+    const columns = (width - 35) / 17;
+    const rows = height / rowHeight;
+    if (!Number.isInteger(rows) || rows < 3 || rows > 90) {
+        throw new RangeError(`Compact PDF417: rows must be an integer in 3..90, got ${rows}`);
+    }
+    if (columns < 1 || columns > 30) {
+        throw new RangeError(`Compact PDF417: columns must be an integer in 1..30, got ${columns}`);
+    }
+    return { rows, columns, rowHeight, width, height };
+}
+/**
+ * Validate encoder dimensions before codeword packing.
+ * @param {object} options
+ */
+export function validateCompactPdf417Options(options = {}) {
+    const { minRows, maxRows, minColumns, maxColumns } = COMPACT_PDF417_LIMITS;
+    const rowHeight = options.rowHeight ?? 3;
+    if (!Number.isInteger(rowHeight) || rowHeight < 3) {
+        throw new EncodeError('Compact PDF417: rowHeight must be an integer of at least 3');
+    }
+    for (const [name, value, min, max] of [
+        ['rows', options.rows, minRows, maxRows],
+        ['columns', options.columns, minColumns, maxColumns],
+    ]) {
+        if (value !== undefined && (!Number.isInteger(value) || value < min || value > max)) {
+            throw new EncodeError(`Compact PDF417: ${name} must be an integer in ${min}..${max}`);
+        }
+    }
+    if (options.aspectRatio !== undefined &&
+        (!Number.isFinite(options.aspectRatio) || options.aspectRatio <= 0)) {
+        throw new EncodeError('Compact PDF417: aspectRatio must be positive');
+    }
+    return rowHeight;
+}
+/**
+ * The row indicator values used by ordinary PDF417 are retained unchanged.
+ * Compact symbols omit only the right indicator, so the left indicator still
+ * carries the row group, row count, error-correction level and column count.
+ */
+export function compactPdf417Indicators(row, rows, columns, level) {
+    const group = Math.floor(row / 3);
+    const y = Math.floor((rows - 1) / 3);
+    const z = level * 3 + (rows - 1) % 3;
+    const v = columns - 1;
+    if (row % 3 === 0)
+        return 30 * group + y;
+    if (row % 3 === 1)
+        return 30 * group + z;
+    return 30 * group + v;
+}
+/**
+ * Return all standard ECC levels which agree with the observed left
+ * indicators. This is kept as a table helper so decoder and tests share the
+ * same compact-layout rule.
+ */
+export function compactPdf417MatchingLevels(leftIndicators, rows, columns) {
+    const matches = [];
+    for (let level = 0; level <= 8; level++) {
+        if (leftIndicators.every((value, row) => value === compactPdf417Indicators(row, rows, columns, level)))
+            matches.push(level);
+    }
+    return matches;
+}
+/** Validate representative layout invariants. */
+export function validateCompactPdf417Tables() {
+    const problems = [];
+    for (const columns of [1, 2, 3, 10, 30]) {
+        const width = compactPdf417Width(columns);
+        if (width !== 35 + columns * 17)
+            problems.push(`columns ${columns}: width mismatch`);
+    }
+    for (const rows of [3, 4, 5, 6, 90]) {
+        const left = Array.from({ length: rows }, (_, row) => compactPdf417Indicators(row, rows, 3, 2));
+        if (compactPdf417MatchingLevels(left, rows, 3).length !== 1) {
+            problems.push(`rows ${rows}: row indicators do not identify one ECC level`);
+        }
+    }
+    return problems;
+}

package/src/js/core/bit-buffer.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.
+ */
+/**
+ * Bit-level writing and reading, MSB-first.
+ *
+ * Every 2D symbology serialises its payload as a bitstream that does not
+ * respect byte boundaries — QR alone mixes 4-bit mode indicators, 10-bit
+ * character-count fields and 11-bit alphanumeric pairs. These two classes are
+ * the write and read halves of that.
+ *
+ * @module core/bit-buffer
+ */
+import { FormatError } from './errors.js';
+/** Growable MSB-first bit writer. */
+export class BitWriter {
+    constructor() {
+        /** @type {number[]} Packed bytes; the last one may be partially filled. */
+        this.bytes = [];
+        this.bitLength = 0;
+    }
+    /** @returns {number} Bits written so far. */
+    get length() {
+        return this.bitLength;
+    }
+    /**
+     * Append the low `count` bits of `value`, most significant first.
+     *
+     * @param {number} value
+     * @param {number} count
+     */
+    put(value, count) {
+        for (let i = count - 1; i >= 0; i--) {
+            this.putBit(((value >>> i) & 1) === 1);
+        }
+    }
+    /** @param {boolean} bit */
+    putBit(bit) {
+        const idx = this.bitLength >>> 3;
+        if (this.bytes.length <= idx)
+            this.bytes.push(0);
+        if (bit)
+            this.bytes[idx] |= 0x80 >>> (this.bitLength & 7);
+        this.bitLength++;
+    }
+    /** @param {ArrayLike<number>} data */
+    putBytes(data) {
+        for (let i = 0; i < data.length; i++)
+            this.put(data[i], 8);
+    }
+    /** Pad with zero bits until the length is a multiple of 8. */
+    padToByte() {
+        while (this.bitLength & 7)
+            this.putBit(false);
+    }
+    /**
+     * @returns {Uint8Array} Byte view; trailing bits of the final byte are zero.
+     */
+    toBytes() {
+        return Uint8Array.from(this.bytes);
+    }
+    /** @returns {string} Debug view, e.g. "0100 0011 0101". */
+    toString() {
+        let s = '';
+        for (let i = 0; i < this.bitLength; i++) {
+            if (i && i % 4 === 0)
+                s += ' ';
+            s += (this.bytes[i >>> 3] >>> (7 - (i & 7))) & 1;
+        }
+        return s;
+    }
+}
+/** MSB-first bit reader over a byte array. */
+export class BitReader {
+    /** @param {ArrayLike<number>} bytes */
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.byteOffset = 0;
+        this.bitOffset = 0;
+    }
+    /** @returns {number} Bits not yet consumed. */
+    available() {
+        return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;
+    }
+    /**
+     * Read `count` bits (1..32) as an unsigned integer, most significant first.
+     *
+     * @param {number} count
+     * @returns {number}
+     * @throws {FormatError} If the stream is exhausted.
+     */
+    read(count) {
+        if (count < 1 || count > 32) {
+            throw new FormatError(`BitReader: cannot read ${count} bits`);
+        }
+        if (count > this.available()) {
+            throw new FormatError(`BitReader: needed ${count} bits, ${this.available()} remain`);
+        }
+        let result = 0;
+        let remaining = count;
+        // Finish the partially consumed byte first, then take whole bytes.
+        if (this.bitOffset > 0) {
+            const inCurrent = 8 - this.bitOffset;
+            const take = Math.min(remaining, inCurrent);
+            const shift = inCurrent - take;
+            const mask = (0xff >> this.bitOffset) & ~((1 << shift) - 1);
+            result = (this.bytes[this.byteOffset] & mask) >> shift;
+            remaining -= take;
+            this.bitOffset += take;
+            if (this.bitOffset === 8) {
+                this.bitOffset = 0;
+                this.byteOffset++;
+            }
+        }
+        while (remaining >= 8) {
+            result = (result << 8) | (this.bytes[this.byteOffset] & 0xff);
+            this.byteOffset++;
+            remaining -= 8;
+        }
+        if (remaining > 0) {
+            const shift = 8 - remaining;
+            const mask = ~((1 << shift) - 1) & 0xff;
+            result = (result << remaining) | ((this.bytes[this.byteOffset] & mask) >> shift);
+            this.bitOffset += remaining;
+        }
+        return result >>> 0;
+    }
+    /** @returns {boolean} */
+    readBit() {
+        return this.read(1) === 1;
+    }
+}

package/src/js/core/bit-matrix.js

@@ -0,0 +1,243 @@
+/*!
+ * 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.
+ */
+/**
+ * A 2D bit grid — the common currency of this library.
+ *
+ * Every writer produces one; every reader consumes one; every renderer draws
+ * one. Keeping it as the single interchange type is what lets formats and
+ * output targets stay independent of each other.
+ *
+ * Storage is row-packed into a Uint32Array: one allocation, cache-friendly row
+ * scans, and cheap whole-row operations for the 1D readers.
+ *
+ * Convention: a set bit is a DARK module (ink). This matches how symbols are
+ * described in every specification, and renderers invert as needed.
+ *
+ * @module core/bit-matrix
+ */
+export class BitMatrix {
+    /**
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width, height = width) {
+        if (width < 1 || height < 1) {
+            throw new Error(`BitMatrix: dimensions must be positive, got ${width}x${height}`);
+        }
+        this.width = width;
+        this.height = height;
+        this.rowWords = Math.ceil(width / 32);
+        this.bits = new Uint32Array(this.rowWords * height);
+    }
+    /**
+     * @param {number} x @param {number} y
+     * @returns {boolean} True if the module is dark.
+     */
+    get(x, y) {
+        if (x < 0 || y < 0 || x >= this.width || y >= this.height)
+            return false;
+        return ((this.bits[y * this.rowWords + (x >>> 5)] >>> (x & 31)) & 1) === 1;
+    }
+    /** @param {number} x @param {number} y */
+    set(x, y) {
+        if (x < 0 || y < 0 || x >= this.width || y >= this.height)
+            return;
+        this.bits[y * this.rowWords + (x >>> 5)] |= 1 << (x & 31);
+    }
+    /** @param {number} x @param {number} y */
+    unset(x, y) {
+        if (x < 0 || y < 0 || x >= this.width || y >= this.height)
+            return;
+        this.bits[y * this.rowWords + (x >>> 5)] &= ~(1 << (x & 31));
+    }
+    /** @param {number} x @param {number} y */
+    flip(x, y) {
+        if (x < 0 || y < 0 || x >= this.width || y >= this.height)
+            return;
+        this.bits[y * this.rowWords + (x >>> 5)] ^= 1 << (x & 31);
+    }
+    /**
+     * @param {number} x @param {number} y @param {boolean} value
+     */
+    setValue(x, y, value) {
+        if (value)
+            this.set(x, y);
+        else
+            this.unset(x, y);
+    }
+    /** Fill a rectangle. @param {number} x @param {number} y @param {number} w @param {number} h */
+    setRegion(x, y, w, h) {
+        for (let j = y; j < y + h; j++) {
+            for (let i = x; i < x + w; i++)
+                this.set(i, j);
+        }
+    }
+    clear() {
+        this.bits.fill(0);
+    }
+    /** @returns {BitMatrix} */
+    clone() {
+        const m = new BitMatrix(this.width, this.height);
+        m.bits.set(this.bits);
+        return m;
+    }
+    /**
+     * Copy row `y` into a reusable array, avoiding an allocation per row in the
+     * 1D scanning loops which run this thousands of times per image.
+     *
+     * @param {number} y
+     * @param {Uint8Array} [out]
+     * @returns {Uint8Array}
+     */
+    getRow(y, out) {
+        const row = out && out.length >= this.width ? out : new Uint8Array(this.width);
+        const base = y * this.rowWords;
+        for (let x = 0; x < this.width; x++) {
+            row[x] = (this.bits[base + (x >>> 5)] >>> (x & 31)) & 1;
+        }
+        return row;
+    }
+    /**
+     * Add a uniform light border. Symbols need a quiet zone to be scannable at
+     * all, so this is applied by default when rendering.
+     *
+     * @param {number} size Modules of margin on every side.
+     * @returns {BitMatrix}
+     */
+    withMargin(size) {
+        if (size <= 0)
+            return this.clone();
+        const m = new BitMatrix(this.width + size * 2, this.height + size * 2);
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                if (this.get(x, y))
+                    m.set(x + size, y + size);
+            }
+        }
+        return m;
+    }
+    /**
+     * Nearest-neighbour upscale. Integer factors only — a barcode resampled with
+     * interpolation stops being readable.
+     *
+     * @param {number} factor
+     * @returns {BitMatrix}
+     */
+    scale(factor) {
+        const f = Math.max(1, Math.floor(factor));
+        if (f === 1)
+            return this.clone();
+        const m = new BitMatrix(this.width * f, this.height * f);
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                if (this.get(x, y))
+                    m.setRegion(x * f, y * f, f, f);
+            }
+        }
+        return m;
+    }
+    /**
+     * Bounding box of the dark modules, or null if the matrix is empty.
+     * @returns {{x: number, y: number, width: number, height: number} | null}
+     */
+    getBounds() {
+        let minX = this.width, minY = this.height, maxX = -1, maxY = -1;
+        for (let y = 0; y < this.height; y++) {
+            for (let x = 0; x < this.width; x++) {
+                if (this.get(x, y)) {
+                    if (x < minX)
+                        minX = x;
+                    if (x > maxX)
+                        maxX = x;
+                    if (y < minY)
+                        minY = y;
+                    if (y > maxY)
+                        maxY = y;
+                }
+            }
+        }
+        if (maxX < 0)
+            return null;
+        return { x: minX, y: minY, width: maxX - minX + 1, height: maxY - minY + 1 };
+    }
+    /**
+     * Rotate 180 degrees, in place. Cheaper than re-detecting when a reader
+     * discovers a symbol is upside down.
+     */
+    rotate180() {
+        const w = this.width, h = this.height;
+        for (let y = 0; y < Math.ceil(h / 2); y++) {
+            for (let x = 0; x < w; x++) {
+                const oy = h - 1 - y, ox = w - 1 - x;
+                if (y === oy && x >= ox)
+                    break;
+                const a = this.get(x, y);
+                const b = this.get(ox, oy);
+                this.setValue(x, y, b);
+                this.setValue(ox, oy, a);
+            }
+        }
+    }
+    /**
+     * Build from a string of '1'/'X'/'#' (dark) and anything else (light),
+     * newline-separated. Test fixtures are far more legible this way.
+     *
+     * @param {string} text
+     * @returns {BitMatrix}
+     */
+    static parse(text) {
+        const lines = text.trim().split('\n').map((l) => l.trim()).filter((l) => l.length);
+        const height = lines.length;
+        const width = Math.max(...lines.map((l) => l.length));
+        const m = new BitMatrix(width, height);
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < lines[y].length; x++) {
+                const c = lines[y][x];
+                if (c === '1' || c === 'X' || c === 'x' || c === '#')
+                    m.set(x, y);
+            }
+        }
+        return m;
+    }
+    /**
+     * @param {string} [dark] @param {string} [light]
+     * @returns {string}
+     */
+    toString(dark = '##', light = '  ') {
+        const rows = [];
+        for (let y = 0; y < this.height; y++) {
+            let s = '';
+            for (let x = 0; x < this.width; x++)
+                s += this.get(x, y) ? dark : light;
+            rows.push(s);
+        }
+        return rows.join('\n');
+    }
+}

package/src/js/core/errors.js

@@ -0,0 +1,59 @@
+/*!
+ * 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.
+ */
+/**
+ * Error types.
+ *
+ * Decoding uses exceptions for control flow internally: a detector that fails
+ * on one candidate should be cheap to abandon, and a `try` around a candidate
+ * loop reads better than threading `null` through six call frames. The public
+ * API converts them to results.
+ *
+ * @module core/errors
+ */
+/** Base class so consumers can `catch (e) { if (e instanceof BarcodeError) ... }`. */
+export class BarcodeError extends Error {
+    /** @param {string} message */
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+/** Input could not be encoded — bad payload, or it does not fit the symbology. */
+export class EncodeError extends BarcodeError {
+}
+/** No symbol was found in the image. Not an error condition for `decode()`. */
+export class NotFoundError extends BarcodeError {
+}
+/** A symbol was found, but its geometry or content is malformed. */
+export class FormatError extends BarcodeError {
+}
+/** A symbol was found and read, but error correction could not repair it. */
+export class ChecksumError extends BarcodeError {
+}