@sythos/js_barcode_universal 1.5.8 → 1.5.9

package/src/js/rmqr/decoder.js

@@ -27,75 +27,183 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 import { BitReader } from '../core/bit-buffer.js';
 import { ChecksumError, FormatError } from '../core/errors.js';
 import { GF256_QR } from '../core/galois-field.js';
 import { rsDecode } from '../core/reed-solomon.js';
-import {
-  FORMAT_MASK_FINDER, FORMAT_MASK_SUB, dataModuleOrder, functionModules, maskBit,
-  versionForSize, versionInfo, formatBits,
-} from './tables.js';
+import { FORMAT_MASK_FINDER, FORMAT_MASK_SUB, dataModuleOrder, maskBit, versionForSize, formatBits, } from './tables.js';
 import { ALPHANUMERIC_CHARS, MODE } from './encoder.js';
-
-function hamming(a, b) { let v = a ^ b, n = 0; while (v) { v &= v - 1; n++; } return n; }
+function hamming(a, b) { let v = a ^ b, n = 0; while (v) {
+    v &= v - 1;
+    n++;
+} return n; }
 function readFormat(matrix, v) {
-  let a = 0; for (let n = 0; n < 18; n++) if (matrix.get(8 + Math.floor(n / 5), 1 + (n % 5))) a |= 1 << n;
-  let b = 0; for (let n = 0; n < 15; n++) if (matrix.get(v.width - 8 + Math.floor(n / 5), v.height - 6 + (n % 5))) b |= 1 << n;
-  for (let n = 15; n < 18; n++) if (matrix.get(v.width - 5 + (n - 15), v.height - 6)) b |= 1 << n;
-  const candidates = [];
-  for (let version = 1; version <= 32; version++) for (const ecc of ['M', 'H']) {
-    candidates.push({ version, ecc, finder: formatBits(version, ecc) ^ FORMAT_MASK_FINDER, sub: formatBits(version, ecc) ^ FORMAT_MASK_SUB });
-  }
-  let best = null;
-  for (const c of candidates) for (const [value, expected] of [[a, c.finder], [b, c.sub]]) { const distance = hamming(value, expected); if (!best || distance < best.distance) best = { ...c, distance }; }
-  if (!best || best.distance > 3) throw new FormatError('rMQR: format information is unreadable');
-  return best;
+    let a = 0;
+    for (let n = 0; n < 18; n++)
+        if (matrix.get(8 + Math.floor(n / 5), 1 + (n % 5)))
+            a |= 1 << n;
+    let b = 0;
+    for (let n = 0; n < 15; n++)
+        if (matrix.get(v.width - 8 + Math.floor(n / 5), v.height - 6 + (n % 5)))
+            b |= 1 << n;
+    for (let n = 15; n < 18; n++)
+        if (matrix.get(v.width - 5 + (n - 15), v.height - 6))
+            b |= 1 << n;
+    const candidates = [];
+    for (let version = 1; version <= 32; version++)
+        for (const ecc of ['M', 'H']) {
+            candidates.push({ version, ecc, finder: formatBits(version, ecc) ^ FORMAT_MASK_FINDER, sub: formatBits(version, ecc) ^ FORMAT_MASK_SUB });
+        }
+    let best = null;
+    for (const c of candidates)
+        for (const [value, expected] of [[a, c.finder], [b, c.sub]]) {
+            const distance = hamming(value, expected);
+            if (!best || distance < best.distance)
+                best = { ...c, distance };
+        }
+    if (!best || best.distance > 3)
+        throw new FormatError('rMQR: format information is unreadable');
+    return best;
 }
-
 function readCodewords(matrix, v, mask, total) {
-  const order = dataModuleOrder(v.version); const out = new Uint8Array(total); let bit = 0;
-  for (const [x, y] of order) { if (bit >= total * 8) break; let on = matrix.get(x, y); if (maskBit(x, y)) on = !on; if (on) out[bit >>> 3] |= 0x80 >>> (bit & 7); bit++; }
-  return out;
+    const order = dataModuleOrder(v.version);
+    const out = new Uint8Array(total);
+    let bit = 0;
+    for (const [x, y] of order) {
+        if (bit >= total * 8)
+            break;
+        let on = matrix.get(x, y);
+        if (maskBit(x, y))
+            on = !on;
+        if (on)
+            out[bit >>> 3] |= 0x80 >>> (bit & 7);
+        bit++;
+    }
+    return out;
 }
-
 function deinterleave(codewords, v, ecc) {
-  const blocks = v.blockLayout(ecc).blocks; const arrays = blocks.map((b) => new Array(b.total).fill(0)); let offset = 0;
-  const maxData = Math.max(...blocks.map((b) => b.data)); for (let i = 0; i < maxData; i++) for (let b = 0; b < blocks.length; b++) if (i < blocks[b].data) arrays[b][i] = codewords[offset++];
-  const maxEcc = Math.max(...blocks.map((b) => b.ecc)); for (let i = 0; i < maxEcc; i++) for (let b = 0; b < blocks.length; b++) if (i < blocks[b].ecc) arrays[b][blocks[b].data + i] = codewords[offset++];
-  const data = []; let corrections = 0;
-  for (let b = 0; b < arrays.length; b++) { corrections += rsDecode(arrays[b], blocks[b].ecc, GF256_QR, 0); data.push(...arrays[b].slice(0, blocks[b].data)); }
-  return { data: Uint8Array.from(data), corrections };
+    const blocks = v.blockLayout(ecc).blocks;
+    const arrays = blocks.map((b) => new Array(b.total).fill(0));
+    let offset = 0;
+    const maxData = Math.max(...blocks.map((b) => b.data));
+    for (let i = 0; i < maxData; i++)
+        for (let b = 0; b < blocks.length; b++)
+            if (i < blocks[b].data)
+                arrays[b][i] = codewords[offset++];
+    const maxEcc = Math.max(...blocks.map((b) => b.ecc));
+    for (let i = 0; i < maxEcc; i++)
+        for (let b = 0; b < blocks.length; b++)
+            if (i < blocks[b].ecc)
+                arrays[b][blocks[b].data + i] = codewords[offset++];
+    const data = [];
+    let corrections = 0;
+    for (let b = 0; b < arrays.length; b++) {
+        corrections += rsDecode(arrays[b], blocks[b].ecc, GF256_QR, 0);
+        data.push(...arrays[b].slice(0, blocks[b].data));
+    }
+    return { data: Uint8Array.from(data), corrections };
 }
-
 function decodeBytes(bytes, eci) {
-  try { return new TextDecoder(eci === 26 ? 'utf-8' : 'iso-8859-1', { fatal: false }).decode(bytes); } catch { return String.fromCharCode(...bytes); }
+    try {
+        return new TextDecoder(eci === 26 ? 'utf-8' : 'iso-8859-1', { fatal: false }).decode(bytes);
+    }
+    catch {
+        return String.fromCharCode(...bytes);
+    }
 }
 function parseSegments(data, v) {
-  const reader = new BitReader(data); let text = ''; const raw = []; let eci = 3; let mode;
-  while (reader.available() >= 3) {
-    const peek = (() => { const save = { byteOffset: reader.byteOffset, bitOffset: reader.bitOffset }; const n = reader.read(3); reader.byteOffset = save.byteOffset; reader.bitOffset = save.bitOffset; return n; })();
-    if (peek === 0) break;
-    mode = reader.read(3);
-    if (mode === MODE.ECI) { const first = reader.read(8); let value; if (!(first & 0x80)) value = first; else if ((first & 0xc0) === 0x80) value = ((first & 0x3f) << 8) | reader.read(8); else if ((first & 0xe0) === 0xc0) value = ((first & 0x1f) << 16) | reader.read(16); else throw new FormatError('rMQR: invalid ECI'); eci = value; continue; }
-    const kind = mode === MODE.NUMERIC ? 'numeric' : mode === MODE.ALPHANUMERIC ? 'alphanumeric' : mode === MODE.BYTE ? 'byte' : mode === MODE.KANJI ? 'kanji' : null;
-    if (!kind) throw new FormatError(`rMQR: unsupported mode ${mode}`);
-    const count = reader.read(v.countBits(kind));
-    if (kind === 'numeric') { let remaining = count; while (remaining >= 3) { const n = reader.read(10).toString().padStart(3, '0'); text += n; remaining -= 3; } if (remaining === 2) text += reader.read(7).toString().padStart(2, '0'); else if (remaining === 1) text += reader.read(4).toString(); }
-    else if (kind === 'alphanumeric') { let remaining = count; while (remaining >= 2) { const n = reader.read(11); text += ALPHANUMERIC_CHARS[Math.floor(n / 45)] + ALPHANUMERIC_CHARS[n % 45]; remaining -= 2; } if (remaining) text += ALPHANUMERIC_CHARS[reader.read(6)]; }
-    else if (kind === 'byte') { const b = new Uint8Array(count); for (let i = 0; i < count; i++) { b[i] = reader.read(8); raw.push(b[i]); } text += decodeBytes(b, eci); }
-    else { const bytes = new Uint8Array(count * 2); for (let i = 0; i < count; i++) { const n = reader.read(13); const v2 = n; const high = Math.floor(v2 / 0xc0); const low = v2 % 0xc0; const sjis = high < 0x1f ? 0x8140 + (high << 8) + low : 0xc140 + (high << 8) + low; bytes[i * 2] = sjis >> 8; bytes[i * 2 + 1] = sjis & 255; } try { text += new TextDecoder('shift_jis').decode(bytes); } catch { text += String.fromCharCode(...bytes); } }
-  }
-  return { text, bytes: Uint8Array.from(raw) };
+    const reader = new BitReader(data);
+    let text = '';
+    const raw = [];
+    let eci = 3;
+    let mode;
+    while (reader.available() >= 3) {
+        const peek = (() => { const save = { byteOffset: reader.byteOffset, bitOffset: reader.bitOffset }; const n = reader.read(3); reader.byteOffset = save.byteOffset; reader.bitOffset = save.bitOffset; return n; })();
+        if (peek === 0)
+            break;
+        mode = reader.read(3);
+        if (mode === MODE.ECI) {
+            const first = reader.read(8);
+            let value;
+            if (!(first & 0x80))
+                value = first;
+            else if ((first & 0xc0) === 0x80)
+                value = ((first & 0x3f) << 8) | reader.read(8);
+            else if ((first & 0xe0) === 0xc0)
+                value = ((first & 0x1f) << 16) | reader.read(16);
+            else
+                throw new FormatError('rMQR: invalid ECI');
+            eci = value;
+            continue;
+        }
+        const kind = mode === MODE.NUMERIC ? 'numeric' : mode === MODE.ALPHANUMERIC ? 'alphanumeric' : mode === MODE.BYTE ? 'byte' : mode === MODE.KANJI ? 'kanji' : null;
+        if (!kind)
+            throw new FormatError(`rMQR: unsupported mode ${mode}`);
+        const count = reader.read(v.countBits(kind));
+        if (kind === 'numeric') {
+            let remaining = count;
+            while (remaining >= 3) {
+                const n = reader.read(10).toString().padStart(3, '0');
+                text += n;
+                remaining -= 3;
+            }
+            if (remaining === 2)
+                text += reader.read(7).toString().padStart(2, '0');
+            else if (remaining === 1)
+                text += reader.read(4).toString();
+        }
+        else if (kind === 'alphanumeric') {
+            let remaining = count;
+            while (remaining >= 2) {
+                const n = reader.read(11);
+                text += ALPHANUMERIC_CHARS[Math.floor(n / 45)] + ALPHANUMERIC_CHARS[n % 45];
+                remaining -= 2;
+            }
+            if (remaining)
+                text += ALPHANUMERIC_CHARS[reader.read(6)];
+        }
+        else if (kind === 'byte') {
+            const b = new Uint8Array(count);
+            for (let i = 0; i < count; i++) {
+                b[i] = reader.read(8);
+                raw.push(b[i]);
+            }
+            text += decodeBytes(b, eci);
+        }
+        else {
+            const bytes = new Uint8Array(count * 2);
+            for (let i = 0; i < count; i++) {
+                const n = reader.read(13);
+                const v2 = n;
+                const high = Math.floor(v2 / 0xc0);
+                const low = v2 % 0xc0;
+                const sjis = high < 0x1f ? 0x8140 + (high << 8) + low : 0xc140 + (high << 8) + low;
+                bytes[i * 2] = sjis >> 8;
+                bytes[i * 2 + 1] = sjis & 255;
+            }
+            try {
+                text += new TextDecoder('shift_jis').decode(bytes);
+            }
+            catch {
+                text += String.fromCharCode(...bytes);
+            }
+        }
+    }
+    return { text, bytes: Uint8Array.from(raw) };
 }
-
 /** Decode an exact rMQR module matrix (without quiet zone). */
 export function decodeRMQR(matrix) {
-  if (!matrix || !matrix.width || !matrix.height) throw new FormatError('rMQR: no matrix supplied');
-  const v = versionForSize(matrix.width, matrix.height); if (!v) throw new FormatError(`rMQR: unsupported symbol size ${matrix.width}x${matrix.height}`);
-  const info = readFormat(matrix, v); if (info.version !== v.version) throw new FormatError('rMQR: format/version mismatch');
-  const codewords = readCodewords(matrix, v, 4, v.totalCodewords); const corrected = deinterleave(codewords, v, info.ecc); const parsed = parseSegments(corrected.data, v);
-  return { ...parsed, version: v.version, name: v.name, ecc: info.ecc, mask: 4, corrections: corrected.corrections };
+    if (!matrix || !matrix.width || !matrix.height)
+        throw new FormatError('rMQR: no matrix supplied');
+    const v = versionForSize(matrix.width, matrix.height);
+    if (!v)
+        throw new FormatError(`rMQR: unsupported symbol size ${matrix.width}x${matrix.height}`);
+    const info = readFormat(matrix, v);
+    if (info.version !== v.version)
+        throw new FormatError('rMQR: format/version mismatch');
+    const codewords = readCodewords(matrix, v, 4, v.totalCodewords);
+    const corrected = deinterleave(codewords, v, info.ecc);
+    const parsed = parseSegments(corrected.data, v);
+    return { ...parsed, version: v.version, name: v.name, ecc: info.ecc, mask: 4, corrections: corrected.corrections };
 }
-
 export { ChecksumError };

package/src/js/rmqr/detector.js

@@ -27,64 +27,96 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 import { BitMatrix } from '../core/bit-matrix.js';
 import { NotFoundError } from '../core/errors.js';
 import { decodeRMQR } from './decoder.js';
 import { versionForSize } from './tables.js';
-
 function rotate90(source) {
-  const out = new BitMatrix(source.height, source.width);
-  for (let y = 0; y < source.height; y++) for (let x = 0; x < source.width; x++) if (source.get(x, y)) out.set(source.height - 1 - y, x);
-  return out;
+    const out = new BitMatrix(source.height, source.width);
+    for (let y = 0; y < source.height; y++)
+        for (let x = 0; x < source.width; x++)
+            if (source.get(x, y))
+                out.set(source.height - 1 - y, x);
+    return out;
 }
-function rotate180(source) { const out = new BitMatrix(source.width, source.height); for (let y = 0; y < source.height; y++) for (let x = 0; x < source.width; x++) if (source.get(x, y)) out.set(source.width - 1 - x, source.height - 1 - y); return out; }
+function rotate180(source) { const out = new BitMatrix(source.width, source.height); for (let y = 0; y < source.height; y++)
+    for (let x = 0; x < source.width; x++)
+        if (source.get(x, y))
+            out.set(source.width - 1 - x, source.height - 1 - y); return out; }
 function rotate270(source) { return rotate90(rotate180(source)); }
 function crop(source, box) {
-  const out = new BitMatrix(box.width, box.height); for (let y = 0; y < box.height; y++) for (let x = 0; x < box.width; x++) if (source.get(box.x + x, box.y + y)) out.set(x, y); return out;
+    const out = new BitMatrix(box.width, box.height);
+    for (let y = 0; y < box.height; y++)
+        for (let x = 0; x < box.width; x++)
+            if (source.get(box.x + x, box.y + y))
+                out.set(x, y);
+    return out;
 }
 function sample(matrix, width, height, scale, offsetX, offsetY) {
-  const out = new BitMatrix(width, height); const half = Math.max(0, Math.floor(scale / 2));
-  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-    let dark = 0, count = 0; const x0 = offsetX + x * scale, y0 = offsetY + y * scale;
-    for (let yy = 0; yy < scale; yy++) for (let xx = 0; xx < scale; xx++) { if (matrix.get(x0 + xx, y0 + yy)) dark++; count++; }
-    if (dark * 2 >= count) out.set(x, y);
-  }
-  return out;
+    const out = new BitMatrix(width, height);
+    const half = Math.max(0, Math.floor(scale / 2));
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            let dark = 0, count = 0;
+            const x0 = offsetX + x * scale, y0 = offsetY + y * scale;
+            for (let yy = 0; yy < scale; yy++)
+                for (let xx = 0; xx < scale; xx++) {
+                    if (matrix.get(x0 + xx, y0 + yy))
+                        dark++;
+                    count++;
+                }
+            if (dark * 2 >= count)
+                out.set(x, y);
+        }
+    return out;
 }
 function bounds(matrix) { return matrix.getBounds(); }
-
 /** Detect an axis-aligned, clean rMQR raster and return the exact module matrix. */
 export function detectRMQR(image, options = {}) {
-  if (!image || !image.width || !image.height) throw new NotFoundError('rMQR: no raster supplied');
-  if (options.perspective) throw new NotFoundError('rMQR: perspective detection is not available for clean-raster mode');
-  const orientations = [image, rotate90(image), rotate180(image), rotate270(image)];
-  for (let rotation = 0; rotation < orientations.length; rotation++) {
-    const source = orientations[rotation]; const box = bounds(source); if (!box) continue;
-    for (let version = 1; version <= 32; version++) {
-      const v = versionForSize(box.width, box.height); // exact modules, scale 1
-      if (v && v.version === version) {
-        try { const matrix = crop(source, box); const result = decodeRMQR(matrix); return { matrix, result, rotation, corners: { x: box.x, y: box.y, width: box.width, height: box.height } }; } catch { /* try next orientation/candidate */ }
-      }
-      // Integer nearest-neighbour scale. The dark bounding box must still be an
-      // exact multiple of the standard geometry; this rejects arbitrary text.
-      const candidate = versionForSize(box.width, box.height);
-      if (candidate) continue;
-      const canonical = (awaitableVersion(version));
-      const wScale = box.width / canonical.width;
-      const hScale = box.height / canonical.height;
-      if (!Number.isInteger(wScale) || wScale < 1 || wScale !== hScale) continue;
-      const info = canonical;
-      try { const matrix = sample(source, info.width, info.height, wScale, box.x, box.y); const result = decodeRMQR(matrix); return { matrix, result, rotation, scale: wScale, corners: { x: box.x, y: box.y, width: box.width, height: box.height } }; } catch { /* continue */ }
+    if (!image || !image.width || !image.height)
+        throw new NotFoundError('rMQR: no raster supplied');
+    if (options.perspective)
+        throw new NotFoundError('rMQR: perspective detection is not available for clean-raster mode');
+    const orientations = [image, rotate90(image), rotate180(image), rotate270(image)];
+    for (let rotation = 0; rotation < orientations.length; rotation++) {
+        const source = orientations[rotation];
+        const box = bounds(source);
+        if (!box)
+            continue;
+        for (let version = 1; version <= 32; version++) {
+            const v = versionForSize(box.width, box.height); // exact modules, scale 1
+            if (v && v.version === version) {
+                try {
+                    const matrix = crop(source, box);
+                    const result = decodeRMQR(matrix);
+                    return { matrix, result, rotation, corners: { x: box.x, y: box.y, width: box.width, height: box.height } };
+                }
+                catch { /* try next orientation/candidate */ }
+            }
+            // Integer nearest-neighbour scale. The dark bounding box must still be an
+            // exact multiple of the standard geometry; this rejects arbitrary text.
+            const candidate = versionForSize(box.width, box.height);
+            if (candidate)
+                continue;
+            const canonical = (awaitableVersion(version));
+            const wScale = box.width / canonical.width;
+            const hScale = box.height / canonical.height;
+            if (!Number.isInteger(wScale) || wScale < 1 || wScale !== hScale)
+                continue;
+            const info = canonical;
+            try {
+                const matrix = sample(source, info.width, info.height, wScale, box.x, box.y);
+                const result = decodeRMQR(matrix);
+                return { matrix, result, rotation, scale: wScale, corners: { x: box.x, y: box.y, width: box.width, height: box.height } };
+            }
+            catch { /* continue */ }
+        }
     }
-  }
-  throw new NotFoundError('rMQR: no clean axis-aligned symbol found');
+    throw new NotFoundError('rMQR: no clean axis-aligned symbol found');
 }
-
 function awaitableVersion(version) {
-  const sizes = [[43, 7], [59, 7], [77, 7], [99, 7], [139, 7], [43, 9], [59, 9], [77, 9], [99, 9], [139, 9], [27, 11], [43, 11], [59, 11], [77, 11], [99, 11], [139, 11], [27, 13], [43, 13], [59, 13], [77, 13], [99, 13], [139, 13], [43, 15], [59, 15], [77, 15], [99, 15], [139, 15], [43, 17], [59, 17], [77, 17], [99, 17], [139, 17]];
-  return { version, width: sizes[version - 1][0], height: sizes[version - 1][1] };
+    const sizes = [[43, 7], [59, 7], [77, 7], [99, 7], [139, 7], [43, 9], [59, 9], [77, 9], [99, 9], [139, 9], [27, 11], [43, 11], [59, 11], [77, 11], [99, 11], [139, 11], [27, 13], [43, 13], [59, 13], [77, 13], [99, 13], [139, 13], [43, 15], [59, 15], [77, 15], [99, 15], [139, 15], [43, 17], [59, 17], [77, 17], [99, 17], [139, 17]];
+    return { version, width: sizes[version - 1][0], height: sizes[version - 1][1] };
 }
-
 /** Detect and decode a raster in one call. */
 export function detectAndDecodeRMQR(image, options = {}) { return detectRMQR(image, options).result; }