@sythos/js_barcode_universal 1.5.8 → 1.5.9

package/src/js/databar/codec.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * GTIN validation and numeric compaction for GS1 DataBar GTIN-only symbols.
  *
@@ -37,145 +36,131 @@
  *
  * @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';
-
+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;
+    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;
+    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);
+    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');
+    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);
+    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) };
+    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]),
-  });
+    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,
-  });
+    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 });
+    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) });
+    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)}`;
+    return `]e001${normalizeGTIN(value)}`;
 }

package/src/js/databar/decoder.js

@@ -27,114 +27,110 @@
  *
  * 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';
-
+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;
+    if (!matrix || !Number.isInteger(matrix.width) || !Number.isInteger(matrix.height)) {
+        throw new TypeError('GS1 DataBar decoder expects a BitMatrix-like value');
     }
-  }
-  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;
+    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);
+    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];
+    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;
+    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',
-  });
+    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;
+    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
@@ -143,46 +139,55 @@ function scanlineRuns(row) {
  * @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++;
+    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;
+    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;
+    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
@@ -192,24 +197,28 @@ function matrixFromRuns(widths, darkFirst) {
  * @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.
+    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;
+    return null;
 }