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

package/packages/types/build/Result.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = void 0;
+const constants_1 = require("@scrabble-solver/constants");
+const lib_1 = require("./lib");
+class Result {
+    constructor({ cells, id, collisions, points, }) {
+        const tiles = getTiles(cells);
+        this.blanksCount = getBlanks(tiles).length;
+        this.cells = cells;
+        this.collisions = collisions;
+        this.consonantsCount = getConsonants(tiles).length;
+        this.id = id;
+        this.length = cells.length;
+        this.points = points;
+        this.pointsRatio = getPointsRatio(tiles, points);
+        this.tiles = tiles;
+        this.tilesCount = tiles.length;
+        this.vowelsCount = getVowels(tiles).length;
+        this.word = getWord(cells);
+        this.words = getWords(cells, collisions);
+        this.wordsCount = 1 + this.collisions.length;
+    }
+    toJson() {
+        const placed = this.cells.filter((cell) => cell.isEmpty);
+        return {
+            blankIndices: placed.flatMap((cell, index) => (cell.tile.isBlank ? [index] : [])),
+            id: this.id,
+            isHorizontal: this.isHorizontal(),
+            points: this.points,
+            tiles: placed.map((cell) => cell.tile.character),
+            x: this.cells[0].x,
+            y: this.cells[0].y,
+        };
+    }
+    isHorizontal() {
+        return this.cells[0].y === this.cells[1].y;
+    }
+    isVertical() {
+        return this.cells[0].x === this.cells[1].x;
+    }
+}
+exports.Result = Result;
+Result.fromJson = (json, board) => {
+    const cells = (0, lib_1.getCells)(board, json);
+    return new Result({
+        cells,
+        collisions: (0, lib_1.getCollisions)(board, cells, json.isHorizontal),
+        id: json.id,
+        points: json.points,
+    });
+};
+const getBlanks = (tiles) => tiles.filter(({ isBlank }) => isBlank);
+const getConsonants = (tiles) => tiles.filter(isConsonant);
+const getVowels = (tiles) => tiles.filter(isVowel);
+const getPointsRatio = (tiles, points) => points / tiles.length;
+const getTiles = (cells) => cells.filter(({ isEmpty }) => isEmpty).map(({ tile }) => tile);
+const getWord = (cells) => cells.reduce((word, cell) => word + cell.toString(), '');
+const getWords = (cells, collisions) => [cells, ...collisions].map(getWord);
+const isConsonant = ({ character, isBlank }) => constants_1.CONSONANTS.includes(character) && !isBlank;
+const isVowel = ({ character, isBlank }) => constants_1.VOWELS.includes(character) && !isBlank;

package/packages/types/build/ResultJson.d.ts

@@ -0,0 +1,9 @@
+export interface ResultJson {
+    blankIndices: number[];
+    id: number;
+    isHorizontal: boolean;
+    points: number;
+    tiles: string[];
+    x: number;
+    y: number;
+}

package/packages/types/build/ResultJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/types/build/ShowCoordinates.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 'alternative' means columns have numbers and rows have letters
+ * 'original' means columns have letters and rows have numbers
+ */
+export type ShowCoordinates = 'alternative' | 'original';

package/packages/types/build/ShowCoordinates.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/types/build/TextDirection.d.ts

@@ -0,0 +1 @@
+export type TextDirection = 'ltr' | 'rtl';

package/packages/types/build/TextDirection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/types/build/Tile.d.ts

@@ -0,0 +1,15 @@
+import { type TileJson } from './TileJson';
+export declare class Tile {
+    static fromJson: (json: TileJson | null) => Tile;
+    static readonly Null: Tile;
+    character: string;
+    isBlank: boolean;
+    constructor({ character, isBlank }: {
+        character: string;
+        isBlank?: boolean;
+    });
+    clone(): Tile;
+    equals(other: Tile): boolean;
+    toJson(): TileJson | null;
+    toString(): string;
+}

package/packages/types/build/Tile.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tile = void 0;
+const constants_1 = require("@scrabble-solver/constants");
+class Tile {
+    constructor({ character, isBlank = false }) {
+        this.character = character;
+        this.isBlank = isBlank;
+    }
+    clone() {
+        return new Tile({
+            character: this.character,
+            isBlank: this.isBlank,
+        });
+    }
+    equals(other) {
+        return this.character === other.character && this.isBlank === other.isBlank;
+    }
+    toJson() {
+        return {
+            character: this.character,
+            isBlank: this.isBlank,
+        };
+    }
+    toString() {
+        return this.character;
+    }
+}
+exports.Tile = Tile;
+Tile.fromJson = (json) => {
+    if (!json) {
+        return Tile.Null;
+    }
+    return new Tile({
+        character: json.character,
+        isBlank: json.isBlank,
+    });
+};
+Tile.Null = Object.freeze({
+    character: constants_1.EMPTY_CELL,
+    isBlank: false,
+    clone: () => Tile.Null,
+    equals: (other) => other === Tile.Null,
+    toJson: () => null,
+    toString: () => constants_1.EMPTY_CELL,
+});

package/packages/types/build/TileConfig.d.ts

@@ -0,0 +1,5 @@
+export interface TileConfig {
+    character: string;
+    count?: number;
+    score: number;
+}

package/packages/types/build/TileConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/types/build/TileJson.d.ts

@@ -0,0 +1,4 @@
+export interface TileJson {
+    character: string;
+    isBlank: boolean;
+}

package/packages/types/build/TileJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/packages/types/build/WordBonus.d.ts

@@ -0,0 +1,6 @@
+import { Bonus } from './Bonus';
+import { type BonusValue } from './BonusValue';
+export declare class WordBonus extends Bonus {
+    readonly type = "BONUS_WORD";
+    get value(): BonusValue;
+}

package/packages/types/build/WordBonus.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WordBonus = void 0;
+const constants_1 = require("@scrabble-solver/constants");
+const Bonus_1 = require("./Bonus");
+class WordBonus extends Bonus_1.Bonus {
+    constructor() {
+        super(...arguments);
+        this.type = constants_1.BONUS_WORD;
+    }
+    get value() {
+        return {
+            characterMultiplier: 1,
+            wordMultiplier: this.multiplier,
+        };
+    }
+}
+exports.WordBonus = WordBonus;

package/packages/types/build/WordDefinition.d.ts

@@ -0,0 +1,17 @@
+import { type WordDefinitionJson } from './WordDefinitionJson';
+export declare class WordDefinition {
+    static fromJson: (json: WordDefinitionJson | null) => WordDefinition;
+    static readonly Null: WordDefinition;
+    readonly definitions: string[];
+    /**
+     * Does the word have an entry in a corresponding online dictionary?
+     */
+    readonly exists: boolean;
+    /**
+     * Can the word be legally used in the game?
+     */
+    readonly isAllowed: boolean;
+    readonly word: string;
+    constructor({ definitions, exists, isAllowed, word }: WordDefinitionJson);
+    toJson(): WordDefinitionJson | null;
+}

package/packages/types/build/WordDefinition.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WordDefinition = void 0;
+class WordDefinition {
+    constructor({ definitions, exists, isAllowed, word }) {
+        this.definitions = definitions;
+        this.exists = exists;
+        this.isAllowed = isAllowed;
+        this.word = word;
+    }
+    toJson() {
+        return {
+            definitions: this.definitions,
+            exists: this.exists,
+            isAllowed: this.isAllowed,
+            word: this.word,
+        };
+    }
+}
+exports.WordDefinition = WordDefinition;
+WordDefinition.fromJson = (json) => {
+    if (!json) {
+        return WordDefinition.Null;
+    }
+    return new WordDefinition({
+        definitions: json.definitions,
+        exists: json.exists,
+        isAllowed: json.isAllowed,
+        word: json.word,
+    });
+};
+WordDefinition.Null = Object.freeze({
+    definitions: [],
+    exists: false,
+    isAllowed: false,
+    word: '',
+    toJson: () => null,
+});

package/packages/types/build/WordDefinitionJson.d.ts

@@ -0,0 +1,12 @@
+export interface WordDefinitionJson {
+    definitions: string[];
+    /**
+     * Does the word have an entry in a corresponding online dictionary?
+     */
+    exists: boolean;
+    /**
+     * Can the word be legally used in the game?
+     */
+    isAllowed: boolean;
+    word: string;
+}

package/packages/types/build/WordDefinitionJson.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,29 @@
+export { Bingo } from './Bingo';
+export { Board } from './Board';
+export { BoardJson } from './BoardJson';
+export { BoardWord } from './BoardWord';
+export { Bonus } from './Bonus';
+export { BonusJson } from './BonusJson';
+export { BonusValue } from './BonusValue';
+export { Cell } from './Cell';
+export { CellJson } from './CellJson';
+export { CharacterBonus } from './CharacterBonus';
+export { Collision } from './Collision';
+export { Config } from './Config';
+export { ConfigJson } from './ConfigJson';
+export { Dictionary } from './Dictionary';
+export { Direction } from './Direction';
+export { Game } from './Game';
+export { isSameBoardWord } from './lib';
+export { Locale } from './Locale';
+export { Result } from './Result';
+export { ResultJson } from './ResultJson';
+export { ShowCoordinates } from './ShowCoordinates';
+export { TextDirection } from './TextDirection';
+export { Tile } from './Tile';
+export { TileConfig } from './TileConfig';
+export { TileJson } from './TileJson';
+export { isBingo, isBoardJson, isCellJson, isError, isGame, isLocale, isMultiplierBingo, isObject, isScoreBingo, isTileJson, } from './type-guards';
+export { WordBonus } from './WordBonus';
+export { WordDefinition } from './WordDefinition';
+export { WordDefinitionJson } from './WordDefinitionJson';

package/packages/types/build/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WordDefinition = exports.WordBonus = exports.isTileJson = exports.isScoreBingo = exports.isObject = exports.isMultiplierBingo = exports.isLocale = exports.isGame = exports.isError = exports.isCellJson = exports.isBoardJson = exports.isBingo = exports.Tile = exports.Result = exports.Locale = exports.isSameBoardWord = exports.Game = exports.Config = exports.CharacterBonus = exports.Cell = exports.Bonus = exports.Board = void 0;
+var Board_1 = require("./Board");
+Object.defineProperty(exports, "Board", { enumerable: true, get: function () { return Board_1.Board; } });
+var Bonus_1 = require("./Bonus");
+Object.defineProperty(exports, "Bonus", { enumerable: true, get: function () { return Bonus_1.Bonus; } });
+var Cell_1 = require("./Cell");
+Object.defineProperty(exports, "Cell", { enumerable: true, get: function () { return Cell_1.Cell; } });
+var CharacterBonus_1 = require("./CharacterBonus");
+Object.defineProperty(exports, "CharacterBonus", { enumerable: true, get: function () { return CharacterBonus_1.CharacterBonus; } });
+var Config_1 = require("./Config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return Config_1.Config; } });
+var Game_1 = require("./Game");
+Object.defineProperty(exports, "Game", { enumerable: true, get: function () { return Game_1.Game; } });
+var lib_1 = require("./lib");
+Object.defineProperty(exports, "isSameBoardWord", { enumerable: true, get: function () { return lib_1.isSameBoardWord; } });
+var Locale_1 = require("./Locale");
+Object.defineProperty(exports, "Locale", { enumerable: true, get: function () { return Locale_1.Locale; } });
+var Result_1 = require("./Result");
+Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return Result_1.Result; } });
+var Tile_1 = require("./Tile");
+Object.defineProperty(exports, "Tile", { enumerable: true, get: function () { return Tile_1.Tile; } });
+var type_guards_1 = require("./type-guards");
+Object.defineProperty(exports, "isBingo", { enumerable: true, get: function () { return type_guards_1.isBingo; } });
+Object.defineProperty(exports, "isBoardJson", { enumerable: true, get: function () { return type_guards_1.isBoardJson; } });
+Object.defineProperty(exports, "isCellJson", { enumerable: true, get: function () { return type_guards_1.isCellJson; } });
+Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return type_guards_1.isError; } });
+Object.defineProperty(exports, "isGame", { enumerable: true, get: function () { return type_guards_1.isGame; } });
+Object.defineProperty(exports, "isLocale", { enumerable: true, get: function () { return type_guards_1.isLocale; } });
+Object.defineProperty(exports, "isMultiplierBingo", { enumerable: true, get: function () { return type_guards_1.isMultiplierBingo; } });
+Object.defineProperty(exports, "isObject", { enumerable: true, get: function () { return type_guards_1.isObject; } });
+Object.defineProperty(exports, "isScoreBingo", { enumerable: true, get: function () { return type_guards_1.isScoreBingo; } });
+Object.defineProperty(exports, "isTileJson", { enumerable: true, get: function () { return type_guards_1.isTileJson; } });
+var WordBonus_1 = require("./WordBonus");
+Object.defineProperty(exports, "WordBonus", { enumerable: true, get: function () { return WordBonus_1.WordBonus; } });
+var WordDefinition_1 = require("./WordDefinition");
+Object.defineProperty(exports, "WordDefinition", { enumerable: true, get: function () { return WordDefinition_1.WordDefinition; } });

package/packages/types/build/lib/getBoardWords.d.ts

@@ -0,0 +1,3 @@
+import { type Board } from '../Board';
+import { type BoardWord } from '../BoardWord';
+export declare function getBoardWords(board: Board): BoardWord[];

package/packages/types/build/lib/getBoardWords.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBoardWords = getBoardWords;
+const getWordsInRows_1 = require("./getWordsInRows");
+const transpose_1 = require("./transpose");
+function getBoardWords(board) {
+    const horizontalWords = (0, getWordsInRows_1.getWordsInRows)(board.rows, 'horizontal');
+    const verticalWords = (0, getWordsInRows_1.getWordsInRows)((0, transpose_1.transpose)(board.rows), 'vertical');
+    return [...horizontalWords, ...verticalWords];
+}

package/packages/types/build/lib/getCells.d.ts

@@ -0,0 +1,4 @@
+import { type Board } from '../Board';
+import { type Cell } from '../Cell';
+import { type ResultJson } from '../ResultJson';
+export declare function getCells(board: Board, json: ResultJson): Cell[];

package/packages/types/build/lib/getCells.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCells = getCells;
+const getPlacedCell_1 = require("./getPlacedCell");
+function getCells(board, json) {
+    const stepX = json.isHorizontal ? 1 : 0;
+    const stepY = json.isHorizontal ? 0 : 1;
+    const cells = [];
+    let placedIndex = 0;
+    let { x, y } = json;
+    while (y < board.rowsCount && x < board.columnsCount) {
+        const boardCell = board.rows[y][x];
+        if (boardCell.isFilled()) {
+            cells.push(boardCell.clone());
+        }
+        else if (placedIndex < json.tiles.length) {
+            cells.push((0, getPlacedCell_1.getPlacedCell)(json, placedIndex, x, y));
+            placedIndex += 1;
+        }
+        else {
+            break;
+        }
+        x += stepX;
+        y += stepY;
+    }
+    return cells;
+}

package/packages/types/build/lib/getCollidingWords.d.ts

@@ -0,0 +1,3 @@
+import { type Board } from '../Board';
+import { type BoardWord } from '../BoardWord';
+export declare function getCollidingWords(board: Board, word: BoardWord): BoardWord[];

package/packages/types/build/lib/getCollidingWords.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCollidingWords = getCollidingWords;
+const getWordThrough_1 = require("./getWordThrough");
+function getCollidingWords(board, word) {
+    const isHorizontal = word.direction === 'horizontal';
+    const collidingDirection = isHorizontal ? 'vertical' : 'horizontal';
+    const collidingWords = [];
+    let { x, y } = word;
+    while (x < board.columnsCount && y < board.rowsCount && !board.rows[y][x].isEmpty) {
+        const collidingWord = (0, getWordThrough_1.getWordThrough)(board, x, y, collidingDirection);
+        if (collidingWord) {
+            collidingWords.push(collidingWord);
+        }
+        x += isHorizontal ? 1 : 0;
+        y += isHorizontal ? 0 : 1;
+    }
+    return collidingWords;
+}

package/packages/types/build/lib/getCollision.d.ts

@@ -0,0 +1,3 @@
+import { type Board } from '../Board';
+import { type Cell } from '../Cell';
+export declare function getCollision(placed: Cell, board: Board, isHorizontal: boolean): Cell[];

package/packages/types/build/lib/getCollision.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCollision = getCollision;
+function getCollision(placed, board, isHorizontal) {
+    const stepX = isHorizontal ? 0 : 1;
+    const stepY = isHorizontal ? 1 : 0;
+    let x = placed.x - stepX;
+    let y = placed.y - stepY;
+    while (x >= 0 && y >= 0 && board.rows[y][x].isFilled()) {
+        x -= stepX;
+        y -= stepY;
+    }
+    x += stepX;
+    y += stepY;
+    const collision = [];
+    while (y < board.rowsCount && x < board.columnsCount) {
+        if (x === placed.x && y === placed.y) {
+            collision.push(placed);
+        }
+        else {
+            const boardCell = board.rows[y][x];
+            if (!boardCell.isFilled()) {
+                break;
+            }
+            collision.push(boardCell.clone());
+        }
+        x += stepX;
+        y += stepY;
+    }
+    return collision;
+}

package/packages/types/build/lib/getCollisions.d.ts

@@ -0,0 +1,3 @@
+import { type Board } from '../Board';
+import { type Cell } from '../Cell';
+export declare function getCollisions(board: Board, cells: Cell[], isHorizontal: boolean): Cell[][];

package/packages/types/build/lib/getCollisions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCollisions = getCollisions;
+const getCollision_1 = require("./getCollision");
+function getCollisions(board, cells, isHorizontal) {
+    const collisions = [];
+    for (const cell of cells) {
+        if (cell.isFilled()) {
+            continue;
+        }
+        const collision = (0, getCollision_1.getCollision)(cell, board, isHorizontal);
+        if (collision.length > 1) {
+            collisions.push(collision);
+        }
+    }
+    return collisions;
+}

package/packages/types/build/lib/getPlacedCell.d.ts

@@ -0,0 +1,3 @@
+import { Cell } from '../Cell';
+import { type ResultJson } from '../ResultJson';
+export declare function getPlacedCell(json: ResultJson, placedIndex: number, x: number, y: number): Cell;

package/packages/types/build/lib/getPlacedCell.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlacedCell = getPlacedCell;
+const Cell_1 = require("../Cell");
+const Tile_1 = require("../Tile");
+function getPlacedCell(json, placedIndex, x, y) {
+    const character = json.tiles[placedIndex];
+    const isBlank = json.blankIndices.includes(placedIndex);
+    return new Cell_1.Cell({ isEmpty: true, tile: new Tile_1.Tile({ character, isBlank }), x, y });
+}

package/packages/types/build/lib/getWordThrough.d.ts

@@ -0,0 +1,4 @@
+import { type Board } from '../Board';
+import { type BoardWord } from '../BoardWord';
+import { type Direction } from '../Direction';
+export declare function getWordThrough(board: Board, x: number, y: number, direction: Direction): BoardWord | undefined;

package/packages/types/build/lib/getWordThrough.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWordThrough = getWordThrough;
+const toBoardWord_1 = require("./toBoardWord");
+function getWordThrough(board, x, y, direction) {
+    const stepX = direction === 'horizontal' ? 1 : 0;
+    const stepY = direction === 'horizontal' ? 0 : 1;
+    let startX = x;
+    let startY = y;
+    while (startX - stepX >= 0 && startY - stepY >= 0 && !board.rows[startY - stepY][startX - stepX].isEmpty) {
+        startX -= stepX;
+        startY -= stepY;
+    }
+    const cells = [];
+    let cellX = startX;
+    let cellY = startY;
+    while (cellX < board.columnsCount && cellY < board.rowsCount && !board.rows[cellY][cellX].isEmpty) {
+        cells.push(board.rows[cellY][cellX]);
+        cellX += stepX;
+        cellY += stepY;
+    }
+    return cells.length > 1 ? (0, toBoardWord_1.toBoardWord)(cells, direction) : undefined;
+}

package/packages/types/build/lib/getWordsInRows.d.ts

@@ -0,0 +1,8 @@
+import { type BoardWord } from '../BoardWord';
+import { type Cell } from '../Cell';
+import { type Direction } from '../Direction';
+/**
+ * Cells in transposed rows keep their original coordinates,
+ * so the first cell of a run is the word's start in both directions.
+ */
+export declare function getWordsInRows(cells: Cell[][], direction: Direction): BoardWord[];

package/packages/types/build/lib/getWordsInRows.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWordsInRows = getWordsInRows;
+const toBoardWord_1 = require("./toBoardWord");
+/**
+ * Cells in transposed rows keep their original coordinates,
+ * so the first cell of a run is the word's start in both directions.
+ */
+function getWordsInRows(cells, direction) {
+    const words = [];
+    for (const row of cells) {
+        let currentWord = [];
+        for (const cell of row) {
+            if (!cell.isEmpty) {
+                currentWord.push(cell);
+            }
+            else if (currentWord.length > 0) {
+                if (currentWord.length > 1) {
+                    words.push((0, toBoardWord_1.toBoardWord)(currentWord, direction));
+                }
+                currentWord = [];
+            }
+        }
+        if (currentWord.length > 1) {
+            words.push((0, toBoardWord_1.toBoardWord)(currentWord, direction));
+        }
+    }
+    return words;
+}

package/packages/types/build/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './getBoardWords';
+export * from './getCells';
+export * from './getCollidingWords';
+export * from './getCollisions';
+export * from './isSameBoardWord';

package/packages/types/build/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./getBoardWords"), exports);
+__exportStar(require("./getCells"), exports);
+__exportStar(require("./getCollidingWords"), exports);
+__exportStar(require("./getCollisions"), exports);
+__exportStar(require("./isSameBoardWord"), exports);

package/packages/types/build/lib/isSameBoardWord.d.ts

@@ -0,0 +1,2 @@
+import { type BoardWord } from '../BoardWord';
+export declare function isSameBoardWord(a: BoardWord, b: BoardWord): boolean;

package/packages/types/build/lib/isSameBoardWord.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSameBoardWord = isSameBoardWord;
+function isSameBoardWord(a, b) {
+    return a.direction === b.direction && a.x === b.x && a.y === b.y;
+}

package/packages/types/build/lib/toBoardWord.d.ts

@@ -0,0 +1,4 @@
+import { type BoardWord } from '../BoardWord';
+import { type Cell } from '../Cell';
+import { type Direction } from '../Direction';
+export declare function toBoardWord(cells: Cell[], direction: Direction): BoardWord;

package/packages/types/build/lib/toBoardWord.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBoardWord = toBoardWord;
+function toBoardWord(cells, direction) {
+    return {
+        direction,
+        word: cells.map((cell) => cell.tile.character).join(''),
+        x: cells[0].x,
+        y: cells[0].y,
+    };
+}

package/packages/types/build/lib/transpose.d.ts

@@ -0,0 +1 @@
+export declare function transpose<T>(array: T[][]): T[][];