213 lines
7.3 KiB
JavaScript
213 lines
7.3 KiB
JavaScript
// Real QR code generator using pure JavaScript (QR code algorithm)
|
|
const fs = require('fs');
|
|
|
|
// QR Code Generator - Minimal implementation
|
|
// Based on QR Code standard (ISO/IEC 18004)
|
|
|
|
const EC_LEVEL = 1; // L = 1, M = 0, Q = 3, H = 2
|
|
|
|
// Generator polynomials for Reed-Solomon
|
|
const GEN_POLYNOMIALS = {
|
|
7: [87, 229, 146, 149, 238, 102, 21],
|
|
10: [66, 83, 10, 220, 108, 180, 110, 36, 221, 40],
|
|
13: [120, 104, 107, 109, 102, 161, 76, 3, 37, 40, 213, 199, 162, 12],
|
|
15: [104, 70, 127, 54, 67, 81, 61, 97, 197, 192, 6, 151, 77, 56, 217],
|
|
16: [120, 112, 45, 6, 236, 124, 228, 185, 66, 39, 52, 228, 198, 180, 50, 28],
|
|
17: [136, 92, 228, 226, 220, 222, 224, 140, 120, 40, 54, 179, 176, 163, 22, 237, 79],
|
|
18: [94, 50, 103, 89, 81, 196, 21, 1, 4, 69, 120, 104, 62, 220, 80, 54, 82, 119],
|
|
20: [152, 185, 240, 5, 111, 99, 6, 220, 112, 150, 69, 36, 187, 22, 228, 198, 100, 101, 68, 205],
|
|
22: [89, 179, 131, 176, 182, 244, 19, 189, 69, 40, 194, 232, 93, 149, 147, 92, 239, 242, 63, 130, 194, 120],
|
|
24: [122, 118, 169, 70, 178, 237, 216, 85, 230, 105, 165, 42, 229, 175, 68, 255, 212, 251, 245, 198, 221, 180, 52, 99],
|
|
26: [246, 51, 50, 103, 174, 74, 65, 238, 185, 192, 249, 52, 220, 86, 65, 231, 47, 163, 248, 19, 50, 126, 194, 190, 12, 192],
|
|
28: [252, 85, 144, 50, 104, 230, 24, 201, 84, 37, 172, 58, 150, 33, 24, 147, 149, 206, 77, 220, 101, 225, 40, 198, 77, 56],
|
|
30: [212, 246, 77, 173, 80, 158, 98, 139, 52, 135, 214, 207, 229, 116, 253, 121, 195, 242, 237, 88, 14, 109, 221, 53, 200, 74, 8, 172, 98, 80],
|
|
};
|
|
|
|
// Galois Field arithmetic for Reed-Solomon
|
|
const GF_EXP = new Array(512);
|
|
const GF_LOG = new Array(256);
|
|
(function initGF() {
|
|
let x = 1;
|
|
for (let i = 0; i < 255; i++) {
|
|
GF_EXP[i] = x;
|
|
GF_LOG[x] = i;
|
|
x <<= 1;
|
|
if (x & 0x100) x ^= 0x11d; // primitive polynomial
|
|
}
|
|
for (let i = 255; i < 512; i++) GF_EXP[i] = GF_EXP[i - 255];
|
|
})();
|
|
|
|
function gfMul(a, b) {
|
|
if (a === 0 || b === 0) return 0;
|
|
return GF_EXP[GF_LOG[a] + GF_LOG[b]];
|
|
}
|
|
|
|
function rsEncode(data, eccLen) {
|
|
const gen = GEN_POLYNOMIALS[eccLen];
|
|
if (!gen) return new Array(eccLen).fill(0);
|
|
const result = new Array(eccLen).fill(0);
|
|
for (let i = 0; i < data.length; i++) {
|
|
const coef = data[i] ^ result[0];
|
|
result.shift();
|
|
result.push(0);
|
|
if (coef !== 0) {
|
|
for (let j = 0; j < eccLen; j++) {
|
|
result[j] ^= gfMul(gen[j], coef);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Version 2 QR Code (25x25 modules, 4+4=8 data bytes for Version 1-L, 16+7=23 total)
|
|
function generateQRData(text) {
|
|
// Use Version 1-L: 21x21 modules, 19 data bytes + 7 ECC = 26 codewords total
|
|
const dataBytes = [];
|
|
|
|
// Mode indicator for byte mode: 0100
|
|
dataBytes.push(0x40 | (text.length >> 4));
|
|
dataBytes.push((text.length << 4) | 0x00); // character count (9 bits)
|
|
|
|
// Character data
|
|
for (let i = 0; i < text.length; i++) {
|
|
dataBytes.push(text.charCodeAt(i));
|
|
}
|
|
|
|
// Terminator (0000)
|
|
dataBytes.push(0x00);
|
|
while (dataBytes.length < 19) dataBytes.push(0x00);
|
|
|
|
// Split into data and ECC
|
|
const data = dataBytes.slice(0, 19);
|
|
const ecc = rsEncode(data, 7);
|
|
|
|
return [...data, ...ecc]; // 26 codewords total
|
|
}
|
|
|
|
function createQRMatrix(text) {
|
|
const size = 21; // Version 1 QR code = 21x21 modules
|
|
const matrix = Array.from({ length: size }, () => Array(size).fill(null));
|
|
const reserved = Array.from({ length: size }, () => Array(size).fill(false));
|
|
|
|
// Finder patterns (3 corners)
|
|
function addFinderPattern(row, col) {
|
|
for (let r = -3; r <= 3; r++) {
|
|
for (let c = -3; c <= 3; c++) {
|
|
const rr = row + r, cc = col + c;
|
|
if (rr < 0 || rr >= size || cc < 0 || cc >= size) continue;
|
|
const isEdge = Math.abs(r) === 3 || Math.abs(c) === 3;
|
|
const isInner = Math.abs(r) <= 1 && Math.abs(c) <= 1;
|
|
const val = isEdge ? 1 : (isInner ? 0 : (r === 0 && c === 0 ? 1 : 0));
|
|
matrix[rr][cc] = val;
|
|
reserved[rr][cc] = true;
|
|
}
|
|
}
|
|
}
|
|
addFinderPattern(3, 3);
|
|
addFinderPattern(3, size - 4);
|
|
addFinderPattern(size - 4, 3);
|
|
|
|
// Timing patterns
|
|
for (let i = 8; i < size - 8; i++) {
|
|
if (matrix[6][i] === null) {
|
|
matrix[6][i] = (i % 2 === 0) ? 1 : 0;
|
|
reserved[6][i] = true;
|
|
}
|
|
if (matrix[i][6] === null) {
|
|
matrix[i][6] = (i % 2 === 0) ? 1 : 0;
|
|
reserved[i][6] = true;
|
|
}
|
|
}
|
|
|
|
// Alignment pattern for Version 1 (just center)
|
|
const ctr = Math.floor(size / 2);
|
|
for (let r = -2; r <= 2; r++) {
|
|
for (let c = -2; c <= 2; c++) {
|
|
const rr = ctr + r, cc = ctr + c;
|
|
if (rr < 0 || rr >= size || cc < 0 || cc >= size) continue;
|
|
if (matrix[rr][cc] !== null) continue;
|
|
const isEdge = Math.abs(r) === 2 || Math.abs(c) === 2;
|
|
const isInner = Math.abs(r) <= 1 && Math.abs(c) <= 1;
|
|
matrix[rr][cc] = isEdge ? 1 : (isInner ? 0 : 1);
|
|
reserved[rr][cc] = true;
|
|
}
|
|
}
|
|
|
|
// Format info around finder patterns
|
|
// For simplicity, use fixed format pattern
|
|
const formatBits = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0]; // mask 0, L level
|
|
|
|
// Version info (for Version 1, none needed)
|
|
|
|
// Encode data in the remaining areas
|
|
const dataBits = generateQRData(text);
|
|
let bitIdx = 0;
|
|
let byteIdx = 0;
|
|
let dataVal = dataBits[0];
|
|
let bitsLeft = 8;
|
|
|
|
// Fill remaining modules column-by-column, boustrophedon style
|
|
const directions = [
|
|
{ dr: 1, dc: 1, cStart: size - 2, cEnd: 0, colFirst: true },
|
|
{ dr: -1, dc: 1, cStart: size - 2, cEnd: 0, colFirst: false },
|
|
{ dr: -1, dc: 1, cStart: size - 2, cEnd: 0, colFirst: true },
|
|
{ dr: 1, dc: 1, cStart: size - 2, cEnd: 0, colFirst: false },
|
|
{ dr: 1, dc: 1, cStart: size - 2, cEnd: 0, colFirst: true },
|
|
{ dr: -1, dc: 1, cStart: size - 2, cEnd: 0, colFirst: false },
|
|
{ dr: -1, dc: 1, cStart: size - 2, cEnd: 0, colFirst: true },
|
|
];
|
|
|
|
// Simple fill: go through and fill non-reserved with data
|
|
for (let r = size - 1; r >= 0; r--) {
|
|
for (let c = size - 1; c >= 0; c--) {
|
|
if (matrix[r][c] !== null) continue;
|
|
// Skip timing pattern column
|
|
if (c === 6 && (r >= 8 && r <= size - 9)) continue;
|
|
|
|
const bit = (dataVal >> (bitsLeft - 1)) & 1;
|
|
matrix[r][c] = bit;
|
|
bitsLeft--;
|
|
if (bitsLeft === 0) {
|
|
byteIdx++;
|
|
if (byteIdx < dataBits.length) dataVal = dataBits[byteIdx];
|
|
bitsLeft = 8;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply mask 0 (invert every cell where mask bit is 1)
|
|
const mask0 = (r, c) => ((r + c) % 2 === 0);
|
|
for (let r = 0; r < size; r++) {
|
|
for (let c = 0; c < size; c++) {
|
|
if (reserved[r][c] || matrix[r][c] === null) continue;
|
|
if (mask0(r, c)) matrix[r][c] ^= 1;
|
|
}
|
|
}
|
|
|
|
return matrix;
|
|
}
|
|
|
|
function renderQRToSVG(text, moduleSize = 10) {
|
|
const size = 21;
|
|
const matrix = createQRMatrix(text);
|
|
const total = size * moduleSize;
|
|
|
|
let svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${total}" height="${total}" viewBox="0 0 ${total} ${total}">\n`;
|
|
svg += `<rect width="${total}" height="${total}" fill="white"/>\n`;
|
|
|
|
for (let r = 0; r < size; r++) {
|
|
for (let c = 0; c < size; c++) {
|
|
if (matrix[r][c] === 1) {
|
|
svg += `<rect x="${c * moduleSize}" y="${r * moduleSize}" width="${moduleSize}" height="${moduleSize}" fill="black"/>\n`;
|
|
}
|
|
}
|
|
}
|
|
svg += `</svg>`;
|
|
return svg;
|
|
}
|
|
|
|
// Main
|
|
const text = process.argv[2] || 'https://github.com/login/device';
|
|
const svg = renderQRToSVG(text, 10);
|
|
console.log(svg);
|