@connectorvol/chessops 1.0.0 → 2.0.1

package/dist/{esm/attacks.js → attacks.js}

@@ -51,12 +51,12 @@ export const pawnAttacks = (color, square) => PAWN_ATTACKS[color][square];
 const FILE_RANGE = tabulate((sq) => SquareSet.fromFile(squareFile(sq)).without(sq));
 const RANK_RANGE = tabulate((sq) => SquareSet.fromRank(squareRank(sq)).without(sq));
 const DIAG_RANGE = tabulate((sq) => {
-    const diag = new SquareSet(134480385, 2151686160);
+    const diag = new SquareSet(0x0804_0201, 0x8040_2010);
     const shift = 8 * (squareRank(sq) - squareFile(sq));
     return (shift >= 0 ? diag.shl64(shift) : diag.shr64(-shift)).without(sq);
 });
 const ANTI_DIAG_RANGE = tabulate((sq) => {
-    const diag = new SquareSet(270549120, 16909320);
+    const diag = new SquareSet(0x1020_4080, 0x0102_0408);
     const shift = 8 * (squareRank(sq) + squareFile(sq) - 7);
     return (shift >= 0 ? diag.shl64(shift) : diag.shr64(-shift)).without(sq);
 });
@@ -137,4 +137,3 @@ export const ray = (a, b) => {
 export const between = (a, b) => ray(a, b)
     .intersect(SquareSet.full().shl64(a).xor(SquareSet.full().shl64(b)))
     .withoutFirst();
-//# sourceMappingURL=attacks.js.map

package/dist/{esm/board.js → board.js}

@@ -9,6 +9,23 @@ import { COLORS, ROLES } from "./types.js";
  * care to keep them consistent.
  */
 export class Board {
+    /**
+     * All occupied squares.
+     */
+    occupied;
+    /**
+     * All squares occupied by pieces known to be promoted. This information is
+     * relevant in chess variants like Crazyhouse.
+     */
+    promoted;
+    white;
+    black;
+    pawn;
+    knight;
+    bishop;
+    rook;
+    queen;
+    king;
     constructor() { }
     static default() {
         const board = new Board();
@@ -19,16 +36,16 @@ export class Board {
      * Resets all pieces to the default starting position for standard chess.
      */
     reset() {
-        this.occupied = new SquareSet(0xffff, 4294901760);
+        this.occupied = new SquareSet(0xffff, 0xffff_0000);
         this.promoted = SquareSet.empty();
         this.white = new SquareSet(0xffff, 0);
-        this.black = new SquareSet(0, 4294901760);
-        this.pawn = new SquareSet(0xff00, 16711680);
-        this.knight = new SquareSet(0x42, 1107296256);
-        this.bishop = new SquareSet(0x24, 603979776);
-        this.rook = new SquareSet(0x81, 2164260864);
-        this.queen = new SquareSet(0x8, 134217728);
-        this.king = new SquareSet(0x10, 268435456);
+        this.black = new SquareSet(0, 0xffff_0000);
+        this.pawn = new SquareSet(0xff00, 0x00ff_0000);
+        this.knight = new SquareSet(0x42, 0x4200_0000);
+        this.bishop = new SquareSet(0x24, 0x2400_0000);
+        this.rook = new SquareSet(0x81, 0x8100_0000);
+        this.queen = new SquareSet(0x8, 0x0800_0000);
+        this.king = new SquareSet(0x10, 0x1000_0000);
     }
     static empty() {
         const board = new Board();
@@ -135,4 +152,3 @@ export class Board {
 export const boardEquals = (left, right) => left.white.equals(right.white) &&
     left.promoted.equals(right.promoted) &&
     ROLES.every((role) => left[role].equals(right[role]));
-//# sourceMappingURL=board.js.map

package/dist/{esm/chess.js → chess.js}

@@ -21,6 +21,9 @@ const attacksTo = (square, attacker, board, occupied) => board[attacker].interse
     .union(kingAttacks(square).intersect(board.king))
     .union(pawnAttacks(opposite(attacker), square).intersect(board.pawn)));
 export class Castles {
+    castlingRights;
+    rook;
+    path;
     constructor() { }
     static default() {
         const castles = new Castles();
@@ -108,6 +111,15 @@ export class Castles {
     }
 }
 export class Position {
+    rules;
+    board;
+    pockets;
+    turn;
+    castles;
+    epSquare;
+    remainingChecks;
+    halfmoves;
+    fullmoves;
     constructor(rules) {
         this.rules = rules;
     }
@@ -185,14 +197,13 @@ export class Position {
         };
     }
     clone() {
-        var _a, _b;
         const pos = new this.constructor();
         pos.board = this.board.clone();
-        pos.pockets = (_a = this.pockets) === null || _a === void 0 ? void 0 : _a.clone();
+        pos.pockets = this.pockets?.clone();
         pos.turn = this.turn;
         pos.castles = this.castles.clone();
         pos.epSquare = this.epSquare;
-        pos.remainingChecks = (_b = this.remainingChecks) === null || _b === void 0 ? void 0 : _b.clone();
+        pos.remainingChecks = this.remainingChecks?.clone();
         pos.halfmoves = this.halfmoves;
         pos.fullmoves = this.fullmoves;
         return pos;
@@ -297,14 +308,13 @@ export class Position {
     }
     // The following should be identical in all subclasses
     toSetup() {
-        var _a, _b;
         return {
             board: this.board.clone(),
-            pockets: (_a = this.pockets) === null || _a === void 0 ? void 0 : _a.clone(),
+            pockets: this.pockets?.clone(),
             turn: this.turn,
             castlingRights: this.castles.castlingRights,
             epSquare: legalEpSquare(this),
-            remainingChecks: (_b = this.remainingChecks) === null || _b === void 0 ? void 0 : _b.clone(),
+            remainingChecks: this.remainingChecks?.clone(),
             halfmoves: Math.min(this.halfmoves, 150),
             fullmoves: Math.min(Math.max(this.fullmoves, 1), 9999),
         };
@@ -551,17 +561,14 @@ export const pseudoDests = (pos, square, ctx) => {
     else
         return pseudo;
 };
-export const equalsIgnoreMoves = (left, right) => {
-    var _a, _b;
-    return left.rules === right.rules &&
-        boardEquals(left.board, right.board) &&
-        ((right.pockets && ((_a = left.pockets) === null || _a === void 0 ? void 0 : _a.equals(right.pockets))) || (!left.pockets && !right.pockets)) &&
-        left.turn === right.turn &&
-        left.castles.castlingRights.equals(right.castles.castlingRights) &&
-        legalEpSquare(left) === legalEpSquare(right) &&
-        ((right.remainingChecks && ((_b = left.remainingChecks) === null || _b === void 0 ? void 0 : _b.equals(right.remainingChecks))) ||
-            (!left.remainingChecks && !right.remainingChecks));
-};
+export const equalsIgnoreMoves = (left, right) => left.rules === right.rules &&
+    boardEquals(left.board, right.board) &&
+    ((right.pockets && left.pockets?.equals(right.pockets)) || (!left.pockets && !right.pockets)) &&
+    left.turn === right.turn &&
+    left.castles.castlingRights.equals(right.castles.castlingRights) &&
+    legalEpSquare(left) === legalEpSquare(right) &&
+    ((right.remainingChecks && left.remainingChecks?.equals(right.remainingChecks)) ||
+        (!left.remainingChecks && !right.remainingChecks));
 export const castlingSide = (pos, move) => {
     if (isDrop(move))
         return;
@@ -621,4 +628,3 @@ export const isImpossibleCheck = (pos) => {
             checkers.intersect(pos.board.steppers()).moreThanOne());
     }
 };
-//# sourceMappingURL=chess.js.map

package/dist/{esm/compat.js → compat.js}

@@ -22,7 +22,7 @@ export const chessgroundDests = (pos, opts) => {
     for (const [from, squares] of pos.allDests(ctx)) {
         if (squares.nonEmpty()) {
             const d = Array.from(squares, makeSquare);
-            if (!(opts === null || opts === void 0 ? void 0 : opts.chess960) && from === ctx.king && squareFile(from) === 4) {
+            if (!opts?.chess960 && from === ctx.king && squareFile(from) === 4) {
                 // Chessground needs both types of castling dests and filters based on
                 // a rookCastles setting.
                 if (squares.has(0))
@@ -78,4 +78,3 @@ export const lichessVariant = (rules) => {
             return rules;
     }
 };
-//# sourceMappingURL=compat.js.map

package/dist/{esm/debug.js → debug.js}

@@ -91,4 +91,3 @@ export const perft = (pos, depth, log = false) => {
         return nodes;
     }
 };
-//# sourceMappingURL=debug.js.map

package/dist/{esm/fen.js → fen.js}

@@ -298,11 +298,10 @@ export const makeFen = (setup, opts) => [
     makeCastlingFen(setup.board, setup.castlingRights),
     defined(setup.epSquare) ? makeSquare(setup.epSquare) : "-",
     ...(setup.remainingChecks ? [makeRemainingChecks(setup.remainingChecks)] : []),
-    ...((opts === null || opts === void 0 ? void 0 : opts.epd)
+    ...(opts?.epd
         ? []
         : [
             Math.max(0, Math.min(setup.halfmoves, 9999)),
             Math.max(1, Math.min(setup.fullmoves, 9999)),
         ]),
 ].join(" ");
-//# sourceMappingURL=fen.js.map

package/dist/{types/index.d.ts → index.d.ts}

@@ -1,10 +1,13 @@
-export { ByCastlingSide, ByColor, ByRole, BySquare, CASTLING_SIDES, CastlingSide, Color, COLORS, DropMove, FILE_NAMES, FileName, isDrop, isNormal, Move, NormalMove, Outcome, Piece, RANK_NAMES, RankName, Role, ROLE_CHARS, RoleChar, ROLES, Rules, Square, SquareName, } from "./types.js";
+export type { ByCastlingSide, ByColor, ByRole, BySquare, CastlingSide, Color, DropMove, FileName, Move, NormalMove, Outcome, Piece, RankName, Role, RoleChar, Rules, Square, SquareName, } from "./types.js";
+export { CASTLING_SIDES, COLORS, FILE_NAMES, isDrop, isNormal, RANK_NAMES, ROLE_CHARS, ROLES, RULES, } from "./types.js";
 export { charToRole, defined, kingCastlesTo, makeSquare, makeUci, opposite, parseSquare, parseUci, roleToChar, squareFile, squareRank, } from "./util.js";
 export { SquareSet } from "./squareSet.js";
 export { attacks, between, bishopAttacks, kingAttacks, knightAttacks, pawnAttacks, queenAttacks, ray, rookAttacks, } from "./attacks.js";
 export { Board, boardEquals } from "./board.js";
-export { defaultSetup, emptySetup, Material, MaterialSide, RemainingChecks, Setup, setupClone, setupEquals, } from "./setup.js";
-export { Castles, Chess, Context, IllegalSetup, Position, PositionError } from "./chess.js";
+export type { Setup } from "./setup.js";
+export { defaultSetup, emptySetup, Material, MaterialSide, RemainingChecks, setupClone, setupEquals, } from "./setup.js";
+export type { Context } from "./chess.js";
+export { Castles, Chess, IllegalSetup, Position, PositionError } from "./chess.js";
 export * as compat from "./compat.js";
 export * as debug from "./debug.js";
 export * as fen from "./fen.js";

package/dist/{esm/index.js → index.js}

@@ -1,4 +1,4 @@
-export { CASTLING_SIDES, COLORS, FILE_NAMES, isDrop, isNormal, RANK_NAMES, ROLE_CHARS, ROLES, } from "./types.js";
+export { CASTLING_SIDES, COLORS, FILE_NAMES, isDrop, isNormal, RANK_NAMES, ROLE_CHARS, ROLES, RULES, } from "./types.js";
 export { charToRole, defined, kingCastlesTo, makeSquare, makeUci, opposite, parseSquare, parseUci, roleToChar, squareFile, squareRank, } from "./util.js";
 export { SquareSet } from "./squareSet.js";
 export { attacks, between, bishopAttacks, kingAttacks, knightAttacks, pawnAttacks, queenAttacks, ray, rookAttacks, } from "./attacks.js";
@@ -12,4 +12,3 @@ export * as san from "./san.js";
 export * as transform from "./transform.js";
 export * as variant from "./variant.js";
 export * as pgn from "./pgn.js";
-//# sourceMappingURL=index.js.map

package/dist/{esm/pgn.js → pgn.js}

@@ -110,9 +110,7 @@ export const defaultGame = (initHeaders = defaultHeaders) => ({
     moves: new Node(),
 });
 export class Node {
-    constructor() {
-        this.children = [];
-    }
+    children = [];
     *mainlineNodes() {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         let node = this;
@@ -135,6 +133,7 @@ export class Node {
     }
 }
 export class ChildNode extends Node {
+    data;
     constructor(data) {
         super();
         this.data = data;
@@ -150,6 +149,7 @@ export const extend = (node, data) => {
     return node;
 };
 export class Box {
+    value;
     constructor(value) {
         this.value = value;
     }
@@ -219,6 +219,12 @@ export const parseOutcome = (s) => {
 };
 const escapeHeader = (value) => value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 const safeComment = (comment) => comment.replace(/\}/g, "");
+var MakePgnState;
+(function (MakePgnState) {
+    MakePgnState[MakePgnState["Pre"] = 0] = "Pre";
+    MakePgnState[MakePgnState["Sidelines"] = 1] = "Sidelines";
+    MakePgnState[MakePgnState["End"] = 2] = "End";
+})(MakePgnState || (MakePgnState = {}));
 export const makePgn = (game) => {
     const builder = [], tokens = [];
     if (game.headers.size) {
@@ -238,7 +244,7 @@ export const makePgn = (game) => {
     const firstVariation = variations.next();
     if (!firstVariation.done) {
         stack.push({
-            state: 0 /* MakePgnState.Pre */,
+            state: MakePgnState.Pre,
             ply: initialPly,
             node: firstVariation.value,
             sidelines: variations,
@@ -255,7 +261,7 @@ export const makePgn = (game) => {
             forceMoveNumber = true;
         }
         switch (frame.state) {
-            case 0 /* MakePgnState.Pre */:
+            case MakePgnState.Pre:
                 for (const comment of frame.node.data.startingComments || []) {
                     tokens.push("{", safeComment(comment), "}");
                     forceMoveNumber = true;
@@ -272,15 +278,15 @@ export const makePgn = (game) => {
                 for (const comment of frame.node.data.comments || []) {
                     tokens.push("{", safeComment(comment), "}");
                 }
-                frame.state = 1 /* MakePgnState.Sidelines */; // fall through
-            case 1 /* MakePgnState.Sidelines */: {
+                frame.state = MakePgnState.Sidelines; // fall through
+            case MakePgnState.Sidelines: {
                 const child = frame.sidelines.next();
                 if (child.done) {
                     const variations = frame.node.children[Symbol.iterator]();
                     const firstVariation = variations.next();
                     if (!firstVariation.done) {
                         stack.push({
-                            state: 0 /* MakePgnState.Pre */,
+                            state: MakePgnState.Pre,
                             ply: frame.ply + 1,
                             node: firstVariation.value,
                             sidelines: variations,
@@ -288,13 +294,13 @@ export const makePgn = (game) => {
                             inVariation: false,
                         });
                     }
-                    frame.state = 2 /* MakePgnState.End */;
+                    frame.state = MakePgnState.End;
                 }
                 else {
                     tokens.push("(");
                     forceMoveNumber = true;
                     stack.push({
-                        state: 0 /* MakePgnState.Pre */,
+                        state: MakePgnState.Pre,
                         ply: frame.ply,
                         node: child.value,
                         sidelines: [][Symbol.iterator](),
@@ -305,7 +311,7 @@ export const makePgn = (game) => {
                 }
                 break;
             }
-            case 2 /* MakePgnState.End */:
+            case MakePgnState.End:
                 stack.pop();
         }
     }
@@ -326,21 +332,38 @@ export const emptyHeaders = () => new Map();
 const BOM = "\ufeff";
 const isWhitespace = (line) => /^\s*$/.test(line);
 const isCommentLine = (line) => line.startsWith("%");
+var ParserState;
+(function (ParserState) {
+    ParserState[ParserState["Bom"] = 0] = "Bom";
+    ParserState[ParserState["Pre"] = 1] = "Pre";
+    ParserState[ParserState["Headers"] = 2] = "Headers";
+    ParserState[ParserState["Moves"] = 3] = "Moves";
+    ParserState[ParserState["Comment"] = 4] = "Comment";
+})(ParserState || (ParserState = {}));
 export class PgnError extends Error {
 }
 export class PgnParser {
-    constructor(emitGame, initHeaders = defaultHeaders, maxBudget = 1000000) {
+    emitGame;
+    initHeaders;
+    maxBudget;
+    lineBuf = [];
+    budget;
+    found;
+    state;
+    game;
+    stack;
+    commentBuf;
+    constructor(emitGame, initHeaders = defaultHeaders, maxBudget = 1_000_000) {
         this.emitGame = emitGame;
         this.initHeaders = initHeaders;
         this.maxBudget = maxBudget;
-        this.lineBuf = [];
         this.resetGame();
-        this.state = 0 /* ParserState.Bom */;
+        this.state = ParserState.Bom;
     }
     resetGame() {
         this.budget = this.maxBudget;
         this.found = false;
-        this.state = 1 /* ParserState.Pre */;
+        this.state = ParserState.Pre;
         this.game = defaultGame(this.initHeaders);
         this.stack = [{ parent: this.game.moves, root: true }];
         this.commentBuf = [];
@@ -368,7 +391,7 @@ export class PgnParser {
             }
             this.consumeBudget(data.length - idx);
             this.lineBuf.push(data.slice(idx));
-            if (!(options === null || options === void 0 ? void 0 : options.stream)) {
+            if (!options?.stream) {
                 this.handleLine();
                 this.emit(undefined);
             }
@@ -383,16 +406,16 @@ export class PgnParser {
         this.lineBuf = [];
         continuedLine: for (;;) {
             switch (this.state) {
-                case 0 /* ParserState.Bom */:
+                case ParserState.Bom:
                     if (line.startsWith(BOM))
                         line = line.slice(BOM.length);
-                    this.state = 1 /* ParserState.Pre */; // fall through
-                case 1 /* ParserState.Pre */:
+                    this.state = ParserState.Pre; // fall through
+                case ParserState.Pre:
                     if (isWhitespace(line) || isCommentLine(line))
                         return;
                     this.found = true;
-                    this.state = 2 /* ParserState.Headers */; // fall through
-                case 2 /* ParserState.Headers */: {
+                    this.state = ParserState.Headers; // fall through
+                case ParserState.Headers: {
                     if (isCommentLine(line))
                         return;
                     let moreHeaders = true;
@@ -408,9 +431,9 @@ export class PgnParser {
                     }
                     if (isWhitespace(line))
                         return;
-                    this.state = 3 /* ParserState.Moves */; // fall through
+                    this.state = ParserState.Moves; // fall through
                 }
-                case 3 /* ParserState.Moves */: {
+                case ParserState.Moves: {
                     if (freshLine) {
                         if (isCommentLine(line))
                             return;
@@ -463,7 +486,7 @@ export class PgnParser {
                             const openIndex = tokenRegex.lastIndex;
                             const beginIndex = line[openIndex] === " " ? openIndex + 1 : openIndex;
                             line = line.slice(beginIndex);
-                            this.state = 4 /* ParserState.Comment */;
+                            this.state = ParserState.Comment;
                             continue continuedLine;
                         }
                         else {
@@ -486,7 +509,7 @@ export class PgnParser {
                     }
                     return;
                 }
-                case 4 /* ParserState.Comment */: {
+                case ParserState.Comment: {
                     const closeIndex = line.indexOf("}");
                     if (closeIndex === -1) {
                         this.commentBuf.push(line);
@@ -497,7 +520,7 @@ export class PgnParser {
                         this.commentBuf.push(line.slice(0, endIndex));
                         this.handleComment();
                         line = line.slice(closeIndex);
-                        this.state = 3 /* ParserState.Moves */;
+                        this.state = ParserState.Moves;
                         freshLine = false;
                     }
                 }
@@ -508,35 +531,33 @@ export class PgnParser {
         this.game.headers.set(name, name === "Result" ? makeOutcome(parseOutcome(value)) : value);
     }
     handleNag(nag) {
-        var _a;
         this.consumeBudget(50);
         const frame = this.stack[this.stack.length - 1];
         if (frame.node) {
-            (_a = frame.node.data).nags || (_a.nags = []);
+            frame.node.data.nags ||= [];
             frame.node.data.nags.push(nag);
         }
     }
     handleComment() {
-        var _a, _b;
         this.consumeBudget(100);
         const frame = this.stack[this.stack.length - 1];
         const comment = this.commentBuf.join("\n");
         this.commentBuf = [];
         if (frame.node) {
-            (_a = frame.node.data).comments || (_a.comments = []);
+            frame.node.data.comments ||= [];
             frame.node.data.comments.push(comment);
         }
         else if (frame.root) {
-            (_b = this.game).comments || (_b.comments = []);
+            this.game.comments ||= [];
             this.game.comments.push(comment);
         }
         else {
-            frame.startingComments || (frame.startingComments = []);
+            frame.startingComments ||= [];
             frame.startingComments.push(comment);
         }
     }
     emit(err) {
-        if (this.state === 4 /* ParserState.Comment */)
+        if (this.state === ParserState.Comment)
             this.handleComment();
         if (err)
             return this.emitGame(this.game, err);
@@ -766,4 +787,3 @@ export const parseComment = (comment) => {
         evaluation,
     };
 };
-//# sourceMappingURL=pgn.js.map

package/dist/pgnOps.svelte.d.ts

@@ -0,0 +1,31 @@
+import type { Color, Square, PieceType, Move } from "@connectorvol/shared";
+import type { Rules } from "./types.js";
+import { type Position } from "./variant.js";
+/** Представляет обёртку над позицией chessops с реактивным состоянием, SAN и удобными операциями для UI. */
+export declare class PgnOps {
+    pos: Position;
+    rule: Rules;
+    constructor(fen: string, rule: Rules);
+    turn(): Color;
+    getAllPossibleMoves(): string[];
+    moves(square: Square): ("a1" | "a2" | "a3" | "a4" | "a5" | "a6" | "a7" | "a8" | "b1" | "b2" | "b3" | "b4" | "b5" | "b6" | "b7" | "b8" | "c1" | "c2" | "c3" | "c4" | "c5" | "c6" | "c7" | "c8" | "d1" | "d2" | "d3" | "d4" | "d5" | "d6" | "d7" | "d8" | "e1" | "e2" | "e3" | "e4" | "e5" | "e6" | "e7" | "e8" | "f1" | "f2" | "f3" | "f4" | "f5" | "f6" | "f7" | "f8" | "g1" | "g2" | "g3" | "g4" | "g5" | "g6" | "g7" | "g8" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "h7" | "h8")[];
+    /** Представляет получение SAN-нотации для хода без его выполнения. */
+    getSanForMove(move: Pick<Move, "from" | "to" | "promotion">): string;
+    makeMove(move: Pick<Move, "from" | "to" | "promotion" | "flags">): {
+        ply: number;
+        fullMoves: number;
+        san: string;
+        move: {
+            from: string;
+            to: string;
+            promotion: PieceType | undefined;
+            flags: string;
+        };
+    };
+    makeSanMove(move: string): Move;
+    fen(): string;
+    /** Представляет установку FEN; при передаче rule обновляет и запомненный вариант. */
+    setFen(fen: string, rule?: Rules): void;
+    /** Представляет сброс позиции на стартовую для текущего варианта. */
+    reset(): void;
+}

package/dist/pgnOps.svelte.js

@@ -0,0 +1,122 @@
+import { calculatePly } from "@connectorvol/shared";
+import { chessgroundDests } from "./compat.js";
+import { INITIAL_FEN, makeFen, parseFen } from "./fen.js";
+import { makeSan, parseSan } from "./san.js";
+import { makeSquare, parseSquare } from "./util.js";
+import { Antichess, Atomic, castlingSide, Chess, Crazyhouse, Horde, KingOfTheHill, RacingKings, ThreeCheck, } from "./variant.js";
+/** Представляет обёртку над позицией chessops с реактивным состоянием, SAN и удобными операциями для UI. */
+export class PgnOps {
+    pos;
+    rule;
+    constructor(fen, rule) {
+        this.rule = $state(rule);
+        this.pos = $derived(setPosition(fen, rule));
+    }
+    turn() {
+        return this.pos.turn === "white" ? "w" : "b";
+    }
+    getAllPossibleMoves() {
+        const dests = chessgroundDests(this.pos);
+        const result = [];
+        for (const [from, tos] of dests) {
+            for (const to of tos) {
+                result.push(makeSan(this.pos, { from: parseSquare(from), to: parseSquare(to) }));
+            }
+        }
+        return result;
+    }
+    moves(square) {
+        const dests = chessgroundDests(this.pos).get(square) ?? [];
+        return dests;
+    }
+    /** Представляет получение SAN-нотации для хода без его выполнения. */
+    getSanForMove(move) {
+        const mov = {
+            from: parseSquare(move.from) ?? 0,
+            to: parseSquare(move.to) ?? 0,
+            promotion: move.promotion ? promotionMap[move.promotion] : undefined,
+        };
+        return makeSan(this.pos, mov);
+    }
+    makeMove(move) {
+        const mov = {
+            from: parseSquare(move.from) ?? 0,
+            to: parseSquare(move.to) ?? 0,
+            promotion: move.promotion ? promotionMap[move.promotion] : undefined,
+        };
+        let flags = move.flags ?? "";
+        const castling = castlingSide(this.pos, mov);
+        if (castling) {
+            flags = castling === "a" ? "q" : "k";
+        }
+        const san = makeSan(this.pos, mov);
+        this.pos.play(mov);
+        const fen = makeFen(this.pos.toSetup());
+        const { halfMoves, fullMoves } = calculatePly(fen);
+        const moveRecord = {
+            from: move.from,
+            to: move.to,
+            promotion: move.promotion,
+            flags,
+        };
+        return { ply: halfMoves, fullMoves, san, move: moveRecord };
+    }
+    makeSanMove(move) {
+        const mov = parseSan(this.pos, move);
+        if (mov) {
+            this.pos.play(mov);
+            if ("from" in mov) {
+                return {
+                    from: makeSquare(mov.from),
+                    to: makeSquare(mov.to),
+                };
+            }
+        }
+        throw new Error("Invalid move");
+    }
+    fen() {
+        return makeFen(this.pos.toSetup());
+    }
+    /** Представляет установку FEN; при передаче rule обновляет и запомненный вариант. */
+    setFen(fen, rule) {
+        if (rule !== undefined) {
+            this.rule = rule;
+        }
+        this.pos = setPosition(fen, this.rule);
+    }
+    /** Представляет сброс позиции на стартовую для текущего варианта. */
+    reset() {
+        this.pos = setPosition(INITIAL_FEN, this.rule);
+    }
+}
+function setPosition(fen, rule) {
+    const setup = parseFen(fen).unwrap();
+    switch (rule) {
+        case "kingofthehill":
+            return KingOfTheHill.fromSetup(setup).unwrap();
+        case "chess":
+            return Chess.fromSetup(setup).unwrap();
+        case "antichess":
+            return Antichess.fromSetup(setup).unwrap();
+        case "3check":
+            return ThreeCheck.fromSetup(setup).unwrap();
+        case "atomic":
+            return Atomic.fromSetup(setup).unwrap();
+        case "horde":
+            return Horde.fromSetup(setup).unwrap();
+        case "racingkings":
+            return RacingKings.fromSetup(setup).unwrap();
+        case "crazyhouse":
+            return Crazyhouse.fromSetup(setup).unwrap();
+        default:
+            return Chess.fromSetup(setup).unwrap();
+    }
+}
+const promotionMap = {
+    q: "queen",
+    r: "rook",
+    b: "bishop",
+    n: "knight",
+    p: "pawn",
+    k: "king",
+};