@sythos/js_barcode_universal 1.5.7 → 1.5.9

package/src/js/rmqr/decoder.js

@@ -0,0 +1,209 @@
+/*!
+ * 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.
+ */
+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, 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 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;
+}
+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;
+}
+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 };
+}
+function decodeBytes(bytes, eci) {
+    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) };
+}
+/** 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 };
+}
+export { ChecksumError };

package/src/js/rmqr/detector.js

@@ -0,0 +1,122 @@
+/*!
+ * 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.
+ */
+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;
+}
+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;
+}
+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;
+}
+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 */ }
+        }
+    }
+    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] };
+}
+/** Detect and decode a raster in one call. */
+export function detectAndDecodeRMQR(image, options = {}) { return detectRMQR(image, options).result; }

package/src/js/rmqr/encoder.js

@@ -0,0 +1,321 @@
+/*!
+ * 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.
+ */
+import { BitMatrix } from '../core/bit-matrix.js';
+import { BitWriter } from '../core/bit-buffer.js';
+import { EncodeError } from '../core/errors.js';
+import { GF256_QR } from '../core/galois-field.js';
+import { rsEncode } from '../core/reed-solomon.js';
+import { FORMAT_MASK_FINDER, FORMAT_MASK_SUB, dataBitCapacity, dataModuleOrder, formatBits, functionModules, maskBit, versionForSize, versionInfo, } from './tables.js';
+export const ALPHANUMERIC_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';
+const MODE = Object.freeze({ TERMINATOR: 0, NUMERIC: 1, ALPHANUMERIC: 2, BYTE: 3, KANJI: 4, FNC1: 5, FNC1_SECOND: 6, ECI: 7 });
+function utf8Bytes(text) { return new TextEncoder().encode(text); }
+function latin1Bytes(text) { const out = new Uint8Array(text.length); for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c > 255)
+        throw new EncodeError('rMQR: text is not ISO-8859-1');
+    out[i] = c;
+} return out; }
+function isAlpha(text) { for (const ch of text)
+    if (ALPHANUMERIC_CHARS.indexOf(ch) < 0)
+        return false; return true; }
+function isNumeric(text) { return /^[0-9]*$/.test(text); }
+let sjisMap;
+function getSjisMap() {
+    if (sjisMap !== undefined)
+        return sjisMap;
+    try {
+        const decoder = new TextDecoder('shift_jis', { fatal: true });
+        if (decoder.decode(new Uint8Array([0x82, 0xa0])) !== 'あ')
+            return (sjisMap = null);
+        const map = new Map();
+        const buf = new Uint8Array(2);
+        for (const [lo, hi] of [[0x8140, 0x9ffc], [0xe040, 0xebbf]])
+            for (let sjis = lo; sjis <= hi; sjis++) {
+                const trail = sjis & 255;
+                if (trail < 0x40 || trail === 0x7f || trail > 0xfc)
+                    continue;
+                buf[0] = sjis >> 8;
+                buf[1] = trail;
+                let text;
+                try {
+                    text = decoder.decode(buf);
+                }
+                catch {
+                    continue;
+                }
+                if (Array.from(text).length === 1 && !map.has(text))
+                    map.set(text, sjis);
+            }
+        return (sjisMap = map);
+    }
+    catch {
+        return (sjisMap = null);
+    }
+}
+function kanjiValue(ch) {
+    const sjis = getSjisMap()?.get(ch);
+    if (sjis === undefined)
+        return -1;
+    let v;
+    if (sjis >= 0x8140 && sjis <= 0x9ffc)
+        v = sjis - 0x8140;
+    else if (sjis >= 0xe040 && sjis <= 0xebbf)
+        v = sjis - 0xc140;
+    else
+        return -1;
+    return ((v >> 8) * 0xc0) + (v & 0xff);
+}
+function chooseMode(text, requested) {
+    if (requested === 'numeric' || requested === 'alphanumeric' || requested === 'byte' || requested === 'kanji')
+        return requested;
+    if (isNumeric(text))
+        return 'numeric';
+    if (isAlpha(text))
+        return 'alphanumeric';
+    return 'byte';
+}
+function modeBits(mode) { return MODE[mode.toUpperCase()] ?? MODE.BYTE; }
+function charCount(mode, text, bytes) { return mode === 'byte' ? bytes.length : mode === 'kanji' ? Array.from(text).length : text.length; }
+function payloadBits(mode, text, bytes) {
+    if (mode === 'numeric') {
+        let n = 0;
+        for (let i = 0; i < text.length; i += 3)
+            n += text.length - i >= 3 ? 10 : text.length - i === 2 ? 7 : 4;
+        return n;
+    }
+    if (mode === 'alphanumeric')
+        return Math.floor(text.length / 2) * 11 + (text.length & 1 ? 6 : 0);
+    if (mode === 'kanji')
+        return Array.from(text).length * 13;
+    return bytes.length * 8;
+}
+function putEci(writer, assignment) {
+    writer.put(MODE.ECI, 3);
+    if (assignment <= 127)
+        writer.put(assignment, 8);
+    else if (assignment <= 16383)
+        writer.put(0x8000 | assignment, 16);
+    else if (assignment <= 999999)
+        writer.put(0xc00000 | assignment, 24);
+    else
+        throw new EncodeError(`rMQR: invalid ECI assignment ${assignment}`);
+}
+function makeData(text, v, ecc, options) {
+    const requested = options.mode;
+    const mode = chooseMode(text, requested);
+    const charset = options.charset || (mode === 'byte' && Array.from(text).every((ch) => ch.charCodeAt(0) <= 255) ? 'iso-8859-1' : 'utf-8');
+    const bytes = mode === 'byte' ? (charset === 'iso-8859-1' ? latin1Bytes(text) : utf8Bytes(text)) : new Uint8Array();
+    const countBits = v.countBits(mode);
+    if (!countBits)
+        throw new EncodeError(`rMQR: unsupported mode ${mode}`);
+    const writer = new BitWriter();
+    if (options.eci !== undefined)
+        putEci(writer, options.eci);
+    else if (mode === 'byte' && charset === 'utf-8')
+        putEci(writer, 26);
+    writer.put(modeBits(mode), 3);
+    writer.put(charCount(mode, text, bytes), countBits); // header
+    if (mode === 'numeric')
+        for (let i = 0; i < text.length; i += 3) {
+            const s = text.slice(i, i + 3);
+            writer.put(Number(s), s.length === 3 ? 10 : s.length === 2 ? 7 : 4);
+        }
+    else if (mode === 'alphanumeric')
+        for (let i = 0; i < text.length; i += 2) {
+            const a = ALPHANUMERIC_CHARS.indexOf(text[i]);
+            const b = i + 1 < text.length ? ALPHANUMERIC_CHARS.indexOf(text[i + 1]) : -1;
+            if (a < 0 || (b < 0 && i + 1 < text.length))
+                throw new EncodeError('rMQR: invalid alphanumeric character');
+            writer.put(b < 0 ? a : a * 45 + b, b < 0 ? 6 : 11);
+        }
+    else if (mode === 'kanji')
+        for (const ch of Array.from(text)) {
+            const value = kanjiValue(ch);
+            if (value < 0)
+                throw new EncodeError(`rMQR: character ${ch} is not encodable in Kanji mode`);
+            writer.put(value, 13);
+        }
+    else
+        writer.putBytes(bytes);
+    const capacity = dataBitCapacity(v.version, ecc);
+    if (writer.length > capacity)
+        throw new EncodeError(`rMQR: payload does not fit ${v.name}-${ecc}`);
+    if (writer.length + 3 <= capacity)
+        writer.put(0, 3);
+    while (writer.length & 7)
+        writer.putBit(false);
+    const dataBytes = v.blockLayout(ecc).totalDataCodewords;
+    let pad = 0xec;
+    while (writer.toBytes().length < dataBytes) {
+        writer.put(pad, 8);
+        pad = pad === 0xec ? 0x11 : 0xec;
+    }
+    return writer.toBytes();
+}
+function interleave(data, v, ecc) {
+    const layout = v.blockLayout(ecc);
+    const blocks = [];
+    let offset = 0;
+    for (const b of layout.blocks) {
+        const d = Array.from(data.slice(offset, offset + b.data));
+        offset += b.data;
+        blocks.push({ data: d, ecc: rsEncode(d, b.ecc, GF256_QR, 0) });
+    }
+    const out = [];
+    const maxData = Math.max(...blocks.map((b) => b.data.length));
+    const maxEcc = Math.max(...blocks.map((b) => b.ecc.length));
+    for (let i = 0; i < maxData; i++)
+        for (const b of blocks)
+            if (i < b.data.length)
+                out.push(b.data[i]);
+    for (let i = 0; i < maxEcc; i++)
+        for (const b of blocks)
+            if (i < b.ecc.length)
+                out.push(b.ecc[i]);
+    return Uint8Array.from(out);
+}
+function drawFunctions(m, version) {
+    const v = versionInfo(version);
+    const fn = functionModules(version);
+    const { width: w, height: h } = v;
+    const setIfData = (x, y, on) => { if (!fn.get(x, y))
+        m.setValue(x, y, on); };
+    for (let x = 0; x < w; x++) {
+        m.setValue(x, 0, (x & 1) === 0);
+        m.setValue(x, h - 1, (x & 1) === 0);
+    }
+    for (const x of [0, w - 1, ...new Set([...(awaitableAlignment(version))])])
+        for (let y = 0; y < h; y++)
+            setIfData(x, y, (y & 1) === 0);
+    for (const cx of awaitableAlignment(version))
+        for (const y of [0, 1, h - 2, h - 1])
+            m.setValue(cx + (y === 0 || y === h - 1 ? 0 : 0), y, false);
+    // Alignment patterns (top and bottom).
+    for (const cx of awaitableAlignment(version))
+        for (let i = 0; i < 3; i++)
+            for (let j = 0; j < 3; j++) {
+                const on = i === 0 || i === 2 || j === 0 || j === 2;
+                m.setValue(cx + j - 1, i, on);
+                m.setValue(cx + j - 1, h - 1 - i, on);
+            }
+    // Finder and separator.
+    for (let i = 0; i < 7; i++)
+        for (let j = 0; j < 7; j++)
+            m.setValue(j, i, i === 0 || i === 6 || j === 0 || j === 6 || (i >= 2 && i <= 4 && j >= 2 && j <= 4));
+    for (let n = 0; n < 8; n++) {
+        if (n < h)
+            m.setValue(7, n, false);
+        if (h >= 9)
+            m.setValue(n, 7, false);
+    }
+    for (let i = 0; i < 5; i++)
+        for (let j = 0; j < 5; j++)
+            m.setValue(w - j - 1, h - i - 1, i === 0 || i === 4 || j === 0 || j === 4 || (i === 2 && j === 2));
+    m.set(w - 1, 0);
+    m.set(w - 2, 0);
+    m.set(w - 1, 1);
+    if (h >= 11) {
+        m.set(0, h - 1);
+        m.set(1, h - 1);
+        m.set(2, h - 1);
+        m.set(0, h - 2);
+    }
+}
+// Kept as a local helper so drawFunctions stays independent of mutable tables.
+function awaitableAlignment(version) { return ({ 27: [], 43: [21], 59: [19, 39], 77: [25, 51], 99: [23, 49, 75], 139: [27, 55, 83, 111] })[versionInfo(version).width] || []; }
+function drawFormat(m, version, ecc) {
+    const v = versionInfo(version);
+    let bits = formatBits(version, ecc) ^ FORMAT_MASK_FINDER;
+    for (let n = 0; n < 18; n++)
+        m.setValue(8 + Math.floor(n / 5), 1 + (n % 5), ((bits >>> n) & 1) !== 0);
+    bits = formatBits(version, ecc) ^ FORMAT_MASK_SUB;
+    for (let n = 0; n < 15; n++)
+        m.setValue(v.width - 8 + Math.floor(n / 5), v.height - 6 + (n % 5), ((bits >>> n) & 1) !== 0);
+    for (let n = 15; n < 18; n++)
+        m.setValue(v.width - 5 + (n - 15), v.height - 6, ((bits >>> n) & 1) !== 0);
+}
+function buildMatrix(version, ecc, codewords) {
+    const v = versionInfo(version);
+    const m = new BitMatrix(v.width, v.height);
+    drawFunctions(m, version);
+    drawFormat(m, version, ecc);
+    const fn = functionModules(version);
+    const order = dataModuleOrder(version);
+    let bit = 0;
+    for (const [x, y] of order) {
+        let on = bit < codewords.length * 8 && ((codewords[bit >>> 3] >>> (7 - (bit & 7))) & 1) !== 0;
+        if (maskBit(x, y))
+            on = !on;
+        m.setValue(x, y, on);
+        bit++;
+    }
+    return m;
+}
+/** Encode text into a rMQR module matrix. */
+export function encodeRMQR(text, options = {}) {
+    if (typeof text !== 'string' || text.length === 0)
+        throw new EncodeError('rMQR: text must be a non-empty string');
+    const ecc = options.ecc || 'M';
+    if (ecc !== 'M' && ecc !== 'H')
+        throw new EncodeError('rMQR: ECC must be M or H');
+    let forced = options.version;
+    if (typeof forced === 'string') {
+        const match = /^R(\d+)x(\d+)$/i.exec(forced);
+        if (!match)
+            throw new EncodeError(`rMQR: invalid version ${forced}`);
+        const info = versionForSize(Number(match[2]), Number(match[1]));
+        if (!info)
+            throw new EncodeError(`rMQR: unsupported version ${forced}`);
+        forced = info.version;
+    }
+    if (forced !== undefined && (!Number.isInteger(forced) || forced < 1 || forced > 32))
+        throw new EncodeError('rMQR: version must be 1-32');
+    const versions = forced ? [forced] : Array.from({ length: 32 }, (_, i) => i + 1);
+    let selected = null;
+    for (const n of versions) {
+        const v = versionInfo(n);
+        try {
+            const data = makeData(text, v, ecc, options);
+            selected = { v, data };
+            break;
+        }
+        catch (error) {
+            if (forced)
+                throw error;
+        }
+    }
+    if (!selected)
+        throw new EncodeError(`rMQR: text is too long for ECC ${ecc}`);
+    const codewords = interleave(selected.data, selected.v, ecc);
+    const matrix = buildMatrix(selected.v.version, ecc, codewords);
+    matrix.rmqr = { version: selected.v.version, name: selected.v.name, ecc };
+    return matrix;
+}
+export { MODE };

package/src/js/rmqr/index.js

@@ -0,0 +1,33 @@
+/*!
+ * 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 { encodeRMQR, ALPHANUMERIC_CHARS } from './encoder.js';
+export { decodeRMQR } from './decoder.js';
+export { detectRMQR, detectAndDecodeRMQR } from './detector.js';
+export { RMQR_SIZES, versionInfo, versionForSize, alignmentCoordinates, dataModuleOrder, functionModules, dataBitCapacity, formatBits, maskBit, validateTables, } from './tables.js';