@johnmorrisdotca/kumimoji 1.3.0 → 1.3.1

package/dist/generate.js

@@ -1,6 +1,6 @@
-import { seededRandom, shuffled } from "./random.js";
 import { encodeGrid, squareAt } from "./grid.js";
 import { crossingFit } from "./placement.js";
+import { seededRandom, shuffled } from "./random.js";
 import { kumimojiTileCount, kumimojiWildCount, TILE_MIX_TOTAL } from "./tiles.constants.js";
 import { tileWords } from "./tileWords.js";
 /**
@@ -58,10 +58,12 @@ export function generateKumimoji(size, level, seed, options = {}) {
     const side = layingSideFor(tiles);
     let bestProgress = 0;
     for (let attempt = 0; attempt < 50; attempt += 1) {
-        const squares = layCrossword(tiles, random, words, side, multiplier, words.mix, (laid) => { bestProgress = Math.max(bestProgress, laid); }, diagonals);
+        const squares = layCrossword(tiles, random, words, side, multiplier, words.mix, (laid) => {
+            bestProgress = Math.max(bestProgress, laid);
+        }, diagonals);
         if (squares === null)
             continue;
-        const positions = shuffled(squares.flatMap((tile, at) => tile === "" ? [] : [at]), random);
+        const positions = shuffled(squares.flatMap((tile, at) => (tile === "" ? [] : [at])), random);
         const wildAt = new Set(positions.slice(0, wilds));
         const bag = squares.flatMap((tile, at) => {
             if (tile === "")
@@ -74,7 +76,18 @@ export function generateKumimoji(size, level, seed, options = {}) {
             squares[at] = assigned;
             return ["*"];
         });
-        return { kind: "kumimoji", size, level, seed, givens: shuffled(bag, random).join(""), solution: encodeGrid(tilesOf(squares, side)), gameLength, doubleSet, language, ...(diagonals ? { diagonals } : {}) };
+        return {
+            kind: "kumimoji",
+            size,
+            level,
+            seed,
+            givens: shuffled(bag, random).join(""),
+            solution: encodeGrid(tilesOf(squares, side)),
+            gameLength,
+            doubleSet,
+            language,
+            ...(diagonals ? { diagonals } : {}),
+        };
     }
     throw new Error(`Could not lay a Kumimoji of ${tiles} tiles from seed ${seed}; furthest attempt laid ${bestProgress}.`);
 }
@@ -102,7 +115,7 @@ const LONGEST_LAID = 7;
 const ANCHORS_TRIED = 8;
 const WORDS_READ = 60;
 const FINISH_BRANCHES = 40;
-const FINISH_NODES = 2000;
+const FINISH_NODES = 2_000;
 /**
  * With Diagonals the last tiles are placed from every tile but a sample of
  * words, and a try that cannot finish is given up sooner: a crossword read

package/dist/grid.js

@@ -48,7 +48,12 @@ export function boundsOf(tiles) {
         bounds =
             bounds === null
                 ? { top: row, left: col, bottom: row, right: col }
-                : { top: Math.min(bounds.top, row), left: Math.min(bounds.left, col), bottom: Math.max(bounds.bottom, row), right: Math.max(bounds.right, col) };
+                : {
+                    top: Math.min(bounds.top, row),
+                    left: Math.min(bounds.left, col),
+                    bottom: Math.max(bounds.bottom, row),
+                    right: Math.max(bounds.right, col),
+                };
     }
     return bounds;
 }
@@ -188,7 +193,12 @@ export function sameLetters(a, b) {
     return true;
 }
 /** One step along each line, as rows and columns. */
-const STEP = { across: [0, 1], down: [1, 0], downRight: [1, 1], downLeft: [1, -1] };
+const STEP = {
+    across: [0, 1],
+    down: [1, 0],
+    downRight: [1, 1],
+    downLeft: [1, -1],
+};
 /**
  * The fewest tiles a diagonal run needs before it is read. Two tiles touching
  * at a corner are what every crossword is full of — the letter above a word
@@ -283,7 +293,13 @@ export function groupsOf(tiles, links = []) {
             const at = queue.pop();
             group.push(at);
             const { row, col } = placeOf(at);
-            for (const near of [squareAt(row - 1, col), squareAt(row + 1, col), squareAt(row, col - 1), squareAt(row, col + 1), ...(joined.get(at) ?? [])]) {
+            for (const near of [
+                squareAt(row - 1, col),
+                squareAt(row + 1, col),
+                squareAt(row, col - 1),
+                squareAt(row, col + 1),
+                ...(joined.get(at) ?? []),
+            ]) {
                 if (tiles.has(near) && !seen.has(near)) {
                     seen.add(near);
                     queue.push(near);
@@ -322,5 +338,11 @@ export function judgeGrid(tiles, isWord, readable = (word) => word, rules = {})
     }
     const groups = groupsOf(tiles, runs.filter((run) => run.line === "downRight" || run.line === "downLeft"));
     const apart = new Set(groups.slice(1).flat());
-    return { sound: tiles.size >= 2 && groups.length === 1 && notWords.length === 0, tiles: tiles.size, misspelt, apart, notWords };
+    return {
+        sound: tiles.size >= 2 && groups.length === 1 && notWords.length === 0,
+        tiles: tiles.size,
+        misspelt,
+        apart,
+        notWords,
+    };
 }

package/dist/index.d.ts

@@ -16,33 +16,33 @@
  * a test through `@johnmorrisdotca/kumimoji/words`, which reads them from
  * disk.
  */
-export * from "./kumimoji.types.ts";
-export * from "./tiles.constants.ts";
-export * from "./kana.ts";
-export * from "./tileFace.ts";
-export * from "./tileFamily.ts";
-export * from "./tileWords.ts";
-export * from "./grid.ts";
-export * from "./placement.ts";
-export * from "./wilds.ts";
-export * from "./judge.ts";
 export * from "./check.ts";
-export * from "./generate.ts";
-export * from "./play.ts";
-export * from "./help.ts";
-export * from "./turn.ts";
-export * from "./tableView.ts";
-export * from "./showcase.ts";
-export * from "./party.types.ts";
-export * from "./party.ts";
-export * from "./partyTurns.ts";
-export * from "./partySeats.ts";
-export * from "./partyKept.ts";
 export * from "./computer.types.ts";
 export * from "./computerPlay.ts";
 export * from "./computerTurn.ts";
-export * from "./random.ts";
 export * from "./daily.ts";
 export * from "./export.ts";
+export * from "./generate.ts";
+export * from "./grid.ts";
+export * from "./help.ts";
+export * from "./judge.ts";
+export * from "./kana.ts";
+export * from "./kumimoji.types.ts";
+export * from "./party.ts";
+export * from "./party.types.ts";
+export * from "./partyKept.ts";
+export * from "./partySeats.ts";
+export * from "./partyTurns.ts";
+export * from "./placement.ts";
+export * from "./play.ts";
+export * from "./random.ts";
+export * from "./showcase.ts";
 export * from "./strings.ts";
+export * from "./tableView.ts";
+export * from "./tileFace.ts";
+export * from "./tileFamily.ts";
+export * from "./tiles.constants.ts";
+export * from "./tileWords.ts";
+export * from "./turn.ts";
 export { KUMIMOJI_VERSION } from "./version.ts";
+export * from "./wilds.ts";

package/dist/index.js

@@ -16,33 +16,33 @@
  * a test through `@johnmorrisdotca/kumimoji/words`, which reads them from
  * disk.
  */
-export * from "./kumimoji.types.js";
-export * from "./tiles.constants.js";
-export * from "./kana.js";
-export * from "./tileFace.js";
-export * from "./tileFamily.js";
-export * from "./tileWords.js";
-export * from "./grid.js";
-export * from "./placement.js";
-export * from "./wilds.js";
-export * from "./judge.js";
 export * from "./check.js";
-export * from "./generate.js";
-export * from "./play.js";
-export * from "./help.js";
-export * from "./turn.js";
-export * from "./tableView.js";
-export * from "./showcase.js";
-export * from "./party.types.js";
-export * from "./party.js";
-export * from "./partyTurns.js";
-export * from "./partySeats.js";
-export * from "./partyKept.js";
 export * from "./computer.types.js";
 export * from "./computerPlay.js";
 export * from "./computerTurn.js";
-export * from "./random.js";
 export * from "./daily.js";
 export * from "./export.js";
+export * from "./generate.js";
+export * from "./grid.js";
+export * from "./help.js";
+export * from "./judge.js";
+export * from "./kana.js";
+export * from "./kumimoji.types.js";
+export * from "./party.js";
+export * from "./party.types.js";
+export * from "./partyKept.js";
+export * from "./partySeats.js";
+export * from "./partyTurns.js";
+export * from "./placement.js";
+export * from "./play.js";
+export * from "./random.js";
+export * from "./showcase.js";
 export * from "./strings.js";
+export * from "./tableView.js";
+export * from "./tileFace.js";
+export * from "./tileFamily.js";
+export * from "./tiles.constants.js";
+export * from "./tileWords.js";
+export * from "./turn.js";
 export { KUMIMOJI_VERSION } from "./version.js";
+export * from "./wilds.js";

package/dist/kana.js

@@ -21,7 +21,21 @@
  */
 export const BASE_KANA = "あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわん";
 const SMALL_AND_OLD = {
-    ぁ: "あ", ぃ: "い", ぅ: "う", ぇ: "え", ぉ: "お", っ: "つ", ゃ: "や", ゅ: "ゆ", ょ: "よ", ゎ: "わ", ゕ: "か", ゖ: "け", を: "お", ゐ: "い", ゑ: "え",
+    ぁ: "あ",
+    ぃ: "い",
+    ぅ: "う",
+    ぇ: "え",
+    ぉ: "お",
+    っ: "つ",
+    ゃ: "や",
+    ゅ: "ゆ",
+    ょ: "よ",
+    ゎ: "わ",
+    ゕ: "か",
+    ゖ: "け",
+    を: "お",
+    ゐ: "い",
+    ゑ: "え",
 };
 /** The tile a kana is played with, or null for anything that is not hiragana (ー, katakana, a letter).
  *
@@ -52,9 +66,28 @@ export function tileKana(kana) {
  * ```
  */
 export const CORNER_FORMS = {
-    か: "が", き: "ぎ", く: "ぐ", け: "げ", こ: "ご",
-    さ: "ざ", し: "じ", す: "ず", せ: "ぜ", そ: "ぞ",
-    た: "だ", ち: "ぢ", つ: "っづ", て: "で", と: "ど",
-    は: "ばぱ", ひ: "びぴ", ふ: "ぶぷ", へ: "べぺ", ほ: "ぼぽ",
-    や: "ゃ", ゆ: "ゅ", よ: "ょ", お: "を",
+    か: "が",
+    き: "ぎ",
+    く: "ぐ",
+    け: "げ",
+    こ: "ご",
+    さ: "ざ",
+    し: "じ",
+    す: "ず",
+    せ: "ぜ",
+    そ: "ぞ",
+    た: "だ",
+    ち: "ぢ",
+    つ: "っづ",
+    て: "で",
+    と: "ど",
+    は: "ばぱ",
+    ひ: "びぴ",
+    ふ: "ぶぷ",
+    へ: "べぺ",
+    ほ: "ぼぽ",
+    や: "ゃ",
+    ゆ: "ゅ",
+    よ: "ょ",
+    お: "を",
 };

package/dist/party.js

@@ -118,9 +118,28 @@ export function startParty(settings, bag, seats) {
         const seat = seats[at] ?? "";
         const asked = typeof seat === "string" ? { name: seat } : seat;
         const dealt = { hand: [...bag.slice(at * hand, (at + 1) * hand)], tiles: new Map() };
-        players.push(asked.computer === true ? { name: computerName(players), computer: true, ...dealt } : { name: tidyName(asked.name), ...dealt });
+        players.push(asked.computer === true
+            ? { name: computerName(players), computer: true, ...dealt }
+            : { name: tidyName(asked.name), ...dealt });
     }
-    return { settings, bag, returned: "", taken: count * hand, players, dealt: count, turn: 0, turns: 0, out: [], lastTurns: null, resigned: [], resignRun: [], ending: null, startTable: "", traded: false, passedBy: null };
+    return {
+        settings,
+        bag,
+        returned: "",
+        taken: count * hand,
+        players,
+        dealt: count,
+        turn: 0,
+        turns: 0,
+        out: [],
+        lastTurns: null,
+        resigned: [],
+        resignRun: [],
+        ending: null,
+        startTable: "",
+        traded: false,
+        passedBy: null,
+    };
 }
 /** The name a new computer takes: "Computer" and the lowest number no player at the table already goes by.
  *
@@ -269,7 +288,7 @@ export function withSeatPlay(game, play) {
         return game;
     if (game.traded && play.returned.length > game.returned.length)
         return game;
-    const players = game.players.map((player, at) => (at === game.turn ? { ...player, hand: play.hand, tiles: play.tiles } : player));
+    const players = game.players.map((player, at) => at === game.turn ? { ...player, hand: play.hand, tiles: play.tiles } : player);
     const traded = game.traded || play.returned.length > game.returned.length;
     return { ...game, returned: play.returned, taken: play.taken, players, traded };
 }
@@ -353,7 +372,11 @@ export function nextIn(game, from) {
  * ```
  */
 export function mayDrawAll(game, verdict) {
-    return game.ending === null && game.lastTurns === null && game.players[game.turn].hand.length === 0 && verdict.sound && partyTilesLeft(game) >= stillIn(game).length;
+    return (game.ending === null &&
+        game.lastTurns === null &&
+        game.players[game.turn].hand.length === 0 &&
+        verdict.sound &&
+        partyTilesLeft(game) >= stillIn(game).length);
 }
 /**
  * DRAW: every player still in takes one tile, in turn order from the one who
@@ -378,7 +401,7 @@ export function drawAll(game) {
     if (partyTilesLeft(game) < order.length)
         return game;
     const coming = (game.bag + game.returned).slice(game.taken, game.taken + order.length);
-    const players = game.players.map((player, at) => (order.includes(at) ? { ...player, hand: [...player.hand, coming[order.indexOf(at)]] } : player));
+    const players = game.players.map((player, at) => order.includes(at) ? { ...player, hand: [...player.hand, coming[order.indexOf(at)]] } : player);
     return { ...game, taken: game.taken + order.length, players };
 }
 /**

package/dist/partyKept.js

@@ -1,5 +1,5 @@
 import { decodeGrid, encodeGrid, lettersOf, sameLetters } from "./grid.js";
-import { KUMIMOJI_PARTY, KUMIMOJI_HANDS } from "./tiles.constants.js";
+import { KUMIMOJI_HANDS, KUMIMOJI_PARTY } from "./tiles.constants.js";
 /**
  * A PASS-AND-PLAY GAME KEPT IN THE BROWSER, as one string of JSON: the
  * settings, the whole bag in its order, what was traded back and taken, whose
@@ -50,7 +50,12 @@ export function encodeParty(game) {
         traded: game.traded,
         passedBy: game.passedBy,
         ...(game.dealt === game.players.length ? {} : { dealt: game.dealt }),
-        players: game.players.map((player) => ({ name: player.name, hand: player.hand.join(""), grid: encodeGrid(player.tiles), ...(player.computer === true ? { computer: true } : {}) })),
+        players: game.players.map((player) => ({
+            name: player.name,
+            hand: player.hand.join(""),
+            grid: encodeGrid(player.tiles),
+            ...(player.computer === true ? { computer: true } : {}),
+        })),
     };
     return JSON.stringify(kept);
 }
@@ -88,7 +93,16 @@ export function readSettings(value) {
     // A game kept before Diagonals existed has no word for it, and was played without.
     if (s.diagonals !== undefined && typeof s.diagonals !== "boolean")
         return null;
-    return { size: s.size, level: s.level, seed: s.seed, gameLength: s.gameLength, language: s.language, doubleSet: s.doubleSet, diagonals: s.diagonals === true, hints: s.hints };
+    return {
+        size: s.size,
+        level: s.level,
+        seed: s.seed,
+        gameLength: s.gameLength,
+        language: s.language,
+        doubleSet: s.doubleSet,
+        diagonals: s.diagonals === true,
+        hints: s.hints,
+    };
 }
 /**
  * A kept game read back, or null for anything that is not one. With
@@ -138,23 +152,54 @@ export function decodeParty(code, familyKey) {
     const dealt = kept.dealt ?? count;
     if (!Number.isInteger(dealt) || dealt < KUMIMOJI_PARTY.least || dealt > KUMIMOJI_PARTY.most)
         return null;
-    if (!isCount(kept.turn, count - 1) || !isCount(kept.turns, 1000000) || (kept.ending !== null && kept.ending !== "out" && kept.ending !== "standing" && kept.ending !== "tied") || typeof kept.traded !== "boolean" || !isTiles(kept.startTable) || (kept.passedBy !== null && !isCount(kept.passedBy, count - 1)))
+    if (!isCount(kept.turn, count - 1) ||
+        !isCount(kept.turns, 1_000_000) ||
+        (kept.ending !== null && kept.ending !== "out" && kept.ending !== "standing" && kept.ending !== "tied") ||
+        typeof kept.traded !== "boolean" ||
+        !isTiles(kept.startTable) ||
+        (kept.passedBy !== null && !isCount(kept.passedBy, count - 1)))
         return null;
     const seats = (list) => Array.isArray(list) && list.every((at) => isCount(at, count - 1)) && new Set(list).size === list.length;
-    if (!seats(kept.out) || (kept.lastTurns !== null && !seats(kept.lastTurns)) || !seats(kept.resigned) || !seats(kept.resignRun))
+    if (!seats(kept.out) ||
+        (kept.lastTurns !== null && !seats(kept.lastTurns)) ||
+        !seats(kept.resigned) ||
+        !seats(kept.resignRun))
         return null;
     const players = [];
     for (const player of kept.players) {
-        if (typeof player !== "object" || player === null || typeof player.name !== "string" || player.name.length > KUMIMOJI_PARTY.nameMost || !isTiles(player.hand))
+        if (typeof player !== "object" ||
+            player === null ||
+            typeof player.name !== "string" ||
+            player.name.length > KUMIMOJI_PARTY.nameMost ||
+            !isTiles(player.hand))
             return null;
         if (player.computer !== undefined && player.computer !== true)
             return null;
         const tiles = decodeGrid(player.grid);
         if (tiles === null)
             return null;
-        players.push(player.computer === true ? { name: player.name, hand: [...player.hand], tiles, computer: true } : { name: player.name, hand: [...player.hand], tiles });
+        players.push(player.computer === true
+            ? { name: player.name, hand: [...player.hand], tiles, computer: true }
+            : { name: player.name, hand: [...player.hand], tiles });
     }
-    const game = { settings, bag: kept.bag, returned: kept.returned, taken: kept.taken, players, dealt, turn: kept.turn, turns: kept.turns, out: kept.out, lastTurns: kept.lastTurns, resigned: kept.resigned, resignRun: kept.resignRun, ending: kept.ending, startTable: kept.startTable, traded: kept.traded, passedBy: kept.passedBy };
+    const game = {
+        settings,
+        bag: kept.bag,
+        returned: kept.returned,
+        taken: kept.taken,
+        players,
+        dealt,
+        turn: kept.turn,
+        turns: kept.turns,
+        out: kept.out,
+        lastTurns: kept.lastTurns,
+        resigned: kept.resigned,
+        resignRun: kept.resignRun,
+        ending: kept.ending,
+        startTable: kept.startTable,
+        traded: kept.traded,
+        passedBy: kept.passedBy,
+    };
     if (familyKey !== undefined && !holdsItsBag(game, familyKey))
         return null;
     return game;

package/dist/partySeats.js

@@ -1,5 +1,5 @@
-import { seededRandom, shuffled } from "./random.js";
 import { computerName, isComputer, nextIn, partyTilesLeft, stillIn, tableTally, tidyName } from "./party.js";
+import { seededRandom, shuffled } from "./random.js";
 import { tileFace } from "./tileFace.js";
 import { KUMIMOJI_PARTY } from "./tiles.constants.js";
 /** Why nobody can join the table now, or null when a hand can be dealt.
@@ -47,7 +47,9 @@ export function joinParty(game, seat) {
         return game;
     const hand = [...(game.bag + game.returned).slice(game.taken, game.taken + game.settings.size)];
     const tiles = new Map();
-    const player = seat.computer === true ? { name: computerName(game.players), computer: true, hand, tiles } : { name: tidyName(seat.name) || freePlayerName(game.players), hand, tiles };
+    const player = seat.computer === true
+        ? { name: computerName(game.players), computer: true, hand, tiles }
+        : { name: tidyName(seat.name) || freePlayerName(game.players), hand, tiles };
     return { ...game, players: [...game.players, player], taken: game.taken + hand.length };
 }
 /** "Player" and the next seat's number, or the lowest number nobody at the table goes by. */
@@ -137,7 +139,7 @@ export function leaveParty(game, at) {
         return game;
     const leaver = game.players[at];
     const back = [...leaver.hand, ...leaver.tiles.values()].map((tile) => (tileFace(tile).wild ? "*" : tile));
-    const players = game.players.flatMap((player, seat) => (seat === at ? [] : [{ ...player, name: player.name || `Player ${seat + 1}` }]));
+    const players = game.players.flatMap((player, seat) => seat === at ? [] : [{ ...player, name: player.name || `Player ${seat + 1}` }]);
     const seatOf = (seat) => (seat > at ? seat - 1 : seat);
     const without = (seats) => seats.filter((seat) => seat !== at).map(seatOf);
     const held = players.flatMap((player) => [...player.hand, ...player.tiles.values()]);
@@ -179,7 +181,12 @@ export function leaveParty(game, at) {
     const moved = at === game.turn ? { startTable: tableTally(players[turn].tiles), traded: false } : {};
     if (ending === null && lastTurns === null && stillIn(after).length === 0) {
         // Only players who resigned are left: tied, the last run of them, or all of them where that run has left.
-        return { ...after, ...moved, ending: "tied", resignRun: after.resignRun.length > 0 ? after.resignRun : after.resigned };
+        return {
+            ...after,
+            ...moved,
+            ending: "tied",
+            resignRun: after.resignRun.length > 0 ? after.resignRun : after.resigned,
+        };
     }
     return { ...after, ...moved };
 }

package/dist/partyTurns.js

@@ -47,7 +47,10 @@ export function isOver(game) {
  * ```
  */
 export function goesOut(game, verdict) {
-    return !isOver(game) && game.players[game.turn].hand.length === 0 && verdict.sound && partyTilesLeft(game) < stillIn(game).length;
+    return (!isOver(game) &&
+        game.players[game.turn].hand.length === 0 &&
+        verdict.sound &&
+        partyTilesLeft(game) < stillIn(game).length);
 }
 /** Whether the player whose turn it is has laid a tile on their table this turn: more tiles there than when it began.
  *
@@ -163,7 +166,15 @@ export function doneRefused(game, verdict, handSpells) {
 }
 /** The game passed to `turn`, a new turn with nothing traded and its table as it stands. */
 function passTo(game, turn, rest) {
-    return { ...game, ...rest, turns: game.turns + 1, turn, traded: false, startTable: tableTally(game.players[turn].tiles), passedBy: game.turn };
+    return {
+        ...game,
+        ...rest,
+        turns: game.turns + 1,
+        turn,
+        traded: false,
+        startTable: tableTally(game.players[turn].tiles),
+        passedBy: game.turn,
+    };
 }
 /**
  * DONE: the end of a turn, and the device passed on. Before anybody is out,
@@ -202,7 +213,9 @@ export function endTurn(game, verdict, handSpells) {
     if (game.lastTurns === null) {
         if (out.length === 0)
             return passTo(game, nextIn(game, game.turn), { resignRun: [] });
-        const lastTurns = stillIn(game).filter((at) => at !== game.turn).sort((a, b) => fromTurn(game, a) - fromTurn(game, b));
+        const lastTurns = stillIn(game)
+            .filter((at) => at !== game.turn)
+            .sort((a, b) => fromTurn(game, a) - fromTurn(game, b));
         if (lastTurns.length === 0)
             return passTo(game, game.turn, { out, lastTurns, ending: "out" });
         return passTo(game, lastTurns[0], { out, lastTurns, resignRun: [] });

package/dist/placement.js

@@ -99,8 +99,11 @@ export function crossingFit(letterAt, inside, word, anchor, at, across, diagonal
  * ```
  */
 export function diagonalsRead(letterAt, inside, word, fit, isWord) {
-    const freshAt = new Map(fit.fresh.map((square) => [`${square.row},${square.col}`, word[(square.row - fit.first.row) + (square.col - fit.first.col)]]));
-    const at = (row, col) => (inside(row, col) ? letterAt(row, col) || (freshAt.get(`${row},${col}`) ?? "") : "");
+    const freshAt = new Map(fit.fresh.map((square) => [
+        `${square.row},${square.col}`,
+        word[square.row - fit.first.row + (square.col - fit.first.col)],
+    ]));
+    const at = (row, col) => inside(row, col) ? letterAt(row, col) || (freshAt.get(`${row},${col}`) ?? "") : "";
     for (const { row, col } of fit.fresh) {
         for (const lean of [1, -1]) {
             let top = 0;

package/dist/play.js

@@ -57,7 +57,11 @@ export function placeFromHand(play, handAt, square) {
     const letter = play.hand[handAt];
     if (letter === undefined || play.tiles.has(square))
         return play;
-    return { ...play, tiles: withTiles(play, (tiles) => tiles.set(square, letter)), hand: play.hand.filter((_, at) => at !== handAt) };
+    return {
+        ...play,
+        tiles: withTiles(play, (tiles) => tiles.set(square, letter)),
+        hand: play.hand.filter((_, at) => at !== handAt),
+    };
 }
 /** Give a hand tile its chosen reading, without changing which physical tile it is.
  *
@@ -276,7 +280,12 @@ export function trade(play, handAt) {
         return play;
     const returned = play.returned + letter;
     const coming = (play.bag + returned).slice(play.taken, play.taken + KUMIMOJI_TRADE.take);
-    return { ...play, returned, taken: play.taken + coming.length, hand: [...play.hand.filter((_, at) => at !== handAt), ...coming] };
+    return {
+        ...play,
+        returned,
+        taken: play.taken + coming.length,
+        hand: [...play.hand.filter((_, at) => at !== handAt), ...coming],
+    };
 }
 /** Whether the game is over: the bag empty, the hand used, and the grid sound.
  *
@@ -334,7 +343,9 @@ export function readTileProgress(code) {
     if (parts.length !== 4)
         return null;
     const [takenText, returned, hand, grid] = parts;
-    if (!/^\d{1,3}$/.test(takenText) || !/^[a-zA-Z*\uE000-\uF8FF]*$/.test(returned) || !/^[a-zA-Z*\uE000-\uF8FF]*$/.test(hand))
+    if (!/^\d{1,3}$/.test(takenText) ||
+        !/^[a-zA-Z*\uE000-\uF8FF]*$/.test(returned) ||
+        !/^[a-zA-Z*\uE000-\uF8FF]*$/.test(hand))
         return null;
     const tiles = decodeGrid(grid);
     if (tiles === null)

package/dist/react.js

@@ -29,11 +29,25 @@ const TILE = {
  */
 export function KumimojiBoard({ tiles, verdict = null, glyphOf, onSquare, held = null, square = 36, style, ...element }) {
     const model = boardModel(tiles, verdict, glyphOf);
-    return (_jsx("div", { role: "grid", style: { display: "grid", gap: 2, gridTemplateColumns: `repeat(${model.cols}, ${square}px)`, width: "max-content", ...style }, ...element, children: model.squares.map((cell) => {
+    return (_jsx("div", { role: "grid", style: {
+            display: "grid",
+            gap: 2,
+            gridTemplateColumns: `repeat(${model.cols}, ${square}px)`,
+            width: "max-content",
+            ...style,
+        }, ...element, children: model.squares.map((cell) => {
             const ring = cell.square === held ? "0 0 0 3px #ffcf3f" : cell.mark === "misspelt" ? "0 0 0 3px #d9534f inset" : undefined;
             const look = cell.tile === null
                 ? { width: square, height: square, borderRadius: 5, background: "rgba(127,127,127,.18)", boxShadow: ring }
-                : { ...TILE, width: square, height: square, fontSize: square * 0.55, background: cell.wild ? "#f6d27a" : TILE.background, opacity: cell.mark === "apart" ? 0.6 : 1, boxShadow: ring ?? TILE.boxShadow };
+                : {
+                    ...TILE,
+                    width: square,
+                    height: square,
+                    fontSize: square * 0.55,
+                    background: cell.wild ? "#f6d27a" : TILE.background,
+                    opacity: cell.mark === "apart" ? 0.6 : 1,
+                    boxShadow: ring ?? TILE.boxShadow,
+                };
             return (_jsx("button", { type: "button", "data-square": cell.square, "aria-label": cell.tile === null ? "Empty square" : cell.glyph, onClick: onSquare === undefined ? undefined : () => onSquare(cell.square), style: { border: 0, padding: 0, cursor: onSquare === undefined ? "default" : "pointer", ...look }, children: cell.glyph.toUpperCase() }, cell.square));
         }) }));
 }
@@ -61,7 +75,23 @@ export function KumimojiTable(props) {
         const target = host.current;
         if (target === null)
             return;
-        const table = mountKumimoji(target, { language, hand, level, gameLength, diagonals, seed, locale, strings, theme, keep, controls, saved, onError: error => latest.current.onError?.(error), onFinish: (result) => latest.current.onFinish?.(result), onChange: (saved) => latest.current.onChange?.(saved) });
+        const table = mountKumimoji(target, {
+            language,
+            hand,
+            level,
+            gameLength,
+            diagonals,
+            seed,
+            locale,
+            strings,
+            theme,
+            keep,
+            controls,
+            saved,
+            onError: (error) => latest.current.onError?.(error),
+            onFinish: (result) => latest.current.onFinish?.(result),
+            onChange: (saved) => latest.current.onChange?.(saved),
+        });
         return () => table.destroy();
         // Mounted once per key, as documented above.
         // eslint-disable-next-line react-hooks/exhaustive-deps

package/dist/showcase.js

@@ -1,6 +1,6 @@
 import { BASE_KANA, CORNER_FORMS, tileKana } from "./kana.js";
 import { kanaTileCode } from "./tileFace.js";
-import { JAPANESE_TILE_MIX, KUMIMOJI_HANDS, TILE_MIX, kumimojiTileCount, kumimojiWildCount } from "./tiles.constants.js";
+import { JAPANESE_TILE_MIX, KUMIMOJI_HANDS, kumimojiTileCount, kumimojiWildCount, TILE_MIX, } from "./tiles.constants.js";
 /** A language's set as a page shows it: every tile with its count, the total, and which are the rarest and the commonest.
  *
  * @param language - The English or Japanese tile language.
@@ -17,7 +17,12 @@ import { JAPANESE_TILE_MIX, KUMIMOJI_HANDS, TILE_MIX, kumimojiTileCount, kumimoj
 export function mixShown(language) {
     const tiles = language === "english"
         ? Object.entries(TILE_MIX).map(([letter, count]) => ({ code: letter, glyph: letter, forms: "", count }))
-        : [...BASE_KANA].map((kana) => ({ code: kanaTileCode(kana), glyph: kana, forms: CORNER_FORMS[kana] ?? "", count: JAPANESE_TILE_MIX[kana] ?? 0 }));
+        : [...BASE_KANA].map((kana) => ({
+            code: kanaTileCode(kana),
+            glyph: kana,
+            forms: CORNER_FORMS[kana] ?? "",
+            count: JAPANESE_TILE_MIX[kana] ?? 0,
+        }));
     const counts = tiles.map((tile) => tile.count);
     const most = Math.max(...counts);
     const fewest = Math.min(...counts);
@@ -87,7 +92,11 @@ export function lengthRows(hand = KUMIMOJI_HANDS.classic) {
             length,
             tiles,
             doubleTiles: kumimojiTileCount(hand, length, undefined, true),
-            wilds: { easy: kumimojiWildCount(hand, "easy", tiles), medium: kumimojiWildCount(hand, "medium", tiles), hard: kumimojiWildCount(hand, "hard", tiles) },
+            wilds: {
+                easy: kumimojiWildCount(hand, "easy", tiles),
+                medium: kumimojiWildCount(hand, "medium", tiles),
+                hard: kumimojiWildCount(hand, "hard", tiles),
+            },
         };
     });
 }