scrabble-solver 2.18.4 → 2.18.5

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

@@ -1,39 +0,0 @@
-/**
- * A GADDAG (Gordon, 1994) stored as flat typed arrays for speed and compact serialization.
- *
- * For every word `w` and every split `1 <= s <= |w|` the automaton accepts
- * `reverse(w[0..s)) + ◇ + w[s..)` (the separator is omitted when `s === |w|`).
- *
- * States are identified by "refs": `ref = (firstArcIndex << 1) | isWordEnd`.
- * A `firstArcIndex` of 0 means the state has no outgoing arcs; ref 0 means "no such state".
- * Arcs of a state are contiguous; the last one is marked with {@link LAST_ARC_FLAG} in its label.
- * An arc label stores the letter index (1..63, 0 = separator) in its low 6 bits.
- */
-export declare class Gaddag {
-    /** Arc labels: letter index | LAST_ARC_FLAG. Index 0 is an unused sentinel. */
-    readonly arcLabels: Uint8Array;
-    /** Arc targets: encoded state refs. Index 0 is an unused sentinel. */
-    readonly arcTargets: Int32Array;
-    /** Ref of the root state. */
-    readonly rootRef: number;
-    /** Code point of each letter index (position 0 holds the code point of letter 1). */
-    readonly charCodes: Int32Array;
-    private readonly letterByCharCode;
-    constructor(arcLabels: Uint8Array, arcTargets: Int32Array, rootRef: number, charCodes: Int32Array);
-    static deserialize(bytes: Uint8Array): Gaddag;
-    serialize(): Uint8Array;
-    /** Number of arcs (including the unused sentinel at index 0). */
-    get arcsCount(): number;
-    /**
-     * Follows the arc labeled with `letter` from the state `ref` points at.
-     * Returns the target ref, or 0 when there is no such arc.
-     *
-     * A state's arcs are stored in ascending letter order, so the scan stops as
-     * soon as it passes the wanted letter.
-     */
-    getArc(ref: number, letter: number): number;
-    /** Maps a code point to its letter index, or -1 when the character is not in the alphabet. */
-    getLetter(charCode: number): number;
-    has(word: string): boolean;
-    hasPrefix(prefix: string): boolean;
-}

package/packages/gaddag/build/Gaddag.js

@@ -1,128 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Gaddag = void 0;
-/* eslint-disable no-bitwise */
-const constants_1 = require("./constants");
-/**
- * A GADDAG (Gordon, 1994) stored as flat typed arrays for speed and compact serialization.
- *
- * For every word `w` and every split `1 <= s <= |w|` the automaton accepts
- * `reverse(w[0..s)) + ◇ + w[s..)` (the separator is omitted when `s === |w|`).
- *
- * States are identified by "refs": `ref = (firstArcIndex << 1) | isWordEnd`.
- * A `firstArcIndex` of 0 means the state has no outgoing arcs; ref 0 means "no such state".
- * Arcs of a state are contiguous; the last one is marked with {@link LAST_ARC_FLAG} in its label.
- * An arc label stores the letter index (1..63, 0 = separator) in its low 6 bits.
- */
-class Gaddag {
-    constructor(arcLabels, arcTargets, rootRef, charCodes) {
-        this.arcLabels = arcLabels;
-        this.arcTargets = arcTargets;
-        this.rootRef = rootRef;
-        this.charCodes = charCodes;
-        this.letterByCharCode = new Map();
-        for (let index = 0; index < charCodes.length; ++index) {
-            this.letterByCharCode.set(charCodes[index], index + 1);
-        }
-    }
-    static deserialize(bytes) {
-        // Note: an explicit copy (not .slice()) — Buffer.prototype.slice returns a
-        // view that would keep the misaligned byteOffset.
-        const aligned = bytes.byteOffset % 4 === 0 ? bytes : new Uint8Array(bytes);
-        const header = new Int32Array(aligned.buffer, aligned.byteOffset, 4);
-        if (header[0] !== constants_1.MAGIC) {
-            throw new Error('Invalid Gaddag data');
-        }
-        const letterCount = header[1];
-        const arcCount = header[2];
-        const rootRef = header[3];
-        const charCodes = new Int32Array(aligned.buffer, aligned.byteOffset + 16, letterCount);
-        const arcTargets = new Int32Array(aligned.buffer, aligned.byteOffset + 16 + 4 * letterCount, arcCount);
-        const arcLabels = new Uint8Array(aligned.buffer, aligned.byteOffset + 16 + 4 * (letterCount + arcCount), arcCount);
-        return new Gaddag(arcLabels, arcTargets, rootRef, charCodes);
-    }
-    serialize() {
-        const letterCount = this.charCodes.length;
-        const arcCount = this.arcTargets.length;
-        const bytes = new Uint8Array(16 + 4 * (letterCount + arcCount) + arcCount);
-        const header = new Int32Array(bytes.buffer, 0, 4);
-        header[0] = constants_1.MAGIC;
-        header[1] = letterCount;
-        header[2] = arcCount;
-        header[3] = this.rootRef;
-        new Int32Array(bytes.buffer, 16, letterCount).set(this.charCodes);
-        new Int32Array(bytes.buffer, 16 + 4 * letterCount, arcCount).set(this.arcTargets);
-        bytes.set(this.arcLabels, 16 + 4 * (letterCount + arcCount));
-        return bytes;
-    }
-    /** Number of arcs (including the unused sentinel at index 0). */
-    get arcsCount() {
-        return this.arcTargets.length;
-    }
-    /**
-     * Follows the arc labeled with `letter` from the state `ref` points at.
-     * Returns the target ref, or 0 when there is no such arc.
-     *
-     * A state's arcs are stored in ascending letter order, so the scan stops as
-     * soon as it passes the wanted letter.
-     */
-    getArc(ref, letter) {
-        let index = ref >>> 1;
-        if (index === 0) {
-            return 0;
-        }
-        const labels = this.arcLabels;
-        for (;;) {
-            const label = labels[index];
-            const arcLetter = label & constants_1.LETTER_MASK;
-            if (arcLetter === letter) {
-                return this.arcTargets[index];
-            }
-            if (arcLetter > letter || label >= constants_1.LAST_ARC_FLAG) {
-                return 0;
-            }
-            ++index;
-        }
-    }
-    /** Maps a code point to its letter index, or -1 when the character is not in the alphabet. */
-    getLetter(charCode) {
-        return this.letterByCharCode.get(charCode) ?? -1;
-    }
-    has(word) {
-        const length = word.length;
-        if (length === 0) {
-            return false;
-        }
-        let ref = this.rootRef;
-        for (let index = length - 1; index >= 0; --index) {
-            const letter = this.getLetter(word.charCodeAt(index));
-            if (letter === -1) {
-                return false;
-            }
-            ref = this.getArc(ref, letter);
-            if (ref === 0) {
-                return false;
-            }
-        }
-        return (ref & 1) === 1;
-    }
-    hasPrefix(prefix) {
-        const length = prefix.length;
-        if (length === 0) {
-            return true;
-        }
-        let ref = this.rootRef;
-        for (let index = length - 1; index >= 0; --index) {
-            const letter = this.getLetter(prefix.charCodeAt(index));
-            if (letter === -1) {
-                return false;
-            }
-            ref = this.getArc(ref, letter);
-            if (ref === 0) {
-                return false;
-            }
-        }
-        return (ref & 1) === 1 || this.getArc(ref, constants_1.SEPARATOR) !== 0;
-    }
-}
-exports.Gaddag = Gaddag;

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

@@ -1,10 +0,0 @@
-import { Gaddag } from './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.
- */
-export declare const buildGaddag: (words: string[]) => Gaddag;

package/packages/gaddag/build/buildGaddag.js

@@ -1,360 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-/** 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

@@ -1,15 +0,0 @@
-"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

@@ -1,3 +0,0 @@
-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

@@ -1,13 +0,0 @@
-"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; } });