chesspal 0.0.1 → 0.2.0

package/dist/core/clock.d.ts

@@ -0,0 +1,45 @@
+import type { Side } from "./game.ts";
+/** A time control: the time each side starts with and the time added after each of its moves, in milliseconds. */
+export interface TimeControl {
+    readonly base: number;
+    readonly increment: number;
+}
+/** The time each side has left, in milliseconds, at the start of the turn of the side to move, `since` (an ISO date). */
+export interface Clock {
+    readonly control: TimeControl;
+    readonly left: Readonly<Record<Side, number>>;
+    readonly since: string;
+    /** The clock waits for the player to start it, on the board page or with their first move: no side's time runs until then. */
+    readonly waiting?: true;
+}
+/** A time control written as minutes and seconds added, as Lichess and chess.com write it: 10+5, 3+0, 0.5+0; the minutes make whole seconds. */
+export declare function timeControlOf(text: string): TimeControl;
+/** A time control as minutes and seconds added: 10+5. */
+export declare function timeControlText({ base, increment }: TimeControl): string;
+/** A time control as PGN's TimeControl tag writes it, in seconds: 600+5. */
+export declare function timeControlTag({ base, increment }: TimeControl): string;
+/** A time control from PGN's TimeControl tag, in seconds: 600+5, or 600 with nothing added; none for a tag of another form, such as - or ?. */
+export declare function timeControlOfTag(tag: string): TimeControl | undefined;
+/** The clock at the start of a game: each side with the whole time, `waiting` for the player to start it or running at once. */
+export declare function startClock(control: TimeControl, now: Date, waiting: boolean): Clock;
+/** The clock started `now`, the turn of the side to move beginning then; a clock already running stays as it is. */
+export declare function clockStarted(clock: Clock, now: Date): Clock;
+/** The time each side has left `now`: the side to move, `turn`, has spent the time since its turn began; never below nothing, and nothing while it waits. */
+export declare function timeLeft(clock: Clock, turn: Side, now: Date): Record<Side, number>;
+/**
+ * The clock after `mover`'s move `now`: the time spent taken off, less an `allowance` for time that was not theirs, the increment added, and the other side's
+ * turn beginning. A clock that waits takes nothing off and stays waiting, unless the move `starts` it: the player's first.
+ */
+export declare function clockAfterMove(clock: Clock, mover: Side, now: Date, allowance?: number, starts?: boolean): Clock;
+/** A time as a clock shows it, cut to the second: 4:32, 1:02:03. */
+export declare function clockText(milliseconds: number): string;
+/** The time left after a move as PGN's [%clk] writes it, in a move's comment: [%clk 0:04:32]. */
+export declare function clockTag(milliseconds: number): string;
+/** The time left a move's comment gives as [%clk 0:04:32], in milliseconds; none without one. */
+export declare function clockOfComment(comment: string): number | undefined;
+/**
+ * Whether `side` could still mate by some series of legal moves, as a fallen flag asks (FIDE 6.9), by Lichess's rule: not with the king alone; not with
+ * king and one knight unless the other side has a piece other than queens to block its king; not with bishops alone, all on squares of one colour, when the
+ * other side has no knight or pawn; with anything else it could, if the other side helped.
+ */
+export declare function canMate(fen: string, side: Side): boolean;

package/dist/core/clock.js

@@ -0,0 +1,109 @@
+/** A time control written as minutes and seconds added, as Lichess and chess.com write it: 10+5, 3+0, 0.5+0; the minutes make whole seconds. */
+export function timeControlOf(text) {
+    const match = /^\s*(\d+(?:\.\d+)?)\s*\+\s*(\d+)\s*$/.exec(text);
+    const seconds = Number(match?.[1]) * 60;
+    const base = Math.round(seconds) * second;
+    const increment = Number(match?.[2]) * second;
+    if (match === null || Math.abs(seconds - Math.round(seconds)) > 1e-9 || base <= 0 || base > 180 * minute || increment > 180 * second) {
+        throw new Error(`"${text}" is not a time control: write minutes, in whole seconds, and seconds added, such as 10+5, 3+0 or 0.5+0, up to 180+180.`);
+    }
+    return { base, increment };
+}
+/** A time control as minutes and seconds added: 10+5. */
+export function timeControlText({ base, increment }) {
+    return `${base / minute}+${increment / second}`;
+}
+/** A time control as PGN's TimeControl tag writes it, in seconds: 600+5. */
+export function timeControlTag({ base, increment }) {
+    return `${Math.round(base / second)}+${Math.round(increment / second)}`;
+}
+/** A time control from PGN's TimeControl tag, in seconds: 600+5, or 600 with nothing added; none for a tag of another form, such as - or ?. */
+export function timeControlOfTag(tag) {
+    const [, base, increment] = /^\s*(\d+)(?:\+(\d+))?\s*$/.exec(tag) ?? [];
+    return base === undefined || Number(base) === 0 ? undefined : { base: Number(base) * second, increment: Number(increment ?? 0) * second };
+}
+/** The clock at the start of a game: each side with the whole time, `waiting` for the player to start it or running at once. */
+export function startClock(control, now, waiting) {
+    const clock = { control, left: { white: control.base, black: control.base }, since: now.toISOString() };
+    return waiting ? { ...clock, waiting: true } : clock;
+}
+/** The clock started `now`, the turn of the side to move beginning then; a clock already running stays as it is. */
+export function clockStarted(clock, now) {
+    return clock.waiting === true ? { control: clock.control, left: clock.left, since: now.toISOString() } : clock;
+}
+/** The time each side has left `now`: the side to move, `turn`, has spent the time since its turn began; never below nothing, and nothing while it waits. */
+export function timeLeft(clock, turn, now) {
+    const spent = clock.waiting === true ? 0 : Math.max(0, now.getTime() - Date.parse(clock.since));
+    return { ...clock.left, [turn]: Math.max(0, clock.left[turn] - spent) };
+}
+/**
+ * The clock after `mover`'s move `now`: the time spent taken off, less an `allowance` for time that was not theirs, the increment added, and the other side's
+ * turn beginning. A clock that waits takes nothing off and stays waiting, unless the move `starts` it: the player's first.
+ */
+export function clockAfterMove(clock, mover, now, allowance = 0, starts = false) {
+    if (clock.waiting === true) {
+        return starts ? clockStarted(clock, now) : { ...clock, since: now.toISOString() };
+    }
+    const left = timeLeft(clock, mover, new Date(now.getTime() - allowance));
+    return { ...clock, left: { ...left, [mover]: left[mover] + clock.control.increment }, since: now.toISOString() };
+}
+/** A time as a clock shows it, cut to the second: 4:32, 1:02:03. */
+export function clockText(milliseconds) {
+    const seconds = Math.floor(milliseconds / second);
+    const [hours, minutes] = [Math.floor(seconds / 3600), Math.floor(seconds / 60) % 60];
+    const rest = String(seconds % 60).padStart(2, "0");
+    return hours > 0 ? `${hours}:${String(minutes).padStart(2, "0")}:${rest}` : `${minutes}:${rest}`;
+}
+/** The time left after a move as PGN's [%clk] writes it, in a move's comment: [%clk 0:04:32]. */
+export function clockTag(milliseconds) {
+    const text = clockText(milliseconds);
+    return `[%clk ${text.split(":").length === 2 ? `0:${text.padStart(5, "0")}` : text}]`;
+}
+/** The time left a move's comment gives as [%clk 0:04:32], in milliseconds; none without one. */
+export function clockOfComment(comment) {
+    const [, hours, minutes, seconds] = /\[%clk (\d+):(\d{1,2}):(\d{1,2}(?:\.\d+)?)\]/.exec(comment) ?? [];
+    return hours === undefined ? undefined : Math.round(((Number(hours) * 60 + Number(minutes)) * 60 + Number(seconds)) * second);
+}
+/**
+ * Whether `side` could still mate by some series of legal moves, as a fallen flag asks (FIDE 6.9), by Lichess's rule: not with the king alone; not with
+ * king and one knight unless the other side has a piece other than queens to block its king; not with bishops alone, all on squares of one colour, when the
+ * other side has no knight or pawn; with anything else it could, if the other side helped.
+ */
+export function canMate(fen, side) {
+    const squares = boardSquares(fen);
+    const own = squares.filter(({ letter }) => (letter === letter.toUpperCase()) === (side === "white")).map(({ letter }) => letter.toLowerCase());
+    const other = squares.filter(({ letter }) => (letter === letter.toUpperCase()) !== (side === "white")).map(({ letter }) => letter.toLowerCase());
+    if (own.length === 0) {
+        return false;
+    }
+    if (own.length === 1 && own[0] === "n") {
+        return other.some((letter) => letter !== "q");
+    }
+    if (own.every((letter) => letter === "b")) {
+        const colours = new Set(squares.filter(({ letter }) => letter.toLowerCase() === "b").map(({ dark }) => dark));
+        return colours.size > 1 || other.some((letter) => letter === "n" || letter === "p");
+    }
+    return true;
+}
+/** The pieces of a FEN but the kings, each with whether its square is dark. */
+function boardSquares(fen) {
+    const rows = (fen.split(" ")[0] ?? "").split("/");
+    return rows.flatMap((row, index) => {
+        let file = 0;
+        const found = [];
+        for (const letter of row) {
+            if (/\d/.test(letter)) {
+                file += Number(letter);
+            }
+            else {
+                if (!/k/i.test(letter)) {
+                    found.push({ letter, dark: (file + (8 - index)) % 2 === 1 });
+                }
+                file += 1;
+            }
+        }
+        return found;
+    });
+}
+const second = 1000;
+const minute = 60 * second;

package/dist/core/facts.d.ts

@@ -0,0 +1,55 @@
+import { Chess, type Color, type Square } from "chess.js";
+import type { Move, Side } from "./game.ts";
+/** A piece's letter, as SAN writes it, with P for a pawn. */
+export type PieceLetter = "K" | "Q" | "R" | "B" | "N" | "P";
+/**
+ * A piece on the board with the pieces that could take it and those of its side that could take back: direct attacks, en passant included; a piece pinned
+ * to its king only along the pin's line, though it still gives check. A king has no defenders.
+ */
+export interface PieceFacts {
+    readonly square: Square;
+    readonly piece: PieceLetter;
+    readonly side: Side;
+    readonly attackers: readonly Square[];
+    readonly defenders: readonly Square[];
+    /** The rooks, bishops and queens lined up behind an attacker or a defender, by its square: a battery. */
+    readonly behind?: Readonly<Partial<Record<Square, readonly Square[]>>>;
+    /** Its legal moves in SAN, for the pieces of the side to move only. */
+    readonly moves?: readonly string[];
+}
+/** A piece pinned to its king, or to a queen or rook of its side worth more than itself when the pinner is worth less or that piece is undefended. */
+export interface Pin {
+    readonly square: Square;
+    readonly by: Square;
+    readonly to: Square;
+}
+/** The facts of a position: data for the AI and the page, never a judgment (D-19). */
+export interface Facts {
+    /** Every piece, White's first, each side's from the king down: K Q R B N P. */
+    readonly pieces: readonly PieceFacts[];
+    /** The pieces giving check to the side to move, when it is in check. */
+    readonly checkedBy?: readonly Square[];
+    /** Pieces attacked and not defended, kings left out. */
+    readonly undefended: readonly Square[];
+    /** Pieces defended, but attacked by a piece worth less. */
+    readonly attackedByCheaper: readonly Square[];
+    /** Pieces defended, but by fewer pieces than attack them, counting only the direct ones on both sides; not those attacked by a cheaper piece. */
+    readonly outnumbered: readonly Square[];
+    /** Pieces neither attacked nor defended, kings left out: the first targets of a tactic. */
+    readonly loose: readonly Square[];
+    readonly pins: readonly Pin[];
+    /** The checks of the side to move, in SAN. */
+    readonly checks: readonly string[];
+    /** The checks the other side would have if it were to move; left out when the side to move is in check, since it could not be. */
+    readonly otherChecks?: readonly string[];
+}
+/** The facts of a chess.js board, whose legal moves are given: computed once for each position, by its key, and frozen. */
+export declare function factsOf(chess: Chess, legal: readonly Move[]): Facts;
+/** Which pieces attack a square: chess.js's direct attacks, a piece pinned to its king only along the pin's line, and the pawns that take en passant. */
+export type Reach = (square: Square, color: Color) => Square[];
+/** Which pieces attack a square as the facts count them: a piece pinned to its king only along the pin's line, though it still gives check; no en passant. */
+export declare function attacksOf(chess: Chess): Reach;
+/** The squares strictly between two squares on one line. */
+export declare function squaresBetween(from: Square, to: Square): Square[];
+export declare function fileOf(square: Square): number;
+export declare function rankOf(square: Square): number;

package/dist/core/facts.js

@@ -0,0 +1,175 @@
+// What a position shows, computed without judging it (D-19, D-26): who attacks and defends each piece, what is at risk, the pins, the checks, the moves of each piece.
+import { Chess } from "chess.js";
+/** The facts of a chess.js board, whose legal moves are given: computed once for each position, by its key, and frozen. */
+export function factsOf(chess, legal) {
+    const key = chess.hash();
+    let facts = factsByPosition.get(key);
+    if (facts === undefined) {
+        facts = deepFrozen(computed(chess, legal));
+        if (factsByPosition.size >= positionsKept) {
+            factsByPosition.delete(factsByPosition.keys().next().value);
+        }
+        factsByPosition.set(key, facts);
+    }
+    return facts;
+}
+// The facts of the positions seen last, by their key.
+const factsByPosition = new Map();
+const positionsKept = 256;
+// The usual values, only to compare two pieces: never summed (D-19). A king is never the cheaper one.
+const values = { p: 1, n: 3, b: 3, r: 5, q: 9, k: 100 };
+// The order SAN lists pieces in.
+const order = { k: 0, q: 1, r: 2, b: 3, n: 4, p: 5 };
+// The lines from a square: a step on the file and the rank, and the slider that moves along it besides the queen.
+const lines = [[0, 1, "r"], [0, -1, "r"], [1, 0, "r"], [-1, 0, "r"], [1, 1, "b"], [1, -1, "b"], [-1, 1, "b"], [-1, -1, "b"]];
+const files = "abcdefgh";
+/** Which pieces attack a square as the facts count them: a piece pinned to its king only along the pin's line, though it still gives check; no en passant. */
+export function attacksOf(chess) {
+    return alongPins(chess, piecesOf(chess).filter((piece) => piece.type === "k").flatMap((king) => pinsTo(chess, king)));
+}
+/** The squares strictly between two squares on one line. */
+export function squaresBetween(from, to) {
+    const ray = rayFrom(from, Math.sign(fileOf(to) - fileOf(from)), Math.sign(rankOf(to) - rankOf(from)));
+    return ray.slice(0, ray.indexOf(to));
+}
+export function fileOf(square) {
+    return files.indexOf(square[0]);
+}
+export function rankOf(square) {
+    return Number(square[1]);
+}
+function computed(chess, legal) {
+    const placed = piecesOf(chess);
+    const turn = chess.turn();
+    const kingPins = placed.filter((piece) => piece.type === "k").flatMap((king) => pinsTo(chess, king));
+    const reach = reachOf(chess, kingPins, legal);
+    const pieces = placed.map((piece) => pieceFacts(chess, piece, reach, turn === piece.color ? legal.filter((move) => move.from === piece.square) : undefined));
+    const factsAt = new Map(pieces.map((piece) => [piece.square, piece]));
+    const officers = pieces.filter((piece) => piece.piece !== "K");
+    const atRisk = officers.filter((piece) => piece.attackers.length > 0);
+    const valueAt = (square) => values[chess.get(square).type];
+    const defended = atRisk.filter((piece) => piece.defenders.length > 0);
+    const byCheaper = defended.filter((piece) => Math.min(...piece.attackers.map(valueAt)) < valueAt(piece.square));
+    const relativePins = placed.filter((piece) => piece.type === "q" || piece.type === "r").flatMap((target) => pinsTo(chess, target).filter((pin) => valueAt(pin.by) < values[target.type] || factsAt.get(target.square)?.defenders.length === 0));
+    const king = pieces.find((piece) => piece.piece === "K" && piece.side === sideOf(turn));
+    const facts = {
+        pieces,
+        ...(chess.inCheck() && king !== undefined ? { checkedBy: king.attackers } : {}),
+        undefended: atRisk.filter((piece) => piece.defenders.length === 0).map((piece) => piece.square),
+        attackedByCheaper: byCheaper.map((piece) => piece.square),
+        outnumbered: defended.filter((piece) => !byCheaper.includes(piece) && piece.attackers.length > piece.defenders.length).map((piece) => piece.square),
+        loose: officers.filter((piece) => piece.attackers.length === 0 && piece.defenders.length === 0).map((piece) => piece.square),
+        pins: [...kingPins, ...relativePins].sort((left, right) => compare(left.square, right.square)),
+        checks: legal.filter((move) => /[+#]$/.test(move.san)).map((move) => move.san),
+    };
+    return chess.inCheck() ? facts : { ...facts, otherChecks: otherChecks(chess) };
+}
+function reachOf(chess, kingPins, legal) {
+    const direct = alongPins(chess, kingPins);
+    const enPassant = enPassantVictim(chess);
+    const takers = enPassant === undefined ? [] : legal.filter((move) => move.to === enPassant.to && chess.get(move.from)?.type === "p").map((move) => move.from);
+    return (square, color) => (square === enPassant?.square && color === chess.turn() ? [...direct(square, color), ...takers].sort(compare) : direct(square, color));
+}
+function alongPins(chess, kingPins) {
+    const pinLines = new Map(kingPins.map((pin) => [pin.square, new Set(squaresBetween(pin.to, pin.by).concat(pin.by))]));
+    return (square, color) => {
+        // A pinned piece still gives check: the king is never taken.
+        const isKing = chess.get(square)?.type === "k";
+        return chess.attackers(square, color).filter((from) => isKing || (pinLines.get(from)?.has(square) ?? true)).sort(compare);
+    };
+}
+function pieceFacts(chess, { square, type, color }, reach, moves) {
+    const attackers = reach(square, color === "w" ? "b" : "w");
+    const defenders = type === "k" ? [] : reach(square, color);
+    const behind = batteries(chess, square, [...attackers, ...defenders]);
+    const facts = { square, piece: type.toUpperCase(), side: sideOf(color), attackers, defenders };
+    const withBehind = Object.keys(behind).length === 0 ? facts : { ...facts, behind };
+    return moves === undefined ? withBehind : { ...withBehind, moves: moves.map((move) => move.san) };
+}
+/** The rooks, bishops and queens of each piece's side lined up behind it, away from the square it attacks or defends. */
+function batteries(chess, target, fronts) {
+    const found = {};
+    for (const front of fronts) {
+        const fileStep = Math.sign(fileOf(front) - fileOf(target));
+        const rankStep = Math.sign(rankOf(front) - rankOf(target));
+        const straight = fileStep === 0 || rankStep === 0;
+        const slider = straight ? "r" : "b";
+        const { color, type } = chess.get(front);
+        // A pawn beside its target takes en passant and leaves the rank: nothing lines up behind it.
+        const onLine = straight ? type !== "p" : Math.abs(fileOf(front) - fileOf(target)) === Math.abs(rankOf(front) - rankOf(target));
+        const lined = [];
+        for (const square of onLine ? rayFrom(front, fileStep, rankStep) : []) {
+            const piece = chess.get(square);
+            if (piece === undefined) {
+                continue;
+            }
+            if (piece.color !== color || (piece.type !== slider && piece.type !== "q")) {
+                break;
+            }
+            lined.push(square);
+        }
+        if (lined.length > 0) {
+            found[front] = lined;
+        }
+    }
+    return found;
+}
+/** The pins to a piece: by a rook, bishop or queen on its line, with a piece of its side between them. */
+function pinsTo(chess, target) {
+    const pins = [];
+    for (const [fileStep, rankStep, slider] of lines) {
+        const [first, second] = rayFrom(target.square, fileStep, rankStep).filter((square) => chess.get(square) !== undefined);
+        const pinned = first === undefined ? undefined : chess.get(first);
+        const pinner = second === undefined ? undefined : chess.get(second);
+        if (pinned?.color === target.color && pinner !== undefined && pinner.color !== target.color && (pinner.type === slider || pinner.type === "q")
+            && (target.type === "k" || values[pinned.type] < values[target.type])) {
+            pins.push({ square: first, by: second, to: target.square });
+        }
+    }
+    return pins;
+}
+/** The pawn that can be taken en passant, and the square a pawn takes it on; none without an en passant square. */
+function enPassantVictim(chess) {
+    const to = chess.fen().split(" ")[3];
+    if (to === undefined || to === "-") {
+        return undefined;
+    }
+    return { square: `${to[0]}${chess.turn() === "w" ? 5 : 4}`, to: to };
+}
+/** The checks of the side not to move, on the same board with the turn passed: no en passant, which belonged to the side to move. */
+function otherChecks(chess) {
+    const fields = chess.fen().split(" ");
+    fields[1] = chess.turn() === "w" ? "b" : "w";
+    fields[3] = "-";
+    return new Chess(fields.join(" ")).moves().filter((san) => /[+#]$/.test(san));
+}
+/** The pieces on the board, White's first, each side's from the king down (K Q R B N P), then by square. */
+function piecesOf(chess) {
+    return chess.board().flat().filter((cell) => cell !== null).map(({ square, type, color }) => ({ square, type, color })).sort((left, right) => compare(right.color, left.color) || order[left.type] - order[right.type] || compare(left.square, right.square));
+}
+/** The squares from a square to the edge of the board, one step at a time. */
+function rayFrom(from, fileStep, rankStep) {
+    const ray = [];
+    let file = fileOf(from) + fileStep;
+    let rank = rankOf(from) + rankStep;
+    while (file >= 0 && file < 8 && rank >= 1 && rank <= 8) {
+        ray.push(`${files[file]}${rank}`);
+        file += fileStep;
+        rank += rankStep;
+    }
+    return ray;
+}
+/** Compares two names of squares or colours: a fixed alphabet, no locale. */
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function sideOf(color) {
+    return color === "w" ? "white" : "black";
+}
+function deepFrozen(value) {
+    if (typeof value === "object" && value !== null) {
+        Object.values(value).forEach(deepFrozen);
+        Object.freeze(value);
+    }
+    return value;
+}

package/dist/core/game.d.ts

@@ -0,0 +1,95 @@
+import { type Square } from "chess.js";
+import { type Facts } from "./facts.ts";
+import { type Illegal } from "./illegal.ts";
+import { type Profile } from "./profile.ts";
+import { type Annotation, type GameRecord } from "./record.ts";
+export type { Square } from "chess.js";
+/** A side of the board. */
+export type Side = "white" | "black";
+/** The piece a pawn becomes. */
+export type Promotion = "q" | "r" | "b" | "n";
+/** A legal move: its SAN, and its squares for the page. */
+export interface Move {
+    readonly san: string;
+    readonly from: Square;
+    readonly to: Square;
+    readonly promotion?: Promotion;
+}
+/** Where the game stands. The key is the same for the same position, whatever the moves that led to it: chess.js's hash, never to store, it changes with the library. */
+export interface Position {
+    readonly fen: string;
+    readonly key: string;
+    readonly turn: Side;
+    readonly moveNumber: number;
+    readonly check: boolean;
+}
+/** How the board ends a game, the draws too (D-37). Resignation, agreement and time are not the board's: the commands record them. */
+export type Ending = "checkmate" | "stalemate" | "insufficient material" | "threefold repetition" | "fifty moves";
+/** Whether the board ends the game, and how. */
+export type Outcome = {
+    readonly over: false;
+} | {
+    readonly over: true;
+    readonly result: "1-0" | "0-1" | "1/2-1/2";
+    readonly ending: Ending;
+};
+/** Why a move was refused. */
+export type Refusal = "unreadable" | "illegal" | "ambiguous" | "over";
+/** A move played, with a note when it was written with a check or a mate it does not give; or why it was refused, with the legal moves in SAN. */
+export type Played = {
+    readonly played: true;
+    readonly move: Move;
+    readonly note?: string;
+} | {
+    readonly played: false;
+    readonly refusal: Refusal;
+    readonly message: string;
+    readonly legal: readonly string[];
+};
+/**
+ * A live game: it plays moves written in SAN or as squares, and keeps the record. Checkmate, stalemate and the draws by insufficient material,
+ * threefold repetition and fifty moves end it (D-37); a game recorded elsewhere replays past the draws it played on from.
+ */
+export declare class Game {
+    private readonly chess;
+    private readonly tags;
+    private readonly comment;
+    private readonly moves;
+    private last;
+    private readonly keys;
+    private readonly castled;
+    private keptPosition;
+    private keptOutcome;
+    private keptRecord;
+    /** The game of a record, replayed move by move; without one, a new game from the standard position. */
+    constructor(record?: GameRecord);
+    /** Where the game stands now. */
+    get position(): Position;
+    /** Whether the board ends the game, and how. */
+    get outcome(): Outcome;
+    /** The game as plain data, frozen; when the board ends the game, its Result tag is the board's, unless the record gave one. */
+    get record(): GameRecord;
+    /** The last move played, with its squares; none before the first. */
+    get lastMove(): Move | undefined;
+    /** What the position shows (D-26): attackers and defenders, pieces at risk, pins, checks, the moves of each piece; computed once for each position. */
+    get facts(): Facts;
+    /** The positional profile (D-19): pawns, files, outposts, space, mobility, development, king safety, control, phase, draws; computed once for each position. */
+    get profile(): Profile;
+    /** The legal moves, or those of the piece on a square. */
+    legalMoves(square?: Square): readonly Move[];
+    /** Why the piece of the side to move on a square cannot go to another (D-18); undefined when it can, or when no rule says why. */
+    whyNot(from: Square, to: Square): Illegal | undefined;
+    /** Plays a move written in SAN (Nf3, exd5, O-O, e8=Q), with the pieces' figurines too (♘f3), or as squares (g1f3, e7e8q); a refused move changes nothing. */
+    play(text: string): Played;
+    /** Plays a move of a game recorded elsewhere, as play does, but also past a draw that game played on from: insufficient material, repetition or fifty moves. */
+    playRecorded(text: string): Played;
+    /** Sets the judgment of a move by its ply, 1 for the first move recorded: the NAGs and the comment given replace its own, an empty one removes them. */
+    annotate(ply: number, annotation: Annotation): void;
+    private apply;
+    /** A move written loosely (as squares, with a letter too many or too few) matched against the legal moves. */
+    private resolve;
+    private illegal;
+    private snapshot;
+}
+/** A text with SAN's letters and signs for the figurines and signs others write: ♘f3 as Nf3, × as x; a pawn's figurine says nothing. */
+export declare function withSanLetters(text: string): string;