@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/yajilinMount.js

@@ -0,0 +1,162 @@
+import { checkYajilin, yajilinNeighbors } from "./yajilinBoard.js";
+import { decodeYajilin, encodeYajilin, hintYajilin, newYajilin, restartYajilin, toggleYajilinEdge, toggleYajilinShade, undoYajilin } from "./yajilinGame.js";
+import { drawYajilin } from "./yajilinDraw.js";
+import { YAJILIN_PLAY_STYLE } from "./yajilinStyle.js";
+import { YAJILIN_STRINGS } from "./yajilinStrings.js";
+export function mountYajilin(element, initial) {
+    const document = element.ownerDocument, style = document.createElement("style");
+    style.textContent = YAJILIN_PLAY_STYLE;
+    const root = document.createElement("section");
+    root.className = "kazu-yajilin";
+    const help = document.createElement("p"), board = document.createElement("div");
+    board.className = "ky-board";
+    const modes = document.createElement("div");
+    modes.className = "ky-tools ky-modes";
+    const tools = document.createElement("div");
+    tools.className = "ky-tools";
+    const status = document.createElement("p");
+    status.className = "ky-status";
+    status.setAttribute("aria-live", "polite");
+    root.append(help, modes, board, tools, status);
+    element.replaceChildren(style, root);
+    let options = { ...initial };
+    let game = initial.progress ? decodeYajilin(initial.progress) : null;
+    const sameBoard = game && game.board.width === initial.board.width && game.board.height === initial.board.height
+        && game.board.clues.every((clue, cell) => JSON.stringify(clue) === JSON.stringify(initial.board.clues[cell]));
+    if (!sameBoard)
+        game = newYajilin(initial.board);
+    let selected = 0, anchor = null, mode = "line";
+    let errors = [], message = "", dead = false;
+    const words = () => YAJILIN_STRINGS[options.language ?? "en"];
+    const copy = () => ({ ...game, board: { ...game.board, clues: game.board.clues.map(clue => clue ? { ...clue } : null) }, shaded: [...game.shaded], edges: [...game.edges], history: game.history.map(turn => ({ shaded: [...turn.shaded], edges: [...turn.edges] })) });
+    const changed = () => { options.onChange?.(copy()); if (checkYajilin(game.board, game.shaded, game.edges).ok)
+        options.onFinish?.(copy()); };
+    const toggleBetween = (first, second) => {
+        const edge = yajilinNeighbors(game.board, first).find(next => next.cell === second)?.edge;
+        if (edge === undefined)
+            return;
+        game = toggleYajilinEdge(game, edge);
+        anchor = second;
+        selected = second;
+        errors = [];
+        message = "";
+        render();
+        changed();
+    };
+    const render = () => {
+        if (dead)
+            return;
+        const w = words();
+        help.textContent = w.help;
+        board.innerHTML = drawYajilin(game.board, { ...options, shaded: game.shaded, edges: game.edges, selected, errors });
+        const controls = document.createElement("div");
+        controls.className = "ky-cells";
+        controls.style.gridTemplateColumns = `repeat(${game.board.width}, 1fr)`;
+        controls.style.gridTemplateRows = `repeat(${game.board.height}, 1fr)`;
+        game.board.clues.forEach((clue, cell) => {
+            const button = document.createElement("button");
+            button.type = "button";
+            button.className = "ky-cell";
+            button.dataset.cell = String(cell);
+            if (clue)
+                button.dataset.clue = "true";
+            button.textContent = clue ? `${clue.direction} ${clue.count}` : String(cell + 1);
+            button.setAttribute("aria-label", clue ? `${clue.direction} ${clue.count}` : `row ${Math.floor(cell / game.board.width) + 1}, column ${cell % game.board.width + 1}${game.shaded[cell] ? ", shaded" : ""}`);
+            button.setAttribute("aria-pressed", String(selected === cell));
+            button.tabIndex = selected === cell ? 0 : -1;
+            button.onclick = () => {
+                selected = cell;
+                if (mode === "shade") {
+                    game = toggleYajilinShade(game, cell);
+                    errors = [];
+                    changed();
+                }
+                else if (anchor === null)
+                    anchor = cell;
+                else if (anchor !== cell)
+                    toggleBetween(anchor, cell);
+                render();
+            };
+            button.onkeydown = event => {
+                const x = cell % game.board.width, y = Math.floor(cell / game.board.width);
+                const moves = { ArrowUp: [0, -1], ArrowDown: [0, 1], ArrowLeft: [-1, 0], ArrowRight: [1, 0] };
+                if (event.key in moves) {
+                    event.preventDefault();
+                    const [dx, dy] = moves[event.key], nextX = x + dx, nextY = y + dy;
+                    if (nextX >= 0 && nextX < game.board.width && nextY >= 0 && nextY < game.board.height) {
+                        selected = nextY * game.board.width + nextX;
+                        render();
+                        board.querySelectorAll(".ky-cell")[selected]?.focus();
+                    }
+                }
+                else if (event.key === "Enter") {
+                    event.preventDefault();
+                    if (mode === "shade") {
+                        game = toggleYajilinShade(game, cell);
+                        errors = [];
+                        changed();
+                    }
+                    else if (anchor === null)
+                        anchor = cell;
+                    else if (anchor !== cell)
+                        toggleBetween(anchor, cell);
+                    render();
+                    board.querySelectorAll(".ky-cell")[selected]?.focus();
+                }
+                else if (event.key === " ") {
+                    event.preventDefault();
+                    mode = "shade";
+                    game = toggleYajilinShade(game, cell);
+                    errors = [];
+                    changed();
+                    render();
+                    board.querySelectorAll(".ky-cell")[selected]?.focus();
+                }
+                else if (event.key.toLowerCase() === "l") {
+                    mode = "line";
+                    render();
+                    board.querySelectorAll(".ky-cell")[selected]?.focus();
+                }
+                else if (event.key.toLowerCase() === "s") {
+                    mode = "shade";
+                    render();
+                    board.querySelectorAll(".ky-cell")[selected]?.focus();
+                }
+            };
+            controls.append(button);
+        });
+        board.append(controls);
+        modes.replaceChildren();
+        tools.replaceChildren();
+        const add = (host, label, action, pressed) => {
+            const button = document.createElement("button");
+            button.type = "button";
+            button.textContent = label;
+            if (pressed !== undefined)
+                button.setAttribute("aria-pressed", String(pressed));
+            button.onclick = action;
+            host.append(button);
+        };
+        add(modes, w.line, () => { mode = "line"; render(); }, mode === "line");
+        add(modes, w.shade, () => { mode = "shade"; render(); }, mode === "shade");
+        add(tools, w.undo, () => { game = undoYajilin(game); errors = []; message = ""; render(); changed(); });
+        add(tools, w.hint, () => {
+            const hint = hintYajilin(game);
+            if (!hint)
+                message = w.bad;
+            else {
+                game = hint.type === "shade" ? toggleYajilinShade(game, hint.cell) : toggleYajilinEdge(game, hint.edge);
+                game = { ...game, helped: true };
+                selected = hint.type === "shade" ? hint.cell : selected;
+                message = w.good;
+                changed();
+            }
+            render();
+        });
+        add(tools, w.check, () => { errors = checkYajilin(game.board, game.shaded, game.edges).errors; message = errors.length ? w.bad : w.good; render(); });
+        add(tools, w.restart, () => { game = restartYajilin(game); anchor = null; errors = []; message = ""; render(); changed(); });
+        status.textContent = checkYajilin(game.board, game.shaded, game.edges).ok ? (game.helped ? w.helped : w.won) : message;
+    };
+    render();
+    return { game: copy, progress: () => encodeYajilin(game), set: next => { options = { ...options, ...next }; render(); }, restart: () => { game = restartYajilin(game); anchor = null; render(); changed(); }, destroy: () => { dead = true; element.replaceChildren(); } };
+}

package/dist/yajilinPlay.types.d.ts

@@ -0,0 +1 @@
+export type { YajilinDrawOptions as YajilinDrawOptions, YajilinMount as YajilinMount, YajilinMountOptions as YajilinMountOptions } from "./yajilin.types.ts";

package/dist/yajilinPlay.types.js

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

package/dist/yajilinSolve.d.ts

@@ -0,0 +1,6 @@
+import type { YajilinBoard, YajilinSolve } from "./yajilin.types.ts";
+/** Counts public shade patterns whose remaining cells form the single required loop. */
+export declare function solveYajilin(board: YajilinBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): YajilinSolve;

package/dist/yajilinSolve.js

@@ -0,0 +1,82 @@
+import { YAJILIN_NODE_BUDGET } from "./yajilin.constants.js";
+import { checkYajilin, isYajilinBoard, yajilinNeighbors, yajilinRay } from "./yajilinBoard.js";
+/** Counts public shade patterns whose remaining cells form the single required loop. */
+export function solveYajilin(board, options = {}) {
+    if (!isYajilinBoard(board))
+        throw new RangeError("Invalid Yajilin board");
+    const limit = options.limit ?? 2, budget = options.nodes ?? YAJILIN_NODE_BUDGET;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
+        throw new RangeError("Invalid search bounds");
+    const total = board.width * board.height, state = Array(total).fill(-1), shadeable = [];
+    const rays = board.clues.flatMap((clue, cell) => clue ? [{ cell, clue, cells: yajilinRay(board, cell, clue.direction) }] : []);
+    board.clues.forEach((clue, cell) => { if (clue)
+        state[cell] = 2;
+    else
+        shadeable.push(cell); });
+    let count = 0, nodes = 0, complete = true, solution = null;
+    const candidateEdges = (shaded) => {
+        const edges = [];
+        for (let cell = 0; cell < total; cell += 1) {
+            if (board.clues[cell] || shaded[cell])
+                continue;
+            for (const next of yajilinNeighbors(board, cell))
+                if (cell < next.cell && !board.clues[next.cell] && !shaded[next.cell])
+                    edges.push(next.edge);
+        }
+        return edges;
+    };
+    const raysPossible = () => rays.every(({ clue, cells }) => {
+        const shaded = cells.filter(cell => state[cell] === 1).length;
+        const unknown = cells.filter(cell => state[cell] === -1).length;
+        return shaded <= clue.count && shaded + unknown >= clue.count;
+    });
+    const visit = (depth) => {
+        if (++nodes > budget) {
+            complete = false;
+            return;
+        }
+        if (!raysPossible())
+            return;
+        if (depth === shadeable.length) {
+            const shaded = state.map(value => value === 1), edges = candidateEdges(shaded);
+            if (!checkYajilin(board, shaded, edges).ok)
+                return;
+            count += 1;
+            solution ?? (solution = { shaded, edges });
+            if (count >= limit)
+                complete = false;
+            return;
+        }
+        let chosen = -1, bestScore = -1;
+        for (const cell of shadeable) {
+            if (state[cell] !== -1)
+                continue;
+            let score = 0;
+            for (const clue of rays)
+                if (clue.cells.includes(cell))
+                    score += 1;
+            if (score > bestScore) {
+                chosen = cell;
+                bestScore = score;
+            }
+        }
+        if (chosen < 0)
+            return;
+        state[chosen] = 0;
+        visit(depth + 1);
+        if (!complete) {
+            state[chosen] = -1;
+            return;
+        }
+        const x = chosen % board.width, y = Math.floor(chosen / board.width);
+        const touchesShade = (x > 0 && state[chosen - 1] === 1) || (x + 1 < board.width && state[chosen + 1] === 1)
+            || (y > 0 && state[chosen - board.width] === 1) || (y + 1 < board.height && state[chosen + board.width] === 1);
+        if (!touchesShade) {
+            state[chosen] = 1;
+            visit(depth + 1);
+        }
+        state[chosen] = -1;
+    };
+    visit(0);
+    return { count, solution, complete, nodes };
+}

package/dist/yajilinStrings.d.ts

@@ -0,0 +1,32 @@
+export declare const YAJILIN_STRINGS: {
+    readonly en: {
+        readonly title: "Yajilin";
+        readonly help: "Shade the number of cells each arrow points to. Shaded cells cannot touch. Every other empty cell is part of one loop.";
+        readonly line: "Line";
+        readonly shade: "Shade";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly won: "Solved!";
+        readonly helped: "Solved with help.";
+        readonly good: "Keep going; the loop is not complete yet.";
+        readonly bad: "Check the marked cells, arrows, and line.";
+        readonly cell: "cell";
+    };
+    readonly ja: {
+        readonly title: "やじりん";
+        readonly help: "矢印の先にある黒マスの数を合わせます。黒マスは辺で隣り合えません。残りの空きマスを一つの輪にします。";
+        readonly line: "線";
+        readonly shade: "黒マス";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確認";
+        readonly restart: "やり直す";
+        readonly won: "完成！";
+        readonly helped: "ヒントを使って完成。";
+        readonly good: "輪はまだ完成していません。続けましょう。";
+        readonly bad: "印のついたマス、矢印、線を確認してください。";
+        readonly cell: "マス";
+    };
+};

package/dist/yajilinStrings.js

@@ -0,0 +1,4 @@
+export const YAJILIN_STRINGS = {
+    en: { title: "Yajilin", help: "Shade the number of cells each arrow points to. Shaded cells cannot touch. Every other empty cell is part of one loop.", line: "Line", shade: "Shade", undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", won: "Solved!", helped: "Solved with help.", good: "Keep going; the loop is not complete yet.", bad: "Check the marked cells, arrows, and line.", cell: "cell" },
+    ja: { title: "やじりん", help: "矢印の先にある黒マスの数を合わせます。黒マスは辺で隣り合えません。残りの空きマスを一つの輪にします。", line: "線", shade: "黒マス", undo: "戻す", hint: "ヒント", check: "確認", restart: "やり直す", won: "完成！", helped: "ヒントを使って完成。", good: "輪はまだ完成していません。続けましょう。", bad: "印のついたマス、矢印、線を確認してください。", cell: "マス" },
+};

package/dist/yajilinStyle.d.ts

@@ -0,0 +1 @@
+export declare const YAJILIN_PLAY_STYLE = "\n.kazu-yajilin { color:var(--kz-ink,#1f2320); font:16px/1.4 system-ui,sans-serif; }\n.kazu-yajilin .ky-board { position:relative; max-width:440px; margin:auto; }\n.kazu-yajilin svg { border:1px solid var(--kz-frame,#a98954); border-radius:4px; }\n.kazu-yajilin .ky-cells { position:absolute; inset:6%; display:grid; }\n.kazu-yajilin .ky-cell { border:0; background:transparent; color:transparent; cursor:pointer; }\n.kazu-yajilin .ky-cell:focus-visible { outline:3px solid var(--kz-focus,#c57d2d); outline-offset:-5px; }\n.kazu-yajilin .ky-tools { display:flex; flex-wrap:wrap; gap:.5rem; justify-content:center; margin:.8rem 0; }\n.kazu-yajilin button { font:inherit; padding:.45rem .8rem; }\n.kazu-yajilin .ky-status { min-height:1.5em; text-align:center; }\n.kazu-yajilin .ky-modes [aria-pressed=\"true\"] { outline:2px solid var(--kz-frame,#a98954); }\n";

package/dist/yajilinStyle.js

@@ -0,0 +1,12 @@
+export const YAJILIN_PLAY_STYLE = `
+.kazu-yajilin { color:var(--kz-ink,#1f2320); font:16px/1.4 system-ui,sans-serif; }
+.kazu-yajilin .ky-board { position:relative; max-width:440px; margin:auto; }
+.kazu-yajilin svg { border:1px solid var(--kz-frame,#a98954); border-radius:4px; }
+.kazu-yajilin .ky-cells { position:absolute; inset:6%; display:grid; }
+.kazu-yajilin .ky-cell { border:0; background:transparent; color:transparent; cursor:pointer; }
+.kazu-yajilin .ky-cell:focus-visible { outline:3px solid var(--kz-focus,#c57d2d); outline-offset:-5px; }
+.kazu-yajilin .ky-tools { display:flex; flex-wrap:wrap; gap:.5rem; justify-content:center; margin:.8rem 0; }
+.kazu-yajilin button { font:inherit; padding:.45rem .8rem; }
+.kazu-yajilin .ky-status { min-height:1.5em; text-align:center; }
+.kazu-yajilin .ky-modes [aria-pressed="true"] { outline:2px solid var(--kz-frame,#a98954); }
+`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@johnmorrisdotca/kazu",
-  "version": "1.1.0",
-  "description": "Kazu \u6570, grid number puzzles for JavaScript and TypeScript: Sudoku (4\u00d74 to a 16\u00d716 Giant), Jigsaw, Diagonal and Killer Sudoku, Futoshiki, Skyscrapers and Shikaku. Shikaku uses a dedicated rectangle model, exact-cover solver and player. A seeded generator whose every puzzle has exactly one answer, at three levels; a solver that counts answers; a check that reads a finished grid in O(cells); a hint that says which cell to fill next and why; puzzles as short codes; the grid drawn as SVG; and played by touch, mouse and keyboard in any page, with pencil marks, undo and a clock, as a function call or a tag. Zero dependencies.",
+  "version": "1.3.0",
+  "description": "Grid number and logic puzzles for JavaScript and TypeScript: Sudoku and its variants, Futoshiki, Skyscrapers, Shikaku, Hitori, Nurikabe, Akari, Juosan, Slitherlink, Masyu, Yajilin, Ripple Effect, Kakuro, Fillomino and Heyawake. Dedicated typed engines, independently checked puzzles, SVG boards and bilingual touch and keyboard players. Zero runtime dependencies.",
   "keywords": [
     "puzzle",
     "sudoku",
@@ -24,7 +24,19 @@
     "browser",
     "node",
     "itsutsu",
-    "shikaku"
+    "shikaku",
+    "hitori",
+    "nurikabe",
+    "akari",
+    "light-puzzle",
+    "juosan",
+    "slitherlink",
+    "masyu",
+    "yajilin",
+    "ripple-effect",
+    "kakuro",
+    "fillomino",
+    "heyawake"
   ],
   "homepage": "https://github.com/johnmorrisdotca/kazu#readme",
   "repository": {
@@ -83,6 +95,171 @@
       "types": "./dist/shikaku-draw-entry.d.ts",
       "import": "./dist/shikaku-draw-entry.js",
       "default": "./dist/shikaku-draw-entry.js"
+    },
+    "./hitori": {
+      "types": "./dist/hitori-entry.d.ts",
+      "import": "./dist/hitori-entry.js",
+      "default": "./dist/hitori-entry.js"
+    },
+    "./hitori/play": {
+      "types": "./dist/hitori-play-entry.d.ts",
+      "import": "./dist/hitori-play-entry.js",
+      "default": "./dist/hitori-play-entry.js"
+    },
+    "./hitori/draw": {
+      "types": "./dist/hitori-draw-entry.d.ts",
+      "import": "./dist/hitori-draw-entry.js",
+      "default": "./dist/hitori-draw-entry.js"
+    },
+    "./nurikabe": {
+      "types": "./dist/nurikabe-entry.d.ts",
+      "import": "./dist/nurikabe-entry.js",
+      "default": "./dist/nurikabe-entry.js"
+    },
+    "./nurikabe/play": {
+      "types": "./dist/nurikabe-play-entry.d.ts",
+      "import": "./dist/nurikabe-play-entry.js",
+      "default": "./dist/nurikabe-play-entry.js"
+    },
+    "./nurikabe/draw": {
+      "types": "./dist/nurikabe-draw-entry.d.ts",
+      "import": "./dist/nurikabe-draw-entry.js",
+      "default": "./dist/nurikabe-draw-entry.js"
+    },
+    "./akari": {
+      "types": "./dist/akari-entry.d.ts",
+      "import": "./dist/akari-entry.js",
+      "default": "./dist/akari-entry.js"
+    },
+    "./akari/play": {
+      "types": "./dist/akari-play-entry.d.ts",
+      "import": "./dist/akari-play-entry.js",
+      "default": "./dist/akari-play-entry.js"
+    },
+    "./akari/draw": {
+      "types": "./dist/akari-draw-entry.d.ts",
+      "import": "./dist/akari-draw-entry.js",
+      "default": "./dist/akari-draw-entry.js"
+    },
+    "./juosan": {
+      "types": "./dist/juosan-entry.d.ts",
+      "import": "./dist/juosan-entry.js",
+      "default": "./dist/juosan-entry.js"
+    },
+    "./juosan/play": {
+      "types": "./dist/juosan-play-entry.d.ts",
+      "import": "./dist/juosan-play-entry.js",
+      "default": "./dist/juosan-play-entry.js"
+    },
+    "./juosan/draw": {
+      "types": "./dist/juosan-draw-entry.d.ts",
+      "import": "./dist/juosan-draw-entry.js",
+      "default": "./dist/juosan-draw-entry.js"
+    },
+    "./slitherlink": {
+      "types": "./dist/slitherlink-entry.d.ts",
+      "import": "./dist/slitherlink-entry.js",
+      "default": "./dist/slitherlink-entry.js"
+    },
+    "./slitherlink/play": {
+      "types": "./dist/slitherlink-play-entry.d.ts",
+      "import": "./dist/slitherlink-play-entry.js",
+      "default": "./dist/slitherlink-play-entry.js"
+    },
+    "./slitherlink/draw": {
+      "types": "./dist/slitherlink-draw-entry.d.ts",
+      "import": "./dist/slitherlink-draw-entry.js",
+      "default": "./dist/slitherlink-draw-entry.js"
+    },
+    "./masyu": {
+      "types": "./dist/masyu-entry.d.ts",
+      "import": "./dist/masyu-entry.js",
+      "default": "./dist/masyu-entry.js"
+    },
+    "./masyu/play": {
+      "types": "./dist/masyu-play-entry.d.ts",
+      "import": "./dist/masyu-play-entry.js",
+      "default": "./dist/masyu-play-entry.js"
+    },
+    "./masyu/draw": {
+      "types": "./dist/masyu-draw-entry.d.ts",
+      "import": "./dist/masyu-draw-entry.js",
+      "default": "./dist/masyu-draw-entry.js"
+    },
+    "./yajilin": {
+      "types": "./dist/yajilin-entry.d.ts",
+      "import": "./dist/yajilin-entry.js",
+      "default": "./dist/yajilin-entry.js"
+    },
+    "./yajilin/play": {
+      "types": "./dist/yajilin-play-entry.d.ts",
+      "import": "./dist/yajilin-play-entry.js",
+      "default": "./dist/yajilin-play-entry.js"
+    },
+    "./yajilin/draw": {
+      "types": "./dist/yajilin-draw-entry.d.ts",
+      "import": "./dist/yajilin-draw-entry.js",
+      "default": "./dist/yajilin-draw-entry.js"
+    },
+    "./ripple": {
+      "types": "./dist/ripple-entry.d.ts",
+      "import": "./dist/ripple-entry.js",
+      "default": "./dist/ripple-entry.js"
+    },
+    "./ripple/play": {
+      "types": "./dist/ripple-play-entry.d.ts",
+      "import": "./dist/ripple-play-entry.js",
+      "default": "./dist/ripple-play-entry.js"
+    },
+    "./ripple/draw": {
+      "types": "./dist/ripple-draw-entry.d.ts",
+      "import": "./dist/ripple-draw-entry.js",
+      "default": "./dist/ripple-draw-entry.js"
+    },
+    "./kakuro": {
+      "types": "./dist/kakuro-entry.d.ts",
+      "import": "./dist/kakuro-entry.js",
+      "default": "./dist/kakuro-entry.js"
+    },
+    "./kakuro/play": {
+      "types": "./dist/kakuro-play-entry.d.ts",
+      "import": "./dist/kakuro-play-entry.js",
+      "default": "./dist/kakuro-play-entry.js"
+    },
+    "./kakuro/draw": {
+      "types": "./dist/kakuro-draw-entry.d.ts",
+      "import": "./dist/kakuro-draw-entry.js",
+      "default": "./dist/kakuro-draw-entry.js"
+    },
+    "./fillomino": {
+      "types": "./dist/fillomino-entry.d.ts",
+      "import": "./dist/fillomino-entry.js",
+      "default": "./dist/fillomino-entry.js"
+    },
+    "./fillomino/play": {
+      "types": "./dist/fillomino-play-entry.d.ts",
+      "import": "./dist/fillomino-play-entry.js",
+      "default": "./dist/fillomino-play-entry.js"
+    },
+    "./fillomino/draw": {
+      "types": "./dist/fillomino-draw-entry.d.ts",
+      "import": "./dist/fillomino-draw-entry.js",
+      "default": "./dist/fillomino-draw-entry.js"
+    },
+    "./heyawake": {
+      "types": "./dist/heyawake-entry.d.ts",
+      "import": "./dist/heyawake-entry.js",
+      "default": "./dist/heyawake-entry.js"
+    },
+    "./heyawake/play": {
+      "types": "./dist/heyawake-play-entry.d.ts",
+      "import": "./dist/heyawake-play-entry.js",
+      "default": "./dist/heyawake-play-entry.js"
+    },
+    "./heyawake/draw": {
+      "types": "./dist/heyawake-draw-entry.d.ts",
+      "import": "./dist/heyawake-draw-entry.js",
+      "default": "./dist/heyawake-draw-entry.js"
     }
   },
   "files": [