scrabble-solver 2.16.7 → 2.18.0

package/packages/gaddag/build/buildGaddag.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGaddag = void 0;
+/* eslint-disable max-depth, max-lines, max-statements, no-bitwise */
+const constants_1 = require("./constants");
+const Gaddag_1 = require("./Gaddag");
+/**
+ * Builds a minimal GADDAG from a word list.
+ *
+ * The construction generates every GADDAG sequence (`reverse(prefix) [+ ◇ + suffix]`)
+ * as a compact `(wordIndex << 6) | splitIndex` integer, orders them with an in-place
+ * MSD radix sort, and feeds them to an incremental minimal-automaton builder
+ * (Daciuk et al., 2000) backed by typed arrays and an open-addressing state registry.
+ */
+const buildGaddag = (words) => {
+    const { charCodes, letterByCharCode } = buildAlphabet(words);
+    const { itemsCount, wordBytes, wordOffsets, wordsCount } = encodeWords(words, letterByCharCode);
+    const items = generateItems(wordsCount, wordOffsets, itemsCount);
+    sortItems(items, wordBytes, wordOffsets);
+    return insertItems(items, wordBytes, wordOffsets, charCodes);
+};
+exports.buildGaddag = buildGaddag;
+const buildAlphabet = (words) => {
+    const codes = new Set();
+    for (const word of words) {
+        if (word.length > constants_1.MAX_WORD_LENGTH) {
+            continue;
+        }
+        for (let index = 0; index < word.length; ++index) {
+            codes.add(word.charCodeAt(index));
+        }
+    }
+    if (codes.size > constants_1.MAX_LETTERS) {
+        throw new Error(`Gaddag supports up to ${constants_1.MAX_LETTERS} distinct characters, got ${codes.size}`);
+    }
+    const charCodes = Int32Array.from([...codes].sort((a, b) => a - b));
+    const letterByCharCode = new Map();
+    for (let index = 0; index < charCodes.length; ++index) {
+        letterByCharCode.set(charCodes[index], index + 1);
+    }
+    return { charCodes, letterByCharCode };
+};
+const encodeWords = (words, letterByCharCode) => {
+    let totalLength = 0;
+    let wordsCount = 0;
+    for (const word of words) {
+        if (word.length === 0 || word.length > constants_1.MAX_WORD_LENGTH) {
+            continue;
+        }
+        totalLength += word.length;
+        ++wordsCount;
+    }
+    if (wordsCount >= 1 << 25) {
+        throw new Error('Gaddag supports up to 33M words');
+    }
+    const wordBytes = new Uint8Array(totalLength);
+    const wordOffsets = new Int32Array(wordsCount + 1);
+    let offset = 0;
+    let wordIndex = 0;
+    for (const word of words) {
+        if (word.length === 0 || word.length > constants_1.MAX_WORD_LENGTH) {
+            continue;
+        }
+        wordOffsets[wordIndex] = offset;
+        for (let index = 0; index < word.length; ++index) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            wordBytes[offset] = letterByCharCode.get(word.charCodeAt(index));
+            ++offset;
+        }
+        ++wordIndex;
+    }
+    wordOffsets[wordsCount] = offset;
+    return { itemsCount: totalLength, wordBytes, wordOffsets, wordsCount };
+};
+const generateItems = (wordsCount, wordOffsets, itemsCount) => {
+    const items = new Int32Array(itemsCount);
+    let itemIndex = 0;
+    for (let wordIndex = 0; wordIndex < wordsCount; ++wordIndex) {
+        const length = wordOffsets[wordIndex + 1] - wordOffsets[wordIndex];
+        for (let split = 1; split <= length; ++split) {
+            items[itemIndex] = (wordIndex << 6) | split;
+            ++itemIndex;
+        }
+    }
+    return items;
+};
+/**
+ * Radix character of sequence `item` at position `depth`:
+ * 0 = end of sequence, 1 = separator, letter + 1 otherwise.
+ */
+const charAt = (item, depth, wordBytes, wordOffsets) => {
+    const wordIndex = item >>> 6;
+    const split = item & 63;
+    const offset = wordOffsets[wordIndex];
+    if (depth < split) {
+        return wordBytes[offset + split - 1 - depth] + 1;
+    }
+    if (depth === split) {
+        return split < wordOffsets[wordIndex + 1] - offset ? 1 : 0;
+    }
+    return depth <= wordOffsets[wordIndex + 1] - offset ? wordBytes[offset + depth - 1] + 1 : 0;
+};
+const RADIX = constants_1.MAX_LETTERS + 2;
+const sortItems = (items, wordBytes, wordOffsets) => {
+    const auxiliary = new Int32Array(items.length);
+    const counts = new Int32Array(RADIX);
+    const starts = new Int32Array(RADIX);
+    // Manual stack of (low, high, depth) ranges to avoid recursion.
+    let stack = new Int32Array(3 * 64);
+    let stackTop = 0;
+    const push = (low, high, depth) => {
+        if (stackTop + 3 > stack.length) {
+            const grown = new Int32Array(stack.length * 2);
+            grown.set(stack);
+            stack = grown;
+        }
+        stack[stackTop] = low;
+        stack[stackTop + 1] = high;
+        stack[stackTop + 2] = depth;
+        stackTop += 3;
+    };
+    push(0, items.length, 0);
+    while (stackTop > 0) {
+        stackTop -= 3;
+        const low = stack[stackTop];
+        const high = stack[stackTop + 1];
+        let depth = stack[stackTop + 2];
+        if (high - low < 2) {
+            continue;
+        }
+        for (;;) {
+            counts.fill(0);
+            for (let index = low; index < high; ++index) {
+                ++counts[charAt(items[index], depth, wordBytes, wordOffsets)];
+            }
+            // Skip scatter when the whole range shares the character at this depth.
+            let singleBucket = -1;
+            for (let bucket = 0; bucket < RADIX; ++bucket) {
+                if (counts[bucket] === high - low) {
+                    singleBucket = bucket;
+                    break;
+                }
+                if (counts[bucket] > 0) {
+                    break;
+                }
+            }
+            if (singleBucket > 0) {
+                ++depth;
+                continue;
+            }
+            if (singleBucket === 0) {
+                break;
+            }
+            let position = low;
+            for (let bucket = 0; bucket < RADIX; ++bucket) {
+                starts[bucket] = position;
+                position += counts[bucket];
+            }
+            for (let index = low; index < high; ++index) {
+                const item = items[index];
+                auxiliary[starts[charAt(item, depth, wordBytes, wordOffsets)]++] = item;
+            }
+            items.set(auxiliary.subarray(low, high), low);
+            // After the scatter, starts[bucket] holds the end position of each bucket.
+            for (let bucket = 1; bucket < RADIX; ++bucket) {
+                if (counts[bucket] > 1) {
+                    push(starts[bucket] - counts[bucket], starts[bucket], depth + 1);
+                }
+            }
+            break;
+        }
+    }
+};
+const MAX_DEPTH = constants_1.MAX_WORD_LENGTH + 2;
+const MAX_ARCS_PER_STATE = constants_1.MAX_LETTERS + 1;
+class Builder {
+    constructor() {
+        // Frozen arcs (1-indexed; index 0 is a sentinel).
+        this.labels = new Uint8Array(1 << 20);
+        this.targets = new Int32Array(1 << 20);
+        this.arcTop = 1;
+        // Open-addressing registry of frozen states, storing first-arc indices (0 = empty slot).
+        this.table = new Int32Array(1 << 20);
+        this.tableCount = 0;
+        // Temporary (not yet minimized) states along the current insertion path.
+        this.pathLetters = new Uint8Array(MAX_DEPTH * MAX_ARCS_PER_STATE);
+        this.pathTargets = new Int32Array(MAX_DEPTH * MAX_ARCS_PER_STATE);
+        this.pathCounts = new Int32Array(MAX_DEPTH);
+        this.pathFinal = new Uint8Array(MAX_DEPTH);
+        this.previous = new Uint8Array(MAX_DEPTH);
+        this.previousLength = 0;
+    }
+    insert(sequence, length) {
+        const { previous, pathCounts, pathFinal } = this;
+        let commonPrefixLength = 0;
+        const maxCommon = Math.min(length, this.previousLength);
+        while (commonPrefixLength < maxCommon && sequence[commonPrefixLength] === previous[commonPrefixLength]) {
+            ++commonPrefixLength;
+        }
+        if (commonPrefixLength === length && commonPrefixLength === this.previousLength) {
+            return; // Duplicate sequence.
+        }
+        for (let depth = this.previousLength; depth > commonPrefixLength; --depth) {
+            this.freeze(depth);
+        }
+        for (let depth = commonPrefixLength; depth < length; ++depth) {
+            const base = depth * MAX_ARCS_PER_STATE;
+            this.pathLetters[base + pathCounts[depth]] = sequence[depth];
+            this.pathTargets[base + pathCounts[depth]] = 0;
+            ++pathCounts[depth];
+            pathCounts[depth + 1] = 0;
+            pathFinal[depth + 1] = 0;
+        }
+        pathFinal[length] = 1;
+        previous.set(sequence.subarray(0, length));
+        this.previousLength = length;
+    }
+    finish(charCodes) {
+        for (let depth = this.previousLength; depth > 0; --depth) {
+            this.freeze(depth);
+        }
+        const rootRef = this.registerState(0);
+        const labels = this.labels.slice(0, this.arcTop);
+        const targets = this.targets.slice(0, this.arcTop);
+        return new Gaddag_1.Gaddag(labels, targets, rootRef, charCodes);
+    }
+    /** Minimizes the state at `depth` and patches its parent's dangling arc. */
+    freeze(depth) {
+        const ref = this.registerState(depth);
+        const parentBase = (depth - 1) * MAX_ARCS_PER_STATE;
+        this.pathTargets[parentBase + this.pathCounts[depth - 1] - 1] = ref;
+    }
+    /** Returns the ref of a frozen state equivalent to the temporary state at `depth`. */
+    registerState(depth) {
+        const count = this.pathCounts[depth];
+        const final = this.pathFinal[depth];
+        if (count === 0) {
+            return final;
+        }
+        const base = depth * MAX_ARCS_PER_STATE;
+        const hash = this.hashPath(base, count);
+        const mask = this.table.length - 1;
+        let slot = hash & mask;
+        for (;;) {
+            const existing = this.table[slot];
+            if (existing === 0) {
+                break;
+            }
+            if (this.equalsPath(existing, base, count)) {
+                return (existing << 1) | final;
+            }
+            slot = (slot + 1) & mask;
+        }
+        const firstArc = this.appendArcs(base, count);
+        this.table[slot] = firstArc;
+        ++this.tableCount;
+        if (this.tableCount * 10 > this.table.length * 7) {
+            this.growTable();
+        }
+        return (firstArc << 1) | final;
+    }
+    hashPath(base, count) {
+        let hash = 0x811c9dc5 ^ count;
+        for (let index = 0; index < count; ++index) {
+            hash = Math.imul(hash ^ this.pathLetters[base + index], 16777619);
+            hash = Math.imul(hash ^ this.pathTargets[base + index], 16777619);
+        }
+        return hash >>> 0;
+    }
+    hashFrozen(firstArc) {
+        let count = 0;
+        for (let index = firstArc;; ++index) {
+            ++count;
+            if (this.labels[index] >= constants_1.LAST_ARC_FLAG) {
+                break;
+            }
+        }
+        let hash = 0x811c9dc5 ^ count;
+        for (let index = 0; index < count; ++index) {
+            hash = Math.imul(hash ^ (this.labels[firstArc + index] & constants_1.LETTER_MASK), 16777619);
+            hash = Math.imul(hash ^ this.targets[firstArc + index], 16777619);
+        }
+        return hash >>> 0;
+    }
+    equalsPath(firstArc, base, count) {
+        for (let index = 0; index < count; ++index) {
+            const label = this.labels[firstArc + index];
+            if ((label & constants_1.LETTER_MASK) !== this.pathLetters[base + index]) {
+                return false;
+            }
+            if (this.targets[firstArc + index] !== this.pathTargets[base + index]) {
+                return false;
+            }
+            const isLast = label >= constants_1.LAST_ARC_FLAG;
+            if (isLast !== (index === count - 1)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    appendArcs(base, count) {
+        if (this.arcTop + count > this.labels.length) {
+            const capacity = Math.max(this.labels.length * 2, this.arcTop + count);
+            const labels = new Uint8Array(capacity);
+            labels.set(this.labels);
+            this.labels = labels;
+            const targets = new Int32Array(capacity);
+            targets.set(this.targets);
+            this.targets = targets;
+        }
+        const firstArc = this.arcTop;
+        for (let index = 0; index < count; ++index) {
+            this.labels[this.arcTop] = this.pathLetters[base + index] | (index === count - 1 ? constants_1.LAST_ARC_FLAG : 0);
+            this.targets[this.arcTop] = this.pathTargets[base + index];
+            ++this.arcTop;
+        }
+        return firstArc;
+    }
+    growTable() {
+        const previousTable = this.table;
+        this.table = new Int32Array(previousTable.length * 2);
+        const mask = this.table.length - 1;
+        for (const firstArc of previousTable) {
+            if (firstArc === 0) {
+                continue;
+            }
+            let slot = this.hashFrozen(firstArc) & mask;
+            while (this.table[slot] !== 0) {
+                slot = (slot + 1) & mask;
+            }
+            this.table[slot] = firstArc;
+        }
+    }
+}
+const insertItems = (items, wordBytes, wordOffsets, charCodes) => {
+    const builder = new Builder();
+    const sequence = new Uint8Array(MAX_DEPTH);
+    for (let index = 0; index < items.length; ++index) {
+        const item = items[index];
+        const wordIndex = item >>> 6;
+        const split = item & 63;
+        const offset = wordOffsets[wordIndex];
+        const length = wordOffsets[wordIndex + 1] - offset;
+        let sequenceLength = 0;
+        for (let position = split - 1; position >= 0; --position) {
+            sequence[sequenceLength] = wordBytes[offset + position];
+            ++sequenceLength;
+        }
+        if (split < length) {
+            sequence[sequenceLength] = 0;
+            ++sequenceLength;
+            for (let position = split; position < length; ++position) {
+                sequence[sequenceLength] = wordBytes[offset + position];
+                ++sequenceLength;
+            }
+        }
+        builder.insert(sequence, sequenceLength);
+    }
+    return builder.finish(charCodes);
+};

package/packages/gaddag/build/constants.d.ts

@@ -0,0 +1,12 @@
+/** Letter index reserved for the GADDAG separator (◇). */
+export declare const SEPARATOR = 0;
+/** Letters are stored on 6 bits (1..63); 0 is the separator. */
+export declare const MAX_LETTERS = 63;
+/** Words longer than this are skipped — they cannot fit on any board. */
+export declare const MAX_WORD_LENGTH = 63;
+/** Arc label bit marking the last arc of a state. */
+export declare const LAST_ARC_FLAG = 128;
+/** Mask extracting the letter from an arc label. */
+export declare const LETTER_MASK = 63;
+/** "GDG1" magic number opening the binary serialization format. */
+export declare const MAGIC = 826754119;

package/packages/gaddag/build/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAGIC = exports.LETTER_MASK = exports.LAST_ARC_FLAG = exports.MAX_WORD_LENGTH = exports.MAX_LETTERS = exports.SEPARATOR = void 0;
+/** Letter index reserved for the GADDAG separator (◇). */
+exports.SEPARATOR = 0;
+/** Letters are stored on 6 bits (1..63); 0 is the separator. */
+exports.MAX_LETTERS = 63;
+/** Words longer than this are skipped — they cannot fit on any board. */
+exports.MAX_WORD_LENGTH = 63;
+/** Arc label bit marking the last arc of a state. */
+exports.LAST_ARC_FLAG = 128;
+/** Mask extracting the letter from an arc label. */
+exports.LETTER_MASK = 63;
+/** "GDG1" magic number opening the binary serialization format. */
+exports.MAGIC = 0x31474447;

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

@@ -0,0 +1,3 @@
+export { buildGaddag } from './buildGaddag';
+export { LAST_ARC_FLAG, LETTER_MASK, MAX_LETTERS, MAX_WORD_LENGTH, SEPARATOR } from './constants';
+export { Gaddag } from './Gaddag';

package/packages/gaddag/build/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gaddag = exports.SEPARATOR = exports.MAX_WORD_LENGTH = exports.MAX_LETTERS = exports.LETTER_MASK = exports.LAST_ARC_FLAG = exports.buildGaddag = void 0;
+var buildGaddag_1 = require("./buildGaddag");
+Object.defineProperty(exports, "buildGaddag", { enumerable: true, get: function () { return buildGaddag_1.buildGaddag; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "LAST_ARC_FLAG", { enumerable: true, get: function () { return constants_1.LAST_ARC_FLAG; } });
+Object.defineProperty(exports, "LETTER_MASK", { enumerable: true, get: function () { return constants_1.LETTER_MASK; } });
+Object.defineProperty(exports, "MAX_LETTERS", { enumerable: true, get: function () { return constants_1.MAX_LETTERS; } });
+Object.defineProperty(exports, "MAX_WORD_LENGTH", { enumerable: true, get: function () { return constants_1.MAX_WORD_LENGTH; } });
+Object.defineProperty(exports, "SEPARATOR", { enumerable: true, get: function () { return constants_1.SEPARATOR; } });
+var Gaddag_1 = require("./Gaddag");
+Object.defineProperty(exports, "Gaddag", { enumerable: true, get: function () { return Gaddag_1.Gaddag; } });

package/packages/logger/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/logger",
-  "version": "2.16.7",
+  "version": "2.18.0",
   "description": "Scrabble Solver 2 - Logger",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/packages/scrabble-solver/.next/BUILD_ID

@@ -1 +1 @@
-vYpMmuC_yEurZGcyGVnLf
+FL82obwzFHRzvV6z76I-U

package/packages/scrabble-solver/.next/build-manifest.json

@@ -4,37 +4,39 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/vYpMmuC_yEurZGcyGVnLf/_buildManifest.js",
-    "static/vYpMmuC_yEurZGcyGVnLf/_ssgManifest.js"
+    "static/FL82obwzFHRzvV6z76I-U/_buildManifest.js",
+    "static/FL82obwzFHRzvV6z76I-U/_ssgManifest.js"
   ],
   "rootMainFiles": [],
   "rootMainFilesTree": {},
   "pages": {
     "/": [
-      "static/chunks/webpack-1a7a166b34ed8d24.js",
-      "static/chunks/framework-3cf15b8041c59dd3.js",
-      "static/chunks/main-852475ca502b4e49.js",
-      "static/css/a78e04fe95452380.css",
-      "static/chunks/pages/index-ec0f6aeeaf7be227.js"
+      "static/chunks/webpack-e34c3ae12275e978.js",
+      "static/chunks/framework-626cbd48ac5aca57.js",
+      "static/chunks/main-b92e08f3fc96dd8d.js",
+      "static/chunks/101-829ab8a8d310e7a0.js",
+      "static/css/c403ce739a9c0d83.css",
+      "static/chunks/pages/index-5f9fa6ac3cd3d97b.js"
     ],
     "/_app": [
-      "static/chunks/webpack-1a7a166b34ed8d24.js",
-      "static/chunks/framework-3cf15b8041c59dd3.js",
-      "static/chunks/main-852475ca502b4e49.js",
-      "static/css/0af35adb4bab56f0.css",
-      "static/chunks/pages/_app-a5bbe02710f13d05.js"
+      "static/chunks/webpack-e34c3ae12275e978.js",
+      "static/chunks/framework-626cbd48ac5aca57.js",
+      "static/chunks/main-b92e08f3fc96dd8d.js",
+      "static/css/abc2425d3ba607bc.css",
+      "static/chunks/pages/_app-ba5d628e81a15461.js"
     ],
     "/_error": [
-      "static/chunks/webpack-1a7a166b34ed8d24.js",
-      "static/chunks/framework-3cf15b8041c59dd3.js",
-      "static/chunks/main-852475ca502b4e49.js",
-      "static/chunks/pages/_error-afeda7c5231b6c3c.js"
+      "static/chunks/webpack-e34c3ae12275e978.js",
+      "static/chunks/framework-626cbd48ac5aca57.js",
+      "static/chunks/main-b92e08f3fc96dd8d.js",
+      "static/chunks/pages/_error-f0290a98eb3ed0ec.js"
     ],
     "/not-found": [
-      "static/chunks/webpack-1a7a166b34ed8d24.js",
-      "static/chunks/framework-3cf15b8041c59dd3.js",
-      "static/chunks/main-852475ca502b4e49.js",
-      "static/chunks/pages/not-found-9e076427bad69d90.js"
+      "static/chunks/webpack-e34c3ae12275e978.js",
+      "static/chunks/framework-626cbd48ac5aca57.js",
+      "static/chunks/main-b92e08f3fc96dd8d.js",
+      "static/css/dee878eb64099d92.css",
+      "static/chunks/pages/not-found-23d61fd3ed791cad.js"
     ]
   }
 }

package/packages/scrabble-solver/.next/cache/.previewinfo

@@ -1 +1 @@
-{"previewModeId":"a6c19cde59370e106894a193c20cd8a4","previewModeSigningKey":"9060e5ecf8e605d70100eb0672f230a6866343e531c51afc048bfc0c8c403919","previewModeEncryptionKey":"62d17ceeff4cc44fb11cc2c43e09f43b9e851a9a2ce563c8d17807a573072eff","expireAt":1786826991817}
+{"previewModeId":"2ed53eba09def2ca7c362be290389f60","previewModeSigningKey":"b9232917f8c299896855e0a45d606f6fe07ad0f8756d32749968f60ba611bfe7","previewModeEncryptionKey":"d88a7abb78c2d6ff4e10c0b65a6a97a1c8d5cda23bbf9b63aa2c551420cde905","expireAt":1788079930556}

package/packages/scrabble-solver/.next/cache/.rscinfo

@@ -1 +1 @@
-{"encryption.key":"UCQyYhWSgZQMZYhNsOgppaCfZZpbJgyOn1/xnLZsT9s=","encryption.expire_at":1786826991813}
+{"encryption.key":"NWqdXk/9uSzI10ITMeyH24p7vLo6OsrRgdE+BzIApxw=","encryption.expire_at":1788079930553}