@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/oned/reader.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Linear barcode reading.
  *
@@ -47,29 +46,14 @@
  *
  * @module oned/reader
  */
-
 import { NotFoundError } from '../core/errors.js';
-import {
-  EAN_L, EAN_G, EAN_R, EAN13_PARITY, UPCE_PARITY,
-  CODE39, CODE39_CHECK_SET,
-  CODE93, CODE93_VALUES,
-  CODE128, CODE128_START_A, CODE128_START_B, CODE128_START_C,
-  CODE128_STOP, CODE128_FNC1, CODE128_CODE_A, CODE128_CODE_B, CODE128_CODE_C,
-  CODE128_SHIFT,
-  ITF, CODABAR, CODABAR_START_STOP,
-  CODE11, CODE11_START_STOP, MSI_START, MSI_STOP, MSI_BIT,
-} from './patterns.js';
+import { EAN_L, EAN_G, EAN_R, EAN13_PARITY, UPCE_PARITY, CODE39, CODE39_CHECK_SET, CODE93, CODE93_VALUES, CODE128, CODE128_START_A, CODE128_START_B, CODE128_START_C, CODE128_STOP, CODE128_FNC1, CODE128_CODE_A, CODE128_CODE_B, CODE128_CODE_C, CODE128_SHIFT, ITF, CODABAR, CODABAR_START_STOP, CODE11, CODE11_START_STOP, } from './patterns.js';
 import { ean13CheckDigit, upceToUpcaBody } from './writers.js';
-import {
-  EAN2_PARITY, EAN5_PARITY, EAN_ADDON_START, EAN_ADDON_SEPARATOR,
-  ean5Checksum,
-} from './addons.js';
+import { EAN2_PARITY, EAN5_PARITY, ean5Checksum, } from './addons.js';
 import { decodeDataBar14Scanline } from '../databar/decoder.js';
-
 /* ------------------------------------------------------------------ *
  * Pattern matching primitives
  * ------------------------------------------------------------------ */
-
 /**
  * Compare measured run lengths against an ideal pattern, scale-independently.
  *
@@ -84,30 +68,29 @@ import { decodeDataBar14Scanline } from '../databar/decoder.js';
  * @returns {number}
  */
 export function patternVariance(counters, pattern, maxIndividual) {
-  const n = counters.length;
-  if (n !== pattern.length) return Infinity;
-
-  let total = 0;
-  let patternTotal = 0;
-  for (let i = 0; i < n; i++) {
-    total += counters[i];
-    patternTotal += pattern[i];
-  }
-  if (total < patternTotal) return Infinity; // fewer pixels than modules
-
-  const unit = total / patternTotal;
-  const maxVariance = unit * maxIndividual;
-
-  let variance = 0;
-  for (let i = 0; i < n; i++) {
-    const expected = pattern[i] * unit;
-    const delta = Math.abs(counters[i] - expected);
-    if (delta > maxVariance) return Infinity;
-    variance += delta;
-  }
-  return variance / total;
+    const n = counters.length;
+    if (n !== pattern.length)
+        return Infinity;
+    let total = 0;
+    let patternTotal = 0;
+    for (let i = 0; i < n; i++) {
+        total += counters[i];
+        patternTotal += pattern[i];
+    }
+    if (total < patternTotal)
+        return Infinity; // fewer pixels than modules
+    const unit = total / patternTotal;
+    const maxVariance = unit * maxIndividual;
+    let variance = 0;
+    for (let i = 0; i < n; i++) {
+        const expected = pattern[i] * unit;
+        const delta = Math.abs(counters[i] - expected);
+        if (delta > maxVariance)
+            return Infinity;
+        variance += delta;
+    }
+    return variance / total;
 }
-
 /**
  * Measure alternating run lengths starting at `start`.
  *
@@ -117,30 +100,29 @@ export function patternVariance(counters, pattern, maxIndividual) {
  * @returns {boolean} False if the row ended before the runs were filled.
  */
 export function recordPattern(row, start, counters) {
-  counters.fill(0);
-  const end = row.length;
-  if (start >= end) return false;
-
-  let isDark = row[start] === 1;
-  let index = 0;
-  let i = start;
-
-  while (i < end) {
-    if ((row[i] === 1) === isDark) {
-      counters[index]++;
-    } else {
-      index++;
-      if (index === counters.length) break;
-      counters[index] = 1;
-      isDark = !isDark;
+    counters.fill(0);
+    const end = row.length;
+    if (start >= end)
+        return false;
+    let isDark = row[start] === 1;
+    let index = 0;
+    let i = start;
+    while (i < end) {
+        if ((row[i] === 1) === isDark) {
+            counters[index]++;
+        }
+        else {
+            index++;
+            if (index === counters.length)
+                break;
+            counters[index] = 1;
+            isDark = !isDark;
+        }
+        i++;
     }
-    i++;
-  }
-
-  // The final run may legitimately reach the edge of the image.
-  return index === counters.length || (index === counters.length - 1 && i === end);
+    // The final run may legitimately reach the edge of the image.
+    return index === counters.length || (index === counters.length - 1 && i === end);
 }
-
 /**
  * Classify run lengths into narrow and wide, for the n/w symbologies.
  *
@@ -154,98 +136,93 @@ export function recordPattern(row, start, counters) {
  * @returns {number} Bit pattern, MSB = first element wide; -1 if undecidable.
  */
 export function toNarrowWidePattern(counters, expectedWide) {
-  const n = counters.length;
-  let maxNarrow = 0;
-
-  for (;;) {
-    let nextNarrow = Infinity;
-    for (let i = 0; i < n; i++) {
-      if (counters[i] > maxNarrow && counters[i] < nextNarrow) nextNarrow = counters[i];
-    }
-    if (nextNarrow === Infinity) return -1;
-    maxNarrow = nextNarrow;
-
-    let wideCount = 0;
-    let pattern = 0;
-    let wideTotal = 0;
-    let narrowTotal = 0;
-    for (let i = 0; i < n; i++) {
-      if (counters[i] > maxNarrow) {
-        pattern |= 1 << (n - 1 - i);
-        wideCount++;
-        wideTotal += counters[i];
-      } else {
-        narrowTotal += counters[i];
-      }
-    }
-
-    if (wideCount === expectedWide) {
-      // Sanity: a wide element should be clearly wider than a narrow one.
-      const narrowCount = n - wideCount;
-      if (narrowCount === 0) return -1;
-      const avgWide = wideTotal / wideCount;
-      const avgNarrow = narrowTotal / narrowCount;
-      if (avgWide < avgNarrow * 1.4) return -1;
-      return pattern;
+    const n = counters.length;
+    let maxNarrow = 0;
+    for (;;) {
+        let nextNarrow = Infinity;
+        for (let i = 0; i < n; i++) {
+            if (counters[i] > maxNarrow && counters[i] < nextNarrow)
+                nextNarrow = counters[i];
+        }
+        if (nextNarrow === Infinity)
+            return -1;
+        maxNarrow = nextNarrow;
+        let wideCount = 0;
+        let pattern = 0;
+        let wideTotal = 0;
+        let narrowTotal = 0;
+        for (let i = 0; i < n; i++) {
+            if (counters[i] > maxNarrow) {
+                pattern |= 1 << (n - 1 - i);
+                wideCount++;
+                wideTotal += counters[i];
+            }
+            else {
+                narrowTotal += counters[i];
+            }
+        }
+        if (wideCount === expectedWide) {
+            // Sanity: a wide element should be clearly wider than a narrow one.
+            const narrowCount = n - wideCount;
+            if (narrowCount === 0)
+                return -1;
+            const avgWide = wideTotal / wideCount;
+            const avgNarrow = narrowTotal / narrowCount;
+            if (avgWide < avgNarrow * 1.4)
+                return -1;
+            return pattern;
+        }
+        if (wideCount < expectedWide)
+            return -1;
     }
-    if (wideCount < expectedWide) return -1;
-  }
 }
-
 /** Convert an 'n'/'w' pattern string to the same bit encoding. */
 function nwToBits(pattern) {
-  let bits = 0;
-  for (let i = 0; i < pattern.length; i++) {
-    if (pattern[i] === 'w') bits |= 1 << (pattern.length - 1 - i);
-  }
-  return bits;
+    let bits = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        if (pattern[i] === 'w')
+            bits |= 1 << (pattern.length - 1 - i);
+    }
+    return bits;
 }
-
 /** Convert a digit-width pattern string to a numeric array. */
 function widthsToArray(pattern) {
-  return [...pattern].map(Number);
+    return [...pattern].map(Number);
 }
-
 /** Convert a module string ('0'/'1') to run lengths. */
 function modulesToRuns(modules) {
-  const runs = [];
-  let current = modules[0];
-  let count = 0;
-  for (const ch of modules) {
-    if (ch === current) count++;
-    else { runs.push(count); current = ch; count = 1; }
-  }
-  runs.push(count);
-  return runs;
+    const runs = [];
+    let current = modules[0];
+    let count = 0;
+    for (const ch of modules) {
+        if (ch === current)
+            count++;
+        else {
+            runs.push(count);
+            current = ch;
+            count = 1;
+        }
+    }
+    runs.push(count);
+    return runs;
 }
-
 /* ------------------------------------------------------------------ *
  * Precomputed lookup structures
  * ------------------------------------------------------------------ */
-
 const EAN_L_RUNS = EAN_L.map(modulesToRuns);
 const EAN_G_RUNS = EAN_G.map(modulesToRuns);
 const EAN_R_RUNS = EAN_R.map(modulesToRuns);
 const CODE128_RUNS = CODE128.map(widthsToArray);
-const CODE93_RUNS = Object.fromEntries(
-  Object.entries(CODE93).map(([k, v]) => [k, widthsToArray(v)])
-);
-const CODE39_BITS = Object.fromEntries(
-  Object.entries(CODE39).map(([k, v]) => [nwToBits(v), k])
-);
-const CODABAR_BITS = Object.fromEntries(
-  Object.entries(CODABAR).map(([k, v]) => [nwToBits(v), k])
-);
+const CODE93_RUNS = Object.fromEntries(Object.entries(CODE93).map(([k, v]) => [k, widthsToArray(v)]));
+const CODE39_BITS = Object.fromEntries(Object.entries(CODE39).map(([k, v]) => [nwToBits(v), k]));
+const CODABAR_BITS = Object.fromEntries(Object.entries(CODABAR).map(([k, v]) => [nwToBits(v), k]));
 const ITF_BITS = Object.fromEntries(ITF.map((v, i) => [nwToBits(v), i]));
-const CODE11_BITS = Object.fromEntries(
-  Object.entries(CODE11).flatMap(([ch, value]) => {
+const CODE11_BITS = Object.fromEntries(Object.entries(CODE11).flatMap(([ch, value]) => {
     const bits = nwToBits(value);
     return [[`${bits}:1`, ch], [`${bits}:2`, ch]];
-  })
-);
+}));
 const CODE11_START_BITS = nwToBits(CODE11_START_STOP);
 const CODE11_CHARSET = '0123456789-';
-
 /**
  * Shortest ITF payload treated as a real read.
  *
@@ -254,15 +231,12 @@ const CODE11_CHARSET = '0123456789-';
  * pair of matching runs inside an unrelated symbol read as a valid ITF.
  */
 const MIN_ITF_DIGITS = 6;
-
 const START_END_PATTERN = [1, 1, 1];
 const MIDDLE_PATTERN = [1, 1, 1, 1, 1];
 const UPCE_END_PATTERN = [1, 1, 1, 1, 1, 1];
-
 /* ------------------------------------------------------------------ *
  * EAN / UPC
  * ------------------------------------------------------------------ */
-
 /**
  * Decode one EAN/UPC digit, reporting which parity set matched.
  *
@@ -272,85 +246,83 @@ const UPCE_END_PATTERN = [1, 1, 1, 1, 1, 1];
  * @returns {{digit: number, even: boolean, end: number} | null}
  */
 function decodeEANDigit(row, start, rightHand) {
-  const counters = [0, 0, 0, 0];
-  if (!recordPattern(row, start, counters)) return null;
-  const width = counters[0] + counters[1] + counters[2] + counters[3];
-
-  let best = null;
-  let bestVariance = 0.48; // reject anything worse than this
-
-  const consider = (runs, digit, even) => {
-    const v = patternVariance(counters, runs, 0.7);
-    if (v < bestVariance) {
-      bestVariance = v;
-      best = { digit, even, end: start + width };
-    }
-  };
-
-  for (let d = 0; d < 10; d++) {
-    if (rightHand) {
-      consider(EAN_R_RUNS[d], d, false);
-    } else {
-      consider(EAN_L_RUNS[d], d, false);
-      consider(EAN_G_RUNS[d], d, true);
+    const counters = [0, 0, 0, 0];
+    if (!recordPattern(row, start, counters))
+        return null;
+    const width = counters[0] + counters[1] + counters[2] + counters[3];
+    let best = null;
+    let bestVariance = 0.48; // reject anything worse than this
+    const consider = (runs, digit, even) => {
+        const v = patternVariance(counters, runs, 0.7);
+        if (v < bestVariance) {
+            bestVariance = v;
+            best = { digit, even, end: start + width };
+        }
+    };
+    for (let d = 0; d < 10; d++) {
+        if (rightHand) {
+            consider(EAN_R_RUNS[d], d, false);
+        }
+        else {
+            consider(EAN_L_RUNS[d], d, false);
+            consider(EAN_G_RUNS[d], d, true);
+        }
     }
-  }
-  return best;
+    return best;
 }
-
 /**
  * @param {Uint8Array} row
  * @returns {{format: string, text: string} | null}
  */
 function decodeEANFamily(row) {
-  const guard = findGuard(row, 0, START_END_PATTERN, false);
-  if (!guard) return null;
-
-  let offset = guard.end;
-  const digits = [];
-  let parityBits = 0;
-
-  // Six left-hand digits, recording parity as we go.
-  for (let i = 0; i < 6; i++) {
-    const d = decodeEANDigit(row, offset, false);
-    if (!d) return null;
-    digits.push(d.digit);
-    if (d.even) parityBits |= 1 << (5 - i);
-    offset = d.end;
-  }
-
-  // EAN-8 has no even-parity digits and a middle guard at a different offset;
-  // try the 13-digit reading first, then fall back.
-  const middle = matchAt(row, offset, MIDDLE_PATTERN);
-  if (middle) {
-    offset = middle.end;
+    const guard = findGuard(row, 0, START_END_PATTERN, false);
+    if (!guard)
+        return null;
+    let offset = guard.end;
+    const digits = [];
+    let parityBits = 0;
+    // Six left-hand digits, recording parity as we go.
     for (let i = 0; i < 6; i++) {
-      const d = decodeEANDigit(row, offset, true);
-      if (!d) return null;
-      digits.push(d.digit);
-      offset = d.end;
+        const d = decodeEANDigit(row, offset, false);
+        if (!d)
+            return null;
+        digits.push(d.digit);
+        if (d.even)
+            parityBits |= 1 << (5 - i);
+        offset = d.end;
     }
-    const trailing = matchAt(row, offset, START_END_PATTERN);
-    if (!trailing) return null;
-
-    const parityStr = [];
-    for (let i = 0; i < 6; i++) parityStr.push((parityBits >> (5 - i)) & 1 ? 'G' : 'L');
-    const first = EAN13_PARITY.indexOf(parityStr.join(''));
-    if (first < 0) return null;
-
-    const text = String(first) + digits.join('');
-    if (Number(text[12]) !== ean13CheckDigit(text.slice(0, 12))) return null;
-
-    // A leading zero means this was printed as UPC-A.
-    const result = first === 0
-      ? { format: 'upca', text: text.slice(1) }
-      : { format: 'ean13', text };
-    return attachEANAddon(result, row, trailing.end);
-  }
-
-  return null;
+    // EAN-8 has no even-parity digits and a middle guard at a different offset;
+    // try the 13-digit reading first, then fall back.
+    const middle = matchAt(row, offset, MIDDLE_PATTERN);
+    if (middle) {
+        offset = middle.end;
+        for (let i = 0; i < 6; i++) {
+            const d = decodeEANDigit(row, offset, true);
+            if (!d)
+                return null;
+            digits.push(d.digit);
+            offset = d.end;
+        }
+        const trailing = matchAt(row, offset, START_END_PATTERN);
+        if (!trailing)
+            return null;
+        const parityStr = [];
+        for (let i = 0; i < 6; i++)
+            parityStr.push((parityBits >> (5 - i)) & 1 ? 'G' : 'L');
+        const first = EAN13_PARITY.indexOf(parityStr.join(''));
+        if (first < 0)
+            return null;
+        const text = String(first) + digits.join('');
+        if (Number(text[12]) !== ean13CheckDigit(text.slice(0, 12)))
+            return null;
+        // A leading zero means this was printed as UPC-A.
+        const result = first === 0
+            ? { format: 'upca', text: text.slice(1) }
+            : { format: 'ean13', text };
+        return attachEANAddon(result, row, trailing.end);
+    }
+    return null;
 }
-
 /**
  * EAN-8: four left digits, middle guard, four right digits.
  *
@@ -358,36 +330,37 @@ function decodeEANFamily(row) {
  * @returns {{format: string, text: string} | null}
  */
 function decodeEAN8(row) {
-  const guard = findGuard(row, 0, START_END_PATTERN, false);
-  if (!guard) return null;
-
-  let offset = guard.end;
-  const digits = [];
-  for (let i = 0; i < 4; i++) {
-    const d = decodeEANDigit(row, offset, false);
-    if (!d || d.even) return null; // EAN-8 left digits are all odd parity
-    digits.push(d.digit);
-    offset = d.end;
-  }
-
-  const middle = matchAt(row, offset, MIDDLE_PATTERN);
-  if (!middle) return null;
-  offset = middle.end;
-
-  for (let i = 0; i < 4; i++) {
-    const d = decodeEANDigit(row, offset, true);
-    if (!d) return null;
-    digits.push(d.digit);
-    offset = d.end;
-  }
-  const trailing = matchAt(row, offset, START_END_PATTERN);
-  if (!trailing) return null;
-
-  const text = digits.join('');
-  if (Number(text[7]) !== ean13CheckDigit(text.slice(0, 7))) return null;
-  return attachEANAddon({ format: 'ean8', text }, row, trailing.end);
+    const guard = findGuard(row, 0, START_END_PATTERN, false);
+    if (!guard)
+        return null;
+    let offset = guard.end;
+    const digits = [];
+    for (let i = 0; i < 4; i++) {
+        const d = decodeEANDigit(row, offset, false);
+        if (!d || d.even)
+            return null; // EAN-8 left digits are all odd parity
+        digits.push(d.digit);
+        offset = d.end;
+    }
+    const middle = matchAt(row, offset, MIDDLE_PATTERN);
+    if (!middle)
+        return null;
+    offset = middle.end;
+    for (let i = 0; i < 4; i++) {
+        const d = decodeEANDigit(row, offset, true);
+        if (!d)
+            return null;
+        digits.push(d.digit);
+        offset = d.end;
+    }
+    const trailing = matchAt(row, offset, START_END_PATTERN);
+    if (!trailing)
+        return null;
+    const text = digits.join('');
+    if (Number(text[7]) !== ean13CheckDigit(text.slice(0, 7)))
+        return null;
+    return attachEANAddon({ format: 'ean8', text }, row, trailing.end);
 }
-
 /**
  * UPC-E: six digits, parity-encoded, terminated by a six-element guard.
  *
@@ -395,48 +368,48 @@ function decodeEAN8(row) {
  * @returns {{format: string, text: string} | null}
  */
 function decodeUPCE(row) {
-  const guard = findGuard(row, 0, START_END_PATTERN, false);
-  if (!guard) return null;
-
-  let offset = guard.end;
-  const digits = [];
-  let parityBits = 0;
-  for (let i = 0; i < 6; i++) {
-    const d = decodeEANDigit(row, offset, false);
-    if (!d) return null;
-    digits.push(d.digit);
-    if (d.even) parityBits |= 1 << (5 - i);
-    offset = d.end;
-  }
-
-  // Six digits and then the end guard, in that order and nothing between. The
-  // EAN readers above match their trailing guard; this one used to stop at the
-  // last digit, which let it report a symbol it had never seen the end of.
-  const trailing = matchAt(row, offset, UPCE_END_PATTERN);
-  if (!trailing) return null;
-
-  const parityStr = [];
-  for (let i = 0; i < 6; i++) parityStr.push((parityBits >> (5 - i)) & 1 ? 'E' : 'O');
-  const check = UPCE_PARITY.indexOf(parityStr.join(''));
-  if (check < 0) return null;
-
-  // The parity pattern carries the check digit and nothing else, so on its own
-  // it says nothing about the six digits it was read alongside: any run whose
-  // parities happen to spell one of the ten patterns would be accepted. What
-  // ties the two together is the check digit itself — expand the body to the
-  // UPC-A it stands for and confirm the digits produce the check digit the
-  // parity claimed. Six digits scraped out of a neighbouring symbol pass the
-  // parity test one time in ten and this one almost never.
-  const body = digits.join('');
-  if (ean13CheckDigit(upceToUpcaBody(0, body)) !== check) return null;
-
-  return attachEANAddon({ format: 'upce', text: '0' + body + String(check) }, row, trailing.end);
+    const guard = findGuard(row, 0, START_END_PATTERN, false);
+    if (!guard)
+        return null;
+    let offset = guard.end;
+    const digits = [];
+    let parityBits = 0;
+    for (let i = 0; i < 6; i++) {
+        const d = decodeEANDigit(row, offset, false);
+        if (!d)
+            return null;
+        digits.push(d.digit);
+        if (d.even)
+            parityBits |= 1 << (5 - i);
+        offset = d.end;
+    }
+    // Six digits and then the end guard, in that order and nothing between. The
+    // EAN readers above match their trailing guard; this one used to stop at the
+    // last digit, which let it report a symbol it had never seen the end of.
+    const trailing = matchAt(row, offset, UPCE_END_PATTERN);
+    if (!trailing)
+        return null;
+    const parityStr = [];
+    for (let i = 0; i < 6; i++)
+        parityStr.push((parityBits >> (5 - i)) & 1 ? 'E' : 'O');
+    const check = UPCE_PARITY.indexOf(parityStr.join(''));
+    if (check < 0)
+        return null;
+    // The parity pattern carries the check digit and nothing else, so on its own
+    // it says nothing about the six digits it was read alongside: any run whose
+    // parities happen to spell one of the ten patterns would be accepted. What
+    // ties the two together is the check digit itself — expand the body to the
+    // UPC-A it stands for and confirm the digits produce the check digit the
+    // parity claimed. Six digits scraped out of a neighbouring symbol pass the
+    // parity test one time in ten and this one almost never.
+    const body = digits.join('');
+    if (ean13CheckDigit(upceToUpcaBody(0, body)) !== check)
+        return null;
+    return attachEANAddon({ format: 'upce', text: '0' + body + String(check) }, row, trailing.end);
 }
-
 /* ------------------------------------------------------------------ *
  * Guard finding
  * ------------------------------------------------------------------ */
-
 /**
  * Scan forward for the first place a pattern matches, starting on a dark run.
  *
@@ -447,43 +420,43 @@ function decodeUPCE(row) {
  * @returns {{start: number, end: number} | null}
  */
 function findGuard(row, from, pattern, startsLight) {
-  const counters = new Array(pattern.length).fill(0);
-  const width = row.length;
-  let index = 0;
-  let isDark = !startsLight;
-  let i = from;
-
-  // Skip any leading run of the wrong colour.
-  while (i < width && (row[i] === 1) !== isDark) i++;
-
-  let patternStart = i;
-  counters.fill(0);
-
-  while (i < width) {
-    if ((row[i] === 1) === isDark) {
-      counters[index]++;
-    } else {
-      if (index === pattern.length - 1) {
-        if (patternVariance(counters, pattern, 0.7) < 0.5) {
-          return { start: patternStart, end: i };
+    const counters = new Array(pattern.length).fill(0);
+    const width = row.length;
+    let index = 0;
+    let isDark = !startsLight;
+    let i = from;
+    // Skip any leading run of the wrong colour.
+    while (i < width && (row[i] === 1) !== isDark)
+        i++;
+    let patternStart = i;
+    counters.fill(0);
+    while (i < width) {
+        if ((row[i] === 1) === isDark) {
+            counters[index]++;
         }
-        // Slide the window forward by two runs and keep looking.
-        patternStart += counters[0] + counters[1];
-        for (let k = 2; k < pattern.length; k++) counters[k - 2] = counters[k];
-        counters[pattern.length - 2] = 0;
-        counters[pattern.length - 1] = 0;
-        index--;
-      } else {
-        index++;
-      }
-      counters[index] = 1;
-      isDark = !isDark;
+        else {
+            if (index === pattern.length - 1) {
+                if (patternVariance(counters, pattern, 0.7) < 0.5) {
+                    return { start: patternStart, end: i };
+                }
+                // Slide the window forward by two runs and keep looking.
+                patternStart += counters[0] + counters[1];
+                for (let k = 2; k < pattern.length; k++)
+                    counters[k - 2] = counters[k];
+                counters[pattern.length - 2] = 0;
+                counters[pattern.length - 1] = 0;
+                index--;
+            }
+            else {
+                index++;
+            }
+            counters[index] = 1;
+            isDark = !isDark;
+        }
+        i++;
     }
-    i++;
-  }
-  return null;
+    return null;
 }
-
 /**
  * Match a pattern at an exact position.
  *
@@ -493,18 +466,19 @@ function findGuard(row, from, pattern, startsLight) {
  * @returns {{end: number} | null}
  */
 function matchAt(row, start, pattern) {
-  const counters = new Array(pattern.length).fill(0);
-  if (!recordPattern(row, start, counters)) return null;
-  if (patternVariance(counters, pattern, 0.7) >= 0.5) return null;
-  let width = 0;
-  for (const c of counters) width += c;
-  return { end: start + width };
+    const counters = new Array(pattern.length).fill(0);
+    if (!recordPattern(row, start, counters))
+        return null;
+    if (patternVariance(counters, pattern, 0.7) >= 0.5)
+        return null;
+    let width = 0;
+    for (const c of counters)
+        width += c;
+    return { end: start + width };
 }
-
 /* ------------------------------------------------------------------ *
  * EAN supplements
  * ------------------------------------------------------------------ */
-
 /**
  * Decode a supplement immediately following a validated EAN/UPC symbol.
  * The caller supplies the end of the parent trailing guard, so a supplement
@@ -516,37 +490,36 @@ function matchAt(row, start, pattern) {
  * @returns {{format:'ean2'|'ean5', text:string, parity:string, checksum?:number, end:number}|null}
  */
 function decodeEANSupplementRow(row, baseEnd, digitCount) {
-  const guard = findGuard(row, baseEnd, [1, 1, 2], false);
-  if (!guard || guard.start - baseEnd < 4) return null;
-
-  let offset = guard.end;
-  let text = '';
-  let parity = '';
-
-  for (let i = 0; i < digitCount; i++) {
-    const digit = decodeEANDigit(row, offset, false);
-    if (!digit) return null;
-    text += String(digit.digit);
-    parity += digit.even ? 'B' : 'A';
-    offset = digit.end;
-
-    if (i + 1 < digitCount) {
-      const separator = matchAt(row, offset, [1, 1]);
-      if (!separator) return null;
-      offset = separator.end;
+    const guard = findGuard(row, baseEnd, [1, 1, 2], false);
+    if (!guard || guard.start - baseEnd < 4)
+        return null;
+    let offset = guard.end;
+    let text = '';
+    let parity = '';
+    for (let i = 0; i < digitCount; i++) {
+        const digit = decodeEANDigit(row, offset, false);
+        if (!digit)
+            return null;
+        text += String(digit.digit);
+        parity += digit.even ? 'B' : 'A';
+        offset = digit.end;
+        if (i + 1 < digitCount) {
+            const separator = matchAt(row, offset, [1, 1]);
+            if (!separator)
+                return null;
+            offset = separator.end;
+        }
+    }
+    if (digitCount === 2) {
+        if (EAN2_PARITY[Number(text) % 4] !== parity)
+            return null;
+        return { format: 'ean2', text, parity, end: offset };
     }
-  }
-
-  if (digitCount === 2) {
-    if (EAN2_PARITY[Number(text) % 4] !== parity) return null;
-    return { format: 'ean2', text, parity, end: offset };
-  }
-
-  const checksum = ean5Checksum(text);
-  if (EAN5_PARITY[checksum] !== parity) return null;
-  return { format: 'ean5', text, parity, checksum, end: offset };
+    const checksum = ean5Checksum(text);
+    if (EAN5_PARITY[checksum] !== parity)
+        return null;
+    return { format: 'ean5', text, parity, checksum, end: offset };
 }
-
 /**
  * Attach the longest valid supplement to a base result. EAN-5 is attempted
  * first so its prefix cannot be reported as a shorter EAN-2 symbol.
@@ -557,23 +530,21 @@ function decodeEANSupplementRow(row, baseEnd, digitCount) {
  * @returns {object}
  */
 function attachEANAddon(base, row, baseEnd) {
-  const addon = decodeEANSupplementRow(row, baseEnd, 5)
-    ?? decodeEANSupplementRow(row, baseEnd, 2);
-  if (!addon) return base;
-  const { end, ...publicAddon } = addon;
-  void end;
-  return { ...base, addon: publicAddon };
+    const addon = decodeEANSupplementRow(row, baseEnd, 5)
+        ?? decodeEANSupplementRow(row, baseEnd, 2);
+    if (!addon)
+        return base;
+    const { end, ...publicAddon } = addon;
+    void end;
+    return { ...base, addon: publicAddon };
 }
-
 /* ------------------------------------------------------------------ *
  * Code 11 and MSI/Plessey
  * ------------------------------------------------------------------ */
-
 /** @param {number[]} counters @returns {number} */
 function counterTotal(counters) {
-  return counters.reduce((sum, value) => sum + value, 0);
+    return counters.reduce((sum, value) => sum + value, 0);
 }
-
 /**
  * Apply the Code 11 C/K checksum grammar used by the writer.
  *
@@ -582,42 +553,43 @@ function counterTotal(counters) {
  * @returns {string|null}
  */
 function finalizeCode11(encoded, requested) {
-  const weighted = (text, maxWeight) => {
-    let sum = 0;
-    for (let i = 0; i < text.length; i++) {
-      const weight = ((text.length - 1 - i) % maxWeight) + 1;
-      sum += weight * CODE11_CHARSET.indexOf(text[i]);
+    const weighted = (text, maxWeight) => {
+        let sum = 0;
+        for (let i = 0; i < text.length; i++) {
+            const weight = ((text.length - 1 - i) % maxWeight) + 1;
+            sum += weight * CODE11_CHARSET.indexOf(text[i]);
+        }
+        return sum;
+    };
+    const validC = (text) => {
+        if (text.length < 2)
+            return null;
+        const body = text.slice(0, -1);
+        const expected = CODE11_CHARSET[weighted(body, 10) % 11];
+        return text[text.length - 1] === expected ? body : null;
+    };
+    const validCK = (text) => {
+        if (text.length < 12)
+            return null;
+        const body = text.slice(0, -2);
+        const c = text[text.length - 2];
+        const k = text[text.length - 1];
+        const expectedC = CODE11_CHARSET[weighted(body, 10) % 11];
+        if (c !== expectedC)
+            return null;
+        const expectedK = CODE11_CHARSET[weighted(body + c, 9) % 11];
+        return k === expectedK ? body : null;
+    };
+    if (requested === false)
+        return encoded;
+    if (requested === true) {
+        const checked = encoded.length >= 12 ? validCK(encoded) : validC(encoded);
+        return checked;
     }
-    return sum;
-  };
-  const validC = (text) => {
-    if (text.length < 2) return null;
-    const body = text.slice(0, -1);
-    const expected = CODE11_CHARSET[weighted(body, 10) % 11];
-    return text[text.length - 1] === expected ? body : null;
-  };
-  const validCK = (text) => {
-    if (text.length < 12) return null;
-    const body = text.slice(0, -2);
-    const c = text[text.length - 2];
-    const k = text[text.length - 1];
-    const expectedC = CODE11_CHARSET[weighted(body, 10) % 11];
-    if (c !== expectedC) return null;
-    const expectedK = CODE11_CHARSET[weighted(body + c, 9) % 11];
-    return k === expectedK ? body : null;
-  };
-
-  if (requested === false) return encoded;
-  if (requested === true) {
-    const checked = encoded.length >= 12 ? validCK(encoded) : validC(encoded);
-    return checked;
-  }
-
-  // With no explicit option, strip checks only when the complete grammar is
-  // unambiguous; otherwise preserve the literal payload.
-  return validCK(encoded) ?? validC(encoded) ?? encoded;
+    // With no explicit option, strip checks only when the complete grammar is
+    // unambiguous; otherwise preserve the literal payload.
+    return validCK(encoded) ?? validC(encoded) ?? encoded;
 }
-
 /**
  * Decode Code 11 from one binarized scanline.
  *
@@ -627,72 +599,83 @@ function finalizeCode11(encoded, requested) {
  * @returns {{format:'code11', text:string}|null}
  */
 export function decodeCode11(row, options = {}) {
-  const counters = new Array(5).fill(0);
-  let start = null;
-  for (let i = 0; i < row.length; i++) {
-    if (row[i] !== 1 || (i > 0 && row[i - 1] === 1)) continue;
-    if (!recordPattern(row, i, counters)) continue;
-    if (toNarrowWidePattern(counters, 2) === CODE11_START_BITS) {
-      start = { position: i, end: i + counterTotal(counters), scale: counterTotal(counters) / 9 };
-      break;
+    const counters = new Array(5).fill(0);
+    let start = null;
+    for (let i = 0; i < row.length; i++) {
+        if (row[i] !== 1 || (i > 0 && row[i - 1] === 1))
+            continue;
+        if (!recordPattern(row, i, counters))
+            continue;
+        if (toNarrowWidePattern(counters, 2) === CODE11_START_BITS) {
+            start = { position: i, end: i + counterTotal(counters), scale: counterTotal(counters) / 9 };
+            break;
+        }
     }
-  }
-  if (!start) return null;
-
-  let offset = start.end;
-  while (offset < row.length && row[offset] === 0) offset++;
-  let encoded = '';
-
-  for (let count = 0; count < 160 && offset < row.length; count++) {
-    if (!recordPattern(row, offset, counters)) return null;
-    const width = counterTotal(counters);
-    const stop = toNarrowWidePattern(counters, 2);
-    if (stop === CODE11_START_BITS) {
-      if (encoded.length === 0) return null;
-      const stopEnd = offset + width;
-      let nextDark = stopEnd;
-      while (nextDark < row.length && row[nextDark] === 0) nextDark++;
-      if (nextDark !== row.length && nextDark - stopEnd < Math.max(3, Math.ceil(start.scale * 3))) {
+    if (!start)
         return null;
-      }
-      const text = finalizeCode11(encoded, options.checkDigit);
-      return text == null ? null : { format: 'code11', text };
-    }
-
-    let character = null;
-    for (const expectedWide of [1, 2]) {
-      const bits = toNarrowWidePattern(counters, expectedWide);
-      if (bits < 0) continue;
-      const candidate = CODE11_BITS[`${bits}:${expectedWide}`];
-      if (candidate !== undefined) {
-        character = candidate;
-        break;
-      }
+    let offset = start.end;
+    while (offset < row.length && row[offset] === 0)
+        offset++;
+    let encoded = '';
+    for (let count = 0; count < 160 && offset < row.length; count++) {
+        if (!recordPattern(row, offset, counters))
+            return null;
+        const width = counterTotal(counters);
+        const stop = toNarrowWidePattern(counters, 2);
+        if (stop === CODE11_START_BITS) {
+            if (encoded.length === 0)
+                return null;
+            const stopEnd = offset + width;
+            let nextDark = stopEnd;
+            while (nextDark < row.length && row[nextDark] === 0)
+                nextDark++;
+            if (nextDark !== row.length && nextDark - stopEnd < Math.max(3, Math.ceil(start.scale * 3))) {
+                return null;
+            }
+            const text = finalizeCode11(encoded, options.checkDigit);
+            return text == null ? null : { format: 'code11', text };
+        }
+        let character = null;
+        for (const expectedWide of [1, 2]) {
+            const bits = toNarrowWidePattern(counters, expectedWide);
+            if (bits < 0)
+                continue;
+            const candidate = CODE11_BITS[`${bits}:${expectedWide}`];
+            if (candidate !== undefined) {
+                character = candidate;
+                break;
+            }
+        }
+        if (character == null)
+            return null;
+        encoded += character;
+        if (encoded.length > 128)
+            return null;
+        offset += width;
+        while (offset < row.length && row[offset] === 0)
+            offset++;
     }
-    if (character == null) return null;
-    encoded += character;
-    if (encoded.length > 128) return null;
-    offset += width;
-    while (offset < row.length && row[offset] === 0) offset++;
-  }
-  return null;
+    return null;
 }
-
 /** @param {string} encoded @param {boolean|undefined} requested */
 function finalizeMSI(encoded, requested) {
-  if (requested !== true) return encoded;
-  if (encoded.length < 2) return null;
-  const body = encoded.slice(0, -1);
-  let odd = '';
-  for (let i = body.length - 1; i >= 0; i -= 2) odd = body[i] + odd;
-  const doubled = String(Number(odd) * 2);
-  let sum = 0;
-  for (const ch of doubled) sum += Number(ch);
-  for (let i = body.length - 2; i >= 0; i -= 2) sum += Number(body[i]);
-  const expected = String((10 - (sum % 10)) % 10);
-  return encoded.endsWith(expected) ? body : null;
+    if (requested !== true)
+        return encoded;
+    if (encoded.length < 2)
+        return null;
+    const body = encoded.slice(0, -1);
+    let odd = '';
+    for (let i = body.length - 1; i >= 0; i -= 2)
+        odd = body[i] + odd;
+    const doubled = String(Number(odd) * 2);
+    let sum = 0;
+    for (const ch of doubled)
+        sum += Number(ch);
+    for (let i = body.length - 2; i >= 0; i -= 2)
+        sum += Number(body[i]);
+    const expected = String((10 - (sum % 10)) % 10);
+    return encoded.endsWith(expected) ? body : null;
 }
-
 /**
  * Decode MSI/Plessey from one binarized scanline.
  *
@@ -702,453 +685,480 @@ function finalizeMSI(encoded, requested) {
  * @returns {{format:'msi', text:string}|null}
  */
 export function decodeMSI(row, options = {}) {
-  const start = findGuard(row, 0, [2, 1], false);
-  if (!start) return null;
-  const scale = (start.end - start.start) / 3;
-  if (!(scale >= 1)) return null;
-
-  let offset = start.end;
-  let encoded = '';
-  const bitPatterns = [
-    { pattern: [1, 2], bit: '0' },
-    { pattern: [2, 1], bit: '1' },
-  ];
-
-  for (let digitIndex = 0; digitIndex < 80; digitIndex++) {
-    const stop = matchAt(row, offset, [1, 2, 1]);
-    if (stop && encoded.length > 0) {
-      let nextDark = stop.end;
-      while (nextDark < row.length && row[nextDark] === 0) nextDark++;
-      if (nextDark === row.length ||
-          nextDark - stop.end >= Math.max(3, Math.ceil(scale * 3))) {
-        if (encoded.length < 6 && !(options.formats && options.formats.includes('msi'))) {
-          return null;
+    const start = findGuard(row, 0, [2, 1], false);
+    if (!start)
+        return null;
+    const scale = (start.end - start.start) / 3;
+    if (!(scale >= 1))
+        return null;
+    let offset = start.end;
+    let encoded = '';
+    const bitPatterns = [
+        { pattern: [1, 2], bit: '0' },
+        { pattern: [2, 1], bit: '1' },
+    ];
+    for (let digitIndex = 0; digitIndex < 80; digitIndex++) {
+        const stop = matchAt(row, offset, [1, 2, 1]);
+        if (stop && encoded.length > 0) {
+            let nextDark = stop.end;
+            while (nextDark < row.length && row[nextDark] === 0)
+                nextDark++;
+            if (nextDark === row.length ||
+                nextDark - stop.end >= Math.max(3, Math.ceil(scale * 3))) {
+                if (encoded.length < 6 && !(options.formats && options.formats.includes('msi'))) {
+                    return null;
+                }
+                const text = finalizeMSI(encoded, options.checkDigit);
+                return text == null ? null : { format: 'msi', text };
+            }
         }
-        const text = finalizeMSI(encoded, options.checkDigit);
-        return text == null ? null : { format: 'msi', text };
-      }
-    }
-
-    let nibble = '';
-    for (let bitIndex = 0; bitIndex < 4; bitIndex++) {
-      let matched = null;
-      for (const candidate of bitPatterns) {
-        const found = matchAt(row, offset, candidate.pattern);
-        if (found) {
-          matched = { ...candidate, end: found.end };
-          break;
+        let nibble = '';
+        for (let bitIndex = 0; bitIndex < 4; bitIndex++) {
+            let matched = null;
+            for (const candidate of bitPatterns) {
+                const found = matchAt(row, offset, candidate.pattern);
+                if (found) {
+                    matched = { ...candidate, end: found.end };
+                    break;
+                }
+            }
+            if (!matched)
+                return null;
+            nibble += matched.bit;
+            offset = matched.end;
         }
-      }
-      if (!matched) return null;
-      nibble += matched.bit;
-      offset = matched.end;
+        const digit = Number.parseInt(nibble, 2);
+        if (digit > 9)
+            return null;
+        encoded += String(digit);
     }
-
-    const digit = Number.parseInt(nibble, 2);
-    if (digit > 9) return null;
-    encoded += String(digit);
-  }
-  return null;
+    return null;
 }
-
 /* ------------------------------------------------------------------ *
  * Code 128
  * ------------------------------------------------------------------ */
-
 /**
  * @param {Uint8Array} row
  * @returns {{format: string, text: string} | null}
  */
 function decodeCode128(row) {
-  // Locate whichever start symbol appears first.
-  let start = null;
-  for (const startCode of [CODE128_START_A, CODE128_START_B, CODE128_START_C]) {
-    const found = findGuard(row, 0, CODE128_RUNS[startCode], false);
-    if (found && (!start || found.start < start.found.start)) {
-      start = { code: startCode, found };
-    }
-  }
-  if (!start) return null;
-
-  // Read every symbol up to the stop pattern first, and only then interpret
-  // them. The symbol immediately before the stop is the checksum, and it is
-  // indistinguishable from data while scanning — interpreting as we go would
-  // append it to the text (a Code C checksum of 70 arrives as the digits
-  // "70"). Collecting first makes dropping it exact rather than a guess.
-  const values = [];
-  let offset = start.found.end;
-  const counters = new Array(6).fill(0);
-  const stopCounters = new Array(7).fill(0);
-
-  for (;;) {
-    // The stop pattern has seven elements, so it must be tried before the
-    // six-element symbol set or its first six would match something.
-    if (recordPattern(row, offset, stopCounters) &&
-        patternVariance(stopCounters, CODE128_RUNS[CODE128_STOP], 0.7) < 0.38) {
-      break;
+    // Locate whichever start symbol appears first.
+    let start = null;
+    for (const startCode of [CODE128_START_A, CODE128_START_B, CODE128_START_C]) {
+        const found = findGuard(row, 0, CODE128_RUNS[startCode], false);
+        if (found && (!start || found.start < start.found.start)) {
+            start = { code: startCode, found };
+        }
     }
-
-    if (!recordPattern(row, offset, counters)) return null;
-
-    let best = -1;
-    let bestVariance = 0.4;
-    for (let c = 0; c < CODE128_RUNS.length - 1; c++) {
-      const v = patternVariance(counters, CODE128_RUNS[c], 0.7);
-      if (v < bestVariance) { bestVariance = v; best = c; }
+    if (!start)
+        return null;
+    // Read every symbol up to the stop pattern first, and only then interpret
+    // them. The symbol immediately before the stop is the checksum, and it is
+    // indistinguishable from data while scanning — interpreting as we go would
+    // append it to the text (a Code C checksum of 70 arrives as the digits
+    // "70"). Collecting first makes dropping it exact rather than a guess.
+    const values = [];
+    let offset = start.found.end;
+    const counters = new Array(6).fill(0);
+    const stopCounters = new Array(7).fill(0);
+    for (;;) {
+        // The stop pattern has seven elements, so it must be tried before the
+        // six-element symbol set or its first six would match something.
+        if (recordPattern(row, offset, stopCounters) &&
+            patternVariance(stopCounters, CODE128_RUNS[CODE128_STOP], 0.7) < 0.38) {
+            break;
+        }
+        if (!recordPattern(row, offset, counters))
+            return null;
+        let best = -1;
+        let bestVariance = 0.4;
+        for (let c = 0; c < CODE128_RUNS.length - 1; c++) {
+            const v = patternVariance(counters, CODE128_RUNS[c], 0.7);
+            if (v < bestVariance) {
+                bestVariance = v;
+                best = c;
+            }
+        }
+        if (best < 0)
+            return null;
+        let width = 0;
+        for (const c of counters)
+            width += c;
+        offset += width;
+        values.push(best);
+        if (values.length > 256)
+            return null; // runaway scan
     }
-    if (best < 0) return null;
-
-    let width = 0;
-    for (const c of counters) width += c;
-    offset += width;
-    values.push(best);
-
-    if (values.length > 256) return null; // runaway scan
-  }
-
-  // Start symbol, data, checksum, stop. Anything shorter is not a symbol.
-  if (values.length < 2) return null;
-
-  const checksum = values[values.length - 1];
-  const dataValues = values.slice(0, -1);
-
-  // Verify the checksum rather than trusting the scan. Without this a run of
-  // noise that happens to match valid patterns decodes to plausible garbage,
-  // which is far worse than reporting nothing.
-  let sum = start.code;
-  for (let i = 0; i < dataValues.length; i++) sum += dataValues[i] * (i + 1);
-  if (sum % 103 !== checksum) return null;
-
-  let mode = start.code === CODE128_START_A ? 'A'
-    : start.code === CODE128_START_B ? 'B' : 'C';
-  let shifted = null;
-  let text = '';
-  const fnc1AtStart = dataValues[0] === CODE128_FNC1;
-  const fnc1Positions = [];
-
-  for (let dataIndex = 0; dataIndex < dataValues.length; dataIndex++) {
-    const value = dataValues[dataIndex];
-    const active = shifted || mode;
-    shifted = null;
-
-    if (value === CODE128_CODE_A && mode !== 'A') { mode = 'A'; continue; }
-    if (value === CODE128_CODE_B && mode !== 'B') { mode = 'B'; continue; }
-    if (value === CODE128_CODE_C) { mode = 'C'; continue; }
-    if (value === CODE128_SHIFT) { shifted = mode === 'A' ? 'B' : 'A'; continue; }
-    if (value === CODE128_FNC1) {
-      if (dataIndex > 0) {
-        fnc1Positions.push(text.length);
-        text += '\x1d';
-      }
-      continue;
+    // Start symbol, data, checksum, stop. Anything shorter is not a symbol.
+    if (values.length < 2)
+        return null;
+    const checksum = values[values.length - 1];
+    const dataValues = values.slice(0, -1);
+    // Verify the checksum rather than trusting the scan. Without this a run of
+    // noise that happens to match valid patterns decodes to plausible garbage,
+    // which is far worse than reporting nothing.
+    let sum = start.code;
+    for (let i = 0; i < dataValues.length; i++)
+        sum += dataValues[i] * (i + 1);
+    if (sum % 103 !== checksum)
+        return null;
+    let mode = start.code === CODE128_START_A ? 'A'
+        : start.code === CODE128_START_B ? 'B' : 'C';
+    let shifted = null;
+    let text = '';
+    const fnc1AtStart = dataValues[0] === CODE128_FNC1;
+    const fnc1Positions = [];
+    for (let dataIndex = 0; dataIndex < dataValues.length; dataIndex++) {
+        const value = dataValues[dataIndex];
+        const active = shifted || mode;
+        shifted = null;
+        if (value === CODE128_CODE_A && mode !== 'A') {
+            mode = 'A';
+            continue;
+        }
+        if (value === CODE128_CODE_B && mode !== 'B') {
+            mode = 'B';
+            continue;
+        }
+        if (value === CODE128_CODE_C) {
+            mode = 'C';
+            continue;
+        }
+        if (value === CODE128_SHIFT) {
+            shifted = mode === 'A' ? 'B' : 'A';
+            continue;
+        }
+        if (value === CODE128_FNC1) {
+            if (dataIndex > 0) {
+                fnc1Positions.push(text.length);
+                text += '\x1d';
+            }
+            continue;
+        }
+        if (value >= 96 && value <= 102) {
+            continue;
+        } // other function characters
+        if (active === 'C') {
+            text += String(value).padStart(2, '0');
+        }
+        else if (active === 'A') {
+            text += value < 64 ? String.fromCharCode(value + 32) : String.fromCharCode(value - 64);
+        }
+        else {
+            text += String.fromCharCode(value + 32);
+        }
     }
-    if (value >= 96 && value <= 102) { continue; } // other function characters
-
-    if (active === 'C') {
-      text += String(value).padStart(2, '0');
-    } else if (active === 'A') {
-      text += value < 64 ? String.fromCharCode(value + 32) : String.fromCharCode(value - 64);
-    } else {
-      text += String.fromCharCode(value + 32);
+    if (text.length === 0)
+        return null;
+    if (fnc1AtStart) {
+        return {
+            format: 'gs1128',
+            text,
+            gs1: true,
+            symbologyIdentifier: ']C1',
+            fnc1AtStart: true,
+            fnc1Positions,
+        };
     }
-  }
-
-  if (text.length === 0) return null;
-  if (fnc1AtStart) {
-    return {
-      format: 'gs1128',
-      text,
-      gs1: true,
-      symbologyIdentifier: ']C1',
-      fnc1AtStart: true,
-      fnc1Positions,
-    };
-  }
-  return { format: 'code128', text };
+    return { format: 'code128', text };
 }
-
 /* ------------------------------------------------------------------ *
  * Code 39
  * ------------------------------------------------------------------ */
-
 /**
  * @param {Uint8Array} row
  * @param {object} options
  * @returns {{format: string, text: string} | null}
  */
 function decodeCode39(row, options = {}) {
-  const counters = new Array(9).fill(0);
-  let offset = 0;
-
-  // Find the '*' start character.
-  const startBits = nwToBits(CODE39['*']);
-  let found = false;
-  while (offset < row.length) {
-    while (offset < row.length && row[offset] !== 1) offset++;
-    if (offset >= row.length) break;
-    if (recordPattern(row, offset, counters)) {
-      if (toNarrowWidePattern(counters, 3) === startBits) { found = true; break; }
+    const counters = new Array(9).fill(0);
+    let offset = 0;
+    // Find the '*' start character.
+    const startBits = nwToBits(CODE39['*']);
+    let found = false;
+    while (offset < row.length) {
+        while (offset < row.length && row[offset] !== 1)
+            offset++;
+        if (offset >= row.length)
+            break;
+        if (recordPattern(row, offset, counters)) {
+            if (toNarrowWidePattern(counters, 3) === startBits) {
+                found = true;
+                break;
+            }
+        }
+        // Advance past this dark run and the following light run.
+        while (offset < row.length && row[offset] === 1)
+            offset++;
+        while (offset < row.length && row[offset] === 0)
+            offset++;
     }
-    // Advance past this dark run and the following light run.
-    while (offset < row.length && row[offset] === 1) offset++;
-    while (offset < row.length && row[offset] === 0) offset++;
-  }
-  if (!found) return null;
-
-  let width = 0;
-  for (const c of counters) width += c;
-  offset += width;
-
-  let text = '';
-  for (;;) {
-    // Skip the inter-character gap.
-    while (offset < row.length && row[offset] === 0) offset++;
-    if (offset >= row.length) return null;
-    if (!recordPattern(row, offset, counters)) return null;
-
-    const bits = toNarrowWidePattern(counters, 3);
-    const ch = CODE39_BITS[bits];
-    if (ch === undefined) return null;
-
-    let w = 0;
-    for (const c of counters) w += c;
-    offset += w;
-
-    if (ch === '*') break;
-    text += ch;
-    if (text.length > 80) return null;
-  }
-
-  if (text.length === 0) return null;
-
-  if (options.checkDigit) {
-    const expected = text[text.length - 1];
-    const body = text.slice(0, -1);
-    let sum = 0;
-    for (const ch of body) sum += CODE39_CHECK_SET.indexOf(ch);
-    if (CODE39_CHECK_SET[sum % 43] !== expected) return null;
-    text = body;
-  }
-
-  return { format: 'code39', text };
+    if (!found)
+        return null;
+    let width = 0;
+    for (const c of counters)
+        width += c;
+    offset += width;
+    let text = '';
+    for (;;) {
+        // Skip the inter-character gap.
+        while (offset < row.length && row[offset] === 0)
+            offset++;
+        if (offset >= row.length)
+            return null;
+        if (!recordPattern(row, offset, counters))
+            return null;
+        const bits = toNarrowWidePattern(counters, 3);
+        const ch = CODE39_BITS[bits];
+        if (ch === undefined)
+            return null;
+        let w = 0;
+        for (const c of counters)
+            w += c;
+        offset += w;
+        if (ch === '*')
+            break;
+        text += ch;
+        if (text.length > 80)
+            return null;
+    }
+    if (text.length === 0)
+        return null;
+    if (options.checkDigit) {
+        const expected = text[text.length - 1];
+        const body = text.slice(0, -1);
+        let sum = 0;
+        for (const ch of body)
+            sum += CODE39_CHECK_SET.indexOf(ch);
+        if (CODE39_CHECK_SET[sum % 43] !== expected)
+            return null;
+        text = body;
+    }
+    return { format: 'code39', text };
 }
-
 /* ------------------------------------------------------------------ *
  * Code 93
  * ------------------------------------------------------------------ */
-
 /**
  * @param {Uint8Array} row
  * @returns {{format: string, text: string} | null}
  */
 function decodeCode93(row) {
-  const startRuns = widthsToArray('111141');
-  const start = findGuard(row, 0, startRuns, false);
-  if (!start) return null;
-
-  let offset = start.end;
-  const counters = new Array(6).fill(0);
-  const values = [];
-
-  for (;;) {
-    if (!recordPattern(row, offset, counters)) return null;
-
-    let best = -1;
-    let bestVariance = 0.38;
-    for (let v = 0; v < CODE93_VALUES.length; v++) {
-      const runs = CODE93_RUNS[CODE93_VALUES[v]];
-      const variance = patternVariance(counters, runs, 0.7);
-      if (variance < bestVariance) { bestVariance = variance; best = v; }
+    const startRuns = widthsToArray('111141');
+    const start = findGuard(row, 0, startRuns, false);
+    if (!start)
+        return null;
+    let offset = start.end;
+    const counters = new Array(6).fill(0);
+    const values = [];
+    for (;;) {
+        if (!recordPattern(row, offset, counters))
+            return null;
+        let best = -1;
+        let bestVariance = 0.38;
+        for (let v = 0; v < CODE93_VALUES.length; v++) {
+            const runs = CODE93_RUNS[CODE93_VALUES[v]];
+            const variance = patternVariance(counters, runs, 0.7);
+            if (variance < bestVariance) {
+                bestVariance = variance;
+                best = v;
+            }
+        }
+        const stopVariance = patternVariance(counters, startRuns, 0.7);
+        if (stopVariance < bestVariance)
+            break;
+        if (best < 0)
+            return null;
+        values.push(best);
+        let w = 0;
+        for (const c of counters)
+            w += c;
+        offset += w;
+        if (values.length > 90)
+            return null;
     }
-
-    const stopVariance = patternVariance(counters, startRuns, 0.7);
-    if (stopVariance < bestVariance) break;
-    if (best < 0) return null;
-
-    values.push(best);
-    let w = 0;
-    for (const c of counters) w += c;
-    offset += w;
-    if (values.length > 90) return null;
-  }
-
-  if (values.length < 3) return null;
-
-  // Verify both check characters before trusting anything.
-  const weighted = (data, maxWeight) => {
-    let sum = 0;
-    for (let i = 0; i < data.length; i++) {
-      const weight = ((data.length - 1 - i) % maxWeight) + 1;
-      sum += weight * data[i];
+    if (values.length < 3)
+        return null;
+    // Verify both check characters before trusting anything.
+    const weighted = (data, maxWeight) => {
+        let sum = 0;
+        for (let i = 0; i < data.length; i++) {
+            const weight = ((data.length - 1 - i) % maxWeight) + 1;
+            sum += weight * data[i];
+        }
+        return sum % 47;
+    };
+    const k = values.pop();
+    const c = values.pop();
+    if (weighted(values, 20) !== c)
+        return null;
+    if (weighted([...values, c], 15) !== k)
+        return null;
+    let text = '';
+    for (const v of values) {
+        const key = CODE93_VALUES[v];
+        if (key.length > 1)
+            return null; // shift characters not expanded here
+        text += key;
     }
-    return sum % 47;
-  };
-  const k = values.pop();
-  const c = values.pop();
-  if (weighted(values, 20) !== c) return null;
-  if (weighted([...values, c], 15) !== k) return null;
-
-  let text = '';
-  for (const v of values) {
-    const key = CODE93_VALUES[v];
-    if (key.length > 1) return null; // shift characters not expanded here
-    text += key;
-  }
-  return { format: 'code93', text };
+    return { format: 'code93', text };
 }
-
 /* ------------------------------------------------------------------ *
  * ITF
  * ------------------------------------------------------------------ */
-
 /**
  * @param {Uint8Array} row
  * @returns {{format: string, text: string} | null}
  */
 function decodeITF(row) {
-  const start = findGuard(row, 0, [1, 1, 1, 1], false);
-  if (!start) return null;
-  const startScale = (start.end - start.start) / 4;
-
-  let offset = start.end;
-  const digits = [];
-  const barCounters = new Array(5).fill(0);
-  const spaceCounters = new Array(5).fill(0);
-  const pair = new Array(10).fill(0);
-
-  for (;;) {
-    if (!recordPattern(row, offset, pair)) break;
-
-    // De-interleave: even indices are bars, odd are spaces.
-    for (let k = 0; k < 5; k++) {
-      barCounters[k] = pair[k * 2];
-      spaceCounters[k] = pair[k * 2 + 1];
+    const start = findGuard(row, 0, [1, 1, 1, 1], false);
+    if (!start)
+        return null;
+    const startScale = (start.end - start.start) / 4;
+    let offset = start.end;
+    const digits = [];
+    const barCounters = new Array(5).fill(0);
+    const spaceCounters = new Array(5).fill(0);
+    const pair = new Array(10).fill(0);
+    for (;;) {
+        if (!recordPattern(row, offset, pair))
+            break;
+        // De-interleave: even indices are bars, odd are spaces.
+        for (let k = 0; k < 5; k++) {
+            barCounters[k] = pair[k * 2];
+            spaceCounters[k] = pair[k * 2 + 1];
+        }
+        const barBits = toNarrowWidePattern(barCounters, 2);
+        const spaceBits = toNarrowWidePattern(spaceCounters, 2);
+        const a = ITF_BITS[barBits];
+        const b = ITF_BITS[spaceBits];
+        if (a === undefined || b === undefined)
+            break;
+        digits.push(a, b);
+        let w = 0;
+        for (const c of pair)
+            w += c;
+        offset += w;
+        if (digits.length > 40)
+            break;
     }
-
-    const barBits = toNarrowWidePattern(barCounters, 2);
-    const spaceBits = toNarrowWidePattern(spaceCounters, 2);
-    const a = ITF_BITS[barBits];
-    const b = ITF_BITS[spaceBits];
-    if (a === undefined || b === undefined) break;
-
-    digits.push(a, b);
-    let w = 0;
-    for (const c of pair) w += c;
-    offset += w;
-    if (digits.length > 40) break;
-  }
-
-  // ITF carries no mandatory checksum, so structure is the only defence
-  // against a false positive — and without these two checks there is none.
-  //
-  // The loop above stops as soon as a pair fails to match, which happens both
-  // at the genuine end of a symbol and in the middle of unrelated bars. Two
-  // digits scraped out of a Code 39 or UPC-A symbol matched the digit patterns
-  // often enough to be reported as a real ITF read, so `decode()` returned a
-  // phantom result alongside the true one.
-  if (digits.length < MIN_ITF_DIGITS) return null;
-
-  // Require the run to end on the actual stop pattern: wide bar, narrow space,
-  // narrow bar. A fragment that merely ran out of matching pairs has no stop
-  // pattern after it and is rejected here.
-  const stop = new Array(3).fill(0);
-  if (!recordPattern(row, offset, stop)) return null;
-  if (toNarrowWidePattern(stop, 1) !== 0b100) return null;
-  const stopEnd = offset + counterTotal(stop);
-  let nextDark = stopEnd;
-  while (nextDark < row.length && row[nextDark] === 0) nextDark++;
-  if (nextDark !== row.length && nextDark - stopEnd < Math.max(3, Math.ceil(startScale * 3))) return null;
-
-  return { format: 'itf', text: digits.join('') };
+    // ITF carries no mandatory checksum, so structure is the only defence
+    // against a false positive — and without these two checks there is none.
+    //
+    // The loop above stops as soon as a pair fails to match, which happens both
+    // at the genuine end of a symbol and in the middle of unrelated bars. Two
+    // digits scraped out of a Code 39 or UPC-A symbol matched the digit patterns
+    // often enough to be reported as a real ITF read, so `decode()` returned a
+    // phantom result alongside the true one.
+    if (digits.length < MIN_ITF_DIGITS)
+        return null;
+    // Require the run to end on the actual stop pattern: wide bar, narrow space,
+    // narrow bar. A fragment that merely ran out of matching pairs has no stop
+    // pattern after it and is rejected here.
+    const stop = new Array(3).fill(0);
+    if (!recordPattern(row, offset, stop))
+        return null;
+    if (toNarrowWidePattern(stop, 1) !== 0b100)
+        return null;
+    const stopEnd = offset + counterTotal(stop);
+    let nextDark = stopEnd;
+    while (nextDark < row.length && row[nextDark] === 0)
+        nextDark++;
+    if (nextDark !== row.length && nextDark - stopEnd < Math.max(3, Math.ceil(startScale * 3)))
+        return null;
+    return { format: 'itf', text: digits.join('') };
 }
-
 /* ------------------------------------------------------------------ *
  * Codabar
  * ------------------------------------------------------------------ */
-
 /**
  * @param {Uint8Array} row
  * @returns {{format: string, text: string} | null}
  */
 function decodeCodabar(row) {
-  const counters = new Array(7).fill(0);
-  let offset = 0;
-  let startChar = null;
-
-  while (offset < row.length) {
-    while (offset < row.length && row[offset] !== 1) offset++;
-    if (offset >= row.length) break;
-    if (recordPattern(row, offset, counters)) {
-      const bits = toNarrowWidePattern(counters, 3) >= 0
-        ? toNarrowWidePattern(counters, 3)
-        : toNarrowWidePattern(counters, 2);
-      const ch = CODABAR_BITS[bits];
-      if (ch && CODABAR_START_STOP.includes(ch)) { startChar = ch; break; }
+    const counters = new Array(7).fill(0);
+    let offset = 0;
+    let startChar = null;
+    while (offset < row.length) {
+        while (offset < row.length && row[offset] !== 1)
+            offset++;
+        if (offset >= row.length)
+            break;
+        if (recordPattern(row, offset, counters)) {
+            const bits = toNarrowWidePattern(counters, 3) >= 0
+                ? toNarrowWidePattern(counters, 3)
+                : toNarrowWidePattern(counters, 2);
+            const ch = CODABAR_BITS[bits];
+            if (ch && CODABAR_START_STOP.includes(ch)) {
+                startChar = ch;
+                break;
+            }
+        }
+        while (offset < row.length && row[offset] === 1)
+            offset++;
+        while (offset < row.length && row[offset] === 0)
+            offset++;
     }
-    while (offset < row.length && row[offset] === 1) offset++;
-    while (offset < row.length && row[offset] === 0) offset++;
-  }
-  if (!startChar) return null;
-
-  let w = 0;
-  for (const c of counters) w += c;
-  offset += w;
-
-  let text = '';
-  for (;;) {
-    while (offset < row.length && row[offset] === 0) offset++;
-    if (offset >= row.length) return null;
-    if (!recordPattern(row, offset, counters)) return null;
-
-    let bits = toNarrowWidePattern(counters, 3);
-    let ch = CODABAR_BITS[bits];
-    if (ch === undefined) {
-      bits = toNarrowWidePattern(counters, 2);
-      ch = CODABAR_BITS[bits];
+    if (!startChar)
+        return null;
+    let w = 0;
+    for (const c of counters)
+        w += c;
+    offset += w;
+    let text = '';
+    for (;;) {
+        while (offset < row.length && row[offset] === 0)
+            offset++;
+        if (offset >= row.length)
+            return null;
+        if (!recordPattern(row, offset, counters))
+            return null;
+        let bits = toNarrowWidePattern(counters, 3);
+        let ch = CODABAR_BITS[bits];
+        if (ch === undefined) {
+            bits = toNarrowWidePattern(counters, 2);
+            ch = CODABAR_BITS[bits];
+        }
+        if (ch === undefined)
+            return null;
+        let width = 0;
+        for (const c of counters)
+            width += c;
+        offset += width;
+        if (CODABAR_START_STOP.includes(ch))
+            break;
+        text += ch;
+        if (text.length > 60)
+            return null;
     }
-    if (ch === undefined) return null;
-
-    let width = 0;
-    for (const c of counters) width += c;
-    offset += width;
-
-    if (CODABAR_START_STOP.includes(ch)) break;
-    text += ch;
-    if (text.length > 60) return null;
-  }
-
-  if (text.length === 0) return null;
-  return { format: 'codabar', text };
+    if (text.length === 0)
+        return null;
+    return { format: 'codabar', text };
 }
-
 /* ------------------------------------------------------------------ *
  * Public entry point
  * ------------------------------------------------------------------ */
-
 /** Decoders in the order they are tried. */
 const DECODERS = [
-  ['ean13', decodeEANFamily],
-  ['upca', decodeEANFamily],
-  ['ean8', decodeEAN8],
-  ['upce', decodeUPCE],
-  ['code128', decodeCode128],
-  ['code11', decodeCode11],
-  ['msi', decodeMSI],
-  ['gs1databar14', decodeDataBar14Scanline],
-  ['code39', decodeCode39],
-  ['code93', decodeCode93],
-  ['itf', decodeITF],
-  ['codabar', decodeCodabar],
+    ['ean13', decodeEANFamily],
+    ['upca', decodeEANFamily],
+    ['ean8', decodeEAN8],
+    ['upce', decodeUPCE],
+    ['code128', decodeCode128],
+    ['code11', decodeCode11],
+    ['msi', decodeMSI],
+    ['gs1databar14', decodeDataBar14Scanline],
+    ['code39', decodeCode39],
+    ['code93', decodeCode93],
+    ['itf', decodeITF],
+    ['codabar', decodeCodabar],
 ];
-
 const EAN_PARENT_FORMATS = new Set(['ean13', 'ean8', 'upca', 'upce', 'isbn']);
 const EAN_SUPPLEMENT_FORMATS = new Set(['ean2', 'ean5']);
-
 /** @param {string} format @returns {boolean} */
 function isEANParentFormat(format) {
-  return format === 'ean13' || format === 'ean8' || format === 'upca' || format === 'upce';
+    return format === 'ean13' || format === 'ean8' || format === 'upca' || format === 'upce';
 }
-
 /**
  * An ISBN is printed as a Bookland EAN-13, so its decoded parent remains
  * `ean13` while an ISBN filter accepts only the Bookland prefixes.
@@ -1158,62 +1168,62 @@ function isEANParentFormat(format) {
  * @returns {boolean}
  */
 function isRequestedEANParent(result, enabled) {
-  if (enabled.has(result.format)) return true;
-  return result.format === 'ean13' && enabled.has('isbn') && /^97[89]/.test(result.text);
+    if (enabled.has(result.format))
+        return true;
+    return result.format === 'ean13' && enabled.has('isbn') && /^97[89]/.test(result.text);
 }
-
 /** @param {object} result @returns {object} */
 function withoutEANAddon(result) {
-  const { addon, ...parent } = result;
-  void addon;
-  return parent;
+    const { addon, ...parent } = result;
+    void addon;
+    return parent;
 }
-
 /** @param {Uint8Array} row @returns {{x:number, width:number, quietZone:boolean}|null} */
 function cameraRowGeometry(row) {
-  let first = 0;
-  while (first < row.length && row[first] === 0) first++;
-  if (first === row.length) return null;
-  let last = row.length - 1;
-  while (last >= 0 && row[last] === 0) last--;
-  return {
-    x: first,
-    width: last - first + 1,
-    quietZone: first >= 2 && row.length - 1 - last >= 2,
-  };
+    let first = 0;
+    while (first < row.length && row[first] === 0)
+        first++;
+    if (first === row.length)
+        return null;
+    let last = row.length - 1;
+    while (last >= 0 && row[last] === 0)
+        last--;
+    return {
+        x: first,
+        width: last - first + 1,
+        quietZone: first >= 2 && row.length - 1 - last >= 2,
+    };
 }
-
 /** @param {string} format @param {object} options @returns {boolean|null} */
 function checksumStatus(format, options) {
-  if (format === 'ean13' || format === 'ean8' || format === 'upca' || format === 'upce' ||
-      format === 'code93' || format === 'code128' || format === 'gs1128' ||
-      format === 'gs1databar14') return true;
-  if (format === 'code11' || format === 'msi' || format === 'code39') {
-    return options.profile === 'camera' || options.checkDigit === true ? true : null;
-  }
-  return null;
+    if (format === 'ean13' || format === 'ean8' || format === 'upca' || format === 'upce' ||
+        format === 'code93' || format === 'code128' || format === 'gs1128' ||
+        format === 'gs1databar14')
+        return true;
+    if (format === 'code11' || format === 'msi' || format === 'code39') {
+        return options.profile === 'camera' || options.checkDigit === true ? true : null;
+    }
+    return null;
 }
-
 /** @param {object} result @param {object} geometry @param {Set<number>} rows @param {object} options @returns {object} */
 function cameraMetadata(result, geometry, rows, options) {
-  const checksum = checksumStatus(result.format, options);
-  const consistency = Math.min(1, rows.size / 3);
-  const confidence = Math.min(1, 0.4 + (geometry.quietZone ? 0.2 : 0) +
-    (checksum === true ? 0.2 : 0) + consistency * 0.2);
-  return {
-    ...result,
-    confidence,
-    bounds: {
-      x: geometry.x,
-      y: Math.min(...rows),
-      width: geometry.width,
-      height: Math.max(...rows) - Math.min(...rows) + 1,
-    },
-    rotation: options.cameraRotation ?? 0,
-    quality: { quietZone: geometry.quietZone, checksum, rows: rows.size, consistency },
-  };
+    const checksum = checksumStatus(result.format, options);
+    const consistency = Math.min(1, rows.size / 3);
+    const confidence = Math.min(1, 0.4 + (geometry.quietZone ? 0.2 : 0) +
+        (checksum === true ? 0.2 : 0) + consistency * 0.2);
+    return {
+        ...result,
+        confidence,
+        bounds: {
+            x: geometry.x,
+            y: Math.min(...rows),
+            width: geometry.width,
+            height: Math.max(...rows) - Math.min(...rows) + 1,
+        },
+        rotation: options.cameraRotation ?? 0,
+        quality: { quietZone: geometry.quietZone, checksum, rows: rows.size, consistency },
+    };
 }
-
 /**
  * Read every linear symbol found in a binarized image.
  *
@@ -1227,129 +1237,137 @@ function cameraMetadata(result, geometry, rows, options) {
  * @returns {Array<{format: string, text: string, row: number}>}
  */
 export function decodeOneD(image, options = {}) {
-  const { formats = null, rows = 15, tryHarder = true, profile = null } = options;
-  const cameraProfile = profile === 'camera';
-  const enabled = formats ? new Set(formats) : null;
-  const active = DECODERS.filter(([id]) => {
-    if (!enabled) return true;
-    if (enabled.has(id)) return true;
-    if (id === 'ean13' || id === 'ean8' || id === 'upca' || id === 'upce') {
-      return enabled.has('ean2') || enabled.has('ean5') ||
-        (id === 'ean13' && enabled.has('isbn'));
-    }
-    if (id === 'code128') return enabled.has('gs1128');
-    if (id === 'gs1databar14') return enabled.has('databar') || enabled.has('gs1-databar14');
-    return false;
-  });
-  if (active.length === 0) return [];
-
-  const results = [];
-  const seen = new Set();
-  const height = image.height;
-  const buffer = new Uint8Array(image.width);
-  const cameraCandidates = new Map();
-
-  // Sample rows from the middle outward: symbols are usually centred, and the
-  // middle of a linear barcode is the part least likely to be clipped.
-  const middle = height >> 1;
-  const sampleRows = cameraProfile ? Math.min(height, Math.max(rows, 48)) : rows;
-  const step = Math.max(1, Math.round(height / sampleRows));
-
-  for (let attempt = 0; attempt < sampleRows; attempt++) {
-    const delta = Math.ceil(attempt / 2) * step * (attempt % 2 === 0 ? 1 : -1);
-    const y = middle + delta;
-    if (y < 0 || y >= height) continue;
-
-    const row = image.getRow(y, buffer);
-
-    for (const pass of tryHarder ? [false, true] : [false]) {
-      const scan = pass ? Uint8Array.from(row).reverse() : row;
-
-      for (const [id, decoder] of active) {
-        let result = null;
-        try {
-          // Code 11 and MSI checks are optional in their base standards, but
-          // a camera frame cannot safely promote their short unchecked forms.
-          const decoderOptions = cameraProfile && (id === 'code11' || id === 'msi')
-            ? { ...options, checkDigit: true }
-            : options;
-          result = decoder(scan, decoderOptions);
-        } catch {
-          result = null; // a malformed candidate is not an error
+    const { formats = null, rows = 15, tryHarder = true, profile = null } = options;
+    const cameraProfile = profile === 'camera';
+    const enabled = formats ? new Set(formats) : null;
+    const active = DECODERS.filter(([id]) => {
+        if (!enabled)
+            return true;
+        if (enabled.has(id))
+            return true;
+        if (id === 'ean13' || id === 'ean8' || id === 'upca' || id === 'upce') {
+            return enabled.has('ean2') || enabled.has('ean5') ||
+                (id === 'ean13' && enabled.has('isbn'));
         }
-        if (!result) continue;
-        if (enabled) {
-          if (isEANParentFormat(result.format)) {
-            const baseRequested = [...EAN_PARENT_FORMATS].some((format) => enabled.has(format));
-            const parentRequested = isRequestedEANParent(result, enabled);
-            if (baseRequested && !parentRequested) {
-              continue;
-            }
-            if (!baseRequested) {
-              // A supplement is never an independent barcode. When it is the
-              // only requested format, return its validated EAN/UPC parent.
-              if (!result.addon || !EAN_SUPPLEMENT_FORMATS.has(result.addon.format) ||
-                  !enabled.has(result.addon.format)) continue;
-            } else if (result.addon && !enabled.has(result.addon.format)) {
-              // Supplements are optional whenever a requested parent exists.
-              result = withoutEANAddon(result);
-            }
-          } else if (result.format === 'gs1128') {
-            if (!enabled.has('gs1128') && !enabled.has('code128')) continue;
-          } else if (result.format === 'gs1databar14') {
-            if (!enabled.has('gs1databar14') && !enabled.has('databar') && !enabled.has('gs1-databar14')) continue;
-          } else if (!enabled.has(result.format)) {
+        if (id === 'code128')
+            return enabled.has('gs1128');
+        if (id === 'gs1databar14')
+            return enabled.has('databar') || enabled.has('gs1-databar14');
+        return false;
+    });
+    if (active.length === 0)
+        return [];
+    const results = [];
+    const seen = new Set();
+    const height = image.height;
+    const buffer = new Uint8Array(image.width);
+    const cameraCandidates = new Map();
+    // Sample rows from the middle outward: symbols are usually centred, and the
+    // middle of a linear barcode is the part least likely to be clipped.
+    const middle = height >> 1;
+    const sampleRows = cameraProfile ? Math.min(height, Math.max(rows, 48)) : rows;
+    const step = Math.max(1, Math.round(height / sampleRows));
+    for (let attempt = 0; attempt < sampleRows; attempt++) {
+        const delta = Math.ceil(attempt / 2) * step * (attempt % 2 === 0 ? 1 : -1);
+        const y = middle + delta;
+        if (y < 0 || y >= height)
             continue;
-          }
-        }
-
-        const addonKey = result.addon ? `:${result.addon.format}:${result.addon.text}` : '';
-        const key = `${result.format}:${result.text}${addonKey}`;
-        if (cameraProfile) {
-          const geometry = cameraRowGeometry(row);
-          // Do not promote partial row fragments from a camera frame.
-          if (!geometry || !geometry.quietZone) continue;
-          const candidate = cameraCandidates.get(key) ?? {
-            result,
-            geometry,
-            rows: new Set(),
-            rotation: ((options.cameraRotation ?? 0) + (pass ? 180 : 0)) % 360,
-          };
-          candidate.rows.add(y);
-          cameraCandidates.set(key, candidate);
-          continue;
+        const row = image.getRow(y, buffer);
+        for (const pass of tryHarder ? [false, true] : [false]) {
+            const scan = pass ? Uint8Array.from(row).reverse() : row;
+            for (const [id, decoder] of active) {
+                let result = null;
+                try {
+                    // Code 11 and MSI checks are optional in their base standards, but
+                    // a camera frame cannot safely promote their short unchecked forms.
+                    const decoderOptions = cameraProfile && (id === 'code11' || id === 'msi')
+                        ? { ...options, checkDigit: true }
+                        : options;
+                    result = decoder(scan, decoderOptions);
+                }
+                catch {
+                    result = null; // a malformed candidate is not an error
+                }
+                if (!result)
+                    continue;
+                if (enabled) {
+                    if (isEANParentFormat(result.format)) {
+                        const baseRequested = [...EAN_PARENT_FORMATS].some((format) => enabled.has(format));
+                        const parentRequested = isRequestedEANParent(result, enabled);
+                        if (baseRequested && !parentRequested) {
+                            continue;
+                        }
+                        if (!baseRequested) {
+                            // A supplement is never an independent barcode. When it is the
+                            // only requested format, return its validated EAN/UPC parent.
+                            if (!result.addon || !EAN_SUPPLEMENT_FORMATS.has(result.addon.format) ||
+                                !enabled.has(result.addon.format))
+                                continue;
+                        }
+                        else if (result.addon && !enabled.has(result.addon.format)) {
+                            // Supplements are optional whenever a requested parent exists.
+                            result = withoutEANAddon(result);
+                        }
+                    }
+                    else if (result.format === 'gs1128') {
+                        if (!enabled.has('gs1128') && !enabled.has('code128'))
+                            continue;
+                    }
+                    else if (result.format === 'gs1databar14') {
+                        if (!enabled.has('gs1databar14') && !enabled.has('databar') && !enabled.has('gs1-databar14'))
+                            continue;
+                    }
+                    else if (!enabled.has(result.format)) {
+                        continue;
+                    }
+                }
+                const addonKey = result.addon ? `:${result.addon.format}:${result.addon.text}` : '';
+                const key = `${result.format}:${result.text}${addonKey}`;
+                if (cameraProfile) {
+                    const geometry = cameraRowGeometry(row);
+                    // Do not promote partial row fragments from a camera frame.
+                    if (!geometry || !geometry.quietZone)
+                        continue;
+                    const candidate = cameraCandidates.get(key) ?? {
+                        result,
+                        geometry,
+                        rows: new Set(),
+                        rotation: ((options.cameraRotation ?? 0) + (pass ? 180 : 0)) % 360,
+                    };
+                    candidate.rows.add(y);
+                    cameraCandidates.set(key, candidate);
+                    continue;
+                }
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                results.push({ ...result, row: y });
+                void id;
+            }
         }
-        if (seen.has(key)) continue;
-        seen.add(key);
-        results.push({ ...result, row: y });
-        void id;
-      }
     }
-  }
-
-  if (cameraProfile) {
-    for (const candidate of cameraCandidates.values()) {
-      // A complete symbol must survive at least two nearby scan samples. This
-      // rejects isolated run coincidences without imposing a payload length.
-      if (candidate.rows.size < 2) continue;
-      results.push(cameraMetadata(candidate.result, candidate.geometry, candidate.rows, {
-        ...options,
-        cameraRotation: candidate.rotation,
-      }));
+    if (cameraProfile) {
+        for (const candidate of cameraCandidates.values()) {
+            // A complete symbol must survive at least two nearby scan samples. This
+            // rejects isolated run coincidences without imposing a payload length.
+            if (candidate.rows.size < 2)
+                continue;
+            results.push(cameraMetadata(candidate.result, candidate.geometry, candidate.rows, {
+                ...options,
+                cameraRotation: candidate.rotation,
+            }));
+        }
     }
-  }
-
-  // A valid EAN/UPC parent is substantially more constrained than a generic
-  // narrow/wide candidate. Suppress competing interpretations of the same
-  // scanline, while retaining symbols detected on other rows.
-  const eanRows = new Set(results
-    .filter((result) => isEANParentFormat(result.format))
-    .map((result) => result.row));
-  return eanRows.size === 0
-    ? results
-    : results.filter((result) => !eanRows.has(result.row) || isEANParentFormat(result.format));
+    // A valid EAN/UPC parent is substantially more constrained than a generic
+    // narrow/wide candidate. Suppress competing interpretations of the same
+    // scanline, while retaining symbols detected on other rows.
+    const eanRows = new Set(results
+        .filter((result) => isEANParentFormat(result.format))
+        .map((result) => result.row));
+    return eanRows.size === 0
+        ? results
+        : results.filter((result) => !eanRows.has(result.row) || isEANParentFormat(result.format));
 }
-
 /**
  * Convenience wrapper that throws when nothing is found.
  *
@@ -1358,7 +1376,8 @@ export function decodeOneD(image, options = {}) {
  * @returns {{format: string, text: string, row: number}}
  */
 export function decodeOneDStrict(image, options) {
-  const results = decodeOneD(image, options);
-  if (results.length === 0) throw new NotFoundError('No linear barcode found');
-  return results[0];
+    const results = decodeOneD(image, options);
+    if (results.length === 0)
+        throw new NotFoundError('No linear barcode found');
+    return results[0];
 }