@vamos-ui/react 0.0.0-stage → 0.3.0

package/dist/charts/utils.js

@@ -0,0 +1,262 @@
+export const CHART_HEIGHTS = { sm: 160, md: 260, lg: 360 };
+const PALETTE = ["chart-1", "chart-2", "chart-3", "chart-4", "chart-5", "chart-6"];
+/** `"chart-2"` → `"var(--chart-2)"`. */
+export function resolveChartColor(color) {
+    return `var(--${color})`;
+}
+/** The first `n` palette tokens (wraps after 6). */
+export function seriesPalette(n) {
+    return Array.from({ length: n }, (_, i) => PALETTE[i % PALETTE.length]);
+}
+/** A CSS-identifier-safe version of a series key, used in `--series-<key>` variables. */
+export function seriesVarName(key) {
+    return `--series-${key.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+/** `var(--series-<key>)` — the colour of a series inside a Chart. */
+export function seriesColor(key) {
+    return `var(${seriesVarName(key)})`;
+}
+const AUTO_PATTERNS = ["solid", "dashed", "dotted"];
+/** Fills in colour and pattern defaults for every series of a config. */
+export function resolveSeries(config) {
+    const keys = Object.keys(config);
+    const auto = keys.length > 3;
+    return keys.map((key, index) => {
+        const s = config[key];
+        return {
+            ...s,
+            key,
+            index,
+            color: s.color ?? PALETTE[index % PALETTE.length],
+            pattern: s.pattern ?? (auto ? AUTO_PATTERNS[index % AUTO_PATTERNS.length] : "solid"),
+        };
+    });
+}
+/** SVG dash array for a pattern. */
+export function patternDash(pattern) {
+    if (pattern === "dashed")
+        return "6 4";
+    if (pattern === "dotted")
+        return "1.5 3.5";
+    return undefined;
+}
+const CHART_DATE_PRESETS = {
+    "day-month": { month: "short", day: "numeric" },
+    month: { month: "short" },
+    "month-short-year": { month: "short", year: "2-digit" },
+    hour: { hour: "numeric" },
+    "weekday-short": { weekday: "short" },
+};
+const isMissing = (v) => v === null || v === undefined || (typeof v === "number" && Number.isNaN(v));
+/**
+ * Writes a value with a FormatSpec. `compact` shortens numbers and money for axis ticks
+ * ("$1.2M", "₺1,2 Mn"); tooltips and tables use the full form. Missing values → "—".
+ */
+export function formatValue(f, spec, value, options = {}) {
+    if (isMissing(value))
+        return "—";
+    // compactFrom: plain numbers shorten from this size (axes whose top tick is ≥ 10K pass 1000 so every tick reads alike)
+    const { compact, compactFrom = 10000 } = options;
+    if (typeof spec === "function")
+        return spec(value, f.locale);
+    const num = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value)) ? Number(value) : NaN;
+    if (spec && typeof spec === "object") {
+        if ("date" in spec) {
+            const preset = spec.date;
+            const o = typeof preset === "string" ? (CHART_DATE_PRESETS[preset] ?? {}) : preset;
+            const opts = { ...o, ...(spec.timeZoneName ? { timeZoneName: spec.timeZoneName } : {}) };
+            if (typeof preset === "string" && !CHART_DATE_PRESETS[preset])
+                return f.date(value, preset);
+            return f.date(value, opts);
+        }
+        if ("relative" in spec)
+            return f.relative(value);
+        if ("currency" in spec) {
+            const c = compact || spec.compact;
+            return f.currency(value, { currency: spec.currency, ...(c ? { notation: "compact", minimumFractionDigits: 0, maximumFractionDigits: 1 } : {}) });
+        }
+    }
+    if (Number.isNaN(num))
+        return String(value);
+    switch (spec) {
+        case "integer":
+            return compact && Math.abs(num) >= compactFrom ? f.compact(num) : f.number(num, { maximumFractionDigits: 0 });
+        case "compact":
+            return f.compact(num);
+        case "percent":
+            return f.percent(num);
+        case "currency":
+            return compact ? f.currency(num, { notation: "compact", minimumFractionDigits: 0, maximumFractionDigits: 1 }) : f.currency(num);
+        case "duration":
+            return f.duration(num, compact ? { maxParts: 1 } : undefined);
+        case "bytes":
+            return f.bytes(num);
+        case "number":
+        default:
+            return compact && Math.abs(num) >= compactFrom ? f.compact(num) : f.number(num, { maximumFractionDigits: 2 });
+    }
+}
+/** Default x formatter: `YYYY-MM-DD` strings become "Nov 1", everything else is printed as is. */
+export function formatCategory(f, spec, value, long = false) {
+    if (spec)
+        return formatValue(f, spec, value);
+    if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value))
+        return f.date(value, long ? "medium" : { month: "short", day: "numeric" });
+    return isMissing(value) ? "—" : String(value);
+}
+/** Estimated pixel width of a y-axis from its longest formatted tick (11px tabular text). */
+export function estimateAxisWidth(labels, fontSize = 11) {
+    const longest = labels.reduce((m, s) => Math.max(m, s.length), 0);
+    return Math.min(128, Math.max(32, Math.ceil(longest * fontSize * 0.68) + 16));
+}
+/** Numeric min / max over some keys of the rows (stacked → per-row sums). */
+export function extent(rows, keys, stacked = false) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (const row of rows) {
+        if (stacked) {
+            let pos = 0;
+            let neg = 0;
+            for (const k of keys) {
+                const v = Number(row[k]);
+                if (!Number.isFinite(v))
+                    continue;
+                if (v >= 0)
+                    pos += v;
+                else
+                    neg += v;
+            }
+            min = Math.min(min, neg);
+            max = Math.max(max, pos);
+        }
+        else {
+            for (const k of keys) {
+                const v = row[k];
+                if (v === null || v === undefined)
+                    continue;
+                const n = Number(v);
+                if (!Number.isFinite(n))
+                    continue;
+                min = Math.min(min, n);
+                max = Math.max(max, n);
+            }
+        }
+    }
+    if (min === Infinity)
+        return [0, 0];
+    return [min, max];
+}
+/** Rounds a max up to a "nice" tick (1, 2, 2.5, 5 × 10ⁿ). */
+export function niceCeil(v) {
+    if (v <= 0)
+        return 0;
+    const exp = Math.floor(Math.log10(v));
+    const base = 10 ** exp;
+    const f = v / base;
+    const nice = f <= 1 ? 1 : f <= 2 ? 2 : f <= 2.5 ? 2.5 : f <= 5 ? 5 : 10;
+    return nice * base;
+}
+/** A "nice" tick step at or above `v` (1, 1.5, 2, 2.5, 3, 4, 5, 6, 8 × 10ⁿ). */
+export function niceStep(v) {
+    if (v <= 0)
+        return 0;
+    const exp = Math.floor(Math.log10(v));
+    const base = 10 ** exp;
+    const f = v / base;
+    const steps = [1, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10];
+    const nice = steps.find((s) => f <= s + 1e-9) ?? 10;
+    return Number((nice * base).toPrecision(12));
+}
+/**
+ * Two value-axis domains whose zero lines meet (Combo). Each input is a `[min, max]` extent.
+ * Returns domains with the same negative share, so neither axis exaggerates.
+ */
+export function alignZeroDomains(a, b) {
+    const norm = ([lo, hi]) => [Math.min(0, lo), Math.max(0, hi, lo < 0 && hi <= 0 ? 0 : hi)];
+    const [aLo, aHi] = norm(a);
+    const [bLo, bHi] = norm(b);
+    const share = (lo, hi) => (hi - lo === 0 ? 0 : -lo / (hi - lo));
+    const s = Math.max(share(aLo, aHi), share(bLo, bHi));
+    const fit = (lo, hi) => {
+        if (s === 0)
+            return [0, niceStep(hi / 4) * 4 || 1];
+        if (s >= 1)
+            return [lo || -1, 0];
+        const top = Math.max(hi, (-lo * (1 - s)) / s);
+        const bottom = -(top * s) / (1 - s);
+        return [Math.min(lo, bottom), top];
+    };
+    return [fit(aLo, aHi), fit(bLo, bHi)];
+}
+/** Min / max / average of one series (nulls skipped). `null` when the series has no numbers. */
+export function seriesStats(rows, key) {
+    let min = Infinity;
+    let max = -Infinity;
+    let sum = 0;
+    let count = 0;
+    let minIndex = 0;
+    let maxIndex = 0;
+    rows.forEach((row, i) => {
+        const raw = row[key];
+        if (raw === null || raw === undefined)
+            return;
+        const v = Number(raw);
+        if (!Number.isFinite(v))
+            return;
+        if (v < min) {
+            min = v;
+            minIndex = i;
+        }
+        if (v > max) {
+            max = v;
+            maxIndex = i;
+        }
+        sum += v;
+        count++;
+    });
+    if (!count)
+        return null;
+    return { key, min, max, avg: sum / count, minIndex, maxIndex, count };
+}
+/**
+ * A one-paragraph text summary of a chart for screen readers:
+ * "Nov 1 – Nov 30. Visits: low 812 (Nov 3), high 1,402 (Nov 28), average 1,090."
+ */
+export function summarizeSeries(options) {
+    const { f, rows, series, x, xFormat } = options;
+    if (!rows.length)
+        return "";
+    const xText = (i) => (x ? formatCategory(f, xFormat, rows[i]?.[x]) : String(i + 1));
+    const fill = (tpl, vars) => tpl.replace(/\{(\w+)\}/g, (_, k) => vars[k] ?? "");
+    const parts = [];
+    if (x && rows.length > 1)
+        parts.push(fill(options.templates?.range ?? "{from} – {to}.", { from: xText(0), to: xText(rows.length - 1) }));
+    for (const s of series) {
+        const st = seriesStats(rows, s.key);
+        if (!st)
+            continue;
+        const fmt = (v) => formatValue(f, s.format, v);
+        parts.push(fill(options.templates?.series ?? "{label}: low {min} ({minAt}), high {max} ({maxAt}), average {avg}.", {
+            label: s.label,
+            min: fmt(st.min),
+            minAt: xText(st.minIndex),
+            max: fmt(st.max),
+            maxAt: xText(st.maxIndex),
+            avg: fmt(Math.round(st.avg * 100) / 100),
+        }));
+    }
+    return parts.join(" ");
+}
+/** Equal-count (quantile) break points for `steps` buckets. Returns `steps - 1` thresholds. */
+export function quantileBreaks(values, steps) {
+    const sorted = values.filter((v) => Number.isFinite(v) && v > 0).sort((a, b) => a - b);
+    if (!sorted.length)
+        return Array.from({ length: steps - 2 }, () => Infinity);
+    const out = [];
+    // bucket 0 is reserved for zero; the rest split the positive values.
+    for (let i = 1; i < steps - 1; i++) {
+        const q = sorted[Math.min(sorted.length - 1, Math.floor((i / (steps - 1)) * sorted.length))];
+        out.push(q);
+    }
+    return out;
+}

package/dist/components/_qr-core.d.ts

@@ -0,0 +1,26 @@
+export type QrErrorCorrection = "L" | "M" | "Q" | "H";
+export interface QrMatrix {
+    /** Modules per side (version × 4 + 17). */
+    size: number;
+    version: number;
+    mask: number;
+    errorCorrection: QrErrorCorrection;
+    /** `modules[y][x]` — true = dark. */
+    modules: boolean[][];
+}
+/**
+ * Encode text (UTF-8, byte mode) as a QR matrix.
+ * Throws when the text does not fit version 40 at the chosen level.
+ *
+ * ```ts
+ * const qr = encodeQr("otpauth://totp/Northpoint:ada@example.com?secret=…", { errorCorrection: "M" });
+ * qr.size; // 41 (version 6)
+ * ```
+ */
+export declare function encodeQr(text: string, options?: {
+    errorCorrection?: QrErrorCorrection;
+    minVersion?: number;
+    mask?: number;
+}): QrMatrix;
+/** One SVG path (`d`) drawing every dark module, offset by `margin` modules. */
+export declare function qrPath(qr: Pick<QrMatrix, "size" | "modules">, margin?: number): string;

package/dist/components/_qr-core.js

@@ -0,0 +1,376 @@
+// QR Code Model 2 encoder (ISO/IEC 18004), byte mode, versions 1–40, all four error
+// correction levels, automatic mask choice. Pure and dependency-free so it runs in RSC.
+// Follows the structure of the public-domain-style reference algorithm (Nayuki).
+const ECL_INDEX = { L: 0, M: 1, Q: 2, H: 3 };
+const ECL_FORMAT = { L: 1, M: 0, Q: 3, H: 2 };
+// prettier-ignore
+const ECC_CODEWORDS_PER_BLOCK = [
+    [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+    [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+    [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+    [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+];
+// prettier-ignore
+const NUM_ERROR_CORRECTION_BLOCKS = [
+    [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+    [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+    [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+    [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81],
+];
+const bit = (x, i) => ((x >>> i) & 1) !== 0;
+function rawDataModules(ver) {
+    let result = (16 * ver + 128) * ver + 64;
+    if (ver >= 2) {
+        const numAlign = Math.floor(ver / 7) + 2;
+        result -= (25 * numAlign - 10) * numAlign - 55;
+        if (ver >= 7)
+            result -= 36;
+    }
+    return result;
+}
+function dataCodewords(ver, ecl) {
+    const e = ECL_INDEX[ecl];
+    return Math.floor(rawDataModules(ver) / 8) - ECC_CODEWORDS_PER_BLOCK[e][ver] * NUM_ERROR_CORRECTION_BLOCKS[e][ver];
+}
+/* Reed–Solomon over GF(2^8), polynomial 0x11D. */
+function gfMul(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i--) {
+        z = (z << 1) ^ ((z >>> 7) * 0x11d);
+        z ^= ((y >>> i) & 1) * x;
+    }
+    return z & 0xff;
+}
+function rsDivisor(degree) {
+    const result = new Array(degree - 1).fill(0);
+    result.push(1);
+    let root = 1;
+    for (let i = 0; i < degree; i++) {
+        for (let j = 0; j < result.length; j++) {
+            result[j] = gfMul(result[j], root);
+            if (j + 1 < result.length)
+                result[j] ^= result[j + 1];
+        }
+        root = gfMul(root, 0x02);
+    }
+    return result;
+}
+function rsRemainder(data, divisor) {
+    const result = divisor.map(() => 0);
+    for (const b of data) {
+        const factor = b ^ result.shift();
+        result.push(0);
+        divisor.forEach((coef, i) => (result[i] ^= gfMul(coef, factor)));
+    }
+    return result;
+}
+/** UTF-8 bytes without TextEncoder (works everywhere). */
+function utf8(text) {
+    const out = [];
+    for (const ch of text) {
+        const cp = ch.codePointAt(0);
+        if (cp < 0x80)
+            out.push(cp);
+        else if (cp < 0x800)
+            out.push(0xc0 | (cp >> 6), 0x80 | (cp & 63));
+        else if (cp < 0x10000)
+            out.push(0xe0 | (cp >> 12), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
+        else
+            out.push(0xf0 | (cp >> 18), 0x80 | ((cp >> 12) & 63), 0x80 | ((cp >> 6) & 63), 0x80 | (cp & 63));
+    }
+    return out;
+}
+class Grid {
+    version;
+    size;
+    modules;
+    fn;
+    constructor(version) {
+        this.version = version;
+        this.size = version * 4 + 17;
+        this.modules = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+        this.fn = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+    }
+    setFn(x, y, dark) {
+        this.modules[y][x] = dark;
+        this.fn[y][x] = true;
+    }
+    alignmentPositions() {
+        if (this.version === 1)
+            return [];
+        const numAlign = Math.floor(this.version / 7) + 2;
+        const step = Math.floor((this.version * 8 + numAlign * 3 + 5) / (numAlign * 4 - 4)) * 2;
+        const result = [6];
+        for (let pos = this.size - 7; result.length < numAlign; pos -= step)
+            result.splice(1, 0, pos);
+        return result;
+    }
+    drawFunctionPatterns(ecl) {
+        const n = this.size;
+        for (let i = 0; i < n; i++) {
+            this.setFn(6, i, i % 2 === 0);
+            this.setFn(i, 6, i % 2 === 0);
+        }
+        this.finder(3, 3);
+        this.finder(n - 4, 3);
+        this.finder(3, n - 4);
+        const pos = this.alignmentPositions();
+        const k = pos.length;
+        for (let i = 0; i < k; i++)
+            for (let j = 0; j < k; j++) {
+                if ((i === 0 && j === 0) || (i === 0 && j === k - 1) || (i === k - 1 && j === 0))
+                    continue;
+                for (let dy = -2; dy <= 2; dy++)
+                    for (let dx = -2; dx <= 2; dx++)
+                        this.setFn(pos[i] + dx, pos[j] + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+            }
+        this.drawFormat(ecl, 0);
+        this.drawVersion();
+    }
+    finder(x, y) {
+        for (let dy = -4; dy <= 4; dy++)
+            for (let dx = -4; dx <= 4; dx++) {
+                const d = Math.max(Math.abs(dx), Math.abs(dy));
+                const xx = x + dx;
+                const yy = y + dy;
+                if (xx >= 0 && xx < this.size && yy >= 0 && yy < this.size)
+                    this.setFn(xx, yy, d !== 2 && d !== 4);
+            }
+    }
+    drawFormat(ecl, mask) {
+        const data = (ECL_FORMAT[ecl] << 3) | mask;
+        let rem = data;
+        for (let i = 0; i < 10; i++)
+            rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+        const bits = ((data << 10) | rem) ^ 0x5412;
+        const n = this.size;
+        for (let i = 0; i <= 5; i++)
+            this.setFn(8, i, bit(bits, i));
+        this.setFn(8, 7, bit(bits, 6));
+        this.setFn(8, 8, bit(bits, 7));
+        this.setFn(7, 8, bit(bits, 8));
+        for (let i = 9; i < 15; i++)
+            this.setFn(14 - i, 8, bit(bits, i));
+        for (let i = 0; i < 8; i++)
+            this.setFn(n - 1 - i, 8, bit(bits, i));
+        for (let i = 8; i < 15; i++)
+            this.setFn(8, n - 15 + i, bit(bits, i));
+        this.setFn(8, n - 8, true);
+    }
+    drawVersion() {
+        if (this.version < 7)
+            return;
+        let rem = this.version;
+        for (let i = 0; i < 12; i++)
+            rem = (rem << 1) ^ ((rem >>> 11) * 0x1f25);
+        const bits = (this.version << 12) | rem;
+        for (let i = 0; i < 18; i++) {
+            const b = bit(bits, i);
+            const a = this.size - 11 + (i % 3);
+            const c = Math.floor(i / 3);
+            this.setFn(a, c, b);
+            this.setFn(c, a, b);
+        }
+    }
+    drawCodewords(data) {
+        let i = 0;
+        const n = this.size;
+        for (let right = n - 1; right >= 1; right -= 2) {
+            if (right === 6)
+                right = 5;
+            for (let vert = 0; vert < n; vert++)
+                for (let j = 0; j < 2; j++) {
+                    const x = right - j;
+                    const upward = ((right + 1) & 2) === 0;
+                    const y = upward ? n - 1 - vert : vert;
+                    if (!this.fn[y][x] && i < data.length * 8) {
+                        this.modules[y][x] = bit(data[i >>> 3], 7 - (i & 7));
+                        i++;
+                    }
+                }
+        }
+    }
+    applyMask(mask) {
+        for (let y = 0; y < this.size; y++)
+            for (let x = 0; x < this.size; x++) {
+                let invert;
+                switch (mask) {
+                    case 0:
+                        invert = (x + y) % 2 === 0;
+                        break;
+                    case 1:
+                        invert = y % 2 === 0;
+                        break;
+                    case 2:
+                        invert = x % 3 === 0;
+                        break;
+                    case 3:
+                        invert = (x + y) % 3 === 0;
+                        break;
+                    case 4:
+                        invert = (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0;
+                        break;
+                    case 5:
+                        invert = ((x * y) % 2) + ((x * y) % 3) === 0;
+                        break;
+                    case 6:
+                        invert = (((x * y) % 2) + ((x * y) % 3)) % 2 === 0;
+                        break;
+                    default: invert = (((x + y) % 2) + ((x * y) % 3)) % 2 === 0;
+                }
+                if (!this.fn[y][x] && invert)
+                    this.modules[y][x] = !this.modules[y][x];
+            }
+    }
+    penalty() {
+        const n = this.size;
+        const m = this.modules;
+        let score = 0;
+        const line = (get) => {
+            let run = 1;
+            let s = 0;
+            for (let i = 1; i <= n; i++) {
+                if (i < n && get(i) === get(i - 1))
+                    run++;
+                else {
+                    if (run >= 5)
+                        s += 3 + (run - 5);
+                    run = 1;
+                }
+            }
+            // Finder-like 1:1:3:1:1 with four light modules on one side.
+            for (let i = 0; i + 10 < n + 4; i++) {
+                const at = (k) => (k < 0 || k >= n ? false : get(k));
+                const core = at(i) && !at(i + 1) && at(i + 2) && at(i + 3) && at(i + 4) && !at(i + 5) && at(i + 6);
+                if (!core)
+                    continue;
+                const before = !at(i - 1) && !at(i - 2) && !at(i - 3) && !at(i - 4);
+                const after = !at(i + 7) && !at(i + 8) && !at(i + 9) && !at(i + 10);
+                if (before || after)
+                    s += 40;
+            }
+            return s;
+        };
+        for (let y = 0; y < n; y++)
+            score += line((x) => m[y][x]);
+        for (let x = 0; x < n; x++)
+            score += line((y) => m[y][x]);
+        for (let y = 0; y < n - 1; y++)
+            for (let x = 0; x < n - 1; x++) {
+                const c = m[y][x];
+                if (c === m[y][x + 1] && c === m[y + 1][x] && c === m[y + 1][x + 1])
+                    score += 3;
+            }
+        let dark = 0;
+        for (const row of m)
+            for (const c of row)
+                if (c)
+                    dark++;
+        const total = n * n;
+        score += (Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1) * 10;
+        return score;
+    }
+}
+/**
+ * Encode text (UTF-8, byte mode) as a QR matrix.
+ * Throws when the text does not fit version 40 at the chosen level.
+ *
+ * ```ts
+ * const qr = encodeQr("otpauth://totp/Northpoint:ada@example.com?secret=…", { errorCorrection: "M" });
+ * qr.size; // 41 (version 6)
+ * ```
+ */
+export function encodeQr(text, options = {}) {
+    const ecl = options.errorCorrection ?? "M";
+    const bytes = utf8(text);
+    let version = Math.max(1, Math.min(40, options.minVersion ?? 1));
+    let capacityBits = 0;
+    for (;; version++) {
+        if (version > 40)
+            throw new RangeError("QR: text is too long to encode");
+        const ccBits = version < 10 ? 8 : 16;
+        capacityBits = dataCodewords(version, ecl) * 8;
+        if (4 + ccBits + bytes.length * 8 <= capacityBits)
+            break;
+    }
+    // Bit stream: mode (byte = 0100), length, data, terminator, padding.
+    const bits = [];
+    const push = (value, len) => {
+        for (let i = len - 1; i >= 0; i--)
+            bits.push((value >>> i) & 1);
+    };
+    push(0b0100, 4);
+    push(bytes.length, version < 10 ? 8 : 16);
+    for (const b of bytes)
+        push(b, 8);
+    push(0, Math.min(4, capacityBits - bits.length));
+    push(0, (8 - (bits.length % 8)) % 8);
+    for (let pad = 0xec; bits.length < capacityBits; pad ^= 0xec ^ 0x11)
+        push(pad, 8);
+    const data = [];
+    for (let i = 0; i < bits.length; i += 8)
+        data.push(bits.slice(i, i + 8).reduce((acc, b) => (acc << 1) | b, 0));
+    // Error correction + interleave.
+    const e = ECL_INDEX[ecl];
+    const numBlocks = NUM_ERROR_CORRECTION_BLOCKS[e][version];
+    const eccLen = ECC_CODEWORDS_PER_BLOCK[e][version];
+    const rawCodewords = Math.floor(rawDataModules(version) / 8);
+    const numShort = numBlocks - (rawCodewords % numBlocks);
+    const shortLen = Math.floor(rawCodewords / numBlocks);
+    const divisor = rsDivisor(eccLen);
+    const blocks = [];
+    for (let i = 0, k = 0; i < numBlocks; i++) {
+        const dat = data.slice(k, k + shortLen - eccLen + (i < numShort ? 0 : 1));
+        k += dat.length;
+        const ecc = rsRemainder(dat, divisor);
+        if (i < numShort)
+            dat.push(0);
+        blocks.push(dat.concat(ecc));
+    }
+    const codewords = [];
+    for (let i = 0; i < blocks[0].length; i++)
+        blocks.forEach((block, j) => {
+            if (i !== shortLen - eccLen || j >= numShort)
+                codewords.push(block[i]);
+        });
+    // Place, then pick the mask with the lowest penalty.
+    const grid = new Grid(version);
+    grid.drawFunctionPatterns(ecl);
+    grid.drawCodewords(codewords);
+    let mask = options.mask ?? -1;
+    if (mask < 0 || mask > 7) {
+        let best = Infinity;
+        for (let candidate = 0; candidate < 8; candidate++) {
+            grid.applyMask(candidate);
+            grid.drawFormat(ecl, candidate);
+            const p = grid.penalty();
+            if (p < best) {
+                best = p;
+                mask = candidate;
+            }
+            grid.applyMask(candidate); // undo (XOR)
+        }
+    }
+    grid.applyMask(mask);
+    grid.drawFormat(ecl, mask);
+    return { size: grid.size, version, mask, errorCorrection: ecl, modules: grid.modules };
+}
+/** One SVG path (`d`) drawing every dark module, offset by `margin` modules. */
+export function qrPath(qr, margin = 0) {
+    let d = "";
+    for (let y = 0; y < qr.size; y++) {
+        let x = 0;
+        while (x < qr.size) {
+            if (!qr.modules[y][x]) {
+                x++;
+                continue;
+            }
+            let run = 1;
+            while (x + run < qr.size && qr.modules[y][x + run])
+                run++;
+            d += `M${x + margin} ${y + margin}h${run}v1h-${run}z`;
+            x += run;
+        }
+    }
+    return d;
+}