@sythos/js_barcode_universal 1.5.8 → 1.5.9

package/src/js/databar/tables.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Static GS1 DataBar facts used by the GTIN compaction codec.
  *
@@ -38,87 +37,87 @@
  *
  * @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,
+    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 }),
+    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]),
+    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),
+    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),
+    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;
+    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;
+    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');
     }
-    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;
+    return problems;
 }

package/src/js/datamatrix/decoder.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Data Matrix ECC 200 decoder for an already sampled symbol.
  *
@@ -40,210 +39,245 @@
  *
  * @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;
+    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 };
+    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;
+    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;
+    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;
+    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++];
+    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 };
+    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;
+    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;
+    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}`);
     }
-    throw new FormatError(`Data Matrix: unsupported encoding codeword ${cw}`);
-  }
-  return { text, bytes: Uint8Array.from(bytes), gs1 };
+    return { text, bytes: Uint8Array.from(bytes), gs1 };
 }
-
 /**
  * Decode an upright, sampled Data Matrix ECC 200 symbol.
  *
@@ -251,12 +285,12 @@ function parseData(data) {
  * @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 };
+    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 };