@sythos/js_barcode_universal 1.5.13 → 1.5.15

package/src/ts/code16k/encoder.ts

@@ -0,0 +1,198 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ * Copyright (c) 2026 Sythos
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/** Code 16K encoder. @module code16k/encoder */
+
+import { BitMatrix } from '../core/bit-matrix.js';
+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,
+  type Code16KEncodeOptions,
+} from './tables.js';
+import { code128PatternModules } from '../stacked128/common.js';
+
+/** Metadata carried by matrices produced by {@link encodeCode16K}. */
+export type Code16KMetadata = {
+  format: 'code16k';
+  rows: number;
+  columns: number;
+  rowHeight: number;
+  separatorHeight: number;
+  mode: number;
+  codewords: number[];
+  checksum: true;
+};
+
+/** A Code 16K matrix with optional non-authoritative encoder metadata. */
+export type Code16KMatrix = BitMatrix & { code16k?: Code16KMetadata };
+
+function asciiText(value: string | Uint8Array | readonly number[]): string {
+  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: readonly number[]): number {
+  let sum = 0;
+  for (let index = 0; index < values.length; index++) sum += (index + 2) * values[index];
+  return sum % 107;
+}
+
+function checksumTwo(valuesThroughC1: readonly number[]): number {
+  let sum = 0;
+  for (let index = 0; index < valuesThroughC1.length; index++) {
+    sum += (index + 1) * valuesThroughC1[index];
+  }
+  return sum % 107;
+}
+
+function rowModules(row: number, values: readonly number[]): string {
+  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: string | Uint8Array | readonly number[],
+  options: Code16KEncodeOptions = {},
+): Code16KMatrix {
+  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,
+  ) as Code16KMatrix;
+  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: string | Uint8Array | readonly number[],
+  options: Code16KEncodeOptions = {},
+): { rows: number; columns: number; width: number; height: number; rowHeight: number; separatorHeight: number } {
+  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/ts/code16k/index.d.ts

@@ -0,0 +1,10 @@
+/*! SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net) */
+/*! SPDX-License-Identifier: MIT */
+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 type { Code16KMode, Code16KModeName, Code16KEncodeOptions, Code16KDecodeOptions, } from './tables.js';
+export { encodeCode16K, code16kDimensions } from './encoder.js';
+export type { Code16KMetadata, Code16KMatrix } from './encoder.js';
+export { decodeCode16K, decodeCode16KRow } from './decoder.js';
+export type { Code16KRow, Code16KDecodeResult } from './decoder.js';
+export { detectCode16K, detectAndDecodeCode16K } from './detector.js';
+export type { Code16KDetectOptions, Code16KPoint, Code16KDetectedResult } from './detector.js';

package/src/ts/code16k/index.ts

@@ -0,0 +1,47 @@
+/*!
+ * 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 type {
+  Code16KMode,
+  Code16KModeName,
+  Code16KEncodeOptions,
+  Code16KDecodeOptions,
+} from './tables.js';
+export { encodeCode16K, code16kDimensions } from './encoder.js';
+export type { Code16KMetadata, Code16KMatrix } from './encoder.js';
+export { decodeCode16K, decodeCode16KRow } from './decoder.js';
+export type { Code16KRow, Code16KDecodeResult } from './decoder.js';
+export { detectCode16K, detectAndDecodeCode16K } from './detector.js';
+export type { Code16KDetectOptions, Code16KPoint, Code16KDetectedResult } from './detector.js';

package/src/ts/code16k/tables.d.ts

@@ -0,0 +1,54 @@
+/*! SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net) */
+/*! SPDX-License-Identifier: MIT */
+export declare const CODE16K_MIN_ROWS = 2;
+export declare const CODE16K_MAX_ROWS = 16;
+export declare const CODE16K_SYMBOLS_PER_ROW = 5;
+export declare const CODE16K_MODULE_WIDTH = 70;
+export declare const CODE16K_START_WIDTH = 7;
+export declare const CODE16K_GUARD_WIDTH = 1;
+export declare const CODE16K_CODEWORD_WIDTH = 11;
+export declare const CODE16K_STOP_WIDTH = 7;
+export declare const CODE16K_DEFAULT_ROW_HEIGHT = 8;
+export declare const CODE16K_DEFAULT_SEPARATOR_HEIGHT = 1;
+export declare const CODE16K_PAD = 103;
+export declare const CODE16K_ROW_PAIRS: readonly (readonly [number, number])[];
+export declare const CODE16K_START_WIDTHS: readonly (readonly [number, number, number, number])[];
+export type Code16KMode = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export type Code16KModeName = 'A' | 'B' | 'C';
+export type Code16KEncodeOptions = {
+    rows?: number;
+    rowHeight?: number;
+    separatorHeight?: number;
+    mode?: Code16KMode | Code16KModeName;
+    gs1?: boolean;
+};
+export type Code16KDecodeOptions = {
+    rowHeight?: number;
+    separatorHeight?: number;
+    rows?: number;
+};
+export declare function code16kModeNumber(mode: Code16KMode | Code16KModeName | undefined, gs1?: boolean): Code16KMode;
+export declare function code16kModeInfo(mode: Code16KMode | Code16KModeName | undefined, gs1?: boolean): {
+    mode: Code16KMode;
+    startSet: Code16KModeName;
+    gs1: boolean;
+};
+export declare function code16kStartModules(row: number): string;
+export declare function code16kStopModules(row: number): string;
+export declare function code16kWidth(): number;
+export declare function code16kGeometry(width: number, height: number, rows: number, rowHeight: number, separatorHeight: number, outerSeparators?: boolean): {
+    width: number;
+    height: number;
+    rows: number;
+    rowHeight: number;
+    separatorHeight: number;
+};
+export declare function validateCode16KOptions(options?: Code16KEncodeOptions): {
+    rows?: number;
+    rowHeight: number;
+    separatorHeight: number;
+    mode: Code16KMode;
+    startSet: Code16KModeName;
+    gs1: boolean;
+};
+export declare function validateCode16KTables(): string[];

package/src/ts/code16k/tables.ts

@@ -0,0 +1,195 @@
+/*!
+ * 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]),
+] as const);
+
+/** 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]),
+] as const);
+
+export type Code16KMode = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export type Code16KModeName = 'A' | 'B' | 'C';
+
+export type Code16KEncodeOptions = {
+  rows?: number;
+  rowHeight?: number;
+  separatorHeight?: number;
+  mode?: Code16KMode | Code16KModeName;
+  gs1?: boolean;
+};
+
+export type Code16KDecodeOptions = {
+  rowHeight?: number;
+  separatorHeight?: number;
+  rows?: number;
+};
+
+/** Return the canonical mode number used by the first symbol character. */
+export function code16kModeNumber(
+  mode: Code16KMode | Code16KModeName | undefined,
+  gs1 = false,
+): Code16KMode {
+  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 as Code16KMode;
+}
+
+/** Resolve the initial Code 128 set and whether the first data value is FNC1. */
+export function code16kModeInfo(
+  mode: Code16KMode | Code16KModeName | undefined,
+  gs1 = false,
+): { mode: Code16KMode; startSet: Code16KModeName; gs1: boolean } {
+  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: Code16KModeName = 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: number): string {
+  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: number): string {
+  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(): number {
+  return CODE16K_MODULE_WIDTH;
+}
+
+/** Validate a matrix geometry and return its row count and separator height. */
+export function code16kGeometry(
+  width: number,
+  height: number,
+  rows: number,
+  rowHeight: number,
+  separatorHeight: number,
+  outerSeparators = true,
+): { width: number; height: number; rows: number; rowHeight: number; separatorHeight: number } {
+  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: Code16KEncodeOptions = {}): {
+  rows?: number;
+  rowHeight: number;
+  separatorHeight: number;
+  mode: Code16KMode;
+  startSet: Code16KModeName;
+  gs1: boolean;
+} {
+  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(): string[] {
+  const problems: string[] = [];
+  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;
+}

package/src/ts/composite/index.d.ts

@@ -0,0 +1,74 @@
+/*!
+ * Sythos Barcode Suite — GS1 Composite declarations
+ * SPDX-License-Identifier: MIT
+ */
+
+import type { BitMatrix } from '../core/bit-matrix.js';
+
+export const GS1_COMPOSITE_PROFILE: 'sythos-gs1-composite-bounded';
+export const GS1_COMPOSITE_HOSTS: readonly [
+  'databar14',
+  'databar-truncated',
+  'databar-stacked',
+  'databar-stacked-omnidirectional',
+  'databar-limited',
+  'databar-expanded',
+];
+
+export type GS1CompositeHostFormat = typeof GS1_COMPOSITE_HOSTS[number];
+export type GS1CompositeComponent = 'auto' | 'cc-a' | 'cc-b';
+export type GS1Element = { ai: string; value: string };
+
+export type GS1CompositeInput = {
+  linear: {
+    format: GS1CompositeHostFormat | string;
+    value: string | number | GS1Element[];
+    options?: Record<string, unknown>;
+  };
+  data: string | GS1Element[];
+  component?: GS1CompositeComponent;
+  rowHeight?: number;
+  separatorGap?: 1 | 2 | 3;
+  moduleScale?: number;
+};
+
+export type GS1CompositeOptions = {
+  component?: GS1CompositeComponent;
+  rowHeight?: number;
+  separatorGap?: 1 | 2 | 3;
+  moduleScale?: number;
+};
+
+export type GS1CompositeResult = {
+  format: 'gs1composite';
+  profile: typeof GS1_COMPOSITE_PROFILE;
+  certified: false;
+  text: string;
+  raw: string;
+  gs1: true;
+  linkage: true;
+  elements: ReadonlyArray<GS1Element & { fixed?: boolean }>;
+  linearFormat: GS1CompositeHostFormat;
+  linear: Record<string, unknown>;
+  component: 'cc-a' | 'cc-b';
+  componentVariant: number;
+  componentRows: number;
+  componentColumns: number;
+  componentRowHeight: number;
+  corrections: number;
+  moduleScale: number;
+  separatorGap?: number;
+  symbologyIdentifier: ']e1' | ']e2';
+  bounds?: { x: number; y: number; width: number; height: number };
+  corners?: Array<{ x: number; y: number }>;
+  matrix?: BitMatrix;
+  moduleSize?: number;
+  rotation?: 0 | 90 | 180 | 270;
+  confidence?: number;
+  quality?: { quietZone: boolean; checksum: boolean; rows: number; consistency: number };
+};
+
+export function encodeGS1Composite(input: GS1CompositeInput, options?: GS1CompositeOptions): BitMatrix;
+export function decodeGS1Composite(matrix: BitMatrix): GS1CompositeResult;
+export function detectGS1Composite(binaryImage: BitMatrix): GS1CompositeResult | null;
+export const detectAndDecodeGS1Composite: typeof detectGS1Composite;