@johnmorrisdotca/kumimoji 1.2.2 → 1.3.1

package/dist/grid.d.ts

@@ -11,40 +11,139 @@
  * and COW down from its C. Only
  * where the tiles stand beside one another is written, never where on the
  * table they were, so one grid has one spelling however far it was dragged.
+ *
+ * @example
+ * ```ts
+ * import type { Tiles } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * const value: Tiles = tiles;
+ * console.log(value);
+ * ```
  */
 export type Tiles = ReadonlyMap<string, string>;
-/** A square's name, "row,col". */
+/** A square's name, "row,col".
+ *
+ * @param row - The integer row coordinate, which may be negative.
+ * @param col - The integer column coordinate, which may be negative.
+ * @returns A square's name, "row,col".
+ * @example
+ * ```ts
+ * import { squareAt } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(squareAt(-1,2));
+ * ```
+ */
 export declare function squareAt(row: number, col: number): string;
-/** A square's row and column, from its name. */
+/** A square's row and column, from its name.
+ *
+ * @param square - The row,column square name.
+ * @returns A square's row and column, from its name.
+ * @example
+ * ```ts
+ * import { placeOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(placeOf("-1,2"));
+ * ```
+ */
 export declare function placeOf(square: string): {
     row: number;
     col: number;
 };
-/** The rows and columns a grid's tiles stand within. */
+/** The rows and columns a grid's tiles stand within.
+ *
+ * @example
+ * ```ts
+ * import type { Bounds } from "@johnmorrisdotca/kumimoji";
+ *
+ * const value: Bounds = {top:0,left:0,bottom:0,right:2};
+ * console.log(value);
+ * ```
+ */
 export type Bounds = {
     top: number;
     left: number;
     bottom: number;
     right: number;
 };
-/** The rows and columns the tiles stand within, or null for no tiles. */
+/** The rows and columns the tiles stand within, or null for no tiles.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @returns The rows and columns the tiles stand within, or null for no tiles.
+ * @example
+ * ```ts
+ * import { boundsOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(boundsOf(tiles));
+ * ```
+ */
 export declare function boundsOf(tiles: Tiles): Bounds | null;
-/** A grid as a string, drawn from its own top-left tile: `cat/2o/2w`. `decodeGrid` reads it back. */
+/** A grid as a string, drawn from its own top-left tile: `cat/2o/2w`. `decodeGrid` reads it back.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @returns A grid as a string, drawn from its own top-left tile: `cat/2o/2w`. `decodeGrid` reads it back.
+ * @example
+ * ```ts
+ * import { encodeGrid } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(encodeGrid(tiles));
+ * ```
+ */
 export declare function encodeGrid(tiles: Tiles): string;
 /**
  * A grid read back, its first row at row 0, or null for anything that is not
  * one: a stray character, a capital, a grid wider or taller than any grid of
  * fifty tiles can be. An empty string is no tiles.
+ *
+ * @param code - The encoded grid or progress text.
+ * @returns A grid read back, its first row at row 0, or null for anything that is not one: a stray character, a capital, a grid wider or taller than any grid of fifty tiles can be. An empty string is no tiles.
+ * @example
+ * ```ts
+ * import { decodeGrid } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(decodeGrid("cat"));
+ * ```
  */
 export declare function decodeGrid(code: string): Map<string, string> | null;
-/** How many of each letter. */
+/** How many of each letter.
+ *
+ * @param letters - The iterable tile letters to count.
+ * @returns How many of each letter.
+ * @example
+ * ```ts
+ * import { lettersOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(lettersOf("cat"));
+ * ```
+ */
 export declare function lettersOf(letters: Iterable<string>): Map<string, number>;
-/** Whether two tallies hold the same letters, as many of each. */
+/** Whether two tallies hold the same letters, as many of each.
+ *
+ * @param a - The first letter-count map.
+ * @param b - The second letter-count map.
+ * @returns Whether two tallies hold the same letters, as many of each.
+ * @example
+ * ```ts
+ * import { lettersOf, sameLetters } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(sameLetters(lettersOf("cat"),lettersOf("act")));
+ * ```
+ */
 export declare function sameLetters(a: Map<string, number>, b: Map<string, number>): boolean;
 /**
  * THE LINES A RUN MAY LIE ALONG, each read top to bottom (and across, left to
  * right): across and down always, and the two diagonals when the game was set
  * up with Diagonals — down to the right, and down to the left.
+ *
+ * @example
+ * ```ts
+ * import type { RunLine } from "@johnmorrisdotca/kumimoji";
+ *
+ * const value: RunLine = "across";
+ * console.log(value);
+ * ```
  */
 export type RunLine = "across" | "down" | "downRight" | "downLeft";
 /**
@@ -52,13 +151,37 @@ export type RunLine = "across" | "down" | "downRight" | "downLeft";
  * at a corner are what every crossword is full of — the letter above a word
  * and the one beside it — so a pair is free, and only three or more in a
  * line are a diagonal word.
+ *
+ * @example
+ * ```ts
+ * import { DIAGONAL_RUN_LEAST } from "@johnmorrisdotca/kumimoji";
+ * console.log(DIAGONAL_RUN_LEAST);
+ * ```
  */
 export declare const DIAGONAL_RUN_LEAST = 3;
-/** How a grid is read: whether its diagonals are (`KumimojiOptions.diagonals`). */
+/** How a grid is read: whether its diagonals are (`KumimojiOptions.diagonals`).
+ *
+ * @example
+ * ```ts
+ * import type { GridRules } from "@johnmorrisdotca/kumimoji";
+ *
+ * const value: GridRules = {diagonals:true};
+ * console.log(value);
+ * ```
+ */
 export type GridRules = {
     diagonals?: boolean;
 };
-/** A run of tiles along one line: the word it spells and the squares it stands on, in reading order. */
+/** A run of tiles along one line: the word it spells and the squares it stands on, in reading order.
+ *
+ * @example
+ * ```ts
+ * import type { Run } from "@johnmorrisdotca/kumimoji";
+ *
+ * const value: Run = {word:"cat",squares:["0,0","0,1","0,2"],line:"across"};
+ * console.log(value);
+ * ```
+ */
 export type Run = {
     word: string;
     squares: string[];
@@ -68,6 +191,17 @@ export type Run = {
  * Every run the grid is read by: two or more tiles across, then down, and
  * with Diagonals three or more down to the right, then down to the left. A
  * tile with nothing beside it in a line is no run.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @param rules - Whether diagonal runs are also judged.
+ * @returns Every run the grid is read by: two or more tiles across, then down, and with Diagonals three or more down to the right, then down to the left. A tile with nothing beside it in a line is no run.
+ * @example
+ * ```ts
+ * import { runsOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(runsOf(tiles));
+ * ```
  */
 export declare function runsOf(tiles: Tiles, rules?: GridRules): Run[];
 /**
@@ -76,6 +210,17 @@ export declare function runsOf(tiles: Tiles, rules?: GridRules): Run[];
  * other in one of those runs are joined too: a diagonal word holds a
  * crossword together as a word across does. A pair touching at a corner is
  * never a link, because it is never read.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @param links - The runs connecting groups; computed from the grid when omitted.
+ * @returns The tiles in groups that touch across or down, largest first. With `links` — the diagonal runs a grid with Diagonals reads — the tiles next to each other in one of those runs are joined too: a diagonal word holds a crossword together as a word across does. A pair touching at a corner is never a link, because it is never read.
+ * @example
+ * ```ts
+ * import { groupsOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(groupsOf(tiles));
+ * ```
  */
 export declare function groupsOf(tiles: Tiles, links?: readonly Run[]): string[][];
 /**
@@ -85,6 +230,18 @@ export declare function groupsOf(tiles: Tiles, links?: readonly Run[]): string[]
  * With Diagonals (`rules`), the diagonal runs of three or more are runs too:
  * each must be a word, a misspelt one is marked as any other is, and each
  * joins its tiles (`groupsOf`).
+ *
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { judgeWithWords } from "@johnmorrisdotca/kumimoji";
+ * import type { GridVerdict } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const verdict = judgeWithWords(new Map([["0,0","c"],["0,1","a"],["0,2","t"]]),words);
+ * const value: GridVerdict = verdict;
+ * console.log(value);
+ * ```
  */
 export type GridVerdict = {
     sound: boolean;
@@ -96,5 +253,19 @@ export type GridVerdict = {
     /** The runs that are not words, as spelled, for the line under the table. */
     notWords: readonly string[];
 };
-/** A grid judged against any test of a word: `isWord` answers for a run as spelt, and `readable` says how to name one that is not. `judgeWithWords` is this with a language's list. */
+/** A grid judged against any test of a word: `isWord` answers for a run as spelt, and `readable` says how to name one that is not. `judgeWithWords` is this with a language's list.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @param isWord - The predicate that accepts a readable word.
+ * @param readable - The conversion from tile codes to readable words.
+ * @param rules - Whether diagonal runs are also judged.
+ * @returns A grid judged against any test of a word: `isWord` answers for a run as spelt, and `readable` says how to name one that is not. `judgeWithWords` is this with a language's list.
+ * @example
+ * ```ts
+ * import { judgeGrid } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(judgeGrid(tiles,word=>word==="cat"));
+ * ```
+ */
 export declare function judgeGrid(tiles: Tiles, isWord: (word: string) => boolean, readable?: (word: string) => string, rules?: GridRules): GridVerdict;

package/dist/grid.js

@@ -1,14 +1,46 @@
 import { KUMIMOJI_GRID_MOST } from "./tiles.constants.js";
-/** A square's name, "row,col". */
+/** A square's name, "row,col".
+ *
+ * @param row - The integer row coordinate, which may be negative.
+ * @param col - The integer column coordinate, which may be negative.
+ * @returns A square's name, "row,col".
+ * @example
+ * ```ts
+ * import { squareAt } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(squareAt(-1,2));
+ * ```
+ */
 export function squareAt(row, col) {
     return `${row},${col}`;
 }
-/** A square's row and column, from its name. */
+/** A square's row and column, from its name.
+ *
+ * @param square - The row,column square name.
+ * @returns A square's row and column, from its name.
+ * @example
+ * ```ts
+ * import { placeOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(placeOf("-1,2"));
+ * ```
+ */
 export function placeOf(square) {
     const [row, col] = square.split(",").map(Number);
     return { row: row, col: col };
 }
-/** The rows and columns the tiles stand within, or null for no tiles. */
+/** The rows and columns the tiles stand within, or null for no tiles.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @returns The rows and columns the tiles stand within, or null for no tiles.
+ * @example
+ * ```ts
+ * import { boundsOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(boundsOf(tiles));
+ * ```
+ */
 export function boundsOf(tiles) {
     let bounds = null;
     for (const square of tiles.keys()) {
@@ -16,11 +48,27 @@ 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;
 }
-/** A grid as a string, drawn from its own top-left tile: `cat/2o/2w`. `decodeGrid` reads it back. */
+/** A grid as a string, drawn from its own top-left tile: `cat/2o/2w`. `decodeGrid` reads it back.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @returns A grid as a string, drawn from its own top-left tile: `cat/2o/2w`. `decodeGrid` reads it back.
+ * @example
+ * ```ts
+ * import { encodeGrid } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(encodeGrid(tiles));
+ * ```
+ */
 export function encodeGrid(tiles) {
     const bounds = boundsOf(tiles);
     if (bounds === null)
@@ -48,6 +96,15 @@ export function encodeGrid(tiles) {
  * A grid read back, its first row at row 0, or null for anything that is not
  * one: a stray character, a capital, a grid wider or taller than any grid of
  * fifty tiles can be. An empty string is no tiles.
+ *
+ * @param code - The encoded grid or progress text.
+ * @returns A grid read back, its first row at row 0, or null for anything that is not one: a stray character, a capital, a grid wider or taller than any grid of fifty tiles can be. An empty string is no tiles.
+ * @example
+ * ```ts
+ * import { decodeGrid } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(decodeGrid("cat"));
+ * ```
  */
 export function decodeGrid(code) {
     if (typeof code !== "string")
@@ -97,7 +154,17 @@ export function decodeGrid(code) {
     }
     return tiles;
 }
-/** How many of each letter. */
+/** How many of each letter.
+ *
+ * @param letters - The iterable tile letters to count.
+ * @returns How many of each letter.
+ * @example
+ * ```ts
+ * import { lettersOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(lettersOf("cat"));
+ * ```
+ */
 export function lettersOf(letters) {
     const counts = new Map();
     for (const letter of letters)
@@ -105,7 +172,18 @@ export function lettersOf(letters) {
             counts.set(letter, (counts.get(letter) ?? 0) + 1);
     return counts;
 }
-/** Whether two tallies hold the same letters, as many of each. */
+/** Whether two tallies hold the same letters, as many of each.
+ *
+ * @param a - The first letter-count map.
+ * @param b - The second letter-count map.
+ * @returns Whether two tallies hold the same letters, as many of each.
+ * @example
+ * ```ts
+ * import { lettersOf, sameLetters } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(sameLetters(lettersOf("cat"),lettersOf("act")));
+ * ```
+ */
 export function sameLetters(a, b) {
     if (a.size !== b.size)
         return false;
@@ -115,12 +193,23 @@ 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
  * and the one beside it — so a pair is free, and only three or more in a
  * line are a diagonal word.
+ *
+ * @example
+ * ```ts
+ * import { DIAGONAL_RUN_LEAST } from "@johnmorrisdotca/kumimoji";
+ * console.log(DIAGONAL_RUN_LEAST);
+ * ```
  */
 export const DIAGONAL_RUN_LEAST = 3;
 function runsAlong(tiles, line, least) {
@@ -147,6 +236,17 @@ function runsAlong(tiles, line, least) {
  * Every run the grid is read by: two or more tiles across, then down, and
  * with Diagonals three or more down to the right, then down to the left. A
  * tile with nothing beside it in a line is no run.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @param rules - Whether diagonal runs are also judged.
+ * @returns Every run the grid is read by: two or more tiles across, then down, and with Diagonals three or more down to the right, then down to the left. A tile with nothing beside it in a line is no run.
+ * @example
+ * ```ts
+ * import { runsOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(runsOf(tiles));
+ * ```
  */
 export function runsOf(tiles, rules = {}) {
     const runs = [...runsAlong(tiles, "across", 2), ...runsAlong(tiles, "down", 2)];
@@ -160,6 +260,17 @@ export function runsOf(tiles, rules = {}) {
  * other in one of those runs are joined too: a diagonal word holds a
  * crossword together as a word across does. A pair touching at a corner is
  * never a link, because it is never read.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @param links - The runs connecting groups; computed from the grid when omitted.
+ * @returns The tiles in groups that touch across or down, largest first. With `links` — the diagonal runs a grid with Diagonals reads — the tiles next to each other in one of those runs are joined too: a diagonal word holds a crossword together as a word across does. A pair touching at a corner is never a link, because it is never read.
+ * @example
+ * ```ts
+ * import { groupsOf } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(groupsOf(tiles));
+ * ```
  */
 export function groupsOf(tiles, links = []) {
     const joined = new Map();
@@ -182,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);
@@ -193,7 +310,21 @@ export function groupsOf(tiles, links = []) {
     }
     return groups.sort((a, b) => b.length - a.length);
 }
-/** A grid judged against any test of a word: `isWord` answers for a run as spelt, and `readable` says how to name one that is not. `judgeWithWords` is this with a language's list. */
+/** A grid judged against any test of a word: `isWord` answers for a run as spelt, and `readable` says how to name one that is not. `judgeWithWords` is this with a language's list.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @param isWord - The predicate that accepts a readable word.
+ * @param readable - The conversion from tile codes to readable words.
+ * @param rules - Whether diagonal runs are also judged.
+ * @returns A grid judged against any test of a word: `isWord` answers for a run as spelt, and `readable` says how to name one that is not. `judgeWithWords` is this with a language's list.
+ * @example
+ * ```ts
+ * import { judgeGrid } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(judgeGrid(tiles,word=>word==="cat"));
+ * ```
+ */
 export function judgeGrid(tiles, isWord, readable = (word) => word, rules = {}) {
     const misspelt = new Set();
     const notWords = [];
@@ -207,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/help.d.ts

@@ -12,9 +12,42 @@ import type { TileWords } from "./tileWords.ts";
  * Only the hand's own tiles are read — a wild is left for the player to place
  * — and nothing on the table is moved.
  */
-/** How many words one hand offers before the presses go round again: the longest first. */
+/** How many words one hand offers before the presses go round again: the longest first.
+ *
+ * @example
+ * ```ts
+ * import { HELP_WORDS_MOST } from "@johnmorrisdotca/kumimoji";
+ * console.log(HELP_WORDS_MOST);
+ * ```
+ */
 export declare const HELP_WORDS_MOST = 40;
-/** The words the hand's own tiles spell, longest first and then in the list's order; wilds are not used. */
+/** The words the hand's own tiles spell, longest first and then in the list's order; wilds are not used.
+ *
+ * @param hand - The hand size or tile codes, as declared by the function signature.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns The words the hand's own tiles spell, longest first and then in the list's order; wilds are not used.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { wordsInHand } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * console.log(wordsInHand(["c","a","t"],words));
+ * ```
+ */
 export declare function wordsInHand(hand: readonly string[], words: TileWords): string[];
-/** The hand with `word`'s tiles first, in its order, and the rest after them as they were. */
+/** The hand with `word`'s tiles first, in its order, and the rest after them as they were.
+ *
+ * @param play - The current immutable solo-game progress.
+ * @param word - The encoded word to lay or spell.
+ * @returns The hand with `word`'s tiles first, in its order, and the rest after them as they were.
+ * @example
+ * ```ts
+ * import { deal, handSpelling } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * const play = deal("catdog",3);
+ * console.log(handSpelling(play,"cat").tiles);
+ * ```
+ */
 export declare function handSpelling(play: TilePlay, word: string): TilePlay;

package/dist/help.js

@@ -10,9 +10,29 @@
  * Only the hand's own tiles are read — a wild is left for the player to place
  * — and nothing on the table is moved.
  */
-/** How many words one hand offers before the presses go round again: the longest first. */
+/** How many words one hand offers before the presses go round again: the longest first.
+ *
+ * @example
+ * ```ts
+ * import { HELP_WORDS_MOST } from "@johnmorrisdotca/kumimoji";
+ * console.log(HELP_WORDS_MOST);
+ * ```
+ */
 export const HELP_WORDS_MOST = 40;
-/** The words the hand's own tiles spell, longest first and then in the list's order; wilds are not used. */
+/** The words the hand's own tiles spell, longest first and then in the list's order; wilds are not used.
+ *
+ * @param hand - The hand size or tile codes, as declared by the function signature.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns The words the hand's own tiles spell, longest first and then in the list's order; wilds are not used.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { wordsInHand } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * console.log(wordsInHand(["c","a","t"],words));
+ * ```
+ */
 export function wordsInHand(hand, words) {
     const have = new Map();
     for (const tile of hand)
@@ -42,7 +62,20 @@ export function wordsInHand(hand, words) {
     }
     return found;
 }
-/** The hand with `word`'s tiles first, in its order, and the rest after them as they were. */
+/** The hand with `word`'s tiles first, in its order, and the rest after them as they were.
+ *
+ * @param play - The current immutable solo-game progress.
+ * @param word - The encoded word to lay or spell.
+ * @returns The hand with `word`'s tiles first, in its order, and the rest after them as they were.
+ * @example
+ * ```ts
+ * import { deal, handSpelling } from "@johnmorrisdotca/kumimoji";
+ *
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * const play = deal("catdog",3);
+ * console.log(handSpelling(play,"cat").tiles);
+ * ```
+ */
 export function handSpelling(play, word) {
     const rest = [...play.hand];
     const front = [];

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";