@johnmorrisdotca/kazu 1.0.0

package/dist/draw.js

@@ -0,0 +1,219 @@
+import { symbolOf } from "./cells.js";
+import { kazuGeometry, KAZU_CELL } from "./geometry.js";
+import { readGivens } from "./givens.js";
+import { notesOf } from "./progress.js";
+import { kazuNameOf, kazuSay } from "./strings.js";
+import { KAZU_STYLE } from "./style.js";
+import { cageOutline } from "./sumCages.js";
+import { lineFrom, TOWER_SIDES } from "./towersCode.js";
+const escape = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const num = (value) => String(Math.round(value * 100) / 100);
+const WHERE_KEY = {
+    "number-place": "whereNumberPlace",
+    diagonal: "whereDiagonal",
+    jigsaw: "whereJigsaw",
+    "sum-cages": "whereSumCages",
+    "more-or-less": "whereMoreOrLess",
+    towers: "whereTowers",
+};
+/** The words for the groups a number is ruled out by, for a hint's line: "its row, column and box". */
+export function kazuWhere(kind, language) {
+    return kazuSay(language, WHERE_KEY[kind]);
+}
+/** A cell as a screen reader names it: "row 3, column 5". */
+export function kazuCellName(size, index, language) {
+    return kazuSay(language, "cell", { row: Math.floor(index / size) + 1, col: (index % size) + 1 });
+}
+/** The thick lines: where two neighbouring cells are in different regions, and the outer edge. */
+function boxPath(givens, x0, y0) {
+    const { size, regions } = givens;
+    const U = KAZU_CELL;
+    const parts = [`M${x0} ${y0}h${size * U}v${size * U}h${-size * U}z`];
+    if (regions !== null) {
+        for (let row = 0; row < size; row += 1) {
+            for (let col = 0; col < size; col += 1) {
+                const here = regions[row * size + col];
+                if (col < size - 1 && regions[row * size + col + 1] !== here)
+                    parts.push(`M${x0 + (col + 1) * U} ${y0 + row * U}v${U}`);
+                if (row < size - 1 && regions[(row + 1) * size + col] !== here)
+                    parts.push(`M${x0 + col * U} ${y0 + (row + 1) * U}h${U}`);
+            }
+        }
+    }
+    return parts.join("");
+}
+/** A mark between two cells: a chevron on the shared edge whose point faces the smaller number. */
+function markShape(size, less, more, x0, y0) {
+    const U = KAZU_CELL;
+    const low = Math.min(less, more);
+    const horizontal = Math.max(less, more) === low + 1;
+    const d = 0.1 * U;
+    const lowRow = Math.floor(low / size);
+    const lowCol = low % size;
+    if (horizontal) {
+        const x = x0 + (lowCol + 1) * U;
+        const y = y0 + lowRow * U + U / 2;
+        // The point faces the smaller cell: left when the left cell is the smaller.
+        const toward = less === low ? -1 : 1;
+        return `<circle class="kz-mark-bg" cx="${num(x)}" cy="${num(y)}" r="${num(0.19 * U)}"/><path class="kz-mark" d="M${num(x - toward * d)} ${num(y - d * 1.2)}L${num(x + toward * d)} ${num(y)}L${num(x - toward * d)} ${num(y + d * 1.2)}"/>`;
+    }
+    const x = x0 + lowCol * U + U / 2;
+    const y = y0 + (lowRow + 1) * U;
+    const toward = less === low ? -1 : 1;
+    return `<circle class="kz-mark-bg" cx="${num(x)}" cy="${num(y)}" r="${num(0.19 * U)}"/><path class="kz-mark" d="M${num(x - d * 1.2)} ${num(y - toward * d)}L${num(x)} ${num(y + toward * d)}L${num(x + d * 1.2)} ${num(y - toward * d)}"/>`;
+}
+/**
+ * A PUZZLE AS SVG TEXT: the grid with its printed numbers, whatever has been written in it, pencil
+ * marks, and everything the kind of puzzle prints: the heavier rules round the boxes or a Jigsaw's
+ * regions, the shaded diagonals, a cage's dashed outline with its sum, the more-than marks between
+ * cells, and the tower clues round the edge. The chosen cell, the cells that break a rule, the cells
+ * Check flagged and the cell a hint pointed at are washed in colour.
+ *
+ * Returns the `<svg>` as a string: put it in a page, a file or an image, with nothing to load. It is
+ * one steady square whatever is drawn, so nothing moves as numbers are written. Nothing in it can be
+ * selected or dragged. Null for givens that are not a puzzle of that kind and side.
+ */
+export function drawKazu(kind, size, givensCode, options = {}) {
+    const givens = readGivens(kind, size, givensCode);
+    if (givens === null)
+        return null;
+    const language = options.language ?? "en";
+    const U = KAZU_CELL;
+    const geo = kazuGeometry(kind, size);
+    const { origin: x0, side } = geo;
+    const y0 = x0;
+    const entries = options.entries ?? [];
+    const notes = options.notes ?? [];
+    const value = (index) => (givens.cells[index] !== 0 ? givens.cells[index] : (entries[index] ?? 0));
+    const selected = options.selected ?? null;
+    const conflicts = new Set(options.conflicts ?? []);
+    const wrong = new Set(options.wrong ?? []);
+    const area = size * size;
+    const at = (index) => geo.corner(index);
+    // Washes: the chosen cell's lines and its number, then the colours that say something is wrong.
+    const peers = new Set();
+    const same = new Set();
+    if (options.peers === true && selected !== null && selected >= 0 && selected < area) {
+        const row = Math.floor(selected / size);
+        const col = selected % size;
+        for (let index = 0; index < area; index += 1) {
+            const sharesRegion = givens.regions !== null && givens.regions[index] === givens.regions[selected];
+            if (Math.floor(index / size) === row || index % size === col || sharesRegion)
+                peers.add(index);
+        }
+        const chosen = value(selected);
+        if (chosen !== 0)
+            for (let index = 0; index < area; index += 1)
+                if (value(index) === chosen)
+                    same.add(index);
+    }
+    const wash = [];
+    const square = (index, cls) => {
+        const { x, y } = at(index);
+        return `<rect class="${cls}" x="${x}" y="${y}" width="${U}" height="${U}"/>`;
+    };
+    for (let index = 0; index < area; index += 1) {
+        const row = Math.floor(index / size);
+        const col = index % size;
+        if (givens.diagonals && (row === col || row + col === size - 1))
+            wash.push(square(index, "kz-diagonal"));
+        if (peers.has(index))
+            wash.push(square(index, "kz-peer"));
+        if (same.has(index))
+            wash.push(square(index, "kz-same"));
+        if (index === selected)
+            wash.push(square(index, "kz-select"));
+        if (options.hint === index)
+            wash.push(square(index, "kz-hint"));
+        if (wrong.has(index))
+            wash.push(square(index, "kz-wrong"));
+        if (conflicts.has(index))
+            wash.push(square(index, "kz-conflict"));
+    }
+    const grid = [];
+    for (let k = 1; k < size; k += 1) {
+        grid.push(`M${x0 + k * U} ${y0}v${size * U}`, `M${x0} ${y0 + k * U}h${size * U}`);
+    }
+    // Cages: a dashed outline inside each, and the sum in the first cell's corner.
+    const cageOf = new Map();
+    const sumAt = new Map();
+    (givens.cages ?? []).forEach((cage, c) => {
+        cage.cells.forEach((index) => cageOf.set(index, c));
+        sumAt.set(Math.min(...cage.cells), cage.sum);
+    });
+    const cageLines = givens.cages === null ? [] : cageOutline(size, (index) => cageOf.get(index)).map((line) => `<line x1="${num(x0 + line.x1 * U)}" y1="${num(y0 + line.y1 * U)}" x2="${num(x0 + line.x2 * U)}" y2="${num(y0 + line.y2 * U)}"/>`);
+    // Numbers and pencil marks.
+    const digitSize = size > 9 ? 0.5 * U : 0.6 * U;
+    const columns = Math.ceil(Math.sqrt(size));
+    const noteTop = givens.cages === null ? 0.07 * U : 0.27 * U;
+    const noteSide = 0.07 * U;
+    const noteWidth = U - 2 * noteSide;
+    const noteHeight = U - noteTop - 0.05 * U;
+    const noteRows = Math.ceil(size / columns);
+    const noteFont = Math.min(noteWidth / columns, noteHeight / noteRows) * 0.72;
+    const digits = [];
+    const pencil = [];
+    for (let index = 0; index < area; index += 1) {
+        const shown = value(index);
+        const { x, y } = at(index);
+        if (shown !== 0) {
+            const printed = givens.cells[index] !== 0;
+            const bad = conflicts.has(index) || wrong.has(index);
+            digits.push(`<text class="kz-digit ${printed ? "kz-given" : "kz-entry"}${bad ? " kz-bad" : ""}" x="${num(x + U / 2)}" y="${num(y + U / 2 + (givens.cages !== null ? 0.06 * U : 0))}" font-size="${num(digitSize)}" data-cell="${index}">${symbolOf(shown)}</text>`);
+        }
+        else {
+            for (const noted of notesOf(notes[index] ?? 0)) {
+                const col = (noted - 1) % columns;
+                const row = Math.floor((noted - 1) / columns);
+                pencil.push(`<text class="kz-note" x="${num(x + noteSide + ((col + 0.5) * noteWidth) / columns)}" y="${num(y + noteTop + ((row + 0.5) * noteHeight) / noteRows)}" font-size="${num(noteFont)}">${symbolOf(noted)}</text>`);
+            }
+        }
+    }
+    const sums = [...sumAt].map(([index, sum]) => {
+        const { x, y } = at(index);
+        return `<text class="kz-cage-sum" x="${num(x + 0.17 * U)}" y="${num(y + 0.17 * U)}" font-size="${num(0.24 * U)}" data-cell="${index}">${sum}</text>`;
+    });
+    const marks = givens.marks.map((mark) => markShape(size, mark.less, mark.more, x0, y0));
+    // Towers' clues, round the edge.
+    const clues = [];
+    if (givens.clues !== null) {
+        for (const side of TOWER_SIDES) {
+            for (let place = 0; place < size; place += 1) {
+                const clue = givens.clues[side][place];
+                if (clue === 0)
+                    continue;
+                const first = lineFrom(side, place, size)[0];
+                const { x, y } = at(first);
+                const cx = side === "left" ? x - U / 2 : side === "right" ? x + U + U / 2 : x + U / 2;
+                const cy = side === "top" ? y - U / 2 : side === "bottom" ? y + U + U / 2 : y + U / 2;
+                clues.push(`<text class="kz-clue" x="${num(cx)}" y="${num(cy)}" font-size="${num(0.5 * U)}" data-side="${side}" data-at="${place}">${clue}</text>`);
+            }
+        }
+    }
+    const hits = [];
+    if (options.interactive === true) {
+        for (let index = 0; index < area; index += 1) {
+            const { x, y } = at(index);
+            hits.push(`<rect class="kz-hit" x="${x}" y="${y}" width="${U}" height="${U}" data-cell="${index}"/>`);
+        }
+    }
+    const label = options.label ?? kazuSay(language, "board", { name: kazuNameOf(kind, language), size });
+    return [
+        `<svg class="kazu" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${side} ${side}" role="img" aria-label="${escape(label)}" data-kind="${kind}" data-size="${size}"${options.done === true ? ` data-solved="true"` : ""}>`,
+        options.style === true ? `<style>${KAZU_STYLE}</style>` : "",
+        options.frame === true ? `<rect class="kz-frame" x="0" y="0" width="${side}" height="${side}" rx="12"/>` : "",
+        `<rect class="kz-paper" x="${options.frame === true ? 6 : 0}" y="${options.frame === true ? 6 : 0}" width="${options.frame === true ? side - 12 : side}" height="${options.frame === true ? side - 12 : side}" rx="${options.frame === true ? 8 : 6}"/>`,
+        wash.join(""),
+        `<path class="kz-grid" d="${grid.join("")}"/>`,
+        cageLines.length > 0 ? `<g class="kz-cage">${cageLines.join("")}</g>` : "",
+        `<path class="kz-box" d="${boxPath(givens, x0, y0)}"/>`,
+        pencil.join(""),
+        digits.join(""),
+        sums.join(""),
+        marks.join(""),
+        clues.join(""),
+        options.done === true ? `<rect class="kz-solved" x="${x0}" y="${y0}" width="${size * U}" height="${size * U}"/>` : "",
+        hits.join(""),
+        `</svg>`,
+    ].join("");
+}

package/dist/element-define.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/element-define.js

@@ -0,0 +1,13 @@
+/**
+ * Defines the `<kazu-board>` element on the page. Import it for its effect:
+ *
+ * ```html
+ * <script type="module" src="https://cdn.jsdelivr.net/npm/@johnmorrisdotca/kazu@1/dist/element-define.js"></script>
+ * <kazu-board kind="number-place" size="9" level="medium"></kazu-board>
+ * ```
+ *
+ * A tag already defined is left as it is, and on a server, where there is no page, nothing happens.
+ */
+import { KazuBoard } from "./element.js";
+if (typeof customElements !== "undefined" && customElements.get("kazu-board") === undefined)
+    customElements.define("kazu-board", KazuBoard);

package/dist/element.d.ts

@@ -0,0 +1,48 @@
+import type { KazuGame } from "./game.ts";
+import { type KazuEventDetail, type KazuMount } from "./mount.ts";
+/**
+ * THE `<kazu-board>` ELEMENT: a playable Kazu puzzle in a tag, with no framework.
+ * `@johnmorrisdotca/kazu/element/define` defines it; this entry holds the class alone, to extend or to
+ * define under another name. Safe to import on a server, where there is no page: the class then extends
+ * nothing.
+ *
+ * ```html
+ * <kazu-board kind="sum-cages" size="9" level="medium" seed="42"></kazu-board>
+ * <kazu-board kind="towers" size="5" givens="…" solution="…" hints="show"></kazu-board>
+ * ```
+ *
+ * Attributes (each is read again when it changes):
+ *  - `kind`: `number-place` (default), `jigsaw`, `diagonal`, `sum-cages`, `more-or-less` or `towers`.
+ *  - `size` (the kind's default side if left out) with `level` (`easy`, `medium` (default) or `hard`) and
+ *    `seed` (a new one if left out): the puzzle is made in the page. Or `size` with `givens` (and
+ *    `solution`, if you have it): a puzzle of your own.
+ *  - `run` and `notes`: what has been written and the pencil marks, from an event's `run` and `notes`, to
+ *    carry on a puzzle half done. `elapsed`: milliseconds already on the clock.
+ *  - `hints`: `place` (default), `show` or `off`. `check`: `count` (default), `show` or `off`.
+ *  - `conflicts`, `peers`, `tidy`, `clock`, `controls`, `tap-to-step`: each on by default; `off` turns it off.
+ *  - `lang`: `en` or `ja`, or the page's.
+ *
+ * It fires `kazu-change`, `kazu-hint`, `kazu-check` and `kazu-solve` (see `mountKazu`), and has the methods
+ * `undo()`, `hint()`, `check()`, `restart()`, `pencil()` and `select()`. Nothing in it can be selected, and
+ * its box stays one steady square whatever is drawn.
+ */
+declare const ElementBase: typeof HTMLElement;
+export declare class KazuBoard extends ElementBase {
+    #private;
+    static observedAttributes: string[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    /** The mounted board's handle (`mountKazu`), or null until a puzzle has been made. */
+    get mount(): KazuMount | null;
+    get game(): KazuGame | null;
+    /** What the events would tell now. */
+    get detail(): KazuEventDetail | null;
+    undo(): void;
+    hint(): void;
+    check(): void;
+    restart(): void;
+    pencil(on?: boolean): void;
+    select(cell: number | null): void;
+}
+export {};

package/dist/element.js

@@ -0,0 +1,150 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _KazuBoard_instances, _KazuBoard_mount, _KazuBoard_key, _KazuBoard_queued, _KazuBoard_seed, _KazuBoard_refresh;
+import { generateKazu } from "./generate.js";
+import { isKazuKind, isKazuLevel, isKazuSize, KAZU_SPECS } from "./kinds.js";
+import { mountKazu } from "./mount.js";
+import { freshKazuSeed, isKazuSeed } from "./random.js";
+/**
+ * THE `<kazu-board>` ELEMENT: a playable Kazu puzzle in a tag, with no framework.
+ * `@johnmorrisdotca/kazu/element/define` defines it; this entry holds the class alone, to extend or to
+ * define under another name. Safe to import on a server, where there is no page: the class then extends
+ * nothing.
+ *
+ * ```html
+ * <kazu-board kind="sum-cages" size="9" level="medium" seed="42"></kazu-board>
+ * <kazu-board kind="towers" size="5" givens="…" solution="…" hints="show"></kazu-board>
+ * ```
+ *
+ * Attributes (each is read again when it changes):
+ *  - `kind`: `number-place` (default), `jigsaw`, `diagonal`, `sum-cages`, `more-or-less` or `towers`.
+ *  - `size` (the kind's default side if left out) with `level` (`easy`, `medium` (default) or `hard`) and
+ *    `seed` (a new one if left out): the puzzle is made in the page. Or `size` with `givens` (and
+ *    `solution`, if you have it): a puzzle of your own.
+ *  - `run` and `notes`: what has been written and the pencil marks, from an event's `run` and `notes`, to
+ *    carry on a puzzle half done. `elapsed`: milliseconds already on the clock.
+ *  - `hints`: `place` (default), `show` or `off`. `check`: `count` (default), `show` or `off`.
+ *  - `conflicts`, `peers`, `tidy`, `clock`, `controls`, `tap-to-step`: each on by default; `off` turns it off.
+ *  - `lang`: `en` or `ja`, or the page's.
+ *
+ * It fires `kazu-change`, `kazu-hint`, `kazu-check` and `kazu-solve` (see `mountKazu`), and has the methods
+ * `undo()`, `hint()`, `check()`, `restart()`, `pencil()` and `select()`. Nothing in it can be selected, and
+ * its box stays one steady square whatever is drawn.
+ */
+const ElementBase = typeof HTMLElement === "undefined" ? class {
+} : HTMLElement;
+const isOff = (value) => value !== null && ["false", "off", "0", "no"].includes(value.toLowerCase());
+const oneOf = (value, allowed) => (allowed.includes(value) ? value : undefined);
+export class KazuBoard extends ElementBase {
+    constructor() {
+        super(...arguments);
+        _KazuBoard_instances.add(this);
+        _KazuBoard_mount.set(this, null);
+        _KazuBoard_key.set(this, "");
+        _KazuBoard_queued.set(this, false);
+        _KazuBoard_seed.set(this, null);
+    }
+    connectedCallback() {
+        __classPrivateFieldGet(this, _KazuBoard_instances, "m", _KazuBoard_refresh).call(this);
+    }
+    disconnectedCallback() {
+        __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.destroy();
+        __classPrivateFieldSet(this, _KazuBoard_mount, null, "f");
+        __classPrivateFieldSet(this, _KazuBoard_key, "", "f");
+    }
+    attributeChangedCallback() {
+        if (!this.isConnected || __classPrivateFieldGet(this, _KazuBoard_queued, "f"))
+            return;
+        __classPrivateFieldSet(this, _KazuBoard_queued, true, "f");
+        queueMicrotask(() => {
+            __classPrivateFieldSet(this, _KazuBoard_queued, false, "f");
+            __classPrivateFieldGet(this, _KazuBoard_instances, "m", _KazuBoard_refresh).call(this);
+        });
+    }
+    /** The mounted board's handle (`mountKazu`), or null until a puzzle has been made. */
+    get mount() {
+        return __classPrivateFieldGet(this, _KazuBoard_mount, "f");
+    }
+    get game() {
+        return __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.game() ?? null;
+    }
+    /** What the events would tell now. */
+    get detail() {
+        return __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.detail() ?? null;
+    }
+    undo() {
+        __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.undo();
+    }
+    hint() {
+        __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.hint();
+    }
+    check() {
+        __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.check();
+    }
+    restart() {
+        __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.restart();
+    }
+    pencil(on) {
+        __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.pencil(on);
+    }
+    select(cell) {
+        __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.select(cell);
+    }
+}
+_KazuBoard_mount = new WeakMap(), _KazuBoard_key = new WeakMap(), _KazuBoard_queued = new WeakMap(), _KazuBoard_seed = new WeakMap(), _KazuBoard_instances = new WeakSet(), _KazuBoard_refresh = function _KazuBoard_refresh() {
+    const kind = isKazuKind(this.getAttribute("kind")) ? this.getAttribute("kind") : "number-place";
+    const asked = Number(this.getAttribute("size"));
+    const size = Number.isInteger(asked) && asked > 0 ? asked : KAZU_SPECS[kind].defaultSize;
+    const level = isKazuLevel(this.getAttribute("level")) ? this.getAttribute("level") : "medium";
+    const givens = this.getAttribute("givens") ?? undefined;
+    const solution = this.getAttribute("solution") ?? undefined;
+    const seedAttribute = this.getAttribute("seed");
+    const seed = isKazuSeed(Number(seedAttribute)) && seedAttribute !== null ? Number(seedAttribute) : (__classPrivateFieldSet(this, _KazuBoard_seed, __classPrivateFieldGet(this, _KazuBoard_seed, "f") ?? freshKazuSeed(), "f"));
+    const run = this.getAttribute("run") ?? undefined;
+    const notes = this.getAttribute("notes") ?? undefined;
+    const elapsed = this.getAttribute("elapsed") === null ? undefined : Number(this.getAttribute("elapsed"));
+    const settings = {
+        hints: oneOf(this.getAttribute("hints"), ["place", "show", "off"]),
+        check: oneOf(this.getAttribute("check"), ["count", "show", "off"]),
+        conflicts: !isOff(this.getAttribute("conflicts")),
+        peers: !isOff(this.getAttribute("peers")),
+        tidy: !isOff(this.getAttribute("tidy")),
+        tapToStep: !isOff(this.getAttribute("tap-to-step")),
+        clock: !isOff(this.getAttribute("clock")),
+        controls: !isOff(this.getAttribute("controls")),
+        language: oneOf(this.getAttribute("lang"), ["en", "ja"]),
+    };
+    const key = JSON.stringify([kind, size, givens === undefined ? [level, seed] : givens, solution, run, notes, elapsed]);
+    if (key === __classPrivateFieldGet(this, _KazuBoard_key, "f") && __classPrivateFieldGet(this, _KazuBoard_mount, "f") !== null) {
+        __classPrivateFieldGet(this, _KazuBoard_mount, "f").set(settings);
+        return;
+    }
+    if (givens === undefined && !isKazuSize(kind, size))
+        return;
+    const made = givens === undefined ? generateKazu(kind, size, level, seed) : null;
+    __classPrivateFieldGet(this, _KazuBoard_mount, "f")?.destroy();
+    __classPrivateFieldSet(this, _KazuBoard_mount, null, "f");
+    __classPrivateFieldSet(this, _KazuBoard_key, key, "f");
+    __classPrivateFieldSet(this, _KazuBoard_mount, mountKazu(this, {
+        kind,
+        size,
+        givens: made?.givens ?? givens,
+        solution: made?.solution ?? solution,
+        level: made?.level,
+        seed: made?.seed,
+        run,
+        notes,
+        elapsed: elapsed !== undefined && Number.isFinite(elapsed) ? elapsed : undefined,
+        ...settings,
+    }), "f");
+};
+KazuBoard.observedAttributes = ["kind", "size", "level", "seed", "givens", "solution", "run", "notes", "elapsed", "hints", "check", "conflicts", "peers", "tidy", "tap-to-step", "clock", "controls", "lang"];

package/dist/game.d.ts

@@ -0,0 +1,65 @@
+import { type KazuGivens } from "./givens.ts";
+import type { KazuKind } from "./kinds.ts";
+/**
+ * A PUZZLE IN PLAY, as pure functions: what has been written, the pencil marks, and how to take a
+ * step back. Every function returns a new game and leaves the one it was given as it was, so a page
+ * can keep them as its history, and a server can replay a solve with no page at all. `mountKazu`
+ * is these functions with a drawing and a finger on them.
+ */
+export type KazuGame = {
+    kind: KazuKind;
+    size: number;
+    /** The puzzle's givens code, as made. */
+    givens: string;
+    /** What the puzzle was printed with. */
+    printed: KazuGivens;
+    /** What the player has written, row-major, 0 where nothing; always 0 on a printed cell. */
+    entries: readonly number[];
+    /** Pencil marks, a bit mask a cell: bit `v` is the note `v`. Always 0 on a printed cell or a cell with a number in it. */
+    notes: readonly number[];
+    /** The grids before this one, newest last, for Undo. */
+    past: readonly {
+        entries: readonly number[];
+        notes: readonly number[];
+    }[];
+};
+export type KazuGameOptions = {
+    /** Entries to start from: a run kept half done (`decodeRun`). Printed cells are ignored. */
+    entries?: readonly number[];
+    /** Pencil marks to start from (`decodeNotes`). */
+    notes?: readonly number[];
+};
+/** A game of a puzzle, or null for givens that are not a puzzle of that kind and side. */
+export declare function newKazuGame(kind: KazuKind, size: number, givens: string, options?: KazuGameOptions): KazuGame | null;
+/** The whole grid as it stands: the printed numbers, and the player's where nothing is printed. */
+export declare function valuesOf(game: KazuGame): number[];
+/** Whether a cell was printed with its number: it never changes. */
+export declare function isPrinted(game: KazuGame, cell: number): boolean;
+/**
+ * Write a number into a cell (0 empties it). Its own pencil marks go, and with `tidy` (the default)
+ * the number comes out of the pencil marks of every cell that shares a group with it, as a person
+ * with a pencil would rub it out. Nothing happens to a printed cell, or when the cell already holds
+ * that number.
+ */
+export declare function enterNumber(game: KazuGame, cell: number, value: number, tidy?: boolean): KazuGame;
+/** Turn the pencil mark `value` on or off in a cell. Nothing happens to a printed cell or a cell that holds a number. */
+export declare function toggleNote(game: KazuGame, cell: number, value: number): KazuGame;
+/** Empty a cell of its number and its pencil marks. */
+export declare function clearCell(game: KazuGame, cell: number): KazuGame;
+/** Take back the last change. The same game when there is nothing to take back. */
+export declare function undoKazu(game: KazuGame): KazuGame;
+/** Start again: every entry and pencil mark gone, and nothing to undo. */
+export declare function restartKazu(game: KazuGame): KazuGame;
+/** How far along it is: cells with a number (printed or written) out of all of them. */
+export declare function kazuProgress(game: KazuGame): {
+    filled: number;
+    total: number;
+};
+/** The whole grid as a cells code: what `checkKazu` takes as an answer. */
+export declare function answerOf(game: KazuGame): string;
+/** Whether the grid is full and right, by the rules alone (`checkKazu`): every puzzle has exactly one answer, so a grid that keeps every rule IS that answer. */
+export declare function isSolved(game: KazuGame): boolean;
+/** The cells that break a rule now (`conflictsOf`). */
+export declare function gameConflicts(game: KazuGame): number[];
+/** The numbers 1 up to the side, each with how many of it are on the grid: a pad greys a number that is all placed. */
+export declare function numberCounts(game: KazuGame): number[];

package/dist/game.js

@@ -0,0 +1,120 @@
+import { encodeCells } from "./cells.js";
+import { checkKazu } from "./check.js";
+import { conflictsOf } from "./conflicts.js";
+import { layoutOfGivens, readGivens } from "./givens.js";
+/** The most steps Undo goes back. */
+const UNDO_MOST = 1000;
+/** A game of a puzzle, or null for givens that are not a puzzle of that kind and side. */
+export function newKazuGame(kind, size, givens, options = {}) {
+    const printed = readGivens(kind, size, givens);
+    if (printed === null)
+        return null;
+    const area = size * size;
+    const entries = Array.from({ length: area }, (_, i) => (printed.cells[i] !== 0 ? 0 : (options.entries?.[i] ?? 0)));
+    const notes = Array.from({ length: area }, (_, i) => (printed.cells[i] !== 0 || entries[i] !== 0 ? 0 : (options.notes?.[i] ?? 0)));
+    return { kind, size, givens, printed, entries, notes, past: [] };
+}
+/** The whole grid as it stands: the printed numbers, and the player's where nothing is printed. */
+export function valuesOf(game) {
+    return game.printed.cells.map((printed, index) => (printed !== 0 ? printed : game.entries[index]));
+}
+/** Whether a cell was printed with its number: it never changes. */
+export function isPrinted(game, cell) {
+    return game.printed.cells[cell] !== 0;
+}
+function remembered(game, entries, notes) {
+    const past = [...game.past, { entries: game.entries, notes: game.notes }].slice(-UNDO_MOST);
+    return { ...game, entries, notes, past };
+}
+/** The cells a cell shares a row, column, box, region, diagonal or cage with: where a number written in it takes that number out of the notes. */
+function peersOf(game, cell) {
+    const { size } = game;
+    const layout = layoutOfGivens(game.printed);
+    const peers = new Set();
+    if (layout !== null)
+        for (const group of layout.groupsOf[cell])
+            for (const index of layout.groups[group])
+                peers.add(index);
+    else {
+        const row = Math.floor(cell / size);
+        const col = cell % size;
+        for (let k = 0; k < size; k += 1) {
+            peers.add(row * size + k);
+            peers.add(k * size + col);
+        }
+    }
+    peers.delete(cell);
+    return peers;
+}
+/**
+ * Write a number into a cell (0 empties it). Its own pencil marks go, and with `tidy` (the default)
+ * the number comes out of the pencil marks of every cell that shares a group with it, as a person
+ * with a pencil would rub it out. Nothing happens to a printed cell, or when the cell already holds
+ * that number.
+ */
+export function enterNumber(game, cell, value, tidy = true) {
+    if (cell < 0 || cell >= game.size * game.size || isPrinted(game, cell) || !Number.isInteger(value) || value < 0 || value > game.size)
+        return game;
+    if (game.entries[cell] === value && (value !== 0 || game.notes[cell] === 0))
+        return game;
+    const entries = [...game.entries];
+    entries[cell] = value;
+    const notes = [...game.notes];
+    notes[cell] = 0;
+    if (tidy && value !== 0)
+        for (const peer of peersOf(game, cell))
+            notes[peer] &= ~(1 << value);
+    return remembered(game, entries, notes);
+}
+/** Turn the pencil mark `value` on or off in a cell. Nothing happens to a printed cell or a cell that holds a number. */
+export function toggleNote(game, cell, value) {
+    if (cell < 0 || cell >= game.size * game.size || isPrinted(game, cell) || game.entries[cell] !== 0 || !Number.isInteger(value) || value < 1 || value > game.size)
+        return game;
+    const notes = [...game.notes];
+    notes[cell] ^= 1 << value;
+    return remembered(game, game.entries, notes);
+}
+/** Empty a cell of its number and its pencil marks. */
+export function clearCell(game, cell) {
+    if (cell < 0 || cell >= game.size * game.size || isPrinted(game, cell) || (game.entries[cell] === 0 && game.notes[cell] === 0))
+        return game;
+    const entries = [...game.entries];
+    const notes = [...game.notes];
+    entries[cell] = 0;
+    notes[cell] = 0;
+    return remembered(game, entries, notes);
+}
+/** Take back the last change. The same game when there is nothing to take back. */
+export function undoKazu(game) {
+    const last = game.past.at(-1);
+    return last === undefined ? game : { ...game, entries: last.entries, notes: last.notes, past: game.past.slice(0, -1) };
+}
+/** Start again: every entry and pencil mark gone, and nothing to undo. */
+export function restartKazu(game) {
+    return { ...game, entries: game.entries.map(() => 0), notes: game.notes.map(() => 0), past: [] };
+}
+/** How far along it is: cells with a number (printed or written) out of all of them. */
+export function kazuProgress(game) {
+    const values = valuesOf(game);
+    return { filled: values.filter((value) => value !== 0).length, total: values.length };
+}
+/** The whole grid as a cells code: what `checkKazu` takes as an answer. */
+export function answerOf(game) {
+    return encodeCells(valuesOf(game));
+}
+/** Whether the grid is full and right, by the rules alone (`checkKazu`): every puzzle has exactly one answer, so a grid that keeps every rule IS that answer. */
+export function isSolved(game) {
+    return kazuProgress(game).filled === game.size * game.size && checkKazu(game.kind, game.size, game.givens, answerOf(game)).ok;
+}
+/** The cells that break a rule now (`conflictsOf`). */
+export function gameConflicts(game) {
+    return conflictsOf(game.printed, valuesOf(game));
+}
+/** The numbers 1 up to the side, each with how many of it are on the grid: a pad greys a number that is all placed. */
+export function numberCounts(game) {
+    const counts = new Array(game.size + 1).fill(0);
+    for (const value of valuesOf(game))
+        if (value !== 0)
+            counts[value] += 1;
+    return counts;
+}

package/dist/generate.d.ts

@@ -0,0 +1,11 @@
+import { type KazuKind, type KazuLevel, type KazuPuzzle } from "./kinds.ts";
+/**
+ * A puzzle of any of the six, from a seed: the one door. The same kind, size, level and seed make the
+ * same puzzle in every browser and every Node, for ever, which is what lets a solve be kept as those
+ * four and a race be handed one number. Every puzzle has exactly one answer, and an easy one yields
+ * to singles alone.
+ *
+ * Throws a RangeError for a kind, size, level or seed it does not make, rather than a puzzle made
+ * from something else.
+ */
+export declare function generateKazu(kind: KazuKind, size: number, level: KazuLevel, seed: number): KazuPuzzle;