scrabble-solver 2.18.10-alpha.2 → 2.19.0-alpha.0

package/packages/solver/build/MoveGenerator.js

@@ -1,686 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoveGenerator = void 0;
-/* eslint-disable max-depth, max-lines, max-statements, no-bitwise */
-const gaddag_1 = require("@kamilmielnik/gaddag");
-const constants_1 = require("@scrabble-solver/constants");
-const types_1 = require("@scrabble-solver/types");
-const MAX_ALPHABET_SIZE = 64;
-// The result sort key packs (direction, line, start, end) into one integer.
-const MAX_BOARD_DIMENSION = 32;
-/**
- * Anchor-based move generation over a {@link Gaddag} (Gordon, 1994).
- *
- * For every anchor (an empty cell adjacent to a tile, or the board center when
- * the board is empty) the generator extends leftwards from the anchor through
- * the reversed-prefix part of the GADDAG, crosses the separator, and extends
- * rightwards — validating perpendicular words with precomputed cross-check
- * masks. Both directions run the same code path: the vertical pass remaps
- * (line, position) to transposed coordinates. Each placement is scored and
- * emitted as a compact {@link ResultJson} — placed tiles plus placement — from
- * which {@link Result.fromJson} rebuilds the full cells and collisions against
- * the board.
- */
-class MoveGenerator {
-    constructor(gaddag, config, board, tiles) {
-        this.blanksLeft = 0;
-        this.rackTotal = 0;
-        this.boardIsEmpty = true;
-        // Current pass (direction) data, indexed by line * lineLength + position.
-        this.isHorizontal = true;
-        this.lineLength = 0;
-        this.linesCount = 0;
-        // Current line/anchor state.
-        this.line = 0;
-        this.lineBase = 0;
-        this.anchorPos = 0;
-        this.limit = 0;
-        this.anchorRightOpen = false;
-        this.leftMost = 0;
-        this.placedCount = 0;
-        // Single-tile placements are the only ones both passes can emit; multi-tile
-        // placements determine their line, span, and anchor uniquely.
-        this.seenSingleTiles = new Set();
-        this.results = [];
-        // Board cells are immutable during a solve, so their JSON is shared between results.
-        // Sort keys reproducing the previous solver's result order:
-        // horizontal before vertical, then by line, start, and end position.
-        this.sortKeys = [];
-        // Secondary sort keys resolving ties within the same word span: the
-        // previous solver filled cells left to right, trying rack tiles in their
-        // original order (and, for blanks, alphabet characters in config order).
-        this.rankKeys = [];
-        this.blankRackIndex = 0;
-        this.gaddag = gaddag;
-        this.config = config;
-        this.width = board.columnsCount;
-        this.height = board.rowsCount;
-        this.cellsCount = this.width * this.height;
-        this.blankScore = config.blankScore;
-        this.rackSize = config.rackSize;
-        this.digraphs = config.twoCharacterTiles;
-        const alphabet = config.alphabet;
-        if (alphabet.length > MAX_ALPHABET_SIZE) {
-            throw new Error(`Alphabets larger than ${MAX_ALPHABET_SIZE} tiles are not supported`);
-        }
-        if (this.width > MAX_BOARD_DIMENSION || this.height > MAX_BOARD_DIMENSION) {
-            throw new Error(`Boards larger than ${MAX_BOARD_DIMENSION}x${MAX_BOARD_DIMENSION} are not supported`);
-        }
-        this.alphaSize = alphabet.length;
-        this.alphaChars = alphabet;
-        this.alphaLetter1 = new Int32Array(this.alphaSize);
-        this.alphaLetter2 = new Int32Array(this.alphaSize);
-        this.alphaPoints = new Int32Array(this.alphaSize);
-        for (let index = 0; index < this.alphaSize; ++index) {
-            const character = alphabet[index];
-            this.alphaLetter1[index] = gaddag.getLetter(character.charCodeAt(0));
-            this.alphaLetter2[index] = character.length > 1 ? gaddag.getLetter(character.charCodeAt(1)) : 0;
-            this.alphaPoints[index] = config.pointsMap[character] || 0;
-        }
-        const lettersCount = MAX_ALPHABET_SIZE;
-        this.leftAlphaStart = new Int32Array(lettersCount + 1);
-        this.rightAlphaStart = new Int32Array(lettersCount + 1);
-        this.leftAlphaList = new Int32Array(this.alphaSize);
-        this.rightAlphaList = new Int32Array(this.alphaSize);
-        this.alphaSecondLeft = new Int32Array(this.alphaSize);
-        this.alphaSecondRight = new Int32Array(this.alphaSize);
-        for (let pass = 0; pass < 2; ++pass) {
-            for (let index = 0; index < this.alphaSize; ++index) {
-                const letter1 = this.alphaLetter1[index];
-                const letter2 = this.alphaLetter2[index];
-                if (letter1 <= 0 || letter2 < 0) {
-                    continue;
-                }
-                const leftLead = letter2 === 0 ? letter1 : letter2;
-                if (pass === 0) {
-                    ++this.leftAlphaStart[leftLead + 1];
-                    ++this.rightAlphaStart[letter1 + 1];
-                }
-                else {
-                    this.leftAlphaList[this.leftAlphaStart[leftLead]++] = index;
-                    this.rightAlphaList[this.rightAlphaStart[letter1]++] = index;
-                    this.alphaSecondLeft[index] = letter2 === 0 ? 0 : letter1;
-                    this.alphaSecondRight[index] = letter2;
-                }
-            }
-            if (pass === 0) {
-                for (let letter = 0; letter < lettersCount; ++letter) {
-                    this.leftAlphaStart[letter + 1] += this.leftAlphaStart[letter];
-                    this.rightAlphaStart[letter + 1] += this.rightAlphaStart[letter];
-                }
-            }
-        }
-        // The second pass advanced the start offsets by each bucket's size; shift them back.
-        for (let letter = lettersCount; letter > 0; --letter) {
-            this.leftAlphaStart[letter] = this.leftAlphaStart[letter - 1];
-            this.rightAlphaStart[letter] = this.rightAlphaStart[letter - 1];
-        }
-        this.leftAlphaStart[0] = 0;
-        this.rightAlphaStart[0] = 0;
-        this.rackCounts = new Int32Array(this.alphaSize);
-        this.alphaFirstRackIndex = new Int32Array(this.alphaSize).fill(tiles.length);
-        this.blankRackIndex = tiles.length;
-        for (let tileIndex = 0; tileIndex < tiles.length; ++tileIndex) {
-            const tile = tiles[tileIndex];
-            if (tile.isBlank) {
-                if (this.blanksLeft === 0) {
-                    this.blankRackIndex = tileIndex;
-                }
-                ++this.blanksLeft;
-                ++this.rackTotal;
-                continue;
-            }
-            const alphaIndex = alphabet.indexOf(tile.character);
-            if (alphaIndex !== -1) {
-                if (this.rackCounts[alphaIndex] === 0) {
-                    this.alphaFirstRackIndex[alphaIndex] = tileIndex;
-                }
-                ++this.rackCounts[alphaIndex];
-                ++this.rackTotal;
-            }
-        }
-        this.bonusType = new Uint8Array(this.cellsCount);
-        this.bonusMult = new Int32Array(this.cellsCount);
-        this.bonusReq = new Int32Array(this.cellsCount).fill(-1);
-        // Iterate backwards so the first matching bonus wins, mirroring config.getCellBonus.
-        for (let index = config.bonuses.length - 1; index >= 0; --index) {
-            const bonus = config.bonuses[index];
-            if (bonus.x < 0 || bonus.x >= this.width || bonus.y < 0 || bonus.y >= this.height) {
-                continue;
-            }
-            const cellIndex = bonus.y * this.width + bonus.x;
-            if (bonus.type === constants_1.BONUS_CHARACTER) {
-                this.bonusType[cellIndex] = 1;
-            }
-            else if (bonus.type === constants_1.BONUS_WORD) {
-                this.bonusType[cellIndex] = 2;
-            }
-            else {
-                this.bonusType[cellIndex] = 0;
-            }
-            this.bonusMult[cellIndex] = bonus.multiplier;
-            this.bonusReq[cellIndex] = typeof bonus.score === 'number' ? bonus.score : -1;
-        }
-        this.boardFilled = new Uint8Array(this.cellsCount);
-        this.boardChar = Array.from({ length: this.cellsCount });
-        this.boardIsBlank = new Uint8Array(this.cellsCount);
-        this.boardScore = new Int32Array(this.cellsCount);
-        this.boardLetter1 = new Int32Array(this.cellsCount);
-        this.boardLetter2 = new Int32Array(this.cellsCount);
-        this.anchor = new Uint8Array(this.cellsCount);
-        for (let y = 0; y < this.height; ++y) {
-            const row = board.rows[y];
-            for (let x = 0; x < this.width; ++x) {
-                const cell = row[x];
-                if (!cell.isFilled()) {
-                    continue;
-                }
-                const cellIndex = y * this.width + x;
-                const character = cell.tile.character;
-                this.boardIsEmpty = false;
-                this.boardFilled[cellIndex] = 1;
-                this.boardChar[cellIndex] = character;
-                this.boardIsBlank[cellIndex] = cell.tile.isBlank ? 1 : 0;
-                this.boardScore[cellIndex] = cell.tile.isBlank ? this.blankScore : config.pointsMap[character] || 0;
-                this.boardLetter1[cellIndex] = gaddag.getLetter(character.charCodeAt(0));
-                this.boardLetter2[cellIndex] = character.length > 1 ? gaddag.getLetter(character.charCodeAt(1)) : 0;
-            }
-        }
-        for (let y = 0; y < this.height; ++y) {
-            for (let x = 0; x < this.width; ++x) {
-                const cellIndex = y * this.width + x;
-                if (this.boardFilled[cellIndex] === 1) {
-                    continue;
-                }
-                const up = y > 0 && this.boardFilled[cellIndex - this.width] === 1;
-                const down = y < this.height - 1 && this.boardFilled[cellIndex + this.width] === 1;
-                const left = x > 0 && this.boardFilled[cellIndex - 1] === 1;
-                const right = x < this.width - 1 && this.boardFilled[cellIndex + 1] === 1;
-                this.anchor[cellIndex] = up || down || left || right ? 1 : 0;
-            }
-        }
-        this.passFilled = new Uint8Array(this.cellsCount);
-        this.passLetter1 = new Int32Array(this.cellsCount);
-        this.passLetter2 = new Int32Array(this.cellsCount);
-        this.passScore = new Int32Array(this.cellsCount);
-        this.passGlobal = new Int32Array(this.cellsCount);
-        this.passAnchor = new Uint8Array(this.cellsCount);
-        this.maskLo = new Int32Array(this.cellsCount);
-        this.maskHi = new Int32Array(this.cellsCount);
-        this.crossBase = new Int32Array(this.cellsCount);
-        this.hasCross = new Uint8Array(this.cellsCount);
-        const maxLineLength = Math.max(this.width, this.height);
-        this.placedAt = new Int32Array(maxLineLength).fill(-1);
-        this.placedBlankAt = new Uint8Array(maxLineLength);
-    }
-    run() {
-        if (this.rackTotal === 0) {
-            return this.results;
-        }
-        this.runPass(true);
-        this.runPass(false);
-        // Reorder results to match the previous solver's enumeration order, so
-        // that ties (equal points) resolve to the same result in the UI.
-        const order = this.results.map((_, index) => index);
-        const { rankKeys, sortKeys } = this;
-        order.sort((a, b) => {
-            const difference = sortKeys[a] - sortKeys[b];
-            if (difference !== 0) {
-                return difference;
-            }
-            const rankA = rankKeys[a];
-            const rankB = rankKeys[b];
-            if (rankA < rankB) {
-                return -1;
-            }
-            return rankA > rankB ? 1 : 0;
-        });
-        return order.map((resultIndex, index) => {
-            const result = this.results[resultIndex];
-            result.id = index;
-            return result;
-        });
-    }
-    runPass(horizontal) {
-        this.isHorizontal = horizontal;
-        this.linesCount = horizontal ? this.height : this.width;
-        this.lineLength = horizontal ? this.width : this.height;
-        this.setupPass();
-        const centerLine = horizontal ? Math.floor(this.height / 2) : Math.floor(this.width / 2);
-        const centerPos = horizontal ? Math.floor(this.width / 2) : Math.floor(this.height / 2);
-        for (let line = 0; line < this.linesCount; ++line) {
-            this.line = line;
-            this.lineBase = line * this.lineLength;
-            for (let position = 0; position < this.lineLength; ++position) {
-                const isAnchor = this.boardIsEmpty
-                    ? line === centerLine && position === centerPos
-                    : this.passAnchor[this.lineBase + position] === 1;
-                if (!isAnchor) {
-                    continue;
-                }
-                this.anchorPos = position;
-                this.anchorRightOpen = position + 1 >= this.lineLength || this.passFilled[this.lineBase + position + 1] === 0;
-                let limit = 0;
-                const maxLimit = this.rackTotal - 1;
-                for (let left = position - 1; left >= 0 && limit < maxLimit; --left) {
-                    const index = this.lineBase + left;
-                    if (this.passFilled[index] === 1 || (!this.boardIsEmpty && this.passAnchor[index] === 1)) {
-                        break;
-                    }
-                    ++limit;
-                }
-                this.limit = limit;
-                this.generateLeft(position, this.gaddag.rootRef);
-            }
-        }
-    }
-    setupPass() {
-        const { lineLength, linesCount } = this;
-        for (let line = 0; line < linesCount; ++line) {
-            const base = line * lineLength;
-            for (let position = 0; position < lineLength; ++position) {
-                const passIndex = base + position;
-                const globalIndex = this.isHorizontal ? passIndex : position * this.width + line;
-                this.passGlobal[passIndex] = globalIndex;
-                this.passFilled[passIndex] = this.boardFilled[globalIndex];
-                this.passLetter1[passIndex] = this.boardLetter1[globalIndex];
-                this.passLetter2[passIndex] = this.boardLetter2[globalIndex];
-                this.passScore[passIndex] = this.boardScore[globalIndex];
-                this.passAnchor[passIndex] = this.anchor[globalIndex];
-            }
-        }
-        this.computeCrossChecks();
-    }
-    /**
-     * For every empty cell with perpendicular neighbors, computes the set of
-     * placeable tile characters (as a 64-bit mask), the sum of the existing
-     * perpendicular tiles' scores, and the perpendicular word span.
-     */
-    computeCrossChecks() {
-        const { gaddag, lineLength, linesCount } = this;
-        const preLetters = [];
-        const postLetters = [];
-        for (let line = 0; line < linesCount; ++line) {
-            for (let position = 0; position < lineLength; ++position) {
-                const passIndex = line * lineLength + position;
-                if (this.passFilled[passIndex] === 1) {
-                    continue;
-                }
-                const upFilled = line > 0 && this.passFilled[passIndex - lineLength] === 1;
-                const downFilled = line < linesCount - 1 && this.passFilled[passIndex + lineLength] === 1;
-                if (!upFilled && !downFilled) {
-                    this.maskLo[passIndex] = -1;
-                    this.maskHi[passIndex] = -1;
-                    this.hasCross[passIndex] = 0;
-                    continue;
-                }
-                let spanLo = line;
-                while (spanLo > 0 && this.passFilled[(spanLo - 1) * lineLength + position] === 1) {
-                    --spanLo;
-                }
-                let spanHi = line;
-                while (spanHi < linesCount - 1 && this.passFilled[(spanHi + 1) * lineLength + position] === 1) {
-                    ++spanHi;
-                }
-                const hasDigraphs = this.digraphs.length > 0;
-                const previousCharacter = hasDigraphs && spanLo < line ? this.boardChar[this.passGlobal[passIndex - lineLength]] : '';
-                const nextCharacter = hasDigraphs && spanHi > line ? this.boardChar[this.passGlobal[passIndex + lineLength]] : '';
-                preLetters.length = 0;
-                postLetters.length = 0;
-                let base = 0;
-                let lettersValid = true;
-                let crossSpellingValid = true;
-                let previousCrossCharacter = '';
-                for (let crossLine = spanLo; crossLine <= spanHi; ++crossLine) {
-                    if (crossLine === line) {
-                        continue;
-                    }
-                    const crossIndex = crossLine * lineLength + position;
-                    base += this.passScore[crossIndex];
-                    if (hasDigraphs) {
-                        const character = this.boardChar[this.passGlobal[crossIndex]];
-                        if (previousCrossCharacter !== '' && this.digraphs.includes(previousCrossCharacter + character)) {
-                            crossSpellingValid = false;
-                        }
-                        previousCrossCharacter = crossLine === line - 1 ? '' : character;
-                    }
-                    const letters = crossLine < line ? preLetters : postLetters;
-                    const letter1 = this.passLetter1[crossIndex];
-                    const letter2 = this.passLetter2[crossIndex];
-                    if (letter1 <= 0 || letter2 < 0) {
-                        lettersValid = false;
-                    }
-                    letters.push(letter1);
-                    if (letter2 !== 0) {
-                        letters.push(letter2);
-                    }
-                }
-                this.hasCross[passIndex] = 1;
-                this.crossBase[passIndex] = base;
-                let maskLo = 0;
-                let maskHi = 0;
-                if (lettersValid && crossSpellingValid) {
-                    // The perpendicular word is pre + tile + post; its pure-reverse GADDAG
-                    // path is rev(post), rev(tile characters), rev(pre). rev(post) is shared
-                    // across all candidate tiles.
-                    let postRef = gaddag.rootRef;
-                    for (let index = postLetters.length - 1; index >= 0 && postRef !== 0; --index) {
-                        postRef = gaddag.getArc(postRef, postLetters[index]);
-                    }
-                    if (postRef !== 0) {
-                        for (let alpha = 0; alpha < this.alphaSize; ++alpha) {
-                            const letter1 = this.alphaLetter1[alpha];
-                            const letter2 = this.alphaLetter2[alpha];
-                            if (letter1 <= 0 || letter2 < 0) {
-                                continue;
-                            }
-                            if (hasDigraphs && this.spellsDigraphWithNeighbor(alpha, previousCharacter, nextCharacter)) {
-                                continue;
-                            }
-                            let ref = postRef;
-                            if (letter2 !== 0) {
-                                ref = gaddag.getArc(ref, letter2);
-                                if (ref === 0) {
-                                    continue;
-                                }
-                            }
-                            ref = gaddag.getArc(ref, letter1);
-                            for (let index = preLetters.length - 1; index >= 0 && ref !== 0; --index) {
-                                ref = gaddag.getArc(ref, preLetters[index]);
-                            }
-                            if ((ref & 1) === 1) {
-                                if (alpha < 32) {
-                                    maskLo |= 1 << alpha;
-                                }
-                                else {
-                                    maskHi |= 1 << (alpha - 32);
-                                }
-                            }
-                        }
-                    }
-                }
-                this.maskLo[passIndex] = maskLo;
-                this.maskHi[passIndex] = maskHi;
-            }
-        }
-    }
-    /**
-     * A digraph must be played as its single tile, so a candidate that would
-     * spell a digraph with the adjacent perpendicular tile is not placeable.
-     * {@link record} enforces the same rule along the main word.
-     */
-    spellsDigraphWithNeighbor(alpha, previousCharacter, nextCharacter) {
-        const character = this.alphaChars[alpha];
-        return ((previousCharacter !== '' && this.digraphs.includes(previousCharacter + character)) ||
-            (nextCharacter !== '' && this.digraphs.includes(character + nextCharacter)));
-    }
-    isOpen(position) {
-        return position < 0 || position >= this.lineLength || this.passFilled[this.lineBase + position] === 0;
-    }
-    generateLeft(position, ref) {
-        const { gaddag, lineBase } = this;
-        const inBounds = position >= 0;
-        const passIndex = lineBase + position;
-        if (inBounds && this.passFilled[passIndex] === 1) {
-            // Read an existing tile (reversed character order when moving left).
-            const letter2 = this.passLetter2[passIndex];
-            let nextRef = ref;
-            if (letter2 !== 0) {
-                nextRef = letter2 > 0 ? gaddag.getArc(nextRef, letter2) : 0;
-                if (nextRef === 0) {
-                    return;
-                }
-            }
-            const letter1 = this.passLetter1[passIndex];
-            nextRef = letter1 > 0 ? gaddag.getArc(nextRef, letter1) : 0;
-            if (nextRef === 0) {
-                return;
-            }
-            this.recordLeftIfWord(nextRef, position);
-            this.generateLeft(position - 1, nextRef);
-            return;
-        }
-        // The cell at `position` is empty or off-board, so the left part may stop here.
-        const separatorRef = gaddag.getArc(ref, gaddag_1.SEPARATOR);
-        if (separatorRef !== 0) {
-            this.leftMost = position + 1;
-            this.generateRight(this.anchorPos + 1, separatorRef);
-        }
-        if (!inBounds || (position !== this.anchorPos && this.anchorPos - position > this.limit)) {
-            return;
-        }
-        this.placeAt(position, passIndex, ref, true);
-    }
-    generateRight(position, ref) {
-        const { gaddag, lineBase } = this;
-        const inBounds = position < this.lineLength;
-        const passIndex = lineBase + position;
-        if (inBounds && this.passFilled[passIndex] === 1) {
-            const letter1 = this.passLetter1[passIndex];
-            let nextRef = letter1 > 0 ? gaddag.getArc(ref, letter1) : 0;
-            if (nextRef === 0) {
-                return;
-            }
-            const letter2 = this.passLetter2[passIndex];
-            if (letter2 !== 0) {
-                nextRef = letter2 > 0 ? gaddag.getArc(nextRef, letter2) : 0;
-                if (nextRef === 0) {
-                    return;
-                }
-            }
-            if ((nextRef & 1) === 1 && this.isOpen(position + 1)) {
-                this.record(this.leftMost, position);
-            }
-            this.generateRight(position + 1, nextRef);
-            return;
-        }
-        if (!inBounds) {
-            return;
-        }
-        this.placeAt(position, passIndex, ref, false);
-    }
-    /**
-     * Tries every rack tile (and blank interpretation) at an empty cell,
-     * recursing further. Iterates the state's arcs instead of the alphabet:
-     * deep GADDAG states have very few arcs, so this is much cheaper than
-     * probing every letter.
-     */
-    placeAt(position, passIndex, ref, leftward) {
-        let arcIndex = ref >>> 1;
-        if (arcIndex === 0 || this.placedCount >= this.rackTotal) {
-            return;
-        }
-        const maskLo = this.maskLo[passIndex];
-        const maskHi = this.maskHi[passIndex];
-        if (maskLo === 0 && maskHi === 0) {
-            return;
-        }
-        const { gaddag } = this;
-        const labels = gaddag.arcLabels;
-        const targets = gaddag.arcTargets;
-        const alphaStart = leftward ? this.leftAlphaStart : this.rightAlphaStart;
-        const alphaList = leftward ? this.leftAlphaList : this.rightAlphaList;
-        const alphaSecond = leftward ? this.alphaSecondLeft : this.alphaSecondRight;
-        // Restored by every recursive call, so stable across loop iterations.
-        const hasBlank = this.blanksLeft > 0;
-        for (;;) {
-            const label = labels[arcIndex];
-            const letter = label & gaddag_1.LETTER_MASK;
-            if (letter !== gaddag_1.SEPARATOR) {
-                const target = targets[arcIndex];
-                const alphasEnd = alphaStart[letter + 1];
-                for (let alphaIndex = alphaStart[letter]; alphaIndex < alphasEnd; ++alphaIndex) {
-                    const alpha = alphaList[alphaIndex];
-                    const hasTile = this.rackCounts[alpha] > 0;
-                    if (!hasTile && !hasBlank) {
-                        continue;
-                    }
-                    const allowed = alpha < 32 ? (maskLo & (1 << alpha)) !== 0 : (maskHi & (1 << (alpha - 32))) !== 0;
-                    if (!allowed) {
-                        continue;
-                    }
-                    const second = alphaSecond[alpha];
-                    const nextRef = second === 0 ? target : gaddag.getArc(target, second);
-                    if (nextRef === 0) {
-                        continue;
-                    }
-                    if (hasTile) {
-                        --this.rackCounts[alpha];
-                        this.pushPlacement(position, alpha, false);
-                        this.afterPlacement(position, nextRef, leftward);
-                        this.popPlacement(position);
-                        ++this.rackCounts[alpha];
-                    }
-                    if (hasBlank) {
-                        --this.blanksLeft;
-                        this.pushPlacement(position, alpha, true);
-                        this.afterPlacement(position, nextRef, leftward);
-                        this.popPlacement(position);
-                        ++this.blanksLeft;
-                    }
-                }
-            }
-            if (label >= gaddag_1.LAST_ARC_FLAG) {
-                return;
-            }
-            ++arcIndex;
-        }
-    }
-    pushPlacement(position, alpha, isBlank) {
-        this.placedAt[position] = alpha;
-        this.placedBlankAt[position] = isBlank ? 1 : 0;
-        ++this.placedCount;
-    }
-    popPlacement(position) {
-        this.placedAt[position] = -1;
-        --this.placedCount;
-    }
-    afterPlacement(position, ref, leftward) {
-        if (leftward) {
-            this.recordLeftIfWord(ref, position);
-            this.generateLeft(position - 1, ref);
-        }
-        else {
-            if ((ref & 1) === 1 && this.isOpen(position + 1)) {
-                this.record(this.leftMost, position);
-            }
-            this.generateRight(position + 1, ref);
-        }
-    }
-    /**
-     * Records a word that ends at the anchor (a pure reversed-word GADDAG path).
-     * Words spanning a single cell are skipped: a lone tile's word is the
-     * perpendicular one, generated by the other pass.
-     */
-    recordLeftIfWord(ref, position) {
-        if ((ref & 1) === 1 && this.anchorRightOpen && position < this.anchorPos && this.isOpen(position - 1)) {
-            this.record(position, this.anchorPos);
-        }
-    }
-    record(startPosition, endPosition) {
-        const { lineBase } = this;
-        if (this.digraphs.length > 0 && this.hasInvalidDigraph(startPosition, endPosition)) {
-            return;
-        }
-        if (this.placedCount === 1) {
-            let placedPosition = startPosition;
-            while (this.passFilled[lineBase + placedPosition] === 1) {
-                ++placedPosition;
-            }
-            const key = this.passGlobal[lineBase + placedPosition] * 128 +
-                this.placedAt[placedPosition] * 2 +
-                this.placedBlankAt[placedPosition];
-            if (this.seenSingleTiles.has(key)) {
-                return;
-            }
-            this.seenSingleTiles.add(key);
-        }
-        // Score and emit ResultJson in a single pass.
-        let mainScore = 0;
-        let wordMultiplier = 1;
-        let collisionsScore = 0;
-        const tiles = [];
-        const blankIndices = [];
-        for (let position = startPosition; position <= endPosition; ++position) {
-            const passIndex = lineBase + position;
-            if (this.passFilled[passIndex] === 1) {
-                mainScore += this.passScore[passIndex];
-                continue;
-            }
-            const globalIndex = this.passGlobal[passIndex];
-            const alpha = this.placedAt[position];
-            const isBlank = this.placedBlankAt[position] === 1;
-            const tileScore = isBlank ? this.blankScore : this.alphaPoints[alpha];
-            let characterMultiplier = 1;
-            let cellWordMultiplier = 1;
-            const bonusType = this.bonusType[globalIndex];
-            if (bonusType === 1) {
-                const requirement = this.bonusReq[globalIndex];
-                if (requirement === -1 || requirement === this.alphaPoints[alpha]) {
-                    characterMultiplier = this.bonusMult[globalIndex];
-                }
-            }
-            else if (bonusType === 2) {
-                cellWordMultiplier = this.bonusMult[globalIndex];
-            }
-            mainScore += tileScore * characterMultiplier;
-            wordMultiplier *= cellWordMultiplier;
-            if (isBlank) {
-                blankIndices.push(tiles.length);
-            }
-            tiles.push(this.alphaChars[alpha]);
-            if (this.hasCross[passIndex] === 1) {
-                collisionsScore += (this.crossBase[passIndex] + tileScore * characterMultiplier) * cellWordMultiplier;
-            }
-        }
-        let points = mainScore * wordMultiplier + collisionsScore;
-        if (this.placedCount === this.rackSize) {
-            const bingo = this.config.bingo;
-            if ((0, types_1.isScoreBingo)(bingo)) {
-                points += bingo.score;
-            }
-            else if ((0, types_1.isMultiplierBingo)(bingo)) {
-                points = mainScore * wordMultiplier * bingo.multiplier + collisionsScore;
-            }
-        }
-        let rankKey = '';
-        for (let position = startPosition; position <= endPosition; ++position) {
-            if (this.passFilled[lineBase + position] === 0) {
-                const alpha = this.placedAt[position];
-                const isBlank = this.placedBlankAt[position] === 1;
-                const rackIndex = isBlank ? this.blankRackIndex : this.alphaFirstRackIndex[alpha];
-                rankKey += String.fromCharCode(rackIndex * 64 + (isBlank ? alpha : 0));
-            }
-        }
-        this.sortKeys.push((this.isHorizontal ? 0 : 1 << 20) | (this.line << 15) | (startPosition << 8) | endPosition);
-        this.rankKeys.push(rankKey);
-        this.results.push({
-            blankIndices,
-            id: this.results.length,
-            isHorizontal: this.isHorizontal,
-            points,
-            tiles,
-            x: this.isHorizontal ? startPosition : this.line,
-            y: this.isHorizontal ? this.line : startPosition,
-        });
-    }
-    hasInvalidDigraph(startPosition, endPosition) {
-        let previousCharacter = this.characterAt(startPosition);
-        for (let position = startPosition + 1; position <= endPosition; ++position) {
-            const character = this.characterAt(position);
-            if (this.digraphs.includes(previousCharacter + character)) {
-                return true;
-            }
-            previousCharacter = character;
-        }
-        return false;
-    }
-    characterAt(position) {
-        const passIndex = this.lineBase + position;
-        if (this.passFilled[passIndex] === 1) {
-            return this.boardChar[this.passGlobal[passIndex]];
-        }
-        return this.alphaChars[this.placedAt[position]];
-    }
-}
-exports.MoveGenerator = MoveGenerator;

package/packages/solver/build/index.d.ts

@@ -1 +0,0 @@
-export { solve } from './solve';