qreator 9.0.6

package/src/errorcode.ts

@@ -0,0 +1,75 @@
+// {{{1 export functions
+export function calculateEC(msg: number[], ec_len: number): Uint8Array {
+    // `msg` could be array or buffer
+    // convert `msg` to array
+    msg = [].slice.call(msg);
+
+    // Generator Polynomial
+    const poly = generatorPolynomial(ec_len);
+
+    for (let i = 0; i < ec_len; i++) msg.push(0);
+    while (msg.length > ec_len) {
+        if (!msg[0]) {
+            msg.shift();
+            continue;
+        }
+        const log_k = log(msg[0]);
+        for (let i = 0; i <= ec_len; i++) {
+            msg[i] = msg[i] ^ exp(poly[i] + log_k);
+        }
+        msg.shift();
+    }
+    return new Uint8Array(msg);
+}
+
+// {{{1 Galois Field Math
+const GF256_BASE = 285;
+
+const EXP_TABLE: number[] = [1];
+const LOG_TABLE: number[] = [];
+
+for (let i = 1; i < 256; i++) {
+    let n = EXP_TABLE[i - 1] << 1;
+    if (n > 255) n ^= GF256_BASE;
+    EXP_TABLE[i] = n;
+}
+
+for (let i = 0; i < 255; i++) {
+    LOG_TABLE[EXP_TABLE[i]] = i;
+}
+
+function exp(k: number) {
+    while (k < 0) k += 255;
+    while (k > 255) k -= 255;
+    return EXP_TABLE[k];
+}
+
+function log(k: number) {
+    if (k < 1 || k > 255) {
+        throw Error(`Bad log(${k})`);
+    }
+    return LOG_TABLE[k];
+}
+
+// {{{1 Generator Polynomials
+const POLYNOMIALS = [
+    [0], // a^0 x^0
+    [0, 0], // a^0 x^1 + a^0 x^0
+    [0, 25, 1], // a^0 x^2 + a^25 x^1 + a^1 x^0
+    // and so on...
+];
+
+function generatorPolynomial(num: number): number[] {
+    if (POLYNOMIALS[num]) {
+        return POLYNOMIALS[num];
+    }
+    const prev = generatorPolynomial(num - 1);
+    const res = [];
+
+    res[0] = prev[0];
+    for (let i = 1; i <= num; i++) {
+        res[i] = log(exp(prev[i]) ^ exp(prev[i - 1] + num - 1));
+    }
+    POLYNOMIALS[num] = res;
+    return res;
+}

package/src/matrix.ts

@@ -0,0 +1,393 @@
+import { Data, EcLevel, Matrix } from "./typing/types";
+
+// {{{1 Initialize matrix with zeros
+export function init(version: number): Matrix {
+    const N = (version << 2) + 0b10001;
+    const matrix: Matrix = [];
+    let zeros: number[] = Array(N).fill(0);
+    for (let i = 0; i < N; i++) {
+        matrix[i] = [...zeros];
+    }
+    return matrix;
+}
+
+// {{{1 Put finders into matrix
+export function fillFinders(matrix: Matrix) {
+    const N = matrix.length;
+    for (var i = -3; i <= 3; i++) {
+        for (let j = -3; j <= 3; j++) {
+            const max = Math.max(i, j);
+            const min = Math.min(i, j);
+            const pixel =
+                (max == 2 && min >= -2) || (min == -2 && max <= 2)
+                    ? 0x80
+                    : 0x81;
+            matrix[3 + i][3 + j] = pixel;
+            matrix[3 + i][N - 4 + j] = pixel;
+            matrix[N - 4 + i][3 + j] = pixel;
+        }
+    }
+    for (var i = 0; i < 8; i++) {
+        matrix[7][i] =
+            matrix[i][7] =
+            matrix[7][N - i - 1] =
+            matrix[i][N - 8] =
+            matrix[N - 8][i] =
+            matrix[N - 1 - i][7] =
+                0x80;
+    }
+}
+
+// {{{1 Put align and timinig
+export function fillAlignAndTiming(matrix: Matrix) {
+    const N = matrix.length;
+    if (N > 21) {
+        const len = N - 13;
+        let delta = Math.round(len / Math.ceil(len / 28));
+        if (delta % 2) delta++;
+        const res = [];
+        for (let p = len + 6; p > 10; p -= delta) {
+            res.unshift(p);
+        }
+        res.unshift(6);
+        for (var i = 0; i < res.length; i++) {
+            for (let j = 0; j < res.length; j++) {
+                const x = res[i];
+                const y = res[j];
+                if (matrix[x][y]) continue;
+                for (let r = -2; r <= 2; r++) {
+                    for (let c = -2; c <= 2; c++) {
+                        const max = Math.max(r, c);
+                        const min = Math.min(r, c);
+                        const pixel =
+                            (max == 1 && min >= -1) || (min == -1 && max <= 1)
+                                ? 0x80
+                                : 0x81;
+                        matrix[x + r][y + c] = pixel;
+                    }
+                }
+            }
+        }
+    }
+    for (var i = 8; i < N - 8; i++) {
+        matrix[6][i] = matrix[i][6] = i % 2 ? 0x80 : 0x81;
+    }
+}
+
+// {{{1 Fill reserved areas with zeroes
+export function fillStub(matrix: Matrix) {
+    const N = matrix.length;
+    for (var i = 0; i < 8; i++) {
+        if (i != 6) {
+            matrix[8][i] = matrix[i][8] = 0x80;
+        }
+        matrix[8][N - 1 - i] = 0x80;
+        matrix[N - 1 - i][8] = 0x80;
+    }
+    matrix[8][8] = 0x80;
+    matrix[N - 8][8] = 0x81;
+
+    if (N < 45) return;
+
+    for (var i = N - 11; i < N - 8; i++) {
+        for (let j = 0; j < 6; j++) {
+            matrix[i][j] = matrix[j][i] = 0x80;
+        }
+    }
+}
+
+// {{{1 Fill reserved areas
+export const fillReserved = (function () {
+    const FORMATS: number[] = Array(32);
+    const VERSIONS: number[] = Array(40);
+
+    const gf15 = 0x0537;
+    const gf18 = 0x1f25;
+    const formats_mask = 0x5412;
+
+    for (let format = 0; format < 32; format++) {
+        let res = format << 10;
+        for (let i = 5; i > 0; i--) {
+            if (res >>> (9 + i)) {
+                res ^= gf15 << (i - 1);
+            }
+        }
+        FORMATS[format] = (res | (format << 10)) ^ formats_mask;
+    }
+
+    for (let version = 7; version <= 40; version++) {
+        let res = version << 12;
+        for (let i = 6; i > 0; i--) {
+            if (res >>> (11 + i)) {
+                res ^= gf18 << (i - 1);
+            }
+        }
+        VERSIONS[version] = res | (version << 12);
+    }
+
+    const EC_LEVELS: { [K in EcLevel]: number } = {
+        L: 1,
+        M: 0,
+        Q: 3,
+        H: 2,
+    };
+
+    return function fillReserved(
+        matrix: Matrix,
+        ec_level: EcLevel,
+        mask: number
+    ) {
+        const N = matrix.length;
+        const format = FORMATS[(EC_LEVELS[ec_level] << 3) | mask];
+
+        function F(k: number) {
+            return (format >> k) & 1 ? 0x81 : 0x80;
+        }
+        for (var i = 0; i < 8; i++) {
+            matrix[8][N - 1 - i] = F(i);
+            if (i < 6) matrix[i][8] = F(i);
+        }
+        for (var i = 8; i < 15; i++) {
+            matrix[N - 15 + i][8] = F(i);
+            if (i > 8) matrix[8][14 - i] = F(i);
+        }
+        matrix[7][8] = F(6);
+        matrix[8][8] = F(7);
+        matrix[8][7] = F(8);
+
+        const version = VERSIONS[(N - 17) / 4];
+        if (!version) {
+            return;
+        }
+
+        function V(k: number) {
+            return (version >> k) & 1 ? 0x81 : 0x80;
+        }
+        for (var i = 0; i < 6; i++) {
+            for (let j = 0; j < 3; j++) {
+                matrix[N - 11 + j][i] = matrix[i][N - 11 + j] = V(i * 3 + j);
+            }
+        }
+    };
+})();
+
+// {{{1 Fill data
+export const fillData = (function () {
+    const MASK_FUNCTIONS = [
+        (i: number, j: number) => (i + j) % 2 == 0,
+        (i: number, j: number) => i % 2 == 0,
+        (i: number, j: number) => j % 3 == 0,
+        (i: number, j: number) => (i + j) % 3 == 0,
+        (i: number, j: number) => (Math.floor(i / 2) + Math.floor(j / 3)) % 2 == 0,
+        (i: number, j: number) => ((i * j) % 2) + ((i * j) % 3) == 0,
+        (i: number, j: number) => (((i * j) % 2) + ((i * j) % 3)) % 2 == 0,
+        (i: number, j: number) => (((i * j) % 3) + ((i + j) % 2)) % 2 == 0,
+    ];
+
+    return function fillData(matrix: Matrix, data: Data, mask: number) {
+        const N = matrix.length;
+        let row: number;
+        let col: number;
+        let dir = -1;
+        row = col = N - 1;
+        const mask_fn = MASK_FUNCTIONS[mask];
+        let len = data.blocks[data.blocks.length - 1].length;
+
+        for (var i = 0; i < len; i++) {
+            for (var b = 0; b < data.blocks.length; b++) {
+                if (data.blocks[b].length <= i) {
+                    continue;
+                }
+                put(data.blocks[b][i]);
+            }
+        }
+
+        len = data.ec_len;
+        for (var i = 0; i < len; i++) {
+            for (var b = 0; b < data.ec.length; b++) {
+                put(data.ec[b][i]);
+            }
+        }
+
+        if (col > -1) {
+            do {
+                matrix[row][col] = mask_fn(row, col) ? 1 : 0;
+            } while (next());
+        }
+
+        function put(byte: number) {
+            for (let mask = 0x80; mask; mask >>= 1) {
+                let pixel = !!(mask & byte);
+                if (mask_fn(row, col)) pixel = !pixel;
+                matrix[row][col] = pixel ? 1 : 0;
+                next();
+            }
+        }
+
+        function next() {
+            do {
+                if (col % 2 ^ Number(col < 6)) {
+                    if ((dir < 0 && row == 0) || (dir > 0 && row == N - 1)) {
+                        col--;
+                        dir = -dir;
+                    } else {
+                        col++;
+                        row += dir;
+                    }
+                } else {
+                    col--;
+                }
+                if (col == 6) {
+                    col--;
+                }
+                if (col < 0) {
+                    return false;
+                }
+            } while (matrix[row][col] & 0xf0);
+            return true;
+        }
+    };
+})();
+
+// {{{1 Calculate penalty
+export function calculatePenalty(matrix: Matrix) {
+    const N = matrix.length;
+    let penalty = 0;
+    // Rule 1
+    for (var i = 0; i < N; i++) {
+        var pixel = matrix[i][0] & 1;
+        var len = 1;
+        for (var j = 1; j < N; j++) {
+            var p = matrix[i][j] & 1;
+            if (p == pixel) {
+                len++;
+                continue;
+            }
+            if (len >= 5) {
+                penalty += len - 2;
+            }
+            pixel = p;
+            len = 1;
+        }
+        if (len >= 5) {
+            penalty += len - 2;
+        }
+    }
+    for (var j = 0; j < N; j++) {
+        var pixel = matrix[0][j] & 1;
+        var len = 1;
+        for (var i = 1; i < N; i++) {
+            var p = matrix[i][j] & 1;
+            if (p == pixel) {
+                len++;
+                continue;
+            }
+            if (len >= 5) {
+                penalty += len - 2;
+            }
+            pixel = p;
+            len = 1;
+        }
+        if (len >= 5) {
+            penalty += len - 2;
+        }
+    }
+
+    // Rule 2
+    for (var i = 0; i < N - 1; i++) {
+        for (var j = 0; j < N - 1; j++) {
+            const s =
+                (matrix[i][j] +
+                    matrix[i][j + 1] +
+                    matrix[i + 1][j] +
+                    matrix[i + 1][j + 1]) &
+                7;
+            if (s == 0 || s == 4) {
+                penalty += 3;
+            }
+        }
+    }
+
+    // Rule 3
+    function I(k: number) {
+        return matrix[i][j + k] & 1;
+    }
+    function J(k: number) {
+        return matrix[i + k][j] & 1;
+    }
+    for (var i = 0; i < N; i++) {
+        for (var j = 0; j < N; j++) {
+            if (
+                j < N - 6 &&
+                I(0) &&
+                !I(1) &&
+                I(2) &&
+                I(3) &&
+                I(4) &&
+                !I(5) &&
+                I(6)
+            ) {
+                if (j >= 4 && !(I(-4) || I(-3) || I(-2) || I(-1))) {
+                    penalty += 40;
+                }
+                if (j < N - 10 && !(I(7) || I(8) || I(9) || I(10))) {
+                    penalty += 40;
+                }
+            }
+
+            if (
+                i < N - 6 &&
+                J(0) &&
+                !J(1) &&
+                J(2) &&
+                J(3) &&
+                J(4) &&
+                !J(5) &&
+                J(6)
+            ) {
+                if (i >= 4 && !(J(-4) || J(-3) || J(-2) || J(-1))) {
+                    penalty += 40;
+                }
+                if (i < N - 10 && !(J(7) || J(8) || J(9) || J(10))) {
+                    penalty += 40;
+                }
+            }
+        }
+    }
+
+    // Rule 4
+    let numDark = 0;
+    for (var i = 0; i < N; i++) {
+        for (var j = 0; j < N; j++) {
+            if (matrix[i][j] & 1) numDark++;
+        }
+    }
+    penalty += 10 * Math.floor(Math.abs(10 - (20 * numDark) / (N * N)));
+
+    return penalty;
+}
+
+// {{{1 All-in-one function
+export function getMatrix(data: Data) {
+    const matrix = init(data.version);
+    fillFinders(matrix);
+    fillAlignAndTiming(matrix);
+    fillStub(matrix);
+
+    let penalty = Infinity;
+    let bestMask = 0;
+    for (let mask = 0; mask < 8; mask++) {
+        fillData(matrix, data, mask);
+        fillReserved(matrix, data.ec_level, mask);
+        const p = calculatePenalty(matrix);
+        if (p < penalty) {
+            penalty = p;
+            bestMask = mask;
+        }
+    }
+
+    fillData(matrix, data, bestMask);
+    fillReserved(matrix, data.ec_level, bestMask);
+
+    return matrix.map((row) => row.map((cell) => cell & 1));
+}

package/src/pdf.ts

@@ -0,0 +1,80 @@
+import { PDFDocument, PDFImage, rgb } from "pdf-lib";
+import { QR } from "./qr-base.js";
+import { ImageOptions, Matrix } from "./typing/types";
+import { getOptions, getSVGPath } from "./utils.js";
+import colorString from "color-string";
+
+const textDec = new TextDecoder();
+
+export async function getPDF(text: string, inOptions: ImageOptions) {
+    const options = getOptions(inOptions);
+    const matrix = QR(text, options.ec_level, options.parse_url);
+    return PDF({ matrix, ...options });
+}
+
+function colorToRGB(color: string | number): [number, number, number] {
+    if (typeof color === "string") {
+        const [red, green, blue] = colorString.get.rgb(color);
+        return [red / 255, green / 255, blue / 255];
+    }
+    return [
+        ((color >>> 24) % 256) / 255,
+        ((color >>> 16) % 256) / 255,
+        ((color >>> 8) % 256) / 255,
+    ];
+}
+
+function getOpacity(color: string | number): number {
+    if (typeof color === "string") {
+        return colorString.get.rgb(color)[3];
+    }
+    return ((color % 256) / 255);
+}
+
+async function PDF({
+    matrix,
+    margin,
+    logo,
+    logoWidth,
+    logoHeight,
+    color,
+    bgColor,
+    borderRadius,
+}: ImageOptions & {
+    matrix: Matrix;
+}) {
+    const size = 9;
+    const document = await PDFDocument.create();
+    const pageSize = (matrix.length + 2 * margin) * size;
+    const page = document.addPage([pageSize, pageSize]);
+    page.drawSquare({
+        size: pageSize,
+        color: rgb(...colorToRGB(bgColor)),
+    });
+    page.moveTo(0, page.getHeight());
+    const path = getSVGPath(matrix, size, margin * size, borderRadius);
+    page.drawSvgPath(path, {
+        color: rgb(...colorToRGB(color)),
+        opacity: getOpacity(color),
+        borderColor: rgb(...colorToRGB(color)),
+        borderOpacity: getOpacity(color),
+    });
+    if (logo) {
+        let logoData: PDFImage;
+        const header = new Uint8Array(logo.slice(0, 4));
+        if (textDec.decode(header.slice(1, 4)) === "PNG" && header.at(0) === 0x89) {
+            logoData = await document.embedPng(logo);
+        } else {
+            logoData = await document.embedJpg(logo);
+        }
+        page.drawImage(logoData, {
+            x: page.getWidth() / 2 - (logoWidth / 100) * (page.getWidth() / 2),
+            y:
+                page.getHeight() / 2 -
+                (logoHeight / 100) * (page.getWidth() / 2),
+            width: (logoWidth / 100) * page.getWidth(),
+            height: (logoHeight / 100) * page.getHeight(),
+        });
+    }
+    return document.save();
+}

package/src/png.ts

@@ -0,0 +1,42 @@
+import { ImageOptions, Matrix } from "./typing/types";
+import { QR } from "./qr-base.js";
+import { createSVG } from './svg.js';
+import { getOptions } from "./utils.js";
+import sharp from "sharp";
+
+export async function getPNG(text: string, inOptions: ImageOptions = {}) {
+    const options = getOptions({...inOptions, type: 'png'});
+    const matrix = QR(text, options.ec_level, options.parse_url);
+    return generateImage({ matrix, ...options, type: 'png' });
+}
+
+export async function generateImage({
+    matrix,
+    size,
+    margin,
+    logo,
+    logoWidth,
+    logoHeight,
+    color,
+    bgColor,
+    borderRadius,
+}: ImageOptions & { matrix: Matrix }) {
+    const marginPx = margin * size;
+    const imageSize = matrix.length * size + marginPx * 2;
+    const svg = await createSVG({
+        matrix, size, margin, color, bgColor,
+        imageWidth: imageSize, imageHeight: imageSize,
+        borderRadius,
+    });
+    const qrImage = sharp(svg);
+    const layers: sharp.OverlayOptions[] = [];
+    if (logo) {
+        const sharpLogo = sharp(logo).resize(imageSize * logoWidth / 100, imageSize * logoHeight / 100, {fit: 'contain'});
+        const data = await sharpLogo.toBuffer()
+        layers.push({
+            input: data,
+        })
+        qrImage.composite(layers);
+    }
+    return await qrImage.png().toBuffer();
+}

package/src/png_browser.ts

@@ -0,0 +1,73 @@
+import { QR } from "./qr-base.js";
+import { getOptions, colorToHex, getSVGPath } from "./utils.js";
+import { ImageOptions, Matrix } from "./typing/types";
+import { Base64 } from "js-base64";
+
+export async function getPNG(text: string, inOptions: ImageOptions) {
+    const options = getOptions(inOptions);
+    const matrix = QR(text, options.ec_level, options.parse_url);
+    return generateImage({ matrix, ...options, type: 'png' });
+}
+
+function dataURItoArrayBuffer(dataURI: string) {
+  return Base64.toUint8Array(dataURI.split(',')[1]);
+}
+
+function blobToDataURL(blob: Blob) {
+    return new Promise<string>((resolve, reject) => {
+        try {
+            var a = new FileReader();
+            a.onload = function(e) {resolve(e.target.result as string);}
+            a.onerror = reject;
+            a.readAsDataURL(blob);
+        } catch (e) {
+            reject(e);
+        }
+    });
+}
+
+
+export async function generateImage({
+    matrix,
+    size,
+    margin,
+    logo,
+    logoWidth,
+    logoHeight,
+    color,
+    bgColor,
+    borderRadius,
+}: ImageOptions & { matrix: Matrix }) {
+    const marginPx = margin * size;
+    const imageSize = matrix.length * size + marginPx * 2;
+
+    const canvas = document.createElement('canvas');
+    canvas.width = imageSize;
+    canvas.height = imageSize;
+    const context = canvas.getContext('2d');
+    context.fillStyle = colorToHex(bgColor);
+    context.fillRect(0, 0, imageSize, imageSize);
+    const path = new Path2D(getSVGPath(matrix, size, marginPx, borderRadius));
+    context.fillStyle = colorToHex(color);
+    context.fill(path);
+    if (logo) {
+        const logoImage = await new Promise<HTMLImageElement>(async (resolve, reject) => {
+            try {
+                const image = new Image();
+                image.onload = () => resolve(image);
+                image.onerror = reject;
+                image.src = await blobToDataURL(new window.Blob([logo]));
+            } catch (e) {
+                reject(e);
+            }
+        });
+        context.drawImage(
+            logoImage,
+            imageSize / 2 - (logoWidth / 2 / 100) * imageSize,
+            imageSize / 2 - (logoHeight / 2 / 100) * imageSize,
+            (logoWidth / 100) * imageSize,
+            (logoHeight / 100) * imageSize
+        );
+    }
+    return dataURItoArrayBuffer(canvas.toDataURL('image/png'));
+}