@sythos/js_barcode_universal 1.5.7 → 1.5.9

package/src/js/databar/codec.js

@@ -0,0 +1,166 @@
+/*!
+ * 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.
+ */
+/**
+ * GTIN validation and numeric compaction for GS1 DataBar GTIN-only symbols.
+ *
+ * This is intentionally not a bar-pattern encoder. It emits the exact symbol
+ * character values required by ISO/IEC 24724:2011; a later encoder can turn
+ * those values into widths without reinterpreting a GTIN or linkage flag.
+ *
+ * @module databar/codec
+ */
+import { DATABAR14_INSIDE_RADIX, DATABAR14_PAIR_RADIX, DATABAR14_SYMBOL_LIMIT, DATABAR_LIMITED_DATA_LIMIT, DATABAR_LIMITED_LINKAGE_OFFSET, DATABAR_LIMITED_PAIR_RADIX, } from './tables.js';
+const GTIN_LENGTHS = new Set([8, 12, 13, 14]);
+function digits(value, label) {
+    const text = String(value);
+    if (!/^\d+$/.test(text))
+        throw new TypeError(`${label} must contain only decimal digits`);
+    return text;
+}
+function asCharacterValue(value, label, maximum) {
+    if (!Number.isInteger(value) || value < 0 || value > maximum) {
+        throw new RangeError(`${label} must be an integer from 0 to ${maximum}`);
+    }
+    return value;
+}
+/** Calculate the GS1 modulo-10 check digit for a GTIN body. */
+export function gtinCheckDigit(body) {
+    const text = digits(body, 'GTIN body');
+    if (text.length < 1 || text.length > 13)
+        throw new RangeError('GTIN body must contain 1 to 13 digits');
+    let sum = 0;
+    for (let i = text.length - 1, weight = 3; i >= 0; i--, weight = weight === 3 ? 1 : 3) {
+        sum += Number(text[i]) * weight;
+    }
+    return String((10 - (sum % 10)) % 10);
+}
+/** Return a checked 14-digit GTIN, preserving only its standardized digits. */
+export function normalizeGTIN(value) {
+    const input = digits(value, 'GTIN');
+    if (!GTIN_LENGTHS.has(input.length)) {
+        throw new RangeError('GTIN must contain 8, 12, 13, or 14 digits including its check digit');
+    }
+    if (gtinCheckDigit(input.slice(0, -1)) !== input.at(-1)) {
+        throw new RangeError(`GTIN check digit is invalid for ${input}`);
+    }
+    return input.padStart(14, '0');
+}
+/** Build a checked GTIN-14 from its thirteen-digit data body. */
+export function makeGTIN14(body) {
+    const input = digits(body, 'GTIN-14 body');
+    if (input.length > 13)
+        throw new RangeError('GTIN-14 body must contain at most 13 digits');
+    const padded = input.padStart(13, '0');
+    return padded + gtinCheckDigit(padded);
+}
+function gtinFromSymbolValue(symbolValue) {
+    const value = BigInt(symbolValue);
+    if (value < 0n || value >= DATABAR14_SYMBOL_LIMIT)
+        throw new RangeError('GS1 DataBar-14 symbol value is out of range');
+    const linkage = value >= 10000000000000n;
+    const body = (linkage ? value - 10000000000000n : value).toString().padStart(13, '0');
+    return { linkage, gtin: body + gtinCheckDigit(body) };
+}
+/**
+ * Compact a GTIN into the four values shared by Omnidirectional, Truncated,
+ * Stacked and Stacked Omnidirectional. The `physicalCharacters` sequence is
+ * left-to-right on a linear DataBar-14 row: 1, 2, 4, 3.
+ */
+export function encodeDataBar14GTIN(value, options = {}) {
+    const gtin = normalizeGTIN(value);
+    const linkage = options.linkage === true;
+    if (options.linkage !== undefined && typeof options.linkage !== 'boolean') {
+        throw new TypeError('GS1 DataBar linkage must be a boolean');
+    }
+    const dataBody = gtin.slice(0, -1);
+    const symbolValue = BigInt(dataBody) + (linkage ? 10000000000000n : 0n);
+    const leftPair = symbolValue / BigInt(DATABAR14_PAIR_RADIX);
+    const rightPair = symbolValue % BigInt(DATABAR14_PAIR_RADIX);
+    const outerLeft = Number(leftPair / BigInt(DATABAR14_INSIDE_RADIX));
+    const innerLeft = Number(leftPair % BigInt(DATABAR14_INSIDE_RADIX));
+    const outerRight = Number(rightPair / BigInt(DATABAR14_INSIDE_RADIX));
+    const innerRight = Number(rightPair % BigInt(DATABAR14_INSIDE_RADIX));
+    return Object.freeze({
+        gtin, linkage, symbolValue, leftPair, rightPair,
+        logicalCharacters: Object.freeze({ outerLeft, innerLeft, outerRight, innerRight }),
+        physicalCharacters: Object.freeze([outerLeft, innerLeft, innerRight, outerRight]),
+    });
+}
+/** Reconstruct and validate a GTIN from the four DataBar-14 character values. */
+export function decodeDataBar14GTIN(values) {
+    if (values === null || typeof values !== 'object')
+        throw new TypeError('GS1 DataBar-14 characters must be an object');
+    const outerLeft = asCharacterValue(values.outerLeft, 'outerLeft', 2840);
+    const innerLeft = asCharacterValue(values.innerLeft, 'innerLeft', 1596);
+    const outerRight = asCharacterValue(values.outerRight, 'outerRight', 2840);
+    const innerRight = asCharacterValue(values.innerRight, 'innerRight', 1596);
+    const leftPair = BigInt(outerLeft) * BigInt(DATABAR14_INSIDE_RADIX) + BigInt(innerLeft);
+    const rightPair = BigInt(outerRight) * BigInt(DATABAR14_INSIDE_RADIX) + BigInt(innerRight);
+    return Object.freeze({
+        ...gtinFromSymbolValue(leftPair * BigInt(DATABAR14_PAIR_RADIX) + rightPair),
+        leftPair, rightPair,
+    });
+}
+/** Compact a DataBar Limited-eligible GTIN into its two data character values. */
+export function encodeDataBarLimitedGTIN(value, options = {}) {
+    const gtin = normalizeGTIN(value);
+    const linkage = options.linkage === true;
+    if (options.linkage !== undefined && typeof options.linkage !== 'boolean') {
+        throw new TypeError('GS1 DataBar linkage must be a boolean');
+    }
+    const dataBody = BigInt(gtin.slice(0, -1));
+    if (dataBody >= DATABAR_LIMITED_DATA_LIMIT) {
+        throw new RangeError('GS1 DataBar Limited requires a GTIN whose indicator digit is 0 or 1');
+    }
+    const symbolValue = dataBody + (linkage ? DATABAR_LIMITED_LINKAGE_OFFSET : 0n);
+    const left = Number(symbolValue / BigInt(DATABAR_LIMITED_PAIR_RADIX));
+    const right = Number(symbolValue % BigInt(DATABAR_LIMITED_PAIR_RADIX));
+    return Object.freeze({ gtin, linkage, symbolValue, left, right });
+}
+/** Reconstruct and validate a GTIN from DataBar Limited data character values. */
+export function decodeDataBarLimitedGTIN(values) {
+    if (values === null || typeof values !== 'object')
+        throw new TypeError('GS1 DataBar Limited characters must be an object');
+    const left = asCharacterValue(values.left, 'left', 1994036);
+    const right = asCharacterValue(values.right, 'right', DATABAR_LIMITED_PAIR_RADIX - 1);
+    let symbolValue = BigInt(left) * BigInt(DATABAR_LIMITED_PAIR_RADIX) + BigInt(right);
+    const linkage = symbolValue >= DATABAR_LIMITED_LINKAGE_OFFSET;
+    if (linkage)
+        symbolValue -= DATABAR_LIMITED_LINKAGE_OFFSET;
+    if (symbolValue < 0n || symbolValue >= DATABAR_LIMITED_DATA_LIMIT) {
+        throw new RangeError('GS1 DataBar Limited character values do not encode a permitted GTIN');
+    }
+    const body = symbolValue.toString().padStart(13, '0');
+    return Object.freeze({ linkage, gtin: body + gtinCheckDigit(body), symbolValue: BigInt(left) * BigInt(DATABAR_LIMITED_PAIR_RADIX) + BigInt(right) });
+}
+/** GS1 transmitted form for the GTIN-only DataBar variants. */
+export function dataBarGtinTransmission(value) {
+    return `]e001${normalizeGTIN(value)}`;
+}

package/src/js/databar/decoder.js

@@ -0,0 +1,224 @@
+/*!
+ * 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/js/databar/encoder.js

@@ -0,0 +1,88 @@
+/*!
+ * 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/js/databar/gs1.js

@@ -0,0 +1,176 @@
+/*!
+ * 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('');
+}