@sythos/js_barcode_universal 1.5.8 → 1.5.9

package/src/js/oned/patterns.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Pattern tables for the linear symbologies.
  *
@@ -49,133 +48,119 @@
  *
  * @module oned/patterns
  */
-
 /* ------------------------------------------------------------------ *
  * EAN / UPC
  * ------------------------------------------------------------------ */
-
 /** Odd-parity ("L") digit patterns, 7 modules each. */
 export const EAN_L = [
-  '0001101', '0011001', '0010011', '0111101', '0100011',
-  '0110001', '0101111', '0111011', '0110111', '0001011',
+    '0001101', '0011001', '0010011', '0111101', '0100011',
+    '0110001', '0101111', '0111011', '0110111', '0001011',
 ];
-
 /** Even-parity ("G") patterns: the R pattern reversed. */
 export const EAN_G = EAN_L.map((p) => [...p].reverse().map((b) => (b === '1' ? '0' : '1')).join(''));
-
 /** Right-hand ("R") patterns: the L pattern complemented. */
 export const EAN_R = EAN_L.map((p) => [...p].map((b) => (b === '1' ? '0' : '1')).join(''));
-
 /**
  * Which parity set each of the six left-hand EAN-13 digits uses, indexed by
  * the first digit. This is how the thirteenth digit is carried without a
  * thirteenth symbol position.
  */
 export const EAN13_PARITY = [
-  'LLLLLL', 'LLGLGG', 'LLGGLG', 'LLGGGL', 'LGLLGG',
-  'LGGLLG', 'LGGGLL', 'LGLGLG', 'LGLGGL', 'LGGLGL',
+    'LLLLLL', 'LLGLGG', 'LLGGLG', 'LLGGGL', 'LGLLGG',
+    'LGGLLG', 'LGGGLL', 'LGLGLG', 'LGLGGL', 'LGGLGL',
 ];
-
 /** UPC-E parity patterns, indexed by check digit. Used when the number system is 0. */
 export const UPCE_PARITY = [
-  'EEEOOO', 'EEOEOO', 'EEOOEO', 'EEOOOE', 'EOEEOO',
-  'EOOEEO', 'EOOOEE', 'EOEOEO', 'EOEOOE', 'EOOEOE',
+    'EEEOOO', 'EEOEOO', 'EEOOEO', 'EEOOOE', 'EOEEOO',
+    'EOOEEO', 'EOOOEE', 'EOEOEO', 'EOEOOE', 'EOOEOE',
 ];
-
 export const EAN_START_END = '101';
 export const EAN_MIDDLE = '01010';
 export const UPCE_END = '010101';
-
 /* ------------------------------------------------------------------ *
  * Code 39
  * ------------------------------------------------------------------ */
-
 /**
  * Code 39 is "three of nine": nine elements per character, of which exactly
  * three are wide. `n` and `w` below are narrow and wide; elements alternate
  * bar, space, bar, ... starting and ending with a bar.
  */
 export const CODE39 = {
-  '0': 'nnnwwnwnn', '1': 'wnnwnnnnw', '2': 'nnwwnnnnw', '3': 'wnwwnnnnn',
-  '4': 'nnnwwnnnw', '5': 'wnnwwnnnn', '6': 'nnwwwnnnn', '7': 'nnnwnnwnw',
-  '8': 'wnnwnnwnn', '9': 'nnwwnnwnn', 'A': 'wnnnnwnnw', 'B': 'nnwnnwnnw',
-  'C': 'wnwnnwnnn', 'D': 'nnnnwwnnw', 'E': 'wnnnwwnnn', 'F': 'nnwnwwnnn',
-  'G': 'nnnnnwwnw', 'H': 'wnnnnwwnn', 'I': 'nnwnnwwnn', 'J': 'nnnnwwwnn',
-  'K': 'wnnnnnnww', 'L': 'nnwnnnnww', 'M': 'wnwnnnnwn', 'N': 'nnnnwnnww',
-  'O': 'wnnnwnnwn', 'P': 'nnwnwnnwn', 'Q': 'nnnnnnwww', 'R': 'wnnnnnwwn',
-  'S': 'nnwnnnwwn', 'T': 'nnnnwnwwn', 'U': 'wwnnnnnnw', 'V': 'nwwnnnnnw',
-  'W': 'wwwnnnnnn', 'X': 'nwnnwnnnw', 'Y': 'wwnnwnnnn', 'Z': 'nwwnwnnnn',
-  '-': 'nwnnnnwnw', '.': 'wwnnnnwnn', ' ': 'nwwnnnwnn', '$': 'nwnwnwnnn',
-  '/': 'nwnwnnnwn', '+': 'nwnnnwnwn', '%': 'nnnwnwnwn', '*': 'nwnnwnwnn',
+    '0': 'nnnwwnwnn', '1': 'wnnwnnnnw', '2': 'nnwwnnnnw', '3': 'wnwwnnnnn',
+    '4': 'nnnwwnnnw', '5': 'wnnwwnnnn', '6': 'nnwwwnnnn', '7': 'nnnwnnwnw',
+    '8': 'wnnwnnwnn', '9': 'nnwwnnwnn', 'A': 'wnnnnwnnw', 'B': 'nnwnnwnnw',
+    'C': 'wnwnnwnnn', 'D': 'nnnnwwnnw', 'E': 'wnnnwwnnn', 'F': 'nnwnwwnnn',
+    'G': 'nnnnnwwnw', 'H': 'wnnnnwwnn', 'I': 'nnwnnwwnn', 'J': 'nnnnwwwnn',
+    'K': 'wnnnnnnww', 'L': 'nnwnnnnww', 'M': 'wnwnnnnwn', 'N': 'nnnnwnnww',
+    'O': 'wnnnwnnwn', 'P': 'nnwnwnnwn', 'Q': 'nnnnnnwww', 'R': 'wnnnnnwwn',
+    'S': 'nnwnnnwwn', 'T': 'nnnnwnwwn', 'U': 'wwnnnnnnw', 'V': 'nwwnnnnnw',
+    'W': 'wwwnnnnnn', 'X': 'nwnnwnnnw', 'Y': 'wwnnwnnnn', 'Z': 'nwwnwnnnn',
+    '-': 'nwnnnnwnw', '.': 'wwnnnnwnn', ' ': 'nwwnnnwnn', '$': 'nwnwnwnnn',
+    '/': 'nwnwnnnwn', '+': 'nwnnnwnwn', '%': 'nnnwnwnwn', '*': 'nwnnwnwnn',
 };
-
 /** Character set for the optional modulo-43 check digit; '*' is excluded. */
 export const CODE39_CHECK_SET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%';
-
 /** Two-character escapes giving Code 39 the full ASCII range. */
 export const CODE39_EXTENDED = (() => {
-  const map = new Array(128);
-  const upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-  for (let i = 0; i < 26; i++) {
-    map[i + 1] = '$' + upper[i];               // SOH..SUB
-    map[i + 65] = upper[i];                    // A-Z
-    map[i + 97] = '+' + upper[i];              // a-z
-  }
-  for (let i = 0; i < 10; i++) map[i + 48] = String(i);
-  map[0] = '%U';
-  for (let i = 27; i <= 31; i++) map[i] = '%' + upper[i - 27 + 0]; // ESC..US -> %A..%E
-  const symbols = {
-    32: ' ', 33: '/A', 34: '/B', 35: '/C', 36: '/D', 37: '/E', 38: '/F',
-    39: '/G', 40: '/H', 41: '/I', 42: '/J', 43: '/K', 44: '/L', 45: '-',
-    46: '.', 47: '/O', 58: '/Z', 59: '%F', 60: '%G', 61: '%H', 62: '%I',
-    63: '%J', 64: '%V', 91: '%K', 92: '%L', 93: '%M', 94: '%N', 95: '%O',
-    96: '%W', 123: '%P', 124: '%Q', 125: '%R', 126: '%S', 127: '%T',
-  };
-  for (const [code, seq] of Object.entries(symbols)) map[Number(code)] = seq;
-  return map;
+    const map = new Array(128);
+    const upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    for (let i = 0; i < 26; i++) {
+        map[i + 1] = '$' + upper[i]; // SOH..SUB
+        map[i + 65] = upper[i]; // A-Z
+        map[i + 97] = '+' + upper[i]; // a-z
+    }
+    for (let i = 0; i < 10; i++)
+        map[i + 48] = String(i);
+    map[0] = '%U';
+    for (let i = 27; i <= 31; i++)
+        map[i] = '%' + upper[i - 27 + 0]; // ESC..US -> %A..%E
+    const symbols = {
+        32: ' ', 33: '/A', 34: '/B', 35: '/C', 36: '/D', 37: '/E', 38: '/F',
+        39: '/G', 40: '/H', 41: '/I', 42: '/J', 43: '/K', 44: '/L', 45: '-',
+        46: '.', 47: '/O', 58: '/Z', 59: '%F', 60: '%G', 61: '%H', 62: '%I',
+        63: '%J', 64: '%V', 91: '%K', 92: '%L', 93: '%M', 94: '%N', 95: '%O',
+        96: '%W', 123: '%P', 124: '%Q', 125: '%R', 126: '%S', 127: '%T',
+    };
+    for (const [code, seq] of Object.entries(symbols))
+        map[Number(code)] = seq;
+    return map;
 })();
-
 /* ------------------------------------------------------------------ *
  * Code 93
  * ------------------------------------------------------------------ */
-
 /** Nine modules per character across six elements. */
 export const CODE93 = {
-  '0': '131112', '1': '111213', '2': '111312', '3': '111411', '4': '121113',
-  '5': '121212', '6': '121311', '7': '111114', '8': '131211', '9': '141111',
-  'A': '211113', 'B': '211212', 'C': '211311', 'D': '221112', 'E': '221211',
-  'F': '231111', 'G': '112113', 'H': '112212', 'I': '112311', 'J': '122112',
-  'K': '132111', 'L': '111123', 'M': '111222', 'N': '111321', 'O': '121122',
-  'P': '131121', 'Q': '212112', 'R': '212211', 'S': '211122', 'T': '211221',
-  'U': '221121', 'V': '222111', 'W': '112122', 'X': '112221', 'Y': '122121',
-  'Z': '123111', '-': '121131', '.': '311112', ' ': '311211', '$': '321111',
-  '/': '112131', '+': '113121', '%': '211131',
-  // The four shift characters. Their conventional names -- ($) (%) (/) (+) --
-  // collide with the literal single-character entries above, so they take
-  // distinct multi-character keys. Writing the bare symbols here would create
-  // duplicate object keys, which JavaScript collapses silently: the table
-  // would end up three entries short, with no error raised anywhere.
-  'S$': '121221',
-  'S%': '312111',
-  'S/': '311121',
-  'S+': '122211',
+    '0': '131112', '1': '111213', '2': '111312', '3': '111411', '4': '121113',
+    '5': '121212', '6': '121311', '7': '111114', '8': '131211', '9': '141111',
+    'A': '211113', 'B': '211212', 'C': '211311', 'D': '221112', 'E': '221211',
+    'F': '231111', 'G': '112113', 'H': '112212', 'I': '112311', 'J': '122112',
+    'K': '132111', 'L': '111123', 'M': '111222', 'N': '111321', 'O': '121122',
+    'P': '131121', 'Q': '212112', 'R': '212211', 'S': '211122', 'T': '211221',
+    'U': '221121', 'V': '222111', 'W': '112122', 'X': '112221', 'Y': '122121',
+    'Z': '123111', '-': '121131', '.': '311112', ' ': '311211', '$': '321111',
+    '/': '112131', '+': '113121', '%': '211131',
+    // The four shift characters. Their conventional names -- ($) (%) (/) (+) --
+    // collide with the literal single-character entries above, so they take
+    // distinct multi-character keys. Writing the bare symbols here would create
+    // duplicate object keys, which JavaScript collapses silently: the table
+    // would end up three entries short, with no error raised anywhere.
+    'S$': '121221',
+    'S%': '312111',
+    'S/': '311121',
+    'S+': '122211',
 };
-
 /**
  * Symbol values 0..46 in order, as keys into {@link CODE93}. An array rather
  * than a string, because the four shift characters have multi-character keys.
  */
 export const CODE93_VALUES = [
-  ...'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%',
-  'S$', 'S%', 'S/', 'S+',
+    ...'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%',
+    'S$', 'S%', 'S/', 'S+',
 ];
-
 export const CODE93_START_STOP = '111141';
-
 /* ------------------------------------------------------------------ *
  * Code 128
  * ------------------------------------------------------------------ */
-
 /**
  * All 107 symbol patterns. Eleven modules each across six elements; the stop
  * pattern is the sole exception at thirteen modules across seven.
@@ -185,24 +170,23 @@ export const CODE93_START_STOP = '111141';
  * pattern breaks the sum.
  */
 export const CODE128 = [
-  '212222', '222122', '222221', '121223', '121322', '131222', '122213',
-  '122312', '132212', '221213', '221312', '231212', '112232', '122132',
-  '122231', '113222', '123122', '123221', '223211', '221132', '221231',
-  '213212', '223112', '312131', '311222', '321122', '321221', '312212',
-  '322112', '322211', '212123', '212321', '232121', '111323', '131123',
-  '131321', '112313', '132113', '132311', '211313', '231113', '231311',
-  '112133', '112331', '132131', '113123', '113321', '133121', '313121',
-  '211331', '231131', '213113', '213311', '213131', '311123', '311321',
-  '331121', '312113', '312311', '332111', '314111', '221411', '431111',
-  '111224', '111422', '121124', '121421', '141122', '141221', '112214',
-  '112412', '122114', '122411', '142112', '142211', '241211', '221114',
-  '413111', '241112', '134111', '111242', '121142', '121241', '114212',
-  '124112', '124211', '411212', '421112', '421211', '212141', '214121',
-  '412121', '111143', '111341', '131141', '114113', '114311', '411113',
-  '411311', '113141', '114131', '311141', '411131', '211412', '211214',
-  '211232', '2331112',
+    '212222', '222122', '222221', '121223', '121322', '131222', '122213',
+    '122312', '132212', '221213', '221312', '231212', '112232', '122132',
+    '122231', '113222', '123122', '123221', '223211', '221132', '221231',
+    '213212', '223112', '312131', '311222', '321122', '321221', '312212',
+    '322112', '322211', '212123', '212321', '232121', '111323', '131123',
+    '131321', '112313', '132113', '132311', '211313', '231113', '231311',
+    '112133', '112331', '132131', '113123', '113321', '133121', '313121',
+    '211331', '231131', '213113', '213311', '213131', '311123', '311321',
+    '331121', '312113', '312311', '332111', '314111', '221411', '431111',
+    '111224', '111422', '121124', '121421', '141122', '141221', '112214',
+    '112412', '122114', '122411', '142112', '142211', '241211', '221114',
+    '413111', '241112', '134111', '111242', '121142', '121241', '114212',
+    '124112', '124211', '411212', '421112', '421211', '212141', '214121',
+    '412121', '111143', '111341', '131141', '114113', '114311', '411113',
+    '411311', '113141', '114131', '311141', '411131', '211412', '211214',
+    '211232', '2331112',
 ];
-
 export const CODE128_START_A = 103;
 export const CODE128_START_B = 104;
 export const CODE128_START_C = 105;
@@ -216,58 +200,46 @@ export const CODE128_SHIFT = 98;
 export const CODE128_CODE_A = 101;
 export const CODE128_CODE_B = 100;
 export const CODE128_CODE_C = 99;
-
 /* ------------------------------------------------------------------ *
  * Interleaved 2 of 5
  * ------------------------------------------------------------------ */
-
 /** Five elements per digit, exactly two of them wide. */
 export const ITF = [
-  'nnwwn', 'wnnnw', 'nwnnw', 'wwnnn', 'nnwnw',
-  'wnwnn', 'nwwnn', 'nnnww', 'wnnwn', 'nwnwn',
+    'nnwwn', 'wnnnw', 'nwnnw', 'wwnnn', 'nnwnw',
+    'wnwnn', 'nwwnn', 'nnnww', 'wnnwn', 'nwnwn',
 ];
-
 /* ------------------------------------------------------------------ *
  * Codabar
  * ------------------------------------------------------------------ */
-
 /** Seven elements per character. */
 export const CODABAR = {
-  '0': 'nnnnnww', '1': 'nnnnwwn', '2': 'nnnwnnw', '3': 'wwnnnnn',
-  '4': 'nnwnnwn', '5': 'wnnnnwn', '6': 'nwnnnnw', '7': 'nwnnwnn',
-  '8': 'nwwnnnn', '9': 'wnnwnnn', '-': 'nnnwwnn', '$': 'nnwwnnn',
-  ':': 'wnnnwnw', '/': 'wnwnnnw', '.': 'wnwnwnn', '+': 'nnwnwnw',
-  'A': 'nnwwnwn', 'B': 'nwnwnnw', 'C': 'nnnwnww', 'D': 'nnnwwwn',
+    '0': 'nnnnnww', '1': 'nnnnwwn', '2': 'nnnwnnw', '3': 'wwnnnnn',
+    '4': 'nnwnnwn', '5': 'wnnnnwn', '6': 'nwnnnnw', '7': 'nwnnwnn',
+    '8': 'nwwnnnn', '9': 'wnnwnnn', '-': 'nnnwwnn', '$': 'nnwwnnn',
+    ':': 'wnnnwnw', '/': 'wnwnnnw', '.': 'wnwnwnn', '+': 'nnwnwnw',
+    'A': 'nnwwnwn', 'B': 'nwnwnnw', 'C': 'nnnwnww', 'D': 'nnnwwwn',
 };
-
 export const CODABAR_START_STOP = 'ABCD';
-
 /* ------------------------------------------------------------------ *
  * Code 11
  * ------------------------------------------------------------------ */
-
 /** Five elements per character, one or two of them wide. */
 export const CODE11 = {
-  '0': 'nnnnw', '1': 'wnnnw', '2': 'nwnnw', '3': 'wwnnn', '4': 'nnwnw',
-  '5': 'wnwnn', '6': 'nwwnn', '7': 'nnnww', '8': 'wnnwn', '9': 'wnnnn',
-  '-': 'nnwnn',
+    '0': 'nnnnw', '1': 'wnnnw', '2': 'nwnnw', '3': 'wwnnn', '4': 'nnwnw',
+    '5': 'wnwnn', '6': 'nwwnn', '7': 'nnnww', '8': 'wnnwn', '9': 'wnnnn',
+    '-': 'nnwnn',
 };
-
 export const CODE11_START_STOP = 'nnwwn';
-
 /* ------------------------------------------------------------------ *
  * MSI / Plessey
  * ------------------------------------------------------------------ */
-
 /** Each bit of a digit becomes a bar pair: 1 is wide-then-narrow, 0 the reverse. */
 export const MSI_BIT = { 0: '100', 1: '110' };
 export const MSI_START = '110';
 export const MSI_STOP = '1001';
-
 /* ------------------------------------------------------------------ *
  * Structural validation
  * ------------------------------------------------------------------ */
-
 /**
  * Assert every invariant these tables are supposed to satisfy.
  *
@@ -278,107 +250,116 @@ export const MSI_STOP = '1001';
  * @returns {string[]} Problems found; empty means all invariants hold.
  */
 export function validateTables() {
-  const problems = [];
-  const sum = (s) => [...s].reduce((a, c) => a + Number(c), 0);
-  const countWide = (s) => [...s].filter((c) => c === 'w').length;
-
-  // --- EAN/UPC: 7 modules per digit; L odd parity; R the complement of L;
-  // G the reverse of R. All 30 patterns distinct.
-  for (let d = 0; d < 10; d++) {
-    for (const [name, table] of [['L', EAN_L], ['G', EAN_G], ['R', EAN_R]]) {
-      if (table[d].length !== 7) problems.push(`EAN ${name}${d}: ${table[d].length} modules, expected 7`);
+    const problems = [];
+    const sum = (s) => [...s].reduce((a, c) => a + Number(c), 0);
+    const countWide = (s) => [...s].filter((c) => c === 'w').length;
+    // --- EAN/UPC: 7 modules per digit; L odd parity; R the complement of L;
+    // G the reverse of R. All 30 patterns distinct.
+    for (let d = 0; d < 10; d++) {
+        for (const [name, table] of [['L', EAN_L], ['G', EAN_G], ['R', EAN_R]]) {
+            if (table[d].length !== 7)
+                problems.push(`EAN ${name}${d}: ${table[d].length} modules, expected 7`);
+        }
+        const darkL = [...EAN_L[d]].filter((c) => c === '1').length;
+        if (darkL % 2 === 0)
+            problems.push(`EAN L${d}: even parity, expected odd`);
+        const darkG = [...EAN_G[d]].filter((c) => c === '1').length;
+        if (darkG % 2 !== 0)
+            problems.push(`EAN G${d}: odd parity, expected even`);
+        if (EAN_L[d][0] !== '0' || EAN_L[d][6] !== '1') {
+            problems.push(`EAN L${d}: must start with a space and end with a bar`);
+        }
+    }
+    const eanAll = new Set([...EAN_L, ...EAN_G, ...EAN_R]);
+    if (eanAll.size !== 30)
+        problems.push(`EAN: ${eanAll.size} distinct patterns, expected 30`);
+    // --- EAN-13 parity: first row all-L, every row six characters, all distinct.
+    if (EAN13_PARITY[0] !== 'LLLLLL')
+        problems.push('EAN-13 parity[0] must be LLLLLL');
+    if (new Set(EAN13_PARITY).size !== 10)
+        problems.push('EAN-13 parity rows are not distinct');
+    for (const [i, row] of EAN13_PARITY.entries()) {
+        if (row.length !== 6)
+            problems.push(`EAN-13 parity[${i}]: ${row.length} entries, expected 6`);
+    }
+    // --- Code 39: nine elements, exactly three wide, all patterns distinct.
+    for (const [ch, p] of Object.entries(CODE39)) {
+        if (p.length !== 9)
+            problems.push(`Code39 '${ch}': ${p.length} elements, expected 9`);
+        if (countWide(p) !== 3)
+            problems.push(`Code39 '${ch}': ${countWide(p)} wide, expected 3`);
+    }
+    if (new Set(Object.values(CODE39)).size !== Object.keys(CODE39).length) {
+        problems.push('Code39: duplicate patterns');
+    }
+    if (CODE39_CHECK_SET.length !== 43) {
+        problems.push(`Code39 check set: ${CODE39_CHECK_SET.length} characters, expected 43`);
+    }
+    // --- Code 93: nine modules across six elements, all patterns distinct.
+    for (const [ch, p] of Object.entries(CODE93)) {
+        if (p.length !== 6)
+            problems.push(`Code93 '${ch}': ${p.length} elements, expected 6`);
+        if (sum(p) !== 9)
+            problems.push(`Code93 '${ch}': ${sum(p)} modules, expected 9`);
+    }
+    if (new Set(Object.values(CODE93)).size !== Object.keys(CODE93).length) {
+        problems.push('Code93: duplicate patterns');
+    }
+    if (CODE93_VALUES.length !== 47) {
+        problems.push(`Code93 values: ${CODE93_VALUES.length}, expected 47`);
+    }
+    if (Object.keys(CODE93).length !== 47) {
+        problems.push(`Code93 table: ${Object.keys(CODE93).length} entries, expected 47 ` +
+            '(duplicate object keys collapse silently — check the shift characters)');
+    }
+    if (new Set(CODE93_VALUES).size !== CODE93_VALUES.length) {
+        problems.push('Code93: duplicate entries in the value order');
+    }
+    for (const ch of CODE93_VALUES) {
+        if (!CODE93[ch])
+            problems.push(`Code93: value character '${ch}' has no pattern`);
+    }
+    // --- Code 128: 107 patterns, 11 modules each, stop 13. All distinct.
+    if (CODE128.length !== 107) {
+        problems.push(`Code128: ${CODE128.length} patterns, expected 107`);
+    }
+    for (const [i, p] of CODE128.entries()) {
+        const expected = i === CODE128_STOP ? 13 : 11;
+        const elements = i === CODE128_STOP ? 7 : 6;
+        if (sum(p) !== expected)
+            problems.push(`Code128 [${i}] "${p}": ${sum(p)} modules, expected ${expected}`);
+        if (p.length !== elements)
+            problems.push(`Code128 [${i}] "${p}": ${p.length} elements, expected ${elements}`);
+        if ([...p].some((c) => c === '0' || Number(c) > 4)) {
+            problems.push(`Code128 [${i}] "${p}": element width out of range 1-4`);
+        }
+    }
+    if (new Set(CODE128).size !== CODE128.length)
+        problems.push('Code128: duplicate patterns');
+    // --- ITF: five elements, exactly two wide, ten distinct patterns.
+    for (const [d, p] of ITF.entries()) {
+        if (p.length !== 5)
+            problems.push(`ITF ${d}: ${p.length} elements, expected 5`);
+        if (countWide(p) !== 2)
+            problems.push(`ITF ${d}: ${countWide(p)} wide, expected 2`);
+    }
+    if (new Set(ITF).size !== 10)
+        problems.push('ITF: duplicate patterns');
+    // --- Codabar: seven elements, all distinct.
+    for (const [ch, p] of Object.entries(CODABAR)) {
+        if (p.length !== 7)
+            problems.push(`Codabar '${ch}': ${p.length} elements, expected 7`);
+    }
+    if (new Set(Object.values(CODABAR)).size !== Object.keys(CODABAR).length) {
+        problems.push('Codabar: duplicate patterns');
     }
-    const darkL = [...EAN_L[d]].filter((c) => c === '1').length;
-    if (darkL % 2 === 0) problems.push(`EAN L${d}: even parity, expected odd`);
-    const darkG = [...EAN_G[d]].filter((c) => c === '1').length;
-    if (darkG % 2 !== 0) problems.push(`EAN G${d}: odd parity, expected even`);
-    if (EAN_L[d][0] !== '0' || EAN_L[d][6] !== '1') {
-      problems.push(`EAN L${d}: must start with a space and end with a bar`);
+    // --- Code 11: five elements, all distinct.
+    for (const [ch, p] of Object.entries(CODE11)) {
+        if (p.length !== 5)
+            problems.push(`Code11 '${ch}': ${p.length} elements, expected 5`);
     }
-  }
-  const eanAll = new Set([...EAN_L, ...EAN_G, ...EAN_R]);
-  if (eanAll.size !== 30) problems.push(`EAN: ${eanAll.size} distinct patterns, expected 30`);
-
-  // --- EAN-13 parity: first row all-L, every row six characters, all distinct.
-  if (EAN13_PARITY[0] !== 'LLLLLL') problems.push('EAN-13 parity[0] must be LLLLLL');
-  if (new Set(EAN13_PARITY).size !== 10) problems.push('EAN-13 parity rows are not distinct');
-  for (const [i, row] of EAN13_PARITY.entries()) {
-    if (row.length !== 6) problems.push(`EAN-13 parity[${i}]: ${row.length} entries, expected 6`);
-  }
-
-  // --- Code 39: nine elements, exactly three wide, all patterns distinct.
-  for (const [ch, p] of Object.entries(CODE39)) {
-    if (p.length !== 9) problems.push(`Code39 '${ch}': ${p.length} elements, expected 9`);
-    if (countWide(p) !== 3) problems.push(`Code39 '${ch}': ${countWide(p)} wide, expected 3`);
-  }
-  if (new Set(Object.values(CODE39)).size !== Object.keys(CODE39).length) {
-    problems.push('Code39: duplicate patterns');
-  }
-  if (CODE39_CHECK_SET.length !== 43) {
-    problems.push(`Code39 check set: ${CODE39_CHECK_SET.length} characters, expected 43`);
-  }
-
-  // --- Code 93: nine modules across six elements, all patterns distinct.
-  for (const [ch, p] of Object.entries(CODE93)) {
-    if (p.length !== 6) problems.push(`Code93 '${ch}': ${p.length} elements, expected 6`);
-    if (sum(p) !== 9) problems.push(`Code93 '${ch}': ${sum(p)} modules, expected 9`);
-  }
-  if (new Set(Object.values(CODE93)).size !== Object.keys(CODE93).length) {
-    problems.push('Code93: duplicate patterns');
-  }
-  if (CODE93_VALUES.length !== 47) {
-    problems.push(`Code93 values: ${CODE93_VALUES.length}, expected 47`);
-  }
-  if (Object.keys(CODE93).length !== 47) {
-    problems.push(
-      `Code93 table: ${Object.keys(CODE93).length} entries, expected 47 ` +
-      '(duplicate object keys collapse silently — check the shift characters)'
-    );
-  }
-  if (new Set(CODE93_VALUES).size !== CODE93_VALUES.length) {
-    problems.push('Code93: duplicate entries in the value order');
-  }
-  for (const ch of CODE93_VALUES) {
-    if (!CODE93[ch]) problems.push(`Code93: value character '${ch}' has no pattern`);
-  }
-
-  // --- Code 128: 107 patterns, 11 modules each, stop 13. All distinct.
-  if (CODE128.length !== 107) {
-    problems.push(`Code128: ${CODE128.length} patterns, expected 107`);
-  }
-  for (const [i, p] of CODE128.entries()) {
-    const expected = i === CODE128_STOP ? 13 : 11;
-    const elements = i === CODE128_STOP ? 7 : 6;
-    if (sum(p) !== expected) problems.push(`Code128 [${i}] "${p}": ${sum(p)} modules, expected ${expected}`);
-    if (p.length !== elements) problems.push(`Code128 [${i}] "${p}": ${p.length} elements, expected ${elements}`);
-    if ([...p].some((c) => c === '0' || Number(c) > 4)) {
-      problems.push(`Code128 [${i}] "${p}": element width out of range 1-4`);
+    if (new Set(Object.values(CODE11)).size !== Object.keys(CODE11).length) {
+        problems.push('Code11: duplicate patterns');
     }
-  }
-  if (new Set(CODE128).size !== CODE128.length) problems.push('Code128: duplicate patterns');
-
-  // --- ITF: five elements, exactly two wide, ten distinct patterns.
-  for (const [d, p] of ITF.entries()) {
-    if (p.length !== 5) problems.push(`ITF ${d}: ${p.length} elements, expected 5`);
-    if (countWide(p) !== 2) problems.push(`ITF ${d}: ${countWide(p)} wide, expected 2`);
-  }
-  if (new Set(ITF).size !== 10) problems.push('ITF: duplicate patterns');
-
-  // --- Codabar: seven elements, all distinct.
-  for (const [ch, p] of Object.entries(CODABAR)) {
-    if (p.length !== 7) problems.push(`Codabar '${ch}': ${p.length} elements, expected 7`);
-  }
-  if (new Set(Object.values(CODABAR)).size !== Object.keys(CODABAR).length) {
-    problems.push('Codabar: duplicate patterns');
-  }
-
-  // --- Code 11: five elements, all distinct.
-  for (const [ch, p] of Object.entries(CODE11)) {
-    if (p.length !== 5) problems.push(`Code11 '${ch}': ${p.length} elements, expected 5`);
-  }
-  if (new Set(Object.values(CODE11)).size !== Object.keys(CODE11).length) {
-    problems.push('Code11: duplicate patterns');
-  }
-
-  return problems;
+    return problems;
 }