specqr 1.0.0-rc.1

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "specqr",
+  "version": "1.0.0-rc.1",
+  "description": "A dependency-free QR Code Model 2 generator for JavaScript.",
+  "homepage": "https://github.com/SpecQR/SpecQR#readme",
+  "bugs": {
+    "url": "https://github.com/SpecQR/SpecQR/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SpecQR/SpecQR.git"
+  },
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./browser": {
+      "types": "./src/browser.d.ts",
+      "import": "./src/browser.js"
+    },
+    "./node": {
+      "types": "./src/node.d.ts",
+      "import": "./src/node.js"
+    }
+  },
+  "files": [
+    "src",
+    "docs",
+    "fixtures",
+    "tools",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "test": "node --test",
+    "fixtures:golden": "node tools/update-golden-fixtures.js",
+    "verify:decode": "node tools/verify-decode.js",
+    "verify:decode:optional": "node tools/verify-decode-optional.js",
+    "verify:decode:jsqr": "node tools/verify-decode-optional.js --only-jsqr --require-jsqr",
+    "verify:decode:independent": "npm run verify:decode:jsqr"
+  },
+  "keywords": [
+    "qr",
+    "qrcode",
+    "barcode",
+    "svg",
+    "png",
+    "kanji",
+    "shift-jis",
+    "gs1",
+    "eci",
+    "model2"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "jsqr": "^1.4.0"
+  }
+}

package/src/browser.d.ts

@@ -0,0 +1,8 @@
+import type { QRCodeOptions, QRInput, QRSegmentInput } from "./index.js";
+
+export function toBlob(input: QRInput, options?: QRCodeOptions): Blob;
+export function toBlobFromSegments(segments: QRSegmentInput[], options?: QRCodeOptions): Blob;
+export function toObjectURL(input: QRInput, options?: QRCodeOptions): string;
+export function toObjectURLFromSegments(segments: QRSegmentInput[], options?: QRCodeOptions): string;
+export function toImageData(input: QRInput, options?: QRCodeOptions): ImageData;
+export function toImageDataFromSegments(segments: QRSegmentInput[], options?: QRCodeOptions): ImageData;

package/src/browser.js

@@ -0,0 +1,99 @@
+import { generate, generateSegments } from "./index.js";
+import { InvalidInputError } from "./errors.js";
+import { normalizeOptions } from "./options.js";
+import { parseRgbaColor } from "./render/color.js";
+
+export function toBlob(input, options = {}) {
+  assertBlobSupport();
+  const png = generate(input, {
+    ...options,
+    output: "png",
+    diagnostics: false
+  });
+  return new Blob([png], { type: "image/png" });
+}
+
+export function toBlobFromSegments(segments, options = {}) {
+  assertBlobSupport();
+  const png = generateSegments(segments, {
+    ...options,
+    output: "png",
+    diagnostics: false
+  });
+  return new Blob([png], { type: "image/png" });
+}
+
+export function toObjectURL(input, options = {}) {
+  assertObjectUrlSupport();
+  return URL.createObjectURL(toBlob(input, options));
+}
+
+export function toObjectURLFromSegments(segments, options = {}) {
+  assertObjectUrlSupport();
+  return URL.createObjectURL(toBlobFromSegments(segments, options));
+}
+
+export function toImageData(input, options = {}) {
+  const normalized = normalizeOptions({
+    ...options,
+    output: "matrix",
+    diagnostics: false
+  });
+  const matrix = generate(input, normalized);
+  return matrixToImageData(matrix, normalized);
+}
+
+export function toImageDataFromSegments(segments, options = {}) {
+  const normalized = normalizeOptions({
+    ...options,
+    output: "matrix",
+    diagnostics: false
+  });
+  const matrix = generateSegments(segments, normalized);
+  return matrixToImageData(matrix, normalized);
+}
+
+function matrixToImageData(matrix, options) {
+  if (typeof ImageData !== "function") {
+    throw new InvalidInputError("ImageData is not available in this environment");
+  }
+
+  const size = matrix.length;
+  const dimension = (size + options.margin * 2) * options.scale;
+  const foreground = parseRgbaColor(options.foreground, "foreground", true);
+  const background = parseRgbaColor(options.background, "background", true);
+  const data = new Uint8ClampedArray(dimension * dimension * 4);
+
+  for (let y = 0; y < dimension; y += 1) {
+    const moduleY = Math.floor(y / options.scale) - options.margin;
+    for (let x = 0; x < dimension; x += 1) {
+      const moduleX = Math.floor(x / options.scale) - options.margin;
+      const dark =
+        moduleX >= 0 &&
+        moduleY >= 0 &&
+        moduleX < size &&
+        moduleY < size &&
+        matrix[moduleY][moduleX];
+      const color = dark ? foreground : background;
+      const offset = (y * dimension + x) * 4;
+      data[offset] = color[0];
+      data[offset + 1] = color[1];
+      data[offset + 2] = color[2];
+      data[offset + 3] = color[3];
+    }
+  }
+
+  return new ImageData(data, dimension, dimension);
+}
+
+function assertBlobSupport() {
+  if (typeof Blob !== "function") {
+    throw new InvalidInputError("Blob is not available in this environment");
+  }
+}
+
+function assertObjectUrlSupport() {
+  if (typeof URL !== "function" || typeof URL.createObjectURL !== "function") {
+    throw new InvalidInputError("URL.createObjectURL is not available in this environment");
+  }
+}

package/src/core/codewords.js

@@ -0,0 +1,52 @@
+import { getErrorCorrectionBlockInfo } from "./tables.js";
+import { computeRemainder, createGeneratorPolynomial } from "./reed-solomon.js";
+
+export function interleaveCodewords(dataCodewords, version, errorCorrectionLevel) {
+  const info = getErrorCorrectionBlockInfo(version, errorCorrectionLevel);
+  if (dataCodewords.length !== info.dataCodewords) {
+    throw new Error(`Expected ${info.dataCodewords} data codewords; got ${dataCodewords.length}`);
+  }
+
+  const generator = createGeneratorPolynomial(info.eccPerBlock);
+  const numShortBlocks = info.blocks - (info.rawCodewords % info.blocks);
+  const shortBlockLength = Math.floor(info.rawCodewords / info.blocks);
+  const shortDataLength = shortBlockLength - info.eccPerBlock;
+
+  const blocks = [];
+  let offset = 0;
+  for (let i = 0; i < info.blocks; i += 1) {
+    const dataLength = shortDataLength + (i < numShortBlocks ? 0 : 1);
+    const data = dataCodewords.slice(offset, offset + dataLength);
+    offset += dataLength;
+
+    const ecc = computeRemainder(data, generator);
+    const interleavable = data.slice();
+    if (i < numShortBlocks) {
+      interleavable.push(null);
+    }
+    interleavable.push(...ecc);
+    blocks.push({ data, ecc, interleavable });
+  }
+
+  const result = [];
+  for (let i = 0; i < shortBlockLength + 1; i += 1) {
+    for (const block of blocks) {
+      const value = block.interleavable[i];
+      if (value !== undefined && value !== null) {
+        result.push(value);
+      }
+    }
+  }
+
+  if (result.length !== info.rawCodewords) {
+    throw new Error(`Expected ${info.rawCodewords} interleaved codewords; got ${result.length}`);
+  }
+
+  return {
+    codewords: result,
+    blocks,
+    dataCodewords: info.dataCodewords,
+    errorCorrectionCodewords: info.rawCodewords - info.dataCodewords,
+    totalCodewords: info.rawCodewords
+  };
+}

package/src/core/galois-field.js

@@ -0,0 +1,41 @@
+const REDUCTION_POLYNOMIAL = 0x11D;
+
+export function multiply(a, b) {
+  assertByte(a);
+  assertByte(b);
+
+  let result = 0;
+  for (let i = 0; i < 8; i += 1) {
+    if ((b & 1) !== 0) {
+      result ^= a;
+    }
+
+    const carry = (a & 0x80) !== 0;
+    a = (a << 1) & 0xFF;
+    if (carry) {
+      a ^= REDUCTION_POLYNOMIAL & 0xFF;
+    }
+    b >>>= 1;
+  }
+
+  return result;
+}
+
+export function pow(base, exponent) {
+  assertByte(base);
+  if (!Number.isInteger(exponent) || exponent < 0) {
+    throw new RangeError(`Exponent must be a non-negative integer; got ${exponent}`);
+  }
+
+  let result = 1;
+  for (let i = 0; i < exponent; i += 1) {
+    result = multiply(result, base);
+  }
+  return result;
+}
+
+function assertByte(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 0xFF) {
+    throw new RangeError(`Expected byte value; got ${value}`);
+  }
+}

package/src/core/mask.js

@@ -0,0 +1,123 @@
+export function maskCondition(maskPattern, x, y) {
+  switch (maskPattern) {
+    case 0:
+      return (x + y) % 2 === 0;
+    case 1:
+      return y % 2 === 0;
+    case 2:
+      return x % 3 === 0;
+    case 3:
+      return (x + y) % 3 === 0;
+    case 4:
+      return (Math.floor(y / 2) + Math.floor(x / 3)) % 2 === 0;
+    case 5:
+      return ((x * y) % 2) + ((x * y) % 3) === 0;
+    case 6:
+      return (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
+    case 7:
+      return (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
+    default:
+      throw new RangeError(`Mask pattern must be from 0 to 7; got ${maskPattern}`);
+  }
+}
+
+export function getPenaltyScore(matrix) {
+  const size = matrix.length;
+  let penalty = 0;
+
+  penalty += getRunPenalty(matrix, true);
+  penalty += getRunPenalty(matrix, false);
+  penalty += getBlockPenalty(matrix);
+  penalty += getFinderLikePenalty(matrix, true);
+  penalty += getFinderLikePenalty(matrix, false);
+  penalty += getBalancePenalty(matrix);
+
+  return penalty;
+}
+
+function getRunPenalty(matrix, horizontal) {
+  const size = matrix.length;
+  let penalty = 0;
+
+  for (let a = 0; a < size; a += 1) {
+    let runColor = false;
+    let runLength = 0;
+
+    for (let b = 0; b < size; b += 1) {
+      const value = horizontal ? matrix[a][b] : matrix[b][a];
+      if (b === 0 || value !== runColor) {
+        if (runLength >= 5) {
+          penalty += runLength - 2;
+        }
+        runColor = value;
+        runLength = 1;
+      } else {
+        runLength += 1;
+      }
+    }
+
+    if (runLength >= 5) {
+      penalty += runLength - 2;
+    }
+  }
+
+  return penalty;
+}
+
+function getBlockPenalty(matrix) {
+  const size = matrix.length;
+  let penalty = 0;
+
+  for (let y = 0; y < size - 1; y += 1) {
+    for (let x = 0; x < size - 1; x += 1) {
+      const color = matrix[y][x];
+      if (color === matrix[y][x + 1] && color === matrix[y + 1][x] && color === matrix[y + 1][x + 1]) {
+        penalty += 3;
+      }
+    }
+  }
+
+  return penalty;
+}
+
+function getFinderLikePenalty(matrix, horizontal) {
+  const size = matrix.length;
+  const patternA = [true, false, true, true, true, false, true, false, false, false, false];
+  const patternB = [false, false, false, false, true, false, true, true, true, false, true];
+  let penalty = 0;
+
+  for (let a = 0; a < size; a += 1) {
+    for (let b = 0; b <= size - 11; b += 1) {
+      let matchA = true;
+      let matchB = true;
+
+      for (let i = 0; i < 11; i += 1) {
+        const value = horizontal ? matrix[a][b + i] : matrix[b + i][a];
+        matchA &&= value === patternA[i];
+        matchB &&= value === patternB[i];
+      }
+
+      if (matchA || matchB) {
+        penalty += 40;
+      }
+    }
+  }
+
+  return penalty;
+}
+
+function getBalancePenalty(matrix) {
+  const size = matrix.length;
+  let dark = 0;
+
+  for (const row of matrix) {
+    for (const value of row) {
+      if (value) {
+        dark += 1;
+      }
+    }
+  }
+
+  const total = size * size;
+  return Math.floor(Math.abs(dark * 20 - total * 10) / total) * 10;
+}

package/src/core/matrix.js

@@ -0,0 +1,239 @@
+import { ERROR_CORRECTION_LEVELS, getAlignmentPatternPositions, getSize } from "./tables.js";
+import { getPenaltyScore, maskCondition } from "./mask.js";
+
+class QRMatrix {
+  constructor(size) {
+    this.size = size;
+    this.modules = Array.from({ length: size }, () => new Array(size).fill(false));
+    this.functionModules = Array.from({ length: size }, () => new Array(size).fill(false));
+  }
+
+  clone() {
+    const copy = new QRMatrix(this.size);
+    copy.modules = this.modules.map((row) => row.slice());
+    copy.functionModules = this.functionModules.map((row) => row.slice());
+    return copy;
+  }
+
+  isInside(x, y) {
+    return x >= 0 && y >= 0 && x < this.size && y < this.size;
+  }
+
+  isFunctionAt(x, y) {
+    return this.functionModules[y][x];
+  }
+
+  setFunction(x, y, dark) {
+    if (!this.isInside(x, y)) {
+      return;
+    }
+    this.modules[y][x] = Boolean(dark);
+    this.functionModules[y][x] = true;
+  }
+
+  setData(x, y, dark) {
+    if (this.functionModules[y][x]) {
+      throw new Error(`Cannot write data over function module at ${x},${y}`);
+    }
+    this.modules[y][x] = Boolean(dark);
+  }
+
+  applyMask(maskPattern) {
+    for (let y = 0; y < this.size; y += 1) {
+      for (let x = 0; x < this.size; x += 1) {
+        if (!this.functionModules[y][x] && maskCondition(maskPattern, x, y)) {
+          this.modules[y][x] = !this.modules[y][x];
+        }
+      }
+    }
+  }
+
+  toBooleans() {
+    return this.modules.map((row) => row.slice());
+  }
+}
+
+export function buildMatrix(codewords, version, errorCorrectionLevel, maskPatternOption = "auto") {
+  const base = new QRMatrix(getSize(version));
+  drawFunctionPatterns(base, version, errorCorrectionLevel);
+  drawCodewords(base, codewords);
+
+  const candidateMasks = maskPatternOption === "auto"
+    ? [0, 1, 2, 3, 4, 5, 6, 7]
+    : [maskPatternOption];
+
+  let best = null;
+  const maskPenalties = [];
+  for (const maskPattern of candidateMasks) {
+    const candidate = base.clone();
+    candidate.applyMask(maskPattern);
+    drawFormatBits(candidate, errorCorrectionLevel, maskPattern);
+
+    const matrix = candidate.toBooleans();
+    const penalty = getPenaltyScore(matrix);
+    maskPenalties.push({ maskPattern, penalty });
+    if (!best || penalty < best.penalty) {
+      best = { matrix, maskPattern, penalty };
+    }
+  }
+
+  return { ...best, maskPenalties };
+}
+
+function drawFunctionPatterns(matrix, version, errorCorrectionLevel) {
+  const size = matrix.size;
+
+  drawFinderPattern(matrix, 0, 0);
+  drawFinderPattern(matrix, size - 7, 0);
+  drawFinderPattern(matrix, 0, size - 7);
+  drawTimingPatterns(matrix);
+  drawAlignmentPatterns(matrix, version);
+  drawFormatBits(matrix, errorCorrectionLevel, 0);
+  drawDarkModule(matrix);
+  drawVersionBits(matrix, version);
+}
+
+function drawFinderPattern(matrix, left, top) {
+  for (let dy = -1; dy <= 7; dy += 1) {
+    for (let dx = -1; dx <= 7; dx += 1) {
+      const x = left + dx;
+      const y = top + dy;
+      if (!matrix.isInside(x, y)) {
+        continue;
+      }
+
+      const inPattern = dx >= 0 && dx <= 6 && dy >= 0 && dy <= 6;
+      const dark = inPattern && (
+        dx === 0 || dx === 6 || dy === 0 || dy === 6 ||
+        (dx >= 2 && dx <= 4 && dy >= 2 && dy <= 4)
+      );
+      matrix.setFunction(x, y, dark);
+    }
+  }
+}
+
+function drawTimingPatterns(matrix) {
+  const size = matrix.size;
+  for (let i = 8; i < size - 8; i += 1) {
+    const dark = i % 2 === 0;
+    matrix.setFunction(i, 6, dark);
+    matrix.setFunction(6, i, dark);
+  }
+}
+
+function drawAlignmentPatterns(matrix, version) {
+  const positions = getAlignmentPatternPositions(version);
+  const last = positions.length - 1;
+
+  for (let yIndex = 0; yIndex < positions.length; yIndex += 1) {
+    for (let xIndex = 0; xIndex < positions.length; xIndex += 1) {
+      const overlapsFinder =
+        (xIndex === 0 && yIndex === 0) ||
+        (xIndex === last && yIndex === 0) ||
+        (xIndex === 0 && yIndex === last);
+
+      if (!overlapsFinder) {
+        drawAlignmentPattern(matrix, positions[xIndex], positions[yIndex]);
+      }
+    }
+  }
+}
+
+function drawAlignmentPattern(matrix, centerX, centerY) {
+  for (let dy = -2; dy <= 2; dy += 1) {
+    for (let dx = -2; dx <= 2; dx += 1) {
+      const distance = Math.max(Math.abs(dx), Math.abs(dy));
+      matrix.setFunction(centerX + dx, centerY + dy, distance !== 1);
+    }
+  }
+}
+
+function drawFormatBits(matrix, errorCorrectionLevel, maskPattern) {
+  const ecl = ERROR_CORRECTION_LEVELS[errorCorrectionLevel];
+  let data = (ecl.formatBits << 3) | maskPattern;
+  let remainder = data;
+  for (let i = 0; i < 10; i += 1) {
+    remainder = (remainder << 1) ^ (((remainder >>> 9) & 1) * 0x537);
+  }
+
+  const bits = ((data << 10) | remainder) ^ 0x5412;
+  const size = matrix.size;
+
+  for (let i = 0; i <= 5; i += 1) {
+    matrix.setFunction(8, i, getBit(bits, i));
+  }
+  matrix.setFunction(8, 7, getBit(bits, 6));
+  matrix.setFunction(8, 8, getBit(bits, 7));
+  matrix.setFunction(7, 8, getBit(bits, 8));
+  for (let i = 9; i < 15; i += 1) {
+    matrix.setFunction(14 - i, 8, getBit(bits, i));
+  }
+
+  for (let i = 0; i < 8; i += 1) {
+    matrix.setFunction(size - 1 - i, 8, getBit(bits, i));
+  }
+  for (let i = 8; i < 15; i += 1) {
+    matrix.setFunction(8, size - 15 + i, getBit(bits, i));
+  }
+}
+
+function drawDarkModule(matrix) {
+  matrix.setFunction(8, matrix.size - 8, true);
+}
+
+function drawVersionBits(matrix, version) {
+  if (version < 7) {
+    return;
+  }
+
+  let remainder = version;
+  for (let i = 0; i < 12; i += 1) {
+    remainder = (remainder << 1) ^ (((remainder >>> 11) & 1) * 0x1F25);
+  }
+
+  const bits = (version << 12) | remainder;
+  const size = matrix.size;
+  for (let i = 0; i < 18; i += 1) {
+    const bit = getBit(bits, i);
+    const a = size - 11 + (i % 3);
+    const b = Math.floor(i / 3);
+    matrix.setFunction(a, b, bit);
+    matrix.setFunction(b, a, bit);
+  }
+}
+
+function drawCodewords(matrix, codewords) {
+  const size = matrix.size;
+  let bitIndex = 0;
+
+  for (let right = size - 1; right >= 1; right -= 2) {
+    if (right === 6) {
+      right = 5;
+    }
+
+    for (let vert = 0; vert < size; vert += 1) {
+      const upward = ((right + 1) & 2) === 0;
+      const y = upward ? size - 1 - vert : vert;
+
+      for (let j = 0; j < 2; j += 1) {
+        const x = right - j;
+        if (!matrix.isFunctionAt(x, y)) {
+          const dark = bitIndex < codewords.length * 8
+            ? getCodewordBit(codewords, bitIndex)
+            : false;
+          matrix.setData(x, y, dark);
+          bitIndex += 1;
+        }
+      }
+    }
+  }
+}
+
+function getCodewordBit(codewords, bitIndex) {
+  const value = codewords[Math.floor(bitIndex / 8)];
+  return ((value >>> (7 - (bitIndex % 8))) & 1) !== 0;
+}
+
+function getBit(value, index) {
+  return ((value >>> index) & 1) !== 0;
+}

package/src/core/reed-solomon.js

@@ -0,0 +1,41 @@
+import { multiply, pow } from "./galois-field.js";
+
+export function createGeneratorPolynomial(degree) {
+  if (!Number.isInteger(degree) || degree < 1) {
+    throw new RangeError(`Generator degree must be a positive integer; got ${degree}`);
+  }
+
+  let result = [1];
+  for (let i = 0; i < degree; i += 1) {
+    const factor = [1, pow(2, i)];
+    result = multiplyPolynomials(result, factor);
+  }
+
+  return result;
+}
+
+export function computeRemainder(data, generator) {
+  const degree = generator.length - 1;
+  const result = new Array(degree).fill(0);
+
+  for (const value of data) {
+    const factor = value ^ result.shift();
+    result.push(0);
+
+    for (let i = 0; i < degree; i += 1) {
+      result[i] ^= multiply(generator[i + 1], factor);
+    }
+  }
+
+  return result;
+}
+
+function multiplyPolynomials(left, right) {
+  const result = new Array(left.length + right.length - 1).fill(0);
+  for (let i = 0; i < left.length; i += 1) {
+    for (let j = 0; j < right.length; j += 1) {
+      result[i + j] ^= multiply(left[i], right[j]);
+    }
+  }
+  return result;
+}