scrabble-solver 2.8.8 → 2.8.10

package/packages/scrabble-solver/src/state/slices/dictionarySlice.ts

@@ -14,27 +14,21 @@ const dictionarySlice = createSlice({
     reset: () => dictionaryInitialState,
 
     submit: (state) => {
-      return {
-        ...state,
-        isLoading: true,
-        results: dictionaryInitialState.results,
-      };
+      const error = dictionaryInitialState.error;
+      const results = dictionaryInitialState.results;
+      return { ...state, error, isLoading: true, results };
     },
 
-    submitFailure: (state) => {
-      return {
-        ...state,
-        isLoading: false,
-        results: dictionaryInitialState.results,
-      };
+    submitFailure: (state, action: PayloadAction<unknown>) => {
+      const error = action.payload;
+      const results = dictionaryInitialState.results;
+      return { ...state, error, isLoading: false, results };
     },
 
     submitSuccess: (state, action: PayloadAction<WordDefinition[]>) => {
-      return {
-        ...state,
-        isLoading: false,
-        results: action.payload,
-      };
+      const error = dictionaryInitialState.error;
+      const results = action.payload;
+      return { ...state, error, isLoading: false, results };
     },
   },
 });

package/packages/scrabble-solver/src/state/slices/index.ts

@@ -12,3 +12,5 @@ export { default as settingsInitialState } from './settingsInitialState';
 export { default as settingsSlice } from './settingsSlice';
 export { default as solveInitialState } from './solveInitialState';
 export { default as solveSlice } from './solveSlice';
+export { default as verifyInitialState } from './verifyInitialState';
+export { default as verifySlice } from './verifySlice';

package/packages/scrabble-solver/src/state/slices/rackSlice.ts

@@ -19,6 +19,13 @@ const rackSlice = createSlice({
       return [...state.slice(0, index), character, ...state.slice(index + 1)];
     },
 
+    changeCharacters: (state, action: PayloadAction<{ characters: (string | null)[]; index: number }>) => {
+      const { characters, index } = action.payload;
+      const expectedRackLength = state.length;
+      const rack = [...state.slice(0, index), ...characters, ...state.slice(index + characters.length)];
+      return rack.slice(0, expectedRackLength);
+    },
+
     groupTiles: (state, action: PayloadAction<'left' | 'right' | null>) => {
       const direction = action.payload;
 

package/packages/scrabble-solver/src/state/slices/solveInitialState.ts

@@ -1,10 +1,22 @@
+import { Board } from '@scrabble-solver/types';
+
 import boardInitialState from './boardInitialState';
 
-const solveInitialState = {
+interface SolveInitialState {
+  error: unknown | undefined;
+  isLoading: boolean;
+  lastSolvedParameters: {
+    board: Board;
+    characters: string[];
+  };
+}
+
+const solveInitialState: SolveInitialState = {
+  error: undefined,
   isLoading: false,
   lastSolvedParameters: {
     board: boardInitialState,
-    characters: [] as string[],
+    characters: [],
   },
 };
 

package/packages/scrabble-solver/src/state/slices/solveSlice.ts

@@ -13,16 +13,19 @@ const solveSlice = createSlice({
   name: 'solve',
   reducers: {
     submit: (state) => {
-      return { ...state, isLoading: true };
+      const error = solveInitialState.error;
+      return { ...state, error, isLoading: true };
     },
 
-    submitFailure: (state) => {
-      return { ...state, isLoading: false };
+    submitFailure: (state, action: PayloadAction<unknown>) => {
+      const error = action.payload;
+      return { ...state, error, isLoading: false };
     },
 
     submitSuccess: (state, action: PayloadAction<SolveParameters>) => {
+      const error = solveInitialState.error;
       const lastSolvedParameters = action.payload;
-      return { ...state, isLoading: false, lastSolvedParameters };
+      return { ...state, error, isLoading: false, lastSolvedParameters };
     },
   },
 });

package/packages/scrabble-solver/src/state/slices/verifyInitialState.ts

@@ -0,0 +1,12 @@
+import boardInitialState from './boardInitialState';
+
+const verifyInitialState = {
+  isLoading: false,
+  lastSolvedParameters: {
+    board: boardInitialState,
+  },
+  invalidWords: [] as string[],
+  validWords: [] as string[],
+};
+
+export default verifyInitialState;

package/packages/scrabble-solver/src/state/slices/verifySlice.ts

@@ -0,0 +1,31 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import { Board } from '@scrabble-solver/types';
+
+import verifyInitialState from './verifyInitialState';
+
+interface VerifyParameters {
+  board: Board;
+  invalidWords: string[];
+  validWords: string[];
+}
+
+const verifySlice = createSlice({
+  initialState: verifyInitialState,
+  name: 'verify',
+  reducers: {
+    submit: (state) => {
+      return { ...state, isLoading: true };
+    },
+
+    submitFailure: (state) => {
+      return { ...state, isLoading: false };
+    },
+
+    submitSuccess: (state, action: PayloadAction<VerifyParameters>) => {
+      const { board, invalidWords, validWords } = action.payload;
+      return { ...state, isLoading: false, lastSolvedParameters: { board }, invalidWords, validWords };
+    },
+  },
+});
+
+export default verifySlice;

package/packages/scrabble-solver/src/styles/variables.scss

@@ -26,7 +26,8 @@ $easeOutSine: cubic-bezier(0.61, 1, 0.88, 1);
   --color--background: #f4f4f4;
   --color--background--secondary: #111;
   --color--background--overlay: rgba(255, 255, 255, 0.65);
-  --color--error: rgba(255, 0, 0, 0.75);
+  --color--error: #fc3d3d;
+  --color--success: #00a900;
   --color--focus: #{rgba(#268fff, 0.5)};
   --color--foreground: black;
   --color--foreground--secondary: #444;

package/packages/scrabble-solver/src/types/index.ts

@@ -1,5 +1,7 @@
 export type Comparator<T> = (a: T, B: T) => number;
 
+export type Direction = 'horizontal' | 'vertical';
+
 export enum SortDirection {
   Ascending = 'ascending',
   Descending = 'descending',
@@ -80,7 +82,10 @@ export type TranslationKey =
   | 'settings.autoGroupTiles.right'
   | 'settings.autoGroupTiles.null'
   | 'settings.game'
-  | 'settings.language';
+  | 'settings.language'
+  | 'words'
+  | 'words.invalid'
+  | 'words.valid';
 
 export type Translate = (key: TranslationKey) => string;
 

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

@@ -0,0 +1,5 @@
+import { Trie } from '@kamilmielnik/trie';
+import { Config, Pattern, Tile } from '@scrabble-solver/types';
+declare const fillPattern: (trie: Trie, config: Config, pattern: Pattern, tiles: Tile[]) => Pattern[];
+export declare const fillPatternRecursive: (results: Pattern[], trie: Trie, config: Config, pattern: Pattern, word: string, tiles: Tile[]) => void;
+export default fillPattern;

package/packages/solver/build/fillPattern.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillPatternRecursive = void 0;
+const constants_1 = require("@scrabble-solver/constants");
+const types_1 = require("@scrabble-solver/types");
+const fillPattern = (trie, config, pattern, tiles) => {
+    if (pattern.getEmptyCellsCount() > tiles.length) {
+        return [];
+    }
+    const results = [];
+    (0, exports.fillPatternRecursive)(results, trie, config, pattern, pattern.toString(), tiles);
+    return results;
+};
+const fillPatternRecursive = (
+/** gets mutated when this function is called */
+results, trie, config, pattern, word, tiles) => {
+    const indexOfFirstCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+    if (indexOfFirstCellWithoutTile === -1) {
+        if (trie.has(word) && pattern.getCollisions().every((collision) => trie.has(collision.toString()))) {
+            results.push(new types_1.FinalPattern(pattern.clone()));
+        }
+        return;
+    }
+    for (let index = 0; index < tiles.length; ++index) {
+        const tile = tiles[index];
+        const previousTile = pattern.cells[indexOfFirstCellWithoutTile].tile;
+        pattern.cells[indexOfFirstCellWithoutTile].tile = tile;
+        const indexOfNextCellWithoutTile = pattern.getIndexOfFirstCellWithoutTile();
+        const indexOfFirstEmptyLetter = word.indexOf(constants_1.EMPTY_CELL);
+        const prefix = word.substring(0, indexOfFirstEmptyLetter);
+        const suffix = word.substring(indexOfFirstEmptyLetter + 1);
+        const characters = tile.isBlank ? config.alphabet : [tile.character];
+        for (const character of characters) {
+            const newWordPrefix = prefix + character;
+            const newWord = newWordPrefix + suffix;
+            tile.character = character;
+            if (indexOfNextCellWithoutTile === -1) {
+                if (trie.has(newWord) && pattern.getCollisions().every((collision) => trie.has(collision.toString()))) {
+                    results.push(new types_1.FinalPattern(pattern.clone()));
+                }
+            }
+            else if (trie.hasPrefix(newWordPrefix)) {
+                tiles.splice(index, 1);
+                (0, exports.fillPatternRecursive)(results, trie, config, pattern, newWord, tiles);
+                tiles.splice(index, 0, tile);
+            }
+        }
+        pattern.cells[indexOfFirstCellWithoutTile].tile = previousTile;
+    }
+};
+exports.fillPatternRecursive = fillPatternRecursive;
+exports.default = fillPattern;

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

@@ -0,0 +1,3 @@
+import { Cell } from '@scrabble-solver/types';
+declare const generateEndIndices: (cells: Cell[], startIndex: number) => number[];
+export default generateEndIndices;

package/packages/solver/build/generateEndIndices.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateEndIndices = (cells, startIndex) => {
+    if (cells.length === 0) {
+        return [];
+    }
+    const endIndices = [];
+    for (let endIndex = startIndex + 1; endIndex < cells.length - 1; ++endIndex) {
+        if (!cells[endIndex + 1].hasTile()) {
+            endIndices.push(endIndex);
+        }
+    }
+    endIndices.push(cells.length - 1);
+    return endIndices;
+};
+exports.default = generateEndIndices;

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

@@ -0,0 +1,3 @@
+import { Board, Config, Pattern } from '@scrabble-solver/types';
+declare const generateHorizontalPatterns: (config: Config, board: Board) => Pattern[];
+export default generateHorizontalPatterns;

package/packages/solver/build/generateHorizontalPatterns.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@scrabble-solver/types");
+const generatePattern_1 = __importDefault(require("./generatePattern"));
+const generateVectors_1 = __importDefault(require("./generateVectors"));
+const generateHorizontalPatterns = (config, board) => {
+    const getNthVector = (index) => board.getRow(index);
+    const vectorsCount = config.boardHeight;
+    const horizontalVectors = (0, generateVectors_1.default)({ getNthVector, vectorsCount });
+    const horizontalPatterns = horizontalVectors.flatMap((cells) => {
+        return (0, generatePattern_1.default)({ board, config, PatternModel: types_1.HorizontalPattern, cells });
+    });
+    return horizontalPatterns;
+};
+exports.default = generateHorizontalPatterns;

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

@@ -0,0 +1,8 @@
+import { Board, Cell, Config, Pattern } from '@scrabble-solver/types';
+declare const generatePattern: <P extends Pattern>({ board, cells, config, PatternModel, }: {
+    board: Board;
+    cells: Cell[];
+    config: Config;
+    PatternModel: new (board: Board, cells: Cell[]) => P;
+}) => P[];
+export default generatePattern;

package/packages/solver/build/generatePattern.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateEndIndices_1 = __importDefault(require("./generateEndIndices"));
+const generateStartIndices_1 = __importDefault(require("./generateStartIndices"));
+const generatePattern = ({ board, cells, config, PatternModel, }) => {
+    const startIndices = (0, generateStartIndices_1.default)(cells);
+    return startIndices.flatMap((startIndex) => {
+        const endIndices = (0, generateEndIndices_1.default)(cells, startIndex);
+        const patterns = [];
+        for (const endIndex of endIndices) {
+            const pattern = new PatternModel(board, cells.slice(startIndex, endIndex + 1));
+            if (pattern.canBePlaced(config)) {
+                patterns.push(pattern);
+            }
+        }
+        return patterns;
+    });
+};
+exports.default = generatePattern;

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

@@ -0,0 +1,3 @@
+import { Board, Config, Pattern } from '@scrabble-solver/types';
+declare const generatePatterns: (config: Config, board: Board) => Pattern[];
+export default generatePatterns;

package/packages/solver/build/generatePatterns.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateHorizontalPatterns_1 = __importDefault(require("./generateHorizontalPatterns"));
+const generateVerticalPatterns_1 = __importDefault(require("./generateVerticalPatterns"));
+const generatePatterns = (config, board) => {
+    const horizontalPatterns = (0, generateHorizontalPatterns_1.default)(config, board);
+    const verticalPatterns = (0, generateVerticalPatterns_1.default)(config, board);
+    return horizontalPatterns.concat(verticalPatterns);
+};
+exports.default = generatePatterns;

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

@@ -0,0 +1,3 @@
+import { Cell } from '@scrabble-solver/types';
+declare const generateStartIndices: (cells: Cell[]) => number[];
+export default generateStartIndices;

package/packages/solver/build/generateStartIndices.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateStartIndices = (cells) => {
+    if (cells.length === 0) {
+        return [];
+    }
+    const startIndices = [0];
+    for (let startIndex = 1; startIndex < cells.length - 1; ++startIndex) {
+        if (!cells[startIndex - 1].hasTile()) {
+            startIndices.push(startIndex);
+        }
+    }
+    return startIndices;
+};
+exports.default = generateStartIndices;

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

@@ -0,0 +1,7 @@
+import { Cell } from '@scrabble-solver/types';
+interface Parameters {
+    getNthVector: (index: number) => Cell[];
+    vectorsCount: number;
+}
+declare const generateVectors: ({ getNthVector, vectorsCount }: Parameters) => Cell[][];
+export default generateVectors;

package/packages/solver/build/generateVectors.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generateVectors = ({ getNthVector, vectorsCount }) => {
+    return Array.from({ length: vectorsCount }, (_, index) => getNthVector(index));
+};
+exports.default = generateVectors;

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

@@ -0,0 +1,3 @@
+import { Board, Config, Pattern } from '@scrabble-solver/types';
+declare const generateVerticalPatterns: (config: Config, board: Board) => Pattern[];
+export default generateVerticalPatterns;

package/packages/solver/build/generateVerticalPatterns.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@scrabble-solver/types");
+const generatePattern_1 = __importDefault(require("./generatePattern"));
+const generateVectors_1 = __importDefault(require("./generateVectors"));
+const generateVerticalPatterns = (config, board) => {
+    const getNthVector = (index) => board.getColumn(index);
+    const vectorsCount = config.boardWidth;
+    const verticalVectors = (0, generateVectors_1.default)({ getNthVector, vectorsCount });
+    const verticalPatterns = verticalVectors.flatMap((cells) => {
+        return (0, generatePattern_1.default)({ board, config, PatternModel: types_1.VerticalPattern, cells });
+    });
+    return verticalPatterns;
+};
+exports.default = generateVerticalPatterns;

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

@@ -0,0 +1,3 @@
+import { Cell, Config } from '@scrabble-solver/types';
+declare const getCellsScore: (config: Config, cells: Cell[]) => number;
+export default getCellsScore;

package/packages/solver/build/getCellsScore.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@scrabble-solver/constants");
+const getCellsScore = (config, cells) => {
+    const total = cells.reduce(({ multiplier, score }, cell) => {
+        const bonus = config.getCellBonus(cell);
+        const { characterMultiplier, wordMultiplier } = bonus && bonus.canApply(config, cell) ? bonus.value : constants_1.NO_BONUS;
+        const characterScore = cell.tile.isBlank ? config.blankScore : config.pointsMap[cell.tile.character];
+        return {
+            multiplier: multiplier * wordMultiplier,
+            score: score + characterScore * characterMultiplier,
+        };
+    }, { multiplier: 1, score: 0 });
+    return total.score * total.multiplier;
+};
+exports.default = getCellsScore;

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

@@ -0,0 +1,3 @@
+import { Pattern } from '@scrabble-solver/types';
+declare const getPatternHash: (pattern: Pattern) => string;
+export default getPatternHash;

package/packages/solver/build/getPatternHash.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPatternHash = (pattern) => {
+    return pattern.cells
+        .map((cell) => {
+        const blank = cell.tile.isBlank ? '!' : '';
+        const tile = cell.tile.character + blank;
+        // eslint-disable-next-line prefer-template
+        return cell.x + ',' + cell.y + ',' + tile;
+    })
+        .join('-');
+};
+exports.default = getPatternHash;

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

@@ -0,0 +1,3 @@
+import { Config, Pattern } from '@scrabble-solver/types';
+declare const getPatternScore: (config: Config, pattern: Pattern) => number;
+export default getPatternScore;

package/packages/solver/build/getPatternScore.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getCellsScore_1 = __importDefault(require("./getCellsScore"));
+const getPatternScore = (config, pattern) => {
+    const areAllTilesUsed = pattern.getEmptyCellsCount() === config.maximumCharactersCount;
+    const bonusScore = areAllTilesUsed ? config.allTilesBonusScore : 0;
+    const score = pattern
+        .getCollisions()
+        .reduce((sum, collision) => sum + (0, getCellsScore_1.default)(config, collision.cells), (0, getCellsScore_1.default)(config, pattern.cells));
+    return score + bonusScore;
+};
+exports.default = getPatternScore;

package/packages/solver/build/getUniquePatterns.js

@@ -1,20 +1,14 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const getPatternHash = (pattern) => {
-    return pattern.cells
-        .map((cell) => {
-        const blank = cell.tile.isBlank ? '!' : '';
-        const tile = cell.tile.character + blank;
-        // eslint-disable-next-line prefer-template
-        return cell.x + ',' + cell.y + ',' + tile;
-    })
-        .join('-');
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPatternHash_1 = __importDefault(require("./getPatternHash"));
 const getUniquePatterns = (patterns) => {
     const hashes = new Set();
     const uniquePatterns = [];
     for (const pattern of patterns) {
-        const hash = getPatternHash(pattern);
+        const hash = (0, getPatternHash_1.default)(pattern);
         if (!hashes.has(hash)) {
             hashes.add(hash);
             uniquePatterns.push(pattern);

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

@@ -1 +1 @@
-export { default } from './Solver';
+export { default as solve } from './solve';

package/packages/solver/build/index.js

@@ -3,6 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var Solver_1 = require("./Solver");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Solver_1).default; } });
+exports.solve = void 0;
+var solve_1 = require("./solve");
+Object.defineProperty(exports, "solve", { enumerable: true, get: function () { return __importDefault(solve_1).default; } });

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

@@ -0,0 +1,4 @@
+import { Trie } from '@kamilmielnik/trie';
+import { Board, Config, ResultJson, Tile } from '@scrabble-solver/types';
+declare const solve: (trie: Trie, config: Config, board: Board, tiles: Tile[]) => ResultJson[];
+export default solve;

package/packages/solver/build/solve.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fillPattern_1 = __importDefault(require("./fillPattern"));
+const generatePatterns_1 = __importDefault(require("./generatePatterns"));
+const getPatternScore_1 = __importDefault(require("./getPatternScore"));
+const getUniquePatterns_1 = __importDefault(require("./getUniquePatterns"));
+const solve = (trie, config, board, tiles) => {
+    const patterns = (0, generatePatterns_1.default)(config, board);
+    const filledPatterns = patterns.flatMap((pattern) => (0, fillPattern_1.default)(trie, config, pattern, tiles));
+    const uniquePatterns = (0, getUniquePatterns_1.default)(filledPatterns);
+    const results = uniquePatterns.map((pattern, index) => ({
+        cells: pattern.cells.map((cell) => cell.toJson()),
+        collisions: pattern.getCollisions().map((collision) => collision.cells.map((cell) => cell.toJson())),
+        id: index,
+        points: (0, getPatternScore_1.default)(config, pattern),
+    }));
+    return results;
+};
+exports.default = solve;

package/packages/solver/package-lock.json

@@ -1,21 +1,21 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.8",
+  "version": "2.8.10",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrabble-solver/solver",
-      "version": "2.8.8",
+      "version": "2.8.10",
       "license": "CC-BY-NC-ND-4.0",
       "dependencies": {
-        "@kamilmielnik/trie": "^2.0.0"
+        "@kamilmielnik/trie": "^2.0.1"
       }
     },
     "node_modules/@kamilmielnik/trie": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.0.tgz",
-      "integrity": "sha512-YWTYtrV97bQ5hRifG1FImP47PI400a56O8+oQClQOtDjY3tioxab4sOgFHckiDdswciN1RwngCZ9Kv3phJfSuA==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.1.tgz",
+      "integrity": "sha512-6Ulw5/xgFRadHsx0uVnpOxB2E2ZO2osnaakI26yS3RMlww580JiaQEfXUmQjXZcmOjcO+HrZ0CWjRDhoDYKHbg==",
       "engines": {
         "node": ">=16"
       }
@@ -23,9 +23,9 @@
   },
   "dependencies": {
     "@kamilmielnik/trie": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.0.tgz",
-      "integrity": "sha512-YWTYtrV97bQ5hRifG1FImP47PI400a56O8+oQClQOtDjY3tioxab4sOgFHckiDdswciN1RwngCZ9Kv3phJfSuA=="
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@kamilmielnik/trie/-/trie-2.0.1.tgz",
+      "integrity": "sha512-6Ulw5/xgFRadHsx0uVnpOxB2E2ZO2osnaakI26yS3RMlww580JiaQEfXUmQjXZcmOjcO+HrZ0CWjRDhoDYKHbg=="
     }
   }
 }

package/packages/solver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/solver",
-  "version": "2.8.8",
+  "version": "2.8.10",
   "description": "Scrabble Solver 2 - Solver",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -24,13 +24,13 @@
     "clean:force": "npm run clean && rimraf package-lock.json"
   },
   "dependencies": {
-    "@kamilmielnik/trie": "^2.0.0",
-    "@scrabble-solver/types": "^2.8.8"
+    "@kamilmielnik/trie": "^2.0.1",
+    "@scrabble-solver/types": "^2.8.10"
   },
   "devDependencies": {
-    "@scrabble-solver/configs": "^2.8.8",
-    "@scrabble-solver/constants": "^2.8.8",
-    "@scrabble-solver/dictionaries": "^2.8.8"
+    "@scrabble-solver/configs": "^2.8.10",
+    "@scrabble-solver/constants": "^2.8.10",
+    "@scrabble-solver/dictionaries": "^2.8.10"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }