@forgesworn/qr 0.0.0-seed.0

package/dist/symbol.js

@@ -0,0 +1,250 @@
+import { ALPHANUMERIC, blocksFor, countBand, EC_ORDER, FORMAT_COORDS, formatBits, Grid, maskBit, versionBits, } from './encode.js';
+import { correct } from './rs.js';
+import { fromUtf8, isUtf8 } from './text.js';
+const FORMATS = EC_ORDER.flatMap((ecc) => [0, 1, 2, 3, 4, 5, 6, 7].map((mask) => ({ bits: formatBits(ecc, mask), ecc, mask })));
+const VERSIONS = Array.from({ length: 34 }, (_, i) => ({
+    bits: versionBits(i + 7),
+    version: i + 7,
+}));
+function popcount(n) {
+    let c = 0;
+    for (; n !== 0; n &= n - 1)
+        c++;
+    return c;
+}
+function nearest(table, reads) {
+    let best;
+    let distance = 4; // both codes correct up to three bit errors
+    for (const read of reads) {
+        for (const entry of table) {
+            const d = popcount(entry.bits ^ read);
+            if (d < distance) {
+                distance = d;
+                best = entry;
+            }
+        }
+    }
+    return best;
+}
+/** The version a symbol of `size` modules declares, when its version blocks can be read. */
+export function readVersion(read, size) {
+    if (size < 45)
+        return (size - 17) / 4;
+    let bottomLeft = 0;
+    let topRight = 0;
+    for (let k = 17; k >= 0; k--) {
+        const i = Math.floor(k / 3);
+        const j = k % 3;
+        bottomLeft = (bottomLeft << 1) | (read(i, size - 11 + j) ? 1 : 0);
+        topRight = (topRight << 1) | (read(size - 11 + j, i) ? 1 : 0);
+    }
+    return nearest(VERSIONS, [bottomLeft, topRight])?.version;
+}
+/**
+ * Decodes a symbol from its modules. `size` must be 17 + 4v; for version 7
+ * and up the version blocks decide, and a size that disagrees fails.
+ * Returns undefined when the symbol cannot be read.
+ */
+export function readSymbol(read, size) {
+    if (size < 21 || size > 177 || (size - 17) % 4 !== 0)
+        return undefined;
+    const version = readVersion(read, size);
+    if (version === undefined || 17 + 4 * version !== size)
+        return undefined;
+    let first = 0;
+    let second = 0;
+    for (let i = 14; i >= 0; i--) {
+        const [x, y] = FORMAT_COORDS[i];
+        first = (first << 1) | (read(x, y) ? 1 : 0);
+        second = (second << 1) | (read(i < 8 ? size - 1 - i : 8, i < 8 ? 8 : size - 7 + (i - 8)) ? 1 : 0);
+    }
+    const format = nearest(FORMATS, [first, second]);
+    if (format === undefined)
+        return undefined;
+    const grid = new Grid(version);
+    const [ecPerBlock, g1, d1, g2] = blocksFor(version, format.ecc);
+    const blockCount = g1 + g2;
+    const total = g1 * d1 + g2 * (d1 + 1) + blockCount * ecPerBlock;
+    const stream = new Uint8Array(total);
+    let bit = 0;
+    let upward = true;
+    for (let right = size - 1; right >= 1 && bit < total * 8; right -= 2) {
+        if (right === 6)
+            right = 5;
+        for (let step = 0; step < size; step++) {
+            const y = upward ? size - 1 - step : step;
+            for (let i = 0; i < 2; i++) {
+                const x = right - i;
+                if (grid.isReserved(x, y) || bit >= total * 8)
+                    continue;
+                if (read(x, y) !== maskBit(format.mask, x, y))
+                    stream[bit >>> 3] |= 0x80 >>> (bit & 7);
+                bit++;
+            }
+        }
+        upward = !upward;
+    }
+    const blocks = [];
+    for (let b = 0; b < blockCount; b++)
+        blocks.push(new Uint8Array((b < g1 ? d1 : d1 + 1) + ecPerBlock));
+    let k = 0;
+    for (let i = 0; i <= d1; i++) {
+        for (let b = 0; b < blockCount; b++)
+            if (i < (b < g1 ? d1 : d1 + 1))
+                blocks[b][i] = stream[k++];
+    }
+    for (let i = 0; i < ecPerBlock; i++) {
+        for (let b = 0; b < blockCount; b++)
+            blocks[b][(b < g1 ? d1 : d1 + 1) + i] = stream[k++];
+    }
+    const data = new Uint8Array(g1 * d1 + g2 * (d1 + 1));
+    let corrected = 0;
+    for (let b = 0, offset = 0; b < blockCount; b++) {
+        const fixed = correct(blocks[b], ecPerBlock);
+        if (fixed < 0)
+            return undefined;
+        corrected += fixed;
+        const length = b < g1 ? d1 : d1 + 1;
+        data.set(blocks[b].subarray(0, length), offset);
+        offset += length;
+    }
+    const parsed = parse(data, version);
+    if (parsed === undefined)
+        return undefined;
+    return { ...parsed, version, ecc: format.ecc, mask: format.mask, corrected };
+}
+class Bits {
+    data;
+    position = 0;
+    constructor(data) {
+        this.data = data;
+    }
+    get available() {
+        return this.data.length * 8 - this.position;
+    }
+    read(count) {
+        if (count > this.available)
+            throw new RangeError('Ran off the end of the data');
+        let value = 0;
+        for (let i = 0; i < count; i++, this.position++) {
+            value = (value << 1) | ((this.data[this.position >>> 3] >>> (7 - (this.position & 7))) & 1);
+        }
+        return value;
+    }
+}
+const KANJI_COUNT_BITS = [8, 10, 12];
+function parse(data, version) {
+    const bits = new Bits(data);
+    const band = countBand(version);
+    const runs = [{ eci: undefined, bytes: [] }];
+    const eci = [];
+    const out = [];
+    const emit = (byte) => {
+        runs[runs.length - 1].bytes.push(byte);
+        out.push(byte);
+    };
+    try {
+        while (bits.available >= 4) {
+            const mode = bits.read(4);
+            if (mode === 0)
+                break;
+            if (mode === 1) {
+                let count = bits.read([10, 12, 14][band]);
+                for (; count >= 3; count -= 3) {
+                    const v = bits.read(10);
+                    if (v > 999)
+                        return undefined;
+                    for (const c of String(v).padStart(3, '0'))
+                        emit(c.charCodeAt(0));
+                }
+                if (count > 0) {
+                    const v = bits.read(count === 2 ? 7 : 4);
+                    if (v >= (count === 2 ? 100 : 10))
+                        return undefined;
+                    for (const c of String(v).padStart(count, '0'))
+                        emit(c.charCodeAt(0));
+                }
+            }
+            else if (mode === 2) {
+                let count = bits.read([9, 11, 13][band]);
+                for (; count >= 2; count -= 2) {
+                    const v = bits.read(11);
+                    if (v >= 45 * 45)
+                        return undefined;
+                    emit(ALPHANUMERIC.charCodeAt(Math.floor(v / 45)));
+                    emit(ALPHANUMERIC.charCodeAt(v % 45));
+                }
+                if (count === 1) {
+                    const v = bits.read(6);
+                    if (v >= 45)
+                        return undefined;
+                    emit(ALPHANUMERIC.charCodeAt(v));
+                }
+            }
+            else if (mode === 4) {
+                const count = bits.read([8, 16, 16][band]);
+                for (let i = 0; i < count; i++)
+                    emit(bits.read(8));
+            }
+            else if (mode === 8) {
+                // Kanji: kept as its Shift_JIS bytes; the text shows U+FFFD for each.
+                const count = bits.read(KANJI_COUNT_BITS[band]);
+                for (let i = 0; i < count; i++) {
+                    const v = bits.read(13);
+                    let sjis = (Math.floor(v / 0xc0) << 8) | v % 0xc0;
+                    sjis += sjis < 0x1f00 ? 0x8140 : 0xc140;
+                    out.push(sjis >>> 8, sjis & 0xff);
+                    runs.push({ eci: -1, bytes: [] }, { eci: runs[runs.length - 1].eci, bytes: [] });
+                }
+            }
+            else if (mode === 7) {
+                const first = bits.read(8);
+                const value = (first & 0x80) === 0
+                    ? first
+                    : (first & 0xc0) === 0x80
+                        ? ((first & 0x3f) << 8) | bits.read(8)
+                        : (first & 0xe0) === 0xc0
+                            ? ((first & 0x1f) << 16) | bits.read(16)
+                            : -1;
+                if (value < 0)
+                    return undefined;
+                eci.push(value);
+                runs.push({ eci: value, bytes: [] });
+            }
+            else if (mode === 3) {
+                bits.read(16); // structured append: position, total and parity; one symbol is read alone
+            }
+            else if (mode === 5) {
+                // FNC1 in first position: GS1 data follows in ordinary segments
+            }
+            else if (mode === 9) {
+                bits.read(8); // FNC1 in second position: application indicator
+            }
+            else {
+                return undefined;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    let text = '';
+    for (const run of runs)
+        text += run.eci === -1 ? '�' : decodeRun(run);
+    return { text, bytes: Uint8Array.from(out), eci };
+}
+/** ECI 26 is UTF-8; 3 and 1 are Latin-1. Without ECI, valid UTF-8 is taken as UTF-8, else Latin-1. */
+function decodeRun(run) {
+    const bytes = Uint8Array.from(run.bytes);
+    if (run.eci === 3 || run.eci === 1)
+        return latin1(bytes);
+    if (run.eci === 26 || isUtf8(bytes))
+        return fromUtf8(bytes);
+    return latin1(bytes);
+}
+function latin1(bytes) {
+    let s = '';
+    for (const b of bytes)
+        s += String.fromCharCode(b);
+    return s;
+}

package/dist/tables.d.ts

@@ -0,0 +1,8 @@
+/** Alignment pattern centre coordinates, indexed by version - 1. */
+export declare const ALIGNMENT_CENTRES: readonly (readonly number[])[];
+/**
+ * Error correction blocks, indexed by version - 1 then level (L, M, Q, H):
+ * [EC codewords per block, group 1 blocks, group 1 data codewords per block,
+ * group 2 blocks]. Group 2 blocks each hold one more data codeword.
+ */
+export declare const EC_BLOCKS: readonly (readonly (readonly [number, number, number, number])[])[];

package/dist/tables.js

@@ -0,0 +1,93 @@
+// Values from ISO/IEC 18004:2015 Table 9 (error correction blocks) and Annex E
+// (alignment pattern centres). test/tables.test.ts checks every row against
+// the module count of its version.
+/** Alignment pattern centre coordinates, indexed by version - 1. */
+export const ALIGNMENT_CENTRES = [
+    [],
+    [6, 18],
+    [6, 22],
+    [6, 26],
+    [6, 30],
+    [6, 34],
+    [6, 22, 38],
+    [6, 24, 42],
+    [6, 26, 46],
+    [6, 28, 50],
+    [6, 30, 54],
+    [6, 32, 58],
+    [6, 34, 62],
+    [6, 26, 46, 66],
+    [6, 26, 48, 70],
+    [6, 26, 50, 74],
+    [6, 30, 54, 78],
+    [6, 30, 56, 82],
+    [6, 30, 58, 86],
+    [6, 34, 62, 90],
+    [6, 28, 50, 72, 94],
+    [6, 26, 50, 74, 98],
+    [6, 30, 54, 78, 102],
+    [6, 28, 54, 80, 106],
+    [6, 32, 58, 84, 110],
+    [6, 30, 58, 86, 114],
+    [6, 34, 62, 90, 118],
+    [6, 26, 50, 74, 98, 122],
+    [6, 30, 54, 78, 102, 126],
+    [6, 26, 52, 78, 104, 130],
+    [6, 30, 56, 82, 108, 134],
+    [6, 34, 60, 86, 112, 138],
+    [6, 30, 58, 86, 114, 142],
+    [6, 34, 62, 90, 118, 146],
+    [6, 30, 54, 78, 102, 126, 150],
+    [6, 24, 50, 76, 102, 128, 154],
+    [6, 28, 54, 80, 106, 132, 158],
+    [6, 32, 58, 84, 110, 136, 162],
+    [6, 26, 54, 82, 110, 138, 166],
+    [6, 30, 58, 86, 114, 142, 170],
+];
+/**
+ * Error correction blocks, indexed by version - 1 then level (L, M, Q, H):
+ * [EC codewords per block, group 1 blocks, group 1 data codewords per block,
+ * group 2 blocks]. Group 2 blocks each hold one more data codeword.
+ */
+export const EC_BLOCKS = [
+    [[7, 1, 19, 0], [10, 1, 16, 0], [13, 1, 13, 0], [17, 1, 9, 0]],
+    [[10, 1, 34, 0], [16, 1, 28, 0], [22, 1, 22, 0], [28, 1, 16, 0]],
+    [[15, 1, 55, 0], [26, 1, 44, 0], [18, 2, 17, 0], [22, 2, 13, 0]],
+    [[20, 1, 80, 0], [18, 2, 32, 0], [26, 2, 24, 0], [16, 4, 9, 0]],
+    [[26, 1, 108, 0], [24, 2, 43, 0], [18, 2, 15, 2], [22, 2, 11, 2]],
+    [[18, 2, 68, 0], [16, 4, 27, 0], [24, 4, 19, 0], [28, 4, 15, 0]],
+    [[20, 2, 78, 0], [18, 4, 31, 0], [18, 2, 14, 4], [26, 4, 13, 1]],
+    [[24, 2, 97, 0], [22, 2, 38, 2], [22, 4, 18, 2], [26, 4, 14, 2]],
+    [[30, 2, 116, 0], [22, 3, 36, 2], [20, 4, 16, 4], [24, 4, 12, 4]],
+    [[18, 2, 68, 2], [26, 4, 43, 1], [24, 6, 19, 2], [28, 6, 15, 2]],
+    [[20, 4, 81, 0], [30, 1, 50, 4], [28, 4, 22, 4], [24, 3, 12, 8]],
+    [[24, 2, 92, 2], [22, 6, 36, 2], [26, 4, 20, 6], [28, 7, 14, 4]],
+    [[26, 4, 107, 0], [22, 8, 37, 1], [24, 8, 20, 4], [22, 12, 11, 4]],
+    [[30, 3, 115, 1], [24, 4, 40, 5], [20, 11, 16, 5], [24, 11, 12, 5]],
+    [[22, 5, 87, 1], [24, 5, 41, 5], [30, 5, 24, 7], [24, 11, 12, 7]],
+    [[24, 5, 98, 1], [28, 7, 45, 3], [24, 15, 19, 2], [30, 3, 15, 13]],
+    [[28, 1, 107, 5], [28, 10, 46, 1], [28, 1, 22, 15], [28, 2, 14, 17]],
+    [[30, 5, 120, 1], [26, 9, 43, 4], [28, 17, 22, 1], [28, 2, 14, 19]],
+    [[28, 3, 113, 4], [26, 3, 44, 11], [26, 17, 21, 4], [26, 9, 13, 16]],
+    [[28, 3, 107, 5], [26, 3, 41, 13], [30, 15, 24, 5], [28, 15, 15, 10]],
+    [[28, 4, 116, 4], [26, 17, 42, 0], [28, 17, 22, 6], [30, 19, 16, 6]],
+    [[28, 2, 111, 7], [28, 17, 46, 0], [30, 7, 24, 16], [24, 34, 13, 0]],
+    [[30, 4, 121, 5], [28, 4, 47, 14], [30, 11, 24, 14], [30, 16, 15, 14]],
+    [[30, 6, 117, 4], [28, 6, 45, 14], [30, 11, 24, 16], [30, 30, 16, 2]],
+    [[26, 8, 106, 4], [28, 8, 47, 13], [30, 7, 24, 22], [30, 22, 15, 13]],
+    [[28, 10, 114, 2], [28, 19, 46, 4], [28, 28, 22, 6], [30, 33, 16, 4]],
+    [[30, 8, 122, 4], [28, 22, 45, 3], [30, 8, 23, 26], [30, 12, 15, 28]],
+    [[30, 3, 117, 10], [28, 3, 45, 23], [30, 4, 24, 31], [30, 11, 15, 31]],
+    [[30, 7, 116, 7], [28, 21, 45, 7], [30, 1, 23, 37], [30, 19, 15, 26]],
+    [[30, 5, 115, 10], [28, 19, 47, 10], [30, 15, 24, 25], [30, 23, 15, 25]],
+    [[30, 13, 115, 3], [28, 2, 46, 29], [30, 42, 24, 1], [30, 23, 15, 28]],
+    [[30, 17, 115, 0], [28, 10, 46, 23], [30, 10, 24, 35], [30, 19, 15, 35]],
+    [[30, 17, 115, 1], [28, 14, 46, 21], [30, 29, 24, 19], [30, 11, 15, 46]],
+    [[30, 13, 115, 6], [28, 14, 46, 23], [30, 44, 24, 7], [30, 59, 16, 1]],
+    [[30, 12, 121, 7], [28, 12, 47, 26], [30, 39, 24, 14], [30, 22, 15, 41]],
+    [[30, 6, 121, 14], [28, 6, 47, 34], [30, 46, 24, 10], [30, 2, 15, 64]],
+    [[30, 17, 122, 4], [28, 29, 46, 14], [30, 49, 24, 10], [30, 24, 15, 46]],
+    [[30, 4, 122, 18], [28, 13, 46, 32], [30, 48, 24, 14], [30, 42, 15, 32]],
+    [[30, 20, 117, 4], [28, 40, 47, 7], [30, 43, 24, 22], [30, 10, 15, 67]],
+    [[30, 19, 118, 6], [28, 18, 47, 31], [30, 34, 24, 34], [30, 20, 15, 61]],
+];

package/dist/terminal.d.ts

@@ -0,0 +1,18 @@
+import { type QrCode } from './encode.js';
+export interface TerminalOptions {
+    /** Quiet zone in modules on every side. Default 4, the standard's minimum. */
+    margin?: number;
+    /**
+     * Which modules the block characters draw. `'light'` (the default) suits a
+     * terminal with a dark background: blocks paint the light modules and the
+     * quiet zone, and the background shows through as dark modules. Use
+     * `'dark'` on a light background.
+     */
+    ink?: 'light' | 'dark';
+}
+/**
+ * Renders a code as text, two module rows per line with half-block
+ * characters, one line per row pair and no trailing newline. Needs a
+ * monospace font whose block characters fill the cell.
+ */
+export declare function toTerminal(qr: QrCode, options?: TerminalOptions): string;

package/dist/terminal.js

@@ -0,0 +1,30 @@
+const BLOCKS = [' ', '▀', '▄', '█']; // none, upper half, lower half, full
+/**
+ * Renders a code as text, two module rows per line with half-block
+ * characters, one line per row pair and no trailing newline. Needs a
+ * monospace font whose block characters fill the cell.
+ */
+export function toTerminal(qr, options = {}) {
+    const margin = options.margin ?? 4;
+    if (!Number.isInteger(margin) || margin < 0)
+        throw new RangeError('Margin must be a whole number of modules');
+    const inkIsLight = (options.ink ?? 'light') === 'light';
+    const side = qr.size + margin * 2;
+    const inked = (x, y) => {
+        const mx = x - margin;
+        const my = y - margin;
+        const dark = mx >= 0 && my >= 0 && mx < qr.size && my < qr.size && qr.modules[my * qr.size + mx] === 1;
+        return dark !== inkIsLight;
+    };
+    const lines = [];
+    for (let y = 0; y < side; y += 2) {
+        let line = '';
+        for (let x = 0; x < side; x++) {
+            // An odd side leaves the last line's lower half blank (the terminal background).
+            const lower = y + 1 < side && inked(x, y + 1);
+            line += BLOCKS[(inked(x, y) ? 1 : 0) | (lower ? 2 : 0)];
+        }
+        lines.push(line);
+    }
+    return lines.join('\n');
+}

package/dist/text.d.ts

@@ -0,0 +1,4 @@
+/** True when `bytes` is entirely well-formed UTF-8. */
+export declare function isUtf8(bytes: Uint8Array): boolean;
+/** Decodes UTF-8, replacing each ill-formed byte with U+FFFD. */
+export declare function fromUtf8(bytes: Uint8Array): string;

package/dist/text.js

@@ -0,0 +1,48 @@
+// UTF-8 decoding without TextDecoder, which ES2022 does not guarantee.
+/** Length of the well-formed UTF-8 sequence at `i`, or 0 if it is not one. */
+function sequence(bytes, i) {
+    const b = bytes[i];
+    if (b < 0x80)
+        return 1;
+    const length = b >= 0xc2 && b <= 0xdf ? 2 : b >= 0xe0 && b <= 0xef ? 3 : b >= 0xf0 && b <= 0xf4 ? 4 : 0;
+    if (length === 0 || i + length > bytes.length)
+        return 0;
+    const second = bytes[i + 1];
+    const low = b === 0xe0 ? 0xa0 : b === 0xf0 ? 0x90 : 0x80;
+    const high = b === 0xed ? 0x9f : b === 0xf4 ? 0x8f : 0xbf;
+    if (second < low || second > high)
+        return 0;
+    for (let k = 2; k < length; k++)
+        if ((bytes[i + k] & 0xc0) !== 0x80)
+            return 0;
+    return length;
+}
+/** True when `bytes` is entirely well-formed UTF-8. */
+export function isUtf8(bytes) {
+    for (let i = 0; i < bytes.length;) {
+        const n = sequence(bytes, i);
+        if (n === 0)
+            return false;
+        i += n;
+    }
+    return true;
+}
+/** Decodes UTF-8, replacing each ill-formed byte with U+FFFD. */
+export function fromUtf8(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length;) {
+        const n = sequence(bytes, i);
+        if (n === 0) {
+            out += '�';
+            i++;
+            continue;
+        }
+        const b = bytes[i];
+        let cp = n === 1 ? b : b & (0xff >>> (n + 1));
+        for (let k = 1; k < n; k++)
+            cp = (cp << 6) | (bytes[i + k] & 0x3f);
+        out += String.fromCodePoint(cp);
+        i += n;
+    }
+    return out;
+}

package/llms.txt

@@ -0,0 +1,37 @@
+# @forgesworn/qr
+
+> QR code encoder and decoder with no dependencies, for browsers, workers and Node. Versions 1-40, levels L/M/Q/H, numeric, alphanumeric and byte modes, optional UTF-8 ECI, SVG, canvas and terminal output. The decoder reads RGBA or greyscale camera frames, including rotated, tilted, mirrored and inverted codes. Tests compare 114 symbols module for module with ZXing, read output back with jsQR, and require the decoder to read at least as many synthetic distorted frames as jsQR.
+
+ESM only, Node.js 22.13+.
+
+## Install
+
+```bash
+npm install @forgesworn/qr
+```
+
+## API
+
+- `encode(data: string | Uint8Array, options?: EncodeOptions): QrCode` - options `ecc` ('L'|'M'|'Q'|'H', default 'M'), `version` (1-40), `minVersion`, `mask` (0-7), `mode` ('numeric'|'alphanumeric'|'byte'), `eci` (boolean). Throws `QrCapacityError` (a RangeError) when the data does not fit.
+- `QrCode` - `{ version, ecc, mask, mode, size, modules }`; `modules` is a row-major Uint8Array, 1 = dark, no quiet zone.
+- `isDark(qr, x, y): boolean`
+- `toSvg(qr, { margin = 4, dark = '#000', light = '#fff' | null, title? }): string`
+- `drawCanvas(canvas, qr, { width = 8 px per module, margin = 4, dark, light | null }): void` - any HTMLCanvasElement or OffscreenCanvas; resizes it to width square.
+- `toTerminal(qr, { margin = 4, ink = 'light' | 'dark' }): string` - half-block text; 'light' ink for dark terminal backgrounds.
+- `decode(image: { data, width, height }, { rowStride?, channels?: 1 | 4, inversion?: 'normal' | 'inverted' | 'both' }): DecodeResult | undefined` - data is RGBA (ImageData) or greyscale; result `{ text, bytes, version, ecc, mask, eci, corrected, mirrored, inverted, location }`; undefined when no readable code is found.
+- `decodeModules(modules, size)` - reads a row-major module grid (no quiet zone), straight or mirrored.
+
+## Example
+
+```ts
+import { encode, toSvg } from '@forgesworn/qr'
+const svg = toSvg(encode('https://example.com/', { ecc: 'Q' }))
+
+import { decode } from '@forgesworn/qr'
+const text = decode(ctx.getImageData(0, 0, w, h))?.text
+```
+
+## Docs
+
+- [README](https://github.com/forgesworn/qr/blob/main/README.md)
+- [SPEC](https://github.com/forgesworn/qr/blob/main/SPEC.md): exact encoder behaviour for ports, and the decoder's pipeline

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@forgesworn/qr",
+  "version": "0.0.0-seed.0",
+  "description": "QR code encoder and decoder with no dependencies: versions 1-40, all error correction levels, SVG output, camera-frame reading, checked against independent test vectors.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "SPEC.md",
+    "llms.txt",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "generate-vectors": "sh scripts/generate-vectors.sh",
+    "check": "npm run typecheck && npm test",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run check"
+  },
+  "keywords": [
+    "qr",
+    "qrcode",
+    "qr-code",
+    "encoder",
+    "svg",
+    "zero-dependency"
+  ],
+  "author": "forgesworn",
+  "funding": {
+    "type": "lightning",
+    "url": "lightning:profusemeat89@walletofsatoshi.com"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.13"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "jsqr": "1.4.0",
+    "typescript": "^5.6.0",
+    "vitest": "^4.1.11"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "homepage": "https://github.com/forgesworn/qr#readme",
+  "bugs": {
+    "url": "https://github.com/forgesworn/qr/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/forgesworn/qr.git"
+  }
+}