qr-core 1.0.0

package/dist/src/mask/selection.js

@@ -0,0 +1,178 @@
+import { Matrix } from "../matrix/bit-matrix.js";
+import { getFormatInfo } from "../spec/bch.js";
+import { calculatePenalty } from "./penalty.js";
+/**
+ * Evaluates all 8 masks and applies the one with the lowest penalty.
+ * Implements the deterministic tie-break (lowest ID).
+ */
+export function selectAndApplyBestMask(matrix, ecc) {
+    let minPenalty = Infinity;
+    let bestMask = 0;
+    const penalties = [];
+    // Pre-allocate work matrix to avoid garbage
+    const workMatrix = new Matrix(matrix.size);
+    for (let id = 0; id < 8; id++) {
+        const maskId = id;
+        // Reset work matrix
+        workMatrix._data.set(matrix._data);
+        const currentPenalty = evaluateMask(workMatrix, ecc, maskId);
+        penalties.push(currentPenalty);
+        if (currentPenalty < minPenalty) {
+            minPenalty = currentPenalty;
+            bestMask = maskId;
+        }
+    }
+    // Final apply of the winner
+    applyMask(matrix, bestMask);
+    writeFormatInformation(matrix, ecc, bestMask);
+    return { mask: bestMask, penalties };
+}
+function evaluateMask(workMatrix, ecc, maskId) {
+    // workMatrix is already a copy/reset
+    applyMask(workMatrix, maskId);
+    writeFormatInformation(workMatrix, ecc, maskId);
+    return calculatePenalty(workMatrix);
+}
+export function applyMask(matrix, maskId) {
+    const size = matrix.size;
+    const data = matrix._data; // Direct access
+    switch (maskId) {
+        case 0:
+            for (let y = 0; y < size; y++) {
+                for (let x = 0; x < size; x++) {
+                    const idx = y * size + x;
+                    const val = data[idx] ?? 0;
+                    if (!(val & 2)) {
+                        if (((x + y) & 1) === 0)
+                            data[idx] = val ^ 1;
+                    }
+                }
+            }
+            break;
+        case 1:
+            for (let y = 0; y < size; y++) {
+                for (let x = 0; x < size; x++) {
+                    const idx = y * size + x;
+                    const val = data[idx] ?? 0;
+                    if (!(val & 2)) {
+                        if ((y & 1) === 0)
+                            data[idx] = val ^ 1;
+                    }
+                }
+            }
+            break;
+        case 2:
+            for (let y = 0; y < size; y++) {
+                for (let x = 0; x < size; x++) {
+                    const idx = y * size + x;
+                    const val = data[idx] ?? 0;
+                    if (!(val & 2)) {
+                        if (x % 3 === 0)
+                            data[idx] = val ^ 1;
+                    }
+                }
+            }
+            break;
+        case 3:
+            for (let y = 0; y < size; y++) {
+                for (let x = 0; x < size; x++) {
+                    const idx = y * size + x;
+                    const val = data[idx] ?? 0;
+                    if (!(val & 2)) {
+                        if ((x + y) % 3 === 0)
+                            data[idx] = val ^ 1;
+                    }
+                }
+            }
+            break;
+        case 4:
+            for (let y = 0; y < size; y++) {
+                for (let x = 0; x < size; x++) {
+                    const idx = y * size + x;
+                    const val = data[idx] ?? 0;
+                    if (!(val & 2)) {
+                        if ((((y >>> 1) + ((x / 3) | 0)) & 1) === 0)
+                            data[idx] = val ^ 1;
+                    }
+                }
+            }
+            break;
+        case 5:
+            for (let y = 0; y < size; y++) {
+                for (let x = 0; x < size; x++) {
+                    const idx = y * size + x;
+                    const val = data[idx] ?? 0;
+                    if (!(val & 2)) {
+                        const temp = x * y;
+                        if ((temp & 1) + (temp % 3) === 0)
+                            data[idx] = val ^ 1;
+                    }
+                }
+            }
+            break;
+        case 6:
+            for (let y = 0; y < size; y++) {
+                for (let x = 0; x < size; x++) {
+                    const idx = y * size + x;
+                    const val = data[idx] ?? 0;
+                    if (!(val & 2)) {
+                        const temp = x * y;
+                        if ((((temp & 1) + (temp % 3)) & 1) === 0)
+                            data[idx] = val ^ 1;
+                    }
+                }
+            }
+            break;
+        case 7:
+            for (let y = 0; y < size; y++) {
+                for (let x = 0; x < size; x++) {
+                    const idx = y * size + x;
+                    const val = data[idx] ?? 0;
+                    if (!(val & 2)) {
+                        if (((((x + y) & 1) + ((x * y) % 3)) & 1) === 0)
+                            data[idx] = val ^ 1;
+                    }
+                }
+            }
+            break;
+    }
+}
+export function writeFormatInformation(matrix, ecc, maskId) {
+    const formatBits = getFormatInfo(ecc, maskId);
+    const size = matrix.size;
+    for (let i = 0; i < 15; i++) {
+        const bit = (formatBits >>> i) & 1;
+        // Top-left
+        let x;
+        let y;
+        if (i < 6) {
+            x = i;
+            y = 8;
+        }
+        else if (i < 8) {
+            x = i + 1;
+            y = 8;
+        }
+        else if (i === 8) {
+            x = 8;
+            y = 7;
+        }
+        else {
+            x = 8;
+            y = 14 - i;
+        }
+        matrix.setReserved(x, y, bit === 1);
+        // Split area
+        let x2;
+        let y2;
+        if (i < 8) {
+            x2 = 8;
+            y2 = size - 1 - i;
+        }
+        else {
+            x2 = size - 15 + i;
+            y2 = 8;
+        }
+        matrix.setReserved(x2, y2, bit === 1);
+    }
+}

package/dist/src/matrix/bit-matrix.d.ts

@@ -0,0 +1,46 @@
+/**
+ * QR Matris Yönetimi
+ */
+import type { BitMatrix } from "../types/index.js";
+export declare class Matrix implements BitMatrix {
+    readonly size: number;
+    private data;
+    constructor(size: number);
+    /**
+     * Internal access to raw data for performance-critical operations (e.g. penalty calculation).
+     */
+    get _data(): Uint8Array;
+    /**
+     * Hücrenin değerini döndürür (Sadece 0 veya 1)
+     */
+    get(x: number, y: number): 0 | 1;
+    /**
+     * Hücrenin "Reserved" (ayrılmış) olup olmadığını kontrol eder
+     */
+    isReserved(x: number, y: number): boolean;
+    /**
+     * Hücreyi ayarlar ve rezerve eder (Fonksiyonel desenler için)
+     */
+    setReserved(x: number, y: number, isDark: boolean): void;
+    /**
+     * Sadece veri modülleri için (Ayrılmamış alanlara yazar)
+     */
+    set(x: number, y: number, isDark: boolean): void;
+    /**
+     * RFC 5.2: Matrisi satırlar halinde döndürür
+     */
+    toRows(): ReadonlyArray<Uint8Array>;
+    /**
+     * RFC 5.2: Matrisi paketlenmiş (MSB-first) bayt dizisi olarak döndürür
+     */
+    toPacked(): Uint8Array;
+    clone(): Matrix;
+}
+export declare class ReadOnlyMatrix implements BitMatrix {
+    readonly size: number;
+    private readonly inner;
+    constructor(matrix: Matrix);
+    get(x: number, y: number): 0 | 1;
+    toRows(): ReadonlyArray<Uint8Array>;
+    toPacked(): Uint8Array;
+}

package/dist/src/matrix/bit-matrix.js

@@ -0,0 +1,139 @@
+/**
+ * QR Matris Yönetimi
+ */
+/**
+ * Matris hücre durumları (Dahili kullanım)
+ */
+const STATUS = {
+    LIGHT: 0,
+    DARK: 1,
+    RESERVED_LIGHT: 2,
+    RESERVED_DARK: 3,
+};
+export class Matrix {
+    size;
+    data;
+    constructor(size) {
+        this.size = size;
+        // Varsayılan olarak tüm hücreler "light" (0)
+        this.data = new Uint8Array(size * size);
+    }
+    /**
+     * Internal access to raw data for performance-critical operations (e.g. penalty calculation).
+     */
+    get _data() {
+        return this.data;
+    }
+    /**
+     * Hücrenin değerini döndürür (Sadece 0 veya 1)
+     */
+    get(x, y) {
+        if (x < 0 || x >= this.size || y < 0 || y >= this.size) {
+            throw new Error(`Matrix access out of bounds: (${x},${y})`);
+        }
+        const idx = y * this.size + x;
+        const val = this.data[idx];
+        if (val === undefined) {
+            // Should be bounds checked or checked at call site, but defensive coding here:
+            throw new Error(`Matrix access out of bounds: (${x},${y})`);
+        }
+        return (val & 1);
+    }
+    /**
+     * Hücrenin "Reserved" (ayrılmış) olup olmadığını kontrol eder
+     */
+    isReserved(x, y) {
+        if (x < 0 || x >= this.size || y < 0 || y >= this.size) {
+            throw new Error(`Matrix access out of bounds: (${x},${y})`);
+        }
+        const idx = y * this.size + x;
+        const val = this.data[idx];
+        if (val === undefined) {
+            throw new Error(`Matrix access out of bounds: (${x},${y})`);
+        }
+        return (val & 2) !== 0;
+    }
+    /**
+     * Hücreyi ayarlar ve rezerve eder (Fonksiyonel desenler için)
+     */
+    setReserved(x, y, isDark) {
+        if (x < 0 || x >= this.size || y < 0 || y >= this.size) {
+            throw new Error(`Matrix access out of bounds: (${x},${y})`);
+        }
+        const idx = y * this.size + x;
+        if (idx < 0 || idx >= this.data.length) {
+            throw new Error(`Matrix access out of bounds: (${x},${y})`);
+        }
+        this.data[idx] = isDark ? STATUS.RESERVED_DARK : STATUS.RESERVED_LIGHT;
+    }
+    /**
+     * Sadece veri modülleri için (Ayrılmamış alanlara yazar)
+     */
+    set(x, y, isDark) {
+        if (x < 0 || x >= this.size || y < 0 || y >= this.size) {
+            throw new Error(`Matrix access out of bounds: (${x},${y})`);
+        }
+        if (this.isReserved(x, y))
+            return;
+        const idx = y * this.size + x;
+        if (idx < 0 || idx >= this.data.length) {
+            // Double safety
+            throw new Error(`Matrix access out of bounds: (${x},${y})`);
+        }
+        this.data[idx] = isDark ? STATUS.DARK : STATUS.LIGHT;
+    }
+    /**
+     * RFC 5.2: Matrisi satırlar halinde döndürür
+     */
+    toRows() {
+        const rows = [];
+        for (let y = 0; y < this.size; y++) {
+            rows.push(this.data
+                .slice(y * this.size, (y + 1) * this.size)
+                .map((v) => (v & 1)));
+        }
+        return rows;
+    }
+    /**
+     * RFC 5.2: Matrisi paketlenmiş (MSB-first) bayt dizisi olarak döndürür
+     */
+    toPacked() {
+        const rowBytes = Math.ceil(this.size / 8);
+        const packed = new Uint8Array(rowBytes * this.size);
+        for (let y = 0; y < this.size; y++) {
+            for (let x = 0; x < this.size; x++) {
+                if (this.get(x, y)) {
+                    const idx = y * rowBytes + (x >>> 3);
+                    const current = packed[idx];
+                    // safe access or initialized 0
+                    if (current !== undefined) {
+                        packed[idx] = current | (0x80 >>> (x & 7));
+                    }
+                }
+            }
+        }
+        return packed;
+    }
+    clone() {
+        const copy = new Matrix(this.size);
+        copy.data.set(this.data);
+        return copy;
+    }
+}
+export class ReadOnlyMatrix {
+    size;
+    inner;
+    constructor(matrix) {
+        this.inner = matrix;
+        this.size = matrix.size;
+    }
+    get(x, y) {
+        return this.inner.get(x, y);
+    }
+    toRows() {
+        return this.inner.toRows();
+    }
+    toPacked() {
+        return this.inner.toPacked();
+    }
+}

package/dist/src/spec/bch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * BCH (Bose-Chaudhuri-Hocquenghem) Error Correction for QR Metadata
+ */
+/**
+ * Format Info BCH (15, 5)
+ */
+export declare function getFormatInfo(eccLevel: "L" | "M" | "Q" | "H", mask: number): number;
+/**
+ * Version Info BCH (18, 6)
+ */
+export declare function getVersionInfo(version: number): number;

package/dist/src/spec/bch.js

@@ -0,0 +1,30 @@
+/**
+ * BCH (Bose-Chaudhuri-Hocquenghem) Error Correction for QR Metadata
+ */
+/**
+ * Format Info BCH (15, 5)
+ */
+export function getFormatInfo(eccLevel, mask) {
+    const eccBits = { L: 1, M: 0, Q: 3, H: 2 };
+    const bits = eccBits[eccLevel];
+    if (bits === undefined)
+        throw new Error(`Invalid ecc level: ${eccLevel}`);
+    const data = (bits << 3) | mask;
+    let rem = data;
+    for (let i = 0; i < 10; i++) {
+        rem = (rem << 1) ^ (rem >>> 9 ? 0x537 : 0);
+    }
+    return ((data << 10) | rem) ^ 0x5412;
+}
+/**
+ * Version Info BCH (18, 6)
+ */
+export function getVersionInfo(version) {
+    if (version < 7)
+        return 0;
+    let rem = version;
+    for (let i = 0; i < 12; i++) {
+        rem = (rem << 1) ^ (rem >>> 11 ? 0x1f25 : 0);
+    }
+    return (version << 12) | rem;
+}

package/dist/src/spec/constants.d.ts

@@ -0,0 +1,40 @@
+import type { QrMode } from "../types/index.js";
+/**
+ * QR Code constants and lookup tables
+ */
+export declare const MIN_VERSION = 1;
+export declare const MAX_VERSION = 40;
+/**
+ * Mode indicators (4-bit values)
+ */
+export declare const MODE_INDICATOR: Record<Exclude<QrMode, "auto">, number>;
+/**
+ * Bit lengths for Character Count Indicator based on version groups
+ * Groups: 1-9, 10-26, 27-40
+ */
+export declare const CHAR_COUNT_INDICATOR_BITS: Record<Exclude<QrMode, "auto">, [
+    number,
+    number,
+    number
+]>;
+/**
+ * Version group index for Character Count Indicator
+ */
+export declare function getVersionGroupIndex(version: number): 0 | 1 | 2;
+/**
+ * Alphanumeric character set mapping
+ */
+export declare const ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+/**
+ * ECC Codeword tables, Alignment pattern positions, etc. will go here or in sub-files.
+ * For now, defining the structure for capacity lookup.
+ */
+export interface EccBlockConfig {
+    totalCodewords: number;
+    dataCodewords: number;
+    eccCodewordsPerBlock: number;
+    blocksGroup1: number;
+    dataPerBlockGroup1: number;
+    blocksGroup2: number;
+    dataPerBlockGroup2: number;
+}

package/dist/src/spec/constants.js

@@ -0,0 +1,37 @@
+/**
+ * QR Code constants and lookup tables
+ */
+export const MIN_VERSION = 1;
+export const MAX_VERSION = 40;
+/**
+ * Mode indicators (4-bit values)
+ */
+export const MODE_INDICATOR = {
+    numeric: 0b0001,
+    alphanumeric: 0b0010,
+    byte: 0b0100,
+};
+/**
+ * Bit lengths for Character Count Indicator based on version groups
+ * Groups: 1-9, 10-26, 27-40
+ */
+export const CHAR_COUNT_INDICATOR_BITS = {
+    numeric: [10, 12, 14],
+    alphanumeric: [9, 11, 13],
+    byte: [8, 16, 16],
+};
+/**
+ * Version group index for Character Count Indicator
+ */
+export function getVersionGroupIndex(version) {
+    if (version <= 9)
+        return 0;
+    if (version <= 26)
+        return 1;
+    return 2;
+}
+/**
+ * Alphanumeric character set mapping
+ */
+export const ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+// These tables are large and will be populated in src/spec/tables.ts

package/dist/src/spec/tables.d.ts

@@ -0,0 +1,20 @@
+import type { EccLevel } from "../types/index.js";
+/**
+ * Alignment pattern center coordinates for each version (1-40)
+ */
+export declare const ALIGNMENT_PATTERN_POSITIONS: number[][];
+export interface EccBlockInfo {
+    numBlocks: number;
+    dataCodewords: number;
+}
+export interface VersionInfo {
+    totalCodewords: number;
+    eccPerBlock: number;
+    group1: EccBlockInfo;
+    group2: EccBlockInfo;
+}
+/**
+ * ECC capacity table for V1 and V2.
+ */
+export declare const ECC_TABLE: Record<number, Record<EccLevel, VersionInfo>>;
+export declare function getDataCapacity(version: number, ecc: EccLevel): number;