@hexpro/qr-code-studio 0.0.0-stage → 0.1.0

package/dist/symbology/micro/read-helpers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * What reading a sampled matrix needs from every small symbology: the
+ * refusal it throws, the erasure map checked and mirrored with the matrix, and
+ * the second attempt at a reflection.
+ */
+import { BitMatrix, QrStudioError } from '../../core/index.js';
+/**
+ * Why a grid was refused before its codewords were read. 'size' and
+ * 'mismatch' are both stage 'version', as in the QR reader: the grid is not
+ * a size this symbology comes in, or its format names a different version
+ * from its size.
+ */
+export type Refusal = 'size' | 'mismatch' | 'format';
+/** A sampled matrix that is not this symbology, or not legibly. */
+export declare function unreadable(why: Refusal): QrStudioError;
+/** Throws TypeError for options that are not `{ strict: boolean, erasures? }` over this matrix. */
+export declare function checkReadOptions(matrix: BitMatrix, options: {
+    readonly strict: boolean;
+    readonly erasures?: Uint8Array;
+}): void;
+/**
+ * Read as sampled and, when that fails and the reading is lenient, as a
+ * reflection. A symbol printed on film and read from the back, or a phone's
+ * front camera, gives a mirror image, and once sampled a reflected symbol is
+ * exactly `matrix.mirrored()` of a readable one. A strict reading never
+ * tries it: the scan check must not pass a symbol on the strength of a
+ * reflection phone readers do not attempt. The first failure is the one
+ * reported, since it describes the symbol as it was given.
+ */
+export declare function readEitherWay<T>(matrix: BitMatrix, strict: boolean, erasures: Uint8Array | undefined, once: (matrix: BitMatrix, erasures: Uint8Array | undefined, mirrored: boolean) => T): T;
+//# sourceMappingURL=read-helpers.d.ts.map

package/dist/symbology/micro/read-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-helpers.d.ts","sourceRoot":"","sources":["../../../src/symbology/micro/read-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;AAQrD,mEAAmE;AACnE,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,aAAa,CAItD;AAED,mGAAmG;AACnG,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAAE,GACnE,IAAI,CAIN;AAoBD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC9B,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,UAAU,GAAG,SAAS,EAChC,IAAI,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,GAAG,SAAS,EAAE,QAAQ,EAAE,OAAO,KAAK,CAAC,GACjF,CAAC,CAiBH"}

package/dist/symbology/micro/read-helpers.js

@@ -0,0 +1,66 @@
+/**
+ * What reading a sampled matrix needs from every small symbology: the
+ * refusal it throws, the erasure map checked and mirrored with the matrix, and
+ * the second attempt at a reflection.
+ */
+import { BitMatrix, QrStudioError } from '../../core/index.js';
+const SENTENCES = Object.freeze({
+    size: 'This grid is not a size this kind of code comes in.',
+    mismatch: 'The size of this code and the version it says it is do not match.',
+    format: 'The part of this code that says how it was made is too damaged to read.',
+});
+/** A sampled matrix that is not this symbology, or not legibly. */
+export function unreadable(why) {
+    return new QrStudioError('decode/unreadable', SENTENCES[why], {
+        stage: why === 'format' ? 'format' : 'version',
+    });
+}
+/** Throws TypeError for options that are not `{ strict: boolean, erasures? }` over this matrix. */
+export function checkReadOptions(matrix, options) {
+    if (!(matrix instanceof BitMatrix))
+        throw new TypeError('read takes a BitMatrix');
+    if (typeof options?.strict !== 'boolean')
+        throw new TypeError('read needs { strict: boolean }');
+    checkErasures(matrix, options.erasures);
+}
+/** Throws TypeError unless `erasures` has one entry per module: a caller's mistake, not damage. */
+function checkErasures(matrix, erasures) {
+    if (erasures === undefined)
+        return;
+    if (!(erasures instanceof Uint8Array) || erasures.length !== matrix.width * matrix.height) {
+        throw new TypeError('erasures is a Uint8Array with one entry per module of the matrix');
+    }
+}
+/** The erasure map moved the same way `BitMatrix.mirrored` moves the modules. */
+function mirrorErasures(matrix, erasures) {
+    const flags = new BitMatrix(matrix.width, matrix.height, erasures.map((value) => (value === 0 ? 0 : 1)));
+    return flags.mirrored().data;
+}
+/**
+ * Read as sampled and, when that fails and the reading is lenient, as a
+ * reflection. A symbol printed on film and read from the back, or a phone's
+ * front camera, gives a mirror image, and once sampled a reflected symbol is
+ * exactly `matrix.mirrored()` of a readable one. A strict reading never
+ * tries it: the scan check must not pass a symbol on the strength of a
+ * reflection phone readers do not attempt. The first failure is the one
+ * reported, since it describes the symbol as it was given.
+ */
+export function readEitherWay(matrix, strict, erasures, once) {
+    try {
+        return once(matrix, erasures, false);
+    }
+    catch (error) {
+        if (strict || !(error instanceof QrStudioError))
+            throw error;
+        try {
+            return once(matrix.mirrored(), erasures === undefined ? undefined : mirrorErasures(matrix, erasures), true);
+        }
+        catch (second) {
+            // A bug on the second attempt must not hide behind the first refusal.
+            if (!(second instanceof QrStudioError))
+                throw second;
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=read-helpers.js.map

package/dist/symbology/micro/read-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-helpers.js","sourceRoot":"","sources":["../../../src/symbology/micro/read-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAU/D,MAAM,SAAS,GAAsC,MAAM,CAAC,MAAM,CAAC;IAClE,IAAI,EAAE,qDAAqD;IAC3D,QAAQ,EAAE,mEAAmE;IAC7E,MAAM,EAAE,yEAAyE;CACjF,CAAC,CAAC;AAEH,mEAAmE;AACnE,MAAM,UAAU,UAAU,CAAC,GAAY;IACtC,OAAO,IAAI,aAAa,CAAC,mBAAmB,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE;QAC7D,KAAK,EAAE,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS;KAC9C,CAAC,CAAC;AACJ,CAAC;AAED,mGAAmG;AACnG,MAAM,UAAU,gBAAgB,CAC/B,MAAiB,EACjB,OAAqE;IAErE,IAAI,CAAC,CAAC,MAAM,YAAY,SAAS,CAAC;QAAE,MAAM,IAAI,SAAS,CAAC,wBAAwB,CAAC,CAAC;IAClF,IAAI,OAAO,OAAO,EAAE,MAAM,KAAK,SAAS;QAAE,MAAM,IAAI,SAAS,CAAC,gCAAgC,CAAC,CAAC;IAChG,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;AACzC,CAAC;AAED,mGAAmG;AACnG,SAAS,aAAa,CAAC,MAAiB,EAAE,QAAgC;IACzE,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO;IACnC,IAAI,CAAC,CAAC,QAAQ,YAAY,UAAU,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;QAC3F,MAAM,IAAI,SAAS,CAAC,kEAAkE,CAAC,CAAC;IACzF,CAAC;AACF,CAAC;AAED,iFAAiF;AACjF,SAAS,cAAc,CAAC,MAAiB,EAAE,QAAoB;IAC9D,MAAM,KAAK,GAAG,IAAI,SAAS,CAC1B,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,MAAM,EACb,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAC9C,CAAC;IACF,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC;AAC9B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAC5B,MAAiB,EACjB,MAAe,EACf,QAAgC,EAChC,IAAmF;IAEnF,IAAI,CAAC;QACJ,OAAO,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,IAAI,MAAM,IAAI,CAAC,CAAC,KAAK,YAAY,aAAa,CAAC;YAAE,MAAM,KAAK,CAAC;QAC7D,IAAI,CAAC;YACJ,OAAO,IAAI,CACV,MAAM,CAAC,QAAQ,EAAE,EACjB,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrE,IAAI,CACJ,CAAC;QACH,CAAC;QAAC,OAAO,MAAM,EAAE,CAAC;YACjB,sEAAsE;YACtE,IAAI,CAAC,CAAC,MAAM,YAAY,aAAa,CAAC;gBAAE,MAAM,MAAM,CAAC;YACrD,MAAM,KAAK,CAAC;QACb,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/symbology/micro/tables.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Micro QR's tables, as data.
+ *
+ * Micro QR (ISO/IEC 18004, the Micro QR clauses) is four symbol sizes, M1 to
+ * M4, each 2 modules wider than the last: 11, 13, 15 and 17. One finder, no
+ * alignment patterns, a single Reed-Solomon block, and a bitstream whose
+ * fields get wider with the version, down to an M1 that carries digits only
+ * and has no mode indicator at all.
+ *
+ * Sources. The rows were transcribed from BWIPP (barcode.ps, MIT licence, as
+ * shipped in bwip-js 4.11): `qrcode.metrics` for the module and codeword
+ * counts, `qrcode.mids` for the mode indicators, `qrcode.cclens` for the
+ * character count widths and `qrcode.termlens` for the terminators. The block
+ * table was checked row by row against zxing-cpp (Apache 2.0,
+ * core/src/qrcode/QRVersion.cpp, which cites ISO/IEC 18004:2006 Table 9) and
+ * the character count widths against zxing-cpp's QRCodecMode.cpp. The
+ * misdecode protection counts `p` are ISO/IEC 18004 Table 9's, which neither
+ * of those carries; see `MICRO_P`. The tests then hold every row to the
+ * arithmetic the specification guarantees and prove the whole by building
+ * symbols that match bwip-js module for module and that zxing-wasm reads.
+ * Tables are facts; no code was copied.
+ */
+import type { BlockLayout } from '../types.js';
+import type { EcLevel, Mode } from '../../segment/types.js';
+export type MicroVersion = 'M1' | 'M2' | 'M3' | 'M4';
+export declare const MICRO_VERSIONS: readonly MicroVersion[];
+export interface MicroLevelSpec {
+    readonly ecLevel: EcLevel;
+    /**
+     * The three bit symbol number written into the format information
+     * (ISO/IEC 18004 Table 13). It names the version and the level together,
+     * which is why Micro QR's format has no separate level field: 000 is M1,
+     * 001 and 010 are M2-L and M2-M, and so on up to 111 for M4-Q.
+     */
+    readonly symbolNumber: number;
+    readonly dataCodewords: number;
+    readonly ecCodewords: number;
+    /** Misdecode protection codewords: errors correctable are floor((ec - p) / 2). */
+    readonly p: number;
+}
+export interface MicroVersionSpec {
+    readonly version: MicroVersion;
+    /** 1 to 4. The mode indicator is (number - 1) bits wide and the terminator 2 * number + 1. */
+    readonly number: number;
+    readonly size: number;
+    /** Codewords in the symbol, counting M1's and M3's half codeword as one. */
+    readonly totalCodewords: number;
+    /** M1 and M3 end their data with a 4 bit codeword, because their module count is 4 short of a byte. */
+    readonly lastDataCodewordBits: 8 | 4;
+    readonly levels: readonly MicroLevelSpec[];
+    readonly modes: readonly Mode[];
+    /** Character count indicator widths, for the modes this version carries. */
+    readonly charCountBits: Readonly<Partial<Record<Mode, number>>>;
+}
+/** Throws TypeError for anything but 'M1' to 'M4': a version is chosen from `versions`, never typed. */
+export declare function microSpec(version: string): MicroVersionSpec;
+/** Throws TypeError for a level the version does not have (M1 has only L, M2 and M3 have L and M). */
+export declare function microLevel(version: string, ec: EcLevel): MicroLevelSpec;
+/** The version whose side is `size` modules, if there is one. */
+export declare function microBySize(size: number): MicroVersionSpec | undefined;
+/** The block structure for a version and level: always one block, cached and frozen. */
+export declare function microBlocks(version: string, ec: EcLevel): BlockLayout;
+//# sourceMappingURL=tables.d.ts.map

package/dist/symbology/micro/tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../src/symbology/micro/tables.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE5D,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAErD,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAA4C,CAAC;AAE/F,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAChC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,8FAA8F;IAC9F,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,uGAAuG;IACvG,QAAQ,CAAC,oBAAoB,EAAE,CAAC,GAAG,CAAC,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;CAChE;AAiHD,wGAAwG;AACxG,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAM3D;AAED,sGAAsG;AACtG,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAG,cAAc,CAMvE;AAED,iEAAiE;AACjE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAKtE;AAID,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAG,WAAW,CAgBrE"}

package/dist/symbology/micro/tables.js

@@ -0,0 +1,163 @@
+/**
+ * Micro QR's tables, as data.
+ *
+ * Micro QR (ISO/IEC 18004, the Micro QR clauses) is four symbol sizes, M1 to
+ * M4, each 2 modules wider than the last: 11, 13, 15 and 17. One finder, no
+ * alignment patterns, a single Reed-Solomon block, and a bitstream whose
+ * fields get wider with the version, down to an M1 that carries digits only
+ * and has no mode indicator at all.
+ *
+ * Sources. The rows were transcribed from BWIPP (barcode.ps, MIT licence, as
+ * shipped in bwip-js 4.11): `qrcode.metrics` for the module and codeword
+ * counts, `qrcode.mids` for the mode indicators, `qrcode.cclens` for the
+ * character count widths and `qrcode.termlens` for the terminators. The block
+ * table was checked row by row against zxing-cpp (Apache 2.0,
+ * core/src/qrcode/QRVersion.cpp, which cites ISO/IEC 18004:2006 Table 9) and
+ * the character count widths against zxing-cpp's QRCodecMode.cpp. The
+ * misdecode protection counts `p` are ISO/IEC 18004 Table 9's, which neither
+ * of those carries; see `MICRO_P`. The tests then hold every row to the
+ * arithmetic the specification guarantees and prove the whole by building
+ * symbols that match bwip-js module for module and that zxing-wasm reads.
+ * Tables are facts; no code was copied.
+ */
+import { makeBlockLayout } from './blocks.js';
+export const MICRO_VERSIONS = Object.freeze(['M1', 'M2', 'M3', 'M4']);
+/**
+ * Misdecode protection, from ISO/IEC 18004 Table 9.
+ *
+ * Small Reed-Solomon codes are easy to "correct" into the wrong codeword: with
+ * five check symbols and a damaged block, a decoder that spends all of them
+ * finds some valid block nearby surprisingly often. So the specification holds
+ * back p of the check symbols from correction in the smallest symbols and uses
+ * them only to detect. Table 9 prints each level as (c, k, r), total, data and
+ * correctable errors, with p = c - k - 2r:
+ *
+ *   M1     (5, 3, 0)   p = 2, detection only
+ *   M2-L   (10, 5, 1)  p = 3     M2-M  (10, 4, 2)  p = 2
+ *   M3-L   (17, 11, 2) p = 2     M3-M  (17, 9, 4)  p = 0
+ *   M4-L   (24, 16, 3) p = 2     M4-M  (24, 14, 5) p = 0    M4-Q (24, 10, 7) p = 0
+ *
+ * Neither BWIPP nor zxing-cpp needs these (an encoder never does, and zxing-cpp
+ * corrects as far as the code reaches), so they are transcribed from the
+ * standard's table as it is widely reproduced, and should be checked against
+ * the owner's copy of ISO/IEC 18004:2024 when it arrives. A wrong p cannot make
+ * a symbol unreadable by another reader; it only changes how far this one
+ * trusts a repair.
+ */
+const MICRO_P = {
+    M1: { L: 2 },
+    M2: { L: 3, M: 2 },
+    M3: { L: 2, M: 0 },
+    M4: { L: 2, M: 0, Q: 0 },
+};
+function level(ecLevel, symbolNumber, dataCodewords, ecCodewords, p) {
+    return Object.freeze({ ecLevel, symbolNumber, dataCodewords, ecCodewords, p });
+}
+let specs;
+/**
+ * Every version, built on first use.
+ *
+ * Total codewords are BWIPP's data module counts (36, 80, 132 and 192) over 8,
+ * rounded up for M1 and M3, whose last data codeword is a nibble. The data and
+ * check codeword splits are BWIPP's EC codeword row and agree with zxing-cpp's
+ * ECBlocks.
+ */
+function table() {
+    if (specs !== undefined)
+        return specs;
+    const rows = [
+        {
+            version: 'M1',
+            number: 1,
+            size: 11,
+            totalCodewords: 5,
+            lastDataCodewordBits: 4,
+            levels: [level('L', 0, 3, 2, MICRO_P.M1.L)],
+            modes: ['numeric'],
+            charCountBits: { numeric: 3 },
+        },
+        {
+            version: 'M2',
+            number: 2,
+            size: 13,
+            totalCodewords: 10,
+            lastDataCodewordBits: 8,
+            levels: [level('L', 1, 5, 5, MICRO_P.M2.L), level('M', 2, 4, 6, MICRO_P.M2.M)],
+            modes: ['numeric', 'alphanumeric'],
+            charCountBits: { numeric: 4, alphanumeric: 3 },
+        },
+        {
+            version: 'M3',
+            number: 3,
+            size: 15,
+            totalCodewords: 17,
+            lastDataCodewordBits: 4,
+            levels: [level('L', 3, 11, 6, MICRO_P.M3.L), level('M', 4, 9, 8, MICRO_P.M3.M)],
+            modes: ['numeric', 'alphanumeric', 'byte', 'kanji'],
+            charCountBits: { numeric: 5, alphanumeric: 4, byte: 4, kanji: 3 },
+        },
+        {
+            version: 'M4',
+            number: 4,
+            size: 17,
+            totalCodewords: 24,
+            lastDataCodewordBits: 8,
+            levels: [
+                level('L', 5, 16, 8, MICRO_P.M4.L),
+                level('M', 6, 14, 10, MICRO_P.M4.M),
+                level('Q', 7, 10, 14, MICRO_P.M4.Q),
+            ],
+            modes: ['numeric', 'alphanumeric', 'byte', 'kanji'],
+            charCountBits: { numeric: 6, alphanumeric: 5, byte: 5, kanji: 4 },
+        },
+    ];
+    specs = new Map(rows.map((row) => [
+        row.version,
+        Object.freeze({
+            ...row,
+            levels: Object.freeze(row.levels),
+            modes: Object.freeze(row.modes),
+            charCountBits: Object.freeze(row.charCountBits),
+        }),
+    ]));
+    return specs;
+}
+/** Throws TypeError for anything but 'M1' to 'M4': a version is chosen from `versions`, never typed. */
+export function microSpec(version) {
+    const spec = table().get(version);
+    if (spec === undefined) {
+        throw new TypeError('a Micro QR version is one of M1, M2, M3 and M4');
+    }
+    return spec;
+}
+/** Throws TypeError for a level the version does not have (M1 has only L, M2 and M3 have L and M). */
+export function microLevel(version, ec) {
+    const found = microSpec(version).levels.find((candidate) => candidate.ecLevel === ec);
+    if (found === undefined) {
+        throw new TypeError('that error correction level is not available at this Micro QR version');
+    }
+    return found;
+}
+/** The version whose side is `size` modules, if there is one. */
+export function microBySize(size) {
+    for (const spec of table().values()) {
+        if (spec.size === size)
+            return spec;
+    }
+    return undefined;
+}
+let blockLayouts;
+/** The block structure for a version and level: always one block, cached and frozen. */
+export function microBlocks(version, ec) {
+    const spec = microSpec(version);
+    const found = microLevel(version, ec);
+    const key = `${spec.version}-${found.ecLevel}`;
+    blockLayouts ??= new Map();
+    let blocks = blockLayouts.get(key);
+    if (blocks === undefined) {
+        blocks = makeBlockLayout([{ count: 1, dataCount: found.dataCodewords }], found.ecCodewords, found.p, spec.lastDataCodewordBits);
+        blockLayouts.set(key, blocks);
+    }
+    return blocks;
+}
+//# sourceMappingURL=tables.js.map

package/dist/symbology/micro/tables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables.js","sourceRoot":"","sources":["../../../src/symbology/micro/tables.ts"],"names":[],"mappings":"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"}

package/dist/symbology/qr/blocks.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Reed-Solomon blocks: splitting data into blocks, adding check codewords,
+ * interleaving, and the reverse.
+ *
+ * Interleaving is what lets a code survive a smudge. Consecutive codewords in
+ * the symbol belong to different blocks, so damage that would overwhelm one
+ * block is spread thinly over all of them. The writer takes the first data
+ * codeword of every block, then the second, skipping blocks that have run out
+ * (group 1's blocks are one codeword shorter than group 2's), then the check
+ * codewords the same way.
+ *
+ * Written over `BlockLayout` rather than QR's tables, so the same functions
+ * serve rMQR (several blocks, same field, same interleave) and Micro QR (one
+ * block). Reed-Solomon itself is core's, over GF(2^8) with polynomial 0x11D
+ * and first root 0, which all three symbologies share.
+ */
+import type { EcLevel } from '../../segment/types.js';
+import type { BlockLayout } from '../types.js';
+/** The block structure of a QR version and level. Cached; frozen. */
+export declare function qrBlocks(version: number, level: EcLevel): BlockLayout;
+/** Errors a block may correct: floor((ec - p) / 2). */
+export declare function blockCapacity(ecCount: number, p: number): number;
+interface Order {
+    readonly block: Int32Array;
+    readonly offset: Int32Array;
+}
+/**
+ * For each position in the interleaved sequence, the block it belongs to and
+ * its position within that block (data codewords first, then check codewords).
+ * Cached per layout object.
+ */
+export declare function interleaveOrder(layout: BlockLayout): Order;
+/** Split data into blocks, add each block's check codewords, and interleave. */
+export declare function interleaveBlocks(data: Uint8Array, layout: BlockLayout): Uint8Array;
+export interface DecodedBlocks {
+    /** The data codewords, corrected, in their original order. */
+    readonly data: Uint8Array;
+    readonly errorsPerBlock: readonly number[];
+    readonly capacityPerBlock: readonly number[];
+    readonly erasuresUsed: number;
+}
+/**
+ * De-interleave and correct every block.
+ *
+ * Each block may correct floor((ec - p) / 2) errors and no more, however many
+ * the algebra could reach: past that the protection the smallest symbols keep
+ * back is spent, and a block that comes out "corrected" may be a different
+ * valid block. Erasures (`erased`, one flag per interleaved position) are
+ * used when a block has no more than ec - p of them, and then cap errors at
+ * floor((ec - p - f) / 2), the same budget ISO/IEC 18004 7.5.2 sets
+ * (e + 2t <= d - p). An erasure is a hint, not a fact: a logo can cover a
+ * codeword whose modules happen to be right, and an erasure list can come
+ * from a guess. So when a block will not decode with its erasures, it is
+ * tried once more without them before it is given up on.
+ */
+export declare function decodeBlocks(codewords: Uint8Array, layout: BlockLayout, erased?: Uint8Array): DecodedBlocks;
+export {};
+//# sourceMappingURL=blocks.d.ts.map

package/dist/symbology/qr/blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../../src/symbology/qr/blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAS/C,qEAAqE;AACrE,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,WAAW,CA2BrE;AAED,uDAAuD;AACvD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,UAAU,KAAK;IACd,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC5B;AAID;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK,CAiC1D;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,CAqBlF;AAED,MAAM,WAAW,aAAa;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC3B,SAAS,EAAE,UAAU,EACrB,MAAM,EAAE,WAAW,EACnB,MAAM,CAAC,EAAE,UAAU,GACjB,aAAa,CA+Cf"}

package/dist/symbology/qr/blocks.js

@@ -0,0 +1,176 @@
+/**
+ * Reed-Solomon blocks: splitting data into blocks, adding check codewords,
+ * interleaving, and the reverse.
+ *
+ * Interleaving is what lets a code survive a smudge. Consecutive codewords in
+ * the symbol belong to different blocks, so damage that would overwhelm one
+ * block is spread thinly over all of them. The writer takes the first data
+ * codeword of every block, then the second, skipping blocks that have run out
+ * (group 1's blocks are one codeword shorter than group 2's), then the check
+ * codewords the same way.
+ *
+ * Written over `BlockLayout` rather than QR's tables, so the same functions
+ * serve rMQR (several blocks, same field, same interleave) and Micro QR (one
+ * block). Reed-Solomon itself is core's, over GF(2^8) with polynomial 0x11D
+ * and first root 0, which all three symbologies share.
+ */
+import { QR_FIELD } from '../../core/field.js';
+import { rsDecode, rsEncode } from '../../core/reed-solomon.js';
+import { TOTAL_CODEWORDS, ecRow, misdecodeProtection } from './tables.js';
+function code(ecCount) {
+    return { field: QR_FIELD, ecCount, firstRoot: 0 };
+}
+let qrCache;
+/** The block structure of a QR version and level. Cached; frozen. */
+export function qrBlocks(version, level) {
+    const key = `${version}${level}`;
+    qrCache ??= new Map();
+    let found = qrCache.get(key);
+    if (found === undefined) {
+        const row = ecRow(version, level);
+        const blocks = [
+            ...Array.from({ length: row.group1Blocks }, () => ({
+                dataCount: row.group1Data,
+                ecCount: row.ecPerBlock,
+            })),
+            ...Array.from({ length: row.group2Blocks }, () => ({
+                dataCount: row.group2Data,
+                ecCount: row.ecPerBlock,
+            })),
+        ].map((block) => Object.freeze(block));
+        const dataCodewords = blocks.reduce((sum, block) => sum + block.dataCount, 0);
+        found = Object.freeze({
+            blocks: Object.freeze(blocks),
+            totalCodewords: TOTAL_CODEWORDS[version - 1],
+            p: misdecodeProtection(version, level),
+            lastDataCodewordBits: 8,
+            dataBits: dataCodewords * 8,
+        });
+        qrCache.set(key, found);
+    }
+    return found;
+}
+/** Errors a block may correct: floor((ec - p) / 2). */
+export function blockCapacity(ecCount, p) {
+    return Math.floor((ecCount - p) / 2);
+}
+let orders;
+/**
+ * For each position in the interleaved sequence, the block it belongs to and
+ * its position within that block (data codewords first, then check codewords).
+ * Cached per layout object.
+ */
+export function interleaveOrder(layout) {
+    orders ??= new WeakMap();
+    const cached = orders.get(layout);
+    if (cached !== undefined)
+        return cached;
+    const total = layout.blocks.reduce((sum, b) => sum + b.dataCount + b.ecCount, 0);
+    const block = new Int32Array(total);
+    const offset = new Int32Array(total);
+    let at = 0;
+    const sweep = (count, base) => {
+        const longest = Math.max(...layout.blocks.map(count));
+        for (let i = 0; i < longest; i += 1) {
+            layout.blocks.forEach((b, index) => {
+                if (i >= count(b))
+                    return;
+                block[at] = index;
+                offset[at] = base(b) + i;
+                at += 1;
+            });
+        }
+    };
+    sweep((b) => b.dataCount, () => 0);
+    sweep((b) => b.ecCount, (b) => b.dataCount);
+    const order = Object.freeze({ block, offset });
+    orders.set(layout, order);
+    return order;
+}
+/** Split data into blocks, add each block's check codewords, and interleave. */
+export function interleaveBlocks(data, layout) {
+    const dataCount = layout.blocks.reduce((sum, b) => sum + b.dataCount, 0);
+    if (data.length !== dataCount) {
+        throw new RangeError(`this block layout takes ${dataCount} data codewords, not ${data.length}`);
+    }
+    const blocks = [];
+    let start = 0;
+    for (const b of layout.blocks) {
+        const block = new Uint8Array(b.dataCount + b.ecCount);
+        const slice = data.subarray(start, start + b.dataCount);
+        block.set(slice);
+        block.set(rsEncode(code(b.ecCount), slice), b.dataCount);
+        blocks.push(block);
+        start += b.dataCount;
+    }
+    const order = interleaveOrder(layout);
+    const out = new Uint8Array(order.block.length);
+    for (let i = 0; i < out.length; i += 1) {
+        out[i] = blocks[order.block[i]][order.offset[i]];
+    }
+    return out;
+}
+/**
+ * De-interleave and correct every block.
+ *
+ * Each block may correct floor((ec - p) / 2) errors and no more, however many
+ * the algebra could reach: past that the protection the smallest symbols keep
+ * back is spent, and a block that comes out "corrected" may be a different
+ * valid block. Erasures (`erased`, one flag per interleaved position) are
+ * used when a block has no more than ec - p of them, and then cap errors at
+ * floor((ec - p - f) / 2), the same budget ISO/IEC 18004 7.5.2 sets
+ * (e + 2t <= d - p). An erasure is a hint, not a fact: a logo can cover a
+ * codeword whose modules happen to be right, and an erasure list can come
+ * from a guess. So when a block will not decode with its erasures, it is
+ * tried once more without them before it is given up on.
+ */
+export function decodeBlocks(codewords, layout, erased) {
+    const order = interleaveOrder(layout);
+    if (codewords.length !== order.block.length) {
+        throw new RangeError(`this block layout has ${order.block.length} codewords, not ${codewords.length}`);
+    }
+    const blocks = layout.blocks.map((b) => new Uint8Array(b.dataCount + b.ecCount));
+    const erasures = layout.blocks.map(() => []);
+    for (let i = 0; i < codewords.length; i += 1) {
+        const index = order.block[i];
+        const offset = order.offset[i];
+        blocks[index][offset] = codewords[i];
+        if (erased !== undefined && erased[i] !== 0)
+            erasures[index].push(offset);
+    }
+    const errorsPerBlock = [];
+    const capacityPerBlock = [];
+    const data = [];
+    let erasuresUsed = 0;
+    layout.blocks.forEach((b, index) => {
+        const received = blocks[index];
+        const flagged = erasures[index].sort((x, y) => x - y);
+        const budget = b.ecCount - layout.p;
+        const rs = code(b.ecCount);
+        let decoded;
+        if (flagged.length > 0 && flagged.length <= budget) {
+            try {
+                decoded = rsDecode(rs, received, {
+                    erasures: flagged,
+                    maxErrors: Math.floor((budget - flagged.length) / 2),
+                });
+            }
+            catch {
+                // Refused with the erasures: try once more on errors alone, below.
+            }
+        }
+        decoded ??= rsDecode(rs, received, { maxErrors: blockCapacity(b.ecCount, layout.p) });
+        errorsPerBlock.push(decoded.errors);
+        capacityPerBlock.push(blockCapacity(b.ecCount, layout.p));
+        erasuresUsed += decoded.erasures;
+        for (let i = 0; i < b.dataCount; i += 1)
+            data.push(decoded.codewords[i]);
+    });
+    return {
+        data: Uint8Array.from(data),
+        errorsPerBlock: Object.freeze(errorsPerBlock),
+        capacityPerBlock: Object.freeze(capacityPerBlock),
+        erasuresUsed,
+    };
+}
+//# sourceMappingURL=blocks.js.map

package/dist/symbology/qr/blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.js","sourceRoot":"","sources":["../../../src/symbology/qr/blocks.ts"],"names":[],"mappings":"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"}

package/dist/symbology/qr/build.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Making a QR symbol from its data codewords.
+ *
+ * Lifted from the authenticator package's encoder (`src/qr/encode/encoder.ts`
+ * there), whose matrix was pinned module for module to the ISO/IEC 18004
+ * Annex I example and to the `qrcode` package, and reorganised around the
+ * cached geometry: the function patterns are a template copied per symbol,
+ * the data goes where the placement walk says, and each candidate mask is a
+ * pass over the data modules only.
+ *
+ * Reed-Solomon and interleaving happen here, through `interleaveBlocks`,
+ * rather than in encode: `read` undoes both inside the symbology, so keeping
+ * the forward direction here too makes build and read mirror images, and lets
+ * a symbology with its own block quirks (Micro QR's 4-bit codewords) keep
+ * them to itself.
+ */
+import type { EcLevel } from '../../segment/types.js';
+import type { BuiltSymbol } from '../types.js';
+export declare function buildQr(data: Uint8Array, version: number, ec: EcLevel, mask: number | 'auto'): BuiltSymbol;
+//# sourceMappingURL=build.d.ts.map

package/dist/symbology/qr/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../src/symbology/qr/build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAyC/C,wBAAgB,OAAO,CACtB,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,MAAM,GAAG,MAAM,GACnB,WAAW,CA2Cb"}