cspell-trie-lib 8.10.2 → 8.11.0

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

@@ -1,7 +1,10 @@
 export interface BuilderCursor {
+    /** Insert a character in the current node. */
     insertChar(char: string): void;
+    /** Mark the current node as End of Word */
     markEOW(): void;
-    reference(nodeIdx: number): void;
+    /** Refer to a previous node */
+    reference(refId: number): void;
     backStep(num: number): void;
 }
 //# sourceMappingURL=BuilderCursor.d.ts.map

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

@@ -1,17 +1,18 @@
 export function insertWordsAtCursor(cursor, words) {
-    let prevWord = '';
-    for (const word of words) {
-        const pLen = commonStrPrefix(prevWord, word);
-        const stepBack = prevWord.length - pLen;
+    let prevWordLetters = [];
+    for (const _word of words) {
+        const letters = [..._word];
+        const pLen = commonStrPrefix(prevWordLetters, letters);
+        const stepBack = prevWordLetters.length - pLen;
         cursor.backStep(stepBack);
-        const wLen = word.length;
+        const wLen = letters.length;
         for (let i = pLen; i < wLen; ++i) {
-            cursor.insertChar(word[i]);
+            cursor.insertChar(letters[i]);
         }
         cursor.markEOW();
-        prevWord = word;
+        prevWordLetters = letters;
     }
-    cursor.backStep(prevWord.length);
+    cursor.backStep(prevWordLetters.length);
 }
 export function commonStringPrefixLen(a, b) {
     let i = 0;

package/dist/lib/ITrie.d.ts

@@ -1,6 +1,6 @@
 import type { WeightMap } from './distance/index.js';
-import type { FindFullResult } from './ITrieNode/find.js';
 import type { ITrieNode } from './ITrieNode/index.js';
+import { FindFullResult } from './ITrieNode/ITrieNode.js';
 import type { PartialTrieInfo, TrieInfo } from './ITrieNode/TrieInfo.js';
 import type { CompoundWordsMethod, WalkerIterator } from './ITrieNode/walker/walkerTypes.js';
 import type { SuggestionCollector, SuggestionResult } from './suggestCollector.js';

package/dist/lib/ITrieNode/FindTypes.d.ts

@@ -0,0 +1,7 @@
+import type { FindFullResult, ITrieNode } from './ITrieNode.js';
+export interface FindNodeResult {
+    node: ITrieNode | undefined;
+}
+export interface FindFullNodeResult extends FindNodeResult, FindFullResult {
+}
+//# sourceMappingURL=FindTypes.d.ts.map

package/dist/lib/ITrieNode/FindTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FindTypes.js.map

package/dist/lib/ITrieNode/ITrieNode.d.ts

@@ -1,4 +1,25 @@
 import type { TrieInfo } from './TrieInfo.js';
+export interface FindResult {
+    found: string | false;
+    compoundUsed: boolean;
+    caseMatched: boolean;
+    /**
+     * Is the word explicitly forbidden.
+     * - `true` - word is in the forbidden list.
+     * - `false` - word is not in the forbidden list.
+     * - `undefined` - unknown - was not checked.
+     */
+    forbidden?: boolean | undefined;
+}
+export interface FindFullResult extends FindResult {
+    /**
+     * Is the word explicitly forbidden.
+     * - `true` - word is in the forbidden list.
+     * - `false` - word is not in the forbidden list.
+     * - `undefined` - unknown - was not checked.
+     */
+    forbidden: boolean | undefined;
+}
 export type ITrieNodeId = object | number | string;
 type Entry = readonly [string, ITrieNode];
 export interface ITrieNode {
@@ -37,6 +58,15 @@ export interface ITrieNodeRoot extends ITrieNode {
      * @param id an of a ITrieNode in this Trie
      */
     resolveId(id: ITrieNodeId): ITrieNode;
+    findExact?: ((word: string) => boolean) | undefined;
+    /**
+     * Try to find a word.
+     * @param word - the normalized word to look up.
+     * @param strict - if `true` the case and accents must match.
+     * @returns undefined if it did not try to find the word, otherwise a FindResult.
+     */
+    find?: ((word: string, strict: boolean) => FindResult | undefined) | undefined;
+    isForbidden?: ((word: string) => boolean) | undefined;
 }
 export {};
 //# sourceMappingURL=ITrieNode.d.ts.map

package/dist/lib/ITrieNode/find.d.ts

@@ -1,25 +1,7 @@
 import type { FindOptions, PartialFindOptions } from './FindOptions.js';
-import type { ITrieNode, ITrieNodeRoot } from './ITrieNode.js';
+import type { FindFullNodeResult } from './FindTypes.js';
+import type { FindFullResult, FindResult, ITrieNode, ITrieNodeRoot } from './ITrieNode.js';
 type Root = ITrieNodeRoot;
-export interface FindNodeResult {
-    node: ITrieNode | undefined;
-}
-export interface FindResult {
-    found: string | false;
-    compoundUsed: boolean;
-    caseMatched: boolean;
-}
-export interface FindFullResult extends FindResult {
-    /**
-     * Is the word explicitly forbidden.
-     * - `true` - word is in the forbidden list.
-     * - `false` - word is not in the forbidden list.
-     * - `undefined` - unknown - was not checked.
-     * */
-    forbidden: boolean | undefined;
-}
-export interface FindFullNodeResult extends FindNodeResult, FindFullResult {
-}
 /**
  *
  * @param root Trie root node. root.c contains the compound root and forbidden root.

package/dist/lib/ITrieNode/find.js

@@ -37,6 +37,11 @@ export function findWordNode(root, word, options) {
  * @param options
  */
 function _findWord(root, word, options) {
+    if (root.find) {
+        const found = root.find(word, options.matchCase);
+        if (found)
+            return found;
+    }
     const { node: _, ...result } = _findWordNode(root, word, options);
     return result;
 }
@@ -49,10 +54,10 @@ function _findWord(root, word, options) {
 function _findWordNode(root, word, options) {
     const trieInfo = root.info;
     const compoundMode = knownCompoundModes.get(options.compoundMode) || _defaultFindOptions.compoundMode;
-    const compoundPrefix = options.compoundMode === 'compound' ? trieInfo.compoundCharacter ?? options.compoundFix : '';
+    const compoundPrefix = options.compoundMode === 'compound' ? (trieInfo.compoundCharacter ?? options.compoundFix) : '';
     const ignoreCasePrefix = options.matchCase
         ? ''
-        : trieInfo.stripCaseAndAccentsPrefix ?? options.caseInsensitivePrefix;
+        : (trieInfo.stripCaseAndAccentsPrefix ?? options.caseInsensitivePrefix);
     function __findCompound() {
         const f = findCompoundWord(root, word, compoundPrefix, ignoreCasePrefix);
         const result = { ...f };
@@ -180,6 +185,9 @@ function findCompoundWord(root, word, compoundCharacter, ignoreCasePrefix) {
     return { found, compoundUsed, node, forbidden: undefined, caseMatched };
 }
 export function findWordExact(root, word) {
+    const r = root;
+    if (r?.findExact)
+        return r.findExact(word);
     return isEndOfWordNode(walk(root, word));
 }
 export function isEndOfWordNode(n) {
@@ -277,6 +285,9 @@ function findLegacyCompoundWord(roots, word, minCompoundLength) {
     return { found, compoundUsed, caseMatched };
 }
 export function isForbiddenWord(root, word, forbiddenPrefix) {
+    const r = root;
+    if (r?.isForbidden)
+        return r.isForbidden(word);
     return findWordExact(root?.get(forbiddenPrefix), word);
 }
 export const createFindOptions = memorizeLastCall(_createFindOptions);

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

@@ -0,0 +1,32 @@
+import { type Utf8BE32 } from './Utf8.js';
+export type Utf8Seq = Readonly<number[]>;
+export type CharIndexMap = Record<string, Utf8BE32>;
+export type RO_CharIndexMap = Readonly<CharIndexMap>;
+export type CharIndexSeqMap = Record<string, Utf8Seq>;
+export type RO_CharIndexSeqMap = Readonly<CharIndexSeqMap>;
+export declare class CharIndex {
+    #private;
+    readonly charIndex: readonly string[];
+    constructor(charIndex: readonly string[]);
+    getCharUtf8Seq(c: string): Utf8Seq;
+    wordToUtf8Seq(word: string): Utf8Seq;
+    indexContainsMultiByteChars(): boolean;
+    get size(): number;
+    toJSON(): {
+        charIndex: readonly string[];
+    };
+}
+export declare class CharIndexBuilder {
+    #private;
+    private readonly charIndex;
+    readonly charIndexMap: CharIndexMap;
+    readonly charIndexSeqMap: CharIndexSeqMap;
+    constructor();
+    getUtf8Value(c: string): number;
+    utf8ValueToUtf8Seq(idx: number): number[];
+    charToUtf8Seq(c: string): number[];
+    wordToUtf8Seq(word: string): number[];
+    get size(): number;
+    build(): CharIndex;
+}
+//# sourceMappingURL=CharIndex.d.ts.map

package/dist/lib/TrieBlob/CharIndex.js

@@ -0,0 +1,116 @@
+import { encodeTextToUtf8, encodeUtf8N_BE } from './Utf8.js';
+const emptySeq = [0];
+Object.freeze(emptySeq);
+export class CharIndex {
+    charIndex;
+    #charToUtf8SeqMap;
+    #lastWord = '';
+    #lastWordSeq = [];
+    #multiByteChars;
+    constructor(charIndex) {
+        this.charIndex = charIndex;
+        this.#charToUtf8SeqMap = buildCharIndexSequenceMap(charIndex);
+        this.#multiByteChars = Object.values(this.#charToUtf8SeqMap).some((c) => c.length > 1);
+    }
+    getCharUtf8Seq(c) {
+        const found = this.#charToUtf8SeqMap[c];
+        if (found)
+            return found;
+        const s = encodeTextToUtf8(c);
+        this.#charToUtf8SeqMap[c] = s;
+        return s;
+    }
+    wordToUtf8Seq(word) {
+        if (this.#lastWord === word)
+            return this.#lastWordSeq;
+        const seq = encodeTextToUtf8(word);
+        this.#lastWord = word;
+        this.#lastWordSeq = seq;
+        return seq;
+    }
+    indexContainsMultiByteChars() {
+        return this.#multiByteChars;
+    }
+    get size() {
+        return this.charIndex.length;
+    }
+    toJSON() {
+        return { charIndex: this.charIndex };
+    }
+}
+function buildCharIndexSequenceMap(charIndex) {
+    const map = Object.create(null);
+    for (const key of charIndex) {
+        map[key] = encodeTextToUtf8(key);
+    }
+    return map;
+}
+export class CharIndexBuilder {
+    charIndex = [];
+    charIndexMap = Object.create(null);
+    charIndexSeqMap = Object.create(null);
+    #mapIdxToSeq = new Map();
+    constructor() {
+        this.getUtf8Value('');
+    }
+    getUtf8Value(c) {
+        const found = this.charIndexMap[c];
+        if (found !== undefined) {
+            return found;
+        }
+        const nc = c.normalize('NFC');
+        this.charIndex.push(nc);
+        const utf8 = encodeUtf8N_BE(nc.codePointAt(0) || 0);
+        this.charIndexMap[c] = utf8;
+        this.charIndexMap[nc] = utf8;
+        this.charIndexMap[c.normalize('NFD')] = utf8;
+        return utf8;
+    }
+    utf8ValueToUtf8Seq(idx) {
+        const found = this.#mapIdxToSeq.get(idx);
+        if (found !== undefined) {
+            return found;
+        }
+        const seq = splitUtf8(idx);
+        this.#mapIdxToSeq.set(idx, seq);
+        return seq;
+    }
+    charToUtf8Seq(c) {
+        const idx = this.getUtf8Value(c);
+        return this.utf8ValueToUtf8Seq(idx);
+    }
+    wordToUtf8Seq(word) {
+        const seq = new Array(word.length);
+        let i = 0;
+        for (const c of word) {
+            const idx = this.getUtf8Value(c);
+            const cSep = this.utf8ValueToUtf8Seq(idx);
+            if (typeof cSep === 'number') {
+                seq[i++] = cSep;
+                continue;
+            }
+            for (const cIdx of cSep) {
+                seq[i++] = cIdx;
+            }
+        }
+        if (seq.length !== i)
+            seq.length = i;
+        return seq;
+    }
+    get size() {
+        return this.charIndex.length;
+    }
+    build() {
+        return new CharIndex(this.charIndex);
+    }
+}
+function splitUtf8(utf8) {
+    if (utf8 <= 0xff)
+        return [utf8];
+    if (utf8 <= 0xffff)
+        return [(utf8 >> 8) & 0xff, utf8 & 0xff];
+    if (utf8 <= 0xff_ffff)
+        return [(utf8 >> 16) & 0xff, (utf8 >> 8) & 0xff, utf8 & 0xff];
+    return [(utf8 >> 24) & 0xff, (utf8 >> 16) & 0xff, (utf8 >> 8) & 0xff, utf8 & 0xff].filter((v) => v);
+}
+//# sourceMappingURL=CharIndex.js.map

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

@@ -1,22 +1,25 @@
 import type { ITrieNode, ITrieNodeRoot } from '../ITrieNode/ITrieNode.js';
 import type { PartialTrieInfo, TrieInfo } from '../ITrieNode/TrieInfo.js';
 import type { TrieData } from '../TrieData.js';
+import { Utf8Seq } from './CharIndex.js';
 import { type FastTrieBlobBitMaskInfo } from './FastTrieBlobBitMaskInfo.js';
 import { FastTrieBlobInternals } from './FastTrieBlobInternals.js';
 import { TrieBlob } from './TrieBlob.js';
+import { Utf8Accumulator } from './Utf8.js';
+type FastTrieBlobNode = number[];
 export declare class FastTrieBlob implements TrieData {
+    #private;
     private nodes;
     private _charIndex;
     readonly bitMasksInfo: FastTrieBlobBitMaskInfo;
-    private _charToIndexMap;
+    readonly sorted: boolean;
     private _readonly;
     private _forbidIdx;
     private _iTrieRoot;
     wordToCharacters: (word: string) => readonly string[];
     readonly info: Readonly<TrieInfo>;
     private constructor();
-    private _lookUpCharIndex;
-    private wordToNodeCharIndexSequence;
+    wordToNodeCharIndexSequence(word: string): Utf8Seq;
     private letterToNodeCharIndexSequence;
     has(word: string): boolean;
     private _has;
@@ -26,8 +29,19 @@ export declare class FastTrieBlob implements TrieData {
     freeze(): this;
     toJSON(): {
         info: Readonly<TrieInfo>;
-        nodes: NodeElement[];
-        charIndex: readonly string[];
+        nodes: ({
+            i: number;
+            w: number;
+            c?: never;
+        } | {
+            i: number;
+            w: number;
+            c: {
+                i: number;
+                c: string | 0 | undefined;
+                s: string;
+            }[];
+        })[];
     };
     static create(data: FastTrieBlobInternals, options?: PartialTrieInfo): FastTrieBlob;
     static toITrieNodeRoot(trie: FastTrieBlob): ITrieNodeRoot;
@@ -40,6 +54,7 @@ export declare class FastTrieBlob implements TrieData {
     getNode(prefix: string): ITrieNode | undefined;
     isForbiddenWord(word: string): boolean;
     hasForbiddenWords(): boolean;
+    nodeInfo(nodeIndex: number, accumulator?: Utf8Accumulator): TrieBlobNodeInfo;
     /** number of nodes */
     get size(): number;
     private _lookupCharIndexNode;
@@ -47,15 +62,28 @@ export declare class FastTrieBlob implements TrieData {
     private _searchNodeForChar;
     get charIndex(): readonly string[];
     static fromTrieBlob(trie: TrieBlob): FastTrieBlob;
+    static isFastTrieBlob(obj: unknown): obj is FastTrieBlob;
 }
-interface NodeElement {
-    id: number;
+interface TrieBlobNodeInfo {
     eow: boolean;
-    n: number;
-    c: {
-        c: number | string;
+    children: {
+        c: string;
         i: number;
+        cIdx: number;
     }[];
 }
+export declare function nodesToJSON(nodes: Readonly<FastTrieBlobNode[]>): ({
+    i: number;
+    w: number;
+    c?: never;
+} | {
+    i: number;
+    w: number;
+    c: {
+        i: number;
+        c: string | 0 | undefined;
+        s: string;
+    }[];
+})[];
 export {};
 //# sourceMappingURL=FastTrieBlob.d.ts.map

package/dist/lib/TrieBlob/FastTrieBlob.js

@@ -1,42 +1,47 @@
 import { findNode } from '../ITrieNode/trie-util.js';
 import { mergeOptionalWithDefaults } from '../utils/mergeOptionalWithDefaults.js';
 import { extractInfo } from './FastTrieBlobBitMaskInfo.js';
-import { FastTrieBlobInternals } from './FastTrieBlobInternals.js';
+import { assertSorted, FastTrieBlobInternals, sortNodes } from './FastTrieBlobInternals.js';
 import { FastTrieBlobIRoot } from './FastTrieBlobIRoot.js';
-import { NumberSequenceByteDecoderAccumulator } from './NumberSequenceByteDecoderAccumulator.js';
 import { TrieBlob } from './TrieBlob.js';
+import { Utf8Accumulator } from './Utf8.js';
+const useSorted = true;
+const checkSorted = false;
 export class FastTrieBlob {
     nodes;
     _charIndex;
     bitMasksInfo;
-    _charToIndexMap;
+    sorted;
     _readonly = false;
     _forbidIdx;
     _iTrieRoot;
     wordToCharacters;
     info;
-    constructor(nodes, _charIndex, bitMasksInfo, options) {
+    constructor(nodes, _charIndex, bitMasksInfo, sorted, options) {
         this.nodes = nodes;
         this._charIndex = _charIndex;
         this.bitMasksInfo = bitMasksInfo;
+        this.sorted = sorted;
         this.info = mergeOptionalWithDefaults(options);
         this.wordToCharacters = (word) => [...word];
-        this._charToIndexMap = createCharToIndexMap(_charIndex);
         this._forbidIdx = this._searchNodeForChar(0, this.info.forbiddenWordPrefix);
-    }
-    _lookUpCharIndex(char) {
-        return this._charToIndexMap[char] ?? -1;
+        if (sorted && checkSorted) {
+            assertSorted(nodes, bitMasksInfo.NodeMaskChildCharIndex);
+        }
     }
     wordToNodeCharIndexSequence(word) {
-        return TrieBlob.charactersToCharIndexSequence(this.wordToCharacters(word), (c) => this._lookUpCharIndex(c));
+        return this._charIndex.wordToUtf8Seq(word);
     }
     letterToNodeCharIndexSequence(letter) {
-        return TrieBlob.toCharIndexSequence(this._lookUpCharIndex(letter));
+        return this._charIndex.getCharUtf8Seq(letter);
     }
     has(word) {
         return this._has(0, word);
     }
     _has(nodeIdx, word) {
+        return this.sorted && useSorted ? this.#hasSorted(nodeIdx, word) : this.#has(nodeIdx, word);
+    }
+    #has(nodeIdx, word) {
         const NodeMaskChildCharIndex = this.bitMasksInfo.NodeMaskChildCharIndex;
         const NodeChildRefShift = this.bitMasksInfo.NodeChildRefShift;
         const NodeMaskEOW = this.bitMasksInfo.NodeMaskEOW;
@@ -61,12 +66,47 @@ export class FastTrieBlob {
         }
         return !!(node[0] & NodeMaskEOW);
     }
+    #hasSorted(nodeIdx, word) {
+        const NodeMaskChildCharIndex = this.bitMasksInfo.NodeMaskChildCharIndex;
+        const NodeChildRefShift = this.bitMasksInfo.NodeChildRefShift;
+        const NodeMaskEOW = this.bitMasksInfo.NodeMaskEOW;
+        const nodes = this.nodes;
+        const charIndexes = this.wordToNodeCharIndexSequence(word);
+        const len = charIndexes.length;
+        let node = nodes[nodeIdx];
+        for (let p = 0; p < len; ++p, node = nodes[nodeIdx]) {
+            const letterIdx = charIndexes[p];
+            const count = node.length;
+            // console.error('%o', { p, letterIdx, ...this.nodeInfo(nodeIdx) });
+            if (count < 2)
+                return false;
+            let i = 1;
+            let j = count - 1;
+            let c = -1;
+            while (i < j) {
+                const m = (i + j) >> 1;
+                c = node[m] & NodeMaskChildCharIndex;
+                if (c < letterIdx) {
+                    i = m + 1;
+                }
+                else {
+                    j = m;
+                }
+            }
+            if (i >= count || (node[i] & NodeMaskChildCharIndex) !== letterIdx)
+                return false;
+            nodeIdx = node[i] >>> NodeChildRefShift;
+            if (!nodeIdx)
+                return false;
+        }
+        return !!(node[0] & NodeMaskEOW);
+    }
     *words() {
         const NodeMaskChildCharIndex = this.bitMasksInfo.NodeMaskChildCharIndex;
         const NodeChildRefShift = this.bitMasksInfo.NodeChildRefShift;
         const NodeMaskEOW = this.bitMasksInfo.NodeMaskEOW;
         const nodes = this.nodes;
-        const accumulator = NumberSequenceByteDecoderAccumulator.create();
+        const accumulator = Utf8Accumulator.create();
         const stack = [{ nodeIdx: 0, pos: 0, word: '', accumulator }];
         let depth = 0;
         while (depth >= 0) {
@@ -83,8 +123,8 @@ export class FastTrieBlob {
             const entry = node[nextPos];
             const charIdx = entry & NodeMaskChildCharIndex;
             const acc = accumulator.clone();
-            const letterIdx = acc.decode(charIdx);
-            const letter = (letterIdx && this._charIndex[letterIdx]) || '';
+            const codePoint = acc.decode(charIdx);
+            const letter = (codePoint && String.fromCodePoint(codePoint)) || '';
             ++depth;
             stack[depth] = {
                 nodeIdx: entry >>> NodeChildRefShift,
@@ -137,15 +177,15 @@ export class FastTrieBlob {
     toJSON() {
         return {
             info: this.info,
-            nodes: nodesToJson(this.nodes),
-            charIndex: this._charIndex,
+            nodes: nodesToJSON(this.nodes),
+            // charIndex: this._charIndex,
         };
     }
     static create(data, options) {
-        return new FastTrieBlob(data.nodes, data.charIndex, extractInfo(data), options);
+        return new FastTrieBlob(data.nodes, data.charIndex, extractInfo(data), data.sorted, 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.bitMasksInfo), 0, trie.info);
     }
     static NodeMaskEOW = TrieBlob.NodeMaskEOW;
     static NodeChildRefShift = TrieBlob.NodeChildRefShift;
@@ -170,6 +210,20 @@ export class FastTrieBlob {
     hasForbiddenWords() {
         return !!this._forbidIdx;
     }
+    nodeInfo(nodeIndex, accumulator) {
+        const acc = accumulator ?? Utf8Accumulator.create();
+        const n = this.nodes[nodeIndex];
+        const eow = !!(n[0] & this.bitMasksInfo.NodeMaskEOW);
+        const children = n.slice(1).map((v) => {
+            const cIdx = v & this.bitMasksInfo.NodeMaskChildCharIndex;
+            const a = acc.clone();
+            const codePoint = a.decode(cIdx);
+            const c = codePoint !== undefined ? String.fromCodePoint(codePoint) : '∎';
+            const i = v >>> this.bitMasksInfo.NodeChildRefShift;
+            return { c, i, cIdx };
+        });
+        return { eow, children };
+    }
     /** number of nodes */
     get size() {
         return this.nodes.length;
@@ -201,7 +255,7 @@ export class FastTrieBlob {
         return idx;
     }
     get charIndex() {
-        return [...this._charIndex];
+        return [...this._charIndex.charIndex];
     }
     static fromTrieBlob(trie) {
         const bitMasksInfo = {
@@ -236,28 +290,42 @@ export class FastTrieBlob {
                 node[j] = (idx << TrieBlob.NodeChildRefShift) | charIndex;
             }
         }
-        return new FastTrieBlob(nodes, trie.charIndex, bitMasksInfo, trie.info);
+        return new FastTrieBlob(sortNodes(nodes, TrieBlob.NodeMaskChildCharIndex), trie.charIndex, bitMasksInfo, true, trie.info);
     }
-}
-function createCharToIndexMap(charIndex) {
-    const map = Object.create(null);
-    for (let i = 0; i < charIndex.length; ++i) {
-        const char = charIndex[i];
-        map[char.normalize('NFC')] = i;
-        map[char.normalize('NFD')] = i;
+    static isFastTrieBlob(obj) {
+        return obj instanceof FastTrieBlob;
     }
-    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 };
+export function nodesToJSON(nodes) {
+    const mapNodeToAcc = new Map();
+    function mapNode(node, i) {
+        if (node.length === 1) {
+            return {
+                i,
+                w: (!!(node[0] & TrieBlob.NodeMaskEOW) && 1) || 0,
+            };
+        }
+        const acc = mapNodeToAcc.get(node) || Utf8Accumulator.create();
+        function mapChild(n) {
+            const index = n >>> TrieBlob.NodeChildRefShift;
+            const seq = n & TrieBlob.NodeMaskChildCharIndex;
+            const cAcc = acc.clone();
+            const codePoint = cAcc.decode(seq);
+            if (codePoint === undefined) {
+                mapNodeToAcc.set(nodes[index], cAcc);
+            }
+            return {
+                i: index,
+                c: codePoint && String.fromCodePoint(codePoint),
+                s: seq.toString(16).padStart(2, '0'),
+            };
+        }
+        return {
+            i,
+            w: (!!(node[0] & TrieBlob.NodeMaskEOW) && 1) || 0,
+            c: node.slice(1).map(mapChild),
+        };
     }
-    const elements = nodes.map((n, i) => nodeElement(n, i));
-    return elements;
+    return nodes.map((n, i) => mapNode(n, i));
 }
 //# sourceMappingURL=FastTrieBlob.js.map