@sythos/js_barcode_universal 1.5.13 → 1.5.15

package/src/js/codablockf/decoder.js

@@ -0,0 +1,198 @@
+/*
+ * Sythos Barcode Suite — Codablock-F reader
+ *
+ * MIT License
+ * Copyright (c) 2026 Sythos
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+import { FormatError } from '../core/errors.js';
+import { code128Checksum, code128CodewordsModules, code128ValueFromModules, decodeCode128Values, sampleModules, scanStackedRows, } from '../stacked128/common.js';
+import { codablockFChecks } from './encoder.js';
+const START_A = 103;
+const CODE_B = 100;
+const STOP = 106;
+const PAD = 103;
+const MIN_COLUMNS = 4;
+const MAX_COLUMNS = 62;
+function parseRow(row, start, moduleSize, columns) {
+    const count = columns + 4;
+    const moduleCount = 11 * count + 13;
+    const modules = sampleModules(row, start, moduleSize, moduleCount);
+    if (!modules)
+        return null;
+    let offset = 0;
+    const startValue = code128ValueFromModules(modules, offset);
+    if (startValue !== START_A)
+        return null;
+    offset += 11;
+    const selector = code128ValueFromModules(modules, offset);
+    if (selector !== CODE_B)
+        return null;
+    offset += 11;
+    const indicator = code128ValueFromModules(modules, offset);
+    if (indicator === null || indicator < 1 || indicator > 44)
+        return null;
+    offset += 11;
+    const data = [];
+    for (let i = 0; i < columns; i++) {
+        const value = code128ValueFromModules(modules, offset);
+        if (value === null || value === STOP)
+            return null;
+        data.push(value);
+        offset += 11;
+    }
+    const rowCheck = code128ValueFromModules(modules, offset);
+    if (rowCheck === null || rowCheck >= 103)
+        return null;
+    const withoutRowCheck = [START_A, CODE_B, indicator, ...data];
+    if (code128Checksum(withoutRowCheck) !== rowCheck)
+        return null;
+    offset += 11;
+    const stop = modules.slice(offset, offset + 13);
+    if (stop !== code128CodewordsModules([STOP]))
+        return null;
+    return { indicator, data };
+}
+function rowBits(matrix, y) {
+    let bits = '';
+    for (let x = 0; x < matrix.width; x++)
+        bits += matrix.get(x, y) ? '1' : '0';
+    return bits;
+}
+function allDark(matrix, y) {
+    if (y < 0 || y >= matrix.height)
+        return false;
+    for (let x = 0; x < matrix.width; x++)
+        if (!matrix.get(x, y))
+            return false;
+    return true;
+}
+function decodeRows(rowsByNumber, rows, columns, moduleSize) {
+    if (rowsByNumber.length !== rows || rows < 2 || rows > 44)
+        return null;
+    const stream = rowsByNumber.flatMap((entry) => entry.data);
+    if (stream.length < 2)
+        return null;
+    const checks = codablockFChecks(stream.slice(0, -2));
+    if (stream[stream.length - 2] !== checks[0] || stream[stream.length - 1] !== checks[1])
+        return null;
+    const body = stream.slice(0, -2);
+    while (body.length > 0 && body[body.length - 1] === PAD)
+        body.pop();
+    const decoded = decodeCode128Values(104, body);
+    if (!decoded)
+        return null;
+    return {
+        format: 'codablockf',
+        text: decoded.text,
+        rows,
+        columns,
+        moduleSize,
+        checksum: true,
+    };
+}
+/** Validate an encoder-shaped matrix row by row, including every row-height pixel. */
+function decodeCanonical(matrix, metadata) {
+    const { rows, columns, rowHeight, separatorHeight } = metadata;
+    if (!Number.isInteger(rows) || rows < 2 || rows > 44 ||
+        !Number.isInteger(columns) || columns < MIN_COLUMNS || columns > MAX_COLUMNS)
+        return null;
+    const expectedWidth = 11 * (columns + 4) + 13;
+    const expectedHeight = 2 + rows * rowHeight + (rows - 1) * separatorHeight;
+    if (matrix.width !== expectedWidth || matrix.height !== expectedHeight)
+        return null;
+    if (!allDark(matrix, 0) || !allDark(matrix, matrix.height - 1))
+        return null;
+    const parsedRows = [];
+    for (let row = 0; row < rows; row++) {
+        const y = 1 + row * (rowHeight + separatorHeight);
+        const source = rowBits(matrix, y);
+        const parsed = parseRow(Uint8Array.from(source, (bit) => bit === '1' ? 1 : 0), 0, 1, columns);
+        if (!parsed || parsed.indicator !== (row === 0 ? rows : row))
+            return null;
+        for (let offset = 1; offset < rowHeight; offset++) {
+            if (rowBits(matrix, y + offset) !== source)
+                return null;
+        }
+        parsedRows.push(parsed);
+        if (row < rows - 1) {
+            for (let offset = 0; offset < separatorHeight; offset++) {
+                if (!allDark(matrix, y + rowHeight + offset))
+                    return null;
+            }
+        }
+    }
+    return decodeRows(parsedRows, rows, columns, 1);
+}
+function assemble(image) {
+    const minimumModules = 11 * (MIN_COLUMNS + 4) + 13;
+    const candidates = scanStackedRows(image, minimumModules, (row, start, moduleSize) => {
+        for (let columns = MIN_COLUMNS; columns <= MAX_COLUMNS; columns++) {
+            const parsed = parseRow(row, start, moduleSize, columns);
+            if (parsed)
+                return { columns, ...parsed };
+        }
+        return null;
+    }, 2200);
+    const groups = new Map();
+    for (const candidate of candidates) {
+        const signature = `${candidate.x}:${candidate.moduleSize}`;
+        const group = groups.get(signature) ?? new Map();
+        const current = group.get(candidate.parsed.indicator);
+        // Rows are repeated vertically; keeping one exact candidate per indicator
+        // prevents rowHeight from multiplying the work without losing a symbol.
+        if (!current)
+            group.set(candidate.parsed.indicator, {
+                columns: candidate.parsed.columns,
+                parsed: candidate.parsed,
+                moduleSize: candidate.moduleSize,
+            });
+        groups.set(signature, group);
+    }
+    for (const group of groups.values()) {
+        for (const [rows, first] of group) {
+            if (rows < 2 || rows > 44)
+                continue;
+            const columns = first.parsed.columns;
+            const rowsByNumber = [];
+            let complete = true;
+            for (let row = 1; row < rows; row++) {
+                const found = group.get(row);
+                if (!found || found.columns !== columns) {
+                    complete = false;
+                    break;
+                }
+                rowsByNumber.push(found.parsed);
+            }
+            if (!complete)
+                continue;
+            rowsByNumber.unshift(first.parsed);
+            const decoded = decodeRows(rowsByNumber, rows, columns, first.moduleSize);
+            if (decoded)
+                return decoded;
+        }
+    }
+    return null;
+}
+/** Decode a Codablock-F matrix or throw when its structure is invalid. */
+export function decodeCodablockF(matrix) {
+    const metadata = matrix.codablockf;
+    if (metadata) {
+        const canonical = decodeCanonical(matrix, metadata);
+        if (canonical)
+            return canonical;
+        throw new FormatError('Codablock-F: invalid rows, checks or Code 128 framing');
+    }
+    const result = assemble(matrix);
+    if (!result)
+        throw new FormatError('Codablock-F: invalid rows, checks or Code 128 framing');
+    return result;
+}
+/** Locate and decode one Codablock-F symbol in a binarized raster. */
+export function detectCodablockF(image) {
+    return assemble(image);
+}
+/** Alias used by the generic image decoder. */
+export const detectAndDecodeCodablockF = detectCodablockF;

package/src/js/codablockf/encoder.js

@@ -0,0 +1,97 @@
+/*
+ * Sythos Barcode Suite — Codablock-F writer
+ *
+ * MIT License
+ * Copyright (c) 2026 Sythos
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+import { EncodeError } from '../core/errors.js';
+import { code128DataCodewords } from '../oned/writers.js';
+import { code128Checksum, code128CodewordsModules, renderStackedRows, } from '../stacked128/common.js';
+const START_A = 103;
+const CODE_B = 100;
+const PAD = 103;
+const MIN_ROWS = 2;
+const MAX_ROWS = 44;
+const MIN_COLUMNS = 4;
+const MAX_COLUMNS = 62;
+/** Weighted modulo-86 K1/K2 checks used by the complete Codablock stream. */
+export function codablockFChecks(values) {
+    let k1 = 0;
+    let k2 = 0;
+    for (let i = 0; i < values.length; i++) {
+        k1 = (k1 + (i + 1) * values[i]) % 86;
+        k2 = (k2 + (i + 2) * values[i]) % 86;
+    }
+    k2 = (k2 + k1) % 86;
+    return [k1, k2];
+}
+function validateDimensions(rows, columns) {
+    if (rows !== undefined && (!Number.isInteger(rows) || rows < MIN_ROWS || rows > MAX_ROWS)) {
+        throw new EncodeError(`Codablock-F: rows must be an integer in ${MIN_ROWS}..${MAX_ROWS}`);
+    }
+    if (columns !== undefined && (!Number.isInteger(columns) || columns < MIN_COLUMNS || columns > MAX_COLUMNS)) {
+        throw new EncodeError(`Codablock-F: columns must be an integer in ${MIN_COLUMNS}..${MAX_COLUMNS}`);
+    }
+}
+function chooseDimensions(length, rowsOption, columnsOption) {
+    validateDimensions(rowsOption, columnsOption);
+    const candidates = [];
+    for (let rows = rowsOption ?? MIN_ROWS; rows <= (rowsOption ?? MAX_ROWS); rows++) {
+        for (let columns = columnsOption ?? MIN_COLUMNS; columns <= (columnsOption ?? MAX_COLUMNS); columns++) {
+            if (rows * columns - 2 < length)
+                continue;
+            // Keep the default reasonably compact while favouring a readable width.
+            const ratio = (columns + 4) / rows;
+            const score = (rows * columns - 2 - length) * 10 + Math.abs(ratio - 2.5);
+            candidates.push({ rows, columns, score });
+        }
+    }
+    if (candidates.length === 0) {
+        throw new EncodeError('Codablock-F: payload does not fit the requested rows and columns');
+    }
+    candidates.sort((a, b) => a.score - b.score || a.rows - b.rows || a.columns - b.columns);
+    return candidates[0];
+}
+/** Encode an ASCII payload as a conservative, standards-shaped Codablock-F symbol. */
+export function encodeCodablockF(value, options = {}) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new EncodeError('Codablock-F: payload must be a non-empty ASCII string');
+    }
+    const dataStream = code128DataCodewords(value, { startSet: 'B' });
+    const { rows, columns } = chooseDimensions(dataStream.values.length, options.rows, options.columns);
+    const rowHeight = options.rowHeight ?? 3;
+    const separatorHeight = options.separatorHeight ?? 1;
+    if (!Number.isInteger(rowHeight) || rowHeight < 1 || rowHeight > 128) {
+        throw new EncodeError('Codablock-F: rowHeight must be an integer in 1..128');
+    }
+    if (!Number.isInteger(separatorHeight) || separatorHeight < 1 || separatorHeight > 16) {
+        throw new EncodeError('Codablock-F: separatorHeight must be an integer in 1..16');
+    }
+    const slotCount = rows * columns;
+    const body = dataStream.values.slice();
+    while (body.length < slotCount - 2)
+        body.push(PAD);
+    const checks = codablockFChecks(body);
+    body.push(checks[0], checks[1]);
+    const rowModules = [];
+    for (let row = 0; row < rows; row++) {
+        const indicator = row === 0 ? rows : row;
+        const data = body.slice(row * columns, (row + 1) * columns);
+        const withoutRowCheck = [START_A, CODE_B, indicator, ...data];
+        const rowCheck = code128Checksum(withoutRowCheck);
+        const codewords = [...withoutRowCheck, rowCheck, 106];
+        rowModules.push(code128CodewordsModules(codewords));
+    }
+    const matrix = renderStackedRows(rowModules, rowHeight, separatorHeight);
+    matrix.codablockf = {
+        rows,
+        columns,
+        rowHeight,
+        separatorHeight,
+        checks,
+    };
+    return matrix;
+}

package/src/js/codablockf/index.js

@@ -0,0 +1,3 @@
+/* Codablock-F public entry points. */
+export { encodeCodablockF, codablockFChecks } from './encoder.js';
+export { decodeCodablockF, detectCodablockF, detectAndDecodeCodablockF } from './decoder.js';

package/src/js/code16k/decoder.js

@@ -0,0 +1,303 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ * Copyright (c) 2026 Sythos
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/** Code 16K decoder for sampled, axis-aligned module matrices. @module code16k/decoder */
+import { FormatError } from '../core/errors.js';
+import { CODE16K_CODEWORD_WIDTH, CODE16K_MAX_ROWS, CODE16K_MIN_ROWS, CODE16K_PAD, CODE16K_SYMBOLS_PER_ROW, code16kModeInfo, code16kStartModules, code16kStopModules, } from './tables.js';
+import { code128ValueFromModules, } from '../stacked128/common.js';
+function equalAt(source, offset, expected) {
+    return source.slice(offset, offset + expected.length) === expected;
+}
+/** Decode one complete 70-module Code 16K row. */
+export function decodeCode16KRow(modules, expectedRow = undefined) {
+    if (typeof modules !== 'string' || modules.length !== 70)
+        return null;
+    const candidates = expectedRow === undefined
+        ? Array.from({ length: CODE16K_MAX_ROWS }, (_, index) => index)
+        : [expectedRow];
+    for (const row of candidates) {
+        if (!Number.isInteger(row) || row < 0 || row >= CODE16K_MAX_ROWS)
+            continue;
+        if (!equalAt(modules, 0, code16kStartModules(row)))
+            continue;
+        if (modules[7] !== '1')
+            continue;
+        if (!equalAt(modules, 63, code16kStopModules(row)))
+            continue;
+        const values = [];
+        let valid = true;
+        for (let column = 0; column < CODE16K_SYMBOLS_PER_ROW; column++) {
+            const value = code128ValueFromModules(modules, 8 + column * CODE16K_CODEWORD_WIDTH);
+            if (value === null) {
+                valid = false;
+                break;
+            }
+            values.push(value);
+        }
+        if (valid)
+            return { row, values };
+    }
+    return null;
+}
+function separatorIsDark(matrix, y) {
+    if (y < 0 || y >= matrix.height)
+        return false;
+    for (let x = 0; x < matrix.width; x++)
+        if (!matrix.get(x, y))
+            return false;
+    return true;
+}
+function readRow(matrix, y) {
+    if (y < 0 || y >= matrix.height)
+        return null;
+    let modules = '';
+    for (let x = 0; x < matrix.width; x++)
+        modules += matrix.get(x, y) ? '1' : '0';
+    return decodeCode16KRow(modules);
+}
+function rowIsConsistent(matrix, y, rowHeight, expected) {
+    for (let offset = 0; offset < rowHeight; offset++) {
+        const parsed = readRow(matrix, y + offset);
+        if (!parsed || parsed.row !== expected.row ||
+            parsed.values.some((value, index) => value !== expected.values[index]))
+            return false;
+    }
+    return true;
+}
+function code128StartForMode(mode) {
+    if (mode === 0)
+        return 103;
+    if (mode === 1 || mode === 3)
+        return 104;
+    if (mode === 2 || mode === 4)
+        return 105;
+    return -1;
+}
+function checksumOne(values) {
+    let sum = 0;
+    for (let index = 0; index < values.length; index++)
+        sum += (index + 2) * values[index];
+    return sum % 107;
+}
+function checksumTwo(valuesThroughC1) {
+    let sum = 0;
+    for (let index = 0; index < valuesThroughC1.length; index++) {
+        sum += (index + 1) * valuesThroughC1[index];
+    }
+    return sum % 107;
+}
+function decodeRows(rows, rowHeight, separatorHeight) {
+    if (rows.length < CODE16K_MIN_ROWS || rows.length > CODE16K_MAX_ROWS) {
+        throw new FormatError('Code 16K: row count must be in 2..16');
+    }
+    const first = rows[0];
+    if (first.row !== 0 || first.values.length !== CODE16K_SYMBOLS_PER_ROW) {
+        throw new FormatError('Code 16K: first row is missing or malformed');
+    }
+    const symbol = first.values[0];
+    if (!Number.isInteger(symbol) || symbol < 0 || symbol > 104) {
+        throw new FormatError('Code 16K: invalid S symbol');
+    }
+    const rowCount = Math.floor(symbol / 7) + 2;
+    const mode = symbol % 7;
+    if (rowCount !== rows.length || rowCount < CODE16K_MIN_ROWS || rowCount > CODE16K_MAX_ROWS) {
+        throw new FormatError('Code 16K: S symbol does not agree with the row count');
+    }
+    if (mode === 5 || mode === 6) {
+        throw new FormatError('Code 16K: shift modes 5 and 6 are not supported by this decoder');
+    }
+    const expectedRows = Array.from({ length: rowCount }, (_, index) => index);
+    for (let index = 0; index < rowCount; index++) {
+        if (rows[index].row !== expectedRows[index] || rows[index].values.length !== CODE16K_SYMBOLS_PER_ROW) {
+            throw new FormatError('Code 16K: rows are missing or out of order');
+        }
+    }
+    const codewords = rows.flatMap((entry) => entry.values);
+    if (codewords.length !== rowCount * CODE16K_SYMBOLS_PER_ROW) {
+        throw new FormatError('Code 16K: invalid codeword count');
+    }
+    const c1 = codewords[codewords.length - 2];
+    const c2 = codewords[codewords.length - 1];
+    const beforeChecks = codewords.slice(0, -2);
+    if (checksumOne(beforeChecks) !== c1 || checksumTwo([...beforeChecks, c1]) !== c2) {
+        throw new FormatError('Code 16K: check character mismatch');
+    }
+    const data = codewords.slice(1, -2);
+    while (data.length && data[data.length - 1] === CODE16K_PAD)
+        data.pop();
+    if (!data.length)
+        throw new FormatError('Code 16K: data region is empty');
+    const expectedStart = code128StartForMode(mode);
+    if (expectedStart < 0)
+        throw new FormatError('Code 16K: unsupported mode');
+    const info = code16kModeInfo(mode, mode === 3 || mode === 4);
+    const firstIsFnc1 = data[0] === 102;
+    if (info.gs1 !== firstIsFnc1) {
+        throw new FormatError('Code 16K: mode and leading FNC1 do not agree');
+    }
+    // Keep Code 16K aligned with ordinary Code 128 A/B/C decoding while the row
+    // framing and checks remain format-specific.
+    const decoded = decodeCode128ValuesLocal(expectedStart, data);
+    if (!decoded)
+        throw new FormatError('Code 16K: invalid Code 128 data stream');
+    return {
+        format: 'code16k',
+        text: decoded.text,
+        rows: rowCount,
+        columns: CODE16K_SYMBOLS_PER_ROW,
+        rowHeight,
+        separatorHeight,
+        mode,
+        codewords,
+        checksum: true,
+        symbologyIdentifier: info.gs1 ? ']K1' : ']K0',
+        ...(info.gs1 ? { gs1: true } : {}),
+        ...(decoded.fnc1AtStart ? { fnc1AtStart: true } : {}),
+        ...(decoded.fnc1Positions?.length ? { fnc1Positions: decoded.fnc1Positions } : {}),
+    };
+}
+/* Keep the decoder self-contained if this module is consumed without the full common declaration graph. */
+function decodeCode128ValuesLocal(startCode, dataValues) {
+    if (![103, 104, 105].includes(startCode) || !dataValues.length)
+        return null;
+    let mode = startCode === 103 ? 'A' : startCode === 104 ? 'B' : 'C';
+    let shifted = null;
+    let text = '';
+    const fnc1AtStart = dataValues[0] === 102;
+    const fnc1Positions = [];
+    for (let index = 0; index < dataValues.length; index++) {
+        const value = dataValues[index];
+        const active = shifted ?? mode;
+        shifted = null;
+        if (value === 101 && mode !== 'A') {
+            mode = 'A';
+            continue;
+        }
+        if (value === 100 && mode !== 'B') {
+            mode = 'B';
+            continue;
+        }
+        if (value === 99) {
+            mode = 'C';
+            continue;
+        }
+        if (value === 98) {
+            shifted = mode === 'A' ? 'B' : 'A';
+            continue;
+        }
+        if (value === 102) {
+            if (index > 0) {
+                fnc1Positions.push(text.length);
+                text += '\x1d';
+            }
+            continue;
+        }
+        if (value >= 96 && value <= 102)
+            continue;
+        if (active === 'C') {
+            if (value > 99)
+                return null;
+            text += String(value).padStart(2, '0');
+        }
+        else if (active === 'A') {
+            if (value > 95)
+                return null;
+            text += value < 64 ? String.fromCharCode(value + 32) : String.fromCharCode(value - 64);
+        }
+        else {
+            if (value > 95)
+                return null;
+            text += String.fromCharCode(value + 32);
+        }
+        if (text.length > 100000)
+            return null;
+    }
+    return text.length ? { text, ...(fnc1AtStart ? { fnc1AtStart: true } : {}), fnc1Positions } : null;
+}
+function candidateGeometry(matrix, options) {
+    const metadata = matrix.code16k;
+    const requestedRows = options.rows ?? metadata?.rows;
+    const requestedRowHeight = options.rowHeight ?? metadata?.rowHeight;
+    const requestedSeparatorHeight = options.separatorHeight ?? metadata?.separatorHeight;
+    const candidates = [];
+    for (const outer of [true, false]) {
+        const innerHeight = matrix.height - (outer ? 2 : 0);
+        for (let rows = CODE16K_MIN_ROWS; rows <= CODE16K_MAX_ROWS; rows++) {
+            if (requestedRows !== undefined && rows !== requestedRows)
+                continue;
+            for (let separatorHeight = requestedSeparatorHeight ?? 1; separatorHeight <= (requestedSeparatorHeight ?? 16); separatorHeight++) {
+                if (!Number.isInteger(separatorHeight) || separatorHeight < 1 || separatorHeight > 16)
+                    continue;
+                const numerator = innerHeight - (rows - 1) * separatorHeight;
+                if (numerator < rows || numerator % rows !== 0)
+                    continue;
+                const rowHeight = numerator / rows;
+                if (rowHeight < 1 || rowHeight > 128)
+                    continue;
+                if (requestedRowHeight !== undefined && rowHeight !== requestedRowHeight)
+                    continue;
+                candidates.push({ rows, rowHeight, separatorHeight, outer });
+            }
+        }
+    }
+    return candidates;
+}
+/**
+ * Decode a complete, axis-aligned Code 16K module matrix.
+ *
+ * The decoder re-checks row geometry, row identifiers, both modulo-107 check
+ * characters and the Code 128 data stream. Metadata attached by the encoder
+ * is used only as a geometry hint and never substitutes for validation.
+ */
+export function decodeCode16K(matrix, options = {}) {
+    if (!matrix?.width || !matrix?.height || typeof matrix.get !== 'function') {
+        throw new FormatError('Code 16K: matrix with width, height and get() is required');
+    }
+    if (matrix.width !== 70)
+        throw new FormatError('Code 16K: matrix width must be 70 modules');
+    for (const geometry of candidateGeometry(matrix, options)) {
+        const first = readRow(matrix, geometry.outer ? 1 : 0);
+        if (!first || first.row !== 0)
+            continue;
+        const encodedRows = Math.floor(first.values[0] / 7) + 2;
+        if (encodedRows !== geometry.rows)
+            continue;
+        const rows = [];
+        let valid = true;
+        for (let row = 0; row < geometry.rows; row++) {
+            const y = (geometry.outer ? 1 : 0) + row * (geometry.rowHeight + geometry.separatorHeight);
+            const parsed = readRow(matrix, y);
+            if (!parsed || parsed.row !== row) {
+                valid = false;
+                break;
+            }
+            if (!rowIsConsistent(matrix, y, geometry.rowHeight, parsed)) {
+                valid = false;
+                break;
+            }
+            rows.push(parsed);
+            if (row < geometry.rows - 1 && !separatorIsDark(matrix, y + geometry.rowHeight)) {
+                valid = false;
+                break;
+            }
+        }
+        if (!valid)
+            continue;
+        if (geometry.outer && (!separatorIsDark(matrix, 0) ||
+            !separatorIsDark(matrix, matrix.height - 1)))
+            continue;
+        try {
+            return decodeRows(rows, geometry.rowHeight, geometry.separatorHeight);
+        }
+        catch {
+            // Try another legal geometry before rejecting the matrix.
+        }
+    }
+    throw new FormatError('Code 16K: no valid row geometry or checksum found');
+}