{"version":3,"file":"qr.cjs","sources":["webpack://thai-qr-payment/../qr/src/bitbuffer.ts","webpack://thai-qr-payment/../qr/src/encoder.ts","webpack://thai-qr-payment/../qr/src/format-info.ts","webpack://thai-qr-payment/../qr/src/gf.ts","webpack://thai-qr-payment/../qr/src/index.ts","webpack://thai-qr-payment/../qr/src/mask.ts","webpack://thai-qr-payment/../qr/src/matrix.ts","webpack://thai-qr-payment/../qr/src/mode.ts","webpack://thai-qr-payment/../qr/src/patterns.ts","webpack://thai-qr-payment/../qr/src/placement.ts","webpack://thai-qr-payment/../qr/src/rs.ts","webpack://thai-qr-payment/../qr/src/version.ts","webpack://thai-qr-payment/./src/qr.ts"],"sourcesContent":["/**\n * Append-only bit buffer used during QR data encoding.\n *\n * QR streams pack each segment's mode indicator, character-count\n * indicator, and payload bits into a continuous bit run that's later\n * sliced into 8-bit codewords. A typed-array-backed buffer keeps the\n * allocations down compared to JS array of booleans.\n */\n\nexport class BitBuffer {\n private storage: Uint8Array;\n private bitLength = 0;\n\n constructor(initialCapacityBits = 256) {\n this.storage = new Uint8Array(Math.ceil(initialCapacityBits / 8));\n }\n\n get length(): number {\n return this.bitLength;\n }\n\n /** Push the low `count` bits of `value`, MSB first. */\n push(value: number, count: number): void {\n if (count < 0 || count > 31) {\n throw new RangeError(`Bit width ${count} out of range (1-31)`);\n }\n this.ensureCapacity(this.bitLength + count);\n for (let i = count - 1; i >= 0; i -= 1) {\n const bit = (value >>> i) & 1;\n const byteIdx = this.bitLength >>> 3;\n const bitIdx = 7 - (this.bitLength & 7);\n if (bit === 1) {\n const current = this.storage[byteIdx] ?? 0;\n this.storage[byteIdx] = current | (1 << bitIdx);\n }\n this.bitLength += 1;\n }\n }\n\n /** Materialise the buffer as a packed byte view (LSB of each byte is the rightmost bit). */\n toBytes(): Uint8Array {\n const byteCount = Math.ceil(this.bitLength / 8);\n return this.storage.slice(0, byteCount);\n }\n\n private ensureCapacity(neededBits: number): void {\n const neededBytes = Math.ceil(neededBits / 8);\n if (neededBytes <= this.storage.length) return;\n let nextSize = this.storage.length === 0 ? 1 : this.storage.length;\n while (nextSize < neededBytes) nextSize *= 2;\n const expanded = new Uint8Array(nextSize);\n expanded.set(this.storage);\n this.storage = expanded;\n }\n}\n","/**\n * Top-level QR encoder.\n *\n * Pipeline:\n * 1. Detect the narrowest mode for the input.\n * 2. Find the smallest version that fits the (mode, ECC) bit budget.\n * 3. Pack data → codewords → split into blocks → append Reed-Solomon ECC.\n * 4. Interleave codewords into the final byte stream + remainder bits.\n * 5. Lay down fixed patterns, place data in zigzag, try all 8 masks,\n * pick the one with the lowest penalty.\n * 6. Embed format-info and (for v7+) version-info, then return.\n */\n\nimport { BitBuffer } from './bitbuffer.js';\nimport { buildBaseMatrix } from './patterns.js';\nimport { applyMask, MASK_COUNT, scoreMask } from './mask.js';\nimport { placeData, placeFormatInfo, placeVersionInfo } from './placement.js';\nimport { dataBitLength, detectMode, emitSegment } from './mode.js';\nimport { encodeBlock } from './rs.js';\nimport {\n type BlockSpec,\n type ErrorCorrectionLevel,\n getBlockSpec,\n totalCodewords,\n} from './version.js';\n\nexport interface EncodeOptions {\n errorCorrectionLevel?: ErrorCorrectionLevel;\n minVersion?: number;\n maxVersion?: number;\n forceMask?: number;\n}\n\nexport interface QRMatrix {\n readonly size: number;\n readonly modules: boolean[][];\n readonly version: number;\n readonly errorCorrectionLevel: ErrorCorrectionLevel;\n readonly mask: number;\n}\n\n/** Pad a partial last codeword with 0 bits, then alternate `0xEC 0x11` filler. */\nfunction padToCapacity(bits: BitBuffer, dataCodewords: number): Uint8Array {\n const target = dataCodewords * 8;\n // Terminator: up to 4 trailing 0 bits.\n const terminator = Math.min(4, target - bits.length);\n if (terminator > 0) bits.push(0, terminator);\n // Pad to byte boundary.\n if (bits.length % 8 !== 0) bits.push(0, 8 - (bits.length % 8));\n // Filler bytes alternate 0xEC / 0x11 per spec until full.\n const bytes = new Uint8Array(dataCodewords);\n const partial = bits.toBytes();\n bytes.set(partial.slice(0, dataCodewords));\n let toggle = false;\n for (let i = partial.length; i < dataCodewords; i += 1) {\n bytes[i] = toggle ? 0x11 : 0xec;\n toggle = !toggle;\n }\n return bytes;\n}\n\n/** Split data into ECC blocks and append Reed-Solomon parity to each. */\nfunction buildCodewordBlocks(\n spec: BlockSpec,\n data: Uint8Array,\n): {\n dataBlocks: Uint8Array[];\n ecBlocks: Uint8Array[];\n} {\n const dataBlocks: Uint8Array[] = [];\n const ecBlocks: Uint8Array[] = [];\n let offset = 0;\n for (const [count, perBlock] of spec.groups) {\n for (let i = 0; i < count; i += 1) {\n const block = data.slice(offset, offset + perBlock);\n offset += perBlock;\n dataBlocks.push(block);\n ecBlocks.push(encodeBlock(block, spec.ecPerBlock));\n }\n }\n return { dataBlocks, ecBlocks };\n}\n\n/** Interleave data + ECC blocks column-major per ISO/IEC 18004 §7.6. */\nfunction interleave(dataBlocks: Uint8Array[], ecBlocks: Uint8Array[]): Uint8Array {\n const maxDataLen = Math.max(...dataBlocks.map((b) => b.length));\n const maxEcLen = Math.max(...ecBlocks.map((b) => b.length));\n const out: number[] = [];\n for (let i = 0; i < maxDataLen; i += 1) {\n for (const block of dataBlocks) if (i < block.length) out.push(block[i] ?? 0);\n }\n for (let i = 0; i < maxEcLen; i += 1) {\n for (const block of ecBlocks) if (i < block.length) out.push(block[i] ?? 0);\n }\n return Uint8Array.from(out);\n}\n\n/** Select the smallest version that can hold the encoded segment. */\nfunction pickVersion(\n text: string,\n mode: ReturnType,\n ecc: ErrorCorrectionLevel,\n min: number,\n max: number,\n): number {\n for (let version = min; version <= max; version += 1) {\n const needBits = dataBitLength(mode, text, version);\n const capacity = getBlockSpec(version, ecc).dataCodewords * 8;\n if (needBits <= capacity) return version;\n }\n throw new RangeError(\n `Input does not fit in versions ${min}-${max} at ECC ${ecc} (${text.length} chars)`,\n );\n}\n\n/**\n * Encode `text` as a QR Code matrix.\n *\n * The returned matrix is a square 2-D boolean array (`true` = dark\n * module). Render with any output (SVG, canvas, PNG, terminal).\n */\nexport function encodeQR(text: string, options: EncodeOptions = {}): QRMatrix {\n const ecc = options.errorCorrectionLevel ?? 'M';\n const minVersion = options.minVersion ?? 1;\n const maxVersion = options.maxVersion ?? 40;\n\n const mode = detectMode(text);\n const version = pickVersion(text, mode, ecc, minVersion, maxVersion);\n const spec = getBlockSpec(version, ecc);\n\n // 1) Bit-encode the segment + pad to full data-codeword capacity.\n const bits = new BitBuffer();\n emitSegment(text, mode, version, bits);\n const codewords = padToCapacity(bits, spec.dataCodewords);\n\n // 2) ECC + interleave into final byte stream.\n const { dataBlocks, ecBlocks } = buildCodewordBlocks(spec, codewords);\n const finalBytes = interleave(dataBlocks, ecBlocks);\n\n // QR may require a few zero \"remainder bits\" at the end of the stream.\n const totalBytesNeeded = Math.ceil(\n (totalCodewords(version, ecc) * 8 + REMAINDER_BITS[version]!) / 8,\n );\n const padded = new Uint8Array(totalBytesNeeded);\n padded.set(finalBytes);\n\n // 3) Build the base matrix and place data, format, version info.\n const base = buildBaseMatrix(version);\n placeData(base, padded);\n\n // 4) Pick the lowest-penalty mask.\n const snapshot = base.snapshot();\n let bestMask = options.forceMask ?? 0;\n let bestScore = Number.POSITIVE_INFINITY;\n if (options.forceMask == null) {\n for (let mask = 0; mask < MASK_COUNT; mask += 1) {\n base.restore(snapshot);\n placeFormatInfo(base, ecc, mask);\n placeVersionInfo(base, version);\n applyMask(base, mask);\n const score = scoreMask(base);\n if (score < bestScore) {\n bestScore = score;\n bestMask = mask;\n }\n }\n }\n\n base.restore(snapshot);\n placeFormatInfo(base, ecc, bestMask);\n placeVersionInfo(base, version);\n applyMask(base, bestMask);\n\n return {\n size: base.dim,\n modules: base.toBooleans(),\n version,\n errorCorrectionLevel: ecc,\n mask: bestMask,\n };\n}\n\n// Remainder-bit table per ISO/IEC 18004 §7.7.\nconst REMAINDER_BITS: Record = {\n 1: 0,\n 2: 7,\n 3: 7,\n 4: 7,\n 5: 7,\n 6: 7,\n 7: 0,\n 8: 0,\n 9: 0,\n 10: 0,\n 11: 0,\n 12: 0,\n 13: 0,\n 14: 3,\n 15: 3,\n 16: 3,\n 17: 3,\n 18: 3,\n 19: 3,\n 20: 3,\n 21: 4,\n 22: 4,\n 23: 4,\n 24: 4,\n 25: 4,\n 26: 4,\n 27: 4,\n 28: 3,\n 29: 3,\n 30: 3,\n 31: 3,\n 32: 3,\n 33: 3,\n 34: 3,\n 35: 0,\n 36: 0,\n 37: 0,\n 38: 0,\n 39: 0,\n 40: 0,\n};\n","/**\n * Format-information and version-information bit strings.\n *\n * Format info encodes (ECC level, mask index) as a 15-bit BCH (15, 5)\n * codeword XOR'd with the spec's fixed mask `0x5412`. Version info\n * encodes the version as an 18-bit BCH (18, 6) codeword for v7+.\n */\n\nimport { ECC_BITS, type ErrorCorrectionLevel } from './version.js';\n\nconst FORMAT_MASK = 0x5412;\nconst FORMAT_GENERATOR = 0x537; // 0b10100110111\nconst VERSION_GENERATOR = 0x1f25;\n\n/** BCH(15,5) encode the (ecc, mask) tuple and XOR with the format mask. */\nexport function encodeFormatBits(ecc: ErrorCorrectionLevel, mask: number): number {\n const data = ((ECC_BITS[ecc] & 0b11) << 3) | (mask & 0b111);\n let value = data << 10;\n for (let i = 4; i >= 0; i -= 1) {\n if (((value >> (i + 10)) & 1) !== 0) {\n value ^= FORMAT_GENERATOR << i;\n }\n }\n const bch = (data << 10) | (value & 0x3ff);\n return bch ^ FORMAT_MASK;\n}\n\n/** BCH(18,6) encode the version number (only used for v7+). */\nexport function encodeVersionBits(version: number): number {\n let value = version << 12;\n for (let i = 5; i >= 0; i -= 1) {\n if (((value >> (i + 12)) & 1) !== 0) {\n value ^= VERSION_GENERATOR << i;\n }\n }\n return (version << 12) | (value & 0xfff);\n}\n","/**\n * Galois field GF(2^8) arithmetic over the QR-spec primitive polynomial\n * 0x11D (binary 100011101) — the same field used by Reed-Solomon error\n * correction throughout ISO/IEC 18004.\n *\n * Lookup tables (`EXP` / `LOG`) trade 512 bytes for constant-time\n * multiplication and inversion. We build them once at module load using\n * the standard alpha-power generator.\n */\n\nconst PRIMITIVE = 0x11d;\n\nexport const EXP: Uint8Array = new Uint8Array(512);\nexport const LOG: Uint8Array = new Uint8Array(256);\n\n(() => {\n let x = 1;\n for (let i = 0; i < 255; i += 1) {\n EXP[i] = x;\n LOG[x] = i;\n x <<= 1;\n if (x & 0x100) x ^= PRIMITIVE;\n }\n // Mirror the first 255 entries into [255, 510] so callers can compute\n // (LOG[a] + LOG[b]) without modulo.\n for (let i = 255; i < 512; i += 1) {\n EXP[i] = EXP[i - 255] ?? 0;\n }\n})();\n\n/** Multiply two field elements. Returns 0 when either operand is 0. */\nexport function mul(a: number, b: number): number {\n if (a === 0 || b === 0) return 0;\n return EXP[(LOG[a] ?? 0) + (LOG[b] ?? 0)] ?? 0;\n}\n","/**\n * `@thai-qr-payment/qr` — zero-dependency QR Code encoder.\n *\n * ISO/IEC 18004 Model-2 implementation tuned for Thai QR Payment\n * (EMVCo MPM) payloads. Returns a boolean matrix; rendering is the\n * caller's responsibility (use `@thai-qr-payment/render` for SVG).\n */\n\nexport { encodeQR } from './encoder.js';\nexport type { EncodeOptions, QRMatrix } from './encoder.js';\nexport type { ErrorCorrectionLevel } from './version.js';\nexport { detectMode } from './mode.js';\nexport type { EncodingMode } from './mode.js';\n","/**\n * Mask pattern selection + penalty scoring per ISO/IEC 18004 §7.8.\n *\n * QR defines 8 mask patterns. After data placement, each candidate mask\n * is applied to the free-data modules and scored on four rule\n * categories; the lowest-scoring mask wins.\n */\n\nimport type { Matrix } from './matrix.js';\n\nconst MASK_PREDICATES: ReadonlyArray<(x: number, y: number) => boolean> = [\n (x, y) => (x + y) % 2 === 0,\n (_x, y) => y % 2 === 0,\n (x) => x % 3 === 0,\n (x, y) => (x + y) % 3 === 0,\n (x, y) => (Math.floor(y / 2) + Math.floor(x / 3)) % 2 === 0,\n (x, y) => ((x * y) % 2) + ((x * y) % 3) === 0,\n (x, y) => (((x * y) % 2) + ((x * y) % 3)) % 2 === 0,\n (x, y) => (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,\n];\n\n/** Toggle every free-data module that matches the mask predicate. */\nexport function applyMask(matrix: Matrix, maskIndex: number): void {\n const predicate = MASK_PREDICATES[maskIndex];\n if (!predicate) throw new RangeError(`Mask index ${maskIndex} out of range`);\n for (let y = 0; y < matrix.dim; y += 1) {\n for (let x = 0; x < matrix.dim; x += 1) {\n if (matrix.isReserved(x, y)) continue;\n if (predicate(x, y)) matrix.set(x, y, !matrix.get(x, y));\n }\n }\n}\n\n// ── Penalty rules ─────────────────────────────────────────────────────\n\n/** Rule 1: penalty for consecutive runs of same-colour modules. */\nfunction penaltyRunLength(matrix: Matrix): number {\n let total = 0;\n const { dim } = matrix;\n for (let y = 0; y < dim; y += 1) {\n let runColor = matrix.get(0, y);\n let runLen = 1;\n for (let x = 1; x < dim; x += 1) {\n const c = matrix.get(x, y);\n if (c === runColor) {\n runLen += 1;\n } else {\n if (runLen >= 5) total += runLen - 2;\n runColor = c;\n runLen = 1;\n }\n }\n if (runLen >= 5) total += runLen - 2;\n }\n for (let x = 0; x < dim; x += 1) {\n let runColor = matrix.get(x, 0);\n let runLen = 1;\n for (let y = 1; y < dim; y += 1) {\n const c = matrix.get(x, y);\n if (c === runColor) {\n runLen += 1;\n } else {\n if (runLen >= 5) total += runLen - 2;\n runColor = c;\n runLen = 1;\n }\n }\n if (runLen >= 5) total += runLen - 2;\n }\n return total;\n}\n\n/** Rule 2: penalty for 2×2 blocks of same-colour modules. */\nfunction penaltyBlocks(matrix: Matrix): number {\n let count = 0;\n const { dim } = matrix;\n for (let y = 0; y < dim - 1; y += 1) {\n for (let x = 0; x < dim - 1; x += 1) {\n const c = matrix.get(x, y);\n if (\n matrix.get(x + 1, y) === c &&\n matrix.get(x, y + 1) === c &&\n matrix.get(x + 1, y + 1) === c\n ) {\n count += 1;\n }\n }\n }\n return count * 3;\n}\n\n/** Rule 3: penalty for finder-like patterns 10111010000 / 00001011101. */\nfunction penaltyFinderLike(matrix: Matrix): number {\n const { dim } = matrix;\n let count = 0;\n const pattern1 = [1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0];\n const pattern2 = [0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1];\n const matches = (line: number[]): number => {\n let hits = 0;\n for (let i = 0; i <= line.length - 11; i += 1) {\n let ok1 = true;\n let ok2 = true;\n for (let j = 0; j < 11; j += 1) {\n if (line[i + j] !== pattern1[j]) ok1 = false;\n if (line[i + j] !== pattern2[j]) ok2 = false;\n if (!ok1 && !ok2) break;\n }\n if (ok1) hits += 1;\n if (ok2) hits += 1;\n }\n return hits;\n };\n for (let y = 0; y < dim; y += 1) {\n const row: number[] = [];\n for (let x = 0; x < dim; x += 1) row.push(matrix.get(x, y) ? 1 : 0);\n count += matches(row);\n }\n for (let x = 0; x < dim; x += 1) {\n const col: number[] = [];\n for (let y = 0; y < dim; y += 1) col.push(matrix.get(x, y) ? 1 : 0);\n count += matches(col);\n }\n return count * 40;\n}\n\n/** Rule 4: penalty for dark/light imbalance. */\nfunction penaltyBalance(matrix: Matrix): number {\n let dark = 0;\n const total = matrix.dim * matrix.dim;\n for (let y = 0; y < matrix.dim; y += 1) {\n for (let x = 0; x < matrix.dim; x += 1) {\n if (matrix.get(x, y)) dark += 1;\n }\n }\n const ratio = (dark * 100) / total;\n const off = Math.floor(Math.abs(ratio - 50) / 5);\n return off * 10;\n}\n\n/** Total penalty (lower is better). */\nexport function scoreMask(matrix: Matrix): number {\n return (\n penaltyRunLength(matrix) +\n penaltyBlocks(matrix) +\n penaltyFinderLike(matrix) +\n penaltyBalance(matrix)\n );\n}\n\nexport const MASK_COUNT = MASK_PREDICATES.length;\n","/**\n * Module-grid layout for a single QR code.\n *\n * Wraps a `Uint8Array` of size `dim*dim` storing one bit per module.\n * A parallel \"reserved\" mask tracks which modules belong to fixed\n * patterns (finders, alignment, timing, format, version) so the data\n * placement skips them during the zigzag walk.\n */\n\nconst DARK = 1;\nconst LIGHT = 0;\nconst RESERVED = 1;\nconst FREE = 0;\n\nexport class Matrix {\n readonly dim: number;\n private readonly modules: Uint8Array;\n private readonly reserved: Uint8Array;\n\n constructor(dim: number) {\n this.dim = dim;\n this.modules = new Uint8Array(dim * dim);\n this.reserved = new Uint8Array(dim * dim);\n }\n\n get(x: number, y: number): boolean {\n return (this.modules[y * this.dim + x] ?? 0) === DARK;\n }\n\n set(x: number, y: number, dark: boolean): void {\n this.modules[y * this.dim + x] = dark ? DARK : LIGHT;\n }\n\n reserve(x: number, y: number): void {\n this.reserved[y * this.dim + x] = RESERVED;\n }\n\n isReserved(x: number, y: number): boolean {\n return (this.reserved[y * this.dim + x] ?? 0) === RESERVED;\n }\n\n /** Export as a 2-D boolean array; useful for renderers. */\n toBooleans(): boolean[][] {\n const rows: boolean[][] = [];\n for (let y = 0; y < this.dim; y += 1) {\n const row: boolean[] = Array.from({ length: this.dim }, () => false);\n for (let x = 0; x < this.dim; x += 1) {\n row[x] = this.get(x, y);\n }\n rows.push(row);\n }\n return rows;\n }\n\n /** Snapshot just the data-module bits (used during mask scoring). */\n snapshot(): Uint8Array {\n return this.modules.slice();\n }\n\n restore(snapshot: Uint8Array): void {\n this.modules.set(snapshot);\n }\n\n /** True if a module at (x, y) is on the free-data path. */\n isFree(x: number, y: number): boolean {\n return !this.isReserved(x, y);\n }\n\n fillReserved(x: number, y: number, dark: boolean): void {\n this.set(x, y, dark);\n this.reserve(x, y);\n }\n}\n\nexport { DARK, LIGHT, RESERVED, FREE };\n","/**\n * Encoding mode detection + bit emission for QR data segments.\n *\n * We support the three modes that matter for Thai QR Payment:\n * - **Numeric** (3 chars → 10 bits): for amount-only payloads\n * - **Alphanumeric** (2 chars → 11 bits): the EMVCo payload character\n * set fits entirely here ([0-9A-Z $%*+-./:])\n * - **Byte** (1 char → 8 bits): fallback for arbitrary text\n *\n * Mode indicators are 4-bit constants prefixed to each segment.\n */\n\nimport type { BitBuffer } from './bitbuffer.js';\n\nexport type EncodingMode = 'numeric' | 'alphanumeric' | 'byte';\n\nexport const MODE_INDICATOR: Record = {\n numeric: 0b0001,\n alphanumeric: 0b0010,\n byte: 0b0100,\n};\n\nconst ALPHANUMERIC_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:';\n\n/** Reverse-lookup map for alphanumeric encoding. */\nconst ALPHANUMERIC_INDEX: ReadonlyMap = (() => {\n const map = new Map();\n for (let i = 0; i < ALPHANUMERIC_CHARS.length; i += 1) {\n map.set(ALPHANUMERIC_CHARS[i]!, i);\n }\n return map;\n})();\n\n/** Width of the character-count indicator (depends on mode + version range). */\nexport function charCountBits(mode: EncodingMode, version: number): number {\n if (version <= 9) {\n return mode === 'numeric' ? 10 : mode === 'alphanumeric' ? 9 : 8;\n }\n if (version <= 26) {\n return mode === 'numeric' ? 12 : mode === 'alphanumeric' ? 11 : 16;\n }\n return mode === 'numeric' ? 14 : mode === 'alphanumeric' ? 13 : 16;\n}\n\nconst DIGITS_RE = /^[0-9]+$/;\nconst ALPHANUM_RE = /^[0-9A-Z $%*+\\-./:]+$/;\n\n/** Detect the narrowest mode that can encode the entire input. */\nexport function detectMode(text: string): EncodingMode {\n if (DIGITS_RE.test(text)) return 'numeric';\n if (ALPHANUM_RE.test(text)) return 'alphanumeric';\n return 'byte';\n}\n\n/** Bit length of the encoded payload (mode indicator + counter + data). */\nexport function dataBitLength(mode: EncodingMode, text: string, version: number): number {\n const header = 4 + charCountBits(mode, version);\n switch (mode) {\n case 'numeric': {\n const full = Math.floor(text.length / 3);\n const remainder = text.length - full * 3;\n const tail = remainder === 0 ? 0 : remainder === 1 ? 4 : 7;\n return header + full * 10 + tail;\n }\n case 'alphanumeric': {\n const pairs = Math.floor(text.length / 2);\n const remainder = text.length - pairs * 2;\n return header + pairs * 11 + (remainder === 0 ? 0 : 6);\n }\n case 'byte':\n return header + utf8Length(text) * 8;\n }\n}\n\nfunction utf8Length(text: string): number {\n // Most Thai QR payloads are ASCII; this branch keeps correctness for\n // hypothetical UTF-8 byte-mode segments without paying for a full\n // TextEncoder allocation on the hot path.\n if (typeof TextEncoder !== 'undefined') return new TextEncoder().encode(text).length;\n let count = 0;\n for (let i = 0; i < text.length; i += 1) {\n const code = text.charCodeAt(i);\n if (code < 0x80) count += 1;\n else if (code < 0x800) count += 2;\n else if (code >= 0xd800 && code <= 0xdbff) {\n count += 4;\n i += 1; // surrogate pair\n } else count += 3;\n }\n return count;\n}\n\n/** Emit a numeric segment. */\nfunction emitNumeric(text: string, bits: BitBuffer): void {\n let i = 0;\n while (i + 3 <= text.length) {\n const triple = Number.parseInt(text.slice(i, i + 3), 10);\n bits.push(triple, 10);\n i += 3;\n }\n const remainder = text.length - i;\n if (remainder === 2) bits.push(Number.parseInt(text.slice(i), 10), 7);\n else if (remainder === 1) bits.push(Number.parseInt(text.slice(i), 10), 4);\n}\n\n/** Emit an alphanumeric segment. */\nfunction emitAlphanumeric(text: string, bits: BitBuffer): void {\n let i = 0;\n while (i + 2 <= text.length) {\n const high = ALPHANUMERIC_INDEX.get(text[i]!);\n const low = ALPHANUMERIC_INDEX.get(text[i + 1]!);\n if (high == null || low == null) throw new TypeError(`Char outside alphanumeric set at ${i}`);\n bits.push(high * 45 + low, 11);\n i += 2;\n }\n if (i < text.length) {\n const value = ALPHANUMERIC_INDEX.get(text[i]!);\n if (value == null) throw new TypeError(`Char outside alphanumeric set at ${i}`);\n bits.push(value, 6);\n }\n}\n\n/** Emit a byte segment (UTF-8 encoded). */\nfunction emitByte(text: string, bits: BitBuffer): void {\n const encoded =\n typeof TextEncoder !== 'undefined' ? new TextEncoder().encode(text) : utf8EncodeFallback(text);\n for (let i = 0; i < encoded.length; i += 1) {\n bits.push(encoded[i] ?? 0, 8);\n }\n}\n\nfunction utf8EncodeFallback(text: string): Uint8Array {\n const out: number[] = [];\n for (let i = 0; i < text.length; i += 1) {\n let code = text.charCodeAt(i);\n if (code >= 0xd800 && code <= 0xdbff && i + 1 < text.length) {\n const low = text.charCodeAt(i + 1);\n if (low >= 0xdc00 && low <= 0xdfff) {\n code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);\n i += 1;\n }\n }\n if (code < 0x80) out.push(code);\n else if (code < 0x800) out.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));\n else if (code < 0x10000) {\n out.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));\n } else {\n out.push(\n 0xf0 | (code >> 18),\n 0x80 | ((code >> 12) & 0x3f),\n 0x80 | ((code >> 6) & 0x3f),\n 0x80 | (code & 0x3f),\n );\n }\n }\n return Uint8Array.from(out);\n}\n\n/** Append the full segment (mode + count + data) to the bit buffer. */\nexport function emitSegment(\n text: string,\n mode: EncodingMode,\n version: number,\n bits: BitBuffer,\n): void {\n bits.push(MODE_INDICATOR[mode], 4);\n bits.push(text.length, charCountBits(mode, version));\n switch (mode) {\n case 'numeric':\n emitNumeric(text, bits);\n return;\n case 'alphanumeric':\n emitAlphanumeric(text, bits);\n return;\n case 'byte':\n emitByte(text, bits);\n return;\n }\n}\n","/**\n * Fixed-pattern placement: finder, separator, alignment, timing, dark\n * module, format-info reservation, and version-info reservation.\n *\n * Each routine reserves the modules it touches so the data placement\n * pass can skip over them.\n */\n\nimport { Matrix } from './matrix.js';\nimport { alignmentCentres, moduleCount } from './version.js';\n\nfunction placeFinder(m: Matrix, originX: number, originY: number): void {\n for (let dy = -1; dy <= 7; dy += 1) {\n for (let dx = -1; dx <= 7; dx += 1) {\n const x = originX + dx;\n const y = originY + dy;\n if (x < 0 || y < 0 || x >= m.dim || y >= m.dim) continue;\n const onEdge = dx === 0 || dx === 6 || dy === 0 || dy === 6;\n const insideCore = dx >= 2 && dx <= 4 && dy >= 2 && dy <= 4;\n const isBorder = dx === -1 || dx === 7 || dy === -1 || dy === 7;\n const dark = !isBorder && (onEdge || insideCore);\n m.fillReserved(x, y, dark);\n }\n }\n}\n\nfunction placeAlignment(m: Matrix, cx: number, cy: number): void {\n for (let dy = -2; dy <= 2; dy += 1) {\n for (let dx = -2; dx <= 2; dx += 1) {\n const dark = Math.max(Math.abs(dx), Math.abs(dy)) !== 1;\n m.fillReserved(cx + dx, cy + dy, dark);\n }\n }\n}\n\nfunction placeTimingPatterns(m: Matrix): void {\n for (let i = 8; i < m.dim - 8; i += 1) {\n const dark = i % 2 === 0;\n m.fillReserved(i, 6, dark);\n m.fillReserved(6, i, dark);\n }\n}\n\nfunction placeDarkModule(m: Matrix, version: number): void {\n // The dark module is the single forced-on module at (8, 4*v + 9).\n m.fillReserved(8, 4 * version + 9, true);\n}\n\nfunction reserveFormatInfo(m: Matrix): void {\n const dim = m.dim;\n // Around top-left finder\n for (let i = 0; i <= 8; i += 1) {\n if (i !== 6) m.reserve(i, 8);\n if (i !== 6) m.reserve(8, i);\n }\n // Bottom-left + top-right format strips\n for (let i = 0; i < 7; i += 1) m.reserve(8, dim - 1 - i);\n for (let i = 0; i < 8; i += 1) m.reserve(dim - 1 - i, 8);\n}\n\nfunction reserveVersionInfo(m: Matrix, version: number): void {\n if (version < 7) return;\n const dim = m.dim;\n for (let row = 0; row < 6; row += 1) {\n for (let col = dim - 11; col < dim - 8; col += 1) {\n m.reserve(col, row);\n m.reserve(row, col);\n }\n }\n}\n\n/**\n * Lay down every fixed pattern for the given version. Returns the\n * matrix in a state where the only unreserved modules are those\n * available for data placement (still empty / 0).\n */\nexport function buildBaseMatrix(version: number): Matrix {\n const dim = moduleCount(version);\n const m = new Matrix(dim);\n\n placeFinder(m, 0, 0);\n placeFinder(m, dim - 7, 0);\n placeFinder(m, 0, dim - 7);\n\n for (const cx of alignmentCentres(version)) {\n for (const cy of alignmentCentres(version)) {\n // Skip alignment patterns that overlap finder patterns.\n const onTopLeftFinder = cx <= 8 && cy <= 8;\n const onTopRightFinder = cx >= dim - 9 && cy <= 8;\n const onBottomLeftFinder = cx <= 8 && cy >= dim - 9;\n if (onTopLeftFinder || onTopRightFinder || onBottomLeftFinder) continue;\n placeAlignment(m, cx, cy);\n }\n }\n\n placeTimingPatterns(m);\n placeDarkModule(m, version);\n reserveFormatInfo(m);\n reserveVersionInfo(m, version);\n\n return m;\n}\n","/**\n * Module placement: data zigzag, format-info embed, version-info embed.\n */\n\nimport { encodeFormatBits, encodeVersionBits } from './format-info.js';\nimport type { Matrix } from './matrix.js';\nimport type { ErrorCorrectionLevel } from './version.js';\n\n/**\n * Walk the QR data area right-to-left in 2-column vertical zigzag and\n * place data bits. Columns at x=6 are skipped (timing pattern lives there).\n */\nexport function placeData(matrix: Matrix, bytes: Uint8Array): void {\n const { dim } = matrix;\n let bitIndex = 0;\n let upward = true;\n\n for (let right = dim - 1; right >= 1; right -= 2) {\n if (right === 6) right -= 1; // skip the vertical timing column\n\n for (let v = 0; v < dim; v += 1) {\n const y = upward ? dim - 1 - v : v;\n for (let off = 0; off < 2; off += 1) {\n const x = right - off;\n if (matrix.isReserved(x, y)) continue;\n const byteIdx = bitIndex >>> 3;\n const bitOffset = 7 - (bitIndex & 7);\n const bit = (((bytes[byteIdx] ?? 0) >>> bitOffset) & 1) === 1;\n matrix.set(x, y, bit);\n bitIndex += 1;\n }\n }\n\n upward = !upward;\n }\n}\n\n/** Embed the 15-bit format-info word in the two canonical strips. */\nexport function placeFormatInfo(matrix: Matrix, ecc: ErrorCorrectionLevel, mask: number): void {\n const bits = encodeFormatBits(ecc, mask);\n const { dim } = matrix;\n\n // Top-left strip (around the top-left finder)\n for (let i = 0; i < 6; i += 1) matrix.set(8, i, ((bits >>> i) & 1) === 1);\n matrix.set(8, 7, ((bits >>> 6) & 1) === 1);\n matrix.set(8, 8, ((bits >>> 7) & 1) === 1);\n matrix.set(7, 8, ((bits >>> 8) & 1) === 1);\n for (let i = 9; i < 15; i += 1) matrix.set(14 - i, 8, ((bits >>> i) & 1) === 1);\n\n // Bottom-left + top-right strips\n for (let i = 0; i < 8; i += 1) matrix.set(dim - 1 - i, 8, ((bits >>> i) & 1) === 1);\n for (let i = 8; i < 15; i += 1) matrix.set(8, dim - 15 + i, ((bits >>> i) & 1) === 1);\n}\n\n/** Embed the version-info word for v7+. No-op for v1-6. */\nexport function placeVersionInfo(matrix: Matrix, version: number): void {\n if (version < 7) return;\n const bits = encodeVersionBits(version);\n const { dim } = matrix;\n for (let i = 0; i < 18; i += 1) {\n const bit = ((bits >>> i) & 1) === 1;\n const row = Math.floor(i / 3);\n const col = (i % 3) + dim - 11;\n matrix.set(col, row, bit);\n matrix.set(row, col, bit);\n }\n}\n","/**\n * Reed-Solomon error correction over GF(2^8).\n *\n * QR uses a punctured Reed-Solomon code with the generator polynomial\n * g(x) = ∏ (x − α^i) for i ∈ [0, ecLen)\n * built incrementally from the alpha exponents in `gf.EXP`. The encoder\n * computes the codeword remainder via long division and appends it to\n * the data stream.\n */\n\nimport { EXP, LOG, mul } from './gf.js';\n\n/** Pre-compute the RS generator polynomial of the requested length. */\nfunction buildGenerator(ecLen: number): Uint8Array {\n // Start with the constant polynomial g(x) = 1.\n let poly = new Uint8Array([1]);\n for (let i = 0; i < ecLen; i += 1) {\n // Multiply by (x − α^i): new coefficients have length+1 entries.\n const next = new Uint8Array(poly.length + 1);\n const alphaI = EXP[i] ?? 0;\n for (let j = 0; j < poly.length; j += 1) {\n const coeff = poly[j] ?? 0;\n const carry = next[j] ?? 0;\n next[j] = carry ^ coeff;\n const tail = next[j + 1] ?? 0;\n next[j + 1] = tail ^ mul(coeff, alphaI);\n }\n poly = next;\n }\n return poly;\n}\n\n/**\n * Encode a data block with `ecLen` ECC codewords appended. The output\n * is `data.length + ecLen` bytes long and matches the per-block format\n * used by QR's interleaved data layout.\n */\nexport function encodeBlock(data: Uint8Array, ecLen: number): Uint8Array {\n const generator = buildGenerator(ecLen);\n const buffer = new Uint8Array(data.length + ecLen);\n buffer.set(data, 0);\n\n for (let i = 0; i < data.length; i += 1) {\n const lead = buffer[i] ?? 0;\n if (lead === 0) continue;\n const leadLog = LOG[lead] ?? 0;\n for (let j = 0; j < generator.length; j += 1) {\n const coeff = generator[j] ?? 0;\n if (coeff === 0) continue;\n const slot = buffer[i + j] ?? 0;\n buffer[i + j] = slot ^ (EXP[leadLog + (LOG[coeff] ?? 0)] ?? 0);\n }\n }\n\n return buffer.slice(data.length);\n}\n","/**\n * Capacity tables + version metadata from ISO/IEC 18004 §6.5 and Annex D.\n *\n * Each version 1-40 has 4 ECC levels (L, M, Q, H). For each (version, ECC)\n * the spec defines:\n * - Total data codewords (`dataCodewords`)\n * - Number of error-correction blocks (groups)\n * - Block sizes within each group\n *\n * The matrix dimension is `(version - 1) * 4 + 21`.\n */\n\nexport type ErrorCorrectionLevel = 'L' | 'M' | 'Q' | 'H';\n\nexport interface BlockSpec {\n /** Total data codewords across all blocks at this (version, ECC). */\n readonly dataCodewords: number;\n /** ECC codewords per block. */\n readonly ecPerBlock: number;\n /** `[count, dataPerBlock]` group entries (1 or 2 groups). */\n readonly groups: ReadonlyArray;\n}\n\n// Format-bit prefix per ECC level (used by format-info encoding too).\nexport const ECC_BITS: Record = {\n L: 0b01,\n M: 0b00,\n Q: 0b11,\n H: 0b10,\n};\n\n/** Matrix dimension in modules. */\nexport function moduleCount(version: number): number {\n return (version - 1) * 4 + 21;\n}\n\n// Block layout per (version, ECC). Sourced from ISO/IEC 18004:2015 Table 9.\n// Compactly encoded as a 2-D lookup keyed by (version, ECC).\n//\n// Each entry = [dataCodewords, ecPerBlock, groupCount1, dataPerBlock1,\n// groupCount2?, dataPerBlock2?]\n// ecBlocks[version-1][ecc] → row above.\nconst ECC_INDEX: Record = { L: 0, M: 1, Q: 2, H: 3 };\n\n// prettier-ignore\nconst ECC_TABLE: ReadonlyArray>> = [\n // v1\n [\n [19, 7, 1, 19],\n [16, 10, 1, 16],\n [13, 13, 1, 13],\n [9, 17, 1, 9],\n ],\n // v2\n [\n [34, 10, 1, 34],\n [28, 16, 1, 28],\n [22, 22, 1, 22],\n [16, 28, 1, 16],\n ],\n // v3\n [\n [55, 15, 1, 55],\n [44, 26, 1, 44],\n [34, 18, 2, 17],\n [26, 22, 2, 13],\n ],\n // v4\n [\n [80, 20, 1, 80],\n [64, 18, 2, 32],\n [48, 26, 2, 24],\n [36, 16, 4, 9],\n ],\n // v5\n [\n [108, 26, 1, 108],\n [86, 24, 2, 43],\n [62, 18, 2, 15, 2, 16],\n [46, 22, 2, 11, 2, 12],\n ],\n // v6\n [\n [136, 18, 2, 68],\n [108, 16, 4, 27],\n [76, 24, 4, 19],\n [60, 28, 4, 15],\n ],\n // v7\n [\n [156, 20, 2, 78],\n [124, 18, 4, 31],\n [88, 18, 2, 14, 4, 15],\n [66, 26, 4, 13, 1, 14],\n ],\n // v8\n [\n [194, 24, 2, 97],\n [154, 22, 2, 38, 2, 39],\n [110, 22, 4, 18, 2, 19],\n [86, 26, 4, 14, 2, 15],\n ],\n // v9\n [\n [232, 30, 2, 116],\n [182, 22, 3, 36, 2, 37],\n [132, 20, 4, 16, 4, 17],\n [100, 24, 4, 12, 4, 13],\n ],\n // v10\n [\n [274, 18, 2, 68, 2, 69],\n [216, 26, 4, 43, 1, 44],\n [154, 24, 6, 19, 2, 20],\n [122, 28, 6, 15, 2, 16],\n ],\n // v11\n [\n [324, 20, 4, 81],\n [254, 30, 1, 50, 4, 51],\n [180, 28, 4, 22, 4, 23],\n [140, 24, 3, 12, 8, 13],\n ],\n // v12\n [\n [370, 24, 2, 92, 2, 93],\n [290, 22, 6, 36, 2, 37],\n [206, 26, 4, 20, 6, 21],\n [158, 28, 7, 14, 4, 15],\n ],\n // v13\n [\n [428, 26, 4, 107],\n [334, 22, 8, 37, 1, 38],\n [244, 24, 8, 20, 4, 21],\n [180, 22, 12, 11, 4, 12],\n ],\n // v14\n [\n [461, 30, 3, 115, 1, 116],\n [365, 24, 4, 40, 5, 41],\n [261, 20, 11, 16, 5, 17],\n [197, 24, 11, 12, 5, 13],\n ],\n // v15\n [\n [523, 22, 5, 87, 1, 88],\n [415, 24, 5, 41, 5, 42],\n [295, 30, 5, 24, 7, 25],\n [223, 24, 11, 12, 7, 13],\n ],\n // v16\n [\n [589, 24, 5, 98, 1, 99],\n [453, 28, 7, 45, 3, 46],\n [325, 24, 15, 19, 2, 20],\n [253, 30, 3, 15, 13, 16],\n ],\n // v17\n [\n [647, 28, 1, 107, 5, 108],\n [507, 28, 10, 46, 1, 47],\n [367, 28, 1, 22, 15, 23],\n [283, 28, 2, 14, 17, 15],\n ],\n // v18\n [\n [721, 30, 5, 120, 1, 121],\n [563, 26, 9, 43, 4, 44],\n [397, 28, 17, 22, 1, 23],\n [313, 28, 2, 14, 19, 15],\n ],\n // v19\n [\n [795, 28, 3, 113, 4, 114],\n [627, 26, 3, 44, 11, 45],\n [445, 26, 17, 21, 4, 22],\n [341, 26, 9, 13, 16, 14],\n ],\n // v20\n [\n [861, 28, 3, 107, 5, 108],\n [669, 26, 3, 41, 13, 42],\n [485, 30, 15, 24, 5, 25],\n [385, 28, 15, 15, 10, 16],\n ],\n // v21\n [\n [932, 28, 4, 116, 4, 117],\n [714, 26, 17, 42],\n [512, 28, 17, 22, 6, 23],\n [406, 30, 19, 16, 6, 17],\n ],\n // v22\n [\n [1006, 28, 2, 111, 7, 112],\n [782, 28, 17, 46],\n [568, 30, 7, 24, 16, 25],\n [442, 24, 34, 13],\n ],\n // v23\n [\n [1094, 30, 4, 121, 5, 122],\n [860, 28, 4, 47, 14, 48],\n [614, 30, 11, 24, 14, 25],\n [464, 30, 16, 15, 14, 16],\n ],\n // v24\n [\n [1174, 30, 6, 117, 4, 118],\n [914, 28, 6, 45, 14, 46],\n [664, 30, 11, 24, 16, 25],\n [514, 30, 30, 16, 2, 17],\n ],\n // v25\n [\n [1276, 26, 8, 106, 4, 107],\n [1000, 28, 8, 47, 13, 48],\n [718, 30, 7, 24, 22, 25],\n [538, 30, 22, 15, 13, 16],\n ],\n // v26\n [\n [1370, 28, 10, 114, 2, 115],\n [1062, 28, 19, 46, 4, 47],\n [754, 28, 28, 22, 6, 23],\n [596, 30, 33, 16, 4, 17],\n ],\n // v27\n [\n [1468, 30, 8, 122, 4, 123],\n [1128, 28, 22, 45, 3, 46],\n [808, 30, 8, 23, 26, 24],\n [628, 30, 12, 15, 28, 16],\n ],\n // v28\n [\n [1531, 30, 3, 117, 10, 118],\n [1193, 28, 3, 45, 23, 46],\n [871, 30, 4, 24, 31, 25],\n [661, 30, 11, 15, 31, 16],\n ],\n // v29\n [\n [1631, 30, 7, 116, 7, 117],\n [1267, 28, 21, 45, 7, 46],\n [911, 30, 1, 23, 37, 24],\n [701, 30, 19, 15, 26, 16],\n ],\n // v30\n [\n [1735, 30, 5, 115, 10, 116],\n [1373, 28, 19, 47, 10, 48],\n [985, 30, 15, 24, 25, 25],\n [745, 30, 23, 15, 25, 16],\n ],\n // v31\n [\n [1843, 30, 13, 115, 3, 116],\n [1455, 28, 2, 46, 29, 47],\n [1033, 30, 42, 24, 1, 25],\n [793, 30, 23, 15, 28, 16],\n ],\n // v32\n [\n [1955, 30, 17, 115],\n [1541, 28, 10, 46, 23, 47],\n [1115, 30, 10, 24, 35, 25],\n [845, 30, 19, 15, 35, 16],\n ],\n // v33\n [\n [2071, 30, 17, 115, 1, 116],\n [1631, 28, 14, 46, 21, 47],\n [1171, 30, 29, 24, 19, 25],\n [901, 30, 11, 15, 46, 16],\n ],\n // v34\n [\n [2191, 30, 13, 115, 6, 116],\n [1725, 28, 14, 46, 23, 47],\n [1231, 30, 44, 24, 7, 25],\n [961, 30, 59, 16, 1, 17],\n ],\n // v35\n [\n [2306, 30, 12, 121, 7, 122],\n [1812, 28, 12, 47, 26, 48],\n [1286, 30, 39, 24, 14, 25],\n [986, 30, 22, 15, 41, 16],\n ],\n // v36\n [\n [2434, 30, 6, 121, 14, 122],\n [1914, 28, 6, 47, 34, 48],\n [1354, 30, 46, 24, 10, 25],\n [1054, 30, 2, 15, 64, 16],\n ],\n // v37\n [\n [2566, 30, 17, 122, 4, 123],\n [1992, 28, 29, 46, 14, 47],\n [1426, 30, 49, 24, 10, 25],\n [1096, 30, 24, 15, 46, 16],\n ],\n // v38\n [\n [2702, 30, 4, 122, 18, 123],\n [2102, 28, 13, 46, 32, 47],\n [1502, 30, 48, 24, 14, 25],\n [1142, 30, 42, 15, 32, 16],\n ],\n // v39\n [\n [2812, 30, 20, 117, 4, 118],\n [2216, 28, 40, 47, 7, 48],\n [1582, 30, 43, 24, 22, 25],\n [1222, 30, 10, 15, 67, 16],\n ],\n // v40\n [\n [2956, 30, 19, 118, 6, 119],\n [2334, 28, 18, 47, 31, 48],\n [1666, 30, 34, 24, 34, 25],\n [1276, 30, 20, 15, 61, 16],\n ],\n];\n\n/** Look up the block specification for a (version, ECC) pair. */\nexport function getBlockSpec(version: number, ecc: ErrorCorrectionLevel): BlockSpec {\n const row = ECC_TABLE[version - 1];\n if (!row) throw new RangeError(`Version ${version} out of range (1-40)`);\n const entry = row[ECC_INDEX[ecc]];\n if (!entry) throw new RangeError(`No spec for version ${version} ECC ${ecc}`);\n const dataCodewords = entry[0] ?? 0;\n const ecPerBlock = entry[1] ?? 0;\n const groups: Array = [];\n for (let i = 2; i < entry.length; i += 2) {\n const count = entry[i] ?? 0;\n const dataPerBlock = entry[i + 1] ?? 0;\n groups.push([count, dataPerBlock]);\n }\n return { dataCodewords, ecPerBlock, groups };\n}\n\n/** Total codewords (data + ECC) on the wire for a given version. */\nexport function totalCodewords(version: number, ecc: ErrorCorrectionLevel): number {\n const spec = getBlockSpec(version, ecc);\n let blocks = 0;\n for (const [count] of spec.groups) blocks += count;\n return spec.dataCodewords + blocks * spec.ecPerBlock;\n}\n\n/** Locations of alignment-pattern centres for a given version. */\nexport function alignmentCentres(version: number): readonly number[] {\n if (version === 1) return [];\n const count = Math.floor(version / 7) + 2;\n const dim = moduleCount(version);\n const last = dim - 7;\n const step = version === 32 ? 26 : 2 * Math.ceil((last - 6) / (2 * (count - 1)));\n // Walk backwards from `last` toward 6, prepending each centre until we\n // have `count` entries (the first being the fixed 6 at the top-left\n // finder edge). Returned in ascending order so callers can iterate\n // predictably.\n const centres: number[] = [6];\n for (let pos = last; centres.length < count; pos -= step) {\n centres.unshift(pos);\n }\n return centres.sort((a, b) => a - b);\n}\n","/** Sub-path entry — direct re-export of the QR encoder source. */\nexport * from '../../qr/src/index.js';\n"],"names":["BitBuffer","initialCapacityBits","Uint8Array","Math","value","count","RangeError","i","bit","byteIdx","bitIdx","current","byteCount","neededBits","neededBytes","nextSize","expanded","encodeQR","padToCapacity","bits","dataCodewords","terminator","target","bytes","partial","toggle","buildCodewordBlocks","spec","data","dataBlocks","ecBlocks","offset","perBlock","block","_rs","interleave","maxDataLen","b","maxEcLen","out","pickVersion","text","mode","ecc","min","max","version","needBits","_mode","_version","options","minVersion","maxVersion","_bitbuffer","codewords","finalBytes","padded","REMAINDER_BITS","base","_patterns","_placement","snapshot","bestMask","bestScore","Number","mask","_mask","score","encodeFormatBits","encodeVersionBits","FORMAT_GENERATOR","bch","VERSION_GENERATOR","EXP","LOG","mul","x","a","_encoder","MASK_COUNT","applyMask","scoreMask","MASK_PREDICATES","y","_x","matrix","maskIndex","predicate","penaltyRunLength","total","dim","runColor","runLen","c","penaltyBlocks","penaltyFinderLike","pattern1","pattern2","matches","line","hits","ok1","ok2","j","row","col","penaltyBalance","dark","off","ratio","DARK","FREE","LIGHT","Matrix","RESERVED","rows","Array","MODE_INDICATOR","charCountBits","dataBitLength","detectMode","emitSegment","ALPHANUMERIC_CHARS","ALPHANUMERIC_INDEX","map","Map","DIGITS_RE","ALPHANUM_RE","header","full","remainder","pairs","utf8Length","TextEncoder","code","emitNumeric","triple","emitAlphanumeric","high","low","TypeError","emitByte","encoded","utf8EncodeFallback","buildBaseMatrix","placeFinder","m","originX","originY","dy","dx","onEdge","insideCore","placeAlignment","cx","cy","placeTimingPatterns","placeDarkModule","reserveFormatInfo","reserveVersionInfo","_matrix","onTopLeftFinder","onTopRightFinder","onBottomLeftFinder","placeData","placeFormatInfo","placeVersionInfo","bitIndex","upward","right","v","bitOffset","_formatinfo","encodeBlock","buildGenerator","ecLen","poly","next","alphaI","_gf","coeff","carry","tail","generator","buffer","lead","leadLog","slot","ECC_BITS","alignmentCentres","getBlockSpec","moduleCount","totalCodewords","ECC_INDEX","ECC_TABLE","entry","ecPerBlock","groups","dataPerBlock","blocks","last","step","centres","pos"],"mappings":"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"}