@sythos/js_barcode_universal 1.5.13 → 1.5.15

package/src/js/code16k/detector.js

@@ -0,0 +1,187 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ * Copyright (c) 2026 Sythos
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/** Conservative integer-module Code 16K detector. @module code16k/detector */
+import { BitMatrix } from '../core/bit-matrix.js';
+import { code128PatternModules, renderStackedRows, sampleModules, scanStackedRows, } from '../stacked128/common.js';
+import { code16kStartModules, code16kStopModules } from './tables.js';
+import { decodeCode16K, decodeCode16KRow } from './decoder.js';
+function rowModules(row, values) {
+    return code16kStartModules(row) + '1' + values.map((value) => code128PatternModules(value)).join('') +
+        code16kStopModules(row);
+}
+function rotateClockwise(source) {
+    const rotated = 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))
+                rotated.set(source.height - 1 - y, x);
+        }
+    }
+    return rotated;
+}
+function cornersFor(x, y, width, height) {
+    return [
+        { x, y }, { x: x + width, y },
+        { x: x + width, y: y + height }, { x, y: y + height },
+    ];
+}
+function rowHasDarkPixels(image, y, x, width) {
+    if (y < 0 || y >= image.height)
+        return false;
+    for (let offset = 0; offset < width; offset++)
+        if (!image.get(x + offset, y))
+            return false;
+    return true;
+}
+function contiguousSpan(values) {
+    if (!values.length)
+        return 0;
+    const sorted = [...new Set(values)].sort((a, b) => a - b);
+    let best = 1;
+    let current = 1;
+    for (let index = 1; index < sorted.length; index++) {
+        if (sorted[index] === sorted[index - 1] + 1)
+            current++;
+        else {
+            best = Math.max(best, current);
+            current = 1;
+        }
+    }
+    return Math.max(best, current);
+}
+function parseSample(row, start, moduleSize) {
+    const modules = sampleModules(row, start, moduleSize, 70);
+    if (!modules)
+        return null;
+    const parsed = decodeCode16KRow(modules);
+    return parsed ? { ...parsed, modules } : null;
+}
+function detectOriented(image, options) {
+    const requestedScale = options.moduleSize;
+    if (requestedScale !== undefined &&
+        (!Number.isInteger(requestedScale) || requestedScale < 1 || requestedScale > 32))
+        return null;
+    const maxModules = 70 * (requestedScale ?? 32);
+    const found = scanStackedRows(image, 70, parseSample, maxModules)
+        .filter((candidate) => requestedScale === undefined || candidate.moduleSize === requestedScale);
+    const groups = new Map();
+    for (const candidate of found) {
+        const key = `${candidate.x}:${candidate.moduleSize}`;
+        let group = groups.get(key);
+        if (!group) {
+            group = { x: candidate.x, moduleSize: candidate.moduleSize, rows: new Map() };
+            groups.set(key, group);
+        }
+        let values = group.rows.get(candidate.parsed.row);
+        if (!values) {
+            values = [];
+            group.rows.set(candidate.parsed.row, values);
+        }
+        values.push({ y: candidate.y, parsed: candidate.parsed });
+    }
+    for (const group of groups.values()) {
+        const firstCandidates = group.rows.get(0);
+        if (!firstCandidates?.length)
+            continue;
+        for (const first of firstCandidates) {
+            const encodedRows = Math.floor(first.parsed.values[0] / 7) + 2;
+            if (encodedRows < 2 || encodedRows > 16 || group.rows.size !== encodedRows)
+                continue;
+            const chosen = [];
+            let complete = true;
+            for (let row = 0; row < encodedRows; row++) {
+                const entries = group.rows.get(row);
+                if (!entries?.length) {
+                    complete = false;
+                    break;
+                }
+                const sorted = entries.slice().sort((a, b) => a.y - b.y);
+                chosen.push({ y: sorted[0].y, parsed: sorted[0].parsed });
+            }
+            if (!complete)
+                continue;
+            const scale = group.moduleSize;
+            const spans = chosen.map((entry) => {
+                const entries = group.rows.get(entry.parsed.row) ?? [];
+                return contiguousSpan(entries.map((candidate) => candidate.y));
+            });
+            if (!spans.every((span) => span === spans[0]) || spans[0] < scale || spans[0] % scale !== 0)
+                continue;
+            const rowHeight = spans[0] / scale;
+            const firstY = chosen[0].y;
+            const steps = chosen.slice(1).map((entry, index) => entry.y - chosen[index].y);
+            if (!steps.length || !steps.every((step) => step === steps[0]) || steps[0] % scale !== 0)
+                continue;
+            const separatorHeight = steps[0] / scale - rowHeight;
+            if (separatorHeight < 1 || separatorHeight > 16)
+                continue;
+            if (options.rowHeight !== undefined && rowHeight !== options.rowHeight)
+                continue;
+            if (options.separatorHeight !== undefined && separatorHeight !== options.separatorHeight)
+                continue;
+            const modules = chosen.map((entry) => rowModules(entry.parsed.row, entry.parsed.values));
+            let matrix;
+            try {
+                matrix = renderStackedRows(modules, rowHeight, separatorHeight);
+                const result = decodeCode16K(matrix, { rowHeight, separatorHeight, rows: encodedRows });
+                const topSeparator = rowHasDarkPixels(image, firstY - scale, group.x, 70 * scale) ? scale : 0;
+                const last = chosen[chosen.length - 1];
+                const bottomY = last.y + spans[spans.length - 1];
+                const bottomSeparator = rowHasDarkPixels(image, bottomY, group.x, 70 * scale) ? scale : 0;
+                const boundsY = firstY - topSeparator;
+                const boundsHeight = (bottomY + bottomSeparator) - boundsY;
+                return {
+                    ...result,
+                    matrix,
+                    corners: cornersFor(group.x, boundsY, 70 * scale, boundsHeight),
+                    rotation: 0,
+                    moduleSize: scale,
+                };
+            }
+            catch {
+                // A candidate is accepted only after all rows and checks decode.
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Detect and decode one Code 16K symbol from a binarized image.
+ *
+ * The detector is intentionally conservative and enumerates integer module
+ * scales and the four orthogonal orientations. Non-integer perspective and
+ * photographic threshold recovery remain the responsibility of the generic
+ * image pipeline.
+ */
+export function detectCode16K(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 found = detectOriented(oriented, options);
+        if (found) {
+            return {
+                ...found,
+                corners: found.corners.map(toOriginal),
+                rotation: rotation * 90,
+            };
+        }
+        const previous = oriented;
+        const previousToOriginal = toOriginal;
+        oriented = rotateClockwise(previous);
+        toOriginal = (point) => previousToOriginal({ x: point.y, y: previous.height - point.x });
+    }
+    return null;
+}
+/** Alias matching the detector naming used by the other format modules. */
+export function detectAndDecodeCode16K(binaryImage, options = {}) {
+    return detectCode16K(binaryImage, options);
+}

package/src/js/code16k/encoder.js

@@ -0,0 +1,153 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * 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 { renderStackedRows } from '../stacked128/common.js';
+import { CODE16K_CODEWORD_WIDTH, CODE16K_PAD, CODE16K_SYMBOLS_PER_ROW, code16kModeInfo, code16kStartModules, code16kStopModules, validateCode16KOptions, } from './tables.js';
+import { code128PatternModules } from '../stacked128/common.js';
+function asciiText(value) {
+    if (typeof value === 'string') {
+        if (value.length > 4096)
+            throw new EncodeError('Code 16K: value is too long for the 16-row symbol limit');
+        for (const character of value) {
+            if (character.codePointAt(0) > 127) {
+                throw new EncodeError('Code 16K: value must contain seven-bit ASCII characters');
+            }
+        }
+        return value;
+    }
+    const bytes = value instanceof Uint8Array ? Array.from(value) :
+        Array.isArray(value) ? value : null;
+    if (!bytes)
+        throw new EncodeError('Code 16K: value must be text or seven-bit bytes');
+    if (bytes.length > 4096)
+        throw new EncodeError('Code 16K: value is too long for the 16-row symbol limit');
+    if (bytes.some((byte) => !Number.isInteger(byte) || byte < 0 || byte > 127)) {
+        throw new EncodeError('Code 16K: byte input must contain values from 0 to 127');
+    }
+    return bytes.map((byte) => String.fromCharCode(byte)).join('');
+}
+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 rowModules(row, values) {
+    if (values.length !== CODE16K_SYMBOLS_PER_ROW) {
+        throw new EncodeError('Code 16K: every row must contain exactly five symbol characters');
+    }
+    let modules = code16kStartModules(row) + '1';
+    for (const value of values) {
+        if (!Number.isInteger(value) || value < 0 || value > 106) {
+            throw new EncodeError(`Code 16K: invalid Code 128 symbol value ${value}`);
+        }
+        const symbol = code128PatternModules(value);
+        if (symbol.length !== CODE16K_CODEWORD_WIDTH) {
+            throw new EncodeError('Code 16K: Code 128 symbol width invariant failed');
+        }
+        modules += symbol;
+    }
+    modules += code16kStopModules(row);
+    if (modules.length !== 70)
+        throw new EncodeError('Code 16K: internal row width mismatch');
+    return modules;
+}
+/**
+ * Encode a Code 16K symbol.
+ *
+ * The implementation accepts seven-bit ASCII and the standard Code 128 A/B/C
+ * data sets. It chooses the smallest legal row count unless `rows` is given.
+ * The first symbol character carries the row count and mode; C1 and C2 are
+ * calculated over every preceding symbol character exactly as specified.
+ *
+ * @param {string|Uint8Array|number[]} value
+ * @param {Code16KEncodeOptions} [options]
+ * @returns {Code16KMatrix}
+ */
+export function encodeCode16K(value, options = {}) {
+    const text = asciiText(value);
+    if (text.length === 0)
+        throw new EncodeError('Code 16K: value must not be empty');
+    const validated = validateCode16KOptions(options);
+    const info = code16kModeInfo(options.mode, options.gs1 === true);
+    const tokenized = code128DataCodewords(text, {
+        gs1: info.gs1,
+        startSet: info.startSet,
+    });
+    const data = tokenized.values.slice();
+    const minimumRows = Math.max(2, Math.ceil((data.length + 3) / CODE16K_SYMBOLS_PER_ROW));
+    const rows = validated.rows ?? minimumRows;
+    if (rows < 2 || rows > 16) {
+        throw new EncodeError('Code 16K: payload needs between 2 and 16 rows');
+    }
+    const capacity = rows * CODE16K_SYMBOLS_PER_ROW - 3;
+    if (data.length > capacity) {
+        throw new EncodeError(`Code 16K: payload needs ${data.length} data symbols but ${capacity} fit in ${rows} rows`);
+    }
+    const first = 7 * (rows - 2) + info.mode;
+    if (first > 104)
+        throw new EncodeError('Code 16K: row count and mode do not fit the S symbol');
+    while (data.length < capacity)
+        data.push(CODE16K_PAD);
+    const beforeChecks = [first, ...data];
+    const c1 = checksumOne(beforeChecks);
+    const c2 = checksumTwo([...beforeChecks, c1]);
+    const codewords = [...beforeChecks, c1, c2];
+    if (codewords.length !== rows * CODE16K_SYMBOLS_PER_ROW) {
+        throw new EncodeError('Code 16K: internal codeword packing mismatch');
+    }
+    const rowsModules = [];
+    for (let row = 0; row < rows; row++) {
+        rowsModules.push(rowModules(row, codewords.slice(row * CODE16K_SYMBOLS_PER_ROW, (row + 1) * CODE16K_SYMBOLS_PER_ROW)));
+    }
+    const matrix = renderStackedRows(rowsModules, validated.rowHeight, validated.separatorHeight);
+    matrix.code16k = {
+        format: 'code16k',
+        rows,
+        columns: CODE16K_SYMBOLS_PER_ROW,
+        rowHeight: validated.rowHeight,
+        separatorHeight: validated.separatorHeight,
+        mode: info.mode,
+        codewords,
+        checksum: true,
+    };
+    return matrix;
+}
+/** Return the dimensions selected for a Code 16K payload without rendering it. */
+export function code16kDimensions(value, options = {}) {
+    const text = asciiText(value);
+    if (text.length === 0)
+        throw new EncodeError('Code 16K: value must not be empty');
+    const validated = validateCode16KOptions(options);
+    const info = code16kModeInfo(options.mode, options.gs1 === true);
+    const tokenized = code128DataCodewords(text, { gs1: info.gs1, startSet: info.startSet });
+    const dataLength = tokenized.values.length;
+    const rows = validated.rows ?? Math.max(2, Math.ceil((dataLength + 3) / CODE16K_SYMBOLS_PER_ROW));
+    const capacity = rows * CODE16K_SYMBOLS_PER_ROW - 3;
+    if (rows > 16 || dataLength > capacity) {
+        throw new EncodeError('Code 16K: payload does not fit the requested row count');
+    }
+    return {
+        rows,
+        columns: CODE16K_SYMBOLS_PER_ROW,
+        width: 70,
+        height: 2 + rows * validated.rowHeight + (rows - 1) * validated.separatorHeight,
+        rowHeight: validated.rowHeight,
+        separatorHeight: validated.separatorHeight,
+    };
+}

package/src/js/code16k/index.js

@@ -0,0 +1,14 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ * Copyright (c) 2026 Sythos
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/** Code 16K public module exports. @module code16k */
+export { CODE16K_MIN_ROWS, CODE16K_MAX_ROWS, CODE16K_SYMBOLS_PER_ROW, CODE16K_MODULE_WIDTH, CODE16K_START_WIDTH, CODE16K_GUARD_WIDTH, CODE16K_CODEWORD_WIDTH, CODE16K_STOP_WIDTH, CODE16K_DEFAULT_ROW_HEIGHT, CODE16K_DEFAULT_SEPARATOR_HEIGHT, CODE16K_PAD, CODE16K_ROW_PAIRS, CODE16K_START_WIDTHS, code16kModeNumber, code16kModeInfo, code16kStartModules, code16kStopModules, code16kWidth, code16kGeometry, validateCode16KOptions, validateCode16KTables, } from './tables.js';
+export { encodeCode16K, code16kDimensions } from './encoder.js';
+export { decodeCode16K, decodeCode16KRow } from './decoder.js';
+export { detectCode16K, detectAndDecodeCode16K } from './detector.js';

package/src/js/code16k/tables.js

@@ -0,0 +1,152 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ * Copyright (c) 2026 Sythos
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/**
+ * Structural facts and option validation for Code 16K.
+ *
+ * A Code 16K row is 70 modules wide: a seven-module start pattern, a one
+ * module guard bar, five eleven-module Code 128 symbols and a seven-module
+ * stop pattern. The row start and stop pair identifies its one-based row
+ * number. This module contains only the public table facts; packing and
+ * decoding live in encoder.ts and decoder.ts.
+ *
+ * @module code16k/tables
+ */
+import { EncodeError } from '../core/errors.js';
+import { alternatingWidths } from '../stacked128/common.js';
+export const CODE16K_MIN_ROWS = 2;
+export const CODE16K_MAX_ROWS = 16;
+export const CODE16K_SYMBOLS_PER_ROW = 5;
+export const CODE16K_MODULE_WIDTH = 70;
+export const CODE16K_START_WIDTH = 7;
+export const CODE16K_GUARD_WIDTH = 1;
+export const CODE16K_CODEWORD_WIDTH = 11;
+export const CODE16K_STOP_WIDTH = 7;
+export const CODE16K_DEFAULT_ROW_HEIGHT = 8;
+export const CODE16K_DEFAULT_SEPARATOR_HEIGHT = 1;
+export const CODE16K_PAD = 103;
+/** Start/stop values used to identify rows, in top-to-bottom order. */
+export const CODE16K_ROW_PAIRS = Object.freeze([
+    Object.freeze([0, 0]), Object.freeze([1, 1]),
+    Object.freeze([2, 2]), Object.freeze([3, 3]),
+    Object.freeze([4, 4]), Object.freeze([5, 5]),
+    Object.freeze([6, 6]), Object.freeze([7, 7]),
+    Object.freeze([0, 4]), Object.freeze([1, 5]),
+    Object.freeze([2, 6]), Object.freeze([3, 7]),
+    Object.freeze([4, 0]), Object.freeze([5, 1]),
+    Object.freeze([6, 2]), Object.freeze([7, 3]),
+]);
+/** Widths for the eight edge-decodable start patterns. */
+export const CODE16K_START_WIDTHS = Object.freeze([
+    Object.freeze([3, 2, 1, 1]), Object.freeze([2, 2, 2, 1]),
+    Object.freeze([2, 1, 2, 2]), Object.freeze([1, 4, 1, 1]),
+    Object.freeze([1, 1, 3, 2]), Object.freeze([1, 2, 3, 1]),
+    Object.freeze([1, 1, 1, 4]), Object.freeze([3, 1, 1, 2]),
+]);
+/** Return the canonical mode number used by the first symbol character. */
+export function code16kModeNumber(mode, gs1 = false) {
+    if (mode === undefined)
+        return gs1 ? 3 : 1;
+    if (typeof mode === 'string') {
+        if (mode === 'A')
+            return 0;
+        if (mode === 'B')
+            return gs1 ? 3 : 1;
+        return gs1 ? 4 : 2;
+    }
+    if (!Number.isInteger(mode) || mode < 0 || mode > 6) {
+        throw new EncodeError('Code 16K: mode must be A, B, C or an integer in 0..6');
+    }
+    return mode;
+}
+/** Resolve the initial Code 128 set and whether the first data value is FNC1. */
+export function code16kModeInfo(mode, gs1 = false) {
+    const resolved = code16kModeNumber(mode, gs1);
+    if (resolved === 5 || resolved === 6) {
+        throw new EncodeError('Code 16K: modes 5 and 6 require a dedicated shift encoder');
+    }
+    const startSet = resolved === 0 ? 'A' :
+        resolved === 1 || resolved === 3 ? 'B' : 'C';
+    return {
+        mode: resolved,
+        startSet,
+        gs1: resolved === 3 || resolved === 4,
+    };
+}
+/** Return the seven-module start pattern for a zero-based row index. */
+export function code16kStartModules(row) {
+    if (!Number.isInteger(row) || row < 0 || row >= CODE16K_MAX_ROWS) {
+        throw new RangeError('Code 16K: row index must be an integer in 0..15');
+    }
+    return alternatingWidths(CODE16K_START_WIDTHS[CODE16K_ROW_PAIRS[row][0]], true);
+}
+/** Return the seven-module stop pattern for a zero-based row index. */
+export function code16kStopModules(row) {
+    if (!Number.isInteger(row) || row < 0 || row >= CODE16K_MAX_ROWS) {
+        throw new RangeError('Code 16K: row index must be an integer in 0..15');
+    }
+    return alternatingWidths(CODE16K_START_WIDTHS[CODE16K_ROW_PAIRS[row][1]], false);
+}
+/** Return a complete row's bare module width. */
+export function code16kWidth() {
+    return CODE16K_MODULE_WIDTH;
+}
+/** Validate a matrix geometry and return its row count and separator height. */
+export function code16kGeometry(width, height, rows, rowHeight, separatorHeight, outerSeparators = true) {
+    if (width !== CODE16K_MODULE_WIDTH) {
+        throw new RangeError(`Code 16K: width must be ${CODE16K_MODULE_WIDTH} modules`);
+    }
+    if (!Number.isInteger(rows) || rows < CODE16K_MIN_ROWS || rows > CODE16K_MAX_ROWS) {
+        throw new RangeError('Code 16K: rows must be an integer in 2..16');
+    }
+    if (!Number.isInteger(rowHeight) || rowHeight < 1 || rowHeight > 128) {
+        throw new RangeError('Code 16K: rowHeight must be an integer in 1..128');
+    }
+    if (!Number.isInteger(separatorHeight) || separatorHeight < 1 || separatorHeight > 16) {
+        throw new RangeError('Code 16K: separatorHeight must be an integer in 1..16');
+    }
+    const outer = outerSeparators ? 2 : 0;
+    const expected = outer + rows * rowHeight + (rows - 1) * separatorHeight;
+    if (height !== expected) {
+        throw new RangeError(`Code 16K: height ${height} does not match the row geometry`);
+    }
+    return { width, height, rows, rowHeight, separatorHeight };
+}
+/** Validate public encoder options before any large matrix allocation. */
+export function validateCode16KOptions(options = {}) {
+    const rowHeight = options.rowHeight ?? CODE16K_DEFAULT_ROW_HEIGHT;
+    const separatorHeight = options.separatorHeight ?? CODE16K_DEFAULT_SEPARATOR_HEIGHT;
+    if (!Number.isInteger(rowHeight) || rowHeight < 1 || rowHeight > 128) {
+        throw new EncodeError('Code 16K: rowHeight must be an integer in 1..128');
+    }
+    if (!Number.isInteger(separatorHeight) || separatorHeight < 1 || separatorHeight > 16) {
+        throw new EncodeError('Code 16K: separatorHeight must be an integer in 1..16');
+    }
+    if (options.rows !== undefined &&
+        (!Number.isInteger(options.rows) || options.rows < CODE16K_MIN_ROWS || options.rows > CODE16K_MAX_ROWS)) {
+        throw new EncodeError('Code 16K: rows must be an integer in 2..16');
+    }
+    const info = code16kModeInfo(options.mode, options.gs1 === true);
+    return { rows: options.rows, rowHeight, separatorHeight, ...info };
+}
+/** Check table invariants used by tests and CI. */
+export function validateCode16KTables() {
+    const problems = [];
+    if (CODE16K_ROW_PAIRS.length !== CODE16K_MAX_ROWS)
+        problems.push('row pair count mismatch');
+    if (CODE16K_START_WIDTHS.length !== 8)
+        problems.push('start pattern count mismatch');
+    for (let row = 0; row < CODE16K_MAX_ROWS; row++) {
+        if (code16kStartModules(row).length !== CODE16K_START_WIDTH)
+            problems.push(`row ${row + 1} start width mismatch`);
+        if (code16kStopModules(row).length !== CODE16K_STOP_WIDTH)
+            problems.push(`row ${row + 1} stop width mismatch`);
+    }
+    return problems;
+}