@datamoc/mw_games 0.5.4 → 0.6.0

package/dist/board/Classics.js

@@ -31,9 +31,15 @@ export class BoardGrid {
             throw new Error(`cell (${x},${y}) is outside the board`);
         return y * this.width + x;
     }
-    inside(x, y) { return x >= 0 && y >= 0 && x < this.width && y < this.height; }
-    get(x, y) { return this.cells[this.index(x, y)]; }
-    set(x, y, piece) { this.cells[this.index(x, y)] = piece; }
+    inside(x, y) {
+        return x >= 0 && y >= 0 && x < this.width && y < this.height;
+    }
+    get(x, y) {
+        return this.cells[this.index(x, y)];
+    }
+    set(x, y, piece) {
+        this.cells[this.index(x, y)] = piece;
+    }
     move(from, to) {
         const piece = this.get(from.x, from.y);
         if (piece === null)
@@ -77,9 +83,15 @@ export function startingCheckers() {
  * ```
  */
 export function checkersMoves(state) {
-    const sources = state.forcedFrom === null ? state.board.map((piece, from) => piece?.side === state.turn ? from : -1).filter((from) => from >= 0) : [state.forcedFrom];
+    const sources = state.forcedFrom === null
+        ? state.board.map((piece, from) => (piece?.side === state.turn ? from : -1)).filter((from) => from >= 0)
+        : [state.forcedFrom];
     const captures = sources.flatMap((from) => checkersFrom(state, from, true));
-    return captures.length > 0 ? captures : state.forcedFrom === null ? sources.flatMap((from) => checkersFrom(state, from, false)) : [];
+    return captures.length > 0
+        ? captures
+        : state.forcedFrom === null
+            ? sources.flatMap((from) => checkersFrom(state, from, false))
+            : [];
 }
 /**
  * @example
@@ -92,7 +104,9 @@ export function checkersMoves(state) {
  * ```
  */
 export function applyCheckersMove(state, move) {
-    if (!checkersMoves(state).some((candidate) => candidate.from === move.from && candidate.to === move.to && candidate.captures.length === move.captures.length))
+    if (!checkersMoves(state).some((candidate) => candidate.from === move.from &&
+        candidate.to === move.to &&
+        candidate.captures.length === move.captures.length))
         throw new Error('illegal checkers move');
     const piece = state.board[move.from];
     if (!piece)
@@ -100,9 +114,15 @@ export function applyCheckersMove(state, move) {
     state.board[move.from] = null;
     for (const captured of move.captures)
         state.board[captured] = null;
-    const promoted = !piece.king && ((piece.side === 'red' && Math.floor(move.to / 8) === 0) || (piece.side === 'black' && Math.floor(move.to / 8) === 7));
+    const promoted = !piece.king &&
+        ((piece.side === 'red' && Math.floor(move.to / 8) === 0) ||
+            (piece.side === 'black' && Math.floor(move.to / 8) === 7));
     state.board[move.to] = { ...piece, king: piece.king || promoted };
-    const next = { board: state.board, turn: state.turn, forcedFrom: move.captures.length > 0 ? move.to : null };
+    const next = {
+        board: state.board,
+        turn: state.turn,
+        forcedFrom: move.captures.length > 0 ? move.to : null,
+    };
     if (move.captures.length === 0 || checkersFrom(next, move.to, true).length === 0) {
         state.turn = state.turn === 'red' ? 'black' : 'red';
         state.forcedFrom = null;
@@ -204,7 +224,11 @@ export function playGo(state, x, y) {
  * console.log(goResult(state)); // 'finished'
  * ```
  */
-export function passGo(state) { state.turn = state.turn === 'black' ? 'white' : 'black'; state.ko = null; state.passes++; }
+export function passGo(state) {
+    state.turn = state.turn === 'black' ? 'white' : 'black';
+    state.ko = null;
+    state.passes++;
+}
 /**
  * @example
  * ```ts
@@ -213,7 +237,9 @@ export function passGo(state) { state.turn = state.turn === 'black' ? 'white' :
  * console.log(goResult(startingGo(9))); // 'ongoing' - nobody has passed yet
  * ```
  */
-export function goResult(state) { return state.passes >= 2 ? 'finished' : 'ongoing'; }
+export function goResult(state) {
+    return state.passes >= 2 ? 'finished' : 'ongoing';
+}
 /**
  * Stones on the board plus surrounded empty territory, per side - area scoring, not the
  * Japanese rule set's separate prisoner count.
@@ -227,49 +253,88 @@ export function goResult(state) { return state.passes >= 2 ? 'finished' : 'ongoi
  * console.log(goScore(state)); // { black: 1, white: 0 } - one stone, no territory settled yet
  * ```
  */
-export function goScore(state) { const score = { black: 0, white: 0 }; const seen = new Set(); for (let i = 0; i < state.board.length; i++) {
-    const stone = state.board[i];
-    if (stone)
-        score[stone]++;
-    else if (!seen.has(i)) {
-        const area = group(state.board, state.size, i);
-        const borders = new Set();
-        for (const cell of area)
-            for (const neighbour of goNeighbours(state, cell))
-                if (state.board[neighbour])
-                    borders.add(state.board[neighbour]);
-        for (const cell of area)
-            seen.add(cell);
-        if (borders.size === 1)
-            score[[...borders][0]] += area.length;
+export function goScore(state) {
+    const score = { black: 0, white: 0 };
+    const seen = new Set();
+    for (let i = 0; i < state.board.length; i++) {
+        const stone = state.board[i];
+        if (stone)
+            score[stone]++;
+        else if (!seen.has(i)) {
+            const area = group(state.board, state.size, i);
+            const borders = new Set();
+            for (const cell of area)
+                for (const neighbour of goNeighbours(state, cell))
+                    if (state.board[neighbour])
+                        borders.add(state.board[neighbour]);
+            for (const cell of area)
+                seen.add(cell);
+            if (borders.size === 1)
+                score[[...borders][0]] += area.length;
+        }
     }
-} return score; }
+    return score;
+}
 function goIndex(state, x, y) {
     if (x < 0 || y < 0 || x >= state.size || y >= state.size)
         throw new Error('Go cell is outside the board');
     return y * state.size + x;
 }
-function goNeighbours(state, index) { const x = index % state.size; const y = Math.floor(index / state.size); return [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]].filter(([nx, ny]) => nx >= 0 && ny >= 0 && nx < state.size && ny < state.size).map(([nx, ny]) => ny * state.size + nx); }
-function group(board, size, start) { const stone = board[start]; if (!stone)
-    return []; const found = []; const todo = [start]; const seen = new Set(); while (todo.length) {
-    const index = todo.pop();
-    if (seen.has(index) || board[index] !== stone)
-        continue;
-    seen.add(index);
-    found.push(index);
-    const x = index % size;
-    const y = Math.floor(index / size);
-    for (const [nx, ny] of [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]])
-        if (nx >= 0 && ny >= 0 && nx < size && ny < size)
-            todo.push(ny * size + nx);
-} return found; }
-function liberties(board, size, start) { const cells = group(board, size, start); const empty = new Set(); for (const index of cells) {
-    const x = index % size;
-    const y = Math.floor(index / size);
-    for (const [nx, ny] of [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]])
-        if (nx >= 0 && ny >= 0 && nx < size && ny < size && board[ny * size + nx] === null)
-            empty.add(ny * size + nx);
-} return empty.size; }
+function goNeighbours(state, index) {
+    const x = index % state.size;
+    const y = Math.floor(index / state.size);
+    return [
+        [x - 1, y],
+        [x + 1, y],
+        [x, y - 1],
+        [x, y + 1],
+    ]
+        .filter(([nx, ny]) => nx >= 0 && ny >= 0 && nx < state.size && ny < state.size)
+        .map(([nx, ny]) => ny * state.size + nx);
+}
+function group(board, size, start) {
+    const stone = board[start];
+    if (!stone)
+        return [];
+    const found = [];
+    const todo = [start];
+    const seen = new Set();
+    while (todo.length) {
+        const index = todo.pop();
+        if (seen.has(index) || board[index] !== stone)
+            continue;
+        seen.add(index);
+        found.push(index);
+        const x = index % size;
+        const y = Math.floor(index / size);
+        for (const [nx, ny] of [
+            [x - 1, y],
+            [x + 1, y],
+            [x, y - 1],
+            [x, y + 1],
+        ])
+            if (nx >= 0 && ny >= 0 && nx < size && ny < size)
+                todo.push(ny * size + nx);
+    }
+    return found;
+}
+function liberties(board, size, start) {
+    const cells = group(board, size, start);
+    const empty = new Set();
+    for (const index of cells) {
+        const x = index % size;
+        const y = Math.floor(index / size);
+        for (const [nx, ny] of [
+            [x - 1, y],
+            [x + 1, y],
+            [x, y - 1],
+            [x, y + 1],
+        ])
+            if (nx >= 0 && ny >= 0 && nx < size && ny < size && board[ny * size + nx] === null)
+                empty.add(ny * size + nx);
+    }
+    return empty.size;
+}
 /**
  * @example
  * ```ts
@@ -279,7 +344,18 @@ function liberties(board, size, start) { const cells = group(board, size, start)
  * console.log(state.points[0], state.points[23]); // 2 -2 - white's and black's back checkers
  * ```
  */
-export function startingBackgammon() { const points = new Array(24).fill(0); points[0] = 2; points[11] = 5; points[16] = 3; points[18] = 5; points[23] = -2; points[12] = -5; points[7] = -3; points[5] = -5; return { points, bar: { white: 0, black: 0 }, off: { white: 0, black: 0 }, turn: 'white' }; }
+export function startingBackgammon() {
+    const points = new Array(24).fill(0);
+    points[0] = 2;
+    points[11] = 5;
+    points[16] = 3;
+    points[18] = 5;
+    points[23] = -2;
+    points[12] = -5;
+    points[7] = -3;
+    points[5] = -5;
+    return { points, bar: { white: 0, black: 0 }, off: { white: 0, black: 0 }, turn: 'white' };
+}
 /** Doubles roll as four of the same die, not two - the standard backgammon rule.
  *
  * @example
@@ -290,7 +366,10 @@ export function startingBackgammon() { const points = new Array(24).fill(0); poi
  * console.log(dice.length === 2 || dice.length === 4); // true
  * ```
  */
-export function rollBackgammonDice() { const dice = rollDice(2, 6); return dice[0] === dice[1] ? [...dice, ...dice] : dice; }
+export function rollBackgammonDice() {
+    const dice = rollDice(2, 6);
+    return dice[0] === dice[1] ? [...dice, ...dice] : dice;
+}
 /**
  * @example
  * ```ts
@@ -300,22 +379,27 @@ export function rollBackgammonDice() { const dice = rollDice(2, 6); return dice[
  * console.log(moves.length, moves[0]); // 3 { from: 0, to: 1, die: 1 }
  * ```
  */
-export function backgammonMoves(state, dice) { const side = state.turn === 'white' ? 1 : -1; const out = []; for (const die of dice) {
-    if (state.bar[state.turn] > 0) {
-        const to = state.turn === 'white' ? die - 1 : 24 - die;
-        if (canBackgammonLand(state, to, side))
-            out.push({ from: 'bar', to, die });
-        continue;
-    }
-    for (let from = 0; from < 24; from++)
-        if (state.points[from] * side > 0) {
-            const to = from + die * side;
-            if (to < 0 || to >= 24)
-                out.push({ from, to: 'off', die });
-            else if (canBackgammonLand(state, to, side))
-                out.push({ from, to, die });
+export function backgammonMoves(state, dice) {
+    const side = state.turn === 'white' ? 1 : -1;
+    const out = [];
+    for (const die of dice) {
+        if (state.bar[state.turn] > 0) {
+            const to = state.turn === 'white' ? die - 1 : 24 - die;
+            if (canBackgammonLand(state, to, side))
+                out.push({ from: 'bar', to, die });
+            continue;
         }
-} return out; }
+        for (let from = 0; from < 24; from++)
+            if (state.points[from] * side > 0) {
+                const to = from + die * side;
+                if (to < 0 || to >= 24)
+                    out.push({ from, to: 'off', die });
+                else if (canBackgammonLand(state, to, side))
+                    out.push({ from, to, die });
+            }
+    }
+    return out;
+}
 /**
  * @example
  * ```ts
@@ -326,21 +410,28 @@ export function backgammonMoves(state, dice) { const side = state.turn === 'whit
  * console.log(state.points[0], state.points[1]); // 1 1 - one checker moved from point 0 to point 1
  * ```
  */
-export function applyBackgammonMove(state, move) { if (!backgammonMoves(state, [move.die]).some((candidate) => candidate.from === move.from && candidate.to === move.to))
-    throw new Error('illegal backgammon move'); const side = state.turn === 'white' ? 1 : -1; if (move.from === 'bar')
-    state.bar[state.turn]--;
-else
-    state.points[move.from] -= side; if (move.to === 'off')
-    state.off[state.turn]++;
-else {
-    if (state.points[move.to] * side < 0) {
-        const enemy = state.turn === 'white' ? 'black' : 'white';
-        state.points[move.to] = 0;
-        state.bar[enemy]++;
+export function applyBackgammonMove(state, move) {
+    if (!backgammonMoves(state, [move.die]).some((candidate) => candidate.from === move.from && candidate.to === move.to))
+        throw new Error('illegal backgammon move');
+    const side = state.turn === 'white' ? 1 : -1;
+    if (move.from === 'bar')
+        state.bar[state.turn]--;
+    else
+        state.points[move.from] -= side;
+    if (move.to === 'off')
+        state.off[state.turn]++;
+    else {
+        if (state.points[move.to] * side < 0) {
+            const enemy = state.turn === 'white' ? 'black' : 'white';
+            state.points[move.to] = 0;
+            state.bar[enemy]++;
+        }
+        state.points[move.to] += side;
     }
-    state.points[move.to] += side;
-} }
-function canBackgammonLand(state, to, side) { return state.points[to] * side >= -1; }
+}
+function canBackgammonLand(state, to, side) {
+    return state.points[to] * side >= -1;
+}
 /**
  * @example
  * ```ts
@@ -350,9 +441,14 @@ function canBackgammonLand(state, to, side) { return state.points[to] * side >=
  * console.log(createDeck(2).length); // 54 - two jokers added
  * ```
  */
-export function createDeck(jokers = 0) { const suits = ['clubs', 'diamonds', 'hearts', 'spades']; const cards = []; for (const suit of suits)
-    for (let rank = 1; rank <= 13; rank++)
-        cards.push({ suit, rank: rank }); return cards.concat(new Array(jokers).fill(null).map(() => ({ suit: 'spades', rank: 1 }))); }
+export function createDeck(jokers = 0) {
+    const suits = ['clubs', 'diamonds', 'hearts', 'spades'];
+    const cards = [];
+    for (const suit of suits)
+        for (let rank = 1; rank <= 13; rank++)
+            cards.push({ suit, rank: rank });
+    return cards.concat(new Array(jokers).fill(null).map(() => ({ suit: 'spades', rank: 1 })));
+}
 /**
  * @example
  * ```ts
@@ -363,7 +459,9 @@ export function createDeck(jokers = 0) { const suits = ['clubs', 'diamonds', 'he
  * console.log(shuffled[0]); // { suit: 'hearts', rank: 6 } - deterministic for seed 1
  * ```
  */
-export function shuffleDeck(deck) { return Random.shuffle(deck); }
+export function shuffleDeck(deck) {
+    return Random.shuffle(deck);
+}
 /**
  * @example
  * ```ts
@@ -373,8 +471,11 @@ export function shuffleDeck(deck) { return Random.shuffle(deck); }
  * console.log(hands.length, hands[0].length); // 4 13 - a full deck dealt to four players
  * ```
  */
-export function deal(deck, hands, cardsEach) { if (hands < 0 || cardsEach < 0 || deck.length < hands * cardsEach)
-    throw new Error('not enough cards to deal'); return Array.from({ length: hands }, () => deck.splice(0, cardsEach)); }
+export function deal(deck, hands, cardsEach) {
+    if (hands < 0 || cardsEach < 0 || deck.length < hands * cardsEach)
+        throw new Error('not enough cards to deal');
+    return Array.from({ length: hands }, () => deck.splice(0, cardsEach));
+}
 /** Highest card of the trump suit wins; failing that, highest card of whoever led. Ace (rank 1) ranks lowest, as in belote/tarot/bridge follow-suit play.
  *
  * @example
@@ -391,8 +492,16 @@ export function deal(deck, hands, cardsEach) { if (hands < 0 || cardsEach < 0 ||
  * console.log(trickWinner(plays, 'spades')); // 'east' - the only spade played beats every heart
  * ```
  */
-export function trickWinner(plays, trumpSuit) { if (plays.length === 0)
-    throw new Error('a trick needs at least one play'); const leadSuit = plays[0].card.suit; const rankValue = (card) => (card.rank === 1 ? 14 : card.rank); const contest = trumpSuit && plays.some((play) => play.card.suit === trumpSuit) ? plays.filter((play) => play.card.suit === trumpSuit) : plays.filter((play) => play.card.suit === leadSuit); return contest.reduce((best, play) => (rankValue(play.card) > rankValue(best.card) ? play : best)).owner; }
+export function trickWinner(plays, trumpSuit) {
+    if (plays.length === 0)
+        throw new Error('a trick needs at least one play');
+    const leadSuit = plays[0].card.suit;
+    const rankValue = (card) => (card.rank === 1 ? 14 : card.rank);
+    const contest = trumpSuit && plays.some((play) => play.card.suit === trumpSuit)
+        ? plays.filter((play) => play.card.suit === trumpSuit)
+        : plays.filter((play) => play.card.suit === leadSuit);
+    return contest.reduce((best, play) => (rankValue(play.card) > rankValue(best.card) ? play : best)).owner;
+}
 /**
  * A Klondike-shaped deal: seven tableau columns, each with one face-up card on a run of
  * face-down ones, the rest in the stock.
@@ -406,10 +515,18 @@ export function trickWinner(plays, trumpSuit) { if (plays.length === 0)
  * console.log(state.tableau[0].up); // [{ suit: 'clubs', rank: 12 }] - one face-up card to start
  * ```
  */
-export function dealSolitaire(seed) { const deck = createDeck(); if (seed === undefined)
-    shuffleDeck(deck);
-else
-    Random.withSeed(seed, () => shuffleDeck(deck)); const tableau = Array.from({ length: 7 }, (_, column) => ({ down: deck.splice(0, 6 - column), up: deck.splice(0, 1) })); return { stock: deck, waste: [], tableau, foundations: [[], [], [], []] }; }
+export function dealSolitaire(seed) {
+    const deck = createDeck();
+    if (seed === undefined)
+        shuffleDeck(deck);
+    else
+        Random.withSeed(seed, () => shuffleDeck(deck));
+    const tableau = Array.from({ length: 7 }, (_, column) => ({
+        down: deck.splice(0, 6 - column),
+        up: deck.splice(0, 1),
+    }));
+    return { stock: deck, waste: [], tableau, foundations: [[], [], [], []] };
+}
 /**
  * Draws from the stock to the waste; once the stock is empty, the waste is turned back over
  * into a new stock rather than the game being stuck.
@@ -424,11 +541,16 @@ else
  * console.log(state.waste.length, state.stock.length); // 1 23
  * ```
  */
-export function drawSolitaire(state) { if (state.stock.length === 0) {
-    state.stock = state.waste.reverse();
-    state.waste = [];
-} const card = state.stock.pop() ?? null; if (card)
-    state.waste.push(card); return card; }
+export function drawSolitaire(state) {
+    if (state.stock.length === 0) {
+        state.stock = state.waste.reverse();
+        state.waste = [];
+    }
+    const card = state.stock.pop() ?? null;
+    if (card)
+        state.waste.push(card);
+    return card;
+}
 /**
  * Moves the top `count` face-up cards from one tableau column to another - legal only onto a
  * card one rank higher of the opposite colour, or onto an empty column with a king.
@@ -442,9 +564,20 @@ export function drawSolitaire(state) { if (state.stock.length === 0) {
  * console.log(state.tableau[0].up.at(-1)); // { suit: 'hearts', rank: 11 }
  * ```
  */
-export function moveSolitaireTableau(state, from, to, count = 1) { const source = state.tableau[from]; const target = state.tableau[to]; const moving = source?.up.slice(-count); if (!source || !target || !moving?.length || (target.up.length === 0 ? moving[0].rank !== 13 : !alternatingDescending(moving[0], target.up.at(-1))))
-    throw new Error('illegal solitaire tableau move'); source.up.splice(-count, count); target.up.push(...moving); if (source.down.length && source.up.length === 0)
-    source.up.push(source.down.pop()); }
+export function moveSolitaireTableau(state, from, to, count = 1) {
+    const source = state.tableau[from];
+    const target = state.tableau[to];
+    const moving = source?.up.slice(-count);
+    if (!source ||
+        !target ||
+        !moving?.length ||
+        (target.up.length === 0 ? moving[0].rank !== 13 : !alternatingDescending(moving[0], target.up.at(-1))))
+        throw new Error('illegal solitaire tableau move');
+    source.up.splice(-count, count);
+    target.up.push(...moving);
+    if (source.down.length && source.up.length === 0)
+        source.up.push(source.down.pop());
+}
 /**
  * Moves a card to its suit's foundation pile - legal only as the next rank up (an ace
  * starts a pile).
@@ -461,16 +594,23 @@ export function moveSolitaireTableau(state, from, to, count = 1) { const source
  * console.log(state.foundations.some((pile) => pile.length === 1)); // true
  * ```
  */
-export function moveSolitaireToFoundation(state, source) { const card = source === 'waste' ? state.waste.at(-1) : state.tableau[source].up.at(-1); if (!card)
-    throw new Error('no solitaire card to move'); const foundation = state.foundations.find((pile) => pile[0]?.suit === card.suit || pile.length === 0); if (!foundation || card.rank !== foundation.length + 1)
-    throw new Error('card cannot move to its foundation'); if (source === 'waste')
-    state.waste.pop();
-else {
-    const column = state.tableau[source];
-    column.up.pop();
-    if (column.down.length && column.up.length === 0)
-        column.up.push(column.down.pop());
-} foundation.push(card); }
+export function moveSolitaireToFoundation(state, source) {
+    const card = source === 'waste' ? state.waste.at(-1) : state.tableau[source].up.at(-1);
+    if (!card)
+        throw new Error('no solitaire card to move');
+    const foundation = state.foundations.find((pile) => pile[0]?.suit === card.suit || pile.length === 0);
+    if (!foundation || card.rank !== foundation.length + 1)
+        throw new Error('card cannot move to its foundation');
+    if (source === 'waste')
+        state.waste.pop();
+    else {
+        const column = state.tableau[source];
+        column.up.pop();
+        if (column.down.length && column.up.length === 0)
+            column.up.push(column.down.pop());
+    }
+    foundation.push(card);
+}
 /**
  * @example
  * ```ts
@@ -479,8 +619,14 @@ else {
  * console.log(solitaireWon(dealSolitaire(1))); // false - a fresh deal is never already won
  * ```
  */
-export function solitaireWon(state) { return state.foundations.every((pile) => pile.length === 13); }
-function alternatingDescending(top, bottom) { const topRed = top.suit === 'diamonds' || top.suit === 'hearts'; const bottomRed = bottom.suit === 'diamonds' || bottom.suit === 'hearts'; return top.rank === bottom.rank - 1 && topRed !== bottomRed; }
+export function solitaireWon(state) {
+    return state.foundations.every((pile) => pile.length === 13);
+}
+function alternatingDescending(top, bottom) {
+    const topRed = top.suit === 'diamonds' || top.suit === 'hearts';
+    const bottomRed = bottom.suit === 'diamonds' || bottom.suit === 'hearts';
+    return top.rank === bottom.rank - 1 && topRed !== bottomRed;
+}
 /**
  * @example
  * ```ts
@@ -491,8 +637,11 @@ function alternatingDescending(top, bottom) { const topRed = top.suit === 'diamo
  * console.log(rolls); // [5, 2] - deterministic for seed 1
  * ```
  */
-export function rollDice(count, sides) { if (!Number.isInteger(count) || count < 0 || !Number.isInteger(sides) || sides < 1)
-    throw new Error('dice need a non-negative count and positive sides'); return Array.from({ length: count }, () => Random.range(1, sides)); }
+export function rollDice(count, sides) {
+    if (!Number.isInteger(count) || count < 0 || !Number.isInteger(sides) || sides < 1)
+        throw new Error('dice need a non-negative count and positive sides');
+    return Array.from({ length: count }, () => Random.range(1, sides));
+}
 /**
  * Rolls a `"NdS+M"`-style expression (2d6+1: two six-sided dice, plus one).
  *
@@ -504,8 +653,12 @@ export function rollDice(count, sides) { if (!Number.isInteger(count) || count <
  * console.log(Random.withSeed(1, () => rollExpression('2d6+1'))); // 8 - rolls [5, 2], plus 1
  * ```
  */
-export function rollExpression(expression) { const match = /^(\d+)d(\d+)([+-]\d+)?$/i.exec(expression.trim()); if (!match)
-    throw new Error(`bad dice expression: "${expression}"`); return rollDice(Number(match[1]), Number(match[2])).reduce((sum, roll) => sum + roll, Number(match[3] ?? 0)); }
+export function rollExpression(expression) {
+    const match = /^(\d+)d(\d+)([+-]\d+)?$/i.exec(expression.trim());
+    if (!match)
+        throw new Error(`bad dice expression: "${expression}"`);
+    return rollDice(Number(match[1]), Number(match[2])).reduce((sum, roll) => sum + roll, Number(match[3] ?? 0));
+}
 /**
  * A cup of dice a player can keep and re-roll - Yahtzee's own mechanic, generalised to any
  * count/sides.
@@ -529,12 +682,19 @@ export class DiceCup {
         this.sides = sides;
         this.values = rollDice(count, sides);
     }
-    reRoll() { for (let i = 0; i < this.values.length; i++)
-        if (!this.kept.has(i))
-            this.values[i] = Random.range(1, this.sides); }
-    keep(index) { if (index < 0 || index >= this.count)
-        throw new Error('die index is outside the cup'); this.kept.add(index); }
-    clearKept() { this.kept.clear(); }
+    reRoll() {
+        for (let i = 0; i < this.values.length; i++)
+            if (!this.kept.has(i))
+                this.values[i] = Random.range(1, this.sides);
+    }
+    keep(index) {
+        if (index < 0 || index >= this.count)
+            throw new Error('die index is outside the cup');
+        this.kept.add(index);
+    }
+    clearKept() {
+        this.kept.clear();
+    }
 }
 /**
  * Scores five d6 values against one Yahtzee category.
@@ -548,17 +708,34 @@ export class DiceCup {
  * console.log(scoreDice([4, 4, 4, 4, 4], 'fours')); // 20 - five fours, four points each
  * ```
  */
-export function scoreDice(values, category) { if (values.length !== 5 || values.some((value) => value < 1 || value > 6))
-    throw new Error('a score sheet needs five d6 values'); const counts = new Map(); for (const value of values)
-    counts.set(value, (counts.get(value) ?? 0) + 1); const total = values.reduce((sum, value) => sum + value, 0); if (category === 'chance')
-    return total; if (category === 'yahtzee')
-    return counts.size === 1 ? 50 : 0; if (category === 'fullHouse')
-    return [...counts.values()].sort().join(',') === '2,3' ? 25 : 0; if (category === 'threeKind')
-    return [...counts.values()].some((count) => count >= 3) ? total : 0; if (category === 'fourKind')
-    return [...counts.values()].some((count) => count >= 4) ? total : 0; if (category === 'smallStraight' || category === 'largeStraight') {
-    const runs = ['1234', '2345', '3456'];
-    const large = ['12345', '23456'];
-    const unique = [...counts.keys()].sort().join('');
-    return (category === 'smallStraight' ? runs : large).some((run) => unique.includes(run)) ? category === 'smallStraight' ? 30 : 40 : 0;
-} const face = ['ones', 'twos', 'threes', 'fours', 'fives', 'sixes'].indexOf(category) + 1; return face > 0 ? (counts.get(face) ?? 0) * face : 0; }
+export function scoreDice(values, category) {
+    if (values.length !== 5 || values.some((value) => value < 1 || value > 6))
+        throw new Error('a score sheet needs five d6 values');
+    const counts = new Map();
+    for (const value of values)
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    const total = values.reduce((sum, value) => sum + value, 0);
+    if (category === 'chance')
+        return total;
+    if (category === 'yahtzee')
+        return counts.size === 1 ? 50 : 0;
+    if (category === 'fullHouse')
+        return [...counts.values()].sort().join(',') === '2,3' ? 25 : 0;
+    if (category === 'threeKind')
+        return [...counts.values()].some((count) => count >= 3) ? total : 0;
+    if (category === 'fourKind')
+        return [...counts.values()].some((count) => count >= 4) ? total : 0;
+    if (category === 'smallStraight' || category === 'largeStraight') {
+        const runs = ['1234', '2345', '3456'];
+        const large = ['12345', '23456'];
+        const unique = [...counts.keys()].sort().join('');
+        return (category === 'smallStraight' ? runs : large).some((run) => unique.includes(run))
+            ? category === 'smallStraight'
+                ? 30
+                : 40
+            : 0;
+    }
+    const face = ['ones', 'twos', 'threes', 'fours', 'fives', 'sixes'].indexOf(category) + 1;
+    return face > 0 ? (counts.get(face) ?? 0) * face : 0;
+}
 //# sourceMappingURL=Classics.js.map