cspell-trie-lib 8.4.0 → 8.5.0

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

@@ -2,16 +2,6 @@ import type { PartialTrieOptions, TrieOptions } from '../trie.js';
 import type { TrieData } from '../TrieData.js';
 import type { BuilderCursor } from './BuilderCursor.js';
 export interface TrieBuilder<T extends TrieData> {
-    /**
-     * Use this method to convert a word into an array of characters.
-     * Since `[...word]` is not equal to `word.split('')` or `word[i]` in some cases,
-     * this method is used to ensure that the characters are split correctly.
-     * @see [String.codePointAt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt)
-     * @see [String.charCodeAt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charCodeAt)
-     * @param word - The word to convert into an array of characters.
-     * @returns An array of characters, one for each character in the word.
-     */
-    wordToCharacters(word: string): string[];
     getCursor(): BuilderCursor;
     build(): T;
     setOptions(options: Readonly<PartialTrieOptions>): Readonly<TrieOptions>;

package/dist/lib/Builder/cursor-util.d.ts

@@ -1,4 +1,3 @@
 import type { BuilderCursor } from './BuilderCursor.js';
 export declare function insertWordsAtCursor(cursor: BuilderCursor, words: Iterable<string>): void;
-export declare function commonStringPrefixLen(a: string, b: string): number;
 //# sourceMappingURL=cursor-util.d.ts.map

package/dist/lib/Builder/cursor-util.js

@@ -1,11 +1,10 @@
 export function insertWordsAtCursor(cursor, words) {
     let prevWord = '';
     for (const word of words) {
-        const pLen = commonStrPrefix(prevWord, word);
+        const pLen = commonPrefixLen(prevWord, word);
         const stepBack = prevWord.length - pLen;
         cursor.backStep(stepBack);
-        const wLen = word.length;
-        for (let i = pLen; i < wLen; ++i) {
+        for (let i = pLen; i < word.length; ++i) {
             cursor.insertChar(word[i]);
         }
         cursor.markEOW();
@@ -13,21 +12,7 @@ export function insertWordsAtCursor(cursor, words) {
     }
     cursor.backStep(prevWord.length);
 }
-export function commonStringPrefixLen(a, b) {
-    let i = 0;
-    for (i = 0; i < a.length && a[i] === b[i]; ++i) {
-        /* empty */
-    }
-    if (i) {
-        // detect second half of a surrogate pair and backup.
-        const c = a.charCodeAt(i) & 0xffff;
-        if (c >= 0xdc00 && c <= 0xdfff) {
-            --i;
-        }
-    }
-    return i;
-}
-function commonStrPrefix(a, b) {
+function commonPrefixLen(a, b) {
     let i = 0;
     for (i = 0; i < a.length && a[i] === b[i]; ++i) {
         /* empty */

package/dist/lib/ITrieNode/find.js

@@ -186,10 +186,10 @@ export function isEndOfWordNode(n) {
     return !!n?.eow;
 }
 function walk(root, word) {
-    const w = [...word];
+    const w = word;
     let n = root;
     let i = 0;
-    while (n && i < w.length) {
+    while (n && i < word.length) {
         const h = w[i++];
         n = n.get(h);
     }

package/dist/lib/TrieBlob/FastTrieBlob.d.ts

@@ -6,29 +6,21 @@ import { FastTrieBlobInternals } from './FastTrieBlobInternals.js';
 import { TrieBlob } from './TrieBlob.js';
 export declare class FastTrieBlob implements TrieData {
     private nodes;
-    private _charIndex;
+    private charIndex;
     readonly bitMasksInfo: FastTrieBlobBitMaskInfo;
-    private _charToIndexMap;
+    private charToIndexMap;
     private _readonly;
     private _forbidIdx;
     private _iTrieRoot;
-    wordToCharacters: (word: string) => readonly string[];
     readonly info: Readonly<TrieInfo>;
     private constructor();
-    private _lookUpCharIndex;
-    private wordToNodeCharIndexSequence;
-    private letterToNodeCharIndexSequence;
+    private lookUpCharIndex;
     has(word: string): boolean;
     private _has;
     words(): Iterable<string>;
     toTrieBlob(): TrieBlob;
     isReadonly(): boolean;
     freeze(): this;
-    toJSON(): {
-        info: Readonly<TrieInfo>;
-        nodes: NodeElement[];
-        charIndex: readonly string[];
-    };
     static create(data: FastTrieBlobInternals, options?: PartialTrieInfo): FastTrieBlob;
     static toITrieNodeRoot(trie: FastTrieBlob): ITrieNodeRoot;
     static NodeMaskEOW: number;
@@ -42,20 +34,6 @@ export declare class FastTrieBlob implements TrieData {
     hasForbiddenWords(): boolean;
     /** number of nodes */
     get size(): number;
-    private _lookupCharIndexNode;
-    /** Search from nodeIdx for the node index representing the character. */
-    private _searchNodeForChar;
-    get charIndex(): readonly string[];
-    static fromTrieBlob(trie: TrieBlob): FastTrieBlob;
+    private _lookupChar;
 }
-interface NodeElement {
-    id: number;
-    eow: boolean;
-    n: number;
-    c: {
-        c: number | string;
-        i: number;
-    }[];
-}
-export {};
 //# sourceMappingURL=FastTrieBlob.d.ts.map

package/dist/lib/TrieBlob/FastTrieBlob.js

@@ -3,35 +3,26 @@ import { mergeOptionalWithDefaults } from '../utils/mergeOptionalWithDefaults.js
 import { extractInfo } from './FastTrieBlobBitMaskInfo.js';
 import { FastTrieBlobInternals } from './FastTrieBlobInternals.js';
 import { FastTrieBlobIRoot } from './FastTrieBlobIRoot.js';
-import { NumberSequenceByteDecoderAccumulator } from './NumberSequenceByteDecoderAccumulator.js';
 import { TrieBlob } from './TrieBlob.js';
 export class FastTrieBlob {
     nodes;
-    _charIndex;
+    charIndex;
     bitMasksInfo;
-    _charToIndexMap;
+    charToIndexMap;
     _readonly = false;
     _forbidIdx;
     _iTrieRoot;
-    wordToCharacters;
     info;
-    constructor(nodes, _charIndex, bitMasksInfo, options) {
+    constructor(nodes, charIndex, bitMasksInfo, options) {
         this.nodes = nodes;
-        this._charIndex = _charIndex;
+        this.charIndex = charIndex;
         this.bitMasksInfo = bitMasksInfo;
         this.info = mergeOptionalWithDefaults(options);
-        this.wordToCharacters = (word) => [...word];
-        this._charToIndexMap = createCharToIndexMap(_charIndex);
-        this._forbidIdx = this._searchNodeForChar(0, this.info.forbiddenWordPrefix);
+        this.charToIndexMap = createCharToIndexMap(charIndex);
+        this._forbidIdx = this._lookupChar(0, this.info.forbiddenWordPrefix);
     }
-    _lookUpCharIndex(char) {
-        return this._charToIndexMap[char] ?? -1;
-    }
-    wordToNodeCharIndexSequence(word) {
-        return TrieBlob.charactersToCharIndexSequence(this.wordToCharacters(word), (c) => this._lookUpCharIndex(c));
-    }
-    letterToNodeCharIndexSequence(letter) {
-        return TrieBlob.toCharIndexSequence(this._lookUpCharIndex(letter));
+    lookUpCharIndex(char) {
+        return this.charToIndexMap[char] ?? -1;
     }
     has(word) {
         return this._has(0, word);
@@ -41,11 +32,10 @@ export class FastTrieBlob {
         const NodeChildRefShift = this.bitMasksInfo.NodeChildRefShift;
         const NodeMaskEOW = this.bitMasksInfo.NodeMaskEOW;
         const nodes = this.nodes;
-        const charIndexes = this.wordToNodeCharIndexSequence(word);
-        const len = charIndexes.length;
+        const len = word.length;
         let node = nodes[nodeIdx];
         for (let p = 0; p < len; ++p, node = nodes[nodeIdx]) {
-            const letterIdx = charIndexes[p];
+            const letterIdx = this.lookUpCharIndex(word[p]);
             const count = node.length;
             let i = count - 1;
             for (; i > 0; --i) {
@@ -66,11 +56,10 @@ export class FastTrieBlob {
         const NodeChildRefShift = this.bitMasksInfo.NodeChildRefShift;
         const NodeMaskEOW = this.bitMasksInfo.NodeMaskEOW;
         const nodes = this.nodes;
-        const accumulator = NumberSequenceByteDecoderAccumulator.create();
-        const stack = [{ nodeIdx: 0, pos: 0, word: '', accumulator }];
+        const stack = [{ nodeIdx: 0, pos: 0, word: '' }];
         let depth = 0;
         while (depth >= 0) {
-            const { nodeIdx, pos, word, accumulator } = stack[depth];
+            const { nodeIdx, pos, word } = stack[depth];
             const node = nodes[nodeIdx];
             if (!pos && node[0] & NodeMaskEOW) {
                 yield word;
@@ -82,15 +71,12 @@ export class FastTrieBlob {
             const nextPos = ++stack[depth].pos;
             const entry = node[nextPos];
             const charIdx = entry & NodeMaskChildCharIndex;
-            const acc = accumulator.clone();
-            const letterIdx = acc.decode(charIdx);
-            const letter = (letterIdx && this._charIndex[letterIdx]) || '';
+            const letter = this.charIndex[charIdx];
             ++depth;
             stack[depth] = {
                 nodeIdx: entry >>> NodeChildRefShift,
                 pos: 0,
                 word: word + letter,
-                accumulator: acc,
             };
         }
     }
@@ -125,7 +111,7 @@ export class FastTrieBlob {
                 binNodes[offset++] = (nodeToIndex[nodeRef] << refShift) | charIndex;
             }
         }
-        return new TrieBlob(binNodes, this._charIndex, this.info);
+        return new TrieBlob(binNodes, this.charIndex, this.info);
     }
     isReadonly() {
         return this._readonly;
@@ -134,18 +120,11 @@ export class FastTrieBlob {
         this._readonly = true;
         return this;
     }
-    toJSON() {
-        return {
-            info: this.info,
-            nodes: nodesToJson(this.nodes),
-            charIndex: this._charIndex,
-        };
-    }
     static create(data, options) {
         return new FastTrieBlob(data.nodes, data.charIndex, extractInfo(data), options);
     }
     static toITrieNodeRoot(trie) {
-        return new FastTrieBlobIRoot(new FastTrieBlobInternals(trie.nodes, trie._charIndex, trie._charToIndexMap, trie.bitMasksInfo), 0, trie.info);
+        return new FastTrieBlobIRoot(new FastTrieBlobInternals(trie.nodes, trie.charIndex, trie.charToIndexMap, trie.bitMasksInfo), 0, trie.info);
     }
     static NodeMaskEOW = TrieBlob.NodeMaskEOW;
     static NodeChildRefShift = TrieBlob.NodeChildRefShift;
@@ -174,12 +153,12 @@ export class FastTrieBlob {
     get size() {
         return this.nodes.length;
     }
-    _lookupCharIndexNode(nodeIdx, charIndex) {
+    _lookupChar(nodeIdx, char) {
         const NodeMaskChildCharIndex = this.bitMasksInfo.NodeMaskChildCharIndex;
         const NodeChildRefShift = this.bitMasksInfo.NodeChildRefShift;
         const nodes = this.nodes;
         const node = nodes[nodeIdx];
-        const letterIdx = charIndex;
+        const letterIdx = this.lookUpCharIndex(char);
         const count = node.length;
         let i = count - 1;
         for (; i > 0; --i) {
@@ -189,54 +168,6 @@ export class FastTrieBlob {
         }
         return 0;
     }
-    /** Search from nodeIdx for the node index representing the character. */
-    _searchNodeForChar(nodeIdx, char) {
-        const charIndexes = this.letterToNodeCharIndexSequence(char);
-        let idx = nodeIdx;
-        for (let i = 0; i < charIndexes.length; ++i) {
-            idx = this._lookupCharIndexNode(idx, charIndexes[i]);
-            if (!idx)
-                return 0;
-        }
-        return idx;
-    }
-    get charIndex() {
-        return [...this._charIndex];
-    }
-    static fromTrieBlob(trie) {
-        const bitMasksInfo = {
-            NodeMaskEOW: TrieBlob.NodeMaskEOW,
-            NodeMaskChildCharIndex: TrieBlob.NodeMaskChildCharIndex,
-            NodeChildRefShift: TrieBlob.NodeChildRefShift,
-        };
-        const trieNodesBin = TrieBlob.nodesView(trie);
-        const nodeOffsets = [];
-        for (let offset = 0; offset < trieNodesBin.length; offset += (trieNodesBin[offset] & TrieBlob.NodeMaskNumChildren) + 1) {
-            nodeOffsets.push(offset);
-        }
-        const offsetToNodeIndex = new Map(nodeOffsets.map((offset, i) => [offset, i]));
-        const nodes = new Array(nodeOffsets.length);
-        for (let i = 0; i < nodes.length; ++i) {
-            const offset = nodeOffsets[i];
-            const n = trieNodesBin[offset];
-            const eow = n & TrieBlob.NodeMaskEOW;
-            const count = n & TrieBlob.NodeMaskNumChildren;
-            const node = new Array(count + 1);
-            node[0] = eow;
-            nodes[i] = node;
-            for (let j = 1; j <= count; ++j) {
-                const n = trieNodesBin[offset + j];
-                const charIndex = n & TrieBlob.NodeMaskChildCharIndex;
-                const nodeIndex = n >>> TrieBlob.NodeChildRefShift;
-                const idx = offsetToNodeIndex.get(nodeIndex);
-                if (idx === undefined) {
-                    throw new Error(`Invalid node index ${nodeIndex}`);
-                }
-                node[j] = (idx << TrieBlob.NodeChildRefShift) | charIndex;
-            }
-        }
-        return new FastTrieBlob(nodes, trie.charIndex, bitMasksInfo, trie.info);
-    }
 }
 function createCharToIndexMap(charIndex) {
     const map = Object.create(null);
@@ -247,16 +178,4 @@ function createCharToIndexMap(charIndex) {
     }
     return map;
 }
-function nodesToJson(nodes) {
-    function nodeElement(node, index) {
-        const eow = !!(node[0] & TrieBlob.NodeMaskEOW);
-        const children = node.slice(1).map((n) => ({
-            c: ('00' + (n & TrieBlob.NodeMaskChildCharIndex).toString(16)).slice(-2),
-            i: n >>> TrieBlob.NodeChildRefShift,
-        }));
-        return { id: index, eow, n: node.length, c: children };
-    }
-    const elements = nodes.map((n, i) => nodeElement(n, i));
-    return elements;
-}
 //# sourceMappingURL=FastTrieBlob.js.map

package/dist/lib/TrieBlob/FastTrieBlobBuilder.d.ts

@@ -11,14 +11,11 @@ export declare class FastTrieBlobBuilder implements TrieBuilder<FastTrieBlob> {
     private IdxEOW;
     private _cursor;
     private _options;
-    wordToCharacters: (word: string) => string[];
     readonly bitMasksInfo: FastTrieBlobBitMaskInfo;
     constructor(options?: PartialTrieInfo, bitMasksInfo?: FastTrieBlobBitMaskInfo);
     setOptions(options: PartialTrieInfo): Readonly<TrieInfo>;
     get options(): Readonly<TrieInfo>;
     private getCharIndex;
-    private wordToNodeCharIndexSequence;
-    private letterToNodeCharIndexSequence;
     insert(word: string | Iterable<string> | string[]): this;
     getCursor(): BuilderCursor;
     private createCursor;
@@ -27,7 +24,7 @@ export declare class FastTrieBlobBuilder implements TrieBuilder<FastTrieBlob> {
     isReadonly(): boolean;
     freeze(): this;
     build(): FastTrieBlob;
-    static fromWordList(words: readonly string[] | Iterable<string>, options?: PartialTrieInfo): FastTrieBlob;
+    static fromWordList(words: string[] | Iterable<string>, options?: PartialTrieInfo): FastTrieBlob;
     static fromTrieRoot(root: TrieRoot): FastTrieBlob;
     static NodeMaskEOW: number;
     static NodeChildRefShift: number;

package/dist/lib/TrieBlob/FastTrieBlobBuilder.js

@@ -1,6 +1,5 @@
 import { assert } from '../utils/assert.js';
 import { mergeOptionalWithDefaults } from '../utils/mergeOptionalWithDefaults.js';
-import { assertValidUtf16Character } from '../utils/text.js';
 import { FastTrieBlob } from './FastTrieBlob.js';
 import { FastTrieBlobInternals } from './FastTrieBlobInternals.js';
 import { resolveMap } from './resolveMap.js';
@@ -13,7 +12,6 @@ export class FastTrieBlobBuilder {
     IdxEOW;
     _cursor;
     _options;
-    wordToCharacters = (word) => [...word];
     bitMasksInfo;
     constructor(options, bitMasksInfo = FastTrieBlobBuilder.DefaultBitMaskInfo) {
         this._options = mergeOptionalWithDefaults(options);
@@ -39,12 +37,6 @@ export class FastTrieBlobBuilder {
         this.charToIndexMap[charNFD] = idx;
         return idx;
     }
-    wordToNodeCharIndexSequence(word) {
-        return TrieBlob.charactersToCharIndexSequence(this.wordToCharacters(word), (c) => this.getCharIndex(c));
-    }
-    letterToNodeCharIndexSequence(letter) {
-        return TrieBlob.toCharIndexSequence(this.getCharIndex(letter));
-    }
     insert(word) {
         if (this.isReadonly()) {
             throw new Error('FastTrieBlob is readonly');
@@ -84,43 +76,10 @@ export class FastTrieBlobBuilder {
         const eow = 1;
         const eowShifted = eow << NodeChildRefShift;
         const nodes = this.nodes;
-        const stack = [{ nodeIdx: 0, pos: 0, dCount: 1, ps: '' }];
+        const stack = [{ nodeIdx: 0, pos: 0 }];
         let nodeIdx = 0;
         let depth = 0;
         const insertChar = (char) => {
-            const cc = char.charCodeAt(0) & 0xdc00;
-            // Work with partial surrogate pairs.
-            if (cc === 0xd800 && char.length == 1) {
-                // We have a high surrogate
-                const s = stack[depth];
-                const ns = stack[++depth];
-                if (ns) {
-                    ns.nodeIdx = s.nodeIdx;
-                    ns.pos = s.pos;
-                    ns.dCount = 1;
-                    ns.ps = char;
-                }
-                else {
-                    stack[depth] = { nodeIdx: s.nodeIdx, pos: s.pos, dCount: 1, ps: char };
-                }
-                return;
-            }
-            if (stack[depth].ps) {
-                char = stack[depth].ps + char;
-                assertValidUtf16Character(char);
-            }
-            const indexSeq = this.letterToNodeCharIndexSequence(char);
-            for (let i = 0; i < indexSeq.length; ++i) {
-                insertCharIndexes(indexSeq[i], i + 1);
-            }
-        };
-        /**
-         * A single character can result in multiple nodes being created
-         * because it takes multiple bytes to represent a character.
-         * @param charIndex - partial character index.
-         * @param char - the source character
-         */
-        const insertCharIndexes = (charIndex, dCount) => {
             // console.warn('i %o at %o', char, nodeIdx);
             if (nodes[nodeIdx] && Object.isFrozen(nodes[nodeIdx])) {
                 nodeIdx = nodes.push([...nodes[nodeIdx]]) - 1;
@@ -132,7 +91,7 @@ export class FastTrieBlobBuilder {
             }
             const node = nodes[nodeIdx] ?? [0];
             nodes[nodeIdx] = node;
-            const letterIdx = charIndex;
+            const letterIdx = this.getCharIndex(char);
             const hasIdx = childPos(node, letterIdx);
             const childIdx = hasIdx ? node[hasIdx] >>> NodeChildRefShift : nodes.length;
             const pos = hasIdx || node.push((childIdx << NodeChildRefShift) | letterIdx) - 1;
@@ -141,11 +100,9 @@ export class FastTrieBlobBuilder {
             if (s) {
                 s.nodeIdx = nodeIdx;
                 s.pos = pos;
-                s.dCount = dCount;
-                s.ps = '';
             }
             else {
-                stack[depth] = { nodeIdx, pos, dCount, ps: '' };
+                stack[depth] = { nodeIdx, pos };
             }
             nodeIdx = childIdx;
         };
@@ -184,9 +141,7 @@ export class FastTrieBlobBuilder {
                 return;
             // console.warn('<< %o', num);
             assert(num <= depth && num > 0);
-            for (; num > 0; --num) {
-                depth -= stack[depth].dCount;
-            }
+            depth -= num;
             nodeIdx = stack[depth + 1].nodeIdx;
         };
         const c = {
@@ -206,11 +161,10 @@ export class FastTrieBlobBuilder {
         const NodeMaskEOW = this.bitMasksInfo.NodeMaskEOW;
         const IdxEOW = this.IdxEOW;
         const nodes = this.nodes;
-        const charIndexes = this.wordToNodeCharIndexSequence(word);
-        const len = charIndexes.length;
+        const len = word.length;
         let nodeIdx = 0;
         for (let p = 0; p < len; ++p) {
-            const letterIdx = charIndexes[p];
+            const letterIdx = this.getCharIndex(word[p]);
             const node = nodes[nodeIdx];
             const count = node.length;
             let i = count - 1;
@@ -243,12 +197,11 @@ export class FastTrieBlobBuilder {
         const NodeChildRefShift = this.bitMasksInfo.NodeChildRefShift;
         const NodeMaskEOW = this.bitMasksInfo.NodeMaskEOW;
         const nodes = this.nodes;
-        const charIndexes = this.wordToNodeCharIndexSequence(word);
-        const len = charIndexes.length;
+        const len = word.length;
         let nodeIdx = 0;
         let node = nodes[nodeIdx];
         for (let p = 0; p < len; ++p, node = nodes[nodeIdx]) {
-            const letterIdx = charIndexes[p];
+            const letterIdx = this.charToIndexMap[word[p]];
             const count = node.length;
             let i = count - 1;
             for (; i > 0; --i) {
@@ -281,7 +234,6 @@ export class FastTrieBlobBuilder {
     static fromTrieRoot(root) {
         const bitMasksInfo = FastTrieBlobBuilder.DefaultBitMaskInfo;
         const NodeChildRefShift = bitMasksInfo.NodeChildRefShift;
-        const NodeCharIndexMask = bitMasksInfo.NodeMaskChildCharIndex;
         const NodeMaskEOW = bitMasksInfo.NodeMaskEOW;
         const tf = new FastTrieBlobBuilder(undefined, bitMasksInfo);
         const IdxEOW = tf.IdxEOW;
@@ -301,37 +253,15 @@ export class FastTrieBlobBuilder {
             if (!n.c)
                 return nodeIdx;
             const children = Object.entries(n.c);
+            node.length = children.length + 1;
             for (let p = 0; p < children.length; ++p) {
                 const [char, childNode] = children[p];
-                addCharToNode(node, char, childNode);
+                const letterIdx = tf.getCharIndex(char);
+                const childIdx = walk(childNode);
+                node[p + 1] = (childIdx << NodeChildRefShift) | letterIdx;
             }
             return nodeIdx;
         }
-        function resolveChild(node, charIndex) {
-            let i = 1;
-            for (i = 1; i < node.length && (node[i] & NodeCharIndexMask) !== charIndex; ++i) {
-                // empty
-            }
-            return i;
-        }
-        function addCharToNode(node, char, n) {
-            const indexSeq = tf.letterToNodeCharIndexSequence(char);
-            for (const idx of indexSeq.slice(0, -1)) {
-                const pos = resolveChild(node, idx);
-                if (pos < node.length) {
-                    node = tf.nodes[node[pos] >>> NodeChildRefShift];
-                }
-                else {
-                    const next = [0];
-                    const nodeIdx = tf.nodes.push(next) - 1;
-                    node[pos] = (nodeIdx << NodeChildRefShift) | idx;
-                    node = next;
-                }
-            }
-            const letterIdx = indexSeq[indexSeq.length - 1];
-            const i = node.push(letterIdx) - 1;
-            node[i] = (walk(n) << NodeChildRefShift) | letterIdx;
-        }
         walk(root);
         return tf.build();
     }

package/dist/lib/TrieBlob/FastTrieBlobIRoot.d.ts

@@ -1,25 +1,19 @@
 import type { ITrieNode, ITrieNodeId, ITrieNodeRoot } from '../ITrieNode/ITrieNode.js';
 import type { TrieInfo } from '../ITrieNode/TrieInfo.js';
 import type { FastTrieBlobInternals } from './FastTrieBlobInternals.js';
-type Node = readonly number[];
-type NodeIndex = number;
 declare class FastTrieBlobINode implements ITrieNode {
     readonly trie: FastTrieBlobInternals;
-    readonly nodeIdx: NodeIndex;
+    readonly nodeIdx: number;
     readonly id: number;
-    readonly node: Node;
+    readonly size: number;
+    readonly node: number[];
     readonly eow: boolean;
+    charToIdx: Record<string, number> | undefined;
     private _keys;
-    private _count;
-    private _size;
-    private _chained;
-    private _nodesEntries;
-    private _entries;
-    private _values;
-    protected charToIdx: Readonly<Record<string, NodeIndex>> | undefined;
-    constructor(trie: FastTrieBlobInternals, nodeIdx: NodeIndex);
-    /** get keys to children */
+    constructor(trie: FastTrieBlobInternals, nodeIdx: number);
     keys(): readonly string[];
+    /** get keys to children */
+    private calcKeys;
     values(): readonly ITrieNode[];
     entries(): readonly (readonly [string, ITrieNode])[];
     /** get child ITrieNode */
@@ -28,10 +22,6 @@ declare class FastTrieBlobINode implements ITrieNode {
     hasChildren(): boolean;
     child(keyIdx: number): ITrieNode;
     getCharToIdxMap(): Record<string, number>;
-    private containsChainedIndexes;
-    private getNodesEntries;
-    private walkChainedIndexes;
-    get size(): number;
 }
 export declare class FastTrieBlobIRoot extends FastTrieBlobINode implements ITrieNodeRoot {
     readonly info: Readonly<TrieInfo>;