@connectorvol/chessops 0.15.1

package/dist/types/squareSet.d.ts

@@ -0,0 +1,50 @@
+import { Color, Square } from "./types.js";
+/**
+ * An immutable set of squares, implemented as a bitboard.
+ */
+export declare class SquareSet implements Iterable<Square> {
+    readonly lo: number;
+    readonly hi: number;
+    constructor(lo: number, hi: number);
+    static fromSquare(square: Square): SquareSet;
+    static fromRank(rank: number): SquareSet;
+    static fromFile(file: number): SquareSet;
+    static empty(): SquareSet;
+    static full(): SquareSet;
+    static corners(): SquareSet;
+    static center(): SquareSet;
+    static backranks(): SquareSet;
+    static backrank(color: Color): SquareSet;
+    static lightSquares(): SquareSet;
+    static darkSquares(): SquareSet;
+    complement(): SquareSet;
+    xor(other: SquareSet): SquareSet;
+    union(other: SquareSet): SquareSet;
+    intersect(other: SquareSet): SquareSet;
+    diff(other: SquareSet): SquareSet;
+    intersects(other: SquareSet): boolean;
+    isDisjoint(other: SquareSet): boolean;
+    supersetOf(other: SquareSet): boolean;
+    subsetOf(other: SquareSet): boolean;
+    shr64(shift: number): SquareSet;
+    shl64(shift: number): SquareSet;
+    bswap64(): SquareSet;
+    rbit64(): SquareSet;
+    minus64(other: SquareSet): SquareSet;
+    equals(other: SquareSet): boolean;
+    size(): number;
+    isEmpty(): boolean;
+    nonEmpty(): boolean;
+    has(square: Square): boolean;
+    set(square: Square, on: boolean): SquareSet;
+    with(square: Square): SquareSet;
+    without(square: Square): SquareSet;
+    toggle(square: Square): SquareSet;
+    last(): Square | undefined;
+    first(): Square | undefined;
+    withoutFirst(): SquareSet;
+    moreThanOne(): boolean;
+    singleSquare(): Square | undefined;
+    [Symbol.iterator](): Iterator<Square>;
+    reversed(): Iterable<Square>;
+}

package/dist/types/transform.d.ts

@@ -0,0 +1,9 @@
+import { Board } from "./board.js";
+import { Setup } from "./setup.js";
+import { SquareSet } from "./squareSet.js";
+export declare const flipVertical: (s: SquareSet) => SquareSet;
+export declare const flipHorizontal: (s: SquareSet) => SquareSet;
+export declare const flipDiagonal: (s: SquareSet) => SquareSet;
+export declare const rotate180: (s: SquareSet) => SquareSet;
+export declare const transformBoard: (board: Board, f: (s: SquareSet) => SquareSet) => Board;
+export declare const transformSetup: (setup: Setup, f: (s: SquareSet) => SquareSet) => Setup;

package/dist/types/types.d.ts

@@ -0,0 +1,58 @@
+export declare const FILE_NAMES: readonly ["a", "b", "c", "d", "e", "f", "g", "h"];
+export type FileName = (typeof FILE_NAMES)[number];
+export declare const RANK_NAMES: readonly ["1", "2", "3", "4", "5", "6", "7", "8"];
+export type RankName = (typeof RANK_NAMES)[number];
+export type Square = number;
+export type SquareName = `${FileName}${RankName}`;
+export declare const ROLE_CHARS: readonly ["q", "n", "r", "b", "p", "k"];
+export type RoleChar = (typeof ROLE_CHARS)[number];
+/**
+ * Indexable by square indices.
+ */
+export type BySquare<T> = T[];
+export declare const COLORS: readonly ["white", "black"];
+export type Color = (typeof COLORS)[number];
+/**
+ * Indexable by `white` and `black`.
+ */
+export type ByColor<T> = {
+    [color in Color]: T;
+};
+export declare const ROLES: readonly ["pawn", "knight", "bishop", "rook", "queen", "king"];
+export type Role = (typeof ROLES)[number];
+/**
+ * Indexable by `pawn`, `knight`, `bishop`, `rook`, `queen`, and `king`.
+ */
+export type ByRole<T> = {
+    [role in Role]: T;
+};
+export declare const CASTLING_SIDES: readonly ["a", "h"];
+export type CastlingSide = (typeof CASTLING_SIDES)[number];
+/**
+ * Indexable by `a` and `h`.
+ */
+export type ByCastlingSide<T> = {
+    [side in CastlingSide]: T;
+};
+export interface Piece {
+    role: Role;
+    color: Color;
+    promoted?: boolean;
+}
+export interface NormalMove {
+    from: Square;
+    to: Square;
+    promotion?: Role;
+}
+export interface DropMove {
+    role: Role;
+    to: Square;
+}
+export type Move = NormalMove | DropMove;
+export declare const isDrop: (v: Move) => v is DropMove;
+export declare const isNormal: (v: Move) => v is NormalMove;
+export declare const RULES: readonly ["chess", "antichess", "kingofthehill", "3check", "atomic", "horde", "racingkings", "crazyhouse"];
+export type Rules = (typeof RULES)[number];
+export interface Outcome {
+    winner: Color | undefined;
+}

package/dist/types/util.d.ts

@@ -0,0 +1,21 @@
+import { CastlingSide, Color, Move, Role, type RoleChar, Square, SquareName } from "./types.js";
+export declare const defined: <A>(v: A | undefined) => v is A;
+export declare const opposite: (color: Color) => Color;
+export declare const squareRank: (square: Square) => number;
+export declare const squareFile: (square: Square) => number;
+export declare const squareFromCoords: (file: number, rank: number) => Square | undefined;
+export declare const roleToChar: (role: Role) => RoleChar;
+export declare function charToRole(ch: RoleChar | Uppercase<RoleChar>): Role;
+export declare function charToRole(ch: string): Role | undefined;
+export declare function parseSquare(str: SquareName): Square;
+export declare function parseSquare(str: string): Square | undefined;
+export declare const makeSquare: (square: Square) => SquareName;
+export declare const parseUci: (str: string) => Move | undefined;
+export declare const moveEquals: (left: Move, right: Move) => boolean;
+/**
+ * Converts a move to UCI notation, like `g1f3` for a normal move,
+ * `a7a8q` for promotion to a queen, and `Q@f7` for a Crazyhouse drop.
+ */
+export declare const makeUci: (move: Move) => string;
+export declare const kingCastlesTo: (color: Color, side: CastlingSide) => Square;
+export declare const rookCastlesTo: (color: Color, side: CastlingSide) => Square;

package/dist/types/variant.d.ts

@@ -0,0 +1,92 @@
+import { Result } from "@badrap/result";
+import { Castles, castlingSide, Chess, Context, equalsIgnoreMoves, IllegalSetup, isImpossibleCheck, normalizeMove, Position, PositionError } from "./chess.js";
+import { Setup } from "./setup.js";
+import { SquareSet } from "./squareSet.js";
+import { Color, Outcome, Piece, Rules, Square } from "./types.js";
+export { Castles, castlingSide, Chess, Context, equalsIgnoreMoves, IllegalSetup, isImpossibleCheck, normalizeMove, Position, PositionError, };
+export declare class Crazyhouse extends Position {
+    private constructor();
+    reset(): void;
+    protected setupUnchecked(setup: Setup): void;
+    static default(): Crazyhouse;
+    static fromSetup(setup: Setup): Result<Crazyhouse, PositionError>;
+    clone(): Crazyhouse;
+    protected validate(): Result<undefined, PositionError>;
+    hasInsufficientMaterial(color: Color): boolean;
+    dropDests(ctx?: Context): SquareSet;
+}
+export declare class Atomic extends Position {
+    private constructor();
+    static default(): Atomic;
+    static fromSetup(setup: Setup): Result<Atomic, PositionError>;
+    clone(): Atomic;
+    protected validate(): Result<undefined, PositionError>;
+    kingAttackers(square: Square, attacker: Color, occupied: SquareSet): SquareSet;
+    protected playCaptureAt(square: Square, captured: Piece): void;
+    hasInsufficientMaterial(color: Color): boolean;
+    dests(square: Square, ctx?: Context): SquareSet;
+    isVariantEnd(): boolean;
+    variantOutcome(_ctx?: Context): Outcome | undefined;
+}
+export declare class Antichess extends Position {
+    private constructor();
+    reset(): void;
+    protected setupUnchecked(setup: Setup): void;
+    static default(): Antichess;
+    static fromSetup(setup: Setup): Result<Antichess, PositionError>;
+    clone(): Antichess;
+    protected validate(): Result<undefined, PositionError>;
+    kingAttackers(_square: Square, _attacker: Color, _occupied: SquareSet): SquareSet;
+    ctx(): Context;
+    dests(square: Square, ctx?: Context): SquareSet;
+    hasInsufficientMaterial(color: Color): boolean;
+    isVariantEnd(): boolean;
+    variantOutcome(ctx?: Context): Outcome | undefined;
+}
+export declare class KingOfTheHill extends Position {
+    private constructor();
+    static default(): KingOfTheHill;
+    static fromSetup(setup: Setup): Result<KingOfTheHill, PositionError>;
+    clone(): KingOfTheHill;
+    hasInsufficientMaterial(_color: Color): boolean;
+    isVariantEnd(): boolean;
+    variantOutcome(_ctx?: Context): Outcome | undefined;
+}
+export declare class ThreeCheck extends Position {
+    private constructor();
+    reset(): void;
+    protected setupUnchecked(setup: Setup): void;
+    static default(): ThreeCheck;
+    static fromSetup(setup: Setup): Result<ThreeCheck, PositionError>;
+    clone(): ThreeCheck;
+    hasInsufficientMaterial(color: Color): boolean;
+    isVariantEnd(): boolean;
+    variantOutcome(_ctx?: Context): Outcome | undefined;
+}
+export declare class RacingKings extends Position {
+    private constructor();
+    reset(): void;
+    setupUnchecked(setup: Setup): void;
+    static default(): RacingKings;
+    static fromSetup(setup: Setup): Result<RacingKings, PositionError>;
+    clone(): RacingKings;
+    protected validate(): Result<undefined, PositionError>;
+    dests(square: Square, ctx?: Context): SquareSet;
+    hasInsufficientMaterial(_color: Color): boolean;
+    isVariantEnd(): boolean;
+    variantOutcome(ctx?: Context): Outcome | undefined;
+}
+export declare class Horde extends Position {
+    private constructor();
+    reset(): void;
+    static default(): Horde;
+    static fromSetup(setup: Setup): Result<Horde, PositionError>;
+    clone(): Horde;
+    protected validate(): Result<undefined, PositionError>;
+    hasInsufficientMaterial(color: Color): boolean;
+    isVariantEnd(): boolean;
+    variantOutcome(_ctx?: Context): Outcome | undefined;
+}
+export declare const defaultPosition: (rules: Rules) => Position;
+export declare const setupPosition: (rules: Rules, setup: Setup) => Result<Position, PositionError>;
+export declare const isStandardMaterial: (pos: Position) => boolean;

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@connectorvol/chessops",
+  "version": "0.15.1",
+  "description": "Chess and chess variant rules and operations",
+  "keywords": [
+    "chess",
+    "fen",
+    "lichess",
+    "pgn",
+    "typescript",
+    "uci"
+  ],
+  "license": "GPL-3.0-or-later",
+  "author": "Niklas Fiekas <niklas.fiekas@backscattering.de>",
+  "repository": "github:niklasf/chessops",
+  "funding": "https://github.com/sponsors/niklasf",
+  "files": [
+    "/src",
+    "/dist",
+    "!/**/*.test.*"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "dist/types/*"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./*": {
+      "types": "./dist/types/*.d.ts",
+      "import": "./dist/esm/*.js",
+      "require": "./dist/cjs/*.js"
+    }
+  },
+  "scripts": {
+    "package": "tsc --declarationDir dist/types && tsc --outDir dist/cjs --module commonjs --declaration false",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "doc": "typedoc src/types.ts src/attacks.ts src/util.ts src/squareSet.ts src/board.ts src/setup.ts src/chess.ts src/compat.ts src/debug.ts src/fen.ts src/san.ts src/transform.ts src/variant.ts src/pgn.ts",
+    "lint": "eslint",
+    "format": "dprint fmt",
+    "check-format": "dprint check"
+  },
+  "dependencies": {
+    "@badrap/result": "^0.3"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30",
+    "@types/node": "^24.9.1",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "dprint": "^0.50",
+    "eslint": "^9",
+    "jest": "^30",
+    "ts-jest": "^29",
+    "typedoc": "^0.28",
+    "typescript": "^5"
+  },
+  "jest": {
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "moduleNameMapper": {
+      "^(.*)\\.js$": "$1"
+    },
+    "testRegex": ".*\\.test\\.ts$",
+    "transform": {
+      "\\.ts$": [
+        "ts-jest",
+        {
+          "useESM": true
+        }
+      ]
+    }
+  }
+}

package/src/attacks.ts

@@ -0,0 +1,160 @@
+/**
+ * Compute attacks and rays.
+ *
+ * These are low-level functions that can be used to implement chess rules.
+ *
+ * Implementation notes: Sliding attacks are computed using
+ * [Hyperbola Quintessence](https://www.chessprogramming.org/Hyperbola_Quintessence).
+ * Magic Bitboards would deliver slightly faster lookups, but also require
+ * initializing considerably larger attack tables. On the web, initialization
+ * time is important, so the chosen method may strike a better balance.
+ *
+ * @packageDocumentation
+ */
+
+import { SquareSet } from "./squareSet.js";
+import { BySquare, Color, Piece, Square } from "./types.js";
+import { squareFile, squareRank } from "./util.js";
+
+const computeRange = (square: Square, deltas: number[]): SquareSet => {
+  let range = SquareSet.empty();
+  for (const delta of deltas) {
+    const sq = square + delta;
+    if (0 <= sq && sq < 64 && Math.abs(squareFile(square) - squareFile(sq)) <= 2) {
+      range = range.with(sq);
+    }
+  }
+  return range;
+};
+
+const tabulate = <T>(f: (square: Square) => T): BySquare<T> => {
+  const table = [];
+  for (let square = 0; square < 64; square++) table[square] = f(square);
+  return table;
+};
+
+const KING_ATTACKS = tabulate((sq) => computeRange(sq, [-9, -8, -7, -1, 1, 7, 8, 9]));
+const KNIGHT_ATTACKS = tabulate((sq) => computeRange(sq, [-17, -15, -10, -6, 6, 10, 15, 17]));
+const PAWN_ATTACKS = {
+  white: tabulate((sq) => computeRange(sq, [7, 9])),
+  black: tabulate((sq) => computeRange(sq, [-7, -9])),
+};
+
+/**
+ * Gets squares attacked or defended by a king on `square`.
+ */
+export const kingAttacks = (square: Square): SquareSet => KING_ATTACKS[square];
+
+/**
+ * Gets squares attacked or defended by a knight on `square`.
+ */
+export const knightAttacks = (square: Square): SquareSet => KNIGHT_ATTACKS[square];
+
+/**
+ * Gets squares attacked or defended by a pawn of the given `color`
+ * on `square`.
+ */
+export const pawnAttacks = (color: Color, square: Square): SquareSet => 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(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(0x1020_4080, 0x0102_0408);
+  const shift = 8 * (squareRank(sq) + squareFile(sq) - 7);
+  return (shift >= 0 ? diag.shl64(shift) : diag.shr64(-shift)).without(sq);
+});
+
+const hyperbola = (bit: SquareSet, range: SquareSet, occupied: SquareSet): SquareSet => {
+  let forward = occupied.intersect(range);
+  let reverse = forward.bswap64(); // Assumes no more than 1 bit per rank
+  forward = forward.minus64(bit);
+  reverse = reverse.minus64(bit.bswap64());
+  return forward.xor(reverse.bswap64()).intersect(range);
+};
+
+const fileAttacks = (square: Square, occupied: SquareSet): SquareSet =>
+  hyperbola(SquareSet.fromSquare(square), FILE_RANGE[square], occupied);
+
+const rankAttacks = (square: Square, occupied: SquareSet): SquareSet => {
+  const range = RANK_RANGE[square];
+  let forward = occupied.intersect(range);
+  let reverse = forward.rbit64();
+  forward = forward.minus64(SquareSet.fromSquare(square));
+  reverse = reverse.minus64(SquareSet.fromSquare(63 - square));
+  return forward.xor(reverse.rbit64()).intersect(range);
+};
+
+/**
+ * Gets squares attacked or defended by a bishop on `square`, given `occupied`
+ * squares.
+ */
+export const bishopAttacks = (square: Square, occupied: SquareSet): SquareSet => {
+  const bit = SquareSet.fromSquare(square);
+  return hyperbola(bit, DIAG_RANGE[square], occupied).xor(
+    hyperbola(bit, ANTI_DIAG_RANGE[square], occupied),
+  );
+};
+
+/**
+ * Gets squares attacked or defended by a rook on `square`, given `occupied`
+ * squares.
+ */
+export const rookAttacks = (square: Square, occupied: SquareSet): SquareSet =>
+  fileAttacks(square, occupied).xor(rankAttacks(square, occupied));
+
+/**
+ * Gets squares attacked or defended by a queen on `square`, given `occupied`
+ * squares.
+ */
+export const queenAttacks = (square: Square, occupied: SquareSet): SquareSet =>
+  bishopAttacks(square, occupied).xor(rookAttacks(square, occupied));
+
+/**
+ * Gets squares attacked or defended by a `piece` on `square`, given
+ * `occupied` squares.
+ */
+export const attacks = (piece: Piece, square: Square, occupied: SquareSet): SquareSet => {
+  switch (piece.role) {
+    case "pawn":
+      return pawnAttacks(piece.color, square);
+    case "knight":
+      return knightAttacks(square);
+    case "bishop":
+      return bishopAttacks(square, occupied);
+    case "rook":
+      return rookAttacks(square, occupied);
+    case "queen":
+      return queenAttacks(square, occupied);
+    case "king":
+      return kingAttacks(square);
+  }
+};
+
+/**
+ * Gets all squares of the rank, file or diagonal with the two squares
+ * `a` and `b`, or an empty set if they are not aligned.
+ */
+export const ray = (a: Square, b: Square): SquareSet => {
+  const other = SquareSet.fromSquare(b);
+  if (RANK_RANGE[a].intersects(other)) return RANK_RANGE[a].with(a);
+  if (ANTI_DIAG_RANGE[a].intersects(other)) return ANTI_DIAG_RANGE[a].with(a);
+  if (DIAG_RANGE[a].intersects(other)) return DIAG_RANGE[a].with(a);
+  if (FILE_RANGE[a].intersects(other)) return FILE_RANGE[a].with(a);
+  return SquareSet.empty();
+};
+
+/**
+ * Gets all squares between `a` and `b` (bounds not included), or an empty set
+ * if they are not on the same rank, file or diagonal.
+ */
+export const between = (a: Square, b: Square): SquareSet =>
+  ray(a, b)
+    .intersect(SquareSet.full().shl64(a).xor(SquareSet.full().shl64(b)))
+    .withoutFirst();

package/src/board.ts

@@ -0,0 +1,168 @@
+import { SquareSet } from "./squareSet.js";
+import { ByColor, ByRole, Color, COLORS, Piece, Role, ROLES, Square } from "./types.js";
+
+/**
+ * Piece positions on a board.
+ *
+ * Properties are sets of squares, like `board.occupied` for all occupied
+ * squares, `board[color]` for all pieces of that color, and `board[role]`
+ * for all pieces of that role. When modifying the properties directly, take
+ * care to keep them consistent.
+ */
+export class Board implements Iterable<[Square, Piece]>, ByRole<SquareSet>, ByColor<SquareSet> {
+  /**
+   * All occupied squares.
+   */
+  occupied: SquareSet;
+  /**
+   * All squares occupied by pieces known to be promoted. This information is
+   * relevant in chess variants like Crazyhouse.
+   */
+  promoted: SquareSet;
+
+  white: SquareSet;
+  black: SquareSet;
+
+  pawn: SquareSet;
+  knight: SquareSet;
+  bishop: SquareSet;
+  rook: SquareSet;
+  queen: SquareSet;
+  king: SquareSet;
+
+  private constructor() {}
+
+  static default(): Board {
+    const board = new Board();
+    board.reset();
+    return board;
+  }
+
+  /**
+   * Resets all pieces to the default starting position for standard chess.
+   */
+  reset(): void {
+    this.occupied = new SquareSet(0xffff, 0xffff_0000);
+    this.promoted = SquareSet.empty();
+    this.white = new SquareSet(0xffff, 0);
+    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(): Board {
+    const board = new Board();
+    board.clear();
+    return board;
+  }
+
+  clear(): void {
+    this.occupied = SquareSet.empty();
+    this.promoted = SquareSet.empty();
+    for (const color of COLORS) this[color] = SquareSet.empty();
+    for (const role of ROLES) this[role] = SquareSet.empty();
+  }
+
+  clone(): Board {
+    const board = new Board();
+    board.occupied = this.occupied;
+    board.promoted = this.promoted;
+    for (const color of COLORS) board[color] = this[color];
+    for (const role of ROLES) board[role] = this[role];
+    return board;
+  }
+
+  getColor(square: Square): Color | undefined {
+    if (this.white.has(square)) return "white";
+    if (this.black.has(square)) return "black";
+    return;
+  }
+
+  getRole(square: Square): Role | undefined {
+    for (const role of ROLES) {
+      if (this[role].has(square)) return role;
+    }
+    return;
+  }
+
+  get(square: Square): Piece | undefined {
+    const color = this.getColor(square);
+    if (!color) return;
+    const role = this.getRole(square)!;
+    const promoted = this.promoted.has(square);
+    return { color, role, promoted };
+  }
+
+  /**
+   * Removes and returns the piece from the given `square`, if any.
+   */
+  take(square: Square): Piece | undefined {
+    const piece = this.get(square);
+    if (piece) {
+      this.occupied = this.occupied.without(square);
+      this[piece.color] = this[piece.color].without(square);
+      this[piece.role] = this[piece.role].without(square);
+      if (piece.promoted) this.promoted = this.promoted.without(square);
+    }
+    return piece;
+  }
+
+  /**
+   * Put `piece` onto `square`, potentially replacing an existing piece.
+   * Returns the existing piece, if any.
+   */
+  set(square: Square, piece: Piece): Piece | undefined {
+    const old = this.take(square);
+    this.occupied = this.occupied.with(square);
+    this[piece.color] = this[piece.color].with(square);
+    this[piece.role] = this[piece.role].with(square);
+    if (piece.promoted) this.promoted = this.promoted.with(square);
+    return old;
+  }
+
+  has(square: Square): boolean {
+    return this.occupied.has(square);
+  }
+
+  *[Symbol.iterator](): Iterator<[Square, Piece]> {
+    for (const square of this.occupied) {
+      yield [square, this.get(square)!];
+    }
+  }
+
+  pieces(color: Color, role: Role): SquareSet {
+    return this[color].intersect(this[role]);
+  }
+
+  rooksAndQueens(): SquareSet {
+    return this.rook.union(this.queen);
+  }
+
+  bishopsAndQueens(): SquareSet {
+    return this.bishop.union(this.queen);
+  }
+
+  steppers(): SquareSet {
+    return this.knight.union(this.pawn).union(this.king);
+  }
+
+  sliders(): SquareSet {
+    return this.bishop.union(this.rook).union(this.queen);
+  }
+
+  /**
+   * Finds the unique king of the given `color`, if any.
+   */
+  kingOf(color: Color): Square | undefined {
+    return this.pieces(color, "king").singleSquare();
+  }
+}
+
+export const boardEquals = (left: Board, right: Board): boolean =>
+  left.white.equals(right.white) &&
+  left.promoted.equals(right.promoted) &&
+  ROLES.every((role) => left[role].equals(right[role]));