@vizejs/ui 0.426.3 → 0.428.0

package/registry/files/families/media/qr-code/qr-code-encoder.ts

@@ -0,0 +1,634 @@
+import { QrCodeEncodeError } from "./qr-code-error.ts";
+import {
+  appendBits,
+  createQrCodeEciSegment,
+  createQrCodeSegments,
+  qrCodeSegmentBitLength,
+} from "./qr-code-segments.ts";
+import {
+  QR_CODE_ECI_MODE_INDICATOR,
+  QR_CODE_ERROR_CORRECTION_LEVELS,
+  QR_CODE_FORMAT_BITS,
+  QR_CODE_MODE_INDICATOR,
+  alignmentPatternPositions,
+  characterCountBits,
+  dataCodewordCount,
+  eccCodewordsPerBlock,
+  errorCorrectionBlockCount,
+  qrCodeSizeOf,
+  rawDataModuleCount,
+} from "./qr-code-tables.ts";
+import type {
+  QrCodeEncodeOptions,
+  QrCodeErrorCorrection,
+  QrCodeMask,
+  QrCodeMatrix,
+  QrCodeMode,
+  QrCodeSegment,
+  QrCodeValue,
+  QrCodeVersion,
+} from "./qr-code-types.ts";
+
+export { QrCodeEncodeError } from "./qr-code-error.ts";
+
+const MASKS: readonly QrCodeMask[] = [0, 1, 2, 3, 4, 5, 6, 7];
+const UTF8_ECI = 26;
+
+function isVersion(value: unknown): value is QrCodeVersion {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 40;
+}
+
+function isMask(value: unknown): value is QrCodeMask {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 7;
+}
+
+/** Multiply two elements of GF(2^8) modulo the QR polynomial `x^8 + x^4 + x^3 + x^2 + 1`. */
+export function gf256Multiply(left: number, right: number): number {
+  let result = 0;
+  for (let bit = 7; bit >= 0; bit--) {
+    result = (result << 1) ^ ((result >>> 7) * 0x11d);
+    result ^= ((right >>> bit) & 1) * left;
+  }
+  return result & 0xff;
+}
+
+/**
+ * Reed–Solomon generator polynomial coefficients for a degree, highest term
+ * first with the implicit leading `1` omitted.
+ */
+export function reedSolomonGenerator(degree: number): readonly number[] {
+  if (!Number.isInteger(degree) || degree < 1 || degree > 255) {
+    throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "degree must be in 1..255");
+  }
+  const result = Array.from<number>({ length: degree }).fill(0);
+  result[degree - 1] = 1;
+  let root = 1;
+  for (let index = 0; index < degree; index++) {
+    for (let term = 0; term < result.length; term++) {
+      const next = term + 1 < result.length ? (result[term + 1] ?? 0) : 0;
+      result[term] = gf256Multiply(result[term] ?? 0, root) ^ next;
+    }
+    root = gf256Multiply(root, 0x02);
+  }
+  return result;
+}
+
+/** Reed–Solomon error correction codewords for data under a generator. */
+export function reedSolomonRemainder(
+  data: readonly number[],
+  generator: readonly number[],
+): readonly number[] {
+  const result = Array.from<number>({ length: generator.length }).fill(0);
+  for (const byte of data) {
+    const factor = byte ^ (result.shift() ?? 0);
+    result.push(0);
+    for (let index = 0; index < generator.length; index++) {
+      result[index] = (result[index] ?? 0) ^ gf256Multiply(generator[index] ?? 0, factor);
+    }
+  }
+  return result;
+}
+
+/**
+ * Build the padded data codewords for segments at a version and level.
+ * Exposed for conformance tests against the standard's worked examples.
+ */
+export function createDataCodewords(
+  segments: readonly QrCodeSegment[],
+  version: QrCodeVersion,
+  ecc: QrCodeErrorCorrection,
+): readonly number[] {
+  const bits: number[] = [];
+  for (const segment of segments) {
+    if (segment.mode === "eci") {
+      appendBits(bits, QR_CODE_ECI_MODE_INDICATOR, 4);
+    } else {
+      appendBits(bits, QR_CODE_MODE_INDICATOR[segment.mode], 4);
+      appendBits(bits, segment.count, characterCountBits(segment.mode, version));
+    }
+    for (const bit of segment.bits) bits.push(bit);
+  }
+  const capacityBits = dataCodewordCount(version, ecc) * 8;
+  appendBits(bits, 0, Math.min(4, capacityBits - bits.length));
+  appendBits(bits, 0, (8 - (bits.length % 8)) % 8);
+  for (let pad = 0xec; bits.length < capacityBits; pad ^= 0xec ^ 0x11) appendBits(bits, pad, 8);
+  const codewords: number[] = [];
+  for (let index = 0; index < bits.length; index += 8) {
+    let byte = 0;
+    for (let offset = 0; offset < 8; offset++) byte = (byte << 1) | (bits[index + offset] ?? 0);
+    codewords.push(byte);
+  }
+  return codewords;
+}
+
+/** Split data into blocks, append Reed–Solomon codewords, and interleave. */
+export function addErrorCorrectionAndInterleave(
+  data: readonly number[],
+  version: QrCodeVersion,
+  ecc: QrCodeErrorCorrection,
+): readonly number[] {
+  const blockCount = errorCorrectionBlockCount(version, ecc);
+  const blockEccLength = eccCodewordsPerBlock(version, ecc);
+  const rawCodewords = Math.floor(rawDataModuleCount(version) / 8);
+  const shortBlockCount = blockCount - (rawCodewords % blockCount);
+  const shortBlockLength = Math.floor(rawCodewords / blockCount);
+  const generator = reedSolomonGenerator(blockEccLength);
+  const blocks: number[][] = [];
+  let offset = 0;
+  for (let index = 0; index < blockCount; index++) {
+    const length = shortBlockLength - blockEccLength + (index < shortBlockCount ? 0 : 1);
+    const block = data.slice(offset, offset + length);
+    offset += length;
+    const remainder = reedSolomonRemainder(block, generator);
+    if (index < shortBlockCount) block.push(0);
+    blocks.push([...block, ...remainder]);
+  }
+  const result: number[] = [];
+  const blockLength = blocks[0]?.length ?? 0;
+  for (let column = 0; column < blockLength; column++) {
+    blocks.forEach((block, blockIndex) => {
+      if (column !== shortBlockLength - blockEccLength || blockIndex >= shortBlockCount) {
+        result.push(block[column] ?? 0);
+      }
+    });
+  }
+  return result;
+}
+
+/** 15-bit format information (level + mask with BCH code and XOR mask). */
+export function formatInformationBits(ecc: QrCodeErrorCorrection, mask: QrCodeMask): number {
+  const data = (QR_CODE_FORMAT_BITS[ecc] << 3) | mask;
+  let remainder = data;
+  for (let index = 0; index < 10; index++) {
+    remainder = (remainder << 1) ^ ((remainder >>> 9) * 0x537);
+  }
+  return ((data << 10) | remainder) ^ 0x5412;
+}
+
+/** 18-bit version information for versions 7 and above. */
+export function versionInformationBits(version: QrCodeVersion): number {
+  let remainder: number = version;
+  for (let index = 0; index < 12; index++) {
+    remainder = (remainder << 1) ^ ((remainder >>> 11) * 0x1f25);
+  }
+  return (version << 12) | remainder;
+}
+
+function bitAt(value: number, index: number): boolean {
+  return ((value >>> index) & 1) !== 0;
+}
+
+function maskApplies(mask: QrCodeMask, x: number, y: number): boolean {
+  switch (mask) {
+    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(x / 3) + Math.floor(y / 2)) % 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;
+  }
+}
+
+/** Mutable module grid used while one symbol is drawn. */
+class SymbolCanvas {
+  readonly version: QrCodeVersion;
+  readonly size: number;
+  readonly modules: boolean[];
+  readonly reserved: boolean[];
+
+  constructor(version: QrCodeVersion) {
+    this.version = version;
+    this.size = qrCodeSizeOf(version);
+    this.modules = Array.from<boolean>({ length: this.size * this.size }).fill(false);
+    this.reserved = Array.from<boolean>({ length: this.size * this.size }).fill(false);
+  }
+
+  get(x: number, y: number): boolean {
+    return this.modules[y * this.size + x] === true;
+  }
+
+  setFunction(x: number, y: number, dark: boolean): void {
+    this.modules[y * this.size + x] = dark;
+    this.reserved[y * this.size + x] = true;
+  }
+
+  drawFunctionPatterns(): void {
+    const { size } = this;
+    for (let index = 0; index < size; index++) {
+      this.setFunction(6, index, index % 2 === 0);
+      this.setFunction(index, 6, index % 2 === 0);
+    }
+    this.drawFinder(3, 3);
+    this.drawFinder(size - 4, 3);
+    this.drawFinder(3, size - 4);
+    const positions = alignmentPatternPositions(this.version);
+    const last = positions.length - 1;
+    positions.forEach((y, row) => {
+      positions.forEach((x, column) => {
+        const overlapsFinder =
+          (row === 0 && column === 0) ||
+          (row === 0 && column === last) ||
+          (row === last && column === 0);
+        if (!overlapsFinder) this.drawAlignment(x, y);
+      });
+    });
+    // Reserve format areas before data placement; real bits are drawn per mask.
+    this.drawFormat(formatInformationBits("M", 0));
+    this.drawVersion();
+  }
+
+  drawFinder(centerX: number, centerY: number): void {
+    for (let dy = -4; dy <= 4; dy++) {
+      for (let dx = -4; dx <= 4; dx++) {
+        const distance = Math.max(Math.abs(dx), Math.abs(dy));
+        const x = centerX + dx;
+        const y = centerY + dy;
+        if (x >= 0 && x < this.size && y >= 0 && y < this.size) {
+          this.setFunction(x, y, distance !== 2 && distance !== 4);
+        }
+      }
+    }
+  }
+
+  drawAlignment(centerX: number, centerY: number): void {
+    for (let dy = -2; dy <= 2; dy++) {
+      for (let dx = -2; dx <= 2; dx++) {
+        this.setFunction(centerX + dx, centerY + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+      }
+    }
+  }
+
+  drawFormat(bits: number): void {
+    const { size } = this;
+    for (let index = 0; index <= 5; index++) this.setFunction(8, index, bitAt(bits, index));
+    this.setFunction(8, 7, bitAt(bits, 6));
+    this.setFunction(8, 8, bitAt(bits, 7));
+    this.setFunction(7, 8, bitAt(bits, 8));
+    for (let index = 9; index < 15; index++) this.setFunction(14 - index, 8, bitAt(bits, index));
+    for (let index = 0; index < 8; index++)
+      this.setFunction(size - 1 - index, 8, bitAt(bits, index));
+    for (let index = 8; index < 15; index++)
+      this.setFunction(8, size - 15 + index, bitAt(bits, index));
+    this.setFunction(8, size - 8, true);
+  }
+
+  drawVersion(): void {
+    if (this.version < 7) return;
+    const bits = versionInformationBits(this.version);
+    for (let index = 0; index < 18; index++) {
+      const dark = bitAt(bits, index);
+      const a = this.size - 11 + (index % 3);
+      const b = Math.floor(index / 3);
+      this.setFunction(a, b, dark);
+      this.setFunction(b, a, dark);
+    }
+  }
+
+  drawCodewords(codewords: readonly number[]): void {
+    const { size } = this;
+    const totalBits = codewords.length * 8;
+    let bitIndex = 0;
+    for (let right = size - 1; right >= 1; right -= 2) {
+      if (right === 6) right = 5;
+      const upward = ((right + 1) & 2) === 0;
+      for (let vertical = 0; vertical < size; vertical++) {
+        const y = upward ? size - 1 - vertical : vertical;
+        for (let offset = 0; offset < 2; offset++) {
+          const x = right - offset;
+          const index = y * size + x;
+          if (this.reserved[index] === true || bitIndex >= totalBits) continue;
+          this.modules[index] = bitAt(codewords[bitIndex >>> 3] ?? 0, 7 - (bitIndex & 7));
+          bitIndex++;
+        }
+      }
+    }
+  }
+
+  /** XOR a mask over data modules. Applying the same mask twice restores the grid. */
+  applyMask(mask: QrCodeMask): void {
+    for (let y = 0; y < this.size; y++) {
+      for (let x = 0; x < this.size; x++) {
+        const index = y * this.size + x;
+        if (this.reserved[index] !== true && maskApplies(mask, x, y)) {
+          this.modules[index] = !this.modules[index];
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Standard mask penalty score (ISO/IEC 18004 §7.8.3): same-color runs, 2×2
+ * blocks, finder-like patterns, and dark/light imbalance. Lower is better.
+ */
+export function qrCodePenaltyScore(size: number, modules: readonly boolean[]): number {
+  // Typed scratch buffers keep this hot loop (8 masks per encode) allocation-free.
+  const grid = new Uint8Array(size * size);
+  let darkCount = 0;
+  for (let index = 0; index < grid.length; index++) {
+    if (modules[index] === true) {
+      grid[index] = 1;
+      darkCount++;
+    }
+  }
+  const history = new Int32Array(7);
+  let result = 0;
+
+  for (let pass = 0; pass < 2; pass++) {
+    const horizontal = pass === 0;
+    for (let line = 0; line < size; line++) {
+      let runDark = 0;
+      let runLength = 0;
+      history.fill(0);
+      for (let cell = 0; cell < size; cell++) {
+        const dark = grid[horizontal ? line * size + cell : cell * size + line] ?? 0;
+        if (dark === runDark) {
+          runLength++;
+          if (runLength === 5) result += 3;
+          else if (runLength > 5) result++;
+        } else {
+          pushFinderRun(history, runLength, size);
+          if (runDark === 0) result += countFinderPatterns(history) * 40;
+          runDark = dark;
+          runLength = 1;
+        }
+      }
+      if (runDark === 1) {
+        pushFinderRun(history, runLength, size);
+        runLength = 0;
+      }
+      pushFinderRun(history, runLength + size, size);
+      result += countFinderPatterns(history) * 40;
+    }
+  }
+
+  for (let y = 0; y < size - 1; y++) {
+    const row = y * size;
+    for (let x = 0; x < size - 1; x++) {
+      const dark = grid[row + x];
+      if (
+        dark === grid[row + x + 1] &&
+        dark === grid[row + size + x] &&
+        dark === grid[row + size + x + 1]
+      ) {
+        result += 3;
+      }
+    }
+  }
+
+  const total = size * size;
+  const k = Math.ceil(Math.abs(darkCount * 20 - total * 10) / total) - 1;
+  return result + k * 10;
+}
+
+/** Shift one run length into the 7-entry finder-pattern history (light border counts as `size`). */
+function pushFinderRun(history: Int32Array, runLength: number, size: number): void {
+  const value = history[0] === 0 ? runLength + size : runLength;
+  history.copyWithin(1, 0, 6);
+  history[0] = value;
+}
+
+/** Count 1:1:3:1:1 finder-like patterns with a 4-module light margin on either side. */
+function countFinderPatterns(history: Int32Array): number {
+  const n = history[1] ?? 0;
+  const core =
+    n > 0 && history[2] === n && history[3] === n * 3 && history[4] === n && history[5] === n;
+  if (!core) return 0;
+  const before = history[0] ?? 0;
+  const after = history[6] ?? 0;
+  return (before >= n * 4 && after >= n ? 1 : 0) + (after >= n * 4 && before >= n ? 1 : 0);
+}
+
+function readVersionOption(name: string, value: unknown, fallback: QrCodeVersion): QrCodeVersion {
+  if (value === undefined) return fallback;
+  if (!isVersion(value)) {
+    throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", `${name} must be an integer in 1..40`);
+  }
+  return value;
+}
+
+/** ECI designator requested by `eci` / `utf8Eci`, or `null`. */
+function readEciOption(options: QrCodeEncodeOptions): number | null {
+  const explicit = options.eci;
+  if (options.utf8Eci === true) {
+    if (explicit !== undefined && explicit !== UTF8_ECI) {
+      throw new QrCodeEncodeError(
+        "VIZE_UI_QR_INVALID_OPTION",
+        `utf8Eci conflicts with eci ${explicit}`,
+      );
+    }
+    return UTF8_ECI;
+  }
+  return explicit ?? null;
+}
+
+function isSegmentList(value: QrCodeValue): value is readonly QrCodeSegment[] {
+  return Array.isArray(value);
+}
+
+function dataModeOf(segments: readonly QrCodeSegment[]): QrCodeMatrix["mode"] {
+  let mode: QrCodeMode | null = null;
+  for (const segment of segments) {
+    if (segment.mode === "eci") continue;
+    if (mode !== null && mode !== segment.mode) return "mixed";
+    mode = segment.mode;
+  }
+  return mode;
+}
+
+/**
+ * Encode text, bytes, or explicit segments as an immutable QR Code symbol.
+ *
+ * Text is split into optimally mixed numeric, alphanumeric, byte (UTF-8), and
+ * — with a `kanji` encoder — Kanji segments, re-optimized for each range of
+ * character-count widths (versions 1–9, 10–26, 27–40). `segmentation:
+ * "single"` or a forced `mode` keeps one segment. An `eci` / `utf8Eci` header
+ * precedes the data when requested. The smallest fitting version is chosen
+ * unless `version` fixes one, and the mask with the lowest penalty is applied
+ * unless `mask` fixes one. Pure and deterministic, so it is safe during SSR.
+ *
+ * @throws {QrCodeEncodeError} `VIZE_UI_QR_DATA_TOO_LONG` when the value does
+ * not fit the allowed versions, `VIZE_UI_QR_INVALID_MODE` when a forced mode
+ * cannot represent it, or `VIZE_UI_QR_INVALID_OPTION` for out-of-range options.
+ */
+export function encodeQrCode(value: QrCodeValue, options: QrCodeEncodeOptions = {}): QrCodeMatrix {
+  const requestedEcc = options.errorCorrection ?? "M";
+  if (!QR_CODE_ERROR_CORRECTION_LEVELS.includes(requestedEcc)) {
+    throw new QrCodeEncodeError(
+      "VIZE_UI_QR_INVALID_OPTION",
+      "errorCorrection must be L, M, Q, or H",
+    );
+  }
+  const fixedVersion = options.version ?? "auto";
+  let minVersion: QrCodeVersion;
+  let maxVersion: QrCodeVersion;
+  if (fixedVersion === "auto") {
+    minVersion = readVersionOption("minVersion", options.minVersion, 1);
+    maxVersion = readVersionOption("maxVersion", options.maxVersion, 40);
+  } else {
+    minVersion = readVersionOption("version", fixedVersion, 1);
+    maxVersion = minVersion;
+  }
+  if (minVersion > maxVersion) {
+    throw new QrCodeEncodeError(
+      "VIZE_UI_QR_INVALID_OPTION",
+      "minVersion must not exceed maxVersion",
+    );
+  }
+  const maskOption = options.mask ?? "auto";
+  if (maskOption !== "auto" && !isMask(maskOption)) {
+    throw new QrCodeEncodeError("VIZE_UI_QR_INVALID_OPTION", "mask must be an integer in 0..7");
+  }
+  const segmentation = options.segmentation ?? "optimal";
+  if (segmentation !== "optimal" && segmentation !== "single") {
+    throw new QrCodeEncodeError(
+      "VIZE_UI_QR_INVALID_OPTION",
+      "segmentation must be optimal or single",
+    );
+  }
+  const eci = readEciOption(options);
+  const header = eci === null ? [] : [createQrCodeEciSegment(eci)];
+
+  // Optimal segmentation depends on count-indicator widths, which change at
+  // versions 10 and 27, so segments are recomputed when entering a new range.
+  const segmentsFor = (candidate: QrCodeVersion): readonly QrCodeSegment[] => {
+    if (isSegmentList(value)) return [...header, ...value];
+    const data = createQrCodeSegments(value, {
+      kanji: options.kanji,
+      mode: options.mode ?? "auto",
+      segmentation,
+      version: candidate,
+    });
+    return [...header, ...data];
+  };
+  const rangeStarts = new Set([minVersion, 10, 27]);
+  let segments: readonly QrCodeSegment[] = [];
+  let version: QrCodeVersion | null = null;
+  let usedBits = 0;
+  for (let candidate: number = minVersion; candidate <= maxVersion; candidate++) {
+    if (!isVersion(candidate)) break;
+    if (rangeStarts.has(candidate)) segments = segmentsFor(candidate);
+    const bits = qrCodeSegmentBitLength(segments, candidate);
+    if (bits <= dataCodewordCount(candidate, requestedEcc) * 8) {
+      version = candidate;
+      usedBits = bits;
+      break;
+    }
+  }
+  if (version === null) {
+    throw new QrCodeEncodeError(
+      "VIZE_UI_QR_DATA_TOO_LONG",
+      `value does not fit version ${maxVersion} at error correction ${requestedEcc}`,
+    );
+  }
+
+  let ecc = requestedEcc;
+  if (options.boostErrorCorrection === true) {
+    for (const level of QR_CODE_ERROR_CORRECTION_LEVELS) {
+      if (usedBits <= dataCodewordCount(version, level) * 8) ecc = level;
+    }
+  }
+
+  const data = createDataCodewords(segments, version, ecc);
+  const codewords = addErrorCorrectionAndInterleave(data, version, ecc);
+  const canvas = new SymbolCanvas(version);
+  canvas.drawFunctionPatterns();
+  canvas.drawCodewords(codewords);
+
+  let mask: QrCodeMask;
+  if (maskOption === "auto") {
+    mask = 0;
+    let lowest = Number.POSITIVE_INFINITY;
+    for (const candidate of MASKS) {
+      canvas.applyMask(candidate);
+      canvas.drawFormat(formatInformationBits(ecc, candidate));
+      const penalty = qrCodePenaltyScore(canvas.size, canvas.modules);
+      if (penalty < lowest) {
+        mask = candidate;
+        lowest = penalty;
+      }
+      canvas.applyMask(candidate);
+    }
+  } else {
+    mask = maskOption;
+  }
+  canvas.applyMask(mask);
+  canvas.drawFormat(formatInformationBits(ecc, mask));
+
+  return Object.freeze({
+    version,
+    size: canvas.size,
+    errorCorrection: ecc,
+    mask,
+    mode: dataModeOf(segments),
+    segments: Object.freeze(
+      segments.map((segment) =>
+        Object.freeze({
+          mode: segment.mode,
+          count: segment.mode === "eci" ? eciDesignatorOf(segment) : segment.count,
+        }),
+      ),
+    ),
+    eci,
+    modules: Object.freeze([...canvas.modules]),
+  });
+}
+
+/** Decode the designator from an ECI segment's 8/16/24 payload bits. */
+function eciDesignatorOf(segment: QrCodeSegment): number {
+  const prefix = segment.bits[0] === 0 ? 1 : segment.bits[1] === 0 ? 2 : 3;
+  let value = 0;
+  for (const bit of segment.bits.slice(prefix)) value = value * 2 + bit;
+  return value;
+}
+
+/** Whether the module at `(x, y)` is dark. Coordinates outside the symbol are light. */
+export function isQrCodeModuleDark(matrix: QrCodeMatrix, x: number, y: number): boolean {
+  if (x < 0 || y < 0 || x >= matrix.size || y >= matrix.size) return false;
+  return matrix.modules[y * matrix.size + x] === true;
+}
+
+/**
+ * Maximum characters a mode holds at a version and level. Useful for input
+ * limits and for choosing a stronger level when a logo covers the symbol.
+ */
+export function qrCodeCapacity(
+  version: QrCodeVersion,
+  errorCorrection: QrCodeErrorCorrection,
+  mode: QrCodeMode,
+): number {
+  const available =
+    dataCodewordCount(version, errorCorrection) * 8 - 4 - characterCountBits(mode, version);
+  const maxCount = 2 ** characterCountBits(mode, version) - 1;
+  let count: number;
+  switch (mode) {
+    case "numeric": {
+      const groups = Math.floor(available / 10);
+      const rest = available - groups * 10;
+      count = groups * 3 + (rest >= 7 ? 2 : rest >= 4 ? 1 : 0);
+      break;
+    }
+    case "alphanumeric": {
+      const pairs = Math.floor(available / 11);
+      count = pairs * 2 + (available - pairs * 11 >= 6 ? 1 : 0);
+      break;
+    }
+    case "byte":
+      count = Math.floor(available / 8);
+      break;
+    case "kanji":
+      count = Math.floor(available / 13);
+      break;
+  }
+  return Math.min(count, maxCount);
+}

package/registry/files/families/media/qr-code/qr-code-error.ts

@@ -0,0 +1,13 @@
+import type { QrCodeEncodeErrorCode } from "./qr-code-types.ts";
+
+/** Typed encoder diagnostic. `message` starts with the stable {@link code}. */
+export class QrCodeEncodeError extends Error {
+  /** Stable machine-readable diagnostic code. */
+  readonly code: QrCodeEncodeErrorCode;
+
+  constructor(code: QrCodeEncodeErrorCode, detail: string) {
+    super(`${code}: ${detail}`);
+    this.name = "QrCodeEncodeError";
+    this.code = code;
+  }
+}

package/registry/files/families/media/qr-code/qr-code-kanji-table.ts

@@ -0,0 +1,11 @@
+// Generated from the WHATWG `shift_jis` decoder (JIS X 0208 rows only; CP932
+// NEC row 13 excluded). Entry `i` is the Unicode code point of the Shift_JIS
+// character whose QR Kanji value is `i` (0 = unassigned), zigzag-delta encoded
+// as unsigned LEB128 varints and packed as base64. Do not edit by hand.
+
+/** Number of QR Kanji values described by {@link QR_CODE_KANJI_TABLE}. */
+export const QR_CODE_KANJI_TABLE_LENGTH = 7973;
+
+/** Packed QR Kanji value -> Unicode table. */
+export const QR_CODE_KANJI_TABLE =
+  "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";