cspell-trie-lib 8.11.0 → 8.13.0

package/dist/lib/ITrie.d.ts

@@ -79,18 +79,23 @@ export interface ITrie {
      * On the returned Iterator, calling .next(goDeeper: boolean), allows for controlling the depth.
      */
     iterate(): WalkerIterator;
-    weightMap: WeightMap | undefined;
-    get isCaseAware(): boolean;
+    readonly weightMap: WeightMap | undefined;
+    readonly isCaseAware: boolean;
+    readonly hasForbiddenWords: boolean;
+    readonly hasCompoundWords: boolean;
+    readonly hasNonStrictWords: boolean;
 }
 export declare class ITrieImpl implements ITrie {
+    #private;
     readonly data: TrieData;
     private numNodes?;
     private _info;
-    private _findOptionsDefaults;
-    private hasForbidden;
     private root;
     private count?;
     weightMap: WeightMap | undefined;
+    readonly hasForbiddenWords: boolean;
+    readonly hasCompoundWords: boolean;
+    readonly hasNonStrictWords: boolean;
     constructor(data: TrieData, numNodes?: number | undefined);
     /**
      * Number of words in the Trie, the first call to this method might be expensive.
@@ -154,11 +159,10 @@ export declare class ITrieImpl implements ITrie {
     iterate(): WalkerIterator;
     static create(words: Iterable<string> | IterableIterator<string>, info?: PartialTrieInfo): ITrie;
     private createFindOptions;
-    private lastCreateFindOptionsMatchCaseMap;
-    private createFindOptionsMatchCase;
 }
 export interface FindWordOptions {
     caseSensitive?: boolean;
     useLegacyWordCompounds?: boolean | number;
+    checkForbidden?: boolean;
 }
 //# sourceMappingURL=ITrie.d.ts.map

package/dist/lib/ITrie.js

@@ -13,22 +13,21 @@ export class ITrieImpl {
     data;
     numNodes;
     _info;
-    _findOptionsDefaults;
-    hasForbidden;
     root;
     count;
     weightMap;
+    #optionsCompound = this.createFindOptions({ compoundMode: 'compound' });
+    hasForbiddenWords;
+    hasCompoundWords;
+    hasNonStrictWords;
     constructor(data, numNodes) {
         this.data = data;
         this.numNodes = numNodes;
         this.root = data.getRoot();
         this._info = mergeOptionalWithDefaults(data.info);
-        this.hasForbidden = data.hasForbiddenWords();
-        this._findOptionsDefaults = {
-            caseInsensitivePrefix: this._info.stripCaseAndAccentsPrefix,
-            compoundFix: this._info.compoundCharacter,
-            forbidPrefix: this._info.forbiddenWordPrefix,
-        };
+        this.hasForbiddenWords = data.hasForbiddenWords;
+        this.hasCompoundWords = data.hasCompoundWords;
+        this.hasNonStrictWords = data.hasNonStrictWords;
     }
     /**
      * Number of words in the Trie, the first call to this method might be expensive.
@@ -54,8 +53,7 @@ export class ITrieImpl {
      * @param text - text to find in the Trie
      */
     find(text) {
-        const options = this.createFindOptions({ compoundMode: 'compound' });
-        return findWordNode(this.data.getRoot(), text, options).node;
+        return findWordNode(this.data.getRoot(), text, this.#optionsCompound).node;
     }
     has(word, minLegacyCompoundLength) {
         if (this.hasWord(word, false))
@@ -73,8 +71,8 @@ export class ITrieImpl {
      * @returns true if the word was found and is not forbidden.
      */
     hasWord(word, caseSensitive) {
-        const f = this.findWord(word, { caseSensitive });
-        return !!f.found && !f.forbidden;
+        const f = this.findWord(word, { caseSensitive, checkForbidden: false });
+        return !!f.found;
     }
     findWord(word, options) {
         if (options?.useLegacyWordCompounds) {
@@ -83,19 +81,21 @@ export class ITrieImpl {
                 : defaultLegacyMinCompoundLength;
             const findOptions = this.createFindOptions({
                 legacyMinCompoundLength: len,
-                matchCase: options.caseSensitive,
+                matchCase: options.caseSensitive || false,
             });
             return findLegacyCompound(this.root, word, findOptions);
         }
-        const findOptions = this.createFindOptionsMatchCase(options?.caseSensitive);
-        return findWord(this.root, word, findOptions);
+        return findWord(this.root, word, {
+            matchCase: options?.caseSensitive,
+            checkForbidden: options?.checkForbidden,
+        });
     }
     /**
      * Determine if a word is in the forbidden word list.
      * @param word the word to lookup.
      */
     isForbiddenWord(word) {
-        return this.hasForbidden && isForbiddenWord(this.root, word, this.info.forbiddenWordPrefix);
+        return this.hasForbiddenWords && isForbiddenWord(this.root, word, this.info.forbiddenWordPrefix);
     }
     /**
      * Provides an ordered sequence of words with the prefix of text.
@@ -165,20 +165,8 @@ export class ITrieImpl {
         const root = builder.build();
         return new ITrieImpl(root, undefined);
     }
-    createFindOptions(options = {}) {
-        const findOptions = createFindOptions({
-            ...this._findOptionsDefaults,
-            ...options,
-        });
-        return findOptions;
-    }
-    lastCreateFindOptionsMatchCaseMap = new Map();
-    createFindOptionsMatchCase(matchCase) {
-        const f = this.lastCreateFindOptionsMatchCaseMap.get(matchCase);
-        if (f !== undefined)
-            return f;
-        const findOptions = this.createFindOptions({ matchCase });
-        this.lastCreateFindOptionsMatchCaseMap.set(matchCase, findOptions);
+    createFindOptions(options) {
+        const findOptions = createFindOptions(options);
         return findOptions;
     }
 }

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

@@ -3,10 +3,8 @@ import type { CompoundModes } from './CompoundModes.js';
 export interface FindOptions {
     matchCase: boolean;
     compoundMode: CompoundModes;
-    forbidPrefix: string;
-    compoundFix: string;
-    caseInsensitivePrefix: string;
-    legacyMinCompoundLength: number;
+    legacyMinCompoundLength?: number | undefined;
+    checkForbidden?: boolean | undefined;
 }
 export type PartialFindOptions = PartialWithUndefined<FindOptions> | undefined;
 //# sourceMappingURL=FindOptions.d.ts.map

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

@@ -34,31 +34,31 @@ export interface ITrieNode {
     readonly id: ITrieNodeId;
     /** flag End of Word */
     readonly eow: boolean;
-    /** number of children */
-    readonly size: number;
     /** get keys to children */
-    keys(): readonly string[];
+    keys(): Iterable<string>;
     /** get keys to children */
-    values(): readonly ITrieNode[];
+    values(): Iterable<ITrieNode>;
     /** get the children as key value pairs */
-    entries(): readonly Entry[];
+    entries(): Iterable<Entry>;
     /** get child ITrieNode */
     get(char: string): ITrieNode | undefined;
-    /** get a child by the key index */
-    child(idx: number): ITrieNode;
+    /** get a nested child ITrieNode */
+    getNode?: (chars: string) => ITrieNode | undefined;
     /** has child */
     has(char: string): boolean;
     /** `true` iff this node has children */
     hasChildren(): boolean;
+    /** check if a word exists within this node. */
+    findExact?: ((word: string) => boolean) | undefined;
 }
 export interface ITrieNodeRoot extends ITrieNode {
-    info: Readonly<TrieInfo>;
+    readonly info: Readonly<TrieInfo>;
     /**
      * converts an `id` into a node.
      * @param id an of a ITrieNode in this Trie
      */
     resolveId(id: ITrieNodeId): ITrieNode;
-    findExact?: ((word: string) => boolean) | undefined;
+    findExact: ((word: string) => boolean) | undefined;
     /**
      * Try to find a word.
      * @param word - the normalized word to look up.
@@ -67,6 +67,12 @@ export interface ITrieNodeRoot extends ITrieNode {
      */
     find?: ((word: string, strict: boolean) => FindResult | undefined) | undefined;
     isForbidden?: ((word: string) => boolean) | undefined;
+    readonly forbidPrefix: string;
+    readonly compoundFix: string;
+    readonly caseInsensitivePrefix: string;
+    readonly hasForbiddenWords: boolean;
+    readonly hasCompoundWords: boolean;
+    readonly hasNonStrictWords: boolean;
 }
 export {};
 //# sourceMappingURL=ITrieNode.d.ts.map

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

@@ -5,5 +5,10 @@ export interface TrieInfo {
     forbiddenWordPrefix: string;
     isCaseAware: boolean;
 }
+export interface TrieCharacteristics {
+    hasForbiddenWords: boolean;
+    hasCompoundWords: boolean;
+    hasNonStrictWords: boolean;
+}
 export type PartialTrieInfo = PartialWithUndefined<TrieInfo> | undefined;
 //# sourceMappingURL=TrieInfo.d.ts.map

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

@@ -8,15 +8,15 @@ type Root = ITrieNodeRoot;
  * @param word A pre normalized word use `normalizeWord` or `normalizeWordToLowercase`
  * @param options
  */
-export declare function findWord(root: Root, word: string, options?: PartialFindOptions): FindFullResult;
+export declare function findWordNode(root: Root, word: string, options?: PartialFindOptions): FindFullNodeResult;
 /**
  *
  * @param root Trie root node. root.c contains the compound root and forbidden root.
  * @param word A pre normalized word use `normalizeWord` or `normalizeWordToLowercase`
  * @param options
  */
-export declare function findWordNode(root: Root, word: string, options?: PartialFindOptions): FindFullNodeResult;
-export declare function findLegacyCompound(root: Root, word: string, options: FindOptions): FindFullNodeResult;
+export declare function findWord(root: Root, word: string, options?: PartialFindOptions): FindFullResult;
+export declare function findLegacyCompound(root: Root, word: string, options: PartialFindOptions): FindFullNodeResult;
 export declare function findCompoundNode(root: Root | undefined, word: string, compoundCharacter: string, ignoreCasePrefix: string): FindFullNodeResult;
 export declare function findWordExact(root: Root | ITrieNode | undefined, word: string): boolean;
 export declare function isEndOfWordNode(n: ITrieNode | undefined): boolean;

package/dist/lib/ITrieNode/find.js

@@ -1,26 +1,15 @@
-import { CASE_INSENSITIVE_PREFIX, COMPOUND_FIX, FORBID_PREFIX } from '../constants.js';
 import { memorizeLastCall } from '../utils/memorizeLastCall.js';
-import { mergeDefaults } from '../utils/mergeDefaults.js';
 const defaultLegacyMinCompoundLength = 3;
 const _defaultFindOptions = {
     matchCase: false,
     compoundMode: 'compound',
-    forbidPrefix: FORBID_PREFIX,
-    compoundFix: COMPOUND_FIX,
-    caseInsensitivePrefix: CASE_INSENSITIVE_PREFIX,
     legacyMinCompoundLength: defaultLegacyMinCompoundLength,
 };
+Object.freeze(_defaultFindOptions);
 const arrayCompoundModes = ['none', 'compound', 'legacy'];
 const knownCompoundModes = new Map(arrayCompoundModes.map((a) => [a, a]));
-/**
- *
- * @param root Trie root node. root.c contains the compound root and forbidden root.
- * @param word A pre normalized word use `normalizeWord` or `normalizeWordToLowercase`
- * @param options
- */
-export function findWord(root, word, options) {
-    return _findWord(root, word, createFindOptions(options));
-}
+const notFound = { found: false, compoundUsed: false, caseMatched: false, forbidden: undefined };
+Object.freeze(notFound);
 /**
  *
  * @param root Trie root node. root.c contains the compound root and forbidden root.
@@ -28,7 +17,7 @@ export function findWord(root, word, options) {
  * @param options
  */
 export function findWordNode(root, word, options) {
-    return _findWordNode(root, word, createFindOptions(options));
+    return _findWordNode(root, word, options);
 }
 /**
  *
@@ -36,14 +25,23 @@ export function findWordNode(root, word, options) {
  * @param word A pre normalized word use `normalizeWord` or `normalizeWordToLowercase`
  * @param options
  */
-function _findWord(root, word, options) {
+export function findWord(root, word, options) {
     if (root.find) {
-        const found = root.find(word, options.matchCase);
+        const found = root.find(word, options?.matchCase || false);
         if (found)
             return found;
+        if (!root.hasCompoundWords) {
+            return notFound;
+        }
     }
-    const { node: _, ...result } = _findWordNode(root, word, options);
-    return result;
+    // return { found: false, compoundUsed: false, caseMatched: false, forbidden: false };
+    const v = _findWordNode(root, word, options);
+    return {
+        found: v.found,
+        compoundUsed: v.compoundUsed,
+        caseMatched: v.caseMatched,
+        forbidden: v.forbidden,
+    };
 }
 /**
  *
@@ -53,29 +51,29 @@ 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 ignoreCasePrefix = options.matchCase
-        ? ''
-        : (trieInfo.stripCaseAndAccentsPrefix ?? options.caseInsensitivePrefix);
+    const matchCase = options?.matchCase || false;
+    const compoundMode = knownCompoundModes.get(options?.compoundMode) || _defaultFindOptions.compoundMode;
+    const compoundPrefix = compoundMode === 'compound' ? (trieInfo.compoundCharacter ?? root.compoundFix) : '';
+    const ignoreCasePrefix = matchCase ? '' : (trieInfo.stripCaseAndAccentsPrefix ?? root.caseInsensitivePrefix);
+    const checkForbidden = options?.checkForbidden ?? true;
     function __findCompound() {
         const f = findCompoundWord(root, word, compoundPrefix, ignoreCasePrefix);
         const result = { ...f };
         if (f.found !== false && f.compoundUsed) {
             // If case was ignored when searching for the word, then check the forbidden
             // in the ignore case forbidden list.
-            const r = !f.caseMatched ? walk(root, options.caseInsensitivePrefix) : root;
-            result.forbidden = isForbiddenWord(r, word, options.forbidPrefix);
+            const r = !f.caseMatched ? walk(root, root.caseInsensitivePrefix) : root;
+            result.forbidden = checkForbidden ? isForbiddenWord(r, word, root.forbidPrefix) : undefined;
         }
         return result;
     }
     function __findExact() {
-        const n = walk(root, word);
+        const n = root.getNode ? root.getNode(word) : walk(root, word);
         const isFound = isEndOfWordNode(n);
         const result = {
             found: isFound && word,
             compoundUsed: false,
-            forbidden: isForbiddenWord(root, word, options.forbidPrefix),
+            forbidden: checkForbidden ? isForbiddenWord(root, word, root.forbidPrefix) : undefined,
             node: n,
             caseMatched: true,
         };
@@ -83,7 +81,7 @@ function _findWordNode(root, word, options) {
     }
     switch (compoundMode) {
         case 'none': {
-            return options.matchCase ? __findExact() : __findCompound();
+            return matchCase ? __findExact() : __findCompound();
         }
         case 'compound': {
             return __findCompound();
@@ -95,10 +93,10 @@ function _findWordNode(root, word, options) {
 }
 export function findLegacyCompound(root, word, options) {
     const roots = [root];
-    if (!options.matchCase) {
-        roots.push(walk(root, options.caseInsensitivePrefix));
+    if (!options?.matchCase) {
+        roots.push(walk(root, root.caseInsensitivePrefix));
     }
-    return findLegacyCompoundNode(roots, word, options.legacyMinCompoundLength);
+    return findLegacyCompoundNode(roots, word, options?.legacyMinCompoundLength || defaultLegacyMinCompoundLength);
 }
 export function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix) {
     // Approach - do a depth first search for the matching word.
@@ -108,7 +106,8 @@ export function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix
     ];
     const compoundPrefix = compoundCharacter || ignoreCasePrefix;
     const possibleCompoundPrefix = ignoreCasePrefix && compoundCharacter ? ignoreCasePrefix + compoundCharacter : '';
-    const w = word.normalize();
+    const nw = word.normalize();
+    const w = [...nw];
     function determineRoot(s) {
         const prefix = s.compoundPrefix;
         let r = root;
@@ -132,7 +131,7 @@ export function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix
         const s = stack[i];
         const h = w[i++];
         const n = s.cr || s.n;
-        const c = n?.get(h);
+        const c = (h && n?.get(h)) || undefined;
         if (c && i < word.length) {
             // Go deeper.
             caseMatched = s.caseMatched;
@@ -156,7 +155,7 @@ export function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix
                 if (!r.cr) {
                     break;
                 }
-                if (!i && !r.caseMatched && w !== w.toLowerCase()) {
+                if (!i && !r.caseMatched && nw !== nw.toLowerCase()) {
                     // It is not going to be found.
                     break;
                 }
@@ -171,7 +170,7 @@ export function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix
             break;
         }
     }
-    const found = (i && i === word.length && word) || false;
+    const found = (i === word.length && word) || false;
     const result = { found, compoundUsed, node, forbidden: undefined, caseMatched };
     return result;
 }
@@ -292,7 +291,15 @@ export function isForbiddenWord(root, word, forbiddenPrefix) {
 }
 export const createFindOptions = memorizeLastCall(_createFindOptions);
 function _createFindOptions(options) {
-    return mergeDefaults(options, _defaultFindOptions);
+    if (!options)
+        return _defaultFindOptions;
+    const d = _defaultFindOptions;
+    return {
+        matchCase: options.matchCase ?? d.matchCase,
+        compoundMode: options.compoundMode ?? d.compoundMode,
+        legacyMinCompoundLength: options.legacyMinCompoundLength ?? d.legacyMinCompoundLength,
+        checkForbidden: options.checkForbidden ?? d.checkForbidden,
+    };
 }
 export const __testing__ = {
     findLegacyCompoundWord,

package/dist/lib/ITrieNode/trie-util.js

@@ -34,8 +34,8 @@ export function countNodes(root) {
         if (seen.has(n.id))
             return;
         seen.add(n.id);
-        for (let i = 0; i < n.size; ++i) {
-            walk(n.child(i));
+        for (const c of n.values()) {
+            walk(c);
         }
     }
     walk(root);
@@ -51,9 +51,8 @@ export function countWords(root) {
         let cnt = n.eow ? 1 : 0;
         // add the node to the set to avoid getting stuck on circular references.
         visited.set(n, cnt);
-        const size = n.size;
-        for (let i = 0; i < size; ++i) {
-            cnt += walk(n.child(i));
+        for (const c of n.values()) {
+            cnt += walk(c);
         }
         visited.set(n, cnt);
         return cnt;

package/dist/lib/ITrieNode/walker/hintedWalker.js

@@ -42,8 +42,8 @@ function* hintedWalkerNext(root, ignoreCase, hint, compoundingMethod, emitWordSe
             // We don't want to suggest the compound character.
             hints.add(compoundCharacter);
             // Then yield everything else.
-            yield* n
-                .entries()
+            const entries = n.entries();
+            yield* (Array.isArray(entries) ? entries : [...entries])
                 .filter((a) => !hints.has(a[0]))
                 .map(([letter, node]) => ({
                 letter,
@@ -109,10 +109,8 @@ class ITrieNodeFiltered {
         this.srcNode = srcNode;
         this.id = srcNode.id;
         this.eow = srcNode.eow;
-        const keys = srcNode.keys();
-        this.filtered = keys
-            .map((key, idx) => [key, idx])
-            .filter(([key, idx]) => predicate(key, idx, srcNode));
+        const entries = srcNode.entries();
+        this.filtered = (Array.isArray(entries) ? entries : [...entries]).filter(([key], idx) => predicate(key, idx, srcNode));
         this.keyMap = new Map(this.filtered);
         this.size = this.keyMap.size;
     }
@@ -120,14 +118,10 @@ class ITrieNodeFiltered {
         return [...this.keyMap.keys()];
     }
     values() {
-        return this.filtered.map(([_, idx]) => this.srcNode.child(idx));
-    }
-    child(idx) {
-        const [_, srcIdx] = this.filtered[idx];
-        return this.srcNode.child(srcIdx);
+        return this.filtered.map(([, node]) => node);
     }
     entries() {
-        return this.filtered.map(([key, idx]) => [key, this.srcNode.child(idx)]);
+        return this.filtered;
     }
     has(char) {
         return this.keyMap.has(char);
@@ -136,10 +130,10 @@ class ITrieNodeFiltered {
         return this.size > 0;
     }
     get(char) {
-        const idx = this.keyMap.get(char);
-        if (idx === undefined)
+        const node = this.keyMap.get(char);
+        if (node === undefined)
             return undefined;
-        return this.srcNode.child(idx);
+        return node;
     }
 }
 //# sourceMappingURL=hintedWalker.js.map

package/dist/lib/ITrieNode/walker/walker.js

@@ -13,7 +13,8 @@ function* compoundWalker(root, compoundingMethod) {
     const rc = roots[compoundingMethod].length ? roots[compoundingMethod] : undefined;
     function children(n) {
         if (n.hasChildren()) {
-            const c = n.keys().map((k, i) => [k, n.child(i)]);
+            const entries = n.entries();
+            const c = Array.isArray(entries) ? entries : [...entries];
             return n.eow && rc ? [...c, ...rc] : c;
         }
         if (n.eow) {
@@ -48,21 +49,22 @@ function* compoundWalker(root, compoundingMethod) {
 function* nodeWalker(root) {
     let depth = 0;
     const stack = [];
-    stack[depth] = { t: '', n: root, c: root.keys(), ci: 0 };
+    const entries = root.entries();
+    stack[depth] = { t: '', n: root, c: Array.isArray(entries) ? entries : [...entries], ci: 0 };
     while (depth >= 0) {
         let s = stack[depth];
         let baseText = s.t;
         while (s.ci < s.c.length && s.n) {
             const idx = s.ci++;
-            const char = s.c[idx];
-            const node = s.n.child(idx);
+            const [char, node] = s.c[idx];
             const text = baseText + char;
             const goDeeper = yield { text, node, depth };
             if (goDeeper !== false) {
                 depth++;
                 baseText = text;
                 const s = stack[depth];
-                const c = node.keys();
+                const entries = node.entries();
+                const c = Array.isArray(entries) ? entries : [...entries];
                 if (s) {
                     s.t = text;
                     s.n = node;
@@ -90,13 +92,14 @@ export function walkerWords(root) {
 export function* walkerWordsITrie(root) {
     let depth = 0;
     const stack = [];
-    stack[depth] = { t: '', n: root, c: root.keys(), ci: 0 };
+    const entries = root.entries();
+    const c = Array.isArray(entries) ? entries : [...entries];
+    stack[depth] = { t: '', n: root, c, ci: 0 };
     while (depth >= 0) {
         let s = stack[depth];
         let baseText = s.t;
         while (s.ci < s.c.length && s.n) {
-            const char = s.c[s.ci++];
-            const node = s.n.get(char);
+            const [char, node] = s.c[s.ci++];
             if (!node)
                 continue;
             const text = baseText + char;
@@ -104,7 +107,8 @@ export function* walkerWordsITrie(root) {
                 yield text;
             depth++;
             baseText = text;
-            const c = node.keys();
+            const entries = node.entries();
+            const c = Array.isArray(entries) ? entries : [...entries];
             if (stack[depth]) {
                 s = stack[depth];
                 s.t = text;

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

@@ -1,8 +1,8 @@
 import { type Utf8BE32 } from './Utf8.js';
 export type Utf8Seq = Readonly<number[]>;
-export type CharIndexMap = Record<string, Utf8BE32>;
+export type CharIndexMap = Map<string, Utf8BE32>;
 export type RO_CharIndexMap = Readonly<CharIndexMap>;
-export type CharIndexSeqMap = Record<string, Utf8Seq>;
+export type CharIndexSeqMap = Map<string, Utf8Seq>;
 export type RO_CharIndexSeqMap = Readonly<CharIndexSeqMap>;
 export declare class CharIndex {
     #private;

package/dist/lib/TrieBlob/CharIndex.js

@@ -10,14 +10,14 @@ export class CharIndex {
     constructor(charIndex) {
         this.charIndex = charIndex;
         this.#charToUtf8SeqMap = buildCharIndexSequenceMap(charIndex);
-        this.#multiByteChars = Object.values(this.#charToUtf8SeqMap).some((c) => c.length > 1);
+        this.#multiByteChars = [...this.#charToUtf8SeqMap.values()].some((c) => c.length > 1);
     }
     getCharUtf8Seq(c) {
-        const found = this.#charToUtf8SeqMap[c];
+        const found = this.#charToUtf8SeqMap.get(c);
         if (found)
             return found;
         const s = encodeTextToUtf8(c);
-        this.#charToUtf8SeqMap[c] = s;
+        this.#charToUtf8SeqMap.set(c, s);
         return s;
     }
     wordToUtf8Seq(word) {
@@ -39,31 +39,31 @@ export class CharIndex {
     }
 }
 function buildCharIndexSequenceMap(charIndex) {
-    const map = Object.create(null);
+    const map = new Map();
     for (const key of charIndex) {
-        map[key] = encodeTextToUtf8(key);
+        map.set(key, encodeTextToUtf8(key));
     }
     return map;
 }
 export class CharIndexBuilder {
     charIndex = [];
-    charIndexMap = Object.create(null);
-    charIndexSeqMap = Object.create(null);
+    charIndexMap = new Map();
+    charIndexSeqMap = new Map();
     #mapIdxToSeq = new Map();
     constructor() {
         this.getUtf8Value('');
     }
     getUtf8Value(c) {
-        const found = this.charIndexMap[c];
+        const found = this.charIndexMap.get(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;
+        this.charIndexMap.set(c, utf8);
+        this.charIndexMap.set(nc, utf8);
+        this.charIndexMap.set(c.normalize('NFD'), utf8);
         return utf8;
     }
     utf8ValueToUtf8Seq(idx) {