@sythos/js_barcode_universal 1.5.8 → 1.5.9

package/src/ts/micropdf417/error-correction.ts

@@ -0,0 +1,55 @@
+/*!
+ * 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.
+ */
+
+/** MicroPDF417 error correction over the existing GF(929) core. @module micropdf417/error-correction */
+
+import { EncodeError } from '../core/errors.js';
+import { GF929 } from '../core/galois-field.js';
+import { generatorPoly, rsDecode, rsEncode } from '../core/reed-solomon.js';
+
+function eccLength(entry) {
+  if (!entry || !Number.isInteger(entry.eccCodewords)) throw new EncodeError('MicroPDF417: a variant with an ECC length is required');
+  if (entry.eccCodewords < 1 || entry.eccCodewords >= GF929.size) throw new EncodeError('MicroPDF417: ECC length is outside GF(929) bounds');
+  return entry.eccCodewords;
+}
+
+/** Return the fixed number of parity codewords for a MicroPDF417 variant. */
+export function microPdf417EccLength(entry) { return eccLength(entry); }
+
+/** Build the MicroPDF417 generator polynomial for a variant's fixed ECC length. */
+export function microPdf417Generator(entry) { return generatorPoly(eccLength(entry), GF929, 1); }
+
+/** Compute systematic MicroPDF417 parity codewords. `data` must already include padding. */
+export function microPdf417ErrorCorrection(data, entry) { return rsEncode(data, eccLength(entry), GF929, 1); }
+
+/** Correct a complete MicroPDF417 codeword stream, optionally marking erasures. */
+export function microPdf417CorrectErrors(codewords, entry, erasures = []) {
+  return rsDecode(codewords, eccLength(entry), GF929, 1, erasures);
+}

package/src/ts/micropdf417/index.ts

@@ -0,0 +1,49 @@
+/*!
+ * 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.
+ */
+
+export {
+  MICROPDF417_VARIANTS,
+  microPdf417NextRap,
+  microPdf417VariantByNumber,
+  microPdf417VariantForCapacity,
+  microPdf417RapSequence,
+  microPdf417RowAddress,
+  validateMicroPdf417Tables,
+} from './tables.js';
+export {
+  microPdf417EccLength,
+  microPdf417Generator,
+  microPdf417ErrorCorrection,
+  microPdf417CorrectErrors,
+} from './error-correction.js';
+export { compactMicroPDF417 } from './compaction.js';
+export { encodeMicroPDF417 } from './encoder.js';
+export { decodeMicroPDF417 } from './decoder.js';
+export { detectMicroPDF417, detectAndDecodeMicroPDF417 } from './detector.js';

package/src/ts/micropdf417/tables.ts

@@ -0,0 +1,184 @@
+/*!
+ * 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.
+ */
+
+/**
+ * MicroPDF417 format facts and Row Address Pattern (RAP) helpers.
+ *
+ * The tables are represented as compact, immutable data and are guarded by
+ * {@link validateMicroPdf417Tables}. They are deliberately separate from the
+ * PDF417 symbol-character table: MicroPDF417 has a fixed family of symbols and
+ * its own row-address system.
+ *
+ * Values are derived from publicly available symbology documentation and
+ * independently checked against black-box reference output. This module makes
+ * no certification or conformance claim.
+ *
+ * @module micropdf417/tables
+ */
+
+const variant = (id, columns, rows, eccCodewords, rapStart, rapRotation) => Object.freeze({
+  id,
+  columns,
+  rows,
+  totalCodewords: columns * rows,
+  dataCodewords: columns * rows - eccCodewords,
+  eccCodewords,
+  rapStart,
+  rapRotation,
+});
+
+/** All 34 predefined MicroPDF417 symbol variants, in format-table order. */
+export const MICROPDF417_VARIANTS = Object.freeze([
+  variant(1, 1, 11, 7, 1, 8), variant(2, 1, 14, 7, 8, 0),
+  variant(3, 1, 17, 7, 36, 0), variant(4, 1, 20, 8, 19, 0),
+  variant(5, 1, 24, 8, 9, 8), variant(6, 1, 28, 8, 25, 8),
+  variant(7, 2, 8, 8, 1, 0), variant(8, 2, 11, 9, 1, 8),
+  variant(9, 2, 14, 9, 8, 0), variant(10, 2, 17, 10, 36, 0),
+  variant(11, 2, 20, 11, 19, 0), variant(12, 2, 23, 13, 9, 8),
+  variant(13, 2, 26, 15, 27, 8),
+  variant(14, 3, 6, 12, 1, 0), variant(15, 3, 8, 14, 7, 0),
+  variant(16, 3, 10, 16, 15, 0), variant(17, 3, 12, 18, 25, 0),
+  variant(18, 3, 15, 21, 37, 0), variant(19, 3, 20, 26, 1, 16),
+  variant(20, 3, 26, 32, 1, 8), variant(21, 3, 32, 38, 21, 8),
+  variant(22, 3, 38, 44, 15, 16), variant(23, 3, 44, 50, 1, 24),
+  variant(24, 4, 4, 8, 47, 24), variant(25, 4, 6, 12, 1, 0),
+  variant(26, 4, 8, 14, 7, 0), variant(27, 4, 10, 16, 15, 0),
+  variant(28, 4, 12, 18, 25, 0), variant(29, 4, 15, 21, 37, 0),
+  variant(30, 4, 20, 26, 1, 16), variant(31, 4, 26, 32, 1, 8),
+  variant(32, 4, 32, 38, 21, 8), variant(33, 4, 38, 44, 15, 16),
+  variant(34, 4, 44, 50, 1, 24),
+]);
+
+const byId = new Map(MICROPDF417_VARIANTS.map((entry) => [entry.id, entry]));
+
+// Six run widths, ordered bar-space-bar-space-bar-space.  A RAP is ten
+// modules wide; the right RAP has one additional one-module stop bar when
+// rendered. Keeping runs rather than bitmap literals makes each invariant
+// inspectable and avoids a rendering-specific representation here.
+const SIDE_RAP_RUNS = Object.freeze([
+  '221311', '311311', '312211', '222211', '213211', '214111', '223111', '313111',
+  '322111', '412111', '421111', '331111', '241111', '232111', '231211', '321211',
+  '411211', '411121', '411112', '321112', '312112', '311212', '311221', '311131',
+  '311122', '311113', '221113', '221122', '221131', '221221', '222121', '312121',
+  '321121', '231121', '231112', '222112', '213112', '212212', '212221', '212131',
+  '212122', '212113', '211213', '211123', '211132', '211141', '211231', '211222',
+  '211312', '211321', '211411', '212311',
+]);
+
+const CENTER_RAP_RUNS = Object.freeze([
+  '112231', '121231', '122131', '131131', '131221', '132121', '141121', '141211',
+  '142111', '133111', '132211', '131311', '122311', '123211', '124111', '115111',
+  '114211', '114121', '123121', '123112', '122212', '122221', '121321', '121411',
+  '112411', '113311', '113221', '113212', '113122', '122122', '131122', '131113',
+  '122113', '113113', '112213', '112222', '112312', '112321', '111421', '111331',
+  '111322', '111232', '111223', '111133', '111124', '111214', '112114', '121114',
+  '121123', '121132', '112132', '112141',
+]);
+
+/** @param {number} value @param {number} offset @returns {number} */
+export function microPdf417NextRap(value, offset = 1) {
+  if (!Number.isInteger(value) || value < 1 || value > 52) throw new RangeError('MicroPDF417: RAP number must be in 1..52');
+  if (!Number.isInteger(offset)) throw new RangeError('MicroPDF417: RAP offset must be an integer');
+  return ((value - 1 + offset) % 52 + 52) % 52 + 1;
+}
+
+/** @param {number} id @returns {Readonly<typeof MICROPDF417_VARIANTS[number]>} */
+export function microPdf417VariantByNumber(id) {
+  const entry = byId.get(id);
+  if (!entry) throw new RangeError('MicroPDF417: variant must be an integer in 1..34');
+  return entry;
+}
+
+/**
+ * Return the smallest data-region candidate that fits `codewords`.
+ * Ties are resolved by width, then height, so selection is deterministic.
+ */
+export function microPdf417VariantForCapacity(codewords) {
+  if (!Number.isInteger(codewords) || codewords < 1) throw new RangeError('MicroPDF417: codeword capacity must be a positive integer');
+  const candidates = MICROPDF417_VARIANTS.filter((entry) => entry.dataCodewords >= codewords);
+  if (!candidates.length) throw new RangeError('MicroPDF417: payload exceeds the largest symbol data region');
+  return candidates.slice().sort((a, b) => a.totalCodewords - b.totalCodewords || a.columns - b.columns || a.rows - b.rows)[0];
+}
+
+/** Return the six bar/space run widths for a numbered side or center RAP. */
+export function microPdf417RapSequence(number, kind = 'side') {
+  if (!Number.isInteger(number) || number < 1 || number > 52) throw new RangeError('MicroPDF417: RAP number must be in 1..52');
+  if (kind === 'side') return SIDE_RAP_RUNS[number - 1];
+  if (kind === 'center') return CENTER_RAP_RUNS[number - 1];
+  throw new RangeError('MicroPDF417: RAP kind must be side or center');
+}
+
+/**
+ * Resolve all row-address data for a zero-based row within a variant.
+ * @returns {{left: number, center: number|null, right: number, cluster: 0|3|6}}
+ */
+export function microPdf417RowAddress(entry, row) {
+  if (!entry || !Number.isInteger(entry.columns) || !Number.isInteger(entry.rows)) throw new TypeError('MicroPDF417: a variant entry is required');
+  if (!Number.isInteger(row) || row < 0 || row >= entry.rows) throw new RangeError(`MicroPDF417: row must be in 0..${entry.rows - 1}`);
+  const left = microPdf417NextRap(entry.rapStart, row);
+  const cluster = /** @type {0|3|6} */ (((left - 1) % 3) * 3);
+  if (entry.columns < 3) return { left, center: null, right: microPdf417NextRap(left, entry.rapRotation), cluster };
+  const center = microPdf417NextRap(left, entry.rapRotation);
+  return { left, center, right: microPdf417NextRap(center, entry.rapRotation), cluster };
+}
+
+const validRuns = (runs) => runs.length === 6 && /^[1-9]{6}$/.test(runs) && [...runs].reduce((sum, digit) => sum + Number(digit), 0) === 10;
+const oneEdgeShift = (from, to) => [...from].reduce((sum, digit, index) => sum + Math.abs(Number(digit) - Number(to[index])), 0) === 2;
+
+/** Return any table-invariant failures; an empty result means the table is coherent. */
+export function validateMicroPdf417Tables() {
+  const issues = [];
+  if (MICROPDF417_VARIANTS.length !== 34) issues.push('expected 34 variants');
+  const ids = new Set();
+  const formats = new Set();
+  for (const entry of MICROPDF417_VARIANTS) {
+    if (ids.has(entry.id)) issues.push(`duplicate variant ${entry.id}`); ids.add(entry.id);
+    const format = `${entry.columns}x${entry.rows}`;
+    if (formats.has(format)) issues.push(`duplicate format ${format}`); formats.add(format);
+    if (entry.totalCodewords !== entry.columns * entry.rows) issues.push(`${format}: total codeword geometry mismatch`);
+    if (entry.dataCodewords + entry.eccCodewords !== entry.totalCodewords) issues.push(`${format}: data/ECC capacity mismatch`);
+    if (entry.eccCodewords < 7 || entry.eccCodewords > 50) issues.push(`${format}: invalid ECC length`);
+    if (entry.rapStart < 1 || entry.rapStart > 52 || entry.rapRotation < 0 || entry.rapRotation > 51) issues.push(`${format}: invalid RAP assignment`);
+    for (let row = 0; row < entry.rows; row++) {
+      const address = microPdf417RowAddress(entry, row);
+      if (address.cluster !== ((address.left - 1) % 3) * 3) issues.push(`${format}: cluster mismatch at row ${row}`);
+      if ((entry.columns < 3) !== (address.center === null)) issues.push(`${format}: center RAP layout mismatch`);
+    }
+  }
+  for (const [kind, runs] of [['side', SIDE_RAP_RUNS], ['center', CENTER_RAP_RUNS]]) {
+    if (runs.length !== 52) issues.push(`${kind}: expected 52 RAPs`);
+    if (new Set(runs).size !== runs.length) issues.push(`${kind}: duplicate RAP`);
+    for (let i = 0; i < runs.length; i++) {
+      if (!validRuns(runs[i])) issues.push(`${kind}: invalid RAP ${i + 1}`);
+      if (runs.length && !oneEdgeShift(runs[i], runs[(i + 1) % runs.length])) issues.push(`${kind}: RAP ${i + 1} is not adjacent to its successor`);
+    }
+  }
+  return issues;
+}

package/src/ts/microqr/decoder.ts

@@ -0,0 +1,245 @@
+/*!
+ * 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.
+ */
+
+/**
+ * Micro QR decoder for an already sampled M1-M4 module matrix.
+ *
+ * @module microqr/decoder
+ */
+
+import { ChecksumError, FormatError } from '../core/errors.js';
+import { GF256_QR } from '../core/galois-field.js';
+import { rsDecode } from '../core/reed-solomon.js';
+import {
+  microQrBlockLayout,
+  microQrDataModuleOrder,
+  microQrDecodeFormatInfo,
+  microQrFormatInfoPositions,
+  microQrMaskBit,
+} from './tables.js';
+
+const ALPHANUMERIC = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
+const MODE_NAMES = ['numeric', 'alphanumeric', 'byte', 'kanji'];
+const COUNT_BITS = {
+  numeric: [0, 3, 4, 5, 6],
+  alphanumeric: [0, 0, 3, 4, 5],
+  byte: [0, 0, 0, 4, 5],
+  kanji: [0, 0, 0, 3, 4],
+};
+
+class LimitedBitReader {
+  constructor(bytes, limit) {
+    this.bytes = bytes;
+    this.limit = limit;
+    this.offset = 0;
+  }
+
+  available() { return this.limit - this.offset; }
+
+  read(count) {
+    if (!Number.isInteger(count) || count < 1 || count > 32 || count > this.available()) {
+      throw new FormatError(`Micro QR: needed ${count} bits, ${Math.max(0, this.available())} remain`);
+    }
+    let value = 0;
+    for (let i = 0; i < count; i++, this.offset++) {
+      value = (value << 1) | ((this.bytes[this.offset >>> 3] >>> (7 - (this.offset & 7))) & 1);
+    }
+    return value >>> 0;
+  }
+}
+
+function moduleAt(matrix, x, y, mirrored) {
+  return mirrored ? matrix.get(y, x) : matrix.get(x, y);
+}
+
+function readFormat(matrix, expectedVersion, mirrored) {
+  let bits = 0;
+  const positions = microQrFormatInfoPositions(matrix.width);
+  for (let i = 0; i < positions.length; i++) {
+    const [x, y] = positions[i];
+    if (moduleAt(matrix, x, y, mirrored)) bits |= 1 << i;
+  }
+  const format = microQrDecodeFormatInfo(bits);
+  if (!format) throw new FormatError('Micro QR: format information is unreadable');
+  if (format.version !== expectedVersion) {
+    throw new FormatError(
+      `Micro QR: format identifies ${format.version}, but the matrix dimension identifies ${expectedVersion}`,
+    );
+  }
+  return format;
+}
+
+function readCodewords(matrix, layout, mask, mirrored) {
+  const order = microQrDataModuleOrder(layout.version);
+  const data = new Array(layout.dataCodewords).fill(0);
+  const ecc = new Array(layout.eccCodewords).fill(0);
+  let streamOffset = 0;
+
+  const readBit = () => {
+    const x = order[streamOffset * 2];
+    const y = order[streamOffset * 2 + 1];
+    if (x === undefined || y === undefined) throw new FormatError('Micro QR: encoding region is truncated');
+    streamOffset++;
+    return moduleAt(matrix, x, y, mirrored) !== microQrMaskBit(mask, x, y) ? 1 : 0;
+  };
+  const readInto = (target, index, count, highBit = 7) => {
+    for (let bit = highBit; bit > highBit - count; bit--) target[index] |= readBit() << bit;
+  };
+
+  const fullData = layout.shortDataCodewordBits === 4 ? layout.dataCodewords - 1 : layout.dataCodewords;
+  for (let i = 0; i < fullData; i++) readInto(data, i, 8);
+  if (layout.shortDataCodewordBits === 4) readInto(data, data.length - 1, 4);
+  for (let i = 0; i < ecc.length; i++) readInto(ecc, i, 8);
+
+  if (streamOffset !== order.length / 2) {
+    throw new FormatError(`Micro QR: read ${streamOffset} of ${order.length / 2} encoding modules`);
+  }
+  return data.concat(ecc);
+}
+
+function correctCodewords(received, layout) {
+  const corrections = rsDecode(received, layout.eccCodewords, GF256_QR, 0);
+  if (layout.version === 'M1' && corrections !== 0) {
+    throw new ChecksumError('Micro QR: M1 provides error detection only');
+  }
+  return { data: Uint8Array.from(received.slice(0, layout.dataCodewords)), corrections };
+}
+
+function decodeKanjiValue(value) {
+  const combined = (Math.floor(value / 0xc0) << 8) | (value % 0xc0);
+  const sjis = combined + (combined < 0x1f00 ? 0x8140 : 0xc140);
+  const bytes = Uint8Array.of(sjis >>> 8, sjis & 0xff);
+  try {
+    return new TextDecoder('shift_jis', { fatal: true }).decode(bytes);
+  } catch {
+    throw new FormatError(`Micro QR: invalid Kanji value ${value}`);
+  }
+}
+
+function parsePayload(data, version, dataBits) {
+  const reader = new LimitedBitReader(data, dataBits);
+  const modeValue = version === 1 ? 0 : reader.read(version - 1);
+  if (modeValue > 3 || (version === 2 && modeValue > 1)) {
+    throw new FormatError(`Micro QR: mode indicator ${modeValue} is unavailable in M${version}`);
+  }
+  const mode = MODE_NAMES[modeValue];
+  const countWidth = COUNT_BITS[mode][version];
+  if (!countWidth) throw new FormatError(`Micro QR: ${mode} mode is unavailable in M${version}`);
+  const count = reader.read(countWidth);
+  if (count === 0) throw new FormatError('Micro QR: zero-length data segment');
+
+  let text = '';
+  const rawBytes = [];
+  if (mode === 'numeric') {
+    let remaining = count;
+    while (remaining >= 3) {
+      const value = reader.read(10);
+      if (value >= 1000) throw new FormatError(`Micro QR: invalid numeric triplet ${value}`);
+      text += String(value).padStart(3, '0');
+      remaining -= 3;
+    }
+    if (remaining === 2) {
+      const value = reader.read(7);
+      if (value >= 100) throw new FormatError(`Micro QR: invalid numeric pair ${value}`);
+      text += String(value).padStart(2, '0');
+    } else if (remaining === 1) {
+      const value = reader.read(4);
+      if (value >= 10) throw new FormatError(`Micro QR: invalid numeric digit ${value}`);
+      text += String(value);
+    }
+  } else if (mode === 'alphanumeric') {
+    let remaining = count;
+    while (remaining >= 2) {
+      const value = reader.read(11);
+      if (value >= 45 * 45) throw new FormatError(`Micro QR: invalid alphanumeric pair ${value}`);
+      text += ALPHANUMERIC[Math.floor(value / 45)] + ALPHANUMERIC[value % 45];
+      remaining -= 2;
+    }
+    if (remaining === 1) {
+      const value = reader.read(6);
+      if (value >= 45) throw new FormatError(`Micro QR: invalid alphanumeric value ${value}`);
+      text += ALPHANUMERIC[value];
+    }
+  } else if (mode === 'byte') {
+    for (let i = 0; i < count; i++) {
+      const value = reader.read(8);
+      rawBytes.push(value);
+      text += String.fromCharCode(value);
+    }
+  } else {
+    for (let i = 0; i < count; i++) text += decodeKanjiValue(reader.read(13));
+  }
+  return { text, bytes: Uint8Array.from(rawBytes), mode };
+}
+
+function decodeOrientation(matrix, expectedVersion, mirrored) {
+  const format = readFormat(matrix, expectedVersion, mirrored);
+  const layout = microQrBlockLayout(format.version, format.ecc);
+  const received = readCodewords(matrix, layout, format.mask, mirrored);
+  const { data, corrections } = correctCodewords(received, layout);
+  const payload = parsePayload(data, Number(format.version.slice(1)), layout.dataBits);
+  return {
+    text: payload.text,
+    bytes: payload.bytes,
+    mode: payload.mode,
+    version: format.version,
+    ecc: format.ecc,
+    mask: format.mask,
+    corrections,
+    formatCorrections: format.correctedBits,
+    mirrored,
+  };
+}
+
+/** Decode a sampled Micro QR Code symbol without its quiet zone. */
+export function decodeMicroQR(matrix) {
+  if (!matrix || !Number.isInteger(matrix.width) || typeof matrix.get !== 'function') {
+    throw new FormatError('Micro QR: no matrix supplied');
+  }
+  if (matrix.height !== matrix.width) {
+    throw new FormatError(`Micro QR: symbol must be square, got ${matrix.width}x${matrix.height}`);
+  }
+  const version = (matrix.width - 9) / 2;
+  if (!Number.isInteger(version) || version < 1 || version > 4) {
+    throw new FormatError(`Micro QR: ${matrix.width} modules is not a valid M1-M4 symbol size`);
+  }
+  const expectedVersion = `M${version}`;
+  try {
+    return decodeOrientation(matrix, expectedVersion, false);
+  } catch (primaryError) {
+    try {
+      return decodeOrientation(matrix, expectedVersion, true);
+    } catch {
+      throw primaryError;
+    }
+  }
+}
+
+export { ChecksumError, FormatError };