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

package/dist/core/bits.js

@@ -0,0 +1,128 @@
+/**
+ * Bit-level writing and reading, most significant bit first.
+ *
+ * Every bit field in the symbologies this package writes is MSB first: mode
+ * indicators, character counts, segment data, codewords, format information.
+ * Having one implementation of that order rather than a shift at each call
+ * site removes a whole category of bug, and it is the kind of bug that
+ * produces plausible-looking wrong output rather than an obvious failure.
+ *
+ * Numbers that are out of range throw `RangeError`. They are bugs in the
+ * caller (a field width of 33, a read past the end of a stream whose length
+ * the caller already knew), never something to explain to a person. The
+ * messages give widths and positions, never the value that was refused: a
+ * value written here is a piece of somebody's content.
+ */
+/** 2^bits for 0 <= bits <= 32, without `**`, which the determinism zone bans. */
+function span(bits) {
+    return bits === 32 ? 4294967296 : (1 << bits) >>> 0;
+}
+function checkWidth(bits) {
+    if (!Number.isInteger(bits) || bits < 0 || bits > 32) {
+        throw new RangeError('a bit field is 0 to 32 bits wide');
+    }
+}
+export class BitBuffer {
+    bytes = new Uint8Array(32);
+    bitLength = 0;
+    /** Bits written so far. */
+    get length() {
+        return this.bitLength;
+    }
+    /** Append the low `bits` bits of `value`, most significant first. */
+    append(value, bits) {
+        checkWidth(bits);
+        if (!Number.isInteger(value) || value < 0 || value >= span(bits)) {
+            throw new RangeError(`the value does not fit in ${bits} bits`);
+        }
+        this.reserve(bits);
+        for (let i = bits - 1; i >= 0; i -= 1) {
+            this.push((value >>> i) & 1);
+        }
+    }
+    /** Append every bit of `other`, which may be this buffer itself. */
+    appendBits(other) {
+        // Read the length first: appending a buffer to itself must copy what was
+        // there when the call started, not chase its own tail.
+        const count = other.bitLength;
+        this.reserve(count);
+        const source = other.bytes;
+        for (let i = 0; i < count; i += 1) {
+            this.push((source[i >>> 3] >>> (7 - (i & 7))) & 1);
+        }
+    }
+    bit(index) {
+        if (!Number.isInteger(index) || index < 0 || index >= this.bitLength) {
+            throw new RangeError(`bit ${index} is outside a buffer of ${this.bitLength} bits`);
+        }
+        return ((this.bytes[index >>> 3] >>> (7 - (index & 7))) & 1);
+    }
+    /**
+     * The bits as bytes, the last one padded with zero bits.
+     *
+     * A copy: the buffer can go on being appended to without changing what a
+     * caller already holds.
+     */
+    toBytes() {
+        return this.bytes.slice(0, (this.bitLength + 7) >>> 3);
+    }
+    reserve(bits) {
+        const needed = (this.bitLength + bits + 7) >>> 3;
+        if (needed <= this.bytes.length)
+            return;
+        let capacity = this.bytes.length * 2;
+        while (capacity < needed)
+            capacity *= 2;
+        const grown = new Uint8Array(capacity);
+        grown.set(this.bytes);
+        this.bytes = grown;
+    }
+    /** Bits are only ever set, never cleared, so fresh bytes must start at zero, which they do. */
+    push(bit) {
+        if (bit !== 0) {
+            const at = this.bitLength >>> 3;
+            this.bytes[at] = this.bytes[at] | (0x80 >>> (this.bitLength & 7));
+        }
+        this.bitLength += 1;
+    }
+}
+export class BitReader {
+    bytes;
+    end;
+    offset = 0;
+    /**
+     * `bitLength` limits the stream to fewer bits than the bytes hold, for a
+     * symbol whose data capacity is not a whole number of bytes (Micro QR M1
+     * and M3 end on a half codeword).
+     */
+    constructor(bytes, bitLength = bytes.length * 8) {
+        if (!Number.isInteger(bitLength) || bitLength < 0 || bitLength > bytes.length * 8) {
+            throw new RangeError(`a reader over ${bytes.length} bytes holds 0 to ${bytes.length * 8} bits`);
+        }
+        this.bytes = bytes;
+        this.end = bitLength;
+    }
+    get remaining() {
+        return this.end - this.offset;
+    }
+    /** Bits read so far, for a caller reporting where in a stream something went wrong. */
+    get position() {
+        return this.offset;
+    }
+    /** Read `bits` bits as an unsigned number, most significant first. */
+    read(bits) {
+        checkWidth(bits);
+        if (bits > this.remaining) {
+            throw new RangeError(`asked for ${bits} bits with ${this.remaining} left`);
+        }
+        let value = 0;
+        for (let i = 0; i < bits; i += 1) {
+            const at = this.offset;
+            // Multiply rather than shift, so a 32 bit read stays positive.
+            value = value * 2 + ((this.bytes[at >>> 3] >>> (7 - (at & 7))) & 1);
+            this.offset = at + 1;
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=bits.js.map

package/dist/core/bits.js.map

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

package/dist/core/checksums.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The two checksums the containers need: CRC-32 for PNG chunks and ZIP
+ * entries, Adler-32 for the zlib wrapper inside PNG.
+ *
+ * Check digits for content (EMVCo CRC-16, IBAN MOD 97-10, the Swiss QR
+ * reference, GS1, Luhn) belong to the content types that use them, in
+ * payload/check-digits.ts.
+ *
+ * Lifted from the image converter's PNG writer, with the table built on first
+ * use instead of at import.
+ */
+/**
+ * CRC-32 of `bytes`.
+ *
+ * `seed` is the CRC of whatever came before, so a value can be built up in
+ * pieces: crc32(b, crc32(a)) equals crc32 of a followed by b. A PNG chunk's
+ * CRC covers its type and its data, which live in different arrays.
+ */
+export declare function crc32(bytes: Uint8Array, seed?: number): number;
+/** Adler-32 of `bytes`, as RFC 1950 defines it for the zlib wrapper. */
+export declare function adler32(bytes: Uint8Array): number;
+//# sourceMappingURL=checksums.d.ts.map

package/dist/core/checksums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksums.d.ts","sourceRoot":"","sources":["../../src/core/checksums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAmBH;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,SAAI,GAAG,MAAM,CAUzD;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAgBjD"}

package/dist/core/checksums.js

@@ -0,0 +1,64 @@
+/**
+ * The two checksums the containers need: CRC-32 for PNG chunks and ZIP
+ * entries, Adler-32 for the zlib wrapper inside PNG.
+ *
+ * Check digits for content (EMVCo CRC-16, IBAN MOD 97-10, the Swiss QR
+ * reference, GS1, Luhn) belong to the content types that use them, in
+ * payload/check-digits.ts.
+ *
+ * Lifted from the image converter's PNG writer, with the table built on first
+ * use instead of at import.
+ */
+let crcTable;
+/** The reflected CRC-32 table for polynomial 0xedb88320 (ISO 3309, as PNG and ZIP use it). */
+function table() {
+    if (crcTable !== undefined)
+        return crcTable;
+    const built = new Uint32Array(256);
+    for (let n = 0; n < 256; n += 1) {
+        let c = n;
+        for (let k = 0; k < 8; k += 1) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        built[n] = c >>> 0;
+    }
+    crcTable = built;
+    return built;
+}
+/**
+ * CRC-32 of `bytes`.
+ *
+ * `seed` is the CRC of whatever came before, so a value can be built up in
+ * pieces: crc32(b, crc32(a)) equals crc32 of a followed by b. A PNG chunk's
+ * CRC covers its type and its data, which live in different arrays.
+ */
+export function crc32(bytes, seed = 0) {
+    if (!Number.isInteger(seed) || seed < 0 || seed > 0xffffffff) {
+        throw new RangeError('a CRC-32 seed is an unsigned 32 bit integer');
+    }
+    const t = table();
+    let c = (seed ^ 0xffffffff) >>> 0;
+    for (let i = 0; i < bytes.length; i += 1) {
+        c = t[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+/** Adler-32 of `bytes`, as RFC 1950 defines it for the zlib wrapper. */
+export function adler32(bytes) {
+    let a = 1;
+    let b = 0;
+    // 5552 is the longest run that cannot overflow the sums before reducing
+    // them (and they are doubles here, so the bound is generous), which keeps
+    // the modulo to once per run rather than once per byte.
+    for (let i = 0; i < bytes.length;) {
+        const end = Math.min(i + 5552, bytes.length);
+        for (; i < end; i += 1) {
+            a += bytes[i];
+            b += a;
+        }
+        a %= 65521;
+        b %= 65521;
+    }
+    return (b * 65536 + a) >>> 0;
+}
+//# sourceMappingURL=checksums.js.map

package/dist/core/checksums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksums.js","sourceRoot":"","sources":["../../src/core/checksums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,IAAI,QAAiC,CAAC;AAEtC,8FAA8F;AAC9F,SAAS,KAAK;IACb,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC;IAC5C,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;IACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/B,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC9C,CAAC;QACD,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IACD,QAAQ,GAAG,KAAK,CAAC;IACjB,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,KAAK,CAAC,KAAiB,EAAE,IAAI,GAAG,CAAC;IAChD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,UAAU,EAAE,CAAC;QAC9D,MAAM,IAAI,UAAU,CAAC,6CAA6C,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,CAAC,GAAG,KAAK,EAAE,CAAC;IAClB,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IAClC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,CAAC,GAAI,CAAC,CAAC,CAAC,CAAC,GAAI,KAAK,CAAC,CAAC,CAAY,CAAC,GAAG,IAAI,CAAY,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,CAAC,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,OAAO,CAAC,KAAiB;IACxC,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,wEAAwE;IACxE,0EAA0E;IAC1E,wDAAwD;IACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC7C,OAAO,CAAC,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,CAAC,IAAI,KAAK,CAAC,CAAC,CAAW,CAAC;YACxB,CAAC,IAAI,CAAC,CAAC;QACR,CAAC;QACD,CAAC,IAAI,KAAK,CAAC;QACX,CAAC,IAAI,KAAK,CAAC;IACZ,CAAC;IACD,OAAO,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC"}

package/dist/core/deflate.d.ts

@@ -0,0 +1,51 @@
+/**
+ * DEFLATE (RFC 1951) and its zlib wrapper (RFC 1950), synchronous and
+ * deterministic.
+ *
+ * This exists because the platform's `CompressionStream` gives different bytes
+ * in Node, Chromium and Safari (each links its own zlib, at its own version),
+ * so the same design would export a different PNG on each, and a PNG whose
+ * bytes depend on the browser cannot be compared, cached or signed. Everything
+ * here is integer arithmetic over typed arrays, so it gives the same output
+ * everywhere, and zlib is its test oracle in both directions.
+ *
+ * The compressor is zlib's design in outline: LZ77 over a 32 KB window with
+ * hash chains, greedy parsing at level 1 and lazy parsing at 6 and 9 (with
+ * zlib's chain lengths and cut-offs), and blocks of 16 383 symbols. Each block
+ * is written in whichever of dynamic Huffman, fixed Huffman or stored is
+ * smallest. Code lengths are optimal for their limits (15 bits, 7 for the
+ * code-length code) by package-merge, with every tie broken by symbol number,
+ * so the output depends on the input and the level and on nothing else.
+ *
+ * The decompressor is strict in the same places zlib is (over-subscribed or
+ * incomplete codes, a missing end-of-block code, distances before the start,
+ * lengths past the declared counts) and stricter in one: bytes after the final
+ * block are refused rather than ignored, because a stream that ends early
+ * inside a container is a damaged container. It never allocates past
+ * `maxOutput`: the check comes before the buffer grows, so a stream built to
+ * expand to gigabytes is refused at the size it would reach next.
+ */
+export type DeflateLevel = 0 | 1 | 6 | 9;
+export interface DeflateOptions {
+    /** 0 stores, 1 is fastest, 6 is zlib's default, 9 tries hardest. Defaults to 6. */
+    readonly level?: DeflateLevel;
+}
+export interface InflateOptions {
+    /** The most bytes the output may hold. Required, because the input says nothing trustworthy about it. */
+    readonly maxOutput: number;
+}
+/** Compress `bytes` as a raw DEFLATE stream, with no header or checksum. */
+export declare function deflateRaw(bytes: Uint8Array, options?: DeflateOptions): Uint8Array;
+/** The zlib stream for `bytes`: a two byte header, the DEFLATE stream, then Adler-32 big endian. */
+export declare function zlibWrap(bytes: Uint8Array, options?: DeflateOptions): Uint8Array;
+/**
+ * Decompress a raw DEFLATE stream.
+ *
+ * Throws `ArchiveMalformedError` on a stream that breaks the format or has
+ * bytes after its final block, and `ArchiveTooLargeError` before the output
+ * would pass `maxOutput`.
+ */
+export declare function inflateRaw(bytes: Uint8Array, options: InflateOptions): Uint8Array;
+/** Decompress a zlib stream, checking its header and its Adler-32. */
+export declare function zlibUnwrap(bytes: Uint8Array, options: InflateOptions): Uint8Array;
+//# sourceMappingURL=deflate.d.ts.map

package/dist/core/deflate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deflate.d.ts","sourceRoot":"","sources":["../../src/core/deflate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEzC,MAAM,WAAW,cAAc;IAC9B,mFAAmF;IACnF,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC9B,yGAAyG;IACzG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC3B;AAkiBD,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,UAAU,CAUlF;AAED,oGAAoG;AACpG,wBAAgB,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,UAAU,CAmBhF;AA8PD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,GAAG,UAAU,CAIjF;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,cAAc,GAAG,UAAU,CAsBjF"}