@altnovatrail/canvas 0.0.0-stage → 0.1.1

package/lib/core/page.d.ts

@@ -0,0 +1,62 @@
+import type { WorkbookItem } from "./task.js";
+/** The numbers of the layout (R35), in page units, the type size among them. */
+export interface Layout {
+    /** The type size of the line's text. */
+    readonly size: number;
+    /** A box, the same for the whole task (R34). */
+    readonly boxWidth: number;
+    readonly boxHeight: number;
+    /** The height of a line of text without a box. */
+    readonly line: number;
+    /** Between a line with a box and one without, in an item that wraps. */
+    readonly lead: number;
+    /** Between a box and a word beside it, and between an item's number and its line. */
+    readonly gap: number;
+    /** Between two boxes side by side, and between two lines with boxes in an item that wraps. */
+    readonly apart: number;
+    /** Between two rows of items. */
+    readonly items: number;
+    /** Between the two columns of short lines. */
+    readonly gutter: number;
+    /** The margin of the page on its sides, its top and its bottom. */
+    readonly margin: number;
+}
+/** The layout the workbook has (R35): the sweep of T47 chose it around the box the author chose. */
+export declare const LAYOUT: Layout;
+/** A piece of a line's text, or its part on one line of the page: one `<text>` (R34, R35). */
+export interface PageText {
+    readonly text: string;
+    /** Where it starts, and its alphabetic baseline, in page units. */
+    readonly left: number;
+    readonly baseline: number;
+    /** The width SVG fits it to, `textLength`. */
+    readonly width: number;
+}
+/** A box, an answer slot, in page units, in the names of the format's zone. */
+export interface PageBox {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** An item on the page: its number, its line in the order it is read, and its boxes by slot. */
+export interface PageItem {
+    readonly number: PageText;
+    readonly line: readonly (PageText | PageBox)[];
+    /** The boxes of the line, the same objects as in `line`: slot 1 first. */
+    readonly boxes: readonly PageBox[];
+}
+/** A workbook's page: its items in the task's order, and the bottom of the last row. */
+export interface Page {
+    readonly items: readonly PageItem[];
+    readonly bottom: number;
+}
+/** Whether a part of a line is a box. */
+export declare function isBox(part: PageText | PageBox): part is PageBox;
+/**
+ * The page of a workbook's items (R35): a function of the items alone, in whole units, frozen. A
+ * row that does not fit is a TypeError at the first item of it, `task.items[i]`.
+ */
+export declare function pageOf(items: readonly WorkbookItem[], layout?: Layout): Page;
+/** Whether two pages are the same, part by part. */
+export declare function samePage(a: Page, b: Page): boolean;

package/lib/core/page.js

@@ -0,0 +1,309 @@
+// The layout of a workbook's page (R34, R35): where the template puts each item's number, the
+// pieces of its line and its boxes, in whole page units, from the task's items alone. The page is
+// the sheet's, 1000 × 1400 units (R06), and the boxes stay where the layout puts them on any
+// device: the widths of the text come from the canvas's own table (widths.ts), and SVG fits the
+// text to them. Short lines stand two to a row, in the task's order; a long line takes the page's
+// width and wraps. A task whose lines do not fit is a TypeError: nothing shrinks. The core's entry
+// point does not give the layout, and vectors/pages.json pins its numbers: once released, they
+// change only by a decision, for histories know neither the task nor the layout (R34).
+import { SHEET } from "./sheet.js";
+import { clustersOf, clusterWidth, SPACE, wordsOf, wordWidth } from "./widths.js";
+/** The layout the workbook has (R35): the sweep of T47 chose it around the box the author chose. */
+export const LAYOUT = Object.freeze({
+    size: 30,
+    boxWidth: 100,
+    boxHeight: 100,
+    line: 46,
+    lead: 12,
+    gap: 16,
+    apart: 32,
+    items: 32,
+    gutter: 40,
+    margin: 40,
+});
+/** Whether a part of a line is a box. */
+export function isBox(part) {
+    return "top" in part;
+}
+/** Marks a line does not start with: they close what came before. */
+const CLOSING = ".,:;!?)]}»…";
+/** Marks a line does not end with: they open what comes after. */
+const OPENING = "([{«„";
+function measuresOf(layout) {
+    const numbers = textWidth(layout, wordWidth("00."));
+    const indent = numbers + layout.gap;
+    const content = SHEET.width - 2 * layout.margin;
+    const column = Math.floor((content - layout.gutter) / 2);
+    return {
+        layout,
+        space: textWidth(layout, SPACE),
+        numbers,
+        indent,
+        column,
+        full: content - indent,
+        second: layout.margin + column + layout.gutter,
+        floor: SHEET.height - layout.margin,
+    };
+}
+/** The width of a text of `hundredths` of the size, in whole units, rounded up. */
+function textWidth(layout, hundredths) {
+    const product = layout.size * hundredths;
+    return (product - (product % 100)) / 100 + (product % 100 > 0 ? 1 : 0);
+}
+/**
+ * The page of a workbook's items (R35): a function of the items alone, in whole units, frozen. A
+ * row that does not fit is a TypeError at the first item of it, `task.items[i]`.
+ */
+export function pageOf(items, layout = LAYOUT) {
+    const measures = measuresOf(layout);
+    // Each item's line as one line, worked out once: whether it is short, and its entries.
+    const lines = [];
+    const lineOf = (n) => {
+        lines[n] ??= entriesOf(tokensOf(items[n]), measures);
+        return lines[n];
+    };
+    const short = (n) => n < items.length && partsOf(lineOf(n), measures).width <= measures.column - measures.indent;
+    const placed = [];
+    let top = layout.margin;
+    let bottom = layout.margin;
+    let i = 0;
+    while (i < items.length) {
+        const room = measures.floor - top;
+        // The column of the numbers is two digits wide.
+        if (i >= MOST)
+            throw new TypeError(noRoom(i, measures));
+        if (short(i)) {
+            const cells = short(i + 1) && i + 1 < MOST ? [i, i + 1] : [i];
+            const laid = cells.map((n, c) => itemOf([lineOf(n)], n, c === 0 ? layout.margin : measures.second, top, measures));
+            const height = Math.max(...laid.map(({ height }) => height));
+            if (height > room)
+                throw new TypeError(noRoom(i, measures));
+            placed.push(...laid.map(({ item }) => item));
+            bottom = top + height;
+            i += cells.length;
+        }
+        else {
+            const wrapped = linesOf(lineOf(i), measures, room);
+            const laid = wrapped === undefined ? undefined : itemOf(wrapped, i, layout.margin, top, measures);
+            if (laid === undefined || laid.height > room)
+                throw new TypeError(noRoom(i, measures));
+            placed.push(laid.item);
+            bottom = top + laid.height;
+            i += 1;
+        }
+        top = bottom + layout.items;
+    }
+    return deepFreeze({ items: placed, bottom });
+}
+/** The most items a page holds: the column of the numbers is "00." wide. */
+const MOST = 99;
+/** Whether two pages are the same, part by part. */
+export function samePage(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function noRoom(i, { floor }) {
+    if (i >= MOST) {
+        return `task.items[${i}]: no room for item ${i + 1} on the workbook's page: it holds no more than ${MOST} items, whose numbers have two digits at most`;
+    }
+    return `task.items[${i}]: no room for item ${i + 1} on the workbook's page, ${SHEET.width} × ${SHEET.height} units: its row would go below ${floor}, where the page's margin begins, and the text and the boxes never shrink`;
+}
+/** The tokens of an item's line: the words of its pieces of text, and its boxes, in order. */
+function tokensOf(item) {
+    return item.line.flatMap((part, piece) => {
+        if ("binding" in part)
+            return [{ piece, box: true }];
+        return wordsOf(part.text).map((word) => ({ piece, word, width: wordWidth(word) }));
+    });
+}
+function isWord(token) {
+    return "word" in token;
+}
+/** What lies between two tokens next to each other in a line. */
+function jointOf(a, b, measures) {
+    const { gap, apart } = measures.layout;
+    if (isWord(a) && isWord(b)) {
+        const glued = CLOSING.includes(b.word.slice(0, 1)) || OPENING.includes(a.word.slice(-1));
+        if (a.piece === b.piece)
+            return { inner: true, width: 0, breaks: !glued };
+        return { inner: false, width: glued ? 0 : measures.space, breaks: !glued };
+    }
+    if (isWord(a))
+        return { inner: false, width: gap, breaks: !OPENING.includes(a.word.slice(-1)) };
+    // A box holds on to the word after it, as a number holds on to its unit.
+    if (isWord(b))
+        return { inner: false, width: gap, breaks: false };
+    return { inner: false, width: apart, breaks: true };
+}
+/** Tokens as one line, each with what lies before it. */
+function entriesOf(tokens, measures) {
+    return tokens.map((token, n) => {
+        const before = tokens[n - 1];
+        return { token, joint: before === undefined ? undefined : jointOf(before, token, measures) };
+    });
+}
+/**
+ * The parts of a line of entries, from its start: the words of a piece that follow each other
+ * within it make one text, and each text and box has its place and its width.
+ */
+function partsOf(entries, measures) {
+    const { layout } = measures;
+    const parts = [];
+    let x = 0;
+    let words = [];
+    let hundredths = 0;
+    let start = 0;
+    const close = () => {
+        if (words.length === 0)
+            return;
+        const width = textWidth(layout, hundredths + SPACE * (words.length - 1));
+        parts.push({ box: false, text: words.join(" "), left: start, width });
+        x = start + width;
+        words = [];
+        hundredths = 0;
+    };
+    for (const { token, joint } of entries) {
+        if (isWord(token) && joint?.inner === true && words.length > 0) {
+            words.push(token.word);
+            hundredths += token.width;
+            continue;
+        }
+        close();
+        if (joint !== undefined)
+            x += joint.width;
+        if (isWord(token)) {
+            start = x;
+            words = [token.word];
+            hundredths = token.width;
+        }
+        else {
+            parts.push({ box: true, left: x, width: layout.boxWidth });
+            x += layout.boxWidth;
+        }
+    }
+    close();
+    return { parts, width: x };
+}
+/**
+ * The lines of a long item across the page: greedily, run by run, where a run is tokens no line may
+ * break between. A run wider than a line goes token by token, and a word wider than a line is
+ * broken between its clusters. Undefined once the lines could no longer fit the room left.
+ */
+function linesOf(entries, measures, room) {
+    const { full } = measures;
+    const { line } = measures.layout;
+    // The lowest a line can be is a line of text: more lines than this cannot fit the room.
+    const most = Math.floor(room / line) + 1;
+    const lines = [];
+    let current = [];
+    const fits = (candidate) => partsOf(candidate, measures).width <= full;
+    const fresh = (entry) => ({ token: entry.token, joint: undefined });
+    const end = () => {
+        if (current.length > 0)
+            lines.push(current);
+        current = [];
+        return lines.length > most;
+    };
+    for (const run of runsOf(entries)) {
+        if (current.length > 0 && fits([...current, ...run])) {
+            current.push(...run);
+            continue;
+        }
+        if (end())
+            return undefined;
+        const alone = [fresh(run[0]), ...run.slice(1)];
+        if (fits(alone)) {
+            current = alone;
+            continue;
+        }
+        for (const entry of run) {
+            if (current.length > 0 && fits([...current, entry])) {
+                current.push(entry);
+                continue;
+            }
+            if (end())
+                return undefined;
+            if (fits([fresh(entry)])) {
+                current = [fresh(entry)];
+                continue;
+            }
+            // A word wider than a line: its clusters, as many to a line as fit.
+            const token = entry.token;
+            let chunk = "";
+            let width = 0;
+            for (const cluster of clustersOf(token.word)) {
+                const more = width + clusterWidth(cluster);
+                if (chunk !== "" && textWidth(measures.layout, more) > full) {
+                    current = [{ token: { piece: token.piece, word: chunk, width }, joint: undefined }];
+                    if (end())
+                        return undefined;
+                    chunk = "";
+                    width = 0;
+                }
+                chunk += cluster;
+                width += clusterWidth(cluster);
+            }
+            current = [{ token: { piece: token.piece, word: chunk, width }, joint: undefined }];
+        }
+    }
+    if (end())
+        return undefined;
+    return lines;
+}
+/** Entries cut where a line may break: each run starts with what lies before it. */
+function runsOf(entries) {
+    const runs = [];
+    for (const entry of entries) {
+        const last = runs.at(-1);
+        if (last === undefined || entry.joint === undefined || entry.joint.breaks)
+            runs.push([entry]);
+        else
+            last.push(entry);
+    }
+    return runs;
+}
+/**
+ * An item laid out from its lines at a place on the page: its parts in their places, its number on
+ * the first line's baseline, right in the column of the numbers, and its height.
+ */
+function itemOf(lines, n, left, top, measures) {
+    const { layout } = measures;
+    const line = [];
+    const baselines = [];
+    let y = top;
+    let boxed;
+    for (const entries of lines) {
+        const { parts } = partsOf(entries, measures);
+        const hasBox = parts.some((part) => part.box);
+        if (boxed !== undefined)
+            y += boxed && hasBox ? layout.apart : boxed || hasBox ? layout.lead : 0;
+        const height = hasBox ? layout.boxHeight : layout.line;
+        const baseline = y + Math.floor(height / 2) + Math.floor(layout.size / 3);
+        baselines.push(baseline);
+        const x = left + measures.indent;
+        for (const part of parts) {
+            line.push(part.box
+                ? { left: x + part.left, top: y, width: part.width, height: layout.boxHeight }
+                : { text: part.text, left: x + part.left, baseline, width: part.width });
+        }
+        y += height;
+        boxed = hasBox;
+    }
+    const label = `${n + 1}.`;
+    const width = textWidth(layout, wordWidth(label));
+    const number = {
+        text: label,
+        left: left + measures.numbers - width,
+        baseline: baselines[0] ?? top + Math.floor(layout.line / 2) + Math.floor(layout.size / 3),
+        width,
+    };
+    const height = Math.max(y - top, lines.length === 0 ? layout.line : 0);
+    return { item: { number, line, boxes: line.filter(isBox) }, height };
+}
+function deepFreeze(value) {
+    if (typeof value === "object" && value !== null) {
+        for (const field of Object.values(value))
+            deepFreeze(field);
+        Object.freeze(value);
+    }
+    return value;
+}

package/lib/core/png.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The PNG of a grey image, a byte to a pixel, row by row from the top (R25): own code, so that the
+ * same pixels give the same bytes in every browser and in Node, as no browser's canvas promises
+ * (R05). The file is the least PNG holds: its signature, the header, one chunk of data and the end,
+ * no ancillary chunk, for a decoder may ignore them (PNG Third Edition, 11.3). The data is a zlib
+ * stream of one deflate block with the fixed Huffman codes (RFC 1950, RFC 1951): every row
+ * unfiltered, and a repeat looked for in two places only — the byte before, which takes the runs of
+ * white, and the row above, which takes the rows a stroke runs straight down through.
+ */
+export declare function encodePNG(gray: Uint8Array, width: number, height: number): Uint8Array<ArrayBuffer>;
+export declare function crc32(bytes: Uint8Array): number;
+/** zlib's checksum of the data before compression: two sums modulo 65521 (RFC 1950). */
+export declare function adler32(bytes: Uint8Array): number;

package/lib/core/png.js

@@ -0,0 +1,231 @@
+/**
+ * The PNG of a grey image, a byte to a pixel, row by row from the top (R25): own code, so that the
+ * same pixels give the same bytes in every browser and in Node, as no browser's canvas promises
+ * (R05). The file is the least PNG holds: its signature, the header, one chunk of data and the end,
+ * no ancillary chunk, for a decoder may ignore them (PNG Third Edition, 11.3). The data is a zlib
+ * stream of one deflate block with the fixed Huffman codes (RFC 1950, RFC 1951): every row
+ * unfiltered, and a repeat looked for in two places only — the byte before, which takes the runs of
+ * white, and the row above, which takes the rows a stroke runs straight down through.
+ */
+export function encodePNG(gray, width, height) {
+    for (const [name, side] of [
+        ["width", width],
+        ["height", height],
+    ]) {
+        if (!Number.isInteger(side) || side < 1 || side > MOST) {
+            throw new RangeError(`the image's ${name} is ${side}, not a whole number from 1 to ${MOST}`);
+        }
+    }
+    if (gray.length !== width * height) {
+        throw new RangeError(`${gray.length} pixels are no image ${width} × ${height}`);
+    }
+    // Each row after its filter, 0: none.
+    const stride = width + 1;
+    const rows = new Uint8Array(stride * height);
+    for (let row = 0; row < height; row++) {
+        rows.set(gray.subarray(row * width, (row + 1) * width), row * stride + 1);
+    }
+    const header = new Uint8Array(13);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, width);
+    view.setUint32(4, height);
+    // A depth of 8 bits, the colour type of grey, and the one method of compression, of filtering
+    // and of no interlacing there is.
+    header.set([8, 0, 0, 0, 0], 8);
+    const stream = deflate(rows, stride);
+    const zlib = new Uint8Array(2 + stream.length + 4);
+    // The deflate method with a window of 32 KiB, and the fastest algorithm; FCHECK makes 0x7801 a
+    // multiple of 31.
+    zlib.set([0x78, 0x01], 0);
+    zlib.set(stream, 2);
+    new DataView(zlib.buffer).setUint32(2 + stream.length, adler32(rows));
+    return joined([
+        SIGNATURE,
+        chunk("IHDR", header),
+        chunk("IDAT", zlib),
+        chunk("IEND", new Uint8Array(0)),
+    ]);
+}
+/** The largest width or height PNG takes: 2^31 − 1. */
+const MOST = 0x7fffffff;
+const SIGNATURE = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+/** A chunk: the length of its data, its type, the data, and the CRC of the type and the data. */
+function chunk(type, data) {
+    const bytes = new Uint8Array(12 + data.length);
+    const view = new DataView(bytes.buffer);
+    view.setUint32(0, data.length);
+    for (let k = 0; k < 4; k++)
+        bytes[4 + k] = type.charCodeAt(k);
+    bytes.set(data, 8);
+    view.setUint32(8 + data.length, crc32(bytes.subarray(4, 8 + data.length)));
+    return bytes;
+}
+function joined(parts) {
+    const bytes = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+    let at = 0;
+    for (const part of parts) {
+        bytes.set(part, at);
+        at += part.length;
+    }
+    return bytes;
+}
+/** The CRC of PNG and zlib's gzip: the polynomial 0xEDB88320, one byte at a time from a table. */
+const CRC_TABLE = Uint32Array.from({ length: 256 }, (_, n) => {
+    let c = n;
+    for (let k = 0; k < 8; k++)
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    return c >>> 0;
+});
+export function crc32(bytes) {
+    let c = 0xffffffff;
+    for (const byte of bytes)
+        c = (CRC_TABLE[(c ^ byte) & 0xff] ?? 0) ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+/** zlib's checksum of the data before compression: two sums modulo 65521 (RFC 1950). */
+export function adler32(bytes) {
+    let s1 = 1;
+    let s2 = 0;
+    for (const byte of bytes) {
+        s1 = (s1 + byte) % 65521;
+        s2 = (s2 + s1) % 65521;
+    }
+    return (s2 * 65536 + s1) >>> 0;
+}
+/**
+ * The lengths of a match, 3 to 258, by their codes from 257 up: each code's least length and its
+ * extra bits (RFC 1951, 3.2.5). 258 has a code of its own, 285, with no extra bits: 284 with all
+ * its extra bits set would also read 258, and decoders refuse it.
+ */
+const LENGTHS = [
+    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131,
+    163, 195, 227, 258,
+];
+const LENGTH_BITS = [
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0,
+];
+/** The distances of a match, 1 to 32768, by their codes from 0: least distance and extra bits. */
+const DISTANCES = [
+    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049,
+    3073, 4097, 6145, 8193, 12289, 16385, 24577,
+];
+const DISTANCE_BITS = [
+    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13,
+];
+/** The longest match deflate allows, and the farthest back. */
+const LONGEST = 258;
+const WINDOW = 32768;
+/**
+ * The fixed Huffman codes of the 288 literals and lengths (RFC 1951, 3.2.6), each with its count of
+ * bits, its bits turned end to front: a Huffman code goes out from its most significant bit, and
+ * everything else from its least, so a code turned round goes out as any other number.
+ */
+const LITERALS = Array.from({ length: 288 }, (_, value) => {
+    if (value < 144)
+        return reversed(0x30 + value, 8);
+    if (value < 256)
+        return reversed(0x190 + value - 144, 9);
+    if (value < 280)
+        return reversed(value - 256, 7);
+    return reversed(0xc0 + value - 280, 8);
+});
+function reversed(code, bits) {
+    let turned = 0;
+    for (let k = 0; k < bits; k++)
+        turned |= ((code >>> k) & 1) << (bits - 1 - k);
+    return [turned, bits];
+}
+/** The index of the last entry no greater than `value`, in an ascending list. */
+function codeOf(bounds, value) {
+    let code = 0;
+    while (code + 1 < bounds.length && (bounds[code + 1] ?? Number.POSITIVE_INFINITY) <= value) {
+        code++;
+    }
+    return code;
+}
+/** Bits as deflate packs them: each byte from its least significant bit up (RFC 1951, 3.1.1). */
+class Bits {
+    #bytes = new Uint8Array(1024);
+    #length = 0;
+    #buffer = 0;
+    #count = 0;
+    /** `count` bits of `value`, from its least significant. */
+    put(value, count) {
+        this.#buffer |= value << this.#count;
+        this.#count += count;
+        while (this.#count >= 8) {
+            this.#byte(this.#buffer & 0xff);
+            this.#buffer >>>= 8;
+            this.#count -= 8;
+        }
+    }
+    /** The bits so far, the last byte filled out with zeros. */
+    done() {
+        if (this.#count > 0)
+            this.#byte(this.#buffer & 0xff);
+        this.#buffer = 0;
+        this.#count = 0;
+        return this.#bytes.slice(0, this.#length);
+    }
+    #byte(value) {
+        if (this.#length === this.#bytes.length) {
+            const larger = new Uint8Array(this.#bytes.length * 2);
+            larger.set(this.#bytes);
+            this.#bytes = larger;
+        }
+        this.#bytes[this.#length++] = value;
+    }
+}
+/** One final block of fixed Huffman codes. */
+function deflate(data, stride) {
+    const bits = new Bits();
+    // BFINAL, then BTYPE 01: the fixed codes.
+    bits.put(1, 1);
+    bits.put(1, 2);
+    const literal = (value) => {
+        const [code, count] = LITERALS[value] ?? [0, 0];
+        bits.put(code, count);
+    };
+    let at = 0;
+    while (at < data.length) {
+        const [length, distance] = repeatAt(data, at, stride);
+        if (length < 3) {
+            literal(data[at] ?? 0);
+            at++;
+            continue;
+        }
+        const lengthCode = codeOf(LENGTHS, length);
+        literal(257 + lengthCode);
+        bits.put(length - (LENGTHS[lengthCode] ?? 0), LENGTH_BITS[lengthCode] ?? 0);
+        const distanceCode = codeOf(DISTANCES, distance);
+        // A distance code is five bits of a Huffman code: from its most significant bit.
+        const [code] = reversed(distanceCode, 5);
+        bits.put(code, 5);
+        bits.put(distance - (DISTANCES[distanceCode] ?? 0), DISTANCE_BITS[distanceCode] ?? 0);
+        at += length;
+    }
+    // The end of the block.
+    literal(256);
+    return bits.done();
+}
+/**
+ * The longest repeat at `at` of the byte before or of the row above: its length and how far back it
+ * starts. The byte before is tried first, and the row above only wins by being longer.
+ */
+function repeatAt(data, at, stride) {
+    let best = 0;
+    let distance = 0;
+    const most = Math.min(LONGEST, data.length - at);
+    for (const back of [1, stride]) {
+        if (back > at || back > WINDOW)
+            continue;
+        let length = 0;
+        while (length < most && data[at + length] === data[at + length - back])
+            length++;
+        if (length > best) {
+            best = length;
+            distance = back;
+        }
+    }
+    return [best, distance];
+}

package/lib/core/raster.d.ts

@@ -0,0 +1,14 @@
+import type { Crop } from "./crop.js";
+import type { Stroke } from "./ink.js";
+/**
+ * The pixels of a crop (R25): grey, a byte each, row by row from the top, white 255 and the ink 0,
+ * of the strokes the crop was made of. Every segment of a stroke is a line as wide all along, with
+ * round ends, and a stroke of one point a dot as wide as the line: a pixel takes the share of it
+ * that the line covers, along a ramp a pixel wide at the line's edge, and the darkest of what
+ * covers it. The places are the crop's own whole numbers, from the points in tenths of a unit, as
+ * a sample keeps them (R09). Only adding, subtracting, multiplying, dividing and Math.sqrt go into
+ * a pixel, which ECMAScript rounds alike in every engine, so the bytes are the same in each.
+ */
+export declare function rasterOf(strokes: readonly Stroke[], crop: Crop): Uint8Array<ArrayBuffer>;
+/** The PNG of a crop: its pixels, encoded (R25). */
+export declare function pictureOf(strokes: readonly Stroke[], crop: Crop): Uint8Array<ArrayBuffer>;