@sythos/js_barcode_universal 1.5.8 → 1.5.9

package/src/ts/databar/decoder.ts

@@ -0,0 +1,215 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/** Clean-matrix decoder for GS1 DataBar Omnidirectional and Truncated. @module databar/decoder */
+
+import { ChecksumError, FormatError } from '../core/errors.js';
+import { BitMatrix } from '../core/bit-matrix.js';
+import { decodeDataBar14GTIN } from './codec.js';
+import {
+  DATABAR14_CHECKSUM_WEIGHTS,
+  DATABAR14_FINDERS,
+  dataBar14ValueForWidths,
+} from './patterns.js';
+
+function sampledRuns(matrix) {
+  if (!matrix || !Number.isInteger(matrix.width) || !Number.isInteger(matrix.height)) {
+    throw new TypeError('GS1 DataBar decoder expects a BitMatrix-like value');
+  }
+  if (matrix.width % 96 !== 0) throw new FormatError('GS1 DataBar-14 matrix width must be an integer multiple of 96 modules');
+  const scale = matrix.width / 96;
+  const y = Math.floor(matrix.height / 2);
+  const bits = Array.from({ length: 96 }, (_, x) => matrix.get(x * scale + Math.floor(scale / 2), y));
+  if (bits[0] || !bits[95]) throw new FormatError('GS1 DataBar-14 guard pattern is invalid');
+  const runs = [];
+  let current = bits[0];
+  let length = 0;
+  for (const bit of bits) {
+    if (bit === current) length++;
+    else {
+      runs.push(length);
+      current = bit;
+      length = 1;
+    }
+  }
+  runs.push(length);
+  if (runs.length !== 46 || runs[0] !== 1 || runs[1] !== 1 || runs[44] !== 1 || runs[45] !== 1) {
+    throw new FormatError('GS1 DataBar-14 element count or guard widths are invalid');
+  }
+  return runs;
+}
+
+function finderIndex(widths) {
+  const key = widths.join(',');
+  return DATABAR14_FINDERS.findIndex((candidate) => candidate.join(',') === key);
+}
+
+function expectedChecksum(widths) {
+  const offsets = [0, 8, 24, 16];
+  let checksum = 0;
+  for (let character = 0; character < 4; character++) {
+    for (let element = 0; element < 8; element++) {
+      checksum += widths[character][element] * DATABAR14_CHECKSUM_WEIGHTS[offsets[character] + element];
+    }
+  }
+  checksum %= 79;
+  if (checksum >= 8) checksum++;
+  if (checksum >= 72) checksum++;
+  return checksum;
+}
+
+/** Decode a clean or integer-scaled 96-module DataBar-14 matrix. */
+export function decodeDataBar14(matrix) {
+  const runs = sampledRuns(matrix);
+  const widths = [
+    runs.slice(2, 10),
+    runs.slice(15, 23).slice().reverse(),
+    runs.slice(23, 31),
+    runs.slice(36, 44).slice().reverse(),
+  ];
+  const leftFinder = finderIndex(runs.slice(10, 15));
+  const rightFinder = finderIndex(runs.slice(31, 36).slice().reverse());
+  if (leftFinder < 0 || rightFinder < 0) throw new FormatError('GS1 DataBar-14 finder pattern is invalid');
+  const encodedChecksum = leftFinder * 9 + rightFinder;
+  if (encodedChecksum !== expectedChecksum(widths)) throw new ChecksumError('GS1 DataBar-14 checksum mismatch');
+
+  const outerLeft = dataBar14ValueForWidths(widths[0], 'outside');
+  const innerLeft = dataBar14ValueForWidths(widths[1], 'inside');
+  const innerRight = dataBar14ValueForWidths(widths[2], 'inside');
+  const outerRight = dataBar14ValueForWidths(widths[3], 'outside');
+  const decoded = decodeDataBar14GTIN({ outerLeft, innerLeft, outerRight, innerRight });
+  return Object.freeze({
+    format: 'databar-omnidirectional',
+    text: decoded.gtin,
+    gtin: decoded.gtin,
+    linkage: decoded.linkage,
+    symbologyIdentifier: ']e0',
+  });
+}
+
+/**
+ * Extract alternating runs from a binarized scanline.
+ * @param {Uint8Array} row
+ * @returns {{widths:number[], dark:boolean}[]}
+ */
+function scanlineRuns(row) {
+  if (!row || row.length < 96) return [];
+  const runs = [];
+  let dark = row[0] === 1;
+  let start = 0;
+  for (let x = 1; x < row.length; x++) {
+    const nextDark = row[x] === 1;
+    if (nextDark === dark) continue;
+    runs.push({ width: x - start, dark });
+    start = x;
+    dark = nextDark;
+  }
+  runs.push({ width: row.length - start, dark });
+  return runs;
+}
+
+/**
+ * Normalize a candidate's pixel runs to the 96 logical DataBar modules.
+ * Rounding is followed by a small conservation pass so mild non-integer
+ * scaling does not change the total symbol width.
+ * @param {number[]} raw
+ * @returns {number[]|null}
+ */
+function normalizeScanlineWidths(raw) {
+  const total = raw.reduce((sum, width) => sum + width, 0);
+  if (total <= 0) return null;
+  const scale = total / 96;
+  if (scale < 0.5) return null;
+  const widths = raw.map((width) => Math.max(1, Math.round(width / scale)));
+  let delta = 96 - widths.reduce((sum, width) => sum + width, 0);
+  while (delta !== 0) {
+    if (delta > 0) {
+      let index = 0;
+      for (let i = 1; i < widths.length; i++) if (raw[i] > raw[index]) index = i;
+      widths[index]++;
+      delta--;
+    } else {
+      let index = -1;
+      for (let i = 0; i < widths.length; i++) {
+        if (widths[i] <= 1) continue;
+        if (index < 0 || raw[i] / widths[i] > raw[index] / widths[index]) index = i;
+      }
+      if (index < 0) return null;
+      widths[index]--;
+      delta++;
+    }
+  }
+  if (widths[0] !== 1 || widths[widths.length - 1] !== 1) return null;
+  return widths;
+}
+
+/** Build a 96-module row from normalized alternating runs. */
+function matrixFromRuns(widths, darkFirst) {
+  const matrix = new BitMatrix(96, 1);
+  let x = 0;
+  let dark = darkFirst;
+  for (const width of widths) {
+    if (dark) for (let i = 0; i < width; i++) matrix.set(x + i, 0);
+    x += width;
+    dark = !dark;
+  }
+  return matrix;
+}
+
+/**
+ * Decode GS1 DataBar-14 from one raster scanline. This is the image layer over
+ * the existing clean 96-module decoder; it recognizes both Omnidirectional
+ * and Truncated symbols because their horizontal pattern is identical.
+ *
+ * @param {Uint8Array} row
+ * @returns {{format:'gs1databar14', text:string, gtin:string, gs1:boolean, linkage:boolean, symbologyIdentifier:string, elements:Array}|null}
+ */
+export function decodeDataBar14Scanline(row) {
+  const runs = scanlineRuns(row);
+  for (let start = 0; start + 46 <= runs.length; start++) {
+    if (runs[start].dark) continue;
+    const candidate = runs.slice(start, start + 46);
+    if (start + 46 < runs.length && runs[start + 46].dark) continue;
+    const widths = normalizeScanlineWidths(candidate.map((run) => run.width));
+    if (!widths) continue;
+    try {
+      const decoded = decodeDataBar14(matrixFromRuns(widths, false));
+      return {
+        ...decoded,
+        format: 'gs1databar14',
+        gs1: true,
+        elements: [{ ai: '01', value: decoded.gtin, fixed: true }],
+      };
+    } catch {
+      // Try the next light-run candidate in the scanline.
+    }
+  }
+  return null;
+}

package/src/ts/databar/encoder.ts

@@ -0,0 +1,96 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/** GS1 DataBar Omnidirectional and Truncated encoder. @module databar/encoder */
+
+import { BitMatrix } from '../core/bit-matrix.js';
+import { EncodeError } from '../core/errors.js';
+import { encodeDataBar14GTIN } from './codec.js';
+import {
+  DATABAR14_CHECKSUM_WEIGHTS,
+  DATABAR14_FINDERS,
+  dataBar14CharacterWidths,
+} from './patterns.js';
+
+function finderIndexes(characters) {
+  const widths = characters.map((value, index) =>
+    dataBar14CharacterWidths(value, index === 0 || index === 3 ? 'outside' : 'inside')
+  );
+  let checksum = 0;
+  const weightOffsets = [0, 8, 24, 16];
+  for (let character = 0; character < 4; character++) {
+    for (let element = 0; element < 8; element++) {
+      checksum += widths[character][element] * DATABAR14_CHECKSUM_WEIGHTS[weightOffsets[character] + element];
+    }
+  }
+  checksum %= 79;
+  if (checksum >= 8) checksum++;
+  if (checksum >= 72) checksum++;
+  return { widths, checksum, left: Math.floor(checksum / 9), right: checksum % 9 };
+}
+
+function widthsToMatrix(widths, height) {
+  const width = widths.reduce((sum, value) => sum + value, 0);
+  const matrix = new BitMatrix(width, height);
+  let dark = false;
+  let x = 0;
+  for (const run of widths) {
+    if (dark) matrix.setRegion(x, 0, run, height);
+    x += run;
+    dark = !dark;
+  }
+  return matrix;
+}
+
+/** Encode a checked GTIN as DataBar Omnidirectional or Truncated. */
+export function encodeDataBar14(value, options = {}) {
+  const variant = options.variant ?? 'omnidirectional';
+  if (variant !== 'omnidirectional' && variant !== 'truncated') {
+    throw new EncodeError('GS1 DataBar-14 physical encoder currently supports omnidirectional and truncated');
+  }
+  const height = options.height ?? (variant === 'omnidirectional' ? 33 : 13);
+  if (!Number.isInteger(height) || height < (variant === 'omnidirectional' ? 33 : 13)) {
+    throw new EncodeError(`GS1 DataBar ${variant} height is below its normative minimum`);
+  }
+  const compacted = encodeDataBar14GTIN(value, { linkage: options.linkage });
+  const characters = compacted.physicalCharacters;
+  const check = finderIndexes(characters);
+  const widths = [1, 1];
+  widths.push(...check.widths[0]);
+  widths.push(...DATABAR14_FINDERS[check.left]);
+  widths.push(...check.widths[1].slice().reverse());
+  widths.push(...check.widths[2]);
+  widths.push(...DATABAR14_FINDERS[check.right].slice().reverse());
+  widths.push(...check.widths[3].slice().reverse());
+  widths.push(1, 1);
+  const matrix = widthsToMatrix(widths, height);
+  matrix.databar = Object.freeze({ variant, gtin: compacted.gtin, linkage: compacted.linkage, checksum: check.checksum });
+  return matrix;
+}

package/src/ts/databar/gs1.ts

@@ -0,0 +1,177 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/** GS1 element-string codec used by GS1 DataBar Expanded. @module databar/gs1 */
+
+import { EncodeError, FormatError } from '../core/errors.js';
+
+export const GS1_SEPARATOR = '\x1d';
+
+const EXACT = new Map([
+  ['00', [18, true]], ['01', [14, true]], ['02', [14, true]],
+  ['10', [20, false]], ['11', [6, true]], ['12', [6, true]],
+  ['13', [6, true]], ['15', [6, true]], ['16', [6, true]],
+  ['17', [6, true]], ['20', [2, true]], ['21', [20, false]],
+  ['22', [29, false]], ['30', [8, false]], ['37', [8, false]],
+  ['240', [30, false]], ['241', [30, false]], ['242', [6, false]],
+  ['243', [20, false]], ['250', [30, false]], ['251', [30, false]],
+  ['253', [30, false]], ['254', [20, false]], ['255', [13, true]],
+  ['400', [30, false]], ['401', [30, false]], ['402', [17, true]],
+  ['403', [30, false]], ['410', [13, true]], ['411', [13, true]],
+  ['412', [13, true]], ['413', [13, true]], ['414', [13, true]],
+  ['415', [13, true]], ['416', [13, true]], ['417', [13, true]],
+  ['420', [20, false]], ['421', [15, false]], ['422', [3, true]],
+  ['423', [15, false]], ['424', [3, true]], ['425', [3, true]],
+  ['426', [3, true]], ['427', [3, false]],
+  ['7001', [13, true]], ['7002', [30, false]], ['7003', [10, true]],
+  ['7004', [4, false]], ['7005', [12, false]], ['7006', [6, true]],
+  ['7007', [12, false]], ['7008', [3, false]], ['7009', [10, false]],
+  ['7010', [2, false]], ['7020', [20, false]], ['7021', [20, false]],
+  ['7022', [20, false]], ['710', [20, false]], ['711', [20, false]],
+  ['712', [20, false]], ['713', [20, false]], ['714', [20, false]],
+  ['715', [20, false]],
+  ['8001', [14, true]], ['8002', [20, false]], ['8003', [30, false]],
+  ['8004', [30, false]], ['8005', [6, true]], ['8006', [18, true]],
+  ['8007', [34, false]], ['8008', [12, false]], ['8009', [50, false]],
+  ['8010', [30, false]], ['8011', [12, false]], ['8012', [20, false]],
+  ['8013', [30, false]], ['8017', [18, true]], ['8018', [18, true]],
+  ['8019', [10, false]], ['8020', [25, false]], ['8026', [18, true]],
+  ['8110', [70, false]], ['8111', [4, true]], ['8112', [70, false]],
+  ['8200', [70, false]],
+]);
+
+function rangedAI(ai) {
+  if (/^31[0-6]\d$/.test(ai) || /^32[0-7]\d$/.test(ai) ||
+      /^33[0-7]\d$/.test(ai) || /^34[0-9]\d$/.test(ai) ||
+      /^35[0-7]\d$/.test(ai) || /^36[0-9]\d$/.test(ai)) return [6, true];
+  if (/^390\d$/.test(ai) || /^392\d$/.test(ai)) return [15, false];
+  if (/^391\d$/.test(ai) || /^393\d$/.test(ai)) return [18, false];
+  if (/^394\d$/.test(ai)) return [4, true];
+  if (/^395\d$/.test(ai)) return [6, true];
+  if (/^703\d$/.test(ai) || /^723\d$/.test(ai)) return [30, false];
+  return undefined;
+}
+
+export function gs1AIInfo(ai) {
+  if (typeof ai !== 'string' || !/^\d{2,4}$/.test(ai)) return undefined;
+  const spec = EXACT.get(ai) || rangedAI(ai);
+  if (!spec) return undefined;
+  return { ai, length: spec[0], fixed: spec[1] };
+}
+
+function assertCharacters(value, label, ErrorType) {
+  if (/[^\x20-\x7e]/.test(value)) {
+    throw new ErrorType(`GS1: ${label} contains a character outside the GS1 element-string character set`);
+  }
+}
+
+function validateElement(ai, value, ErrorType) {
+  const info = gs1AIInfo(ai);
+  if (!info) throw new ErrorType(`GS1: unsupported or invalid Application Identifier ${ai}`);
+  if (value.length === 0) throw new ErrorType(`GS1: AI ${ai} must not be empty`);
+  if (info.fixed ? value.length !== info.length : value.length > info.length) {
+    const expectation = info.fixed ? `exactly ${info.length}` : `at most ${info.length}`;
+    throw new ErrorType(`GS1: AI ${ai} requires ${expectation} characters`);
+  }
+  assertCharacters(value, `AI ${ai}`, ErrorType);
+  return { ai, value, fixed: info.fixed };
+}
+
+export function parseGS1ElementString(input) {
+  if (typeof input !== 'string' || input.length === 0) {
+    throw new EncodeError('GS1: element string must be a non-empty string');
+  }
+  const elements = [];
+  let offset = 0;
+  while (offset < input.length) {
+    const match = /^\((\d{2,4})\)/.exec(input.slice(offset));
+    if (!match) throw new EncodeError(`GS1: expected an Application Identifier at offset ${offset}`);
+    const ai = match[1];
+    offset += match[0].length;
+    const next = input.indexOf('(', offset);
+    const end = next < 0 ? input.length : next;
+    elements.push(validateElement(ai, input.slice(offset, end), EncodeError));
+    offset = end;
+  }
+  return elements;
+}
+
+export function encodeGS1ElementString(input) {
+  const elements = Array.isArray(input)
+    ? input.map(({ ai, value }) => validateElement(String(ai), String(value), EncodeError))
+    : parseGS1ElementString(input);
+  return elements.map((element, index) =>
+    `${element.ai}${element.value}${!element.fixed && index + 1 < elements.length ? GS1_SEPARATOR : ''}`
+  ).join('');
+}
+
+function matchAIAt(data, offset) {
+  for (const length of [4, 3, 2]) {
+    const ai = data.slice(offset, offset + length);
+    if (gs1AIInfo(ai)) return ai;
+  }
+  return undefined;
+}
+
+export function decodeGS1ElementString(data) {
+  if (typeof data !== 'string' || data.length === 0) {
+    throw new FormatError('GS1: encoded data must be a non-empty string');
+  }
+  const elements = [];
+  let offset = 0;
+  while (offset < data.length) {
+    if (data[offset] === GS1_SEPARATOR) {
+      throw new FormatError(`GS1: unexpected separator at offset ${offset}`);
+    }
+    const ai = matchAIAt(data, offset);
+    if (!ai) throw new FormatError(`GS1: unknown Application Identifier at offset ${offset}`);
+    offset += ai.length;
+    const info = gs1AIInfo(ai);
+    let value;
+    if (info.fixed) {
+      value = data.slice(offset, offset + info.length);
+      if (value.length !== info.length || value.includes(GS1_SEPARATOR)) {
+        throw new FormatError(`GS1: truncated fixed-length AI ${ai}`);
+      }
+      offset += info.length;
+    } else {
+      const separator = data.indexOf(GS1_SEPARATOR, offset);
+      const end = separator < 0 ? data.length : separator;
+      value = data.slice(offset, end);
+      offset = separator < 0 ? data.length : separator + 1;
+    }
+    elements.push(validateElement(ai, value, FormatError));
+  }
+  return elements;
+}
+
+export function formatGS1Elements(elements) {
+  return elements.map(({ ai, value }) => `(${ai})${value}`).join('');
+}

package/src/ts/databar/index.ts

@@ -0,0 +1,68 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/** Verified GS1 DataBar data-layer primitives. @module databar */
+
+export {
+  dataBarGtinTransmission,
+  decodeDataBar14GTIN,
+  decodeDataBarLimitedGTIN,
+  encodeDataBar14GTIN,
+  encodeDataBarLimitedGTIN,
+  gtinCheckDigit,
+  makeGTIN14,
+  normalizeGTIN,
+} from './codec.js';
+
+export {
+  GS1_SEPARATOR,
+  decodeGS1ElementString,
+  encodeGS1ElementString,
+  formatGS1Elements,
+  gs1AIInfo,
+  parseGS1ElementString,
+} from './gs1.js';
+
+export {
+  DATABAR14_VARIANTS,
+  DATABAR_LIMITED_VARIANT,
+  dataBar14GroupFor,
+  validateDataBarTables,
+} from './tables.js';
+
+export { encodeDataBar14 } from './encoder.js';
+export { decodeDataBar14, decodeDataBar14Scanline } from './decoder.js';
+export {
+  DATABAR14_CHECKSUM_WEIGHTS,
+  DATABAR14_FINDERS,
+  dataBar14CharacterWidths,
+  dataBar14ValueForWidths,
+  dataBarWidths,
+} from './patterns.js';