@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/ts/databar/patterns.ts

@@ -0,0 +1,143 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/** Mathematical width construction for GS1 DataBar characters. @module databar/patterns */
+
+import { dataBar14GroupFor } from './tables.js';
+
+function combinations(n, r) {
+  if (n < r || r < 0) return 0;
+  if (r === 0 || n === r) return 1;
+  let result = 1;
+  const k = Math.min(r, n - r);
+  for (let i = 1; i <= k; i++) result = result * (n - k + i) / i;
+  return result;
+}
+
+/**
+ * Unrank one constrained positive composition.
+ *
+ * The rank is the GS1 DataBar symbol-character value inside its group. This
+ * implementation follows the combinatorial definition directly: it counts
+ * every remaining admissible suffix rather than storing third-party patterns.
+ */
+export function dataBarWidths(rank, modules, elements, maximumWidth, noNarrow) {
+  if (!Number.isInteger(rank) || rank < 0) throw new RangeError('GS1 DataBar width rank must be non-negative');
+  const widths = new Array(elements).fill(0);
+  let remaining = modules;
+  let narrowMask = 0;
+
+  for (let bar = 0; bar < elements - 1; bar++) {
+    let count = 0;
+    for (let width = 1; ; width++) {
+      narrowMask |= width === 1 ? 1 << bar : 0;
+      count = combinations(remaining - width - 1, elements - bar - 2);
+
+      if (noNarrow && narrowMask === 0 && remaining - width - (elements - bar - 1) >= elements - bar - 1) {
+        count -= combinations(remaining - width - (elements - bar), elements - bar - 2);
+      }
+
+      if (elements - bar - 1 > 1) {
+        let tooWide = 0;
+        for (let last = remaining - width - (elements - bar - 2); last > maximumWidth; last--) {
+          tooWide += combinations(remaining - width - last - 1, elements - bar - 3);
+        }
+        count -= tooWide * (elements - 1 - bar);
+      } else if (remaining - width > maximumWidth) {
+        count--;
+      }
+
+      if (rank < count) {
+        widths[bar] = width;
+        remaining -= width;
+        break;
+      }
+      rank -= count;
+      narrowMask &= ~(1 << bar);
+    }
+  }
+  widths[elements - 1] = remaining;
+  if (rank !== 0 || widths.some((width) => width < 1 || width > maximumWidth)) {
+    throw new RangeError('GS1 DataBar width rank exceeds its character group');
+  }
+  return widths;
+}
+
+/** Convert one DataBar-14 character value into its eight alternating widths. */
+export function dataBar14CharacterWidths(value, kind) {
+  const group = dataBar14GroupFor(value, kind);
+  const offset = value - group.gsum;
+  const outside = kind === 'outside';
+  const oddRank = outside ? Math.floor(offset / group.evenTotal) : offset % group.oddTotal;
+  const evenRank = outside ? offset % group.evenTotal : Math.floor(offset / group.oddTotal);
+  const odd = dataBarWidths(oddRank, group.oddModules, 4, group.oddWidest, !outside);
+  const even = dataBarWidths(evenRank, group.evenModules, 4, group.evenWidest, outside);
+  const result = [];
+  for (let i = 0; i < 4; i++) result.push(odd[i], even[i]);
+  return result;
+}
+
+const inverseCharacterMaps = new Map();
+
+/** Recover a character value from its canonical eight-width representation. */
+export function dataBar14ValueForWidths(widths, kind) {
+  if (!Array.isArray(widths) || widths.length !== 8 || widths.some((width) => !Number.isInteger(width) || width < 1)) {
+    throw new TypeError('GS1 DataBar character widths must contain eight positive integers');
+  }
+  if (kind !== 'outside' && kind !== 'inside') throw new RangeError(`Unknown GS1 DataBar character kind "${kind}"`);
+  let inverse = inverseCharacterMaps.get(kind);
+  if (!inverse) {
+    inverse = new Map();
+    const maximum = kind === 'outside' ? 2840 : 1596;
+    for (let value = 0; value <= maximum; value++) {
+      inverse.set(dataBar14CharacterWidths(value, kind).join(','), value);
+    }
+    inverseCharacterMaps.set(kind, inverse);
+  }
+  const value = inverse.get(widths.join(','));
+  if (value === undefined) throw new RangeError(`Invalid GS1 DataBar ${kind} character widths`);
+  return value;
+}
+
+/** Nine finder patterns, expressed as normative five-element widths. */
+export const DATABAR14_FINDERS = Object.freeze([
+  Object.freeze([3, 8, 2, 1, 1]), Object.freeze([3, 5, 5, 1, 1]),
+  Object.freeze([3, 3, 7, 1, 1]), Object.freeze([3, 1, 9, 1, 1]),
+  Object.freeze([2, 7, 4, 1, 1]), Object.freeze([2, 5, 6, 1, 1]),
+  Object.freeze([2, 3, 8, 1, 1]), Object.freeze([1, 5, 7, 1, 1]),
+  Object.freeze([1, 3, 9, 1, 1]),
+]);
+
+/** Weight sequence generated as powers of three modulo 79. */
+export const DATABAR14_CHECKSUM_WEIGHTS = Object.freeze(Array.from({ length: 32 }, (_, index) => {
+  let value = 1;
+  for (let i = 0; i < index; i++) value = (value * 3) % 79;
+  return value;
+}));

package/src/ts/databar/tables.ts

@@ -0,0 +1,124 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * Static GS1 DataBar facts used by the GTIN compaction codec.
+ *
+ * The numbers in the DataBar-14 group tables are the public tables in
+ * ISO/IEC 24724:2011, clauses 5.2.2 and 5.2.3. They describe values, not a
+ * third-party implementation. Pattern construction deliberately belongs in
+ * the renderer/encoder layer so this module stays a small, auditable contract.
+ *
+ * @module databar/tables
+ */
+
+const group = (first, last, gsum, oddModules, evenModules, oddWidest, evenWidest, oddTotal, evenTotal) => Object.freeze({
+  first, last, gsum, oddModules, evenModules, oddWidest, evenWidest, oddTotal, evenTotal,
+});
+
+/** The four GTIN-only layouts sharing the DataBar-14 compaction rules. */
+export const DATABAR14_VARIANTS = Object.freeze({
+  omnidirectional: Object.freeze({ id: 'omnidirectional', rows: 1, modules: 96, checksumModulus: 79, pointOfSale: true }),
+  truncated: Object.freeze({ id: 'truncated', rows: 1, modules: 96, checksumModulus: 79, pointOfSale: false }),
+  stacked: Object.freeze({ id: 'stacked', rows: 2, modules: 50, checksumModulus: 79, pointOfSale: false }),
+  'stacked-omnidirectional': Object.freeze({ id: 'stacked-omnidirectional', rows: 2, modules: 50, checksumModulus: 79, pointOfSale: true }),
+});
+
+/** GS1 DataBar Limited is a distinct two-character symbology. */
+export const DATABAR_LIMITED_VARIANT = Object.freeze({
+  id: 'limited', rows: 1, checksumModulus: 89, pointOfSale: false,
+  permittedIndicatorDigits: Object.freeze([0, 1]),
+});
+
+/** (16,4) outside character groups, ISO/IEC 24724:2011 Table 1. */
+export const DATABAR14_OUTSIDE_GROUPS = Object.freeze([
+  group(0, 160, 0, 12, 4, 8, 1, 161, 1),
+  group(161, 960, 161, 10, 6, 6, 3, 80, 10),
+  group(961, 2014, 961, 8, 8, 4, 5, 31, 34),
+  group(2015, 2714, 2015, 6, 10, 3, 6, 10, 70),
+  group(2715, 2840, 2715, 4, 12, 1, 8, 1, 126),
+]);
+
+/** (15,4) inside character groups, ISO/IEC 24724:2011 Table 2. */
+export const DATABAR14_INSIDE_GROUPS = Object.freeze([
+  group(0, 335, 0, 5, 10, 2, 7, 4, 84),
+  group(336, 1035, 336, 7, 8, 4, 5, 20, 35),
+  group(1036, 1515, 1036, 9, 6, 6, 3, 48, 10),
+  group(1516, 1596, 1516, 11, 4, 8, 1, 81, 1),
+]);
+
+/** Number of values carried by an inside (15,4) character. */
+export const DATABAR14_INSIDE_RADIX = 1597;
+/** Number of values carried by one outside/inside character pair. */
+export const DATABAR14_PAIR_RADIX = 4537077;
+/** Stand-alone and composite DataBar-14 payload domain, including linkage. */
+export const DATABAR14_SYMBOL_LIMIT = 20000000000000n;
+
+/** GS1 DataBar Limited divides its 13 data digits into two character values. */
+export const DATABAR_LIMITED_PAIR_RADIX = 2013571;
+/** Offset that switches a DataBar Limited value from stand-alone to composite. */
+export const DATABAR_LIMITED_LINKAGE_OFFSET = 2015133531096n;
+/** DataBar Limited carries GTIN values whose first digit is zero or one. */
+export const DATABAR_LIMITED_DATA_LIMIT = 2000000000000n;
+
+/** Locate the value group that an outside or inside character belongs to. */
+export function dataBar14GroupFor(value, kind) {
+  if (!Number.isInteger(value)) throw new TypeError('GS1 DataBar character value must be an integer');
+  const groups = kind === 'outside' ? DATABAR14_OUTSIDE_GROUPS
+    : kind === 'inside' ? DATABAR14_INSIDE_GROUPS : null;
+  if (!groups) throw new RangeError(`Unknown GS1 DataBar character kind "${kind}"`);
+  const found = groups.find((entry) => value >= entry.first && value <= entry.last);
+  if (!found) throw new RangeError(`GS1 DataBar ${kind} character value ${value} is out of range`);
+  return found;
+}
+/** Check the independently represented table identities. */
+export function validateDataBarTables() {
+  const problems = [];
+  const validateGroups = (name, groups, expectedLast) => {
+    let next = 0;
+    for (const entry of groups) {
+      if (entry.first !== next) problems.push(`${name}: gap before ${entry.first}`);
+      if (entry.last < entry.first) problems.push(`${name}: inverted range ${entry.first}-${entry.last}`);
+      if (entry.oddTotal * entry.evenTotal !== entry.last - entry.first + 1) {
+        problems.push(`${name}: combination count mismatch at ${entry.first}`);
+      }
+      next = entry.last + 1;
+    }
+    if (next - 1 !== expectedLast) problems.push(`${name}: final value is ${next - 1}, expected ${expectedLast}`);
+  };
+  validateGroups('outside', DATABAR14_OUTSIDE_GROUPS, 2840);
+  validateGroups('inside', DATABAR14_INSIDE_GROUPS, 1596);
+  if (DATABAR14_PAIR_RADIX !== 2841 * DATABAR14_INSIDE_RADIX) problems.push('pair radix mismatch');
+  if (DATABAR14_SYMBOL_LIMIT !== 2n * 10000000000000n) problems.push('symbol limit mismatch');
+  if (DATABAR_LIMITED_LINKAGE_OFFSET !== BigInt(DATABAR_LIMITED_PAIR_RADIX) * 1000776n) {
+    problems.push('limited linkage offset mismatch');
+  }
+  return problems;
+}

package/src/ts/datamatrix/decoder.ts

@@ -0,0 +1,262 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+
+/**
+ * Data Matrix ECC 200 decoder for an already sampled symbol.
+ *
+ * The detector owns locating, perspective correction and orientation. This
+ * module starts with the complete, upright symbol including its finder borders.
+ * The table entry is deliberately read through a small normalizer so table data
+ * remains declarative: it needs total rows/columns, one data-region's rows and
+ * columns, data/ECC codeword counts, and either a block count or data block
+ * lengths. The standard 144x144 uneven data blocks are supported.
+ *
+ * @module datamatrix/decoder
+ */
+
+import { ChecksumError, FormatError } from '../core/errors.js';
+import { GF256_DM } from '../core/galois-field.js';
+import { rsDecode } from '../core/reed-solomon.js';
+import { SYMBOLS } from './tables.js';
+
+const CW_PAD = 129;
+const CW_BASE256 = 231;
+
+/** @param {object} entry @param {...string} names @returns {number | undefined} */
+function numberField(entry, ...names) {
+  for (const name of names) if (Number.isInteger(entry[name])) return entry[name];
+  return undefined;
+}
+
+/** Normalize the public table entry into the decoder's geometry contract. */
+function layoutFor(width, height) {
+  const entry = SYMBOLS.find((s) =>
+    numberField(s, 'columns', 'cols', 'matrixColumns', 'width') === width &&
+    numberField(s, 'rows', 'matrixRows', 'height') === height);
+  if (!entry) throw new FormatError(`Data Matrix: ${width}x${height} is not an ECC 200 symbol size`);
+
+  const regionRows = numberField(entry, 'dataRegionRows', 'regionRows') ??
+    (numberField(entry, 'regionHeight') ? numberField(entry, 'regionHeight') - 2 : undefined);
+  const regionCols = numberField(entry, 'dataRegionColumns', 'dataRegionCols', 'regionColumns') ??
+    (numberField(entry, 'regionWidth') ? numberField(entry, 'regionWidth') - 2 : undefined);
+  const dataCount = numberField(entry, 'dataCodewords', 'dataCapacity');
+  const eccCount = numberField(entry, 'errorCodewords', 'eccCodewords');
+  const blockCount = numberField(entry, 'interleavedBlocks', 'interleavedBlockCount', 'blockCount', 'rsBlocks') || 1;
+  if (!regionRows || !regionCols || dataCount === undefined || eccCount === undefined ||
+      height % (regionRows + 2) || width % (regionCols + 2) || eccCount % blockCount) {
+    throw new FormatError(`Data Matrix: invalid table layout for ${width}x${height}`);
+  }
+
+  const rows = height / (regionRows + 2);
+  const cols = width / (regionCols + 2);
+  const blockData = Array.isArray(entry.blockDataCodewords) ? entry.blockDataCodewords.slice() :
+    Array.isArray(entry.dataCodewordsPerBlock) ? entry.dataCodewordsPerBlock.slice() : null;
+  let dataLengths;
+  if (blockData) {
+    dataLengths = blockData;
+  } else {
+    // The sole uneven ECC 200 distribution is 144x144: its first eight of ten
+    // blocks contain one extra data codeword. This derives it instead of hiding
+    // a magic size check in the deinterleaver.
+    const short = Math.floor(dataCount / blockCount);
+    dataLengths = new Array(blockCount).fill(short);
+    for (let i = 0; i < dataCount % blockCount; i++) dataLengths[i]++;
+  }
+  if (dataLengths.length !== blockCount || dataLengths.reduce((a, b) => a + b, 0) !== dataCount) {
+    throw new FormatError(`Data Matrix: inconsistent block layout for ${width}x${height}`);
+  }
+  return { entry, regionRows, regionCols, regionRowCount: rows, regionColCount: cols,
+    dataRows: rows * regionRows, dataCols: cols * regionCols, dataCount, eccCount,
+    blockCount, eccPerBlock: eccCount / blockCount, dataLengths };
+}
+
+/** Remove the L/finders from every data region, retaining only placement modules. */
+function extractDataModules(matrix, layout) {
+  const data = new Uint8Array(layout.dataRows * layout.dataCols);
+  for (let regionY = 0; regionY < layout.regionRowCount; regionY++) {
+    for (let regionX = 0; regionX < layout.regionColCount; regionX++) {
+      const sourceX = regionX * (layout.regionCols + 2) + 1;
+      const sourceY = regionY * (layout.regionRows + 2) + 1;
+      for (let y = 0; y < layout.regionRows; y++) {
+        const targetY = regionY * layout.regionRows + y;
+        for (let x = 0; x < layout.regionCols; x++) {
+          data[targetY * layout.dataCols + regionX * layout.regionCols + x] =
+            matrix.get(sourceX + x, sourceY + y) ? 1 : 0;
+        }
+      }
+    }
+  }
+  return data;
+}
+
+/** Read placement codewords using the ECC 200 Utah sweep (the inverse writer path). */
+function readPlacement(modules, rows, cols, count) {
+  const seen = new Uint8Array(rows * cols);
+  const out = new Uint8Array(count);
+  const get = (row, col) => modules[row * cols + col] !== 0;
+  const module = (row, col) => {
+    if (row < 0) { row += rows; col += 4 - ((rows + 4) % 8); }
+    if (col < 0) { col += cols; row += 4 - ((cols + 4) % 8); }
+    if (row < 0 || row >= rows || col < 0 || col >= cols) {
+      throw new FormatError('Data Matrix: placement coordinate escaped data region');
+    }
+    seen[row * cols + col] = 1;
+    return get(row, col) ? 1 : 0;
+  };
+  const bits = (coords) => coords.reduce((value, p) => (value << 1) | module(p[0], p[1]), 0);
+  const utah = (row, col) => bits([[row - 2, col - 2], [row - 2, col - 1], [row - 1, col - 2], [row - 1, col - 1],
+    [row - 1, col], [row, col - 2], [row, col - 1], [row, col]]);
+  const corner1 = () => bits([[rows - 1, 0], [rows - 1, 1], [rows - 1, 2], [0, cols - 2], [0, cols - 1], [1, cols - 1], [2, cols - 1], [3, cols - 1]]);
+  const corner2 = () => bits([[rows - 3, 0], [rows - 2, 0], [rows - 1, 0], [0, cols - 4], [0, cols - 3], [0, cols - 2], [0, cols - 1], [1, cols - 1]]);
+  const corner3 = () => bits([[rows - 3, 0], [rows - 2, 0], [rows - 1, 0], [0, cols - 2], [0, cols - 1], [1, cols - 1], [2, cols - 1], [3, cols - 1]]);
+  const corner4 = () => bits([[rows - 1, 0], [rows - 1, cols - 1], [0, cols - 3], [0, cols - 2], [0, cols - 1], [1, cols - 3], [1, cols - 2], [1, cols - 1]]);
+
+  let row = 4, col = 0, n = 0;
+  const put = (value) => { if (n < count) out[n++] = value; };
+  do {
+    if (row === rows && col === 0) put(corner1());
+    if (row === rows - 2 && col === 0 && cols % 4 !== 0) put(corner2());
+    if (row === rows - 2 && col === 0 && cols % 8 === 4) put(corner3());
+    if (row === rows + 4 && col === 2 && cols % 8 === 0) put(corner4());
+    do { if (row < rows && col >= 0 && !seen[row * cols + col]) put(utah(row, col)); row -= 2; col += 2; } while (row >= 0 && col < cols);
+    row += 1; col += 3;
+    do { if (row >= 0 && col < cols && !seen[row * cols + col]) put(utah(row, col)); row += 2; col -= 2; } while (row < rows && col >= 0);
+    row += 3; col += 1;
+  } while (row < rows || col < cols);
+  if (n !== count) throw new FormatError(`Data Matrix: placement yielded ${n}, expected ${count} codewords`);
+  return out;
+}
+
+/** Restore RS blocks, correct them, then concatenate their data portions. */
+function deinterleaveAndCorrect(codewords, layout) {
+  if (codewords.length !== layout.dataCount + layout.eccCount) throw new FormatError('Data Matrix: codeword count mismatch');
+  const blocks = layout.dataLengths.map((len) => new Uint8Array(len + layout.eccPerBlock));
+  // Data codewords arrive in their original stream order. ECC 200 deals that
+  // stream round-robin across the RS blocks, so the inverse is determined by
+  // the wire index rather than by splitting it into consecutive block-sized
+  // chunks. For 144x144, indices 1550..1557 naturally land in the eight long
+  // blocks while the two short blocks remain at 155 data codewords.
+  for (let i = 0; i < layout.dataCount; i++) {
+    blocks[i % layout.blockCount][Math.floor(i / layout.blockCount)] = codewords[i];
+  }
+
+  // Parity normally begins with block zero. The uneven 144x144 layout rotates
+  // the parity wire order to begin with its first short block; derive the same
+  // mapping from the declarative lengths instead of keying it to dimensions.
+  const longest = Math.max(...layout.dataLengths);
+  const firstShort = layout.dataLengths.findIndex((length) => length < longest);
+  const rotation = firstShort < 0 ? 0 : firstShort;
+  let at = layout.dataCount;
+  for (let i = 0; i < layout.eccPerBlock; i++) {
+    for (let slot = 0; slot < layout.blockCount; slot++) {
+      const block = (slot + rotation) % layout.blockCount;
+      blocks[block][layout.dataLengths[block] + i] = codewords[at++];
+    }
+  }
+
+  let corrections = 0;
+  const data = new Uint8Array(layout.dataCount);
+  for (let b = 0; b < blocks.length; b++) {
+    corrections += rsDecode(blocks[b], layout.eccPerBlock, GF256_DM, 1);
+  }
+  // Rebuild the original high-level codeword stream after correction. Keeping
+  // this in wire-index order is essential: concatenating block data passes
+  // single-block round trips but scrambles every multi-block payload.
+  for (let i = 0; i < layout.dataCount; i++) {
+    data[i] = blocks[i % layout.blockCount][Math.floor(i / layout.blockCount)];
+  }
+  return { data, corrections };
+}
+
+function unrandomize(value, position) {
+  const pseudo = ((149 * position) % 255) + 1;
+  return value - pseudo >= 0 ? value - pseudo : value - pseudo + 256;
+}
+
+/** Decode ASCII plus Base 256, preserving semantic bytes alongside text. */
+function parseData(data) {
+  let text = '';
+  const bytes = [];
+  let upperShift = false;
+  let gs1 = false;
+  for (let i = 0; i < data.length;) {
+    const cw = data[i++];
+    if (cw === CW_PAD) break;
+    if (cw <= 128) {
+      const value = cw - 1 + (upperShift ? 128 : 0);
+      upperShift = false;
+      text += String.fromCharCode(value); bytes.push(value); continue;
+    }
+    if (cw <= 229) {
+      const pair = cw - 130;
+      const digits = String(pair).padStart(2, '0'); text += digits; bytes.push(digits.charCodeAt(0), digits.charCodeAt(1)); continue;
+    }
+    if (cw === 232) {
+      if (i === 1) gs1 = true;
+      else { text += '\x1d'; bytes.push(29); }
+      continue;
+    }
+    if (cw === 235) { upperShift = true; continue; }
+    if (cw === CW_BASE256) {
+      if (i >= data.length) throw new FormatError('Data Matrix: Base 256 length is missing');
+      let length = unrandomize(data[i], i + 1); i++;
+      if (length === 0) length = data.length - i;
+      else if (length >= 250) {
+        if (i >= data.length) throw new FormatError('Data Matrix: Base 256 extended length is missing');
+        length = 250 * (length - 249) + unrandomize(data[i], i + 1); i++;
+      }
+      if (i + length > data.length) throw new FormatError('Data Matrix: Base 256 segment exceeds data capacity');
+      const segment = new Uint8Array(length);
+      for (let n = 0; n < length; n++, i++) segment[n] = unrandomize(data[i], i + 1);
+      bytes.push(...segment);
+      for (let n = 0; n < segment.length; n++) text += String.fromCharCode(segment[n]);
+      continue;
+    }
+    throw new FormatError(`Data Matrix: unsupported encoding codeword ${cw}`);
+  }
+  return { text, bytes: Uint8Array.from(bytes), gs1 };
+}
+
+/**
+ * Decode an upright, sampled Data Matrix ECC 200 symbol.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix Full symbol, no quiet zone.
+ * @returns {{text: string, bytes: Uint8Array, correctedErrors: number, symbol: object}}
+ */
+export function decodeDataMatrix(matrix) {
+  if (!matrix || !Number.isInteger(matrix.width) || !Number.isInteger(matrix.height)) throw new FormatError('Data Matrix: no matrix supplied');
+  const layout = layoutFor(matrix.width, matrix.height);
+  const placement = readPlacement(extractDataModules(matrix, layout), layout.dataRows, layout.dataCols, layout.dataCount + layout.eccCount);
+  const { data, corrections } = deinterleaveAndCorrect(placement, layout);
+  const result = parseData(data);
+  return { ...result, corrections, correctedErrors: corrections, symbol: layout.entry };
+}
+
+export { ChecksumError };