@sythos/js_barcode_universal 1.5.13 → 1.5.15

package/src/ts/oned/telepen.ts

@@ -0,0 +1,368 @@
+/*!
+ * 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.
+ */
+
+/**
+ * Telepen Alpha and Telepen Numeric.
+ *
+ * Telepen does not assign an arbitrary glyph table to each character. It emits
+ * the seven-bit ASCII value with an even parity bit, least-significant bit
+ * first, and maps the resulting bit stream to narrow/wide bar-space pairs.
+ * Keeping that mapping algorithmic makes the implementation auditable and
+ * avoids shipping a copied third-party pattern table.
+ *
+ * @module oned/telepen
+ */
+
+import { BitMatrix } from '../core/bit-matrix.js';
+import { EncodeError } from '../core/errors.js';
+
+export const TELEPEN_START_VALUE = 0x5f;
+export const TELEPEN_STOP_VALUE = 0x7a;
+export const TELEPEN_MAX_LENGTH = 500;
+
+/** @param {number} value @returns {string} Run widths for one 16-module glyph. */
+export function telepenPattern(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 127) {
+    throw new RangeError(`Telepen character value must be in 0..127, got ${value}`);
+  }
+
+  // Telepen carries seven-bit ASCII plus an even parity bit in the eighth
+  // position. The stream is transmitted least-significant bit first.
+  const bits = new Array(8).fill(0);
+  let ones = 0;
+  for (let bit = 0; bit < 7; bit++) {
+    bits[bit] = (value >>> bit) & 1;
+    ones += bits[bit];
+  }
+  bits[7] = ones & 1;
+
+  // The four legal bar/space pairs encode the bit stream without changing the
+  // fixed 16-module character width:
+  //   1    -> narrow bar, narrow space (11)
+  //   00   -> wide bar, narrow space   (31)
+  //   010  -> wide bar, wide space     (33)
+  //   01/10 edges -> narrow bar, wide space (13)
+  let widths = '';
+  let index = 0;
+  while (index < bits.length) {
+    if (bits[index] === 1) {
+      widths += '11';
+      index++;
+      continue;
+    }
+
+    let end = index + 1;
+    while (end < bits.length && bits[end] === 1) end++;
+
+    if (end === index + 1) {
+      widths += '31';
+      index += 2;
+    } else if (end === index + 2) {
+      widths += '33';
+      index += 3;
+    } else if (end < bits.length) {
+      // A block 0 1* 0 longer than 010 has 01 and 10 edges. Any
+      // one-bits between those edges remain single-bit pairs.
+      widths += '13';
+      widths += '11'.repeat(Math.max(0, end - index - 3));
+      widths += '13';
+      index = end + 1;
+    } else {
+      // A final 0 1* block has no trailing zero. The final light element is
+      // implied by the following character or quiet zone.
+      widths += '13';
+      widths += '11'.repeat(Math.max(0, end - index - 2));
+      index = end;
+    }
+  }
+
+  return widths;
+}
+
+/** @param {string} widths @returns {number} */
+function widthTotal(widths) {
+  let total = 0;
+  for (const width of widths) total += Number(width);
+  return total;
+}
+
+/** @param {string} widths @returns {BitMatrix} */
+function widthsToMatrix(widths) {
+  const matrix = new BitMatrix(widthTotal(widths), 1);
+  let dark = true;
+  let x = 0;
+  for (const width of widths) {
+    const count = Number(width);
+    if (dark) matrix.setRegion(x, 0, count, 1);
+    x += count;
+    dark = !dark;
+  }
+  return matrix;
+}
+
+/** @param {string} value @returns {number} */
+function telepenChecksum(value) {
+  let sum = 0;
+  for (const character of value) sum = (sum + character.charCodeAt(0)) % 127;
+  return (127 - sum) % 127;
+}
+
+/** @param {string} value @returns {number[]} */
+function numericGlyphs(value) {
+  if (value.length % 2 !== 0) {
+    throw new EncodeError('Telepen Numeric: payload must contain an even number of characters');
+  }
+
+  const glyphs = [];
+  for (let index = 0; index < value.length; index += 2) {
+    const first = value[index];
+    const second = value[index + 1];
+    if (!/[0-9]/.test(first) || !/[0-9X]/.test(second)) {
+      throw new EncodeError(
+        'Telepen Numeric: pairs must contain digits, with X allowed only in the second position',
+      );
+    }
+    const firstDigit = Number(first);
+    glyphs.push(second === 'X'
+      ? firstDigit + 17
+      : firstDigit * 10 + Number(second) + 27);
+  }
+  return glyphs;
+}
+
+/**
+ * Encode Telepen Alpha (full seven-bit ASCII) or Telepen Numeric.
+ *
+ * @param {string} value
+ * @param {object} [options]
+ * @param {boolean} [options.numeric] Use two-digit numeric compaction.
+ * @returns {BitMatrix}
+ */
+export function encodeTelepen(value, options = {}) {
+  const text = String(value);
+  const numeric = options.numeric === true || options.mode === 'numeric' || options.telepenMode === 'numeric';
+  if (text.length > TELEPEN_MAX_LENGTH) {
+    throw new EncodeError(`Telepen: payload is limited to ${TELEPEN_MAX_LENGTH} characters`);
+  }
+
+  const glyphs = [TELEPEN_START_VALUE];
+  if (numeric) {
+    const compacted = numericGlyphs(text);
+    glyphs.push(...compacted);
+    const checksumValue = compacted.reduce((sum, glyph) => (sum + glyph) % 127, 0);
+    glyphs.push((127 - checksumValue) % 127);
+  } else {
+    for (const character of text) {
+      const code = character.charCodeAt(0);
+      if (code > 127) {
+        throw new EncodeError(`Telepen: character U+${code.toString(16).toUpperCase()} is outside ASCII`);
+      }
+      glyphs.push(code);
+    }
+    glyphs.push(telepenChecksum(text));
+  }
+  glyphs.push(TELEPEN_STOP_VALUE);
+
+  return widthsToMatrix(glyphs.map(telepenPattern).join(''));
+}
+
+/** Encode Telepen Numeric explicitly. @param {string} value @returns {BitMatrix} */
+export function encodeTelepenNumeric(value) {
+  return encodeTelepen(value, { numeric: true });
+}
+
+const TELEPEN_RUNS = Array.from({ length: 128 }, (_, value) =>
+  telepenPattern(value).split('').map(Number)
+);
+const START_RUNS = TELEPEN_RUNS[TELEPEN_START_VALUE];
+const STOP_RUNS = TELEPEN_RUNS[TELEPEN_STOP_VALUE];
+
+/** @param {Uint8Array} row @param {number} start @param {number} count */
+function measureRuns(row, start, count) {
+  if (start < 0 || start >= row.length || row[start] !== 1) return null;
+  const counters = new Array(count).fill(0);
+  let run = 0;
+  let dark = true;
+  let index = start;
+  while (index < row.length) {
+    const pixelDark = row[index] === 1;
+    if (pixelDark === dark) {
+      counters[run]++;
+      index++;
+      continue;
+    }
+    run++;
+    if (run === count) break;
+    dark = !dark;
+    counters[run] = 1;
+    index++;
+  }
+  if (run < count - 1 || counters[count - 1] === 0) return null;
+  return { counters, end: index };
+}
+
+/** @param {number[]} counters @param {number[]} expected @param {number} [ignoredTail] */
+function runVariance(counters, expected, ignoredTail = 0) {
+  const total = counters.reduce((sum, width) => sum + width, 0);
+  const expectedTotal = expected.reduce((sum, width) => sum + width, 0);
+  const compared = expected.length - ignoredTail;
+  const comparedTotal = expected
+    .slice(0, compared)
+    .reduce((sum, width) => sum + width, 0);
+  const measuredCompared = counters
+    .slice(0, compared)
+    .reduce((sum, width) => sum + width, 0);
+  if (total <= 0 || expectedTotal <= 0 || measuredCompared <= 0) return Infinity;
+
+  // For normal glyphs all sixteen modules participate. Stop's final light
+  // run includes the quiet zone, so its first eleven runs establish scale.
+  const unit = ignoredTail > 0 ? measuredCompared / comparedTotal : total / expectedTotal;
+  const limit = unit * 0.85;
+  let variance = 0;
+  for (let index = 0; index < compared; index++) {
+    const delta = Math.abs(counters[index] - expected[index] * unit);
+    if (delta > limit) return Infinity;
+    variance += delta;
+  }
+  return variance / Math.max(1, measuredCompared);
+}
+
+/** @param {Uint8Array} row @param {number} start @param {number[]} expected */
+function matchGlyph(row, start, expected) {
+  const measured = measureRuns(row, start, expected.length);
+  if (!measured) return null;
+  const score = runVariance(measured.counters, expected);
+  if (!Number.isFinite(score) || measured.end >= row.length) return null;
+  return { score, end: measured.end };
+}
+
+/** @param {Uint8Array} row @param {number} start */
+function matchStop(row, start) {
+  const measured = measureRuns(row, start, STOP_RUNS.length);
+  if (!measured) return null;
+  const score = runVariance(measured.counters, STOP_RUNS, 1);
+  if (!Number.isFinite(score)) return null;
+  for (let index = measured.end; index < row.length; index++) {
+    if (row[index] === 1) return { score, end: measured.end, terminal: false };
+  }
+  return { score, end: measured.end, terminal: true };
+}
+
+/** @param {Uint8Array} row @param {number} start @param {number[]} expected */
+function findStart(row, start, expected) {
+  for (let index = Math.max(0, start); index < row.length; index++) {
+    if (row[index] !== 1 || (index > 0 && row[index - 1] === 1)) continue;
+    const measured = measureRuns(row, index, expected.length);
+    if (!measured) continue;
+    const score = runVariance(measured.counters, expected);
+    if (Number.isFinite(score) && measured.end < row.length) {
+      return { end: measured.end, score };
+    }
+  }
+  return null;
+}
+
+/** @param {number[]} glyphs @returns {boolean} */
+function validChecksum(glyphs) {
+  if (glyphs.length < 1) return false;
+  const checksum = glyphs[glyphs.length - 1];
+  const payload = glyphs.slice(0, -1);
+  const sum = payload.reduce((total, value) => (total + value) % 127, 0);
+  return checksum === (127 - sum) % 127;
+}
+
+/** @param {number[]} glyphs @returns {string|null} */
+function decodeNumericGlyphs(glyphs) {
+  let text = '';
+  for (const glyph of glyphs) {
+    if (glyph >= 17 && glyph <= 26) {
+      text += `${glyph - 17}X`;
+    } else if (glyph >= 27 && glyph <= 126) {
+      text += String(glyph - 27).padStart(2, '0');
+    } else {
+      return null;
+    }
+  }
+  return text;
+}
+
+/**
+ * Decode a Telepen scanline. The row must be binarized (1 = dark).
+ *
+ * @param {Uint8Array} row
+ * @param {object} [options]
+ * @param {boolean} [options.numeric] Decode two-digit numeric glyphs.
+ * @returns {{format:'telepen'|'telepennumeric', text:string, mode:'ascii'|'numeric'}|null}
+ */
+export function decodeTelepen(row, options = {}) {
+  const numeric = options.numeric === true || options.mode === 'numeric' || options.telepenMode === 'numeric';
+  const start = findStart(row, 0, START_RUNS);
+  if (!start) return null;
+
+  const glyphs = [];
+  let offset = start.end;
+  for (let count = 0; count <= TELEPEN_MAX_LENGTH + 1; count++) {
+    const stop = matchStop(row, offset);
+    if (stop?.terminal) {
+      if (!validChecksum(glyphs)) return null;
+      glyphs.pop();
+      if (numeric) {
+        const text = decodeNumericGlyphs(glyphs);
+        return text === null ? null : { format: 'telepennumeric', text, mode: 'numeric' };
+      }
+      return {
+        format: 'telepen',
+        text: glyphs.map((value) => String.fromCharCode(value)).join(''),
+        mode: 'ascii',
+      };
+    }
+
+    const candidates = [];
+    for (let value = 0; value < TELEPEN_RUNS.length; value++) {
+      const match = matchGlyph(row, offset, TELEPEN_RUNS[value]);
+      if (match) candidates.push({ value, ...match });
+    }
+    if (candidates.length === 0) return null;
+    candidates.sort((a, b) => a.score - b.score);
+    const best = candidates[0];
+    const second = candidates[1];
+    // A close tie is an ambiguous optical measurement. Returning nothing is
+    // safer than guessing a character that merely has a similar run profile.
+    if (second && second.score - best.score < 0.035) return null;
+    glyphs.push(best.value);
+    offset = best.end;
+  }
+  return null;
+}
+
+/** Decode Telepen Numeric explicitly. @param {Uint8Array} row */
+export function decodeTelepenNumeric(row) {
+  return decodeTelepen(row, { numeric: true });
+}

package/src/ts/oned/writers.d.ts

@@ -142,6 +142,18 @@ export declare function encodeCode93(value: string): BitMatrix;
 export declare function encodeCode128(value: string, options?: {
     gs1?: boolean;
 }): BitMatrix;
+/**
+ * Build the Code 128 data stream used by Code 128 and stacked Code 128
+ * symbologies, without a checksum or stop symbol.
+ */
+export declare function code128DataCodewords(value: string, options?: {
+    gs1?: boolean;
+    startSet?: 'A' | 'B' | 'C';
+}): {
+    start: number;
+    values: number[];
+    mode: 'A' | 'B' | 'C';
+};
 /**
  * Interleaved 2 of 5.
  *
@@ -216,3 +228,23 @@ export declare function encodeMSI(value: string, options?: {
  * @returns {BitMatrix}
  */
 export declare function encodePharmacode(value: number | string): BitMatrix;
+/** Italian Code 32 check digit for an eight-digit body. */
+export declare function code32CheckDigit(value: string): number;
+/** Encode an Italian Code 32 pharmaceutical identifier. */
+export declare function encodeCode32(value: string): BitMatrix;
+/** Decode and validate a six-character Code 32 payload. */
+export declare function decodeCode32Payload(text: string): {
+    text: string;
+    checkDigit: number;
+} | null;
+/** Encode a PZN-7 or PZN-8 pharmaceutical identifier through Code 39. */
+export declare function encodePZN(value: string, options?: {
+    pzn8?: boolean;
+    variant?: 'pzn7' | 'pzn8';
+}): BitMatrix;
+/** Decode and validate a PZN Code 39 payload. */
+export declare function decodePZNPayload(text: string): {
+    text: string;
+    variant: 'pzn7' | 'pzn8';
+    checkDigit: number;
+} | null;

package/src/ts/oned/writers.ts

@@ -46,7 +46,7 @@ import {
   EAN_START_END, EAN_MIDDLE, UPCE_END,
   CODE39, CODE39_CHECK_SET, CODE39_EXTENDED,
   CODE93, CODE93_VALUES, CODE93_START_STOP,
-  CODE128, CODE128_START_B, CODE128_START_C,
+  CODE128, CODE128_START_A, CODE128_START_B, CODE128_START_C,
   CODE128_STOP, CODE128_FNC1, CODE128_CODE_A, CODE128_CODE_B, CODE128_CODE_C,
   ITF, CODABAR, CODABAR_START_STOP, CODE11, CODE11_START_STOP,
   MSI_BIT, MSI_START, MSI_STOP,
@@ -373,6 +373,147 @@ export function encodeCode39(value, options = {}) {
   return toMatrix(parts.join('0'));
 }
 
+/* ------------------------------------------------------------------ *
+ * Code 32 / PZN
+ * ------------------------------------------------------------------ */
+
+/** Code 32's six-character alphabet after its four skipped vowels. */
+const CODE32_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUV';
+
+/**
+ * Convert a Code 32 base-32 digit to the printed character set. The standard
+ * skips A, E, I and O so the human-readable text cannot be mistaken for a
+ * vowel-heavy word. The successive threshold shifts are intentionally
+ * expressed as rules rather than copied lookup data.
+ */
+function code32PrintCharacter(character) {
+  let code = character.charCodeAt(0);
+  for (const vowel of 'AEIO') {
+    if (code >= vowel.charCodeAt(0)) code++;
+  }
+  return String.fromCharCode(code);
+}
+
+const CODE32_PRINT_ALPHABET = [...CODE32_ALPHABET].map(code32PrintCharacter).join('');
+const CODE32_DECODE = new Map([...CODE32_PRINT_ALPHABET].map((ch, index) => [ch, index]));
+
+/**
+ * Italian Code 32 (Italian Pharmacode) check digit.
+ *
+ * @param {string} value The eight-digit body, without the check digit.
+ * @returns {number}
+ */
+export function code32CheckDigit(value) {
+  let sum = 0;
+  for (let i = 0; i < 8; i++) {
+    let digit = Number(value[i]);
+    if (i % 2 === 1) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    sum += digit;
+  }
+  return sum % 10;
+}
+
+/**
+ * Encode the Italian Code 32 pharmaceutical identifier through Code 39.
+ * Accepts the eight-digit body or the same body followed by its check digit.
+ *
+ * @param {string} value Eight or nine digits.
+ * @returns {BitMatrix}
+ */
+export function encodeCode32(value) {
+  const digits = String(value);
+  if (!/^\d{8,9}$/.test(digits)) {
+    throw new EncodeError('Code 32: payload must contain 8 or 9 digits');
+  }
+  const body = digits.slice(0, 8);
+  const check = code32CheckDigit(body);
+  if (digits.length === 9 && Number(digits[8]) !== check) {
+    throw new EncodeError(`Code 32: invalid check digit ${digits[8]}, expected ${check}`);
+  }
+  const complete = body + String(check);
+  let base32 = BigInt(complete).toString(32).toUpperCase().padStart(6, '0');
+  base32 = [...base32].map(code32PrintCharacter).join('');
+  return encodeCode39(base32);
+}
+
+/**
+ * Decode the Code 39 payload of an Italian Code 32 symbol.
+ *
+ * This helper is deliberately kept separate from the image reader so it can
+ * validate the numeric/check-digit grammar without introducing a module cycle.
+ *
+ * @param {string} text Code 39 payload, excluding its asterisks.
+ * @returns {{text:string, checkDigit:number}|null}
+ */
+export function decodeCode32Payload(text) {
+  if (text.length !== 6) return null;
+  let value = 0n;
+  for (const ch of text) {
+    const digit = CODE32_DECODE.get(ch);
+    if (digit === undefined) return null;
+    value = value * 32n + BigInt(digit);
+  }
+  const complete = value.toString(10).padStart(9, '0');
+  if (complete.length !== 9) return null;
+  const body = complete.slice(0, 8);
+  const checkDigit = code32CheckDigit(body);
+  if (Number(complete[8]) !== checkDigit) return null;
+  return { text: body, checkDigit };
+}
+
+function pznCheckDigit(body, pzn8) {
+  let sum = 0;
+  const offset = pzn8 ? 1 : 2;
+  for (let i = 0; i < body.length; i++) sum += Number(body[i]) * (i + offset);
+  const check = sum % 11;
+  return check === 10 ? null : check;
+}
+
+/**
+ * Encode a Pharmazentralnummer (PZN-7 or PZN-8) through Code 39.
+ *
+ * @param {string} value Six/seven digits for PZN-7, or seven/eight for PZN-8.
+ * @param {object} [options]
+ * @param {boolean} [options.pzn8=false] Select the modern eight-digit body.
+ * @param {'pzn7'|'pzn8'} [options.variant] Alias for `pzn8`.
+ * @returns {BitMatrix}
+ */
+export function encodePZN(value, options = {}) {
+  const pzn8 = options.pzn8 === true || options.variant === 'pzn8';
+  const digits = String(value);
+  const bodyLength = pzn8 ? 7 : 6;
+  if (!new RegExp(`^\\d{${bodyLength},${bodyLength + 1}}$`).test(digits)) {
+    throw new EncodeError(`PZN-${pzn8 ? 8 : 7}: payload must contain ${bodyLength} or ${bodyLength + 1} digits`);
+  }
+  const body = digits.slice(0, bodyLength);
+  const check = pznCheckDigit(body, pzn8);
+  if (check === null) throw new EncodeError('PZN: input sequence produces the reserved check value 10');
+  if (digits.length === bodyLength + 1 && Number(digits[bodyLength]) !== check) {
+    throw new EncodeError(`PZN: invalid check digit ${digits[bodyLength]}, expected ${check}`);
+  }
+  return encodeCode39(`-${body}${check}`);
+}
+
+/**
+ * Decode the Code 39 payload of a PZN symbol.
+ *
+ * @param {string} text Code 39 payload, excluding its asterisks.
+ * @returns {{text:string, variant:'pzn7'|'pzn8', checkDigit:number}|null}
+ */
+export function decodePZNPayload(text) {
+  if (!/^-\d+$/.test(text)) return null;
+  const digits = text.slice(1);
+  const pzn8 = digits.length === 8;
+  if (digits.length !== 7 && !pzn8) return null;
+  const body = digits.slice(0, -1);
+  const checkDigit = pznCheckDigit(body, pzn8);
+  if (checkDigit === null || Number(digits.at(-1)) !== checkDigit) return null;
+  return { text: body, variant: pzn8 ? 'pzn8' : 'pzn7', checkDigit };
+}
+
 /* ------------------------------------------------------------------ *
  * Code 93
  * ------------------------------------------------------------------ */
@@ -421,20 +562,19 @@ export function encodeCode93(value) {
 const CODE128_B_OFFSET = 32;
 
 /**
- * Code 128, with automatic code-set selection.
+ * Build the Code 128 data stream without the checksum and stop symbol.
  *
- * The heuristic: switch into set C when enough consecutive digits are present
- * to repay the switch symbol — four at the start or end of the payload, six in
- * the middle, since C packs two digits per symbol. An encoder that never
- * switches produces a valid but needlessly wide symbol.
+ * Stacked Code 128 symbologies use the same A/B/C data alphabet but provide
+ * their own row framing and checks. Keeping the tokeniser here makes those
+ * writers use the exact same ASCII and numeric rules as the ordinary Code 128
+ * writer. `startSet` is an optional explicit starting set for a stacked row.
  *
  * @param {string} value
- * @param {object} [options]
- * @param {boolean} [options.gs1] Emit a leading FNC1, making this GS1-128.
- * @returns {BitMatrix}
+ * @param {{gs1?: boolean, startSet?: 'A'|'B'|'C'}} [options]
+ * @returns {{start: number, values: number[], mode: 'A'|'B'|'C'}}
  */
-export function encodeCode128(value, options = {}) {
-  const { gs1 = false } = options;
+export function code128DataCodewords(value, options = {}) {
+  const { gs1 = false, startSet = null } = options;
   for (const ch of value) {
     if (ch.charCodeAt(0) > 127) {
       throw new EncodeError(`Code 128: '${ch}' is outside ASCII`);
@@ -451,9 +591,20 @@ export function encodeCode128(value, options = {}) {
   const codes = [];
   let mode;
   let i = 0;
-
   const startRun = digitRun(0);
-  if (startRun >= 4 && startRun % 2 === 0) {
+  if (startSet === 'A') {
+    codes.push(CODE128_START_A);
+    mode = 'A';
+  } else if (startSet === 'C') {
+    if (startRun < 2 || startRun % 2 !== 0) {
+      throw new EncodeError('Code 128: set C requires an even leading digit run');
+    }
+    codes.push(CODE128_START_C);
+    mode = 'C';
+  } else if (startSet === 'B') {
+    codes.push(CODE128_START_B);
+    mode = 'B';
+  } else if (startRun >= 4 && startRun % 2 === 0) {
     codes.push(CODE128_START_C);
     mode = 'C';
   } else {
@@ -509,6 +660,26 @@ export function encodeCode128(value, options = {}) {
     i++;
   }
 
+  return { start: codes[0], values: codes.slice(1), mode };
+}
+
+/**
+ * Code 128, with automatic code-set selection.
+ *
+ * The heuristic: switch into set C when enough consecutive digits are present
+ * to repay the switch symbol — four at the start or end of the payload, six in
+ * the middle, since C packs two digits per symbol. An encoder that never
+ * switches produces a valid but needlessly wide symbol.
+ *
+ * @param {string} value
+ * @param {object} [options]
+ * @param {boolean} [options.gs1] Emit a leading FNC1, making this GS1-128.
+ * @returns {BitMatrix}
+ */
+export function encodeCode128(value, options = {}) {
+  const data = code128DataCodewords(value, options);
+  const codes = [data.start, ...data.values];
+
   // Checksum: the start value plus each symbol weighted by its position.
   let sum = codes[0];
   for (let k = 1; k < codes.length; k++) sum += codes[k] * k;