@sythos/js_barcode_universal 1.5.13 → 1.5.15

package/src/js/stacked128/common.js

@@ -0,0 +1,208 @@
+/*
+ * Sythos Barcode Suite — shared stacked Code 128 helpers
+ *
+ * MIT License
+ * Copyright (c) 2026 Sythos
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+import { BitMatrix } from '../core/bit-matrix.js';
+import { EncodeError } from '../core/errors.js';
+import { CODE128, CODE128_START_A, CODE128_START_B, CODE128_START_C, CODE128_FNC1, CODE128_CODE_A, CODE128_CODE_B, CODE128_CODE_C, CODE128_SHIFT, } from '../oned/patterns.js';
+/** Expand a Code 128 width string into dark/light modules. */
+export function code128PatternModules(value) {
+    if (!Number.isInteger(value) || value < 0 || value >= CODE128.length) {
+        throw new EncodeError(`Code 128: invalid symbol value ${value}`);
+    }
+    const pattern = CODE128[value];
+    let modules = '';
+    let dark = true;
+    for (const digit of pattern) {
+        const width = Number(digit);
+        modules += (dark ? '1' : '0').repeat(width);
+        dark = !dark;
+    }
+    return modules;
+}
+/** Render complete Code 128 codewords, including their 13-module stop. */
+export function code128CodewordsModules(values) {
+    return values.map((value) => code128PatternModules(value)).join('');
+}
+/** Code 128 checksum for a sequence that includes the start symbol. */
+export function code128Checksum(values) {
+    if (values.length === 0)
+        throw new EncodeError('Code 128: checksum needs a start symbol');
+    let sum = values[0];
+    for (let i = 1; i < values.length; i++)
+        sum += values[i] * i;
+    return sum % 103;
+}
+const CODE128_BITS = new Map();
+for (let value = 0; value < CODE128.length; value++) {
+    CODE128_BITS.set(code128PatternModules(value), value);
+}
+/** Decode a single 11-module Code 128 symbol from a sampled module string. */
+export function code128ValueFromModules(modules, offset) {
+    const slice = modules.slice(offset, offset + 11);
+    if (slice.length !== 11)
+        return null;
+    return CODE128_BITS.get(slice) ?? null;
+}
+/**
+ * Interpret Code 128 data values after the start symbol and checksum.
+ *
+ * This deliberately mirrors the public Code 128 reader but keeps stacked
+ * decoders independent from scanline state. The result is null for an empty
+ * or structurally impossible stream.
+ */
+export function decodeCode128Values(startCode, dataValues) {
+    if (![CODE128_START_A, CODE128_START_B, CODE128_START_C].includes(startCode))
+        return null;
+    if (dataValues.length === 0)
+        return null;
+    let mode = startCode === CODE128_START_A
+        ? 'A' : startCode === CODE128_START_B ? 'B' : 'C';
+    let shifted = null;
+    let text = '';
+    const fnc1AtStart = dataValues[0] === CODE128_FNC1;
+    const fnc1Positions = [];
+    for (let index = 0; index < dataValues.length; index++) {
+        const value = dataValues[index];
+        const active = shifted ?? mode;
+        shifted = null;
+        if (value === CODE128_CODE_A && mode !== 'A') {
+            mode = 'A';
+            continue;
+        }
+        if (value === CODE128_CODE_B && mode !== 'B') {
+            mode = 'B';
+            continue;
+        }
+        if (value === CODE128_CODE_C) {
+            mode = 'C';
+            continue;
+        }
+        if (value === CODE128_SHIFT) {
+            shifted = mode === 'A' ? 'B' : 'A';
+            continue;
+        }
+        if (value === CODE128_FNC1) {
+            if (index > 0) {
+                fnc1Positions.push(text.length);
+                text += '\x1d';
+            }
+            continue;
+        }
+        // FNC2, FNC3 and FNC4 are control values. They are not part of the
+        // textual payload exposed by this SDK, but remain valid Code 128 symbols.
+        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;
+    }
+    if (text.length === 0)
+        return null;
+    return fnc1AtStart
+        ? { text, fnc1AtStart: true, fnc1Positions }
+        : { text };
+}
+/** Sample one module at the centre of every integer-sized module. */
+export function sampleModules(row, start, moduleSize, count) {
+    if (!Number.isInteger(moduleSize) || moduleSize < 1 || start < 0)
+        return null;
+    const end = start + moduleSize * count;
+    if (end > row.length)
+        return null;
+    let modules = '';
+    const centre = Math.floor((moduleSize - 1) / 2);
+    for (let index = 0; index < count; index++) {
+        modules += row[start + index * moduleSize + centre] ? '1' : '0';
+    }
+    return modules;
+}
+/**
+ * Scan a binarized image for stacked symbols with integer module scaling.
+ * The parser receives every plausible dark-run origin and can try one or more
+ * geometry variants. A bounded scale keeps camera frames predictable.
+ */
+export function scanStackedRows(image, minimumModules, parser, maximumModules = 900) {
+    const candidates = [];
+    const rowBuffer = new Uint8Array(image.width);
+    const maximumScale = Math.min(32, Math.max(1, Math.floor(maximumModules / Math.max(1, minimumModules))));
+    for (let y = 0; y < image.height; y++) {
+        const row = image.getRow(y, rowBuffer);
+        for (let start = 0; start < row.length; start++) {
+            if (!row[start] || (start > 0 && row[start - 1]))
+                continue;
+            for (let moduleSize = 1; moduleSize <= maximumScale; moduleSize++) {
+                if (start + minimumModules * moduleSize > row.length)
+                    break;
+                const parsed = parser(row, start, moduleSize);
+                if (parsed !== null)
+                    candidates.push({ x: start, y, moduleSize, parsed });
+            }
+        }
+    }
+    return candidates;
+}
+/** Paint a set of row module strings with separator bars and quiet rows. */
+export function renderStackedRows(rowModules, rowHeight, separatorHeight) {
+    if (!Number.isInteger(rowHeight) || rowHeight < 1 || rowHeight > 128) {
+        throw new EncodeError('Stacked Code 128: rowHeight must be an integer in 1..128');
+    }
+    if (!Number.isInteger(separatorHeight) || separatorHeight < 1 || separatorHeight > 16) {
+        throw new EncodeError('Stacked Code 128: separatorHeight must be an integer in 1..16');
+    }
+    if (rowModules.length < 1)
+        throw new EncodeError('Stacked Code 128: at least one row is required');
+    const width = rowModules[0].length;
+    if (width < 1 || rowModules.some((modules) => modules.length !== width)) {
+        throw new EncodeError('Stacked Code 128: rows must have equal module widths');
+    }
+    const height = 2 + rowModules.length * rowHeight + (rowModules.length - 1) * separatorHeight;
+    const matrix = new BitMatrix(width, height);
+    matrix.setRegion(0, 0, width, 1);
+    matrix.setRegion(0, height - 1, width, 1);
+    let y = 1;
+    for (let row = 0; row < rowModules.length; row++) {
+        const modules = rowModules[row];
+        for (let x = 0; x < width; x++) {
+            if (modules[x] === '1')
+                matrix.setRegion(x, y, 1, rowHeight);
+        }
+        y += rowHeight;
+        if (row < rowModules.length - 1) {
+            matrix.setRegion(0, y, width, separatorHeight);
+            y += separatorHeight;
+        }
+    }
+    return matrix;
+}
+/** Build an alternating-width pattern, starting with dark or light. */
+export function alternatingWidths(widths, startsDark) {
+    let modules = '';
+    let dark = startsDark;
+    for (const width of widths) {
+        if (!Number.isInteger(width) || width < 1)
+            throw new EncodeError('Stacked barcode: invalid guard width');
+        modules += (dark ? '1' : '0').repeat(width);
+        dark = !dark;
+    }
+    return modules;
+}

package/src/ts/codablockf/decoder.ts

@@ -0,0 +1,212 @@
+/*
+ * 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 { BitMatrix } from '../core/bit-matrix.js';
+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;
+
+export interface CodablockFDecodeResult {
+  readonly format: 'codablockf';
+  readonly text: string;
+  readonly rows: number;
+  readonly columns: number;
+  readonly moduleSize: number;
+  readonly checksum: true;
+}
+
+interface ParsedRow {
+  readonly indicator: number;
+  readonly data: number[];
+}
+
+interface CodablockFMetadataHint {
+  readonly rows: number;
+  readonly columns: number;
+  readonly rowHeight: number;
+  readonly separatorHeight: number;
+}
+
+function parseRow(row: Uint8Array, start: number, moduleSize: number, columns: number): ParsedRow | null {
+  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: number[] = [];
+  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: BitMatrix, y: number): string {
+  let bits = '';
+  for (let x = 0; x < matrix.width; x++) bits += matrix.get(x, y) ? '1' : '0';
+  return bits;
+}
+
+function allDark(matrix: BitMatrix, y: number): boolean {
+  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: readonly ParsedRow[],
+  rows: number,
+  columns: number,
+  moduleSize: number,
+): CodablockFDecodeResult | null {
+  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: BitMatrix, metadata: CodablockFMetadataHint): CodablockFDecodeResult | null {
+  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: ParsedRow[] = [];
+  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: BitMatrix): CodablockFDecodeResult | null {
+  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<string, Map<number, { columns: number; parsed: ParsedRow; moduleSize: number }>>();
+  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: ParsedRow[] = [];
+      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: BitMatrix): CodablockFDecodeResult {
+  const metadata = (matrix as BitMatrix & { codablockf?: CodablockFMetadataHint }).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: BitMatrix): CodablockFDecodeResult | null {
+  return assemble(image);
+}
+
+/** Alias used by the generic image decoder. */
+export const detectAndDecodeCodablockF = detectCodablockF;

package/src/ts/codablockf/encoder.ts

@@ -0,0 +1,128 @@
+/*
+ * 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 { BitMatrix } from '../core/bit-matrix.js';
+import { EncodeError } from '../core/errors.js';
+import { code128DataCodewords } from '../oned/writers.js';
+import {
+  code128Checksum,
+  code128CodewordsModules,
+  renderStackedRows,
+} from '../stacked128/common.js';
+
+export interface CodablockFEncodeOptions {
+  /** Number of stacked rows, from 2 through 44. */
+  rows?: number;
+  /** Data symbols per row, from 4 through 62. */
+  columns?: number;
+  /** Height of each row in modules. */
+  rowHeight?: number;
+  /** Height of the separator bars in modules. */
+  separatorHeight?: number;
+}
+
+export interface CodablockFMatrixMetadata {
+  readonly rows: number;
+  readonly columns: number;
+  readonly rowHeight: number;
+  readonly separatorHeight: number;
+  readonly checks: readonly [number, number];
+}
+
+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: readonly number[]): [number, number] {
+  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: number | undefined, columns: number | undefined) {
+  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: number, rowsOption?: number, columnsOption?: number) {
+  validateDimensions(rowsOption, columnsOption);
+  const candidates: { rows: number; columns: number; score: number }[] = [];
+  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: string, options: CodablockFEncodeOptions = {}): BitMatrix {
+  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: string[] = [];
+  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 as BitMatrix & { codablockf?: CodablockFMatrixMetadata }).codablockf = {
+    rows,
+    columns,
+    rowHeight,
+    separatorHeight,
+    checks,
+  };
+  return matrix;
+}

package/src/ts/codablockf/index.d.ts

@@ -0,0 +1,31 @@
+import type { BitMatrix } from '../core/bit-matrix.js';
+
+export interface CodablockFEncodeOptions {
+  rows?: number;
+  columns?: number;
+  rowHeight?: number;
+  separatorHeight?: number;
+}
+
+export interface CodablockFMatrixMetadata {
+  readonly rows: number;
+  readonly columns: number;
+  readonly rowHeight: number;
+  readonly separatorHeight: number;
+  readonly checks: readonly [number, number];
+}
+
+export interface CodablockFDecodeResult {
+  readonly format: 'codablockf';
+  readonly text: string;
+  readonly rows: number;
+  readonly columns: number;
+  readonly moduleSize: number;
+  readonly checksum: true;
+}
+
+export declare function encodeCodablockF(value: string, options?: CodablockFEncodeOptions): BitMatrix;
+export declare function codablockFChecks(values: readonly number[]): [number, number];
+export declare function decodeCodablockF(matrix: BitMatrix): CodablockFDecodeResult;
+export declare function detectCodablockF(image: BitMatrix): CodablockFDecodeResult | null;
+export declare const detectAndDecodeCodablockF: typeof detectCodablockF;

package/src/ts/codablockf/index.ts

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

package/src/ts/code16k/decoder.d.ts

@@ -0,0 +1,25 @@
+/*! SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net) */
+/*! SPDX-License-Identifier: MIT */
+import type { Code16KMatrix } from './encoder.js';
+import type { Code16KDecodeOptions } from './tables.js';
+export type Code16KRow = {
+    row: number;
+    values: number[];
+};
+export type Code16KDecodeResult = {
+    format: 'code16k';
+    text: string;
+    rows: number;
+    columns: number;
+    rowHeight: number;
+    separatorHeight: number;
+    mode: number;
+    codewords: number[];
+    checksum: true;
+    symbologyIdentifier: string;
+    gs1?: boolean;
+    fnc1AtStart?: boolean;
+    fnc1Positions?: number[];
+};
+export declare function decodeCode16KRow(modules: string, expectedRow?: number): Code16KRow | null;
+export declare function decodeCode16K(matrix: Code16KMatrix, options?: Code16KDecodeOptions): Code16KDecodeResult;