@scanmate/image-fix 0.0.3

package/dist/index.esm.js

@@ -0,0 +1,2786 @@
+import { decode, encode } from 'jpeg-js';
+import { PNG } from 'pngjs';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+/**
+ * How well two ink images actually overlap.
+ *
+ * Every stage of the pipeline proposes a transform; this is the referee. It
+ * has to be a *correlation*, not a difference: the scan is darker, or fainter,
+ * or contrast-stretched by the scanner's own firmware, and a sum of absolute
+ * differences would rank a badly aligned pale scan above a well aligned dark
+ * one. Zero-mean normalised cross correlation is invariant to both of those —
+ * it only asks whether the ink rises and falls in the same places.
+ */ /** Zero-mean normalised cross correlation of two equally sized images, in `[-1, 1]`. */ function correlation(a, b) {
+    if (a.width !== b.width || a.height !== b.height) throw new Error('correlation needs two images of the same size');
+    const n = a.data.length;
+    if (n === 0) return 0;
+    let sumA = 0;
+    let sumB = 0;
+    for(let i = 0; i < n; i++){
+        sumA += a.data[i];
+        sumB += b.data[i];
+    }
+    const meanA = sumA / n;
+    const meanB = sumB / n;
+    let cov = 0;
+    let varA = 0;
+    let varB = 0;
+    for(let i = 0; i < n; i++){
+        const da = a.data[i] - meanA;
+        const db = b.data[i] - meanB;
+        cov += da * db;
+        varA += da * da;
+        varB += db * db;
+    }
+    const denom = Math.sqrt(varA * varB);
+    return denom > 1e-12 ? cov / denom : 0;
+}
+/** Intersection over union of two masks. The pixel-level version of "did it land on top of it". */ function intersectionOverUnion(a, b) {
+    if (a.width !== b.width || a.height !== b.height) throw new Error('intersectionOverUnion needs two masks of the same size');
+    let intersection = 0;
+    let union = 0;
+    for(let i = 0; i < a.data.length; i++){
+        const hit = a.data[i] | b.data[i];
+        union += hit;
+        intersection += a.data[i] & b.data[i];
+    }
+    return union > 0 ? intersection / union : 0;
+}
+/** Mean of a single channel image. */ function mean(image) {
+    if (image.data.length === 0) return 0;
+    let total = 0;
+    for (const value of image.data)total += value;
+    return total / image.data.length;
+}
+
+/** Allocate an opaque RGBA raster, filled with `fill` (white by default). */ function createRaster(width, height, fill = [
+    255,
+    255,
+    255,
+    255
+]) {
+    assertDimensions(width, height);
+    const data = new Uint8ClampedArray(width * height * 4);
+    const [r, g, b, a] = fill;
+    for(let i = 0; i < data.length; i += 4){
+        data[i] = r;
+        data[i + 1] = g;
+        data[i + 2] = b;
+        data[i + 3] = a;
+    }
+    return {
+        width,
+        height,
+        data
+    };
+}
+function createGray(width, height) {
+    assertDimensions(width, height);
+    return {
+        width,
+        height,
+        data: new Float32Array(width * height)
+    };
+}
+function createBinary(width, height) {
+    assertDimensions(width, height);
+    return {
+        width,
+        height,
+        data: new Uint8Array(width * height)
+    };
+}
+function cloneRaster(image) {
+    return {
+        width: image.width,
+        height: image.height,
+        data: Uint8ClampedArray.from(image.data)
+    };
+}
+/**
+ * True when the value is already a decoded raster.
+ *
+ * The check is structural rather than `instanceof` because a raster is a plain
+ * object on purpose: callers should be able to hand us a canvas `ImageData`,
+ * or something they built themselves, without importing anything from here.
+ */ function isRaster(value) {
+    if (typeof value !== 'object' || value === null) return false;
+    const candidate = value;
+    return typeof candidate.width === 'number' && typeof candidate.height === 'number' && ArrayBuffer.isView(candidate.data) && candidate.data.byteLength === candidate.width * candidate.height * 4;
+}
+/** Narrow any accepted input to the bytes of an encoded image, or `null` if it is already decoded. */ function toBytes(input) {
+    if (isRaster(input)) return null;
+    if (input instanceof ArrayBuffer) return new Uint8Array(input);
+    if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    throw new TypeError('expected a Raster, a Uint8Array/Buffer, or an ArrayBuffer');
+}
+/** Wrap bytes as a `Uint8ClampedArray` without copying when the alignment allows it. */ function asClamped(data) {
+    return data instanceof Uint8ClampedArray ? data : new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength);
+}
+function assertDimensions(width, height) {
+    if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width <= 0 || height <= 0) throw new RangeError(`image dimensions must be positive integers, got ${width}x${height}`);
+}
+
+const PNG_MAGIC = [
+    0x89,
+    0x50,
+    0x4E,
+    0x47,
+    0x0D,
+    0x0A,
+    0x1A,
+    0x0A
+];
+const JPEG_MAGIC = [
+    0xFF,
+    0xD8,
+    0xFF
+];
+/** Identify a buffer by its magic bytes. Returns `null` when it is neither PNG nor JPEG. */ function sniffFormat(bytes) {
+    if (startsWith(bytes, PNG_MAGIC)) return 'png';
+    if (startsWith(bytes, JPEG_MAGIC)) return 'jpeg';
+    return null;
+}
+/**
+ * Decode PNG or JPEG bytes to RGBA, or pass a {@link Raster} straight through.
+ *
+ * Passing a raster through untouched is what makes it cheap to align a page
+ * against several scans: decode once, reuse.
+ */ function decodeImage(input) {
+    if (isRaster(input)) return input;
+    const bytes = toBytes(input);
+    if (bytes === null || bytes.length === 0) throw new Error('cannot decode an empty image buffer');
+    const format = sniffFormat(bytes);
+    if (format === 'png') {
+        const png = PNG.sync.read(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+        return {
+            width: png.width,
+            height: png.height,
+            data: asClamped(png.data)
+        };
+    }
+    if (format === 'jpeg') {
+        const jpeg = decode(bytes, {
+            useTArray: true,
+            formatAsRGBA: true,
+            tolerantDecoding: true
+        });
+        return {
+            width: jpeg.width,
+            height: jpeg.height,
+            data: asClamped(jpeg.data)
+        };
+    }
+    throw new Error('unsupported image format: expected PNG or JPEG');
+}
+/** Encode a raster. PNG by default, because a scan re-encoded as JPEG is a scan with new artefacts. */ function encodeImage(image, options = {}) {
+    const { format = 'png', quality = 92 } = options;
+    if (format === 'jpeg') {
+        const encoded = encode({
+            width: image.width,
+            height: image.height,
+            data: new Uint8Array(image.data.buffer, image.data.byteOffset, image.data.byteLength)
+        }, quality);
+        return Uint8Array.from(encoded.data);
+    }
+    const png = new PNG({
+        width: image.width,
+        height: image.height
+    });
+    png.data = Buffer.from(image.data.buffer, image.data.byteOffset, image.data.byteLength);
+    return Uint8Array.from(PNG.sync.write(png));
+}
+function startsWith(bytes, magic) {
+    if (bytes.length < magic.length) return false;
+    for (const [i, byte] of magic.entries())if (bytes[i] !== byte) return false;
+    return true;
+}
+
+/**
+ * Turning a photograph of paper into something two images can be compared on.
+ *
+ * A scan differs from its source in ways that have nothing to do with where
+ * the page is: the lamp is brighter in the middle, the phone cast a shadow
+ * down one side, the JPEG quantiser smeared the strokes. Comparing raw
+ * greyscale means comparing all of that too. So every stage below the codec
+ * works on **ink**: greyscale divided by its own slowly-varying background and
+ * inverted, which is near zero on paper and near one on print no matter what
+ * the lighting did.
+ *
+ * Think of it as reading a page through a sheet of tracing paper — you lose
+ * the tint of the paper and the angle of the lamp, and keep the writing.
+ */ /** Rec. 601 luminance, alpha composited over white, scaled to `[0, 1]`. */ function toGrayscale(image) {
+    const out = createGray(image.width, image.height);
+    const src = image.data;
+    const dst = out.data;
+    for(let i = 0, p = 0; p < dst.length; i += 4, p++){
+        const a = src[i + 3] / 255;
+        const r = src[i] * a + 255 * (1 - a);
+        const g = src[i + 1] * a + 255 * (1 - a);
+        const b = src[i + 2] * a + 255 * (1 - a);
+        dst[p] = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+    }
+    return out;
+}
+/** Render a single channel back to RGBA, for debugging and diff overlays. */ function grayToRaster(image) {
+    const data = new Uint8ClampedArray(image.width * image.height * 4);
+    for(let p = 0, i = 0; p < image.data.length; p++, i += 4){
+        const v = image.data[p] * 255;
+        data[i] = v;
+        data[i + 1] = v;
+        data[i + 2] = v;
+        data[i + 3] = 255;
+    }
+    return {
+        width: image.width,
+        height: image.height,
+        data
+    };
+}
+/** Summed-area table with a zero first row and column, so a window sum is four lookups. */ function integralImage(image) {
+    const { width, height, data } = image;
+    const stride = width + 1;
+    const sum = new Float64Array(stride * (height + 1));
+    for(let y = 0; y < height; y++){
+        let rowSum = 0;
+        const srcRow = y * width;
+        const dstRow = (y + 1) * stride;
+        const prevRow = y * stride;
+        for(let x = 0; x < width; x++){
+            rowSum += data[srcRow + x];
+            sum[dstRow + x + 1] = sum[prevRow + x + 1] + rowSum;
+        }
+    }
+    return sum;
+}
+/**
+ * Mean over a `(2 * radius + 1)` square, in time independent of the radius.
+ *
+ * Border windows are clipped and divided by their real area rather than padded,
+ * so the blur never invents dark paper outside the page.
+ */ function boxBlur(image, radius) {
+    const r = Math.max(0, Math.round(radius));
+    if (r === 0) return _extends({}, image, {
+        data: Float32Array.from(image.data)
+    });
+    const { width, height } = image;
+    const sum = integralImage(image);
+    const stride = width + 1;
+    const out = createGray(width, height);
+    for(let y = 0; y < height; y++){
+        const y0 = Math.max(0, y - r);
+        const y1 = Math.min(height, y + r + 1);
+        const top = y0 * stride;
+        const bottom = y1 * stride;
+        for(let x = 0; x < width; x++){
+            const x0 = Math.max(0, x - r);
+            const x1 = Math.min(width, x + r + 1);
+            const total = sum[bottom + x1] - sum[bottom + x0] - sum[top + x1] + sum[top + x0];
+            out.data[y * width + x] = total / ((y1 - y0) * (x1 - x0));
+        }
+    }
+    return out;
+}
+/**
+ * Greyscale to ink: divide out the local background, invert, clip the noise floor.
+ *
+ * Division rather than subtraction because illumination is multiplicative —
+ * a shadow halves what reaches the sensor, it does not subtract a constant —
+ * so dividing restores the same contrast in the shadow as in the light.
+ */ function inkMap(gray, options = {}) {
+    const { backgroundFraction = 1 / 16, floor = 0.06 } = options;
+    const radius = Math.max(4, Math.round(Math.min(gray.width, gray.height) * backgroundFraction));
+    const background = boxBlur(gray, radius);
+    const out = createGray(gray.width, gray.height);
+    for(let p = 0; p < out.data.length; p++){
+        const bg = Math.max(background.data[p], 1e-3);
+        const ratio = gray.data[p] / bg;
+        const ink = 1 - Math.min(1, ratio);
+        out.data[p] = ink < floor ? 0 : Math.min(1, (ink - floor) / (1 - floor));
+    }
+    return out;
+}
+/** Otsu's threshold over a 256-bin histogram of `[0, 1]` values. */ function otsuThreshold(image) {
+    const bins = 256;
+    const histogram = new Float64Array(bins);
+    for (const value of image.data){
+        const bin = Math.min(bins - 1, Math.max(0, Math.round(value * (bins - 1))));
+        histogram[bin]++;
+    }
+    const total = image.data.length;
+    let sumAll = 0;
+    for(let i = 0; i < bins; i++)sumAll += i * histogram[i];
+    let sumBackground = 0;
+    let weightBackground = 0;
+    let best = 0;
+    let bestVariance = -1;
+    for(let t = 0; t < bins; t++){
+        weightBackground += histogram[t];
+        if (weightBackground === 0) continue;
+        const weightForeground = total - weightBackground;
+        if (weightForeground === 0) break;
+        sumBackground += t * histogram[t];
+        const meanBackground = sumBackground / weightBackground;
+        const meanForeground = (sumAll - sumBackground) / weightForeground;
+        const between = weightBackground * weightForeground * (meanBackground - meanForeground) ** 2;
+        if (between > bestVariance) {
+            bestVariance = between;
+            best = t;
+        }
+    }
+    return best / (bins - 1);
+}
+/**
+ * Ink to a binary mask.
+ *
+ * `threshold` defaults to Otsu's, with a floor: a page that is genuinely blank
+ * has no bimodal split to find, and Otsu will happily cut its noise in half
+ * and report that 50% of the paper is ink.
+ */ function binarize(image, threshold) {
+    const t = Math.max(threshold != null ? threshold : otsuThreshold(image), 0.12);
+    const out = createBinary(image.width, image.height);
+    for(let p = 0; p < out.data.length; p++)out.data[p] = image.data[p] > t ? 1 : 0;
+    return out;
+}
+/**
+ * Morphological dilation by a square, done as two 1D max passes.
+ *
+ * Used to give the original's ink a tolerance band before asking what is new
+ * in the scan: without it, alignment that is half a pixel off reports the edge
+ * of every printed character as freshly written.
+ */ function dilate(mask, radius) {
+    const r = Math.max(0, Math.round(radius));
+    if (r === 0) return _extends({}, mask, {
+        data: Uint8Array.from(mask.data)
+    });
+    const { width, height } = mask;
+    const horizontal = new Uint8Array(width * height);
+    for(let y = 0; y < height; y++){
+        const row = y * width;
+        for(let x = 0; x < width; x++){
+            let hit = 0;
+            const from = Math.max(0, x - r);
+            const to = Math.min(width - 1, x + r);
+            for(let k = from; k <= to; k++)if (mask.data[row + k] === 1) {
+                hit = 1;
+                break;
+            }
+            horizontal[row + x] = hit;
+        }
+    }
+    const out = createBinary(width, height);
+    for(let y = 0; y < height; y++){
+        const from = Math.max(0, y - r);
+        const to = Math.min(height - 1, y + r);
+        for(let x = 0; x < width; x++){
+            let hit = 0;
+            for(let k = from; k <= to; k++)if (horizontal[k * width + x] === 1) {
+                hit = 1;
+                break;
+            }
+            out.data[y * width + x] = hit;
+        }
+    }
+    return out;
+}
+/** Fraction of pixels set in `mask`, restricted to a rectangle when one is given. */ function coverage(mask, x0 = 0, y0 = 0, x1 = mask.width, y1 = mask.height) {
+    const left = Math.max(0, Math.floor(x0));
+    const top = Math.max(0, Math.floor(y0));
+    const right = Math.min(mask.width, Math.ceil(x1));
+    const bottom = Math.min(mask.height, Math.ceil(y1));
+    if (right <= left || bottom <= top) return 0;
+    let hits = 0;
+    for(let y = top; y < bottom; y++){
+        const row = y * mask.width;
+        for(let x = left; x < right; x++)hits += mask.data[row + x];
+    }
+    return hits / ((right - left) * (bottom - top));
+}
+
+/**
+ * Separable resampling: area-average going down, bilinear going up.
+ *
+ * Going down matters more than it sounds. Point-sampling a 300 dpi scan to
+ * half size drops every other row, and on a page of 9pt text that deletes
+ * roughly half the strokes — the thumbnail the matcher sees is not a smaller
+ * version of the page, it is a different page. Averaging over the exact source
+ * footprint of each destination pixel is what keeps the ink where it was.
+ */ /** Resize a single channel image to exactly `width x height`. */ function resizeGray(src, width, height) {
+    if (width === src.width && height === src.height) return _extends({}, src, {
+        data: Float32Array.from(src.data)
+    });
+    const horizontal = new Float32Array(width * src.height);
+    resampleRows(src.data, src.width, src.height, horizontal, width);
+    const out = createGray(width, height);
+    resampleColumns(horizontal, width, src.height, out.data, height);
+    return out;
+}
+/**
+ * Shrink so the longer side is at most `maxDimension`.
+ *
+ * Returns the factor applied, because every coordinate the caller recovers in
+ * this smaller frame has to be scaled back up by it.
+ */ function downscaleGray(src, maxDimension) {
+    const longest = Math.max(src.width, src.height);
+    if (longest <= maxDimension) return {
+        image: _extends({}, src, {
+            data: Float32Array.from(src.data)
+        }),
+        scale: 1
+    };
+    const scale = maxDimension / longest;
+    const width = Math.max(1, Math.round(src.width * scale));
+    const height = Math.max(1, Math.round(src.height * scale));
+    // The realised scale is what the rounded pixel counts imply, not the request.
+    return {
+        image: resizeGray(src, width, height),
+        scale: width / src.width
+    };
+}
+/**
+ * Box blur an RGBA raster with two sliding-window passes.
+ *
+ * Lives here rather than with the other blurs because its only caller is the
+ * warp prefilter, and because it has to work in bytes: a summed-area table over
+ * four channels of a 12 megapixel scan is 400 MB, which is not a thing to
+ * allocate inside a function app.
+ */ function boxBlurRaster(src, radius) {
+    const r = Math.max(0, Math.round(radius));
+    if (r === 0) return _extends({}, src, {
+        data: Uint8ClampedArray.from(src.data)
+    });
+    const { width, height } = src;
+    const temp = new Uint8ClampedArray(width * height * 4);
+    const sums = new Int32Array(4);
+    for(let y = 0; y < height; y++){
+        const row = y * width * 4;
+        sums.fill(0);
+        let count = 0;
+        for(let x = 0; x <= Math.min(r, width - 1); x++, count++)for(let c = 0; c < 4; c++)sums[c] += src.data[row + x * 4 + c];
+        for(let x = 0; x < width; x++){
+            for(let c = 0; c < 4; c++)temp[row + x * 4 + c] = sums[c] / count;
+            const leaving = x - r;
+            const entering = x + r + 1;
+            if (leaving >= 0) {
+                for(let c = 0; c < 4; c++)sums[c] -= src.data[row + leaving * 4 + c];
+                count--;
+            }
+            if (entering < width) {
+                for(let c = 0; c < 4; c++)sums[c] += src.data[row + entering * 4 + c];
+                count++;
+            }
+        }
+    }
+    const out = new Uint8ClampedArray(width * height * 4);
+    const columnSums = new Int32Array(width * 4);
+    let count = 0;
+    for(let y = 0; y <= Math.min(r, height - 1); y++, count++)for(let i = 0; i < width * 4; i++)columnSums[i] += temp[y * width * 4 + i];
+    for(let y = 0; y < height; y++){
+        const row = y * width * 4;
+        for(let i = 0; i < width * 4; i++)out[row + i] = columnSums[i] / count;
+        const leaving = y - r;
+        const entering = y + r + 1;
+        if (leaving >= 0) {
+            for(let i = 0; i < width * 4; i++)columnSums[i] -= temp[leaving * width * 4 + i];
+            count--;
+        }
+        if (entering < height) {
+            for(let i = 0; i < width * 4; i++)columnSums[i] += temp[entering * width * 4 + i];
+            count++;
+        }
+    }
+    return {
+        width,
+        height,
+        data: out
+    };
+}
+function resampleRows(src, srcWidth, rows, dst, dstWidth) {
+    const ratio = srcWidth / dstWidth;
+    if (ratio > 1) {
+        for(let y = 0; y < rows; y++){
+            const srcRow = y * srcWidth;
+            const dstRow = y * dstWidth;
+            for(let x = 0; x < dstWidth; x++){
+                const start = x * ratio;
+                const end = start + ratio;
+                dst[dstRow + x] = areaAverage(src, srcRow, srcWidth, start, end);
+            }
+        }
+        return;
+    }
+    for(let y = 0; y < rows; y++){
+        const srcRow = y * srcWidth;
+        const dstRow = y * dstWidth;
+        for(let x = 0; x < dstWidth; x++){
+            const pos = clamp$1((x + 0.5) * ratio - 0.5, 0, srcWidth - 1);
+            const i0 = Math.floor(pos);
+            const i1 = Math.min(srcWidth - 1, i0 + 1);
+            const frac = pos - i0;
+            dst[dstRow + x] = src[srcRow + i0] * (1 - frac) + src[srcRow + i1] * frac;
+        }
+    }
+}
+function resampleColumns(src, width, srcHeight, dst, dstHeight) {
+    const ratio = srcHeight / dstHeight;
+    const column = new Float32Array(srcHeight);
+    for(let x = 0; x < width; x++){
+        for(let y = 0; y < srcHeight; y++)column[y] = src[y * width + x];
+        if (ratio > 1) for(let y = 0; y < dstHeight; y++){
+            const start = y * ratio;
+            dst[y * width + x] = areaAverage(column, 0, srcHeight, start, start + ratio);
+        }
+        else for(let y = 0; y < dstHeight; y++){
+            const pos = clamp$1((y + 0.5) * ratio - 0.5, 0, srcHeight - 1);
+            const i0 = Math.floor(pos);
+            const i1 = Math.min(srcHeight - 1, i0 + 1);
+            const frac = pos - i0;
+            dst[y * width + x] = column[i0] * (1 - frac) + column[i1] * frac;
+        }
+    }
+}
+/** Mean of `src[offset + start .. offset + end)`, weighting the two partially covered ends. */ function areaAverage(src, offset, length, start, end) {
+    const from = Math.max(0, Math.floor(start));
+    const to = Math.min(length, Math.ceil(end));
+    let total = 0;
+    let weight = 0;
+    for(let i = from; i < to; i++){
+        const w = Math.min(end, i + 1) - Math.max(start, i);
+        if (w <= 0) continue;
+        total += src[offset + i] * w;
+        weight += w;
+    }
+    return weight > 0 ? total / weight : 0;
+}
+function clamp$1(value, min, max) {
+    return value < min ? min : Math.min(value, max);
+}
+
+/** Warp an RGBA raster onto a `width x height` canvas. */ function warpRaster(source, matrix, width, height, options = {}) {
+    const { background = [
+        255,
+        255,
+        255,
+        255
+    ], interpolation = 'bilinear', prefilter = true } = options;
+    const src = prefilter ? applyPrefilter(source, matrix) : source;
+    const data = new Uint8ClampedArray(width * height * 4);
+    const [m0, m1, m2, m3, m4, m5, m6, m7, m8] = matrix;
+    for(let y = 0; y < height; y++){
+        const dy = y + 0.5;
+        let i = y * width * 4;
+        for(let x = 0; x < width; x++, i += 4){
+            const dx = x + 0.5;
+            const w = m6 * dx + m7 * dy + m8;
+            if (w === 0) {
+                writePixel(data, i, background);
+                continue;
+            }
+            // Continuous source coordinate, then index space: pixel k spans [k, k+1)
+            // with its centre at k + 0.5, so the sample index is the centre minus a half.
+            const u = (m0 * dx + m1 * dy + m2) / w - 0.5;
+            const v = (m3 * dx + m4 * dy + m5) / w - 0.5;
+            if (u < -1 || v < -1 || u > src.width || v > src.height) {
+                writePixel(data, i, background);
+                continue;
+            }
+            sampleRaster(src, u, v, interpolation, data, i);
+        }
+    }
+    return {
+        width,
+        height,
+        data
+    };
+}
+/** Warp a single channel image. Used for scoring, where colour is noise. */ function warpGray(source, matrix, width, height, fill = 0) {
+    const out = createGray(width, height);
+    const [m0, m1, m2, m3, m4, m5, m6, m7, m8] = matrix;
+    for(let y = 0; y < height; y++){
+        const dy = y + 0.5;
+        const row = y * width;
+        for(let x = 0; x < width; x++){
+            const dx = x + 0.5;
+            const w = m6 * dx + m7 * dy + m8;
+            if (w === 0) {
+                out.data[row + x] = fill;
+                continue;
+            }
+            const u = (m0 * dx + m1 * dy + m2) / w - 0.5;
+            const v = (m3 * dx + m4 * dy + m5) / w - 0.5;
+            out.data[row + x] = sampleGrayBilinear(source, u, v, fill);
+        }
+    }
+    return out;
+}
+/** Bilinear read at a fractional index, returning `fill` outside the image. */ function sampleGrayBilinear(image, u, v, fill = 0) {
+    const { width, height, data } = image;
+    if (u <= -1 || v <= -1 || u >= width || v >= height) return fill;
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    const x1 = x0 + 1;
+    const y1 = y0 + 1;
+    const cx0 = clampIndex(x0, width);
+    const cx1 = clampIndex(x1, width);
+    const cy0 = clampIndex(y0, height);
+    const cy1 = clampIndex(y1, height);
+    const p00 = data[cy0 * width + cx0];
+    const p10 = data[cy0 * width + cx1];
+    const p01 = data[cy1 * width + cx0];
+    const p11 = data[cy1 * width + cx1];
+    return p00 * (1 - fx) * (1 - fy) + p10 * fx * (1 - fy) + p01 * (1 - fx) * fy + p11 * fx * fy;
+}
+/**
+ * Blur the source when the warp is a minification.
+ *
+ * `sqrt(|det|)` of the linear part is how many source pixels land on one
+ * destination pixel along an average direction; when that is comfortably above
+ * one, a point sample is reading one of them and discarding the rest.
+ */ function applyPrefilter(source, matrix) {
+    const det = Math.abs(matrix[0] * matrix[4] - matrix[1] * matrix[3]);
+    const scale = Math.sqrt(det);
+    if (!Number.isFinite(scale) || scale <= 1.25) return source;
+    return boxBlurRaster(source, (scale - 1) / 2);
+}
+function sampleRaster(src, u, v, interpolation, out, at) {
+    if (interpolation === 'nearest') {
+        const x = clampIndex(Math.round(u), src.width);
+        const y = clampIndex(Math.round(v), src.height);
+        const i = (y * src.width + x) * 4;
+        out[at] = src.data[i];
+        out[at + 1] = src.data[i + 1];
+        out[at + 2] = src.data[i + 2];
+        out[at + 3] = src.data[i + 3];
+        return;
+    }
+    if (interpolation === 'bicubic') {
+        sampleBicubic(src, u, v, out, at);
+        return;
+    }
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    const cx0 = clampIndex(x0, src.width);
+    const cx1 = clampIndex(x0 + 1, src.width);
+    const cy0 = clampIndex(y0, src.height);
+    const cy1 = clampIndex(y0 + 1, src.height);
+    const i00 = (cy0 * src.width + cx0) * 4;
+    const i10 = (cy0 * src.width + cx1) * 4;
+    const i01 = (cy1 * src.width + cx0) * 4;
+    const i11 = (cy1 * src.width + cx1) * 4;
+    const w00 = (1 - fx) * (1 - fy);
+    const w10 = fx * (1 - fy);
+    const w01 = (1 - fx) * fy;
+    const w11 = fx * fy;
+    for(let c = 0; c < 4; c++)out[at + c] = src.data[i00 + c] * w00 + src.data[i10 + c] * w10 + src.data[i01 + c] * w01 + src.data[i11 + c] * w11;
+}
+/** Catmull-Rom over a 4x4 neighbourhood: sharper strokes than bilinear when upscaling. */ function sampleBicubic(src, u, v, out, at) {
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    const wx = catmullRomWeights(fx);
+    const wy = catmullRomWeights(fy);
+    for(let c = 0; c < 4; c++){
+        let total = 0;
+        for(let j = 0; j < 4; j++){
+            const y = clampIndex(y0 - 1 + j, src.height);
+            const row = y * src.width;
+            let rowTotal = 0;
+            for(let i = 0; i < 4; i++){
+                const x = clampIndex(x0 - 1 + i, src.width);
+                rowTotal += src.data[(row + x) * 4 + c] * wx[i];
+            }
+            total += rowTotal * wy[j];
+        }
+        out[at + c] = total;
+    }
+}
+function catmullRomWeights(t) {
+    const t2 = t * t;
+    const t3 = t2 * t;
+    return [
+        0.5 * (-t3 + 2 * t2 - t),
+        0.5 * (3 * t3 - 5 * t2 + 2),
+        0.5 * (-3 * t3 + 4 * t2 + t),
+        0.5 * (t3 - t2)
+    ];
+}
+function writePixel(data, at, rgba) {
+    data[at] = rgba[0];
+    data[at + 1] = rgba[1];
+    data[at + 2] = rgba[2];
+    data[at + 3] = rgba[3];
+}
+function clampIndex(value, length) {
+    return value < 0 ? 0 : value >= length ? length - 1 : value;
+}
+
+/**
+ * 3x3 homogeneous matrix helpers.
+ *
+ * ## The one convention that matters
+ *
+ * Every matrix in this library maps **original coordinates to scanned
+ * coordinates**, never the other way round. That reads backwards the first
+ * time: we are producing an image on the original's canvas, so we walk the
+ * output pixel by pixel and ask "where in the scan does this come from?".
+ * Inverse mapping is what stops the output having holes — forward-splatting a
+ * rotated source leaves gaps between the splats, like spray-painting through a
+ * rotated stencil.
+ *
+ * Coordinates are continuous, with the centre of pixel `(i, j)` at
+ * `(i + 0.5, j + 0.5)`. Sticking to that is what makes {@link conjugateScale}
+ * a plain scale conjugation instead of a scale plus a half-pixel fudge.
+ */ const IDENTITY = [
+    1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    1
+];
+/** `a * b` — the transform that applies `b` first, then `a`. */ function multiply(a, b) {
+    return [
+        a[0] * b[0] + a[1] * b[3] + a[2] * b[6],
+        a[0] * b[1] + a[1] * b[4] + a[2] * b[7],
+        a[0] * b[2] + a[1] * b[5] + a[2] * b[8],
+        a[3] * b[0] + a[4] * b[3] + a[5] * b[6],
+        a[3] * b[1] + a[4] * b[4] + a[5] * b[7],
+        a[3] * b[2] + a[4] * b[5] + a[5] * b[8],
+        a[6] * b[0] + a[7] * b[3] + a[8] * b[6],
+        a[6] * b[1] + a[7] * b[4] + a[8] * b[7],
+        a[6] * b[2] + a[7] * b[5] + a[8] * b[8]
+    ];
+}
+function determinant(m) {
+    return m[0] * (m[4] * m[8] - m[5] * m[7]) - m[1] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * m[7] - m[4] * m[6]);
+}
+/** Throws when `m` is singular — a transform that collapses the page to a line is never a usable answer. */ function invert(m) {
+    const det = determinant(m);
+    if (!Number.isFinite(det) || Math.abs(det) < 1e-12) throw new Error('matrix is singular and cannot be inverted');
+    const inv = 1 / det;
+    return [
+        (m[4] * m[8] - m[5] * m[7]) * inv,
+        (m[2] * m[7] - m[1] * m[8]) * inv,
+        (m[1] * m[5] - m[2] * m[4]) * inv,
+        (m[5] * m[6] - m[3] * m[8]) * inv,
+        (m[0] * m[8] - m[2] * m[6]) * inv,
+        (m[2] * m[3] - m[0] * m[5]) * inv,
+        (m[3] * m[7] - m[4] * m[6]) * inv,
+        (m[1] * m[6] - m[0] * m[7]) * inv,
+        (m[0] * m[4] - m[1] * m[3]) * inv
+    ];
+}
+/** Divide through by `m8` so two matrices describing the same transform compare equal. */ function normalize(m) {
+    const s = m[8];
+    if (s === 0 || s === 1) return m;
+    return [
+        m[0] / s,
+        m[1] / s,
+        m[2] / s,
+        m[3] / s,
+        m[4] / s,
+        m[5] / s,
+        m[6] / s,
+        m[7] / s,
+        1
+    ];
+}
+function applyPoint(m, x, y) {
+    const w = m[6] * x + m[7] * y + m[8];
+    const iw = w === 0 ? 0 : 1 / w;
+    return {
+        x: (m[0] * x + m[1] * y + m[2]) * iw,
+        y: (m[3] * x + m[4] * y + m[5]) * iw
+    };
+}
+function translation(tx, ty) {
+    return [
+        1,
+        0,
+        tx,
+        0,
+        1,
+        ty,
+        0,
+        0,
+        1
+    ];
+}
+function scaling(sx, sy = sx) {
+    return [
+        sx,
+        0,
+        0,
+        0,
+        sy,
+        0,
+        0,
+        0,
+        1
+    ];
+}
+/**
+ * Scale `s` and rotation `angleRad` about `pivot`, then land that pivot on `target`.
+ *
+ * This is the shape the coarse stage produces: "the middle of the original's
+ * printed content is the middle of the scan's printed content, turned by this
+ * much and this many times bigger".
+ */ function similarity(s, angleRad, pivot, target) {
+    const c = Math.cos(angleRad) * s;
+    const k = Math.sin(angleRad) * s;
+    return [
+        c,
+        -k,
+        target.x - c * pivot.x + k * pivot.y,
+        k,
+        c,
+        target.y - k * pivot.x - c * pivot.y,
+        0,
+        0,
+        1
+    ];
+}
+/**
+ * Re-express `m` in a coordinate frame scaled by `k`.
+ *
+ * Fitting runs on downscaled copies because matching 3000x4000 images is a
+ * waste; the matrix that comes back speaks in those small pixels. `k` is
+ * `working / full`, and the result speaks in full-resolution pixels.
+ */ function conjugateScale(m, k) {
+    return multiply(scaling(1 / k), multiply(m, scaling(k)));
+}
+/**
+ * Re-express a matrix whose two frames were scaled by different factors.
+ *
+ * The coarse stage measures on two independently shrunk copies - the original
+ * and the scan rarely have the same pixel count, so they rarely shrink by the
+ * same factor. `sourceScale` and `targetScale` are each `working / full` for
+ * their own side, and the result speaks full-resolution pixels on both.
+ */ function rebase(m, sourceScale, targetScale) {
+    return multiply(scaling(1 / targetScale), multiply(m, scaling(sourceScale)));
+}
+/** The four corners of `rect` mapped through `m`, clockwise from the top-left. */ function mapRectCorners(m, rect) {
+    const { x, y, width, height } = rect;
+    return [
+        applyPoint(m, x, y),
+        applyPoint(m, x + width, y),
+        applyPoint(m, x + width, y + height),
+        applyPoint(m, x, y + height)
+    ];
+}
+/**
+ * Pull a matrix apart into scale, rotation and shear.
+ *
+ * The 2x2 linear part is factored as `R(theta) * [[sx, k], [0, sy]]`, which is
+ * the order a scanner actually applies them: the page is stretched on the
+ * glass, then the whole thing sits at an angle.
+ */ function decompose(m, model) {
+    const [a, b, , d, e] = m;
+    const scaleX = Math.hypot(a, d);
+    const det = a * e - b * d;
+    const scaleY = scaleX === 0 ? 0 : det / scaleX;
+    const shear = scaleX === 0 ? 0 : (a * b + d * e) / scaleX;
+    const origin = applyPoint(m, 0, 0);
+    return {
+        model,
+        scaleX,
+        scaleY,
+        rotationDeg: Math.atan2(d, a) * 180 / Math.PI,
+        shearDeg: Math.atan2(shear, scaleY || 1) * 180 / Math.PI,
+        translation: origin,
+        perspective: {
+            x: m[6],
+            y: m[7]
+        }
+    };
+}
+/** Euclidean distance between `m * source` and `target`, in target pixels. */ function reprojectionError(m, source, target) {
+    const p = applyPoint(m, source.x, source.y);
+    return Math.hypot(p.x - target.x, p.y - target.y);
+}
+/**
+ * True when `m` is a plausible page-to-page transform rather than numerical debris.
+ *
+ * RANSAC on a minimal sample of near-collinear points loves to return a
+ * matrix that folds the page in half. Cheaper to reject it here than to
+ * discover it in the output.
+ */ function isPlausible(m, maxScaleRatio = 8) {
+    if (m.some((v)=>!Number.isFinite(v))) return false;
+    const [a, b, , d, e] = m;
+    const det = a * e - b * d;
+    if (Math.abs(det) <= 1e-9) return false;
+    // A mirrored page is never a scan of the same page.
+    if (det < 0) return false;
+    const sx = Math.hypot(a, d);
+    if (sx < 1 / maxScaleRatio || sx > maxScaleRatio) return false;
+    const sy = Math.hypot(b, e);
+    return !(sy < 1 / maxScaleRatio || sy > maxScaleRatio);
+}
+
+/**
+ * Extent of the ink along axes rotated by `angle`, trimming outliers.
+ *
+ * `trim` is a fraction of the total ink discarded from each end of each axis.
+ * A scanner that clips a black strip down one edge, or a speck of dust, would
+ * otherwise set the page boundary — and since this measurement becomes the
+ * scale estimate, a 2% error here is a 2% error in every coordinate downstream.
+ */ function contentExtent(ink, angle = 0, trim = 0.004) {
+    const { width, height, data } = ink;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const corners = [
+        {
+            x: 0,
+            y: 0
+        },
+        {
+            x: width,
+            y: 0
+        },
+        {
+            x: 0,
+            y: height
+        },
+        {
+            x: width,
+            y: height
+        }
+    ];
+    let minU = Infinity;
+    let maxU = -Infinity;
+    let minV = Infinity;
+    let maxV = -Infinity;
+    for (const c of corners){
+        const u = c.x * cos + c.y * sin;
+        const v = -c.x * sin + c.y * cos;
+        minU = Math.min(minU, u);
+        maxU = Math.max(maxU, u);
+        minV = Math.min(minV, v);
+        maxV = Math.max(maxV, v);
+    }
+    const uBins = new Float64Array(Math.ceil(maxU - minU) + 2);
+    const vBins = new Float64Array(Math.ceil(maxV - minV) + 2);
+    let total = 0;
+    for(let y = 0; y < height; y++){
+        const row = y * width;
+        const yCos = (y + 0.5) * cos;
+        const ySin = (y + 0.5) * sin;
+        for(let x = 0; x < width; x++){
+            const value = data[row + x];
+            if (value <= 0) continue;
+            const px = x + 0.5;
+            // floor, not round: a pixel centre at x + 0.5 belongs to bucket x.
+            uBins[Math.floor(px * cos + ySin - minU)] += value;
+            vBins[Math.floor(-px * sin + yCos - minV)] += value;
+            total += value;
+        }
+    }
+    if (total <= 0) {
+        // Nothing printed: report the whole frame rather than an empty box, so the
+        // caller falls back to fitting the page frame instead of dividing by zero.
+        return {
+            width,
+            height,
+            center: {
+                x: width / 2,
+                y: height / 2
+            },
+            angle,
+            density: 0
+        };
+    }
+    const [u0, u1] = trimmedSpan(uBins, total, trim);
+    const [v0, v1] = trimmedSpan(vBins, total, trim);
+    const centerU = minU + (u0 + u1) / 2;
+    const centerV = minV + (v0 + v1) / 2;
+    return {
+        width: Math.max(1, u1 - u0),
+        height: Math.max(1, v1 - v0),
+        center: {
+            x: centerU * cos - centerV * sin,
+            y: centerU * sin + centerV * cos
+        },
+        angle,
+        density: total / (width * height)
+    };
+}
+/**
+ * The page's own skew, in radians, from the sharpness of its ink profile.
+ *
+ * Rotate the page until the rows of text stack up: at the right angle every
+ * line of type falls into one bin of the projection histogram and the profile
+ * is a comb of tall spikes; a degree off and each line smears across several
+ * bins. Sum of squares rewards exactly that concentration — same total ink,
+ * fewer bins, bigger number. Searched coarse to fine so the cost stays flat.
+ */ function estimateSkew(ink, options = {}) {
+    const { maxAngleDeg = 12 } = options;
+    const toRad = Math.PI / 180;
+    let best = 0;
+    let bestScore = -Infinity;
+    for(let deg = -maxAngleDeg; deg <= maxAngleDeg; deg += 1){
+        const score = profileSharpness(ink, deg * toRad);
+        if (score > bestScore) {
+            bestScore = score;
+            best = deg;
+        }
+    }
+    for (const [span, step] of [
+        [
+            1,
+            0.2
+        ],
+        [
+            0.2,
+            0.04
+        ]
+    ]){
+        let localBest = best;
+        for(let deg = best - span; deg <= best + span + 1e-9; deg += step){
+            const score = profileSharpness(ink, deg * toRad);
+            if (score > bestScore) {
+                bestScore = score;
+                localBest = deg;
+            }
+        }
+        best = localBest;
+    }
+    return best * toRad;
+}
+/** Sum of squares of the ink profile projected onto the axis perpendicular to `angle`. */ function profileSharpness(ink, angle) {
+    const { width, height, data } = ink;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const offset = Math.max(0, -width * sin);
+    const bins = new Float64Array(Math.ceil(height * cos + width * Math.abs(sin)) + 2);
+    for(let y = 0; y < height; y++){
+        const row = y * width;
+        const yCos = (y + 0.5) * cos + offset;
+        for(let x = 0; x < width; x++){
+            const value = data[row + x];
+            if (value <= 0) continue;
+            const bin = Math.floor(yCos - (x + 0.5) * sin);
+            if (bin >= 0 && bin < bins.length) bins[bin] += value;
+        }
+    }
+    let score = 0;
+    for (const value of bins)score += value * value;
+    return score;
+}
+/** First and last bin holding all but `trim` of the mass at each end. */ function trimmedSpan(bins, total, trim) {
+    const cutoff = total * trim;
+    let accumulated = 0;
+    let low = 0;
+    for(; low < bins.length; low++){
+        accumulated += bins[low];
+        if (accumulated > cutoff) break;
+    }
+    accumulated = 0;
+    let high = bins.length - 1;
+    for(; high > low; high--){
+        accumulated += bins[high];
+        if (accumulated > cutoff) break;
+    }
+    return [
+        low,
+        high + 1
+    ];
+}
+
+/**
+ * In-place radix-2 Cooley-Tukey FFT, real and imaginary parts in separate arrays.
+ *
+ * Only used by phase correlation, which needs a *global* translation estimate
+ * that no amount of local feature matching can produce on a page with almost
+ * nothing printed on it. Sizes must be powers of two; {@link nextPowerOfTwo}
+ * and the caller's zero padding see to that.
+ */ function nextPowerOfTwo(n) {
+    let p = 1;
+    while(p < n)p *= 2;
+    return p;
+}
+function isPowerOfTwo(n) {
+    return n > 0 && (n & n - 1) === 0;
+}
+/** Transform `re`/`im` of length `n` in place. `inverse` also divides by `n`. */ function fft1d(re, im, inverse = false) {
+    const n = re.length;
+    if (!isPowerOfTwo(n)) throw new Error(`fft length must be a power of two, got ${n}`);
+    if (n === 1) return;
+    // Bit-reversal permutation: the decimation-in-time butterflies below expect
+    // the input already shuffled into the order the recursion would have left it.
+    for(let i = 1, j = 0; i < n; i++){
+        let bit = n >> 1;
+        for(; (j & bit) !== 0; bit >>= 1)j ^= bit;
+        j ^= bit;
+        if (i < j) {
+            let t = re[i];
+            re[i] = re[j];
+            re[j] = t;
+            t = im[i];
+            im[i] = im[j];
+            im[j] = t;
+        }
+    }
+    const sign = inverse ? 1 : -1;
+    for(let len = 2; len <= n; len <<= 1){
+        const angle = sign * 2 * Math.PI / len;
+        const wRe = Math.cos(angle);
+        const wIm = Math.sin(angle);
+        for(let start = 0; start < n; start += len){
+            let curRe = 1;
+            let curIm = 0;
+            const half = len >> 1;
+            for(let k = 0; k < half; k++){
+                const i = start + k;
+                const j = i + half;
+                const evenRe = re[i];
+                const evenIm = im[i];
+                const oddRe = re[j] * curRe - im[j] * curIm;
+                const oddIm = re[j] * curIm + im[j] * curRe;
+                re[i] = evenRe + oddRe;
+                im[i] = evenIm + oddIm;
+                re[j] = evenRe - oddRe;
+                im[j] = evenIm - oddIm;
+                const nextRe = curRe * wRe - curIm * wIm;
+                curIm = curRe * wIm + curIm * wRe;
+                curRe = nextRe;
+            }
+        }
+    }
+    if (inverse) for(let i = 0; i < n; i++){
+        re[i] /= n;
+        im[i] /= n;
+    }
+}
+/** 2D transform of a `width x height` row-major complex image, rows then columns. */ function fft2d(re, im, width, height, inverse = false) {
+    const rowRe = new Float64Array(width);
+    const rowIm = new Float64Array(width);
+    for(let y = 0; y < height; y++){
+        const off = y * width;
+        rowRe.set(re.subarray(off, off + width));
+        rowIm.set(im.subarray(off, off + width));
+        fft1d(rowRe, rowIm, inverse);
+        re.set(rowRe, off);
+        im.set(rowIm, off);
+    }
+    const colRe = new Float64Array(height);
+    const colIm = new Float64Array(height);
+    for(let x = 0; x < width; x++){
+        for(let y = 0; y < height; y++){
+            colRe[y] = re[y * width + x];
+            colIm[y] = im[y * width + x];
+        }
+        fft1d(colRe, colIm, inverse);
+        for(let y = 0; y < height; y++){
+            re[y * width + x] = colRe[y];
+            im[y * width + x] = colIm[y];
+        }
+    }
+}
+
+/**
+ * Correlate two equally sized images.
+ *
+ * Both are Hann-windowed first. Without it the FFT sees the frame edges as a
+ * hard discontinuity repeating forever, and that cross pattern in the spectrum
+ * can be a stronger signal than the page.
+ */ function phaseCorrelate(a, b) {
+    if (a.width !== b.width || a.height !== b.height) throw new Error('phaseCorrelate needs two images of the same size');
+    const width = nextPowerOfTwo(a.width);
+    const height = nextPowerOfTwo(a.height);
+    const size = width * height;
+    const aRe = new Float64Array(size);
+    const aIm = new Float64Array(size);
+    const bRe = new Float64Array(size);
+    const bIm = new Float64Array(size);
+    const windowX = hann(a.width);
+    const windowY = hann(a.height);
+    for(let y = 0; y < a.height; y++){
+        const src = y * a.width;
+        const dst = y * width;
+        for(let x = 0; x < a.width; x++){
+            const w = windowX[x] * windowY[y];
+            aRe[dst + x] = a.data[src + x] * w;
+            bRe[dst + x] = b.data[src + x] * w;
+        }
+    }
+    fft2d(aRe, aIm, width, height);
+    fft2d(bRe, bIm, width, height);
+    // Cross-power spectrum of b against a, normalised to unit magnitude so that
+    // every frequency contributes its phase and nothing else.
+    for(let i = 0; i < size; i++){
+        const re = bRe[i] * aRe[i] + bIm[i] * aIm[i];
+        const im = bIm[i] * aRe[i] - bRe[i] * aIm[i];
+        const magnitude = Math.hypot(re, im);
+        if (magnitude < 1e-12) {
+            bRe[i] = 0;
+            bIm[i] = 0;
+        } else {
+            bRe[i] = re / magnitude;
+            bIm[i] = im / magnitude;
+        }
+    }
+    fft2d(bRe, bIm, width, height, true);
+    let peakIndex = 0;
+    let peakValue = -Infinity;
+    for(let i = 0; i < size; i++)if (bRe[i] > peakValue) {
+        peakValue = bRe[i];
+        peakIndex = i;
+    }
+    const px = peakIndex % width;
+    const py = Math.floor(peakIndex / width);
+    const dx = wrap(px + parabolic(sample(bRe, width, height, px - 1, py), peakValue, sample(bRe, width, height, px + 1, py)), width);
+    const dy = wrap(py + parabolic(sample(bRe, width, height, px, py - 1), peakValue, sample(bRe, width, height, px, py + 1)), height);
+    return {
+        dx,
+        dy,
+        peak: peakValue
+    };
+}
+/**
+ * Sub-pixel offset of a peak, by fitting a parabola through it and its neighbours.
+ *
+ * The correlation surface is sampled on the pixel grid, but the true offset is
+ * not a whole number of pixels. Three samples determine a parabola, and its
+ * vertex is a better estimate than the middle sample - typically to about a
+ * tenth of a pixel.
+ */ function parabolic(left, center, right) {
+    const denominator = left - 2 * center + right;
+    if (Math.abs(denominator) < 1e-12) return 0;
+    const offset = 0.5 * (left - right) / denominator;
+    return Math.abs(offset) < 1 ? offset : 0;
+}
+function sample(data, width, height, x, y) {
+    const cx = (x % width + width) % width;
+    const cy = (y % height + height) % height;
+    return data[cy * width + cx];
+}
+/** Map an index in `[0, n)` onto a signed shift in `[-n/2, n/2)`. */ function wrap(value, n) {
+    return value > n / 2 ? value - n : value;
+}
+function hann(n) {
+    const w = new Float64Array(n);
+    if (n === 1) {
+        w[0] = 1;
+        return w;
+    }
+    for(let i = 0; i < n; i++)w[i] = 0.5 * (1 - Math.cos(2 * Math.PI * i / (n - 1)));
+    return w;
+}
+
+function estimateCoarse(originalInk, scannedInk, options = {}) {
+    const { workingSize = 512, maxSkewDeg = 12, maxScaleRatio = 6 } = options;
+    const original = downscaleGray(originalInk, workingSize);
+    const scanned = downscaleGray(scannedInk, workingSize);
+    const originalSkew = estimateSkew(original.image, {
+        maxAngleDeg: maxSkewDeg
+    });
+    const scannedSkew = estimateSkew(scanned.image, {
+        maxAngleDeg: maxSkewDeg
+    });
+    const originalFlat = contentExtent(original.image, 0);
+    const scannedFlat = contentExtent(scanned.image, 0);
+    const originalTilted = contentExtent(original.image, originalSkew);
+    const scannedTilted = contentExtent(scanned.image, scannedSkew);
+    const candidates = [];
+    const frameScale = geometricMean(scanned.image.width / original.image.width, scanned.image.height / original.image.height);
+    push(candidates, 'frame', similarity(frameScale, 0, {
+        x: original.image.width / 2,
+        y: original.image.height / 2
+    }, {
+        x: scanned.image.width / 2,
+        y: scanned.image.height / 2
+    }), maxScaleRatio);
+    if (originalFlat.density > 0 && scannedFlat.density > 0) push(candidates, 'content', fromExtents(originalFlat, scannedFlat, 0), maxScaleRatio);
+    if (originalTilted.density > 0 && scannedTilted.density > 0) push(candidates, 'deskew', fromExtents(originalTilted, scannedTilted, scannedSkew - originalSkew), maxScaleRatio);
+    let bestMatrix = similarity(Number.isFinite(frameScale) ? frameScale : 1, 0, {
+        x: original.image.width / 2,
+        y: original.image.height / 2
+    }, {
+        x: scanned.image.width / 2,
+        y: scanned.image.height / 2
+    });
+    let bestScore = -Infinity;
+    let bestStrategy = 'fallback';
+    for (const candidate of candidates){
+        for (const variant of withTranslationPolish(candidate, original.image, scanned.image)){
+            const warped = warpGray(scanned.image, variant.matrix, original.image.width, original.image.height, 0);
+            const score = correlation(original.image, warped);
+            if (score > bestScore) {
+                bestMatrix = variant.matrix;
+                bestScore = score;
+                bestStrategy = variant.strategy;
+            }
+        }
+    }
+    return {
+        // Measured on two independently shrunk copies; hand back full-resolution pixels.
+        matrix: rebase(bestMatrix, original.scale, scanned.scale),
+        score: bestScore === -Infinity ? 0 : bestScore,
+        strategy: bestStrategy,
+        skew: {
+            original: originalSkew,
+            scanned: scannedSkew
+        }
+    };
+}
+/** The coarse matrix, plus a copy nudged by whatever phase correlation says is left over. */ function withTranslationPolish(candidate, original, scanned) {
+    const warped = warpGray(scanned, candidate.matrix, original.width, original.height, 0);
+    let shift;
+    try {
+        shift = phaseCorrelate(original, warped);
+    } catch (unused) {
+        return [
+            candidate
+        ];
+    }
+    if (!Number.isFinite(shift.dx) || !Number.isFinite(shift.dy)) return [
+        candidate
+    ];
+    if (Math.abs(shift.dx) < 0.25 && Math.abs(shift.dy) < 0.25) return [
+        candidate
+    ];
+    // `warped` sits in the original's frame, so a residual shift of d means the
+    // original at p matches the warp at p + d: sample d further along.
+    return [
+        candidate,
+        {
+            strategy: `${candidate.strategy}+phase`,
+            matrix: multiply(candidate.matrix, translation(shift.dx, shift.dy))
+        }
+    ];
+}
+function fromExtents(original, scanned, angle) {
+    const scale = geometricMean(scanned.width / original.width, scanned.height / original.height);
+    return similarity(scale, angle, original.center, scanned.center);
+}
+function push(into, strategy, matrix, maxScaleRatio) {
+    if (isPlausible(matrix, maxScaleRatio)) into.push({
+        strategy,
+        matrix
+    });
+}
+/**
+ * Geometric rather than arithmetic mean of the two axis ratios.
+ *
+ * The quantity is a ratio, and the mean of a ratio and its reciprocal should be
+ * one. Arithmetic mean says 1.25.
+ */ function geometricMean(a, b) {
+    if (Number.isNaN(a) || Number.isNaN(b) || a <= 0 || b <= 0) return NaN;
+    return Math.sqrt(a * b);
+}
+
+/**
+ * A seeded PRNG, so that two runs on the same bytes give the same matrix.
+ *
+ * RANSAC samples at random and the BRIEF pattern is drawn at random; with
+ * `Math.random` the library would return a slightly different answer every
+ * time, which makes a regression test a coin toss and a production bug
+ * impossible to reproduce from the inputs alone. mulberry32 is 32 bits of
+ * state and passes the statistical tests that matter at this scale.
+ */ function createRandom(seed) {
+    let state = seed >>> 0;
+    return ()=>{
+        state = state + 0x6D2B79F5 >>> 0;
+        let t = state;
+        t = Math.imul(t ^ t >>> 15, t | 1);
+        t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+}
+/** Box-Muller, used to draw the BRIEF sampling pattern from a Gaussian around the patch centre. */ function gaussian(random) {
+    const u = Math.max(random(), Number.EPSILON);
+    const v = random();
+    return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+}
+
+const DESCRIPTOR_WORDS = 8;
+const DESCRIPTOR_BITS = DESCRIPTOR_WORDS * 32;
+/** Rotation bins for the steered pattern. 32 bins is 11.25 degrees, finer than ORB's own 12. */ const ANGLE_BINS = 32;
+/** The Bresenham circle of radius 3, clockwise from the top. */ const CIRCLE = [
+    [
+        0,
+        -3
+    ],
+    [
+        1,
+        -3
+    ],
+    [
+        2,
+        -2
+    ],
+    [
+        3,
+        -1
+    ],
+    [
+        3,
+        0
+    ],
+    [
+        3,
+        1
+    ],
+    [
+        2,
+        2
+    ],
+    [
+        1,
+        3
+    ],
+    [
+        0,
+        3
+    ],
+    [
+        -1,
+        3
+    ],
+    [
+        -2,
+        2
+    ],
+    [
+        -3,
+        1
+    ],
+    [
+        -3,
+        0
+    ],
+    [
+        -3,
+        -1
+    ],
+    [
+        -2,
+        -2
+    ],
+    [
+        -1,
+        -3
+    ]
+];
+const ARC = 9;
+const COMPASS_MINIMUM = Math.floor((ARC - 1) / 4);
+function detectAndDescribe(image, options = {}) {
+    const { maxFeatures = 1200, fastThreshold = 0.08, levels = 3, scaleFactor = 1.3, patchSize = 31, gridSize = 8, seed = 0xB81EF } = options;
+    const patterns = steeredPatterns(patchSize, seed);
+    const halfPatch = (patchSize - 1) / 2;
+    const border = Math.ceil(halfPatch * Math.SQRT2) + 2;
+    const keypoints = [];
+    const descriptorChunks = [];
+    const perLevel = Math.ceil(maxFeatures / levels);
+    for(let level = 0; level < levels; level++){
+        const levelScale = scaleFactor ** level;
+        const width = Math.round(image.width / levelScale);
+        const height = Math.round(image.height / levelScale);
+        if (width < border * 2 + 8 || height < border * 2 + 8) break;
+        const levelImage = level === 0 ? image : resizeGray(image, width, height);
+        // BRIEF compares single pixels, so it is exquisitely sensitive to noise;
+        // the smoothing is part of the descriptor, not a preprocessing nicety.
+        const smoothed = boxBlur(levelImage, 2);
+        const found = detectFast(levelImage, fastThreshold, border);
+        const kept = distribute(found, width, height, gridSize, perLevel);
+        for (const corner of kept){
+            const angle = orientation(levelImage, corner.x, corner.y, halfPatch);
+            const bin = angleBin(angle);
+            const descriptor = describe(smoothed, corner.x, corner.y, patterns[bin]);
+            if (descriptor === null) continue;
+            descriptorChunks.push(descriptor);
+            keypoints.push({
+                x: (corner.x + 0.5) * levelScale,
+                y: (corner.y + 0.5) * levelScale,
+                score: corner.score,
+                angle,
+                level,
+                size: patchSize * levelScale
+            });
+        }
+    }
+    const descriptors = new Uint32Array(descriptorChunks.length * DESCRIPTOR_WORDS);
+    for (const [i, chunk] of descriptorChunks.entries())descriptors.set(chunk, i * DESCRIPTOR_WORDS);
+    return {
+        keypoints,
+        descriptors
+    };
+}
+/** FAST-9 with a 3x3 non-maximum suppression pass over the corner scores. */ function detectFast(image, threshold, border) {
+    const { width, height, data } = image;
+    const scores = new Float32Array(width * height);
+    const ring = new Float64Array(16);
+    for(let y = border; y < height - border; y++){
+        for(let x = border; x < width - border; x++){
+            const center = data[y * width + x];
+            const high = center + threshold;
+            const low = center - threshold;
+            // Cheap rejection on the four compass points, which sit 4 apart on the
+            // ring. Any run of ARC consecutive pixels must contain at least
+            // floor((ARC - 1) / 4) of them, so fewer than that cannot be a corner.
+            // For ARC = 9 that bound is 2, not the 3 that the widely quoted FAST-12
+            // version of this test uses - requiring 3 here silently discards real
+            // corners, among them the corner of a plain filled rectangle.
+            let bright = 0;
+            let dark = 0;
+            for (const k of [
+                0,
+                4,
+                8,
+                12
+            ]){
+                const value = data[(y + CIRCLE[k][1]) * width + x + CIRCLE[k][0]];
+                if (value > high) bright++;
+                else if (value < low) dark++;
+            }
+            if (bright < COMPASS_MINIMUM && dark < COMPASS_MINIMUM) continue;
+            for(let k = 0; k < 16; k++)ring[k] = data[(y + CIRCLE[k][1]) * width + x + CIRCLE[k][0]];
+            if (!hasArc(ring, high, low)) continue;
+            let brightSum = 0;
+            let darkSum = 0;
+            for(let k = 0; k < 16; k++){
+                if (ring[k] > high) brightSum += ring[k] - high;
+                else if (ring[k] < low) darkSum += low - ring[k];
+            }
+            scores[y * width + x] = Math.max(brightSum, darkSum);
+        }
+    }
+    const corners = [];
+    for(let y = border; y < height - border; y++){
+        for(let x = border; x < width - border; x++){
+            const score = scores[y * width + x];
+            if (score <= 0) continue;
+            let isPeak = true;
+            for(let dy = -1; isPeak && dy <= 1; dy++)for(let dx = -1; dx <= 1; dx++){
+                if (dx === 0 && dy === 0) continue;
+                if (scores[(y + dy) * width + x + dx] > score) {
+                    isPeak = false;
+                    break;
+                }
+            }
+            if (isPeak) corners.push({
+                x,
+                y,
+                score
+            });
+        }
+    }
+    return corners;
+}
+/** True when 9 consecutive ring pixels (wrapping) are all above `high` or all below `low`. */ function hasArc(ring, high, low) {
+    let runBright = 0;
+    let runDark = 0;
+    for(let k = 0; k < 16 + ARC - 1; k++){
+        const value = ring[k % 16];
+        runBright = value > high ? runBright + 1 : 0;
+        runDark = value < low ? runDark + 1 : 0;
+        if (runBright >= ARC || runDark >= ARC) return true;
+    }
+    return false;
+}
+/**
+ * Keep the strongest corners, but spread over the page.
+ *
+ * Score alone concentrates every keypoint in the densest block of text, and a
+ * transform fitted to correspondences from one corner of the page extrapolates
+ * badly to the other three. Filling a grid first, then topping up from what is
+ * left, buys coverage without throwing away the best corners.
+ */ function distribute(corners, width, height, gridSize, budget) {
+    if (corners.length <= budget) return corners;
+    const cells = new Map();
+    const cellWidth = width / gridSize;
+    const cellHeight = height / gridSize;
+    for (const corner of corners){
+        const cx = Math.min(gridSize - 1, Math.floor(corner.x / cellWidth));
+        const cy = Math.min(gridSize - 1, Math.floor(corner.y / cellHeight));
+        const key = cy * gridSize + cx;
+        const bucket = cells.get(key);
+        if (bucket === undefined) cells.set(key, [
+            corner
+        ]);
+        else bucket.push(corner);
+    }
+    const perCell = Math.max(1, Math.floor(budget / Math.max(1, cells.size)));
+    const kept = [];
+    const leftovers = [];
+    for (const bucket of cells.values()){
+        bucket.sort((a, b)=>b.score - a.score);
+        kept.push(...bucket.slice(0, perCell));
+        leftovers.push(...bucket.slice(perCell));
+    }
+    if (kept.length < budget) {
+        leftovers.sort((a, b)=>b.score - a.score);
+        kept.push(...leftovers.slice(0, budget - kept.length));
+    }
+    // With more cells than budget the floor above rounds to one per cell, which
+    // can overshoot; the budget is a promise, so trim by score.
+    if (kept.length > budget) {
+        kept.sort((a, b)=>b.score - a.score);
+        return kept.slice(0, budget);
+    }
+    return kept;
+}
+/**
+ * Angle from the patch centre to its centre of intensity mass.
+ *
+ * On an ink image the mass is the writing, so the angle turns with the page —
+ * which is the entire trick that makes a binary descriptor rotation invariant.
+ */ function orientation(image, cx, cy, radius) {
+    const { width, height, data } = image;
+    const r = Math.floor(radius);
+    let m10 = 0;
+    let m01 = 0;
+    for(let dy = -r; dy <= r; dy++){
+        const y = cy + dy;
+        if (y < 0 || y >= height) continue;
+        const span = Math.floor(Math.sqrt(r * r - dy * dy));
+        const row = y * width;
+        for(let dx = -span; dx <= span; dx++){
+            const x = cx + dx;
+            if (x < 0 || x >= width) continue;
+            const value = data[row + x];
+            m10 += dx * value;
+            m01 += dy * value;
+        }
+    }
+    return Math.atan2(m01, m10);
+}
+function angleBin(angle) {
+    const twoPi = Math.PI * 2;
+    const normalized = (angle % twoPi + twoPi) % twoPi;
+    return Math.floor(normalized / twoPi * ANGLE_BINS) % ANGLE_BINS;
+}
+function describe(image, cx, cy, pattern) {
+    const { width, height, data } = image;
+    const out = new Uint32Array(DESCRIPTOR_WORDS);
+    for(let bit = 0; bit < DESCRIPTOR_BITS; bit++){
+        const base = bit * 4;
+        const x1 = cx + pattern[base];
+        const y1 = cy + pattern[base + 1];
+        const x2 = cx + pattern[base + 2];
+        const y2 = cy + pattern[base + 3];
+        if (x1 < 0 || y1 < 0 || x2 < 0 || y2 < 0 || x1 >= width || y1 >= height || x2 >= width || y2 >= height) return null;
+        if (data[y1 * width + x1] < data[y2 * width + x2]) out[bit >> 5] |= 1 << (bit & 31);
+    }
+    return out;
+}
+const patternCache = new Map();
+/**
+ * One integer sampling pattern per rotation bin, built once and cached.
+ *
+ * Rotating 256 point pairs per keypoint would mean a thousand trig calls each;
+ * quantising the angle instead turns the whole thing into a table lookup, at a
+ * cost of at most half a bin of angular error.
+ */ function steeredPatterns(patchSize, seed) {
+    const key = `${patchSize}:${seed}`;
+    const cached = patternCache.get(key);
+    if (cached !== undefined) return cached;
+    const half = (patchSize - 1) / 2;
+    const sigma = patchSize / 5;
+    const random = createRandom(seed);
+    const base = new Float64Array(DESCRIPTOR_BITS * 4);
+    for(let i = 0; i < DESCRIPTOR_BITS * 4; i++)base[i] = clamp(Math.round(gaussian(random) * sigma), -half, half);
+    const patterns = [];
+    for(let bin = 0; bin < ANGLE_BINS; bin++){
+        const angle = bin / ANGLE_BINS * Math.PI * 2;
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        const rotated = new Int32Array(DESCRIPTOR_BITS * 4);
+        for(let i = 0; i < DESCRIPTOR_BITS * 4; i += 2){
+            const x = base[i];
+            const y = base[i + 1];
+            rotated[i] = Math.round(cos * x - sin * y);
+            rotated[i + 1] = Math.round(sin * x + cos * y);
+        }
+        patterns.push(rotated);
+    }
+    patternCache.set(key, patterns);
+    return patterns;
+}
+function clamp(value, min, max) {
+    return value < min ? min : Math.min(value, max);
+}
+
+/**
+ * "No candidate yet", as a value an Int32Array can actually hold.
+ *
+ * `Number.MAX_SAFE_INTEGER` cannot: writing it to an Int32Array truncates it to
+ * -1, and every subsequent "is this closer?" comparison then answers no.
+ */ const UNSET = 0x7FFFFFFF;
+function matchFeatures(source, target, options = {}) {
+    const { ratio = 0.8, maxDistance = 96, crossCheck = true, maxDisplacement = Infinity } = options;
+    const n = source.keypoints.length;
+    const m = target.keypoints.length;
+    if (n === 0 || m === 0) return [];
+    const bestForSource = new Int32Array(n).fill(-1);
+    const bestDistance = new Int32Array(n).fill(UNSET);
+    const secondDistance = new Int32Array(n).fill(UNSET);
+    const bestForTarget = new Int32Array(m).fill(-1);
+    const bestTargetDistance = new Int32Array(m).fill(UNSET);
+    const gated = Number.isFinite(maxDisplacement);
+    const gate = maxDisplacement * maxDisplacement;
+    for(let i = 0; i < n; i++){
+        const a = source.keypoints[i];
+        const offsetA = i * DESCRIPTOR_WORDS;
+        let first = UNSET;
+        let second = UNSET;
+        let firstIndex = -1;
+        for(let j = 0; j < m; j++){
+            const b = target.keypoints[j];
+            if (gated) {
+                const dx = a.x - b.x;
+                const dy = a.y - b.y;
+                if (dx * dx + dy * dy > gate) continue;
+            }
+            const distance = hamming(source.descriptors, offsetA, target.descriptors, j * DESCRIPTOR_WORDS);
+            if (distance < first) {
+                second = first;
+                first = distance;
+                firstIndex = j;
+            } else if (distance < second) {
+                second = distance;
+            }
+            if (distance < bestTargetDistance[j]) {
+                bestTargetDistance[j] = distance;
+                bestForTarget[j] = i;
+            }
+        }
+        bestForSource[i] = firstIndex;
+        bestDistance[i] = first;
+        secondDistance[i] = second;
+    }
+    const matches = [];
+    for(let i = 0; i < n; i++){
+        const j = bestForSource[i];
+        if (j < 0) continue;
+        if (bestDistance[i] > maxDistance) continue;
+        if (secondDistance[i] !== UNSET && bestDistance[i] > ratio * secondDistance[i]) continue;
+        if (crossCheck && bestForTarget[j] !== i) continue;
+        const a = source.keypoints[i];
+        const b = target.keypoints[j];
+        matches.push({
+            source: {
+                x: a.x,
+                y: a.y
+            },
+            target: {
+                x: b.x,
+                y: b.y
+            },
+            distance: bestDistance[i]
+        });
+    }
+    return matches;
+}
+/** Hamming distance between two 256-bit descriptors. */ function hamming(a, offsetA, b, offsetB) {
+    let total = 0;
+    for(let k = 0; k < DESCRIPTOR_WORDS; k++)total += popcount(a[offsetA + k] ^ b[offsetB + k]);
+    return total;
+}
+/** SWAR bit count: pair off, then nibble off, then one multiply to sum the bytes. */ function popcount(value) {
+    let v = value - (value >> 1 & 0x55555555);
+    v = (v & 0x33333333) + (v >> 2 & 0x33333333);
+    v = v + (v >> 4) & 0x0F0F0F0F;
+    return Math.imul(v, 0x01010101) >> 24 & 0xFF;
+}
+
+/**
+ * The two dense solvers the estimators need, and nothing more.
+ *
+ * Both work on plain row-major `Float64Array`s of a fixed, tiny size (n <= 9),
+ * so there is no pivoting strategy worth agonising over and no allocation
+ * pressure worth caring about.
+ */ /**
+ * Solve `A x = b` by Gaussian elimination with partial pivoting.
+ *
+ * `a` is destroyed. Returns `null` when the system is singular, which for the
+ * affine fit means the sample points were collinear — a real, common case, not
+ * an exceptional one, so it is a return value rather than a throw.
+ */ function solve(a, b, n) {
+    const m = Float64Array.from(a);
+    const x = Float64Array.from(b);
+    for(let col = 0; col < n; col++){
+        let pivot = col;
+        let best = Math.abs(m[col * n + col]);
+        for(let row = col + 1; row < n; row++){
+            const v = Math.abs(m[row * n + col]);
+            if (v > best) {
+                best = v;
+                pivot = row;
+            }
+        }
+        if (best < 1e-12) return null;
+        if (pivot !== col) {
+            for(let k = 0; k < n; k++){
+                const t = m[col * n + k];
+                m[col * n + k] = m[pivot * n + k];
+                m[pivot * n + k] = t;
+            }
+            const t = x[col];
+            x[col] = x[pivot];
+            x[pivot] = t;
+        }
+        const diag = m[col * n + col];
+        for(let row = col + 1; row < n; row++){
+            const factor = m[row * n + col] / diag;
+            if (factor === 0) continue;
+            for(let k = col; k < n; k++)m[row * n + k] -= factor * m[col * n + k];
+            x[row] -= factor * x[col];
+        }
+    }
+    for(let row = n - 1; row >= 0; row--){
+        let sum = x[row];
+        for(let k = row + 1; k < n; k++)sum -= m[row * n + k] * x[k];
+        x[row] = sum / m[row * n + row];
+    }
+    return x;
+}
+/**
+ * Eigen-decompose a symmetric matrix with the cyclic Jacobi method.
+ *
+ * Jacobi is the right tool at this size: it is a dozen lines, it is
+ * unconditionally stable for symmetric input, and it gives eigenvectors for
+ * free. The homography fit needs the eigenvector of `A^T A` belonging to the
+ * smallest eigenvalue — the direction the data constrains least, which is the
+ * null-space direction we are after.
+ *
+ * @param input Row-major, `n * n`, symmetric. Not modified.
+ * @returns `values[i]` paired with column `i` of `vectors` (`vectors[row * n + i]`).
+ */ function jacobiEigen(input, n, maxSweeps = 60) {
+    const a = Float64Array.from(input);
+    const v = new Float64Array(n * n);
+    for(let i = 0; i < n; i++)v[i * n + i] = 1;
+    for(let sweep = 0; sweep < maxSweeps; sweep++){
+        let off = 0;
+        for(let p = 0; p < n; p++)for(let q = p + 1; q < n; q++)off += a[p * n + q] * a[p * n + q];
+        if (off < 1e-24) break;
+        for(let p = 0; p < n; p++){
+            for(let q = p + 1; q < n; q++){
+                const apq = a[p * n + q];
+                if (Math.abs(apq) < 1e-18) continue;
+                const theta = (a[q * n + q] - a[p * n + p]) / (2 * apq);
+                const t = Math.sign(theta || 1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
+                const c = 1 / Math.sqrt(t * t + 1);
+                const s = t * c;
+                for(let k = 0; k < n; k++){
+                    const akp = a[k * n + p];
+                    const akq = a[k * n + q];
+                    a[k * n + p] = c * akp - s * akq;
+                    a[k * n + q] = s * akp + c * akq;
+                }
+                for(let k = 0; k < n; k++){
+                    const apk = a[p * n + k];
+                    const aqk = a[q * n + k];
+                    a[p * n + k] = c * apk - s * aqk;
+                    a[q * n + k] = s * apk + c * aqk;
+                }
+                for(let k = 0; k < n; k++){
+                    const vkp = v[k * n + p];
+                    const vkq = v[k * n + q];
+                    v[k * n + p] = c * vkp - s * vkq;
+                    v[k * n + q] = s * vkp + c * vkq;
+                }
+            }
+        }
+    }
+    const values = new Float64Array(n);
+    for(let i = 0; i < n; i++)values[i] = a[i * n + i];
+    return {
+        values,
+        vectors: v
+    };
+}
+/** The unit eigenvector of a symmetric `n x n` matrix belonging to its smallest eigenvalue. */ function smallestEigenvector(input, n) {
+    const { values, vectors } = jacobiEigen(input, n);
+    let best = 0;
+    for(let i = 1; i < n; i++)if (values[i] < values[best]) best = i;
+    const out = new Float64Array(n);
+    let norm = 0;
+    for(let row = 0; row < n; row++){
+        out[row] = vectors[row * n + best];
+        norm += out[row] * out[row];
+    }
+    norm = Math.sqrt(norm);
+    if (norm > 0) for(let row = 0; row < n; row++)out[row] /= norm;
+    return out;
+}
+
+/** How many correspondences the model needs before it is determined at all. */ function minimumSamples(model) {
+    switch(model){
+        case 'similarity':
+            {
+                return 2;
+            }
+        case 'affine':
+            {
+                return 3;
+            }
+        case 'homography':
+            {
+                return 4;
+            }
+    }
+}
+function fitModel(model, matches, indices) {
+    switch(model){
+        case 'similarity':
+            {
+                return fitSimilarity(matches, indices);
+            }
+        case 'affine':
+            {
+                return fitAffine(matches, indices);
+            }
+        case 'homography':
+            {
+                return fitHomography(matches, indices);
+            }
+    }
+}
+/**
+ * Least-squares similarity, in closed form.
+ *
+ * No iteration and no matrix inverse: centre both point sets, and the rotation
+ * and scale fall out of two dot products. That closed form is why similarity
+ * survives a RANSAC sample that affine would choke on.
+ */ function fitSimilarity(matches, indices) {
+    const picked = select(matches, indices);
+    if (picked.length < 2) return null;
+    let sx = 0;
+    let sy = 0;
+    let tx = 0;
+    let ty = 0;
+    for (const m of picked){
+        sx += m.source.x;
+        sy += m.source.y;
+        tx += m.target.x;
+        ty += m.target.y;
+    }
+    const n = picked.length;
+    sx /= n;
+    sy /= n;
+    tx /= n;
+    ty /= n;
+    let dot = 0;
+    let cross = 0;
+    let norm = 0;
+    for (const m of picked){
+        const px = m.source.x - sx;
+        const py = m.source.y - sy;
+        const qx = m.target.x - tx;
+        const qy = m.target.y - ty;
+        dot += px * qx + py * qy;
+        cross += px * qy - py * qx;
+        norm += px * px + py * py;
+    }
+    if (norm < 1e-12) return null;
+    const a = dot / norm;
+    const b = cross / norm;
+    if (Math.hypot(a, b) < 1e-9) return null;
+    return [
+        a,
+        -b,
+        tx - a * sx + b * sy,
+        b,
+        a,
+        ty - b * sx - a * sy,
+        0,
+        0,
+        1
+    ];
+}
+/** Least-squares affine: two independent 3x3 normal systems sharing one matrix. */ function fitAffine(matches, indices) {
+    const picked = select(matches, indices);
+    if (picked.length < 3) return null;
+    const m = new Float64Array(9);
+    const bx = new Float64Array(3);
+    const by = new Float64Array(3);
+    for (const match of picked){
+        const { x, y } = match.source;
+        const { x: u, y: v } = match.target;
+        m[0] += x * x;
+        m[1] += x * y;
+        m[2] += x;
+        m[4] += y * y;
+        m[5] += y;
+        m[8] += 1;
+        bx[0] += x * u;
+        bx[1] += y * u;
+        bx[2] += u;
+        by[0] += x * v;
+        by[1] += y * v;
+        by[2] += v;
+    }
+    m[3] = m[1];
+    m[6] = m[2];
+    m[7] = m[5];
+    const row0 = solve(m, bx, 3);
+    const row1 = solve(m, by, 3);
+    if (row0 === null || row1 === null) return null;
+    return [
+        row0[0],
+        row0[1],
+        row0[2],
+        row1[0],
+        row1[1],
+        row1[2],
+        0,
+        0,
+        1
+    ];
+}
+/**
+ * Direct Linear Transform with Hartley normalisation.
+ *
+ * The normalisation is not optional polish. Raw pixel coordinates put entries
+ * like `x * u` (order 10^6) next to a constant 1 in the same row, and the
+ * eigen solve then answers a question dominated by the big column. Centring
+ * each point set and scaling it to a mean radius of `sqrt(2)` puts every
+ * column on the same footing; the result is mapped back afterwards.
+ */ function fitHomography(matches, indices) {
+    const picked = select(matches, indices);
+    if (picked.length < 4) return null;
+    const sourceNorm = normalizer(picked.map((m)=>m.source));
+    const targetNorm = normalizer(picked.map((m)=>m.target));
+    if (sourceNorm === null || targetNorm === null) return null;
+    // Accumulate A^T A directly: 9x9 regardless of how many points there are.
+    const ata = new Float64Array(81);
+    const row = new Float64Array(9);
+    for (const match of picked){
+        const p = apply(sourceNorm, match.source.x, match.source.y);
+        const q = apply(targetNorm, match.target.x, match.target.y);
+        row.set([
+            -p.x,
+            -p.y,
+            -1,
+            0,
+            0,
+            0,
+            q.x * p.x,
+            q.x * p.y,
+            q.x
+        ]);
+        accumulate(ata, row);
+        row.set([
+            0,
+            0,
+            0,
+            -p.x,
+            -p.y,
+            -1,
+            q.y * p.x,
+            q.y * p.y,
+            q.y
+        ]);
+        accumulate(ata, row);
+    }
+    const h = smallestEigenvector(ata, 9);
+    const normalized = [
+        h[0],
+        h[1],
+        h[2],
+        h[3],
+        h[4],
+        h[5],
+        h[6],
+        h[7],
+        h[8]
+    ];
+    let denormalized;
+    try {
+        denormalized = multiply(invert(targetNorm), multiply(normalized, sourceNorm));
+    } catch (unused) {
+        return null;
+    }
+    const scale = denormalized[8];
+    if (!Number.isFinite(scale) || Math.abs(scale) < 1e-12) return null;
+    return denormalized.map((v)=>v / scale);
+}
+function accumulate(ata, row) {
+    for(let i = 0; i < 9; i++){
+        const vi = row[i];
+        if (vi === 0) continue;
+        for(let j = 0; j < 9; j++)ata[i * 9 + j] += vi * row[j];
+    }
+}
+/** Translate to the centroid and scale so the mean distance from it is `sqrt(2)`. */ function normalizer(points) {
+    let cx = 0;
+    let cy = 0;
+    for (const p of points){
+        cx += p.x;
+        cy += p.y;
+    }
+    cx /= points.length;
+    cy /= points.length;
+    let distance = 0;
+    for (const p of points)distance += Math.hypot(p.x - cx, p.y - cy);
+    distance /= points.length;
+    // Explicit about NaN: a degenerate point set must fail, not divide.
+    if (Number.isNaN(distance) || distance <= 1e-9) return null;
+    const s = Math.SQRT2 / distance;
+    return [
+        s,
+        0,
+        -s * cx,
+        0,
+        s,
+        -s * cy,
+        0,
+        0,
+        1
+    ];
+}
+function apply(m, x, y) {
+    return {
+        x: m[0] * x + m[1] * y + m[2],
+        y: m[3] * x + m[4] * y + m[5]
+    };
+}
+function select(matches, indices) {
+    return indices === undefined ? matches : indices.map((i)=>matches[i]);
+}
+
+function ransac(matches, options) {
+    var _options_minInliers;
+    const { model, threshold, maxIterations = 2000, confidence = 0.995, seed = 0x5CA7F1 } = options;
+    const sampleSize = minimumSamples(model);
+    const minInliers = (_options_minInliers = options.minInliers) != null ? _options_minInliers : Math.max(sampleSize + 2, Math.ceil(matches.length * 0.08));
+    if (matches.length < Math.max(sampleSize, minInliers)) return null;
+    const random = createRandom(seed);
+    const sample = Array.from({
+        length: sampleSize
+    }, ()=>0);
+    let bestInliers = [];
+    let bestMatrix = null;
+    let limit = maxIterations;
+    let iterations = 0;
+    for(; iterations < limit && iterations < maxIterations; iterations++){
+        drawSample(sample, matches.length, random);
+        const candidate = fitModel(model, matches, sample);
+        if (candidate === null || !isPlausible(candidate)) continue;
+        const inliers = findInliers(matches, candidate, threshold);
+        if (inliers.length <= bestInliers.length) continue;
+        bestInliers = inliers;
+        bestMatrix = candidate;
+        // Adaptive stopping: once a large fraction agrees, the chance that more
+        // draws find something better collapses, and so does the budget.
+        const ratio = inliers.length / matches.length;
+        if (ratio > 0 && ratio < 1) {
+            const denominator = Math.log(1 - ratio ** sampleSize);
+            if (denominator < 0) limit = Math.min(maxIterations, Math.ceil(Math.log(1 - confidence) / denominator) + 1);
+        } else if (ratio >= 1) {
+            limit = iterations + 1;
+        }
+    }
+    if (bestMatrix === null || bestInliers.length < minInliers) return null;
+    // Re-fit on every inlier. The minimal sample only ever located the consensus;
+    // the accurate transform comes from all of it.
+    let refined = fitModel(model, matches, bestInliers);
+    if (refined !== null && isPlausible(refined)) {
+        const refinedInliers = findInliers(matches, refined, threshold);
+        if (refinedInliers.length >= bestInliers.length) bestInliers = refinedInliers;
+        else refined = bestMatrix;
+    } else {
+        refined = bestMatrix;
+    }
+    const matrix = refined != null ? refined : bestMatrix;
+    let total = 0;
+    for (const i of bestInliers)total += reprojectionError(matrix, matches[i].source, matches[i].target);
+    return {
+        matrix,
+        inliers: bestInliers,
+        inlierRatio: bestInliers.length / matches.length,
+        iterations,
+        error: bestInliers.length > 0 ? total / bestInliers.length : Infinity
+    };
+}
+function findInliers(matches, matrix, threshold) {
+    const inliers = [];
+    for (const [i, match] of matches.entries())if (reprojectionError(matrix, match.source, match.target) <= threshold) inliers.push(i);
+    return inliers;
+}
+/** Distinct indices, drawn without replacement. */ function drawSample(into, count, random) {
+    for(let i = 0; i < into.length; i++){
+        let candidate = 0;
+        for(let attempt = 0; attempt < 32; attempt++){
+            candidate = Math.min(count - 1, Math.floor(random() * count));
+            let duplicate = false;
+            for(let j = 0; j < i; j++)if (into[j] === candidate) {
+                duplicate = true;
+                break;
+            }
+            if (!duplicate) break;
+        }
+        into[i] = candidate;
+    }
+}
+
+function alignScan(original, scanned, options = {}) {
+    const startedAt = Date.now();
+    const { model = 'similarity', workingSize = 1400, coarseSize = 512, maxFeatures = 1200, ransacThreshold = 3, minInliers = 12, maxSkewDeg = 12, maxScaleRatio = 6, maxDisplacementRatio = 0.12, ink, interpolation = 'bilinear', background = [
+        255,
+        255,
+        255,
+        255
+    ], output = 'png', quality = 92, seed = 0x5CA7F1 } = options;
+    const originalRaster = decodeImage(original);
+    const scannedRaster = decodeImage(scanned);
+    const originalInk = inkMap(toGrayscale(originalRaster), ink);
+    const scannedInk = inkMap(toGrayscale(scannedRaster), ink);
+    const coarse = estimateCoarse(originalInk, scannedInk, {
+        workingSize: coarseSize,
+        maxSkewDeg,
+        maxScaleRatio
+    });
+    const refined = refineWithFeatures(originalInk, scannedInk, coarse, {
+        model,
+        workingSize,
+        maxFeatures,
+        ransacThreshold,
+        minInliers,
+        maxDisplacementRatio,
+        seed
+    });
+    const matrix = refined.matrix;
+    const raster = warpRaster(scannedRaster, matrix, originalRaster.width, originalRaster.height, {
+        background,
+        interpolation,
+        prefilter: true
+    });
+    const agreement = measure(originalInk, scannedInk, matrix, workingSize);
+    return {
+        raster,
+        image: output === 'none' ? null : encodeImage(raster, {
+            format: output,
+            quality
+        }),
+        width: raster.width,
+        height: raster.height,
+        matrix,
+        inverse: invert(matrix),
+        transform: decompose(matrix, model),
+        confidence: Math.max(0, Math.min(1, agreement.correlation)),
+        method: refined.method,
+        diagnostics: {
+            coarseScore: coarse.score,
+            coarseStrategy: coarse.strategy,
+            skewDeg: {
+                original: coarse.skew.original * 180 / Math.PI,
+                scanned: coarse.skew.scanned * 180 / Math.PI
+            },
+            features: refined.features,
+            matches: refined.matches,
+            inliers: refined.inliers,
+            inlierRatio: refined.inlierRatio,
+            reprojectionError: refined.reprojectionError,
+            correlation: agreement.correlation,
+            intersectionOverUnion: agreement.iou,
+            durationMs: Date.now() - startedAt
+        }
+    };
+}
+/**
+ * Match features between the original and the *coarsely corrected* scan.
+ *
+ * Doing it after the coarse warp rather than before is what makes the whole
+ * thing work. The two images now sit at the same scale and nearly the same
+ * angle, so a fixed-offset binary descriptor describes the same thing on both,
+ * and a correspondence that jumps across the page can be rejected on sight.
+ * What RANSAC recovers is only the small residual, which is then composed onto
+ * the coarse transform.
+ */ function refineWithFeatures(originalInk, scannedInk, coarse, options) {
+    const fallback = {
+        matrix: coarse.matrix,
+        method: 'coarse',
+        features: {
+            original: 0,
+            scanned: 0
+        },
+        matches: 0,
+        inliers: 0,
+        inlierRatio: 0,
+        reprojectionError: NaN
+    };
+    const original = downscaleGray(originalInk, options.workingSize);
+    const scanned = downscaleGray(scannedInk, options.workingSize);
+    // The coarse matrix speaks full-resolution pixels; restate it between the two
+    // working frames, which were shrunk by different amounts.
+    const coarseWork = rebase(coarse.matrix, 1 / original.scale, 1 / scanned.scale);
+    const rough = warpGray(scanned.image, coarseWork, original.image.width, original.image.height, 0);
+    const originalFeatures = detectAndDescribe(original.image, {
+        maxFeatures: options.maxFeatures,
+        seed: options.seed
+    });
+    const scannedFeatures = detectAndDescribe(rough, {
+        maxFeatures: options.maxFeatures,
+        seed: options.seed
+    });
+    const counts = {
+        original: originalFeatures.keypoints.length,
+        scanned: scannedFeatures.keypoints.length
+    };
+    const diagonal = Math.hypot(original.image.width, original.image.height);
+    const matches = matchFeatures(originalFeatures, scannedFeatures, {
+        maxDisplacement: diagonal * options.maxDisplacementRatio
+    });
+    const consensus = ransac(matches, {
+        model: options.model,
+        threshold: options.ransacThreshold,
+        minInliers: options.minInliers,
+        seed: options.seed
+    });
+    if (consensus === null) return _extends({}, fallback, {
+        features: counts,
+        matches: matches.length
+    });
+    // RANSAC's matrix maps the original's working frame onto the rough warp,
+    // which lives in that same frame. Scale it back up, then compose: original ->
+    // rough -> scan.
+    const residual = conjugateScale(consensus.matrix, original.scale);
+    return {
+        matrix: multiply(coarse.matrix, residual),
+        method: 'features',
+        features: counts,
+        matches: matches.length,
+        inliers: consensus.inliers.length,
+        inlierRatio: consensus.inlierRatio,
+        reprojectionError: consensus.error
+    };
+}
+/** Ink correlation and mask overlap after warping, computed at a modest resolution. */ function measure(originalInk, scannedInk, matrix, workingSize) {
+    const original = downscaleGray(originalInk, Math.min(workingSize, 800));
+    const scanned = downscaleGray(scannedInk, Math.min(workingSize, 800));
+    const work = rebase(matrix, 1 / original.scale, 1 / scanned.scale);
+    const warped = warpGray(scanned.image, work, original.image.width, original.image.height, 0);
+    return {
+        correlation: correlation(original.image, warped),
+        iou: intersectionOverUnion(binarize(original.image), binarize(warped))
+    };
+}
+/**
+ * Nudge an existing transform by whatever residual translation is still measurable.
+ *
+ * Exposed because it is occasionally useful on its own: if you already know the
+ * transform from a previous page of the same batch, this re-seats it on the
+ * current page for a fraction of the cost of a full alignment.
+ */ function polishTranslation(originalInk, scannedInk, matrix, workingSize = 512) {
+    const original = downscaleGray(originalInk, workingSize);
+    const scanned = downscaleGray(scannedInk, workingSize);
+    const work = rebase(matrix, 1 / original.scale, 1 / scanned.scale);
+    const warped = warpGray(scanned.image, work, original.image.width, original.image.height, 0);
+    const shift = phaseCorrelate(original.image, warped);
+    if (!Number.isFinite(shift.dx) || !Number.isFinite(shift.dy)) return matrix;
+    const corrected = multiply(work, translation(shift.dx, shift.dy));
+    const candidate = rebase(corrected, original.scale, scanned.scale);
+    const before = correlation(original.image, warped);
+    const after = correlation(original.image, warpGray(scanned.image, corrected, original.image.width, original.image.height, 0));
+    return after > before ? candidate : matrix;
+}
+
+/**
+ * Compare an aligned scan against its original over a set of known rectangles.
+ *
+ * `aligned` must be the output of `alignScan` - or anything else already on the
+ * original's canvas. Feeding a raw scan in produces confident nonsense, because
+ * every rectangle then names a different part of the page in each image.
+ */ function compareRegions(original, aligned, regions, options = {}) {
+    const { tolerance = 2, threshold = 0.02, ink } = options;
+    const masks = buildMasks(original, aligned, ink, tolerance);
+    return regions.map((region)=>report(region, masks, threshold));
+}
+/** Page-wide added/removed ink, plus per-region detail for any regions supplied. */ function diffDocument(original, aligned, regions = [], options = {}) {
+    const { tolerance = 2, threshold = 0.02, ink } = options;
+    const masks = buildMasks(original, aligned, ink, tolerance);
+    const full = {
+        x: 0,
+        y: 0,
+        width: masks.width,
+        height: masks.height
+    };
+    const whole = report({
+        id: '__document__',
+        rect: full
+    }, masks, threshold);
+    return {
+        added: whole.added,
+        removed: whole.removed,
+        regions: regions.map((region)=>report(region, masks, threshold))
+    };
+}
+/**
+ * An RGBA overlay of the comparison, for looking at with your own eyes.
+ *
+ * Red is ink the scan added, blue is ink it lost, grey is ink both agree on.
+ * A correctly aligned pair of a signed form is almost entirely grey with a red
+ * signature; a misaligned one is red and blue confetti along every stroke,
+ * which is the fastest way to tell the two failures apart.
+ */ function renderDiff(original, aligned, options = {}) {
+    const { tolerance = 2, ink } = options;
+    const masks = buildMasks(original, aligned, ink, tolerance);
+    const { width, height } = masks;
+    const data = new Uint8ClampedArray(width * height * 4);
+    for(let i = 0, p = 0; p < width * height; p++, i += 4){
+        const inOriginal = masks.original.data[p] === 1;
+        const inScan = masks.scan.data[p] === 1;
+        const nearOriginal = masks.originalDilated.data[p] === 1;
+        let r = 255;
+        let g = 255;
+        let b = 255;
+        if (inScan && !nearOriginal) {
+            r = 220;
+            g = 30;
+            b = 40;
+        } else if (inOriginal && masks.scanDilated.data[p] === 0) {
+            r = 40;
+            g = 90;
+            b = 220;
+        } else if (inOriginal || inScan) {
+            r = 110;
+            g = 110;
+            b = 110;
+        }
+        data[i] = r;
+        data[i + 1] = g;
+        data[i + 2] = b;
+        data[i + 3] = 255;
+    }
+    return {
+        width,
+        height,
+        data
+    };
+}
+function buildMasks(original, aligned, ink, tolerance) {
+    const originalRaster = decodeImage(original);
+    const alignedRaster = decodeImage(aligned);
+    if (originalRaster.width !== alignedRaster.width || originalRaster.height !== alignedRaster.height) throw new Error(`compareRegions needs both images on the same canvas: got ${originalRaster.width}x${originalRaster.height} and ${alignedRaster.width}x${alignedRaster.height}. Align the scan first.`);
+    const originalMask = binarize(inkMap(toGrayscale(originalRaster), ink));
+    const scanMask = binarize(inkMap(toGrayscale(alignedRaster), ink));
+    return {
+        width: originalRaster.width,
+        height: originalRaster.height,
+        original: originalMask,
+        scan: scanMask,
+        originalDilated: dilate(originalMask, tolerance),
+        scanDilated: dilate(scanMask, tolerance)
+    };
+}
+function report(region, masks, defaultThreshold) {
+    var _region_threshold;
+    const { x, y, width, height } = region.rect;
+    const left = Math.max(0, Math.floor(x));
+    const top = Math.max(0, Math.floor(y));
+    const right = Math.min(masks.width, Math.ceil(x + width));
+    const bottom = Math.min(masks.height, Math.ceil(y + height));
+    if (right <= left || bottom <= top) return {
+        id: region.id,
+        rect: region.rect,
+        originalInk: 0,
+        scanInk: 0,
+        added: 0,
+        removed: 0,
+        filled: false,
+        score: 0
+    };
+    const threshold = (_region_threshold = region.threshold) != null ? _region_threshold : defaultThreshold;
+    let added = 0;
+    let removed = 0;
+    for(let row = top; row < bottom; row++){
+        const offset = row * masks.width;
+        for(let column = left; column < right; column++){
+            const p = offset + column;
+            if (masks.scan.data[p] === 1 && masks.originalDilated.data[p] === 0) added++;
+            if (masks.original.data[p] === 1 && masks.scanDilated.data[p] === 0) removed++;
+        }
+    }
+    const area = (right - left) * (bottom - top);
+    const addedRatio = added / area;
+    return {
+        id: region.id,
+        rect: region.rect,
+        originalInk: coverage(masks.original, left, top, right, bottom),
+        scanInk: coverage(masks.scan, left, top, right, bottom),
+        added: addedRatio,
+        removed: removed / area,
+        filled: addedRatio >= threshold,
+        score: threshold > 0 ? Math.min(1, addedRatio / threshold) : 0
+    };
+}
+
+/**
+ * A plausible printed form: header rule, paragraphs, a table, tick boxes, a
+ * signature box. Deterministic for a given seed.
+ */ function createSyntheticDocument(options = {}) {
+    var _options_signatureBox;
+    const { width = 850, height = 1100, seed = 42 } = options;
+    const random = createRandom(seed);
+    const page = {
+        width,
+        height,
+        data: new Uint8ClampedArray(width * height * 4).fill(255)
+    };
+    // The layout is written once against a nominal 850x1100 page and scaled to
+    // whatever was asked for. Laying it out in absolute pixels instead means a
+    // smaller page silently loses its last few elements off the bottom edge -
+    // including, on a form, the signature box.
+    const scale = Math.min(width / 850, height / 1100);
+    const unit = (value)=>value * scale;
+    const margin = Math.round(unit(76));
+    const right = width - margin;
+    const lineHeight = Math.max(4, unit(21));
+    const textHeight = Math.max(2, Math.round(unit(9)));
+    let y = margin;
+    fillRect(page, {
+        x: margin,
+        y,
+        width: Math.round((right - margin) * 0.44),
+        height: Math.max(3, unit(26))
+    }, 20);
+    y += unit(54);
+    drawLine(page, margin, y, right, y, Math.max(1, unit(3)), 40);
+    y += unit(34);
+    // Fixed line counts rather than random ones, so the page always fits.
+    for (const lines of [
+        3,
+        4,
+        5,
+        6
+    ]){
+        for(let line = 0; line < lines; line++){
+            drawTextLine(page, margin, y, right, textHeight, random);
+            y += lineHeight;
+        }
+        y += unit(18);
+    }
+    const tableTop = y;
+    const rows = 5;
+    const columns = 4;
+    const rowHeight = Math.max(6, unit(30));
+    const columnWidth = (right - margin) / columns;
+    const ruleWidth = Math.max(1, unit(2));
+    for(let r = 0; r <= rows; r++)drawLine(page, margin, tableTop + r * rowHeight, right, tableTop + r * rowHeight, ruleWidth, 60);
+    for(let c = 0; c <= columns; c++)drawLine(page, margin + c * columnWidth, tableTop, margin + c * columnWidth, tableTop + rows * rowHeight, ruleWidth, 60);
+    for(let r = 0; r < rows; r++)for(let c = 0; c < columns; c++)drawTextLine(page, margin + c * columnWidth + unit(8), tableTop + r * rowHeight + rowHeight * 0.36, margin + (c + 1) * columnWidth - unit(8), textHeight, random);
+    y = tableTop + rows * rowHeight + unit(46);
+    const regions = {};
+    const boxSize = Math.max(6, Math.round(unit(18)));
+    for(let i = 0; i < 3; i++){
+        const box = {
+            x: margin + i * unit(150),
+            y,
+            width: boxSize,
+            height: boxSize
+        };
+        strokeRect(page, box, Math.max(1, unit(2)), 30);
+        regions[`tick-${i + 1}`] = box;
+    }
+    y += unit(70);
+    const signature = (_options_signatureBox = options.signatureBox) != null ? _options_signatureBox : {
+        x: margin,
+        y,
+        width: Math.round((right - margin) * 0.55),
+        height: Math.max(12, Math.round(unit(78)))
+    };
+    strokeRect(page, signature, Math.max(1, unit(2)), 30);
+    regions.signature = signature;
+    regions.stamp = {
+        x: right - Math.round(unit(150)),
+        y,
+        width: Math.round(unit(150)),
+        height: signature.height
+    };
+    return {
+        raster: page,
+        regions
+    };
+}
+/** Scribble inside a rectangle, the way a signature crosses a signature box. */ function drawSignature(page, box, seed = 7) {
+    const random = createRandom(seed);
+    const points = 9;
+    const baseline = box.y + box.height * 0.62;
+    let previousX = box.x + box.width * 0.06;
+    let previousY = baseline;
+    for(let i = 1; i <= points; i++){
+        const x = box.x + box.width * (0.06 + 0.86 * i / points);
+        const y = baseline - box.height * (0.05 + random() * 0.42) * (i % 2 === 0 ? 1 : -0.45);
+        drawLine(page, previousX, previousY, x, y, 3, 25);
+        previousX = x;
+        previousY = y;
+    }
+}
+/** Fill a tick box, the way a pen does. */ function drawTick(page, box) {
+    const { x, y, width, height } = box;
+    drawLine(page, x + width * 0.15, y + height * 0.5, x + width * 0.42, y + height * 0.82, 3, 20);
+    drawLine(page, x + width * 0.42, y + height * 0.82, x + width * 0.88, y + height * 0.12, 3, 20);
+}
+/**
+ * Put a page through everything a scanner does to it, and report the matrix used.
+ *
+ * Order matters and mirrors the physical one: the page is placed on the glass
+ * somewhere, at some angle, and sampled at some resolution (the geometry);
+ * then the lamp falls off towards one corner, the optics blur, and the sensor
+ * adds noise (the photometry). Estimators that only ever see clean geometric
+ * distortion pass tests and fail on real scans.
+ */ function simulateScan(page, options = {}) {
+    var _options_canvas;
+    const { rotationDeg = 0, scale = 1, translateX = 0, translateY = 0, noise = 0, blur = 0, illumination = 0, seed = 1234 } = options;
+    const canvas = (_options_canvas = options.canvas) != null ? _options_canvas : {
+        width: Math.max(8, Math.round(page.width * scale)),
+        height: Math.max(8, Math.round(page.height * scale))
+    };
+    const angle = rotationDeg * Math.PI / 180;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const cx = page.width / 2;
+    const cy = page.height / 2;
+    // Rotate about the page centre, scale, then place that centre in the middle
+    // of the scan canvas plus the requested offset.
+    const rotateAboutCentre = [
+        cos,
+        -sin,
+        cx - cos * cx + sin * cy,
+        sin,
+        cos,
+        cy - sin * cx - cos * cy,
+        0,
+        0,
+        1
+    ];
+    const place = translation(canvas.width / 2 - cx * scale + translateX, canvas.height / 2 - cy * scale + translateY);
+    const forward = multiply(place, multiply(scaling(scale), rotateAboutCentre));
+    let raster = warpRaster(page, invert(forward), canvas.width, canvas.height, {
+        background: [
+            255,
+            255,
+            255,
+            255
+        ],
+        interpolation: 'bilinear',
+        prefilter: true
+    });
+    if (blur > 0) raster = boxBlurRaster(raster, blur);
+    if (illumination > 0) applyIllumination(raster, illumination);
+    if (noise > 0) applyNoise(raster, noise, seed);
+    return {
+        raster,
+        matrix: forward
+    };
+}
+/** A diagonal ramp plus a soft corner shadow: the two things a phone camera always adds. */ function applyIllumination(raster, strength) {
+    const { width, height, data } = raster;
+    for(let y = 0; y < height; y++){
+        for(let x = 0; x < width; x++){
+            const u = x / width;
+            const v = y / height;
+            const ramp = 1 - strength * (0.35 * u + 0.65 * v);
+            const corner = 1 - strength * 0.8 * Math.max(0, 1 - Math.hypot(u, v) * 1.3);
+            const factor = ramp * corner;
+            const i = (y * width + x) * 4;
+            data[i] *= factor;
+            data[i + 1] *= factor;
+            data[i + 2] *= factor;
+        }
+    }
+}
+function applyNoise(raster, sigma, seed) {
+    const random = createRandom(seed);
+    const amplitude = sigma * 255;
+    for(let i = 0; i < raster.data.length; i += 4){
+        const n = (random() + random() + random() - 1.5) * 2 * amplitude;
+        raster.data[i] += n;
+        raster.data[i + 1] += n;
+        raster.data[i + 2] += n;
+    }
+}
+/** One line of "text": dark blocks of word-ish widths with gaps between them. */ function drawTextLine(page, x0, y, x1, height, random) {
+    const unit = height / 9;
+    let x = x0;
+    while(x < x1 - 12 * unit){
+        const word = (14 + Math.floor(random() * 46)) * unit;
+        const end = Math.min(x1, x + word);
+        fillRect(page, {
+            x,
+            y,
+            width: end - x,
+            height
+        }, 35 + Math.floor(random() * 40));
+        x = end + (6 + Math.floor(random() * 6)) * unit;
+    }
+}
+function fillRect(page, rect, value) {
+    const left = Math.max(0, Math.round(rect.x));
+    const top = Math.max(0, Math.round(rect.y));
+    const right = Math.min(page.width, Math.round(rect.x + rect.width));
+    const bottom = Math.min(page.height, Math.round(rect.y + rect.height));
+    for(let y = top; y < bottom; y++){
+        let i = (y * page.width + left) * 4;
+        for(let x = left; x < right; x++, i += 4){
+            page.data[i] = value;
+            page.data[i + 1] = value;
+            page.data[i + 2] = value;
+            page.data[i + 3] = 255;
+        }
+    }
+}
+function strokeRect(page, rect, thickness, value) {
+    const { x, y, width, height } = rect;
+    fillRect(page, {
+        x,
+        y,
+        width,
+        height: thickness
+    }, value);
+    fillRect(page, {
+        x,
+        y: y + height - thickness,
+        width,
+        height: thickness
+    }, value);
+    fillRect(page, {
+        x,
+        y,
+        width: thickness,
+        height
+    }, value);
+    fillRect(page, {
+        x: x + width - thickness,
+        y,
+        width: thickness,
+        height
+    }, value);
+}
+function drawLine(page, x0, y0, x1, y1, thickness, value) {
+    const steps = Math.ceil(Math.hypot(x1 - x0, y1 - y0)) + 1;
+    const half = thickness / 2;
+    for(let i = 0; i <= steps; i++){
+        const t = i / steps;
+        fillRect(page, {
+            x: x0 + (x1 - x0) * t - half,
+            y: y0 + (y1 - y0) * t - half,
+            width: thickness,
+            height: thickness
+        }, value);
+    }
+}
+
+export { IDENTITY, alignScan, applyPoint, binarize, boxBlur, boxBlurRaster, cloneRaster, compareRegions, conjugateScale, contentExtent, correlation, coverage, createBinary, createGray, createRaster, createSyntheticDocument, decodeImage, decompose, detectAndDescribe, determinant, diffDocument, dilate, downscaleGray, drawSignature, drawTick, encodeImage, estimateCoarse, estimateSkew, findInliers, fitAffine, fitHomography, fitModel, fitSimilarity, grayToRaster, hamming, inkMap, intersectionOverUnion, invert, isPlausible, isRaster, mapRectCorners, matchFeatures, mean, minimumSamples, multiply, normalize, otsuThreshold, phaseCorrelate, polishTranslation, popcount, ransac, rebase, renderDiff, reprojectionError, resizeGray, sampleGrayBilinear, scaling, similarity, simulateScan, sniffFormat, toGrayscale, translation, warpGray, warpRaster };
+//# sourceMappingURL=index.esm.js.map