cspell-trie-lib 6.28.0 → 6.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-trie-lib",
-  "version": "6.28.0",
+  "version": "6.29.0",
   "description": "Trie Data Structure to support cspell.",
   "type": "commonjs",
   "main": "dist/cjs/index.js",
@@ -14,6 +14,8 @@
   },
   "files": [
     "dist",
+    "!dist/esm/**/*.js",
+    "!dist/esm/**/*.ts",
     "!**/*.tsbuildInfo",
     "!**/__mocks__",
     "!**/test/**",
@@ -48,8 +50,8 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "6.28.0",
-    "@cspell/cspell-types": "6.28.0",
+    "@cspell/cspell-pipe": "6.29.0",
+    "@cspell/cspell-types": "6.29.0",
     "gensequence": "^5.0.2"
   },
   "engines": {
@@ -59,5 +61,5 @@
     "@cspell/dict-en_us": "^3.0.0",
     "@cspell/dict-es-es": "^2.2.4"
   },
-  "gitHead": "1c314413e76908e5fbf61fd2555726112b177c0e"
+  "gitHead": "2eabb1c47c12c2a42eb95d30329be6f544ee2ffc"
 }

package/dist/esm/index.d.ts

@@ -1,2 +0,0 @@
-export * from './lib/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -1 +0,0 @@
-export * from './lib/index.js';

package/dist/esm/lib/SimpleDictionaryParser.d.ts

@@ -1,73 +0,0 @@
-import { type Operator } from '@cspell/cspell-pipe/sync';
-import type { Trie } from './trie.js';
-export interface ParseDictionaryOptions {
-    compoundCharacter: string;
-    optionalCompoundCharacter: string;
-    forbiddenPrefix: string;
-    caseInsensitivePrefix: string;
-    /**
-     * Start of a single-line comment.
-     * @default "#"
-     */
-    commentCharacter: string;
-    /**
-     * If word starts with prefix, do not strip case or accents.
-     * @default false;
-     */
-    keepExactPrefix: string;
-    /**
-     * Tell the parser to automatically create case / accent insensitive forms.
-     * @default true
-     */
-    stripCaseAndAccents: boolean;
-    /**
-     * Tell the parser to keep non-case/accent version in both forms.
-     * @default false
-     */
-    stripCaseAndAccentsKeepDuplicate: boolean;
-    /**
-     * Tell the parser to keep non-case/accent version in both forms.
-     * @default false
-     */
-    stripCaseAndAccentsOnForbidden: boolean;
-    /**
-     * Tell the parser to split into words along spaces.
-     * @default false
-     */
-    split: boolean;
-    /**
-     * When splitting tells the parser to output both the split and non-split versions of the line.
-     * @default false
-     */
-    splitKeepBoth: boolean;
-    /**
-     * Specify the separator for splitting words.
-     */
-    splitSeparator: RegExp | string;
-}
-export declare const defaultParseDictionaryOptions: ParseDictionaryOptions;
-export declare const cSpellToolDirective = "cspell-dictionary:";
-export declare const setOfCSpellDirectiveFlags: string[];
-/**
- * Normalizes a dictionary words based upon prefix / suffixes.
- * Case insensitive versions are also generated.
- * @param options - defines prefixes used when parsing lines.
- * @returns words that have been normalized.
- */
-export declare function createDictionaryLineParserMapper(options?: Partial<ParseDictionaryOptions>): Operator<string>;
-/**
- * Normalizes a dictionary words based upon prefix / suffixes.
- * Case insensitive versions are also generated.
- * @param lines - one word per line
- * @param _options - defines prefixes used when parsing lines.
- * @returns words that have been normalized.
- */
-export declare function parseDictionaryLines(lines: Iterable<string> | string, options?: Partial<ParseDictionaryOptions>): Iterable<string>;
-export declare function parseLinesToDictionary(lines: Iterable<string>, options?: Partial<ParseDictionaryOptions>): Trie;
-export declare function parseDictionary(text: string, options?: Partial<ParseDictionaryOptions>): Trie;
-declare function splitLine(line: string, regExp: RegExp | string): string[];
-export declare const __testing__: {
-    splitLine: typeof splitLine;
-};
-export {};
-//# sourceMappingURL=SimpleDictionaryParser.d.ts.map

package/dist/esm/lib/SimpleDictionaryParser.js

@@ -1,191 +0,0 @@
-import { opCombine as opPipe, opConcatMap, opFilter, opMap } from '@cspell/cspell-pipe/sync';
-import { CASE_INSENSITIVE_PREFIX, COMPOUND_FIX, FORBID_PREFIX, IDENTITY_PREFIX, LINE_COMMENT, OPTIONAL_COMPOUND_FIX, } from './constants.js';
-import { buildTrieFast } from './TrieBuilder.js';
-import { normalizeWord, normalizeWordForCaseInsensitive } from './utils/normalizeWord.js';
-const RegExpSplit = /[\s,;]/g;
-const _defaultOptions = {
-    commentCharacter: LINE_COMMENT,
-    optionalCompoundCharacter: OPTIONAL_COMPOUND_FIX,
-    compoundCharacter: COMPOUND_FIX,
-    forbiddenPrefix: FORBID_PREFIX,
-    caseInsensitivePrefix: CASE_INSENSITIVE_PREFIX,
-    keepExactPrefix: IDENTITY_PREFIX,
-    stripCaseAndAccents: true,
-    stripCaseAndAccentsKeepDuplicate: false,
-    stripCaseAndAccentsOnForbidden: false,
-    split: false,
-    splitKeepBoth: false,
-    splitSeparator: RegExpSplit,
-};
-export const defaultParseDictionaryOptions = Object.freeze(_defaultOptions);
-export const cSpellToolDirective = 'cspell-dictionary:';
-export const setOfCSpellDirectiveFlags = ['no-split', 'split', 'generate-alternatives', 'no-generate-alternatives'];
-/**
- * Normalizes a dictionary words based upon prefix / suffixes.
- * Case insensitive versions are also generated.
- * @param options - defines prefixes used when parsing lines.
- * @returns words that have been normalized.
- */
-export function createDictionaryLineParserMapper(options) {
-    const _options = options || _defaultOptions;
-    const { commentCharacter = _defaultOptions.commentCharacter, optionalCompoundCharacter: optionalCompound = _defaultOptions.optionalCompoundCharacter, compoundCharacter: compound = _defaultOptions.compoundCharacter, caseInsensitivePrefix: ignoreCase = _defaultOptions.caseInsensitivePrefix, forbiddenPrefix: forbidden = _defaultOptions.forbiddenPrefix, keepExactPrefix: keepCase = _defaultOptions.keepExactPrefix, splitSeparator = _defaultOptions.splitSeparator, splitKeepBoth = _defaultOptions.splitKeepBoth, stripCaseAndAccentsKeepDuplicate = _defaultOptions.stripCaseAndAccentsKeepDuplicate, stripCaseAndAccentsOnForbidden = _defaultOptions.stripCaseAndAccentsOnForbidden, } = _options;
-    let { stripCaseAndAccents = _defaultOptions.stripCaseAndAccents, split = _defaultOptions.split } = _options;
-    // console.log('options: %o', options);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    function isString(line) {
-        return typeof line === 'string';
-    }
-    function trim(line) {
-        return line.trim();
-    }
-    function removeComments(line) {
-        const idx = line.indexOf(commentCharacter);
-        if (idx < 0)
-            return line;
-        const idxDirective = line.indexOf(cSpellToolDirective, idx);
-        if (idxDirective >= 0) {
-            const flags = line
-                .slice(idxDirective)
-                .split(/[\s,;]/g)
-                .map((s) => s.trim())
-                .filter((a) => !!a);
-            for (const flag of flags) {
-                switch (flag) {
-                    case 'split':
-                        split = true;
-                        break;
-                    case 'no-split':
-                        split = false;
-                        break;
-                    case 'no-generate-alternatives':
-                        stripCaseAndAccents = false;
-                        break;
-                    case 'generate-alternatives':
-                        stripCaseAndAccents = true;
-                        break;
-                }
-            }
-        }
-        return line.slice(0, idx).trim();
-    }
-    function filterEmptyLines(line) {
-        return !!line;
-    }
-    function* mapOptionalPrefix(line) {
-        if (line[0] === optionalCompound) {
-            const t = line.slice(1);
-            yield t;
-            yield compound + t;
-        }
-        else {
-            yield line;
-        }
-    }
-    function* mapOptionalSuffix(line) {
-        if (line.slice(-1) === optionalCompound) {
-            const t = line.slice(0, -1);
-            yield t;
-            yield t + compound;
-        }
-        else {
-            yield line;
-        }
-    }
-    const doNotNormalizePrefix = Object.create(null);
-    [ignoreCase, keepCase, '"'].forEach((prefix) => (doNotNormalizePrefix[prefix] = true));
-    if (!stripCaseAndAccentsOnForbidden) {
-        doNotNormalizePrefix[forbidden] = true;
-    }
-    function removeDoublePrefix(w) {
-        return w.startsWith(ignoreCase + ignoreCase) ? w.slice(1) : w;
-    }
-    function stripKeepCasePrefixAndQuotes(word) {
-        word = word.replace(/"(.*?)"/g, '$1');
-        return word[0] === keepCase ? word.slice(1) : word;
-    }
-    function _normalize(word) {
-        return normalizeWord(stripKeepCasePrefixAndQuotes(word));
-    }
-    function* mapNormalize(word) {
-        const nWord = _normalize(word);
-        const forms = new Set();
-        forms.add(nWord);
-        if (stripCaseAndAccents && !(word[0] in doNotNormalizePrefix)) {
-            for (const n of normalizeWordForCaseInsensitive(nWord)) {
-                (stripCaseAndAccentsKeepDuplicate || n !== nWord) && forms.add(ignoreCase + n);
-            }
-        }
-        yield* forms;
-    }
-    function* splitWords(lines) {
-        for (const line of lines) {
-            if (split) {
-                const lineEscaped = line.indexOf('"') >= 0
-                    ? line.replace(/".*?"/g, (quoted) => ' ' + quoted.replace(/(\s)/g, '\\$1') + ' ')
-                    : line;
-                const words = splitLine(lineEscaped, splitSeparator);
-                yield* words.map((escaped) => escaped.replace(/\\/g, ''));
-                if (!splitKeepBoth)
-                    continue;
-            }
-            yield line;
-        }
-    }
-    function* splitLines(paragraphs) {
-        for (const paragraph of paragraphs) {
-            yield* paragraph.split('\n');
-        }
-    }
-    const processLines = opPipe(opFilter(isString), splitLines, opMap(removeComments), splitWords, opMap(trim), opFilter(filterEmptyLines), opConcatMap(mapOptionalPrefix), opConcatMap(mapOptionalSuffix), opConcatMap(mapNormalize), opMap(removeDoublePrefix));
-    return processLines;
-}
-/**
- * Normalizes a dictionary words based upon prefix / suffixes.
- * Case insensitive versions are also generated.
- * @param lines - one word per line
- * @param _options - defines prefixes used when parsing lines.
- * @returns words that have been normalized.
- */
-export function parseDictionaryLines(lines, options) {
-    return createDictionaryLineParserMapper(options)(typeof lines === 'string' ? [lines] : lines);
-}
-export function parseLinesToDictionary(lines, options) {
-    const _options = mergeOptions(_defaultOptions, options);
-    const dictLines = parseDictionaryLines(lines, _options);
-    return buildTrieFast([...new Set(dictLines)].sort(), {
-        compoundCharacter: _options.compoundCharacter,
-        forbiddenWordPrefix: _options.forbiddenPrefix,
-        stripCaseAndAccentsPrefix: _options.caseInsensitivePrefix,
-    });
-}
-export function parseDictionary(text, options) {
-    return parseLinesToDictionary(text.split('\n'), options);
-}
-// function escapeRegEx(s: string) {
-//     return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
-// }
-function mergeOptions(base, ...partials) {
-    const opt = { ...base };
-    for (const p of partials) {
-        if (!p)
-            continue;
-        Object.assign(opt, p);
-    }
-    return opt;
-}
-const RegExpToEncode = /\\([\s,;])/g;
-const RegExpDecode = /<<(%[\da-f]{2})>>/gi;
-function encodeLine(line) {
-    return line.replace(RegExpToEncode, (_, v) => '<<' + encodeURIComponent(v) + '>>');
-}
-function decodeLine(line) {
-    return line.replace(RegExpDecode, (_, v) => '\\' + decodeURIComponent(v));
-}
-function splitLine(line, regExp) {
-    return encodeLine(line)
-        .split(regExp)
-        .map((line) => decodeLine(line));
-}
-export const __testing__ = {
-    splitLine,
-};

package/dist/esm/lib/TrieBuilder.d.ts

@@ -1,46 +0,0 @@
-import type { PartialTrieOptions, TrieOptions } from './trie.js';
-import { Trie } from './trie.js';
-/**
- * Builds an optimized Trie from a Iterable<string>. It attempts to reduce the size of the trie
- * by finding common endings.
- * @param words Iterable set of words -- no processing is done on the words, they are inserted as is.
- * @param trieOptions options for the Trie
- */
-export declare function buildTrie(words: Iterable<string>, trieOptions?: PartialTrieOptions): Trie;
-/**
- * Builds a Trie from a Iterable<string>. NO attempt a reducing the size of the Trie is done.
- * @param words Iterable set of words -- no processing is done on the words, they are inserted as is.
- * @param trieOptions options for the Trie
- */
-export declare function buildTrieFast(words: Iterable<string>, trieOptions?: PartialTrieOptions): Trie;
-export declare class TrieBuilder {
-    private count;
-    private readonly signatures;
-    private readonly cached;
-    private readonly transforms;
-    private _eow;
-    /** position 0 of lastPath is always the root */
-    private lastPath;
-    private tails;
-    trieOptions: TrieOptions;
-    constructor(words?: Iterable<string>, trieOptions?: PartialTrieOptions);
-    private set _root(value);
-    private get _root();
-    private signature;
-    private _canBeCached;
-    private tryCacheFrozen;
-    private freeze;
-    private tryToCache;
-    private storeTransform;
-    private addChild;
-    private buildTail;
-    private _insert;
-    insertWord(word: string): void;
-    insert(words: Iterable<string>): void;
-    /**
-     * Resets the builder
-     */
-    reset(): void;
-    build(consolidateSuffixes?: boolean): Trie;
-}
-//# sourceMappingURL=TrieBuilder.d.ts.map

package/dist/esm/lib/TrieBuilder.js

@@ -1,214 +0,0 @@
-import { consolidate } from './consolidate.js';
-import { Trie } from './trie.js';
-import { createTrieRoot, createTriFromList, trieNodeToRoot } from './trie-util.js';
-import { mergeOptionalWithDefaults } from './utils/mergeOptionalWithDefaults.js';
-import { SecondChanceCache } from './utils/secondChanceCache.js';
-/**
- * Builds an optimized Trie from a Iterable<string>. It attempts to reduce the size of the trie
- * by finding common endings.
- * @param words Iterable set of words -- no processing is done on the words, they are inserted as is.
- * @param trieOptions options for the Trie
- */
-export function buildTrie(words, trieOptions) {
-    return new TrieBuilder(words, trieOptions).build();
-}
-/**
- * Builds a Trie from a Iterable<string>. NO attempt a reducing the size of the Trie is done.
- * @param words Iterable set of words -- no processing is done on the words, they are inserted as is.
- * @param trieOptions options for the Trie
- */
-export function buildTrieFast(words, trieOptions) {
-    const root = createTriFromList(words, trieOptions);
-    return new Trie(root, undefined);
-}
-// cspell:words sigs
-const MAX_NUM_SIGS = 100000;
-const MAX_TRANSFORMS = 1000000;
-const MAX_CACHE_SIZE = 1000000;
-export class TrieBuilder {
-    constructor(words, trieOptions) {
-        this.count = 0;
-        this.signatures = new SecondChanceCache(MAX_NUM_SIGS);
-        this.cached = new SecondChanceCache(MAX_CACHE_SIZE);
-        this.transforms = new SecondChanceCache(MAX_TRANSFORMS);
-        this._eow = Object.freeze({ f: 1 });
-        /** position 0 of lastPath is always the root */
-        this.lastPath = [{ s: '', n: { f: undefined, c: undefined } }];
-        this.tails = new Map([['', this._eow]]);
-        this._canBeCached(this._eow); // this line is just for coverage reasons
-        this.signatures.set(this.signature(this._eow), this._eow);
-        this.cached.set(this._eow, this.count++);
-        this.trieOptions = Object.freeze(mergeOptionalWithDefaults(trieOptions));
-        if (words) {
-            this.insert(words);
-        }
-    }
-    set _root(n) {
-        this.lastPath[0].n = n;
-    }
-    get _root() {
-        return trieNodeToRoot(this.lastPath[0].n, this.trieOptions);
-    }
-    signature(n) {
-        const isWord = n.f ? '*' : '';
-        const ref = n.c ? JSON.stringify([...n.c.entries()].map(([k, n]) => [k, this.cached.get(n)])) : '';
-        return isWord + ref;
-    }
-    _canBeCached(n) {
-        if (!n.c)
-            return true;
-        for (const v of n.c) {
-            if (!this.cached.has(v[1]))
-                return false;
-        }
-        return true;
-    }
-    tryCacheFrozen(n) {
-        if (this.cached.has(n)) {
-            return n;
-        }
-        this.cached.set(n, this.count++);
-        return n;
-    }
-    freeze(n) {
-        if (Object.isFrozen(n))
-            return n;
-        // istanbul ignore else
-        if (n.c) {
-            const c = [...n.c]
-                .sort((a, b) => (a[0] < b[0] ? -1 : 1))
-                .map(([k, n]) => [k, this.freeze(n)]);
-            n.c = new Map(c);
-            Object.freeze(n.c);
-        }
-        return Object.freeze(n);
-    }
-    tryToCache(n) {
-        if (!this._canBeCached(n)) {
-            return n;
-        }
-        const sig = this.signature(n);
-        const ref = this.signatures.get(sig);
-        if (ref !== undefined) {
-            return this.tryCacheFrozen(ref);
-        }
-        this.signatures.set(sig, this.freeze(n));
-        return n;
-    }
-    storeTransform(src, s, result) {
-        if (!Object.isFrozen(result) || !Object.isFrozen(src))
-            return;
-        const t = this.transforms.get(src) ?? new Map();
-        t.set(s, result);
-        this.transforms.set(src, t);
-    }
-    addChild(node, head, child) {
-        if (node.c?.get(head) !== child) {
-            if (!node.c || Object.isFrozen(node)) {
-                node = { ...node, c: new Map(node.c ?? []) };
-            }
-            node.c?.set(head, child);
-        }
-        return Object.isFrozen(child) ? this.tryToCache(node) : node;
-    }
-    buildTail(s) {
-        const v = this.tails.get(s);
-        if (v)
-            return v;
-        const head = s[0];
-        const tail = s.slice(1);
-        const t = this.tails.get(tail);
-        const c = t || this.buildTail(tail);
-        const n = this.addChild({ f: undefined, c: undefined }, head, c);
-        if (!t) {
-            return n;
-        }
-        const cachedNode = this.tryCacheFrozen(Object.freeze(n));
-        this.tails.set(s, cachedNode);
-        return cachedNode;
-    }
-    _insert(node, s, d) {
-        const orig = node;
-        if (Object.isFrozen(node)) {
-            const n = this.transforms.get(node)?.get(s);
-            if (n) {
-                return this.tryCacheFrozen(n);
-            }
-        }
-        if (!s) {
-            if (!node.c) {
-                return this._eow;
-            }
-            else {
-                node = copyIfFrozen(node);
-                node.f = this._eow.f;
-                return node;
-            }
-        }
-        const head = s[0];
-        const tail = s.slice(1);
-        const cNode = node.c?.get(head);
-        const child = cNode ? this._insert(cNode, tail, d + 1) : this.buildTail(tail);
-        node = this.addChild(node, head, child);
-        this.storeTransform(orig, s, node);
-        this.lastPath[d] = { s: head, n: child };
-        return node;
-    }
-    insertWord(word) {
-        let d = 1;
-        for (const s of word.split('')) {
-            const p = this.lastPath[d];
-            if (p?.s !== s)
-                break;
-            d++;
-        }
-        // remove the remaining part of the path because it doesn't match this word.
-        if (word.length < d) {
-            d = word.length;
-        }
-        this.lastPath.length = d;
-        d -= 1;
-        const { n } = this.lastPath[d];
-        const tail = word.slice(d);
-        this.lastPath[d].n = this._insert(n, tail, d + 1);
-        while (d > 0) {
-            const { s, n } = this.lastPath[d];
-            d -= 1;
-            const parent = this.lastPath[d];
-            const pn = parent.n;
-            parent.n = this.addChild(pn, s, n);
-            if (pn === parent.n)
-                break;
-            const tail = word.slice(d);
-            this.storeTransform(pn, tail, parent.n);
-        }
-    }
-    insert(words) {
-        for (const w of words) {
-            w && this.insertWord(w);
-        }
-    }
-    /**
-     * Resets the builder
-     */
-    reset() {
-        this._root = createTrieRoot(this.trieOptions);
-        this.cached.clear();
-        this.signatures.clear();
-        this.signatures.set(this.signature(this._eow), this._eow);
-        this.count = 0;
-        this.cached.set(this._eow, this.count++);
-    }
-    build(consolidateSuffixes = false) {
-        const root = this._root;
-        // Reset the builder to prevent updating the trie in the background.
-        this.reset();
-        return new Trie(consolidateSuffixes ? consolidate(root) : root);
-    }
-}
-function copyIfFrozen(n) {
-    if (!Object.isFrozen(n))
-        return n;
-    const c = n.c ? new Map(n.c) : undefined;
-    return { f: n.f, c };
-}

package/dist/esm/lib/TrieNode.d.ts

@@ -1,18 +0,0 @@
-import type { PartialWithUndefined } from './types.js';
-export declare const FLAG_WORD = 1;
-export declare class ChildMap extends Map<string, TrieNode> {
-}
-export interface TrieNode {
-    f?: number | undefined;
-    c?: ChildMap | undefined;
-}
-export interface TrieOptions {
-    compoundCharacter: string;
-    stripCaseAndAccentsPrefix: string;
-    forbiddenWordPrefix: string;
-}
-export type PartialTrieOptions = PartialWithUndefined<TrieOptions> | undefined;
-export interface TrieRoot extends TrieOptions {
-    c: ChildMap;
-}
-//# sourceMappingURL=TrieNode.d.ts.map

package/dist/esm/lib/TrieNode.js

@@ -1,3 +0,0 @@
-export const FLAG_WORD = 1;
-export class ChildMap extends Map {
-}

package/dist/esm/lib/compoundWalker.d.ts

@@ -1,29 +0,0 @@
-import type { Trie } from './trie.js';
-import type { TrieNode } from './TrieNode.js';
-export interface WalkItem {
-    /** prefix so far */
-    s: string;
-    n: TrieNode;
-    /** compound depth */
-    d: number;
-    /** true iff compound edge */
-    c: boolean;
-}
-export type WalkNext = boolean;
-/**
- *
- * Depth first walk of a compound trie.
- * If there are compounds, this becomes an infinite iterator.
- * Use i.next(false) to prevent the walker from going deeper into the trie.
- *
- * @param trie the compound Trie to walk
- */
-export declare function compoundWalker(trie: Trie, caseSensitive?: boolean): Generator<WalkItem, void, WalkNext>;
-/**
- *
- * @param trie Trie to walk
- * @param maxDepth Max compound depth
- * @param caseSensitive case sensitive search.
- */
-export declare function compoundWords(trie: Trie, maxDepth: number, caseSensitive?: boolean): Generator<string, void, unknown>;
-//# sourceMappingURL=compoundWalker.d.ts.map

package/dist/esm/lib/compoundWalker.js

@@ -1,56 +0,0 @@
-/**
- *
- * Depth first walk of a compound trie.
- * If there are compounds, this becomes an infinite iterator.
- * Use i.next(false) to prevent the walker from going deeper into the trie.
- *
- * @param trie the compound Trie to walk
- */
-export function* compoundWalker(trie, caseSensitive = true) {
-    const { compoundCharacter: cc, forbiddenWordPrefix: forbidden, stripCaseAndAccentsPrefix } = trie.options;
-    const blockNode = new Set([cc, forbidden, stripCaseAndAccentsPrefix]);
-    const root = (!caseSensitive && trie.root.c?.get(stripCaseAndAccentsPrefix)) || trie.root;
-    function* walk(n, s, c, d) {
-        const deeper = yield { n, s, c, d };
-        if (deeper !== false && n.c) {
-            for (const [k, cn] of n.c) {
-                if (blockNode.has(k))
-                    continue;
-                yield* walk(cn, s + k, false, d);
-            }
-            if (n.c.has(cc)) {
-                const compoundNodes = root.c?.get(cc);
-                if (compoundNodes) {
-                    yield* walk(compoundNodes, s, true, d + 1);
-                }
-            }
-        }
-    }
-    // Make sure we do not walk forbidden and compound only words from the root.
-    for (const n of root.c || []) {
-        if (!blockNode.has(n[0])) {
-            yield* walk(n[1], n[0], false, 0);
-        }
-    }
-}
-/**
- *
- * @param trie Trie to walk
- * @param maxDepth Max compound depth
- * @param caseSensitive case sensitive search.
- */
-export function* compoundWords(trie, maxDepth, caseSensitive = true) {
-    const stream = compoundWalker(trie, caseSensitive);
-    let item = stream.next();
-    while (!item.done) {
-        const { n, s, d } = item.value;
-        if (d >= maxDepth) {
-            item = stream.next(false);
-            continue;
-        }
-        if (n.f) {
-            yield s;
-        }
-        item = stream.next();
-    }
-}

package/dist/esm/lib/consolidate.d.ts

@@ -1,7 +0,0 @@
-import type { TrieRoot } from './TrieNode.js';
-/**
- * Consolidate to DAWG
- * @param root the root of the Trie tree
- */
-export declare function consolidate(root: TrieRoot): TrieRoot;
-//# sourceMappingURL=consolidate.d.ts.map