@forgesworn/qr 0.0.0-seed.0

package/dist/locate.js

@@ -0,0 +1,489 @@
+const dark = (image, x, y) => image.data[y * image.width + x] === 1;
+function distance(a, b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+}
+/** Runs in 1:1:3:1:1 proportion, each within half a module (the centre within 1.5). */
+function finderRatio(counts, tolerance = 0.5) {
+    let total = 0;
+    for (const c of counts) {
+        if (c === 0)
+            return false;
+        total += c;
+    }
+    if (total < 7)
+        return false;
+    const module = total / 7;
+    const slack = module * tolerance;
+    return (Math.abs(module - counts[0]) < slack &&
+        Math.abs(module - counts[1]) < slack &&
+        Math.abs(3 * module - counts[2]) < 3 * slack &&
+        Math.abs(module - counts[3]) < slack &&
+        Math.abs(module - counts[4]) < slack);
+}
+const centreFromEnd = (counts, end) => end - counts[4] - counts[3] - counts[2] / 2;
+/**
+ * Counts the five runs through (x, y) along direction (dx, dy), starting in
+ * the dark centre, and returns the centre along that line, or NaN.
+ */
+function crossCheck(image, x, y, dx, dy, maxCount, originalTotal, tolerance = 0.5) {
+    const { width, height } = image;
+    const inside = (px, py) => px >= 0 && py >= 0 && px < width && py < height;
+    const counts = [0, 0, 0, 0, 0];
+    let px = x;
+    let py = y;
+    while (inside(px, py) && dark(image, px, py)) {
+        counts[2]++;
+        px -= dx;
+        py -= dy;
+    }
+    while (inside(px, py) && !dark(image, px, py) && counts[1] <= maxCount) {
+        counts[1]++;
+        px -= dx;
+        py -= dy;
+    }
+    if (!inside(px, py) || counts[1] > maxCount)
+        return NaN;
+    while (inside(px, py) && dark(image, px, py) && counts[0] <= maxCount) {
+        counts[0]++;
+        px -= dx;
+        py -= dy;
+    }
+    if (counts[0] > maxCount)
+        return NaN;
+    px = x + dx;
+    py = y + dy;
+    while (inside(px, py) && dark(image, px, py)) {
+        counts[2]++;
+        px += dx;
+        py += dy;
+    }
+    while (inside(px, py) && !dark(image, px, py) && counts[3] < maxCount) {
+        counts[3]++;
+        px += dx;
+        py += dy;
+    }
+    if (!inside(px, py) || counts[3] >= maxCount)
+        return NaN;
+    while (inside(px, py) && dark(image, px, py) && counts[4] < maxCount) {
+        counts[4]++;
+        px += dx;
+        py += dy;
+    }
+    if (counts[4] >= maxCount)
+        return NaN;
+    const total = counts.reduce((a, b) => a + b, 0);
+    // A diagonal crosses the pattern at a longer stretch, so only straight lines compare totals.
+    if (!(dx && dy) && 5 * Math.abs(total - originalTotal) >= 2 * originalTotal)
+        return NaN;
+    if (!finderRatio(counts, tolerance))
+        return NaN;
+    // Position along the line, measured in steps from the start point.
+    const end = dx !== 0 ? px - x : py - y;
+    return centreFromEnd(counts, end * (dx + dy > 0 ? 1 : -1));
+}
+/**
+ * Finds finder pattern candidates, most often confirmed first. `tolerance`
+ * is how far a run may stray from its share, in modules; a blurred light
+ * ring needs more than the default half module.
+ */
+export function findFinders(image, tolerance = 0.5) {
+    const { width, height } = image;
+    const found = [];
+    const consider = (counts, row, end) => {
+        const total = counts.reduce((a, b) => a + b, 0);
+        let cx = centreFromEnd(counts, end);
+        const maxCount = counts[2];
+        const dy = crossCheck(image, Math.floor(cx), row, 0, 1, maxCount, total, tolerance);
+        if (Number.isNaN(dy))
+            return false;
+        const cy = row + dy;
+        const dx = crossCheck(image, Math.floor(cx), Math.floor(cy), 1, 0, maxCount, total, tolerance);
+        if (Number.isNaN(dx))
+            return false;
+        cx = Math.floor(cx) + dx;
+        const diagonal = crossCheck(image, Math.floor(cx), Math.floor(cy), 1, 1, maxCount * 2, total, tolerance + 0.25);
+        if (Number.isNaN(diagonal))
+            return false;
+        const moduleSize = total / 7;
+        for (const f of found) {
+            if (Math.abs(cy - f.y) <= moduleSize &&
+                Math.abs(cx - f.x) <= moduleSize &&
+                (Math.abs(moduleSize - f.moduleSize) <= 1 || Math.abs(moduleSize - f.moduleSize) <= f.moduleSize * 0.25)) {
+                const n = f.count + 1;
+                f.x = (f.x * f.count + cx) / n;
+                f.y = (f.y * f.count + cy) / n;
+                f.moduleSize = (f.moduleSize * f.count + moduleSize) / n;
+                f.count = n;
+                return true;
+            }
+        }
+        found.push({ x: cx, y: cy, moduleSize, count: 1 });
+        return true;
+    };
+    const skip = Math.max(1, Math.min(3, Math.floor(height / 200)));
+    for (let y = skip - 1; y < height; y += skip) {
+        const counts = [0, 0, 0, 0, 0];
+        let state = 0;
+        const row = y * width;
+        for (let x = 0; x < width; x++) {
+            if (image.data[row + x] === 1) {
+                if (state & 1)
+                    state++;
+                counts[state]++;
+            }
+            else if (state & 1) {
+                counts[state]++;
+            }
+            else if (state === 4) {
+                if (finderRatio(counts, tolerance) && consider(counts, y, x)) {
+                    counts.fill(0);
+                    state = 0;
+                }
+                else {
+                    counts.copyWithin(0, 2);
+                    counts[3] = 1;
+                    counts[4] = 0;
+                    state = 3;
+                }
+            }
+            else {
+                state++;
+                counts[state]++;
+            }
+        }
+        if (state === 4 && finderRatio(counts, tolerance))
+            consider(counts, y, width);
+    }
+    return found.sort((a, b) => b.count - a.count);
+}
+/**
+ * Every plausible top-left, top-right, bottom-left triple, best first: the
+ * three should form a right-angled isosceles triangle of like-sized finders.
+ */
+export function finderTriples(finders) {
+    const pool = finders.slice(0, 12);
+    const triples = [];
+    for (let i = 0; i < pool.length; i++) {
+        for (let j = i + 1; j < pool.length; j++) {
+            for (let k = j + 1; k < pool.length; k++) {
+                const a = pool[i];
+                const b = pool[j];
+                const c = pool[k];
+                const sizes = [a.moduleSize, b.moduleSize, c.moduleSize];
+                if (Math.max(...sizes) > 2 * Math.min(...sizes))
+                    continue;
+                const ab = distance(a, b) ** 2;
+                const bc = distance(b, c) ** 2;
+                const ca = distance(c, a) ** 2;
+                // The corner opposite the longest side is the top-left.
+                let topLeft = c;
+                let p = a;
+                let q = b;
+                let hyp = ab;
+                let s1 = bc;
+                let s2 = ca;
+                if (bc >= ab && bc >= ca)
+                    [topLeft, p, q, hyp, s1, s2] = [a, b, c, bc, ab, ca];
+                else if (ca >= ab)
+                    [topLeft, p, q, hyp, s1, s2] = [b, c, a, ca, ab, bc];
+                const side = Math.sqrt((s1 + s2) / 2);
+                if (side < 10 * Math.min(...sizes))
+                    continue;
+                const score = (Math.abs(hyp - s1 - s2) + Math.abs(s1 - s2)) / hyp;
+                if (score > 0.5)
+                    continue;
+                // In picture coordinates (y down) top-right x bottom-left is positive.
+                const cross = (p.x - topLeft.x) * (q.y - topLeft.y) - (p.y - topLeft.y) * (q.x - topLeft.x);
+                if (cross < 0)
+                    [p, q] = [q, p];
+                triples.push({ score: score - 0.01 * Math.min(a.count + b.count + c.count, 15), triple: [topLeft, p, q] });
+            }
+        }
+    }
+    return triples.sort((x, y) => x.score - y.score).map((t) => t.triple);
+}
+/** Module size along a line from one finder centre to another, by its black-white-black runs. */
+function runModuleSize(image, from, to) {
+    const one = blackWhiteBlack(image, from, to);
+    const other = blackWhiteBlack(image, to, from);
+    if (Number.isNaN(one))
+        return other / 7;
+    if (Number.isNaN(other))
+        return one / 7;
+    return (one + other) / 14;
+}
+/** Length of the dark-light-dark run from a finder centre outwards, through and beyond the finder edge. */
+function blackWhiteBlack(image, from, to) {
+    const run = (sx, sy, tx, ty) => {
+        const steep = Math.abs(ty - sy) > Math.abs(tx - sx);
+        if (steep)
+            [sx, sy, tx, ty] = [sy, sx, ty, tx];
+        const dx = Math.abs(tx - sx);
+        const dy = Math.abs(ty - sy);
+        let error = -dx / 2;
+        const xstep = sx < tx ? 1 : -1;
+        const ystep = sy < ty ? 1 : -1;
+        let state = 0;
+        let y = sy;
+        for (let x = sx; x !== tx + xstep; x += xstep) {
+            const rx = steep ? y : x;
+            const ry = steep ? x : y;
+            if (rx < 0 || ry < 0 || rx >= image.width || ry >= image.height)
+                break;
+            if ((state === 1) === dark(image, rx, ry)) {
+                if (state === 2)
+                    return Math.hypot(x - sx, y - sy);
+                state++;
+            }
+            error += dy;
+            if (error > 0) {
+                if (y === ty)
+                    break;
+                y += ystep;
+                error -= dx;
+            }
+        }
+        return state === 2 ? Math.hypot(tx + xstep - sx, ty - sy) : NaN;
+    };
+    const sx = Math.floor(from.x);
+    const sy = Math.floor(from.y);
+    const forward = run(sx, sy, Math.floor(to.x), Math.floor(to.y));
+    // The same distance the other way, clipped to the picture.
+    let ox = sx - (Math.floor(to.x) - sx);
+    let oy = sy - (Math.floor(to.y) - sy);
+    let scale = 1;
+    if (ox < 0)
+        scale = Math.min(scale, sx / (sx - ox));
+    else if (ox >= image.width)
+        scale = Math.min(scale, (image.width - 1 - sx) / (ox - sx));
+    if (oy < 0)
+        scale = Math.min(scale, sy / (sy - oy));
+    else if (oy >= image.height)
+        scale = Math.min(scale, (image.height - 1 - sy) / (oy - sy));
+    ox = Math.floor(sx + (ox - sx) * scale);
+    oy = Math.floor(sy + (oy - sy) * scale);
+    const backward = run(sx, sy, ox, oy);
+    if (Number.isNaN(forward) || Number.isNaN(backward))
+        return NaN;
+    return forward + backward - 1;
+}
+/**
+ * Searches near `estimate` for alignment pattern centres. Candidates seen on
+ * two or more rows come first, then nearest the estimate.
+ */
+function findAlignments(image, estimate, moduleSize, reach) {
+    const radius = Math.ceil(reach * moduleSize);
+    const left = Math.max(0, Math.floor(estimate.x - radius));
+    const right = Math.min(image.width - 1, Math.ceil(estimate.x + radius));
+    const top = Math.max(0, Math.floor(estimate.y - radius));
+    const bottom = Math.min(image.height - 1, Math.ceil(estimate.y + radius));
+    if (right - left < moduleSize * 3 || bottom - top < moduleSize * 3)
+        return [];
+    const fits = (n) => Math.abs(n - moduleSize) < moduleSize * 0.6;
+    const vertical = (x, y) => {
+        // Light, dark, light runs through (x, y) going up and down from the dark centre.
+        let up = y;
+        while (up >= top && dark(image, x, up))
+            up--;
+        let down = y;
+        while (down <= bottom && dark(image, x, down))
+            down++;
+        const middle = down - up - 1;
+        if (!fits(middle))
+            return NaN;
+        let above = 0;
+        for (let yy = up; yy >= top && !dark(image, x, yy); yy--)
+            above++;
+        let below = 0;
+        for (let yy = down; yy <= bottom && !dark(image, x, yy); yy++)
+            below++;
+        if (!fits(above) || !fits(below))
+            return NaN;
+        return (up + 1 + down) / 2;
+    };
+    const found = [];
+    for (let y = top; y <= bottom; y++) {
+        const runs = [];
+        let x = left;
+        while (x <= right && dark(image, x, y))
+            x++; // skip a dark run cut by the window
+        let start = x;
+        let current = false;
+        for (; x <= right + 1; x++) {
+            const d = x <= right && dark(image, x, y);
+            if (x <= right && d === current)
+                continue;
+            runs.push(x - start);
+            start = x;
+            current = d;
+            // runs alternate light, dark, light ... ; check the last three when they end in light
+            if (runs.length >= 3 && runs.length % 2 === 1) {
+                const [l1, d1, l2] = runs.slice(-3);
+                if (fits(l1) && fits(d1) && fits(l2)) {
+                    const cx = x - l2 - d1 / 2;
+                    const cy = vertical(Math.floor(cx), y);
+                    if (!Number.isNaN(cy)) {
+                        const same = found.find((f) => Math.abs(f.x - cx) <= moduleSize && Math.abs(f.y - cy) <= moduleSize);
+                        if (same) {
+                            same.x = (same.x * same.count + cx) / (same.count + 1);
+                            same.y = (same.y * same.count + cy) / (same.count + 1);
+                            same.count++;
+                        }
+                        else {
+                            found.push({ x: cx, y: cy, count: 1 });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // A candidate seen on one row only counts as three modules further away.
+    const score = (f) => distance(f, estimate) / moduleSize + (f.count >= 2 ? 0 : 3);
+    return found.sort((p, q) => score(p) - score(q)).map(({ x, y }) => ({ x, y }));
+}
+/** A projective map from the unit square's corners to four picture points. */
+function squareToQuad(p0, p1, p2, p3) {
+    const dx3 = p0.x - p1.x + p2.x - p3.x;
+    const dy3 = p0.y - p1.y + p2.y - p3.y;
+    if (dx3 === 0 && dy3 === 0) {
+        return [p1.x - p0.x, p2.x - p1.x, p0.x, p1.y - p0.y, p2.y - p1.y, p0.y, 0, 0, 1];
+    }
+    const dx1 = p1.x - p2.x;
+    const dx2 = p3.x - p2.x;
+    const dy1 = p1.y - p2.y;
+    const dy2 = p3.y - p2.y;
+    const den = dx1 * dy2 - dx2 * dy1;
+    const a13 = (dx3 * dy2 - dx2 * dy3) / den;
+    const a23 = (dx1 * dy3 - dx3 * dy1) / den;
+    return [
+        p1.x - p0.x + a13 * p1.x, p3.x - p0.x + a23 * p3.x, p0.x,
+        p1.y - p0.y + a13 * p1.y, p3.y - p0.y + a23 * p3.y, p0.y,
+        a13, a23, 1,
+    ];
+}
+function adjoint(m) {
+    const [a, b, c, d, e, f, g, h, i] = m;
+    return [e * i - f * h, c * h - b * i, b * f - c * e, f * g - d * i, a * i - c * g, c * d - a * f, d * h - e * g, b * g - a * h, a * e - b * d];
+}
+function multiply(m, n) {
+    const out = [];
+    for (let r = 0; r < 3; r++) {
+        for (let c = 0; c < 3; c++)
+            out.push(m[r * 3] * n[c] + m[r * 3 + 1] * n[3 + c] + m[r * 3 + 2] * n[6 + c]);
+    }
+    return out;
+}
+/** The map taking four module-space points to four picture points. */
+function quadToQuad(from, to) {
+    const toPicture = squareToQuad(to[0], to[1], to[2], to[3]);
+    const fromModules = adjoint(squareToQuad(from[0], from[1], from[2], from[3]));
+    // Column-vector convention: picture = toPicture · fromModules⁻¹ · module.
+    const m = multiply(toPicture, fromModules);
+    return (x, y) => {
+        const w = m[6] * x + m[7] * y + m[8];
+        return { x: (m[0] * x + m[1] * y + m[2]) / w, y: (m[3] * x + m[4] * y + m[5]) / w };
+    };
+}
+/**
+ * Out of 25, how many modules around `centre` match an alignment pattern
+ * (dark centre, light ring, dark ring), stepping by `u` across and `v` down.
+ * Perspective changes the local module size, so three scales are tried.
+ */
+function alignmentScore(image, centre, u, v) {
+    let best = 0;
+    for (const scale of [0.85, 1, 1.15]) {
+        let score = 0;
+        for (let j = -2; j <= 2; j++) {
+            for (let i = -2; i <= 2; i++) {
+                const x = Math.floor(centre.x + (i * u.x + j * v.x) * scale);
+                const y = Math.floor(centre.y + (i * u.y + j * v.y) * scale);
+                const want = Math.max(Math.abs(i), Math.abs(j)) !== 1;
+                const got = x >= 0 && y >= 0 && x < image.width && y < image.height && dark(image, x, y);
+                if (got === want)
+                    score++;
+            }
+        }
+        best = Math.max(best, score);
+    }
+    return best;
+}
+/**
+ * Turns three finders into sampling maps: one through each likely alignment
+ * pattern (when the version has one), then one through the parallelogram's
+ * fourth corner. `sizeHint` overrides the estimated module count.
+ */
+export function locate(image, triple, sizeHint) {
+    const [topLeft, topRight, bottomLeft] = triple;
+    const moduleSize = (runModuleSize(image, topLeft, topRight) + runModuleSize(image, topLeft, bottomLeft)) / 2;
+    if (!(moduleSize >= 1))
+        return [];
+    let size = sizeHint;
+    if (size === undefined) {
+        size = Math.round((distance(topLeft, topRight) + distance(topLeft, bottomLeft)) / 2 / moduleSize) + 7;
+        switch (size & 3) {
+            case 0:
+                size++;
+                break;
+            case 2:
+                size--;
+                break;
+            case 3:
+                size -= 2;
+                break;
+        }
+    }
+    if (size < 21 || size > 177)
+        return [];
+    const corner = { x: topRight.x - topLeft.x + bottomLeft.x, y: topRight.y - topLeft.y + bottomLeft.y };
+    let alignments = [];
+    if (size > 21) {
+        // Two guesses at the fourth corner: the parallelogram's, and one that
+        // follows perspective, where modules grow towards the nearer edge.
+        const tl = topLeft.moduleSize;
+        const down = bottomLeft.moduleSize / tl;
+        const right = topRight.moduleSize / tl;
+        const scaled = {
+            x: (bottomLeft.x + (topRight.x - topLeft.x) * down + topRight.x + (bottomLeft.x - topLeft.x) * right) / 2,
+            y: (bottomLeft.y + (topRight.y - topLeft.y) * down + topRight.y + (bottomLeft.y - topLeft.y) * right) / 2,
+        };
+        const correction = 1 - 3 / (size - 7);
+        const estimates = [corner, scaled].map((c) => ({
+            x: topLeft.x + correction * (c.x - topLeft.x),
+            y: topLeft.y + correction * (c.y - topLeft.y),
+        }));
+        // A row or column crosses a turned module on the slant: at 45 degrees a
+        // module's run is the diagonal, root 2 times its side.
+        const across = distance(topLeft, topRight);
+        const slant = Math.max(Math.abs(topRight.x - topLeft.x), Math.abs(topRight.y - topLeft.y)) / across;
+        const runSize = moduleSize / slant;
+        // Rank candidates by how well the 5x5 pattern around them matches, read
+        // along the code's own axes, then by nearness to a guess.
+        const steps = size - 7;
+        const u = { x: (topRight.x - topLeft.x) / steps, y: (topRight.y - topLeft.y) / steps };
+        const v = { x: (bottomLeft.x - topLeft.x) / steps, y: (bottomLeft.y - topLeft.y) / steps };
+        const near = (p) => Math.min(...estimates.map((e) => distance(p, e)));
+        const scored = [];
+        for (const reach of [4, 8, 16]) {
+            for (const estimate of estimates) {
+                for (const p of findAlignments(image, estimate, runSize, reach)) {
+                    if (scored.some((a) => distance(a.p, p) <= moduleSize / 2))
+                        continue;
+                    scored.push({ p, score: alignmentScore(image, p, u, v), away: near(p) });
+                }
+            }
+            if (scored.some((c) => c.score >= 23))
+                break;
+        }
+        alignments = scored
+            .filter((c) => c.score >= 20)
+            .sort((a, b) => b.score - a.score || a.away - b.away)
+            .slice(0, 4)
+            .map((c) => c.p);
+    }
+    const far = size - 3.5;
+    const map = (alignment) => {
+        const project = quadToQuad([{ x: 3.5, y: 3.5 }, { x: far, y: 3.5 }, alignment ? { x: size - 6.5, y: size - 6.5 } : { x: far, y: far }, { x: 3.5, y: far }], [topLeft, topRight, alignment ?? corner, bottomLeft]);
+        return { topLeft, topRight, bottomLeft, alignment, size, project: (x, y) => project(x + 0.5, y + 0.5) };
+    };
+    return [...alignments.map(map), map(undefined)];
+}

package/dist/rs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Corrects `block` (data codewords then `ecCount` check codewords) in place.
+ * Returns the number of codewords corrected, or -1 when the block has more
+ * errors than the code can correct.
+ */
+export declare function correct(block: Uint8Array, ecCount: number): number;

package/dist/rs.js

@@ -0,0 +1,99 @@
+import { EXP, gfMul, LOG } from './encode.js';
+// Reed-Solomon error correction for QR codes: GF(256) with 0x11D, generator
+// roots α^0 .. α^(ecCount - 1). Polynomials here are lowest power first,
+// except `block`, which is a received codeword block, highest power first.
+function gfDiv(a, b) {
+    if (b === 0)
+        throw new RangeError('Division by zero in GF(256)');
+    return a === 0 ? 0 : EXP[(LOG[a] + 255 - LOG[b]) % 255];
+}
+function evaluate(poly, x) {
+    let y = 0;
+    for (let i = poly.length - 1; i >= 0; i--)
+        y = gfMul(y, x) ^ poly[i];
+    return y;
+}
+/**
+ * Corrects `block` (data codewords then `ecCount` check codewords) in place.
+ * Returns the number of codewords corrected, or -1 when the block has more
+ * errors than the code can correct.
+ */
+export function correct(block, ecCount) {
+    const n = block.length;
+    const syndromes = [];
+    let clean = true;
+    for (let j = 0; j < ecCount; j++) {
+        let s = 0;
+        const x = EXP[j];
+        for (let i = 0; i < n; i++)
+            s = gfMul(s, x) ^ block[i];
+        syndromes.push(s);
+        if (s !== 0)
+            clean = false;
+    }
+    if (clean)
+        return 0;
+    // Berlekamp-Massey: the error locator Λ.
+    let locator = [1];
+    let previous = [1];
+    let errors = 0;
+    let shift = 1;
+    let lastDiscrepancy = 1;
+    for (let k = 0; k < ecCount; k++) {
+        let d = syndromes[k];
+        for (let i = 1; i <= errors; i++)
+            d ^= gfMul(locator[i] ?? 0, syndromes[k - i]);
+        if (d === 0) {
+            shift++;
+            continue;
+        }
+        const factor = gfDiv(d, lastDiscrepancy);
+        const next = locator.slice();
+        for (let i = 0; i < previous.length; i++) {
+            const at = i + shift;
+            while (next.length <= at)
+                next.push(0);
+            next[at] ^= gfMul(factor, previous[i]);
+        }
+        if (2 * errors <= k) {
+            previous = locator;
+            errors = k + 1 - errors;
+            lastDiscrepancy = d;
+            shift = 1;
+        }
+        else {
+            shift++;
+        }
+        locator = next;
+    }
+    while (locator.length > 1 && locator[locator.length - 1] === 0)
+        locator.pop();
+    if (errors * 2 > ecCount || locator.length - 1 !== errors)
+        return -1;
+    // Chien search: a root at α^-p marks an error at power p, index n - 1 - p.
+    const powers = [];
+    for (let p = 0; p < n; p++) {
+        if (evaluate(locator, EXP[(255 - p) % 255]) === 0)
+            powers.push(p);
+    }
+    if (powers.length !== errors)
+        return -1;
+    // Forney: Ω = S·Λ mod x^ecCount; e = X·Ω(X⁻¹) / Λ'(X⁻¹) for first root α^0.
+    const omega = new Array(ecCount).fill(0);
+    for (let i = 0; i < ecCount; i++) {
+        for (let j = 0; j < locator.length && i + j < ecCount; j++)
+            omega[i + j] ^= gfMul(syndromes[i], locator[j]);
+    }
+    const derivative = [];
+    for (let i = 1; i < locator.length; i++)
+        derivative.push(i % 2 === 1 ? locator[i] : 0);
+    for (const p of powers) {
+        const x = EXP[p % 255];
+        const xInverse = EXP[(255 - p) % 255];
+        const denominator = evaluate(derivative, xInverse);
+        if (denominator === 0)
+            return -1;
+        block[n - 1 - p] ^= gfMul(x, gfDiv(evaluate(omega, xInverse), denominator));
+    }
+    return errors;
+}

package/dist/svg.d.ts

@@ -0,0 +1,17 @@
+import { type QrCode } from './encode.js';
+export interface SvgOptions {
+    /** Quiet zone in modules on every side. Default 4, the standard's minimum. */
+    margin?: number;
+    /** Colour of dark modules. Default `'#000'`. */
+    dark?: string;
+    /** Background colour, or `null` for none. Default `'#fff'`. */
+    light?: string | null;
+    /** Accessible name, written as the SVG `<title>`. */
+    title?: string;
+}
+/**
+ * Renders a code as a standalone SVG document, one module per user unit and
+ * one path for all dark modules. Size it with CSS or `width`/`height`; the
+ * viewBox keeps it square.
+ */
+export declare function toSvg(qr: QrCode, options?: SvgOptions): string;

package/dist/svg.js

@@ -0,0 +1,35 @@
+/**
+ * Renders a code as a standalone SVG document, one module per user unit and
+ * one path for all dark modules. Size it with CSS or `width`/`height`; the
+ * viewBox keeps it square.
+ */
+export function toSvg(qr, options = {}) {
+    const margin = options.margin ?? 4;
+    if (!Number.isInteger(margin) || margin < 0)
+        throw new RangeError('Margin must be a whole number of modules');
+    const dark = escape(options.dark ?? '#000');
+    const light = options.light === undefined ? '#fff' : options.light;
+    const side = qr.size + margin * 2;
+    let path = '';
+    for (let y = 0; y < qr.size; y++) {
+        let x = 0;
+        while (x < qr.size) {
+            if (qr.modules[y * qr.size + x] !== 1) {
+                x++;
+                continue;
+            }
+            const start = x;
+            while (x < qr.size && qr.modules[y * qr.size + x] === 1)
+                x++;
+            path += `M${start + margin} ${y + margin}h${x - start}v1h${start - x}z`;
+        }
+    }
+    const title = options.title === undefined ? '' : `<title>${escape(options.title)}</title>`;
+    const background = light === null ? '' : `<rect width="${side}" height="${side}" fill="${escape(light)}"/>`;
+    const role = options.title === undefined ? '' : ' role="img"';
+    return (`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${side} ${side}" shape-rendering="crispEdges"${role}>` +
+        `${title}${background}<path fill="${dark}" d="${path}"/></svg>`);
+}
+function escape(text) {
+    return text.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+}

package/dist/symbol.d.ts

@@ -0,0 +1,25 @@
+import { type ErrorCorrection } from './encode.js';
+/** What a symbol says, once read. */
+export interface Payload {
+    /** The decoded text. */
+    readonly text: string;
+    /** The payload as bytes: byte-mode data as stored, numeric and alphanumeric as ASCII. */
+    readonly bytes: Uint8Array;
+    readonly version: number;
+    readonly ecc: ErrorCorrection;
+    readonly mask: number;
+    /** ECI assignment numbers in the order they appeared; empty if none. */
+    readonly eci: readonly number[];
+    /** Codewords Reed-Solomon had to correct. */
+    readonly corrected: number;
+}
+/** Reads modules through a callback: true for dark, x across, y down. */
+export type ModuleReader = (x: number, y: number) => boolean;
+/** The version a symbol of `size` modules declares, when its version blocks can be read. */
+export declare function readVersion(read: ModuleReader, size: number): number | undefined;
+/**
+ * Decodes a symbol from its modules. `size` must be 17 + 4v; for version 7
+ * and up the version blocks decide, and a size that disagrees fails.
+ * Returns undefined when the symbol cannot be read.
+ */
+export declare function readSymbol(read: ModuleReader, size: number): Payload | undefined;