@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/slitherlinkMount.js

@@ -0,0 +1,267 @@
+import { progressSlitherlink, slitherlinkCellEdges, slitherlinkHorizontalCount, slitherlinkVertexEdges, } from "./slitherlinkBoard.js";
+import { decodeSlitherlink, encodeSlitherlink, hintSlitherlink, newSlitherlink, slitherlinkFinished, toggleSlitherlink, undoSlitherlink, } from "./slitherlinkGame.js";
+import { KAZU_STYLE } from "./style.js";
+import { SLITHERLINK_PLAY_STYLE } from "./slitherlinkStyle.js";
+import { slitherlinkWords } from "./slitherlinkStrings.js";
+/** Mounts an accessible dot-and-edge loop player in the given host element. */
+export function mountSlitherlink(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial };
+    let game = initial.progress ? decodeSlitherlink(initial.progress) : null;
+    game ?? (game = newSlitherlink(initial.board));
+    const geometry = edgeGeometry(game.board);
+    let selected = 0;
+    let errors = [];
+    let message = "";
+    let finished = slitherlinkFinished(game);
+    let dead = false;
+    const root = doc.createElement("div");
+    const style = doc.createElement("style");
+    const board = doc.createElement("div");
+    const status = doc.createElement("p");
+    const tools = doc.createElement("div");
+    const help = doc.createElement("p");
+    root.className = "sl-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".sl-palette") + SLITHERLINK_PLAY_STYLE;
+    board.className = "sl-board";
+    status.className = "sl-status";
+    status.setAttribute("role", "status");
+    tools.className = "sl-tools";
+    help.className = "sl-help";
+    root.append(style, board, status, tools, help);
+    host.append(root);
+    const copy = () => ({
+        ...game,
+        board: { ...game.board, clues: [...game.board.clues] },
+        edges: [...game.edges],
+        history: game.history.map(turn => [...turn]),
+    });
+    const words = () => slitherlinkWords(options.language);
+    const button = (label, action, disabled = false) => {
+        const control = doc.createElement("button");
+        control.type = "button";
+        control.textContent = label;
+        control.disabled = disabled;
+        control.onclick = action;
+        tools.append(control);
+    };
+    const changed = () => {
+        errors = [];
+        message = "";
+        const won = slitherlinkFinished(game);
+        render();
+        options.onChange?.(copy());
+        root.dispatchEvent(new CustomEvent("slitherlink-change", { detail: copy(), bubbles: true }));
+        if (won && !finished) {
+            options.onFinish?.(copy());
+            root.dispatchEvent(new CustomEvent("slitherlink-finish", { detail: copy(), bubbles: true }));
+        }
+        finished = won;
+    };
+    const toggle = (edge) => {
+        if (finished)
+            return;
+        selected = edge;
+        game = toggleSlitherlink(game, edge);
+        changed();
+    };
+    const restart = () => {
+        game = newSlitherlink(game.board);
+        finished = false;
+        selected = 0;
+        changed();
+    };
+    const render = () => {
+        if (dead)
+            return;
+        const focused = board.contains(doc.activeElement);
+        const w = words();
+        const current = game.board;
+        const selectedEdges = new Set(game.edges);
+        const clues = progressSlitherlink(current, game.edges);
+        board.classList.toggle("sl-palette", (options.material ?? "ivory") === "ivory");
+        const material = options.material ?? "ivory";
+        const palette = {
+            ivory: ["var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"],
+            wood: ["#493e2f", "#bca582"],
+            slate: ["#ece8dc", "#454a44"],
+        }[material];
+        board.style.setProperty("--sl-ink", palette[0]);
+        board.style.setProperty("--kz-grid", palette[1]);
+        board.setAttribute("role", "grid");
+        board.setAttribute("aria-label", w.title);
+        board.style.gridTemplateColumns = `repeat(${current.width * 2 + 1}, 1fr)`;
+        board.style.gridTemplateRows = `repeat(${current.height * 2 + 1}, 1fr)`;
+        board.style.aspectRatio = `${current.width * 2 + 1} / ${current.height * 2 + 1}`;
+        board.replaceChildren();
+        for (let cell = 0; cell < current.clues.length; cell += 1) {
+            const clue = current.clues[cell];
+            if (clue === null)
+                continue;
+            const tile = doc.createElement("span");
+            tile.className = "sl-cell";
+            tile.style.gridColumnStart = String((cell % current.width) * 2 + 2);
+            tile.style.gridRowStart = String(Math.floor(cell / current.width) * 2 + 2);
+            tile.textContent = String(clue);
+            tile.setAttribute("aria-hidden", "true");
+            board.append(tile);
+        }
+        for (const point of gridPoints(current)) {
+            const dot = doc.createElement("span");
+            dot.className = "sl-dot";
+            dot.style.gridColumnStart = String(point.x * 2 + 1);
+            dot.style.gridRowStart = String(point.y * 2 + 1);
+            dot.setAttribute("aria-hidden", "true");
+            board.append(dot);
+        }
+        for (const edge of geometry) {
+            const control = doc.createElement("button");
+            const on = selectedEdges.has(edge.id);
+            control.type = "button";
+            control.className = `sl-edge ${edge.orientation}${on ? " on" : ""}${errors.includes(edge.id) ? " error" : ""}`;
+            control.style.gridColumnStart = String(edge.x * 2 + 1);
+            control.style.gridRowStart = String(edge.y * 2 + 1);
+            if (edge.orientation === "horizontal")
+                control.style.gridColumnEnd = "span 3";
+            else
+                control.style.gridRowEnd = "span 3";
+            control.tabIndex = edge.id === selected ? 0 : -1;
+            control.dataset.edge = String(edge.id);
+            control.setAttribute("aria-pressed", String(on));
+            control.setAttribute("aria-label", `${w.edge} ${edge.id + 1}, ${on ? "on" : "off"}`);
+            control.onclick = () => toggle(edge.id);
+            control.onkeydown = event => {
+                if (event.key === "Enter" || event.key === " ") {
+                    event.preventDefault();
+                    toggle(edge.id);
+                }
+                else if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.key)) {
+                    event.preventDefault();
+                    moveFocus(edge.id, event.key);
+                }
+                else if ((event.key === "Delete" || event.key === "Backspace") && on) {
+                    event.preventDefault();
+                    toggle(edge.id);
+                }
+            };
+            board.append(control);
+        }
+        if (focused)
+            board.querySelector(`[data-edge="${selected}"]`)?.focus();
+        status.textContent = finished ? (game.helped ? w.helped : w.won) : message || w.checked;
+        help.textContent = w.help;
+        tools.replaceChildren();
+        button(w.undo, () => {
+            game = undoSlitherlink(game);
+            finished = slitherlinkFinished(game);
+            changed();
+        }, !game.history.length);
+        button(w.check, () => {
+            errors = progressEdges(current, game.edges, clues.clues, clues.vertices, clues.loops);
+            message = slitherlinkFinished(game) ? w.won : w.wrong;
+            render();
+        });
+        button(w.hint, () => {
+            const edge = hintSlitherlink(game);
+            if (edge === null) {
+                message = w.noHint;
+                render();
+                return;
+            }
+            game = { ...toggleSlitherlink(game, edge), helped: true };
+            changed();
+            message = w.hintWhy;
+            render();
+        }, finished);
+        button(w.restart, restart);
+        button(w.expand, expand);
+    };
+    function moveFocus(edge, direction) {
+        const origin = geometry[edge];
+        const dx = direction === "ArrowLeft" ? -1 : direction === "ArrowRight" ? 1 : 0;
+        const dy = direction === "ArrowUp" ? -1 : direction === "ArrowDown" ? 1 : 0;
+        const candidates = geometry.filter(candidate => {
+            const deltaX = candidate.cx - origin.cx;
+            const deltaY = candidate.cy - origin.cy;
+            return dx ? deltaX * dx > 0 : deltaY * dy > 0;
+        });
+        candidates.sort((a, b) => {
+            const aMajor = dx ? Math.abs(a.cx - origin.cx) : Math.abs(a.cy - origin.cy);
+            const bMajor = dx ? Math.abs(b.cx - origin.cx) : Math.abs(b.cy - origin.cy);
+            if (aMajor !== bMajor)
+                return aMajor - bMajor;
+            const aMinor = dx ? Math.abs(a.cy - origin.cy) : Math.abs(a.cx - origin.cx);
+            const bMinor = dx ? Math.abs(b.cy - origin.cy) : Math.abs(b.cx - origin.cx);
+            return aMinor - bMinor;
+        });
+        const next = candidates[0];
+        if (!next)
+            return;
+        selected = next.id;
+        render();
+    }
+    function expand() {
+        if (root.parentElement !== host)
+            return;
+        const dialog = doc.createElement("dialog");
+        const close = doc.createElement("button");
+        dialog.className = "sl-dialog";
+        close.className = "sl-close";
+        close.textContent = words().close;
+        close.onclick = () => dialog.close();
+        dialog.append(close, root);
+        host.append(dialog);
+        dialog.onclose = () => {
+            host.append(root);
+            dialog.remove();
+        };
+        dialog.showModal();
+    }
+    render();
+    return {
+        game: copy,
+        progress: () => encodeSlitherlink(game),
+        restart,
+        set: (next) => {
+            if (next.language && next.language !== options.language)
+                message = "";
+            options = { ...options, ...next };
+            render();
+        },
+        destroy: () => {
+            dead = true;
+            const dialog = root.closest("dialog");
+            root.remove();
+            dialog?.remove();
+        },
+    };
+}
+function gridPoints(board) {
+    return Array.from({ length: (board.width + 1) * (board.height + 1) }, (_, vertex) => ({
+        x: vertex % (board.width + 1),
+        y: Math.floor(vertex / (board.width + 1)),
+    }));
+}
+function edgeGeometry(board) {
+    const horizontal = slitherlinkHorizontalCount(board);
+    const edges = Array.from({ length: horizontal + board.height * (board.width + 1) }, (_, id) => {
+        if (id < horizontal) {
+            const x = id % board.width;
+            const y = Math.floor(id / board.width);
+            return { id, orientation: "horizontal", x, y, cx: x + .5, cy: y };
+        }
+        const local = id - horizontal;
+        const x = local % (board.width + 1);
+        const y = Math.floor(local / (board.width + 1));
+        return { id, orientation: "vertical", x, y, cx: x, cy: y + .5 };
+    });
+    return edges;
+}
+function progressEdges(board, edges, clueErrors, vertexErrors, loops) {
+    if (loops > 1)
+        return [...edges];
+    const result = new Set();
+    clueErrors.forEach(cell => slitherlinkCellEdges(board, cell)?.forEach(edge => result.add(edge)));
+    vertexErrors.forEach(vertex => slitherlinkVertexEdges(board, vertex).forEach(edge => result.add(edge)));
+    return [...result];
+}

package/dist/slitherlinkPlay.types.d.ts

@@ -0,0 +1,23 @@
+import type { SlitherlinkBoard, SlitherlinkGame } from "./slitherlink.types.ts";
+export type SlitherlinkLanguage = "en" | "ja";
+export type SlitherlinkMaterial = "ivory" | "wood" | "slate";
+export type SlitherlinkDrawOptions = {
+    edges?: SlitherlinkGame["edges"];
+    selected?: number | null;
+    errors?: readonly number[];
+    material?: SlitherlinkMaterial;
+    language?: SlitherlinkLanguage;
+};
+export type SlitherlinkMountOptions = SlitherlinkDrawOptions & {
+    board: SlitherlinkBoard;
+    progress?: string;
+    onChange?: (game: SlitherlinkGame) => void;
+    onFinish?: (game: SlitherlinkGame) => void;
+};
+export type SlitherlinkMount = {
+    game: () => SlitherlinkGame;
+    progress: () => string;
+    set: (options: SlitherlinkDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/slitherlinkPlay.types.js

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

package/dist/slitherlinkRate.d.ts

@@ -0,0 +1,3 @@
+import type { SlitherlinkBoard, SlitherlinkRating } from "./slitherlink.types.ts";
+/** Rates a board with one answer by solving it as a person would: with the rules, then by supposing one edge at a time. */
+export declare function rateSlitherlink(board: SlitherlinkBoard): SlitherlinkRating;

package/dist/slitherlinkRate.js

@@ -0,0 +1,26 @@
+import { isSlitherlinkBoard } from "./slitherlinkBoard.js";
+import { slitherlinkModel } from "./slitherlinkLogic.js";
+import { logicCsp, openSlots, solveCsp } from "./csp.js";
+/** Rates a board with one answer by solving it as a person would: with the rules, then by supposing one edge at a time. */
+export function rateSlitherlink(board) {
+    if (!isSlitherlinkBoard(board))
+        throw new RangeError("Invalid Slitherlink board");
+    const { csp } = slitherlinkModel(board);
+    const proof = solveCsp(csp, openSlots(csp), 2, 300000);
+    if (proof.count !== 1 || proof.exhausted)
+        throw new RangeError("Slitherlink rating needs a board with one answer");
+    const plain = logicCsp(csp, openSlots(csp), 0);
+    const probing = plain.solved ? plain : logicCsp(csp, openSlots(csp), 1);
+    const numbered = board.clues.filter(clue => clue !== null);
+    let loop = 0;
+    for (let at = 1; at < proof.solution.length; at += 2)
+        loop += proof.solution[at];
+    return {
+        depth: plain.solved ? 0 : probing.solved ? 1 : 2,
+        probes: plain.solved ? 0 : probing.probes,
+        clues: numbered.length,
+        clueShare: numbered.length / board.clues.length,
+        zeroShare: numbered.length ? numbered.filter(clue => clue === 0).length / numbered.length : 0,
+        loop,
+    };
+}

package/dist/slitherlinkSolve.d.ts

@@ -0,0 +1,6 @@
+import type { SlitherlinkBoard, SlitherlinkSolve } from "./slitherlink.types.ts";
+/** Counts loop solutions with the pruning in `slitherlinkLogic.ts` under explicit work bounds. */
+export declare function solveSlitherlink(board: SlitherlinkBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): SlitherlinkSolve;

package/dist/slitherlinkSolve.js

@@ -0,0 +1,19 @@
+import { SLITHERLINK_MOST_NODES } from "./slitherlink.constants.js";
+import { isSlitherlinkBoard, slitherlinkEdgeCount } from "./slitherlinkBoard.js";
+import { slitherlinkModel } from "./slitherlinkLogic.js";
+import { openSlots, solveCsp } from "./csp.js";
+/** Counts loop solutions with the pruning in `slitherlinkLogic.ts` under explicit work bounds. */
+export function solveSlitherlink(board, options = {}) {
+    if (!isSlitherlinkBoard(board))
+        throw new RangeError("Invalid Slitherlink board");
+    const limit = options.limit ?? 2;
+    const budget = options.nodes ?? SLITHERLINK_MOST_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1) {
+        throw new RangeError("Invalid search bounds");
+    }
+    const { csp } = slitherlinkModel(board);
+    const found = solveCsp(csp, openSlots(csp), limit, budget);
+    const edges = slitherlinkEdgeCount(board);
+    const solution = found.solution ? Array.from({ length: edges }, (_, edge) => edge).filter(edge => found.solution[2 * edge + 1] === 1) : null;
+    return { count: found.count, solution, complete: !found.exhausted && !found.stopped, nodes: found.nodes };
+}

package/dist/slitherlinkStrings.d.ts

@@ -0,0 +1,86 @@
+import type { SlitherlinkLanguage } from "./slitherlinkPlay.types.ts";
+export declare const SLITHERLINK_STRINGS: {
+    readonly en: {
+        readonly title: "Slitherlink";
+        readonly help: "Connect adjacent dots with horizontal and vertical edges to make one closed loop. Each number says how many of its four bordering edges are in the loop. Empty cells may have any number of edges. The loop cannot branch or split into separate loops. Click or tap an edge, or focus it and press Enter or Space. Arrow keys move between edges.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly expand: "Just the board";
+        readonly close: "Close";
+        readonly won: "One closed loop. Solved!";
+        readonly helped: "Solved with help.";
+        readonly checked: "No rule conflicts so far. Keep drawing the loop.";
+        readonly wrong: "Check the numbered cells, branches and loop connections.";
+        readonly hintWhy: "This edge is part of the only proved loop.";
+        readonly noHint: "No proved hint is available.";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly clue: "number";
+        readonly blank: "no number";
+        readonly edge: "edge";
+    };
+    readonly ja: {
+        readonly title: "スリザーリンク";
+        readonly help: "点を縦横の線でつなぎ、一つの閉じた輪を作ります。数字はそのマスを囲む四辺のうち、輪になる辺の数です。数字のないマスは何辺でも構いません。輪を分岐させたり、別々の輪に分けたりしません。線をタップ、クリック、または選んでEnterかSpaceを押します。矢印キーで辺を移動します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確かめる";
+        readonly restart: "やり直す";
+        readonly expand: "盤だけ";
+        readonly close: "閉じる";
+        readonly won: "一つの輪ができました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly checked: "ここまでルールに合っています。輪を続けましょう。";
+        readonly wrong: "数字のマス、分岐、輪のつながりを確かめましょう。";
+        readonly hintWhy: "唯一の解答に含まれる辺です。";
+        readonly noHint: "確かなヒントがありません。";
+        readonly row: "行";
+        readonly column: "列";
+        readonly clue: "数字";
+        readonly blank: "数字なし";
+        readonly edge: "辺";
+    };
+};
+export declare function slitherlinkWords(language?: SlitherlinkLanguage): {
+    readonly title: "Slitherlink";
+    readonly help: "Connect adjacent dots with horizontal and vertical edges to make one closed loop. Each number says how many of its four bordering edges are in the loop. Empty cells may have any number of edges. The loop cannot branch or split into separate loops. Click or tap an edge, or focus it and press Enter or Space. Arrow keys move between edges.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly expand: "Just the board";
+    readonly close: "Close";
+    readonly won: "One closed loop. Solved!";
+    readonly helped: "Solved with help.";
+    readonly checked: "No rule conflicts so far. Keep drawing the loop.";
+    readonly wrong: "Check the numbered cells, branches and loop connections.";
+    readonly hintWhy: "This edge is part of the only proved loop.";
+    readonly noHint: "No proved hint is available.";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly clue: "number";
+    readonly blank: "no number";
+    readonly edge: "edge";
+} | {
+    readonly title: "スリザーリンク";
+    readonly help: "点を縦横の線でつなぎ、一つの閉じた輪を作ります。数字はそのマスを囲む四辺のうち、輪になる辺の数です。数字のないマスは何辺でも構いません。輪を分岐させたり、別々の輪に分けたりしません。線をタップ、クリック、または選んでEnterかSpaceを押します。矢印キーで辺を移動します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確かめる";
+    readonly restart: "やり直す";
+    readonly expand: "盤だけ";
+    readonly close: "閉じる";
+    readonly won: "一つの輪ができました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly checked: "ここまでルールに合っています。輪を続けましょう。";
+    readonly wrong: "数字のマス、分岐、輪のつながりを確かめましょう。";
+    readonly hintWhy: "唯一の解答に含まれる辺です。";
+    readonly noHint: "確かなヒントがありません。";
+    readonly row: "行";
+    readonly column: "列";
+    readonly clue: "数字";
+    readonly blank: "数字なし";
+    readonly edge: "辺";
+};

package/dist/slitherlinkStrings.js

@@ -0,0 +1,47 @@
+export const SLITHERLINK_STRINGS = {
+    en: {
+        title: "Slitherlink",
+        help: "Connect adjacent dots with horizontal and vertical edges to make one closed loop. Each number says how many of its four bordering edges are in the loop. Empty cells may have any number of edges. The loop cannot branch or split into separate loops. Click or tap an edge, or focus it and press Enter or Space. Arrow keys move between edges.",
+        undo: "Undo",
+        hint: "Hint",
+        check: "Check",
+        restart: "Restart",
+        expand: "Just the board",
+        close: "Close",
+        won: "One closed loop. Solved!",
+        helped: "Solved with help.",
+        checked: "No rule conflicts so far. Keep drawing the loop.",
+        wrong: "Check the numbered cells, branches and loop connections.",
+        hintWhy: "This edge is part of the only proved loop.",
+        noHint: "No proved hint is available.",
+        row: "Row",
+        column: "column",
+        clue: "number",
+        blank: "no number",
+        edge: "edge",
+    },
+    ja: {
+        title: "スリザーリンク",
+        help: "点を縦横の線でつなぎ、一つの閉じた輪を作ります。数字はそのマスを囲む四辺のうち、輪になる辺の数です。数字のないマスは何辺でも構いません。輪を分岐させたり、別々の輪に分けたりしません。線をタップ、クリック、または選んでEnterかSpaceを押します。矢印キーで辺を移動します。",
+        undo: "戻す",
+        hint: "ヒント",
+        check: "確かめる",
+        restart: "やり直す",
+        expand: "盤だけ",
+        close: "閉じる",
+        won: "一つの輪ができました。完成！",
+        helped: "ヒントを使って完成！",
+        checked: "ここまでルールに合っています。輪を続けましょう。",
+        wrong: "数字のマス、分岐、輪のつながりを確かめましょう。",
+        hintWhy: "唯一の解答に含まれる辺です。",
+        noHint: "確かなヒントがありません。",
+        row: "行",
+        column: "列",
+        clue: "数字",
+        blank: "数字なし",
+        edge: "辺",
+    },
+};
+export function slitherlinkWords(language = "en") {
+    return SLITHERLINK_STRINGS[language];
+}

package/dist/slitherlinkStyle.d.ts

@@ -0,0 +1 @@
+export declare const SLITHERLINK_PLAY_STYLE = "\n.sl-root{color:var(--sl-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:760px;margin:auto}\n.sl-board{display:grid;position:relative;gap:0;width:100%;min-width:240px;touch-action:manipulation;user-select:none}\n.sl-cell{position:relative;grid-column:span 2;grid-row:span 2;display:grid;place-items:center;min-width:0;min-height:0;border:0;background:transparent;padding:0;color:var(--sl-ink,#1f2320);font:700 clamp(14px,2vw,22px)/1 system-ui,sans-serif}\n.sl-dot{z-index:2;grid-column:span 1;grid-row:span 1;justify-self:center;align-self:center;width:8px;height:8px;border-radius:50%;background:var(--sl-ink,#1f2320);pointer-events:none}\n.sl-edge{position:relative;z-index:1;grid-column:span 2;grid-row:span 1;min-width:0;min-height:0;border:0;padding:0;background:transparent;cursor:pointer;touch-action:manipulation}\n.sl-edge.vertical{grid-column:span 1;grid-row:span 2}\n.sl-edge::after{content:\"\";position:absolute;background:var(--kz-grid,#cfc6b2);transition:background .12s ease}\n.sl-edge.horizontal::after{left:0;right:0;top:50%;height:5px;transform:translateY(-50%)}\n.sl-edge.vertical::after{top:0;bottom:0;left:50%;width:5px;transform:translateX(-50%)}\n.sl-edge.on::after{background:var(--sl-ink,#1f2320)}\n.sl-edge.error::after{background:var(--kz-bad,#b5452c)}\n.sl-edge:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-2px;border-radius:4px}\n.sl-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}\n.sl-tools button,.sl-close{font:inherit;border:1px solid var(--sl-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--sl-surface,#fbf8f1);color:var(--sl-ink,#1f2320);cursor:pointer}\n.sl-tools button:disabled{opacity:.45;cursor:default}.sl-status{min-height:1.5em}.sl-help{font-size:14px;opacity:.8}\n.sl-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,820px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--sl-ink:var(--ink,#1f2320);--sl-surface:var(--surface,#fbf8f1);--sl-rule:var(--rule,#ddd6c6)}.sl-dialog::backdrop{background:#172c28bb}.sl-close{float:right;margin-bottom:10px}.sl-dialog .sl-root{clear:both}\n";

package/dist/slitherlinkStyle.js

@@ -0,0 +1,18 @@
+export const SLITHERLINK_PLAY_STYLE = `
+.sl-root{color:var(--sl-ink,#1f2320);font:16px/1.5 var(--font,system-ui,sans-serif);max-width:760px;margin:auto}
+.sl-board{display:grid;position:relative;gap:0;width:100%;min-width:240px;touch-action:manipulation;user-select:none}
+.sl-cell{position:relative;grid-column:span 2;grid-row:span 2;display:grid;place-items:center;min-width:0;min-height:0;border:0;background:transparent;padding:0;color:var(--sl-ink,#1f2320);font:700 clamp(14px,2vw,22px)/1 system-ui,sans-serif}
+.sl-dot{z-index:2;grid-column:span 1;grid-row:span 1;justify-self:center;align-self:center;width:8px;height:8px;border-radius:50%;background:var(--sl-ink,#1f2320);pointer-events:none}
+.sl-edge{position:relative;z-index:1;grid-column:span 2;grid-row:span 1;min-width:0;min-height:0;border:0;padding:0;background:transparent;cursor:pointer;touch-action:manipulation}
+.sl-edge.vertical{grid-column:span 1;grid-row:span 2}
+.sl-edge::after{content:"";position:absolute;background:var(--kz-grid,#cfc6b2);transition:background .12s ease}
+.sl-edge.horizontal::after{left:0;right:0;top:50%;height:5px;transform:translateY(-50%)}
+.sl-edge.vertical::after{top:0;bottom:0;left:50%;width:5px;transform:translateX(-50%)}
+.sl-edge.on::after{background:var(--sl-ink,#1f2320)}
+.sl-edge.error::after{background:var(--kz-bad,#b5452c)}
+.sl-edge:focus-visible{outline:3px solid var(--accent,#b5452c);outline-offset:-2px;border-radius:4px}
+.sl-tools{display:flex;flex-wrap:wrap;gap:8px;margin:16px 0}
+.sl-tools button,.sl-close{font:inherit;border:1px solid var(--sl-rule,#ddd6c6);border-radius:999px;min-height:44px;padding:0 14px;background:var(--sl-surface,#fbf8f1);color:var(--sl-ink,#1f2320);cursor:pointer}
+.sl-tools button:disabled{opacity:.45;cursor:default}.sl-status{min-height:1.5em}.sl-help{font-size:14px;opacity:.8}
+.sl-dialog{border:0;border-radius:14px;padding:24px;width:min(86vw,820px);max-height:90vh;overflow:auto;background:var(--surface,#fbf8f1);--sl-ink:var(--ink,#1f2320);--sl-surface:var(--surface,#fbf8f1);--sl-rule:var(--rule,#ddd6c6)}.sl-dialog::backdrop{background:#172c28bb}.sl-close{float:right;margin-bottom:10px}.sl-dialog .sl-root{clear:both}
+`;

package/dist/slitherlinkTemplate.d.ts

@@ -0,0 +1,3 @@
+import type { SlitherlinkPuzzle } from "./slitherlink.types.ts";
+/** The first generator, kept as the fallback that cannot fail: a proved puzzle from a seeded rectangle or L-shaped tile-region loop. */
+export declare function templateSlitherlink(width?: number, height?: number, seed?: number): Omit<SlitherlinkPuzzle, "level">;

package/dist/slitherlinkTemplate.js

@@ -0,0 +1,101 @@
+import { SLITHERLINK_MOST_SIDE } from "./slitherlink.constants.js";
+import { checkSlitherlink, isSlitherlinkBoard, slitherlinkCellEdges, } from "./slitherlinkBoard.js";
+import { solveSlitherlink } from "./slitherlinkSolve.js";
+import { isKazuSeed, seededRandom } from "./random.js";
+/** The first generator, kept as the fallback that cannot fail: a proved puzzle from a seeded rectangle or L-shaped tile-region loop. */
+export function templateSlitherlink(width = 5, height = width, seed = 1) {
+    if (![width, height].every(side => Number.isInteger(side) && side >= 2 && side <= SLITHERLINK_MOST_SIDE)
+        || !isKazuSeed(seed))
+        throw new RangeError("Invalid Slitherlink settings");
+    const random = seededRandom(seed);
+    const useL = width >= 3 && height >= 3 && random() < .5;
+    const region = [];
+    let x0;
+    let y0;
+    let blockWidth;
+    let blockHeight;
+    if (useL) {
+        blockWidth = 2 + Math.floor(random() * (width - 1));
+        blockHeight = 2 + Math.floor(random() * (height - 1));
+        x0 = Math.floor(random() * (width - blockWidth + 1));
+        y0 = Math.floor(random() * (height - blockHeight + 1));
+        for (let y = 0; y < blockHeight; y += 1) {
+            for (let x = 0; x < blockWidth; x += 1) {
+                if (x === 0 || y === 0)
+                    region.push((y0 + y) * width + x0 + x);
+            }
+        }
+    }
+    else {
+        blockWidth = 1 + Math.floor(random() * width);
+        blockHeight = 1 + Math.floor(random() * height);
+        if (blockWidth === 1 && blockHeight === 1)
+            blockWidth = 2;
+        x0 = Math.floor(random() * (width - blockWidth + 1));
+        y0 = Math.floor(random() * (height - blockHeight + 1));
+        for (let y = 0; y < blockHeight; y += 1) {
+            for (let x = 0; x < blockWidth; x += 1)
+                region.push((y0 + y) * width + x0 + x);
+        }
+    }
+    const blank = { width, height, clues: Array(width * height).fill(null) };
+    const regionSet = new Set(region);
+    const edges = new Set();
+    for (const cell of region) {
+        const [top, right, bottom, left] = slitherlinkCellEdges(blank, cell);
+        const x = cell % width;
+        if (!regionSet.has(cell - width))
+            edges.add(top);
+        if (x === width - 1 || !regionSet.has(cell + 1))
+            edges.add(right);
+        if (!regionSet.has(cell + width))
+            edges.add(bottom);
+        if (x === 0 || !regionSet.has(cell - 1))
+            edges.add(left);
+    }
+    let board = {
+        width,
+        height,
+        clues: Array.from({ length: width * height }, (_, cell) => slitherlinkCellEdges(blank, cell).filter(edge => edges.has(edge)).length),
+    };
+    let answer = [...edges];
+    // Seeded axis reflections give each selected shape more than one orientation.
+    const reflectX = random() < .5;
+    const reflectY = random() < .5;
+    if (reflectX || reflectY) {
+        const horizontalCount = width * (height + 1);
+        const mapEdge = (edge) => {
+            if (edge < horizontalCount) {
+                const x = edge % width;
+                const y = Math.floor(edge / width);
+                const nextX = reflectX ? width - 1 - x : x;
+                const nextY = reflectY ? height - y : y;
+                return nextY * width + nextX;
+            }
+            const local = edge - horizontalCount;
+            const x = local % (width + 1);
+            const y = Math.floor(local / (width + 1));
+            const nextX = reflectX ? width - x : x;
+            const nextY = reflectY ? height - 1 - y : y;
+            return horizontalCount + nextY * (width + 1) + nextX;
+        };
+        const reflected = Array(width * height).fill(null);
+        board.clues.forEach((clue, cell) => {
+            const x = cell % width;
+            const y = Math.floor(cell / width);
+            const nextX = reflectX ? width - 1 - x : x;
+            const nextY = reflectY ? height - 1 - y : y;
+            reflected[nextY * width + nextX] = clue;
+        });
+        board = { width, height, clues: reflected };
+        answer = answer.map(mapEdge);
+    }
+    if (!isSlitherlinkBoard(board) || !checkSlitherlink(board, answer).ok) {
+        throw new Error("Unable to construct Slitherlink loop");
+    }
+    const proof = solveSlitherlink(board, { limit: 2 });
+    if (!proof.complete || proof.count !== 1 || !proof.solution) {
+        throw new Error("No uniquely solvable Slitherlink found within the generation budget");
+    }
+    return { ...board, seed, solution: proof.solution };
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version. */
-export declare const VERSION = "1.1.0";
+export declare const VERSION = "1.3.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version. */
-export const VERSION = "1.1.0";
+export const VERSION = "1.3.0";

package/dist/yajilin-draw-entry.d.ts

@@ -0,0 +1,2 @@
+export { drawYajilin } from "./yajilinDraw.ts";
+export type { YajilinDrawOptions } from "./yajilin.types.ts";

package/dist/yajilin-draw-entry.js

@@ -0,0 +1 @@
+export { drawYajilin } from "./yajilinDraw.js";

package/dist/yajilin-entry.d.ts

@@ -0,0 +1,6 @@
+export * from "./yajilin.types.ts";
+export * from "./yajilin.constants.ts";
+export * from "./yajilinBoard.ts";
+export * from "./yajilinSolve.ts";
+export * from "./yajilinGenerate.ts";
+export * from "./yajilinGame.ts";

package/dist/yajilin-entry.js

@@ -0,0 +1,6 @@
+export * from "./yajilin.types.js";
+export * from "./yajilin.constants.js";
+export * from "./yajilinBoard.js";
+export * from "./yajilinSolve.js";
+export * from "./yajilinGenerate.js";
+export * from "./yajilinGame.js";