@sythos/js_barcode_universal 1.5.7 → 1.5.9

package/src/js/aztec/tables.js

@@ -0,0 +1,196 @@
+/*!
+ * 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.
+ */
+/**
+ * Aztec Code layer geometry and Reed-Solomon parameters.
+ *
+ * `totalBits` counts the payload ring before its leading pad bits are added;
+ * consequently only `usableBits` can be partitioned into codewords. Compact
+ * symbols have no reference grid. Full symbols insert alternating reference
+ * rows and columns every 16 modules around the centre.
+ *
+ * The five data fields use generator base 1. GF(256)/DataMatrix is also the
+ * Aztec 8-bit field: both use primitive polynomial 0x12d.
+ *
+ * @module aztec/tables
+ */
+import { GF16, GF64, GF256_AZTEC, GF1024, GF4096 } from '../core/galois-field.js';
+/** Reed-Solomon generator base defined for Aztec parameter and data fields. */
+export const AZTEC_RS_GENERATOR_BASE = 1;
+/** Minimum recommended error correction: 23 percent plus three codewords. */
+export const AZTEC_DEFAULT_ECC_PERCENT = 23;
+export const AZTEC_MIN_ECC_WORDS = 3;
+/** Word size selected solely by the number of layers. */
+export function wordSizeForLayers(layers) {
+    if (!Number.isInteger(layers) || layers < 1 || layers > 32) {
+        throw new RangeError(`Aztec: layers must be an integer from 1 to 32 (got ${layers})`);
+    }
+    if (layers <= 2)
+        return 6;
+    if (layers <= 8)
+        return 8;
+    if (layers <= 22)
+        return 10;
+    return 12;
+}
+/** Return the field used by Aztec codewords of `wordSize` bits. */
+export function fieldForWordSize(wordSize) {
+    switch (wordSize) {
+        case 4: return GF16; // Mode message only.
+        case 6: return GF64;
+        case 8: return GF256_AZTEC;
+        case 10: return GF1024;
+        case 12: return GF4096;
+        default: throw new RangeError(`Aztec: unsupported codeword size ${wordSize}`);
+    }
+}
+/** Return the data field selected for a symbol with `layers` layers. */
+export function fieldForLayers(layers) {
+    return fieldForWordSize(wordSizeForLayers(layers));
+}
+/** Matrix side length, including Full-mode reference grid lines. */
+export function aztecSymbolSize(layers, compact = false) {
+    if (!Number.isInteger(layers) || layers < 1 || layers > (compact ? 4 : 32)) {
+        throw new RangeError(`Aztec: ${compact ? 'Compact' : 'Full'} layers out of range: ${layers}`);
+    }
+    if (compact)
+        return 11 + 4 * layers;
+    const baseMatrixSize = 14 + 4 * layers;
+    return baseMatrixSize + 1 + 2 * Math.floor((baseMatrixSize / 2 - 1) / 15);
+}
+function layer(layers, compact) {
+    const wordSize = wordSizeForLayers(layers);
+    const totalBits = ((compact ? 88 : 112) + 16 * layers) * layers;
+    const usableBits = totalBits - totalBits % wordSize;
+    const totalCodewords = usableBits / wordSize;
+    const baseMatrixSize = (compact ? 11 : 14) + 4 * layers;
+    return Object.freeze({
+        compact,
+        layers,
+        wordSize,
+        totalBits,
+        usableBits,
+        totalCodewords,
+        // Compact mode encodes the count in six bits and can therefore hold no
+        // more than 64 data codewords even where the ring itself is larger.
+        maxDataCodewords: compact ? Math.min(totalCodewords, 64) : totalCodewords,
+        baseMatrixSize,
+        symbolSize: aztecSymbolSize(layers, compact),
+        modeMessageDataWords: compact ? 2 : 4,
+        modeMessageWords: compact ? 7 : 10,
+        modeMessageBits: compact ? 28 : 40,
+        rsGeneratorBase: AZTEC_RS_GENERATOR_BASE,
+    });
+}
+/** Compact Aztec layers 1 through 4, in encoding preference order. */
+export const AZTEC_COMPACT_LAYERS = Object.freeze(Array.from({ length: 4 }, (_, i) => layer(i + 1, true)));
+/** Full Aztec layers 1 through 32, in ascending layer order. */
+export const AZTEC_FULL_LAYERS = Object.freeze(Array.from({ length: 32 }, (_, i) => layer(i + 1, false)));
+/** All allowed symbols. Compact entries precede Full entries for automatic selection. */
+export const AZTEC_LAYERS = Object.freeze([
+    ...AZTEC_COMPACT_LAYERS,
+    ...AZTEC_FULL_LAYERS,
+]);
+/** Return one immutable layer record. */
+export function aztecLayer(layers, compact = false) {
+    if (!Number.isInteger(layers) || layers < 1 || layers > (compact ? 4 : 32)) {
+        throw new RangeError(`Aztec: ${compact ? 'Compact' : 'Full'} layers out of range: ${layers}`);
+    }
+    return (compact ? AZTEC_COMPACT_LAYERS : AZTEC_FULL_LAYERS)[layers - 1];
+}
+/**
+ * Calculate the minimum parity count for a data word count.
+ *
+ * The percentage is rounded up because a fractional codeword cannot be
+ * emitted. The mandatory three words protect short payloads, where a bare
+ * percentage would otherwise round to zero.
+ */
+export function eccCodewordsFor(dataCodewords, eccPercent = AZTEC_DEFAULT_ECC_PERCENT) {
+    if (!Number.isInteger(dataCodewords) || dataCodewords < 0) {
+        throw new RangeError(`Aztec: data codewords must be a non-negative integer (got ${dataCodewords})`);
+    }
+    if (!Number.isFinite(eccPercent) || eccPercent < 0 || eccPercent > 100) {
+        throw new RangeError(`Aztec: ECC percent must be between 0 and 100 (got ${eccPercent})`);
+    }
+    return Math.ceil(dataCodewords * eccPercent / 100) + AZTEC_MIN_ECC_WORDS;
+}
+/**
+ * Choose the first symbol which holds an already stuffed payload.
+ *
+ * `dataBits` must be a multiple of the candidate word size; callers which
+ * start from high-level bits must stuff separately per candidate word size.
+ */
+export function selectAztecLayer(dataBits, { eccPercent = AZTEC_DEFAULT_ECC_PERCENT, layers = null, compact = null, } = {}) {
+    if (!Number.isInteger(dataBits) || dataBits < 0) {
+        throw new RangeError(`Aztec: data bits must be a non-negative integer (got ${dataBits})`);
+    }
+    if (compact !== null && typeof compact !== 'boolean') {
+        throw new TypeError('Aztec: compact must be true, false or null');
+    }
+    let candidates;
+    if (layers !== null) {
+        if (compact === null)
+            throw new TypeError('Aztec: compact must be specified when layers is specified');
+        candidates = [aztecLayer(layers, compact)];
+    }
+    else if (compact === null) {
+        candidates = AZTEC_LAYERS;
+    }
+    else {
+        candidates = compact ? AZTEC_COMPACT_LAYERS : AZTEC_FULL_LAYERS;
+    }
+    for (const candidate of candidates) {
+        if (dataBits % candidate.wordSize !== 0)
+            continue;
+        const dataCodewords = dataBits / candidate.wordSize;
+        const eccCodewords = eccCodewordsFor(dataCodewords, eccPercent);
+        if (dataCodewords <= candidate.maxDataCodewords &&
+            dataCodewords + eccCodewords <= candidate.totalCodewords) {
+            return Object.freeze({ ...candidate, dataCodewords, eccCodewords });
+        }
+    }
+    throw new RangeError('Aztec: payload and requested error correction do not fit an available symbol');
+}
+/** Check static identities so table corruption fails explicitly in tests. */
+export function validateAztecTables() {
+    const issues = [];
+    for (const entry of AZTEC_LAYERS) {
+        if (entry.usableBits % entry.wordSize !== 0)
+            issues.push(`${entry.compact ? 'C' : 'F'}${entry.layers}: unaligned usable bits`);
+        if (entry.totalCodewords !== entry.usableBits / entry.wordSize)
+            issues.push(`${entry.compact ? 'C' : 'F'}${entry.layers}: codeword mismatch`);
+        if (entry.symbolSize !== aztecSymbolSize(entry.layers, entry.compact))
+            issues.push(`${entry.compact ? 'C' : 'F'}${entry.layers}: matrix size mismatch`);
+        if (entry.rsGeneratorBase !== AZTEC_RS_GENERATOR_BASE)
+            issues.push(`${entry.compact ? 'C' : 'F'}${entry.layers}: generator base mismatch`);
+        if (entry.compact && entry.maxDataCodewords > 64)
+            issues.push(`C${entry.layers}: Compact data-word limit exceeded`);
+    }
+    return issues;
+}

package/src/js/aztecrune/decoder.js

@@ -0,0 +1,146 @@
+/*!
+ * 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.
+ */
+/**
+ * Aztec Rune decoder.
+ *
+ * The input is a square 11x11 module matrix. Structural modules are checked
+ * before the seven masked GF(16) codewords are Reed-Solomon corrected. The
+ * decoder tries the four in-plane quarter turns and both polarities, allowing
+ * it to consume an oriented sampled image while still rejecting ordinary
+ * Aztec/QR matrices.
+ *
+ * @module aztecrune/decoder
+ */
+import { FormatError } from '../core/errors.js';
+import { rsDecode } from '../core/reed-solomon.js';
+import { AZTEC_RUNE_DATA_POSITIONS, AZTEC_RUNE_ECC_CODEWORDS, AZTEC_RUNE_MASK, AZTEC_RUNE_SIZE, aztecRuneField, aztecRuneStructuralValue, } from './tables.js';
+/** @param {import('../core/bit-matrix.js').BitMatrix} source @param {number} turns */
+function rotateClockwise(source, turns) {
+    let current = source.clone();
+    for (let turn = 0; turn < turns; turn++) {
+        const out = new source.constructor(current.height, current.width);
+        for (let y = 0; y < current.height; y++)
+            for (let x = 0; x < current.width; x++) {
+                if (current.get(x, y))
+                    out.set(current.height - 1 - y, x);
+            }
+        current = out;
+    }
+    return current;
+}
+/** @param {import('../core/bit-matrix.js').BitMatrix} matrix */
+function invert(matrix) {
+    const out = matrix.clone();
+    for (let y = 0; y < out.height; y++)
+        for (let x = 0; x < out.width; x++)
+            out.flip(x, y);
+    return out;
+}
+/** @param {import('../core/bit-matrix.js').BitMatrix} matrix @param {boolean} inverted */
+function structureMatches(matrix, inverted) {
+    for (let y = 0; y < AZTEC_RUNE_SIZE; y++)
+        for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
+            const expected = aztecRuneStructuralValue(x, y);
+            if (expected === null)
+                continue;
+            if (matrix.get(x, y) !== (inverted ? !expected : expected))
+                return false;
+        }
+    return true;
+}
+/** @param {import('../core/bit-matrix.js').BitMatrix} matrix @param {boolean} inverted */
+function readCodewords(matrix, inverted) {
+    const words = new Array(2 + AZTEC_RUNE_ECC_CODEWORDS).fill(0);
+    for (let at = 0; at < AZTEC_RUNE_DATA_POSITIONS.length; at++) {
+        const [x, y] = AZTEC_RUNE_DATA_POSITIONS[at];
+        const bit = matrix.get(x, y) !== inverted;
+        words[at >>> 2] = (words[at >>> 2] << 1) | (bit ? 1 : 0);
+    }
+    return words.map((word) => word ^ AZTEC_RUNE_MASK);
+}
+/** @param {number} value @param {boolean} inverted @param {number} rotation @param {number} corrections */
+function result(value, inverted, rotation, corrections) {
+    return {
+        format: 'aztecrune',
+        value,
+        text: String(value).padStart(3, '0'),
+        bytes: Uint8Array.of(value),
+        dimension: AZTEC_RUNE_SIZE,
+        inverted,
+        rotation,
+        corrections,
+    };
+}
+/**
+ * Decode a square Aztec Rune matrix.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {{inverted?: boolean|'auto', rotation?: number|'auto'}} [options]
+ * @returns {{format:'aztecrune',value:number,text:string,bytes:Uint8Array,dimension:number,inverted:boolean,rotation:number,corrections:number}}
+ * @throws {FormatError} For non-Rune geometry, structure or uncorrectable data.
+ */
+export function decodeAztecRune(matrix, options = {}) {
+    if (!matrix || matrix.width !== AZTEC_RUNE_SIZE || matrix.height !== AZTEC_RUNE_SIZE) {
+        throw new FormatError(`Aztec Rune: expected an ${AZTEC_RUNE_SIZE}x${AZTEC_RUNE_SIZE} module matrix`);
+    }
+    const invertedModes = options.inverted === true ? [true] : options.inverted === false ? [false] : [false, true];
+    const rotations = Number.isInteger(options.rotation)
+        ? [((options.rotation % 360) + 360) % 360]
+        : [0, 90, 180, 270];
+    let checksumError = null;
+    for (const requestedRotation of rotations) {
+        if (requestedRotation % 90 !== 0)
+            continue;
+        // To canonicalize an input rotated clockwise by k degrees, rotate it
+        // counter-clockwise by k. `turns` is the clockwise operation we apply.
+        const turns = (4 - requestedRotation / 90) % 4;
+        const canonicalRotation = requestedRotation;
+        const rotated = turns === 0 ? matrix.clone() : rotateClockwise(matrix, turns);
+        for (const inverted of invertedModes) {
+            const canonical = inverted ? invert(rotated) : rotated;
+            if (!structureMatches(canonical, false))
+                continue;
+            const words = readCodewords(canonical, false);
+            try {
+                const corrections = rsDecode(words, AZTEC_RUNE_ECC_CODEWORDS, aztecRuneField(), 1);
+                const value = (words[0] << 4) | words[1];
+                return result(value, inverted, canonicalRotation, corrections);
+            }
+            catch (error) {
+                checksumError = error;
+            }
+        }
+    }
+    if (checksumError) {
+        throw new FormatError(`Aztec Rune: Reed-Solomon check failed: ${checksumError.message}`);
+    }
+    throw new FormatError('Aztec Rune: structural pattern or orientation is invalid');
+}
+export { readCodewords, structureMatches };

package/src/js/aztecrune/detector.js

@@ -0,0 +1,180 @@
+/*!
+ * 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.
+ */
+/**
+ * Detector for Aztec Rune symbols.
+ *
+ * Rune has a fixed 11x11 geometry and a distinctive five-ring bull's-eye. This
+ * detector targets binarized, module-aligned rasters (including an integer
+ * scale, quiet zone and quarter turns). Arbitrary perspective and severe blur
+ * remain detector-level limitations; callers needing those conditions should
+ * pass a rectified 11x11 matrix to decodeAztecRune.
+ *
+ * @module aztecrune/detector
+ */
+import { NotFoundError } from '../core/errors.js';
+import { BitMatrix } from '../core/bit-matrix.js';
+import { decodeAztecRune } from './decoder.js';
+import { AZTEC_RUNE_SIZE } from './tables.js';
+/** @typedef {{x:number,y:number}} Point */
+/**
+ * Find connected components of a polarity. Components touching the image
+ * border are ignored when they exceed the plausible module area; this avoids
+ * returning the light background as a candidate while retaining an inverted
+ * Rune's isolated light centre module.
+ */
+function components(image, value) {
+    const width = image.width;
+    const height = image.height;
+    const seen = new Uint8Array(width * height);
+    const limit = Math.max(64, Math.floor(width * height * 0.04));
+    const found = [];
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            const start = y * width + x;
+            if (seen[start] || image.get(x, y) !== value)
+                continue;
+            const queue = [[x, y]];
+            seen[start] = 1;
+            let head = 0;
+            let minX = x;
+            let maxX = x;
+            let minY = y;
+            let maxY = y;
+            let count = 0;
+            let touchesBorder = false;
+            while (head < queue.length) {
+                const [px, py] = queue[head++];
+                count++;
+                minX = Math.min(minX, px);
+                maxX = Math.max(maxX, px);
+                minY = Math.min(minY, py);
+                maxY = Math.max(maxY, py);
+                if (px === 0 || py === 0 || px === width - 1 || py === height - 1)
+                    touchesBorder = true;
+                for (const [nx, ny] of [[px - 1, py], [px + 1, py], [px, py - 1], [px, py + 1]]) {
+                    if (nx < 0 || ny < 0 || nx >= width || ny >= height)
+                        continue;
+                    const at = ny * width + nx;
+                    if (!seen[at] && image.get(nx, ny) === value) {
+                        seen[at] = 1;
+                        queue.push([nx, ny]);
+                    }
+                }
+            }
+            const boxWidth = maxX - minX + 1;
+            const boxHeight = maxY - minY + 1;
+            if (count <= limit && !touchesBorder &&
+                Math.abs(boxWidth - boxHeight) <= Math.max(1, Math.ceil(Math.max(boxWidth, boxHeight) * 0.35)) &&
+                count >= boxWidth * boxHeight * 0.45) {
+                found.push({ x: (minX + maxX) / 2, y: (minY + maxY) / 2, width: boxWidth, height: boxHeight, count });
+            }
+        }
+    return found.sort((a, b) => b.count - a.count);
+}
+/** @param {import('../core/bit-matrix.js').BitMatrix} image @param {Point} center @param {number} pitch */
+function sample(image, center, pitch) {
+    const matrix = new BitMatrix(AZTEC_RUNE_SIZE);
+    for (let y = 0; y < AZTEC_RUNE_SIZE; y++)
+        for (let x = 0; x < AZTEC_RUNE_SIZE; x++) {
+            const px = Math.round(center.x + (x - 5) * pitch);
+            const py = Math.round(center.y + (y - 5) * pitch);
+            if (px >= 0 && py >= 0 && px < image.width && py < image.height && image.get(px, py))
+                matrix.set(x, y);
+        }
+    return matrix;
+}
+function corners(center, pitch) {
+    const half = AZTEC_RUNE_SIZE * pitch / 2;
+    return [
+        { x: center.x - half, y: center.y - half },
+        { x: center.x + half, y: center.y - half },
+        { x: center.x + half, y: center.y + half },
+        { x: center.x - half, y: center.y + half },
+    ];
+}
+function sameCandidate(left, right) {
+    return Math.hypot(left.center.x - right.center.x, left.center.y - right.center.y) <= Math.max(left.moduleSize, right.moduleSize) * 2;
+}
+/**
+ * Detect the most prominent Aztec Rune in a binarized image.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @returns {{corners:Point[],dimension:11,moduleSize:number,matrix:BitMatrix,result:object}|null}
+ */
+export function detectAztecRune(binaryImage) {
+    if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+        throw new NotFoundError('detectAztecRune: no image supplied');
+    }
+    const candidates = [];
+    for (const value of [true, false]) {
+        for (const component of components(binaryImage, value)) {
+            const pitch = (component.width + component.height) / 2;
+            if (pitch < 0.8)
+                continue;
+            const matrix = sample(binaryImage, component, pitch);
+            let decoded;
+            try {
+                decoded = decodeAztecRune(matrix);
+            }
+            catch {
+                continue;
+            }
+            const candidate = {
+                center: component,
+                corners: corners(component, pitch),
+                dimension: AZTEC_RUNE_SIZE,
+                moduleSize: pitch,
+                matrix,
+                result: decoded,
+            };
+            if (!candidates.some((entry) => sameCandidate(entry, candidate)))
+                candidates.push(candidate);
+        }
+    }
+    candidates.sort((a, b) => b.moduleSize - a.moduleSize);
+    const best = candidates[0];
+    if (!best)
+        return null;
+    delete best.center;
+    return best;
+}
+/** Detect and decode one Aztec Rune, or return `null` when none is verified. */
+export function detectAndDecodeAztecRune(binaryImage) {
+    let detection;
+    try {
+        detection = detectAztecRune(binaryImage);
+    }
+    catch {
+        return null;
+    }
+    if (!detection)
+        return null;
+    return { ...detection.result, corners: detection.corners, moduleSize: detection.moduleSize };
+}

package/src/js/aztecrune/encoder.js

@@ -0,0 +1,103 @@
+/*!
+ * 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 { EncodeError } from '../core/errors.js';
+import { rsEncode } from '../core/reed-solomon.js';
+import { AZTEC_RUNE_DATA_POSITIONS, AZTEC_RUNE_ECC_CODEWORDS, AZTEC_RUNE_MASK, AZTEC_RUNE_SIZE, aztecRuneField, buildAztecRuneStructure, } from './tables.js';
+/** @param {unknown} value @returns {number} */
+export function normalizeAztecRuneValue(value) {
+    if (typeof value === 'number') {
+        if (Number.isInteger(value) && value >= 0 && value <= 255)
+            return value;
+        throw new EncodeError('Aztec Rune: numeric value must be an integer from 0 to 255');
+    }
+    if (typeof value === 'string') {
+        if (!/^\d{1,3}$/.test(value))
+            throw new EncodeError('Aztec Rune: text input must contain one to three decimal digits');
+        const numeric = Number(value);
+        if (numeric > 255)
+            throw new EncodeError('Aztec Rune: decimal value must be from 000 to 255');
+        return numeric;
+    }
+    let bytes = null;
+    if (value instanceof ArrayBuffer)
+        bytes = new Uint8Array(value);
+    else if (ArrayBuffer.isView(value))
+        bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    if (bytes) {
+        if (bytes.length !== 1)
+            throw new EncodeError('Aztec Rune: binary input must contain exactly one byte');
+        return bytes[0];
+    }
+    throw new EncodeError('Aztec Rune: expected a number, decimal string or one-byte binary value');
+}
+/** @param {number} value @returns {number[]} */
+function codewordsForValue(value) {
+    const data = [value >>> 4, value & 0x0f];
+    const parity = rsEncode(data, AZTEC_RUNE_ECC_CODEWORDS, aztecRuneField(), 1);
+    return data.concat(parity).map((word) => word ^ AZTEC_RUNE_MASK);
+}
+/** @param {BitMatrix} matrix @param {number[]} codewords */
+function writeDataRing(matrix, codewords) {
+    for (let word = 0; word < codewords.length; word++) {
+        for (let bit = 0; bit < 4; bit++) {
+            const at = word * 4 + bit;
+            const [x, y] = AZTEC_RUNE_DATA_POSITIONS[at];
+            matrix.setValue(x, y, ((codewords[word] >>> (3 - bit)) & 1) !== 0);
+        }
+    }
+}
+/**
+ * Encode one byte as an Aztec Rune.
+ *
+ * @param {number|string|ArrayBuffer|ArrayBufferView} value
+ * @param {{inverted?: boolean}} [options]
+ * @returns {import('../core/bit-matrix.js').BitMatrix & {
+ *   format: 'aztecrune', value: number, inverted: boolean
+ * }}
+ */
+export function encodeAztecRune(value, options = {}) {
+    const numeric = normalizeAztecRuneValue(value);
+    if (options.inverted !== undefined && typeof options.inverted !== 'boolean') {
+        throw new EncodeError('Aztec Rune: inverted must be boolean');
+    }
+    const inverted = options.inverted === true;
+    const matrix = buildAztecRuneStructure();
+    writeDataRing(matrix, codewordsForValue(numeric));
+    if (inverted) {
+        for (let y = 0; y < AZTEC_RUNE_SIZE; y++)
+            for (let x = 0; x < AZTEC_RUNE_SIZE; x++)
+                matrix.flip(x, y);
+    }
+    matrix.format = 'aztecrune';
+    matrix.value = numeric;
+    matrix.inverted = inverted;
+    return matrix;
+}
+export { codewordsForValue };

package/src/js/aztecrune/index.js

@@ -0,0 +1,34 @@
+/*!
+ * 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.
+ */
+/** Aztec Rune entry points. @module aztecrune */
+export { encodeAztecRune, normalizeAztecRuneValue } from './encoder.js';
+export { decodeAztecRune } from './decoder.js';
+export { detectAztecRune, detectAndDecodeAztecRune } from './detector.js';
+export { AZTEC_RUNE_SIZE, AZTEC_RUNE_DATA_BITS, AZTEC_RUNE_WORD_SIZE, AZTEC_RUNE_DATA_CODEWORDS, AZTEC_RUNE_ECC_CODEWORDS, AZTEC_RUNE_TOTAL_CODEWORDS, AZTEC_RUNE_MASK, AZTEC_RUNE_DATA_POSITIONS, aztecRuneStructuralValue, buildAztecRuneStructure, aztecRuneField, validateAztecRuneTables, } from './tables.js';