@johnmorrisdotca/kazu 1.2.0 → 1.4.0

package/dist/slitherlinkLogic.js

@@ -0,0 +1,267 @@
+import { edgeVertices, slitherlinkCellEdges, slitherlinkEdgeCount, slitherlinkVertexEdges } from "./slitherlinkBoard.js";
+/**
+ * Slitherlink as variables: one per edge, slot 0 for off and slot 1 for on. The pruning rules are the ones
+ * a person uses first: a number counts the edges round its square, every corner has none or two edges, and
+ * a loop may not close while any other part of it is still to be drawn or while a number is not yet met.
+ */
+export function slitherlinkModel(board) {
+    const edges = slitherlinkEdgeCount(board), vertexCount = (board.width + 1) * (board.height + 1);
+    const at = Array.from({ length: vertexCount }, (_, vertex) => Int32Array.from(slitherlinkVertexEdges(board, vertex)));
+    const endA = new Int32Array(edges), endB = new Int32Array(edges);
+    for (let edge = 0; edge < edges; edge += 1) {
+        const [a, b] = edgeVertices(board, edge);
+        endA[edge] = a;
+        endB[edge] = b;
+    }
+    const clues = board.clues.flatMap((clue, cell) => clue === null ? [] : [{ need: clue, edges: Int32Array.from(slitherlinkCellEdges(board, cell)) }]);
+    const cluesOf = Array.from({ length: edges }, () => []);
+    clues.forEach((clue, index) => clue.edges.forEach(edge => cluesOf[edge].push(index)));
+    const starts = Int32Array.from({ length: edges + 1 }, (_, i) => i * 2);
+    const endList = new Int32Array(vertexCount), parent = new Int32Array(vertexCount), degree = new Uint8Array(vertexCount), componentEdges = new Int32Array(vertexCount), openEnds = new Int32Array(vertexCount);
+    const vertexQueue = new Int32Array(vertexCount * 8), clueQueue = new Int32Array(clues.length * 8 + 8);
+    const vertexQueued = new Uint8Array(vertexCount), clueQueued = new Uint8Array(clues.length);
+    const reachable = new Int32Array(vertexCount);
+    const findIn = (table, v) => { while (table[v] !== v) {
+        table[v] = table[table[v]];
+        v = table[v];
+    } return v; };
+    const find = (v) => { while (parent[v] !== v) {
+        parent[v] = parent[parent[v]];
+        v = parent[v];
+    } return v; };
+    const propagate = (alive, decided) => {
+        let vertexHead = 0, vertexTail = 0, clueHead = 0, clueTail = 0;
+        const touch = (e) => {
+            const a = endA[e], b = endB[e];
+            if (!vertexQueued[a]) {
+                vertexQueued[a] = 1;
+                vertexQueue[vertexTail++ % vertexQueue.length] = a;
+            }
+            if (!vertexQueued[b]) {
+                vertexQueued[b] = 1;
+                vertexQueue[vertexTail++ % vertexQueue.length] = b;
+            }
+            for (const index of cluesOf[e])
+                if (!clueQueued[index]) {
+                    clueQueued[index] = 1;
+                    clueQueue[clueTail++ % clueQueue.length] = index;
+                }
+        };
+        const clear = () => { vertexQueued.fill(0); clueQueued.fill(0); return false; };
+        if (decided === undefined)
+            for (let e = 0; e < edges; e += 1)
+                touch(e);
+        else
+            touch(decided);
+        for (;;) {
+            while (vertexHead < vertexTail || clueHead < clueTail) {
+                while (vertexHead < vertexTail) {
+                    const v = vertexQueue[vertexHead++ % vertexQueue.length];
+                    vertexQueued[v] = 0;
+                    const around = at[v];
+                    let on = 0, open = 0, lastOpen = -1;
+                    for (let k = 0; k < around.length; k += 1) {
+                        const e = around[k], off = alive[2 * e], onSlot = alive[2 * e + 1];
+                        if (!off && !onSlot)
+                            return clear();
+                        if (onSlot && !off)
+                            on += 1;
+                        else if (off && onSlot) {
+                            open += 1;
+                            lastOpen = e;
+                        }
+                    }
+                    if (on > 2 || on === 1 && !open)
+                        return clear();
+                    if (on === 2 && open) {
+                        for (let k = 0; k < around.length; k += 1) {
+                            const e = around[k];
+                            if (alive[2 * e] && alive[2 * e + 1]) {
+                                alive[2 * e + 1] = 0;
+                                touch(e);
+                            }
+                        }
+                    }
+                    else if (open === 1 && on < 2) {
+                        if (on === 1)
+                            alive[2 * lastOpen] = 0;
+                        else
+                            alive[2 * lastOpen + 1] = 0;
+                        touch(lastOpen);
+                    }
+                }
+                while (clueHead < clueTail) {
+                    const index = clueQueue[clueHead++ % clueQueue.length], clue = clues[index];
+                    clueQueued[index] = 0;
+                    let on = 0, open = 0;
+                    for (let k = 0; k < 4; k += 1) {
+                        const e = clue.edges[k];
+                        if (!alive[2 * e] && !alive[2 * e + 1])
+                            return clear();
+                        if (alive[2 * e + 1] && !alive[2 * e])
+                            on += 1;
+                        else if (alive[2 * e] && alive[2 * e + 1])
+                            open += 1;
+                    }
+                    if (on > clue.need || on + open < clue.need)
+                        return clear();
+                    if (open && on === clue.need) {
+                        for (let k = 0; k < 4; k += 1) {
+                            const e = clue.edges[k];
+                            if (alive[2 * e] && alive[2 * e + 1]) {
+                                alive[2 * e + 1] = 0;
+                                touch(e);
+                            }
+                        }
+                    }
+                    else if (open && on + open === clue.need) {
+                        for (let k = 0; k < 4; k += 1) {
+                            const e = clue.edges[k];
+                            if (alive[2 * e] && alive[2 * e + 1]) {
+                                alive[2 * e] = 0;
+                                touch(e);
+                            }
+                        }
+                    }
+                }
+            }
+            // Loops: join the drawn edges into pieces, then forbid an edge that would close a piece too early.
+            for (let v = 0; v < vertexCount; v += 1) {
+                parent[v] = v;
+                degree[v] = 0;
+                componentEdges[v] = 0;
+                openEnds[v] = 0;
+            }
+            let drawn = 0;
+            for (let e = 0; e < edges; e += 1) {
+                if (!(alive[2 * e + 1] && !alive[2 * e]))
+                    continue;
+                drawn += 1;
+                const a = endA[e], b = endB[e];
+                degree[a] += 1;
+                degree[b] += 1;
+                parent[find(a)] = find(b);
+            }
+            if (!drawn) {
+                // No loop yet: a fully decided empty drawing is not an answer.
+                for (let e = 0; e < edges; e += 1)
+                    if (alive[2 * e] && alive[2 * e + 1])
+                        return true;
+                return false;
+            }
+            for (let e = 0; e < edges; e += 1)
+                if (alive[2 * e + 1] && !alive[2 * e])
+                    componentEdges[find(endA[e])] += 1;
+            // Everything drawn must still be able to join up: the edges not ruled out have to connect all of it.
+            for (let v = 0; v < vertexCount; v += 1)
+                reachable[v] = v;
+            for (let e = 0; e < edges; e += 1)
+                if (alive[2 * e + 1])
+                    reachable[findIn(reachable, endA[e])] = findIn(reachable, endB[e]);
+            let anchor = -1;
+            for (let e = 0; e < edges; e += 1) {
+                if (!(alive[2 * e + 1] && !alive[2 * e]))
+                    continue;
+                const root = findIn(reachable, endA[e]);
+                if (anchor < 0)
+                    anchor = root;
+                else if (root !== anchor)
+                    return clear();
+            }
+            let ends = 0;
+            for (let v = 0; v < vertexCount; v += 1)
+                if (degree[v] === 1) {
+                    openEnds[find(v)] += 1;
+                    endList[ends++] = v;
+                }
+            let moved = false;
+            for (let v = 0; v < vertexCount; v += 1) {
+                if (degree[v] === 0 || find(v) !== v || openEnds[v])
+                    continue;
+                if (componentEdges[v] !== drawn)
+                    return clear();
+                // A finished loop is the whole answer: nothing else may be drawn.
+                for (let e = 0; e < edges; e += 1)
+                    if (alive[2 * e] && alive[2 * e + 1]) {
+                        alive[2 * e + 1] = 0;
+                        touch(e);
+                        moved = true;
+                    }
+            }
+            // An edge joining the two ends of one piece would close it.
+            for (let k = 0; k < ends; k += 1) {
+                const a = endList[k], around = at[a];
+                for (let j = 0; j < around.length; j += 1) {
+                    const e = around[j];
+                    if (!(alive[2 * e] && alive[2 * e + 1]))
+                        continue;
+                    const b = endA[e] === a ? endB[e] : endA[e];
+                    if (degree[b] !== 1 || find(a) !== find(b))
+                        continue;
+                    // Closing this edge finishes the loop: allowed only when it is the whole drawing and every number is met.
+                    let whole = componentEdges[find(a)] === drawn;
+                    if (whole) {
+                        for (const clue of clues) {
+                            let on = 0;
+                            for (let k2 = 0; k2 < 4; k2 += 1) {
+                                const x = clue.edges[k2];
+                                if (x === e || alive[2 * x + 1] && !alive[2 * x])
+                                    on += 1;
+                            }
+                            if (on !== clue.need) {
+                                whole = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (!whole) {
+                        alive[2 * e + 1] = 0;
+                        touch(e);
+                        moved = true;
+                    }
+                }
+            }
+            if (!moved)
+                return true;
+        }
+    };
+    const choose = (alive) => {
+        // Branch where the board is most pinned down: next to a loose end of the drawing, else on the numbered square with the fewest edges left.
+        let best = -1, bestScore = 99;
+        for (let v = 0; v < vertexCount; v += 1) {
+            const around = at[v];
+            let on = 0, first = -1;
+            for (let k = 0; k < around.length; k += 1) {
+                const e = around[k];
+                if (alive[2 * e + 1] && !alive[2 * e])
+                    on += 1;
+                else if (alive[2 * e] && alive[2 * e + 1] && first < 0)
+                    first = e;
+            }
+            if (first >= 0 && on === 1)
+                return first;
+        }
+        for (const clue of clues) {
+            let open = 0, first = -1;
+            for (let k = 0; k < 4; k += 1) {
+                const e = clue.edges[k];
+                if (alive[2 * e] && alive[2 * e + 1]) {
+                    open += 1;
+                    if (first < 0)
+                        first = e;
+                }
+            }
+            if (open && open < bestScore) {
+                bestScore = open;
+                best = first;
+            }
+        }
+        if (best >= 0)
+            return best;
+        for (let e = 0; e < edges; e += 1)
+            if (alive[2 * e] && alive[2 * e + 1])
+                return e;
+        return -1;
+    };
+    return { csp: { starts, propagate, choose } };
+}

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

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

package/dist/slitherlinkSolve.js

@@ -1,6 +1,8 @@
 import { SLITHERLINK_MOST_NODES } from "./slitherlink.constants.js";
-import { checkSlitherlink, edgeVertices, isSlitherlinkBoard, slitherlinkCellEdges, slitherlinkEdgeCount, slitherlinkVertexEdges, } from "./slitherlinkBoard.js";
-/** Counts loop solutions with clue and vertex propagation under explicit work bounds. */
+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");
@@ -9,119 +11,9 @@ export function solveSlitherlink(board, options = {}) {
     if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1) {
         throw new RangeError("Invalid search bounds");
     }
-    const edgeCount = slitherlinkEdgeCount(board);
-    const vertices = Array.from({ length: (board.width + 1) * (board.height + 1) }, (_, vertex) => slitherlinkVertexEdges(board, vertex));
-    const cells = board.clues.flatMap((clue, cell) => clue === null ? [] : [slitherlinkCellEdges(board, cell)]);
-    let count = 0;
-    let nodes = 0;
-    let complete = true;
-    let solution = null;
-    const search = (start) => {
-        if (!complete)
-            return;
-        nodes += 1;
-        if (nodes > budget) {
-            complete = false;
-            return;
-        }
-        const state = start.slice();
-        let changed = true;
-        while (changed) {
-            changed = false;
-            for (const group of vertices) {
-                const on = group.filter(edge => state[edge] === 1).length;
-                const unknown = group.filter(edge => state[edge] < 0);
-                if (on > 2 || on === 1 && !unknown.length)
-                    return;
-                if (on === 2) {
-                    for (const edge of unknown) {
-                        state[edge] = 0;
-                        changed = true;
-                    }
-                }
-                else if (on === 1 && unknown.length === 1) {
-                    state[unknown[0]] = 1;
-                    changed = true;
-                }
-                else if (on === 0 && unknown.length === 1) {
-                    state[unknown[0]] = 0;
-                    changed = true;
-                }
-            }
-            let clueIndex = 0;
-            for (const clue of board.clues) {
-                if (clue === null)
-                    continue;
-                const group = cells[clueIndex++];
-                const on = group.filter(edge => state[edge] === 1).length;
-                const unknown = group.filter(edge => state[edge] < 0);
-                if (on > clue || on + unknown.length < clue)
-                    return;
-                if (on === clue) {
-                    for (const edge of unknown) {
-                        state[edge] = 0;
-                        changed = true;
-                    }
-                }
-                else if (on + unknown.length === clue) {
-                    for (const edge of unknown) {
-                        state[edge] = 1;
-                        changed = true;
-                    }
-                }
-            }
-        }
-        const selected = Array.from(state).flatMap((value, edge) => value === 1 ? [edge] : []);
-        const closed = closedComponents(board, selected);
-        if (closed.length > 1)
-            return;
-        if (closed.length === 1 && closed[0].length !== selected.length)
-            return;
-        const branch = state.findIndex(value => value < 0);
-        if (branch < 0) {
-            if (!checkSlitherlink(board, selected).ok)
-                return;
-            count += 1;
-            solution ?? (solution = selected);
-            if (count >= limit)
-                complete = false;
-            return;
-        }
-        for (const value of [1, 0]) {
-            const next = state.slice();
-            next[branch] = value;
-            search(next);
-            if (!complete)
-                return;
-        }
-    };
-    search(new Int8Array(edgeCount).fill(-1));
-    return { count, solution, complete, nodes };
-}
-function closedComponents(board, selected) {
-    const unseen = new Set(selected);
-    const components = [];
-    while (unseen.size) {
-        const first = unseen.values().next().value;
-        const component = [first];
-        const queue = [first];
-        unseen.delete(first);
-        while (queue.length) {
-            const edge = queue.pop();
-            for (const vertex of edgeVertices(board, edge)) {
-                for (const adjacent of slitherlinkVertexEdges(board, vertex)) {
-                    if (!unseen.has(adjacent))
-                        continue;
-                    unseen.delete(adjacent);
-                    component.push(adjacent);
-                    queue.push(adjacent);
-                }
-            }
-        }
-        const vertices = new Set(component.flatMap(edge => edgeVertices(board, edge)));
-        if ([...vertices].every(vertex => slitherlinkVertexEdges(board, vertex)
-            .filter(edge => component.includes(edge)).length === 2))
-            components.push(component);
-    }
-    return components;
+    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/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/strings.js

@@ -19,6 +19,7 @@ export const KAZU_STRINGS = {
         tap: "Tap a cell, then a number.",
         tapPencil: "Pencil marks are on: tap a number to note it in the cell.",
         keys: "Arrow keys move, a number fills the cell, Backspace empties it, N turns pencil marks on or off.",
+        keysColossus: "Arrow keys move, a number or a letter from A to P fills the cell, Backspace empties it, the slash key turns pencil marks on or off (N is a number here).",
         undo: "Undo",
         pencil: "Pencil",
         pencilTitle: "Write small notes in a cell instead of a number",
@@ -83,6 +84,7 @@ export const KAZU_STRINGS = {
         tap: "マスをタップして、数字を選びます。",
         tapPencil: "メモがオンです。数字をタップすると、マスにメモします。",
         keys: "矢印キーで移動、数字キーで入力、Backspaceで消去、Nでメモのオンとオフ。",
+        keysColossus: "矢印キーで移動、数字またはAからPのキーで入力、Backspaceで消去、スラッシュキーでメモのオンとオフ（ここではNは数字です）。",
         undo: "元に戻す",
         pencil: "メモ",
         pencilTitle: "数字のかわりに、マスに小さくメモを書きます",

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@johnmorrisdotca/kazu",
-  "version": "1.2.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.",
+  "version": "1.4.0",
+  "description": "Grid number and logic puzzles for JavaScript and TypeScript: Sudoku (up to 25×25) 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",