cspell-trie-lib 6.1.0 → 6.1.3-alpha.0

package/dist/lib/TrieBuilder.js

@@ -100,20 +100,18 @@ class TrieBuilder {
         return n;
     }
     storeTransform(src, s, result) {
-        var _a;
         if (!Object.isFrozen(result) || !Object.isFrozen(src))
             return;
-        const t = (_a = this.transforms.get(src)) !== null && _a !== void 0 ? _a : new Map();
+        const t = this.transforms.get(src) ?? new Map();
         t.set(s, result);
         this.transforms.set(src, t);
     }
     addChild(node, head, child) {
-        var _a, _b, _c;
-        if (((_a = node.c) === null || _a === void 0 ? void 0 : _a.get(head)) !== child) {
+        if (node.c?.get(head) !== child) {
             if (!node.c || Object.isFrozen(node)) {
-                node = { ...node, c: new Map((_b = node.c) !== null && _b !== void 0 ? _b : []) };
+                node = { ...node, c: new Map(node.c ?? []) };
             }
-            (_c = node.c) === null || _c === void 0 ? void 0 : _c.set(head, child);
+            node.c?.set(head, child);
         }
         return Object.isFrozen(child) ? this.tryToCache(node) : node;
     }
@@ -134,10 +132,9 @@ class TrieBuilder {
         return cachedNode;
     }
     _insert(node, s, d) {
-        var _a, _b;
         const orig = node;
         if (Object.isFrozen(node)) {
-            const n = (_a = this.transforms.get(node)) === null || _a === void 0 ? void 0 : _a.get(s);
+            const n = this.transforms.get(node)?.get(s);
             if (n) {
                 return this.tryCacheFrozen(n);
             }
@@ -154,7 +151,7 @@ class TrieBuilder {
         }
         const head = s[0];
         const tail = s.slice(1);
-        const cNode = (_b = node.c) === null || _b === void 0 ? void 0 : _b.get(head);
+        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);
@@ -165,7 +162,7 @@ class TrieBuilder {
         let d = 1;
         for (const s of word.split('')) {
             const p = this.lastPath[d];
-            if ((p === null || p === void 0 ? void 0 : p.s) !== s)
+            if (p?.s !== s)
                 break;
             d++;
         }

package/dist/lib/compoundWalker.js

@@ -10,12 +10,10 @@ exports.compoundWords = exports.compoundWalker = void 0;
  * @param trie the compound Trie to walk
  */
 function* compoundWalker(trie, caseSensitive = true) {
-    var _a;
     const { compoundCharacter: cc, forbiddenWordPrefix: forbidden, stripCaseAndAccentsPrefix } = trie.options;
     const blockNode = new Set([cc, forbidden, stripCaseAndAccentsPrefix]);
-    const root = (!caseSensitive && ((_a = trie.root.c) === null || _a === void 0 ? void 0 : _a.get(stripCaseAndAccentsPrefix))) || trie.root;
+    const root = (!caseSensitive && trie.root.c?.get(stripCaseAndAccentsPrefix)) || trie.root;
     function* walk(n, s, c, d) {
-        var _a;
         const deeper = yield { n, s, c, d };
         if (deeper !== false && n.c) {
             for (const [k, cn] of n.c) {
@@ -24,7 +22,7 @@ function* compoundWalker(trie, caseSensitive = true) {
                 yield* walk(cn, s + k, false, d);
             }
             if (n.c.has(cc)) {
-                const compoundNodes = (_a = root.c) === null || _a === void 0 ? void 0 : _a.get(cc);
+                const compoundNodes = root.c?.get(cc);
                 if (compoundNodes) {
                     yield* walk(compoundNodes, s, true, d + 1);
                 }

package/dist/lib/convertToTrieRefNodes.js

@@ -15,7 +15,6 @@ function convertToTrieRefNodes(root) {
     const cached = new Map();
     const rollupTally = new Map();
     function tally(n) {
-        var _a;
         if (n.f && !n.c) {
             tallies.set(eow, (tallies.get(eow) || 0) + 1);
             return;
@@ -26,7 +25,7 @@ function convertToTrieRefNodes(root) {
             return;
         }
         tallies.set(n, 1);
-        for (const c of ((_a = n.c) === null || _a === void 0 ? void 0 : _a.values()) || []) {
+        for (const c of n.c?.values() || []) {
             tally(c);
         }
     }
@@ -51,7 +50,6 @@ function convertToTrieRefNodes(root) {
         }
     }
     function* walkByRollup(n) {
-        var _a;
         if (cached.has(n))
             return;
         if (n.f && !n.c) {
@@ -59,7 +57,7 @@ function convertToTrieRefNodes(root) {
             cached.set(n, cached.get(eow));
             return;
         }
-        const children = [...(((_a = n.c) === null || _a === void 0 ? void 0 : _a.values()) || [])].sort((a, b) => (rollupTally.get(b) || 0) - (rollupTally.get(a) || 0));
+        const children = [...(n.c?.values() || [])].sort((a, b) => (rollupTally.get(b) || 0) - (rollupTally.get(a) || 0));
         for (const c of children) {
             yield* walkByRollup(c);
         }

package/dist/lib/distance/distanceAStar.js

@@ -8,7 +8,6 @@ const PairingHeap_1 = require("../utils/PairingHeap");
  * Using basic weights, this algorithm has the same results as the Damerau-Levenshtein algorithm.
  */
 function distanceAStar(a, b) {
-    var _a;
     const aN = a.length;
     const bN = b.length;
     const cost = 100;
@@ -49,7 +48,7 @@ function distanceAStar(a, b) {
         opDel(best);
         opSub(best);
     }
-    return (_a = best === null || best === void 0 ? void 0 : best.c) !== null && _a !== void 0 ? _a : -1;
+    return best?.c ?? -1;
 }
 exports.distanceAStar = distanceAStar;
 function compare(a, b) {

package/dist/lib/distance/weightedMaps.js

@@ -272,19 +272,18 @@ function prettyPrintWeightMap(map) {
 }
 exports.prettyPrintWeightMap = prettyPrintWeightMap;
 function lookupReplaceCost(map, a, b) {
-    var _a, _b;
     const trie = map.replace;
     let tt = trie;
     for (let ai = 0; ai < a.length && tt; ++ai) {
-        tt = (_a = tt.n) === null || _a === void 0 ? void 0 : _a[a[ai]];
+        tt = tt.n?.[a[ai]];
     }
     if (!tt)
         return undefined;
     let t = tt.t;
     for (let bi = 0; bi < b.length && t; ++bi) {
-        t = (_b = t.n) === null || _b === void 0 ? void 0 : _b[b[bi]];
+        t = t.n?.[b[bi]];
     }
-    return t === null || t === void 0 ? void 0 : t.c;
+    return t?.c;
 }
 exports.lookupReplaceCost = lookupReplaceCost;
 function normalizeDef(def) {

package/dist/lib/find.js

@@ -52,10 +52,9 @@ function _findWord(root, word, options) {
  * @param options
  */
 function _findWordNode(root, word, options) {
-    var _a, _b;
     const compoundMode = knownCompoundModes.get(options.compoundMode) || _defaultFindOptions.compoundMode;
-    const compoundPrefix = options.compoundMode === 'compound' ? (_a = root.compoundCharacter) !== null && _a !== void 0 ? _a : options.compoundFix : '';
-    const ignoreCasePrefix = options.matchCase ? '' : (_b = root.stripCaseAndAccentsPrefix) !== null && _b !== void 0 ? _b : options.caseInsensitivePrefix;
+    const compoundPrefix = options.compoundMode === 'compound' ? root.compoundCharacter ?? options.compoundFix : '';
+    const ignoreCasePrefix = options.matchCase ? '' : root.stripCaseAndAccentsPrefix ?? options.caseInsensitivePrefix;
     function __findCompound() {
         const f = findCompoundWord(root, word, compoundPrefix, ignoreCasePrefix);
         const result = { ...f };
@@ -97,7 +96,6 @@ function findLegacyCompound(root, word, options) {
 }
 exports.findLegacyCompound = findLegacyCompound;
 function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix) {
-    var _a, _b, _c;
     // Approach - do a depth first search for the matching word.
     const stack = [
         // { n: root, compoundPrefix: '', cr: undefined, caseMatched: true },
@@ -107,12 +105,11 @@ function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix) {
     const possibleCompoundPrefix = ignoreCasePrefix && compoundCharacter ? ignoreCasePrefix + compoundCharacter : '';
     const w = word.normalize();
     function determineRoot(s) {
-        var _a;
         const prefix = s.compoundPrefix;
         let r = root;
         let i;
         for (i = 0; i < prefix.length && r; ++i) {
-            r = (_a = r.c) === null || _a === void 0 ? void 0 : _a.get(prefix[i]);
+            r = r.c?.get(prefix[i]);
         }
         const caseMatched = s.caseMatched && prefix[0] !== ignoreCasePrefix;
         return {
@@ -131,7 +128,7 @@ function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix) {
         const s = stack[i];
         const h = w[i++];
         const n = s.cr || s.n;
-        const c = (_a = n === null || n === void 0 ? void 0 : n.c) === null || _a === void 0 ? void 0 : _a.get(h);
+        const c = n?.c?.get(h);
         if (c && i < word.length) {
             // Go deeper.
             caseMatched = s.caseMatched;
@@ -141,7 +138,7 @@ function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix) {
             // Remember the first matching node for possible auto completion.
             node = node || c;
             // We did not find the word backup and take the first unused compound branch
-            while (--i > 0 && (!stack[i].compoundPrefix || !((_c = (_b = stack[i].n) === null || _b === void 0 ? void 0 : _b.c) === null || _c === void 0 ? void 0 : _c.has(compoundCharacter)))) {
+            while (--i > 0 && (!stack[i].compoundPrefix || !stack[i].n?.c?.has(compoundCharacter))) {
                 /* empty */
             }
             if (i >= 0 && stack[i].compoundPrefix) {
@@ -186,22 +183,20 @@ function findWordExact(root, word) {
 }
 exports.findWordExact = findWordExact;
 function isEndOfWordNode(n) {
-    return (n === null || n === void 0 ? void 0 : n.f) === TrieNode_1.FLAG_WORD;
+    return n?.f === TrieNode_1.FLAG_WORD;
 }
 exports.isEndOfWordNode = isEndOfWordNode;
 function walk(root, word) {
-    var _a;
     const w = word;
     let n = root;
     let i = 0;
     while (n && i < word.length) {
         const h = w[i++];
-        n = (_a = n.c) === null || _a === void 0 ? void 0 : _a.get(h);
+        n = n.c?.get(h);
     }
     return n;
 }
 function findLegacyCompoundNode(roots, word, minCompoundLength) {
-    var _a, _b;
     const root = roots[0];
     const numRoots = roots.length;
     // Approach - do a depth first search for the matching word.
@@ -219,7 +214,7 @@ function findLegacyCompoundNode(roots, word, minCompoundLength) {
         const s = stack[i];
         const h = w[i++];
         const n = s.cr || s.n;
-        const c = (_a = n === null || n === void 0 ? void 0 : n.c) === null || _a === void 0 ? void 0 : _a.get(h);
+        const c = n?.c?.get(h);
         if (c && i < wLen) {
             // Go deeper.
             stack[i] = {
@@ -236,7 +231,7 @@ function findLegacyCompoundNode(roots, word, minCompoundLength) {
             while (--i > 0) {
                 const s = stack[i];
                 if (s.usedRoots < numRoots &&
-                    ((_b = s.n) === null || _b === void 0 ? void 0 : _b.f) &&
+                    s.n?.f &&
                     (s.subLength >= minCompoundLength || !s.subLength) &&
                     wLen - i >= minCompoundLength) {
                     break;
@@ -284,8 +279,7 @@ function findLegacyCompoundWord(roots, word, minCompoundLength) {
     return { found, compoundUsed, caseMatched };
 }
 function isForbiddenWord(root, word, forbiddenPrefix) {
-    var _a;
-    return findWordExact((_a = root === null || root === void 0 ? void 0 : root.c) === null || _a === void 0 ? void 0 : _a.get(forbiddenPrefix), word);
+    return findWordExact(root?.c?.get(forbiddenPrefix), word);
 }
 exports.isForbiddenWord = isForbiddenWord;
 function createFindOptions(options) {

package/dist/lib/io/importExportV2.js

@@ -8,9 +8,8 @@ const EOW = '*';
 exports.DATA = '__DATA__';
 function leaves(node) {
     function toRefNode(node, k) {
-        var _a;
         const refNode = node;
-        refNode.s = (_a = refNode.s) !== null && _a !== void 0 ? _a : k;
+        refNode.s = refNode.s ?? k;
         return refNode;
     }
     function* walk(node, k, p) {

package/dist/lib/io/importExportV3.js

@@ -148,13 +148,12 @@ function parseStream(radix) {
     function parseReference(acc, _) {
         let ref = '';
         function parser(acc, s) {
-            var _a;
             if (s === EOR) {
                 const { root, nodes, stack } = acc;
                 const r = parseInt(ref, radix);
                 const top = stack[stack.length - 1];
                 const p = stack[stack.length - 2].node;
-                (_a = p.c) === null || _a === void 0 ? void 0 : _a.set(top.s, nodes[r]);
+                p.c?.set(top.s, nodes[r]);
                 return { root, nodes, stack, parser: undefined };
             }
             ref = ref + s;
@@ -180,12 +179,11 @@ function parseStream(radix) {
         return { ...acc, parser };
     }
     function parseCharacter(acc, s) {
-        var _a;
         const parser = undefined;
         const { root, nodes, stack } = acc;
         const top = stack[stack.length - 1];
         const node = top.node;
-        node.c = (_a = node.c) !== null && _a !== void 0 ? _a : new Map();
+        node.c = node.c ?? new Map();
         const n = { f: undefined, c: undefined, n: nodes.length };
         node.c.set(s, n);
         stack.push({ node: n, s });
@@ -193,7 +191,6 @@ function parseStream(radix) {
         return { root, nodes, stack, parser };
     }
     function parseEOW(acc, _) {
-        var _a;
         const parser = parseBack;
         const { root, nodes, stack } = acc;
         const top = stack[stack.length - 1];
@@ -202,7 +199,7 @@ function parseStream(radix) {
         if (!node.c) {
             top.node = eow;
             const p = stack[stack.length - 2].node;
-            (_a = p.c) === null || _a === void 0 ? void 0 : _a.set(top.s, eow);
+            p.c?.set(top.s, eow);
             nodes.pop();
         }
         stack.pop();
@@ -232,8 +229,7 @@ function parseStream(radix) {
         [LF, parseIgnore],
     ]);
     function parserMain(acc, s) {
-        var _a, _b;
-        const parser = (_b = (_a = acc.parser) !== null && _a !== void 0 ? _a : parsers.get(s)) !== null && _b !== void 0 ? _b : parseCharacter;
+        const parser = acc.parser ?? parsers.get(s) ?? parseCharacter;
         return parser(acc, s);
     }
     return parserMain;

package/dist/lib/mappers/mapDictionaryInfo.js

@@ -10,7 +10,7 @@ const mapToSuggestionCostDef_1 = require("./mapToSuggestionCostDef");
 function mapDictionaryInformation(dictInfo) {
     const _locale = dictInfo.locale;
     const locale = _locale ? (0, locale_1.parseLocale)(_locale).filter((loc) => loc.isValid()) : undefined;
-    const locales = locale === null || locale === void 0 ? void 0 : locale.map((loc) => loc.locale);
+    const locales = locale?.map((loc) => loc.locale);
     const costs = (0, mapCosts_1.mapEditCosts)(dictInfo.costs);
     const defsEC = dictInfo.suggestionEditCosts || [];
     const defsHI = dictInfo.hunspellInformation
@@ -32,7 +32,7 @@ function processAlphabet(alphabet, locale, editCost) {
     ];
 }
 function toCharSets(cs, defaultValue, cost, penalty) {
-    cs = cs !== null && cs !== void 0 ? cs : defaultValue;
+    cs = cs ?? defaultValue;
     if (!cs)
         return [];
     if (typeof cs === 'string') {

package/dist/lib/mappers/mapHunspellInformation.js

@@ -37,7 +37,7 @@ function hunspellInformationToSuggestionCostDef(hunInfo, locales) {
 }
 exports.hunspellInformationToSuggestionCostDef = hunspellInformationToSuggestionCostDef;
 function calcCosts(costs = {}, locale) {
-    const useLocale = (locale === null || locale === void 0 ? void 0 : locale.length) ? locale.map((loc) => loc.locale) : undefined;
+    const useLocale = locale?.length ? locale.map((loc) => loc.locale) : undefined;
     const hunCosts = (0, mapCosts_1.mapHunspellCosts)(costs);
     const c = {
         ...hunCosts,

package/dist/lib/suggestions/genSuggestionsOptions.js

@@ -44,7 +44,6 @@ function createSuggestionOptions(...opts) {
 }
 exports.createSuggestionOptions = createSuggestionOptions;
 function assign(dest, src, k) {
-    var _a;
-    dest[k] = (_a = src[k]) !== null && _a !== void 0 ? _a : dest[k];
+    dest[k] = src[k] ?? dest[k];
 }
 //# sourceMappingURL=genSuggestionsOptions.js.map

package/dist/lib/suggestions/suggestAStar.js

@@ -150,14 +150,12 @@ function* genCompoundableSuggestions(root, word, options) {
         }
     }
     function opCompoundWord(best) {
-        var _a;
-        if (!((_a = best.n.c) === null || _a === void 0 ? void 0 : _a.get(compoundIndicator)))
+        if (!best.n.c?.get(compoundIndicator))
             return;
         const i = best.i;
         const s = '';
         nodes.forEach((node) => {
-            var _a;
-            const n = (_a = node.c) === null || _a === void 0 ? void 0 : _a.get(compoundIndicator);
+            const n = node.c?.get(compoundIndicator);
             if (!n)
                 return;
             const e = { p: best, n, i, s, c: opCosts.wordBreak, a: Action.CompoundWord };
@@ -189,9 +187,8 @@ function* genCompoundableSuggestions(root, word, options) {
         return addEdge(best, e);
     }
     function opIdentity(best) {
-        var _a;
         const s = word[best.i];
-        const n = (_a = best.n.c) === null || _a === void 0 ? void 0 : _a.get(s);
+        const n = best.n.c?.get(s);
         if (!n)
             return;
         const i = best.i + 1;
@@ -216,7 +213,6 @@ function* genCompoundableSuggestions(root, word, options) {
         }
     }
     function opSwap(best) {
-        var _a, _b;
         const children = best.n.c;
         const i = best.i;
         const i2 = i + 1;
@@ -226,8 +222,8 @@ function* genCompoundableSuggestions(root, word, options) {
         const wc2 = word[i2];
         if (wc1 === wc2)
             return;
-        const n = (_a = best.n.c) === null || _a === void 0 ? void 0 : _a.get(wc2);
-        const n2 = (_b = n === null || n === void 0 ? void 0 : n.c) === null || _b === void 0 ? void 0 : _b.get(wc1);
+        const n = best.n.c?.get(wc2);
+        const n2 = n?.c?.get(wc1);
         if (!n || !n2)
             return;
         const e = {
@@ -242,7 +238,6 @@ function* genCompoundableSuggestions(root, word, options) {
         addEdge(best, e);
     }
     function opDuplicate(best) {
-        var _a, _b;
         const children = best.n.c;
         const i = best.i;
         const i2 = i + 1;
@@ -250,7 +245,7 @@ function* genCompoundableSuggestions(root, word, options) {
             return;
         const wc1 = word[i];
         const wc2 = word[i2];
-        const n = (_a = best.n.c) === null || _a === void 0 ? void 0 : _a.get(wc1);
+        const n = best.n.c?.get(wc1);
         if (!n)
             return;
         if (wc1 === wc2) {
@@ -259,7 +254,7 @@ function* genCompoundableSuggestions(root, word, options) {
             addEdge(best, e);
             return;
         }
-        const n2 = (_b = n === null || n === void 0 ? void 0 : n.c) === null || _b === void 0 ? void 0 : _b.get(wc1);
+        const n2 = n?.c?.get(wc1);
         if (!n2)
             return;
         // convert single to double letter
@@ -278,9 +273,8 @@ function* genCompoundableSuggestions(root, word, options) {
         }
     }
     function resolveEdge({ edge, suffixes }) {
-        var _a;
         const { p, s: es, c: ec } = edge;
-        if (!((_a = p.r) === null || _a === void 0 ? void 0 : _a.has(edge)))
+        if (!p.r?.has(edge))
             return;
         const edgeSuffixes = suffixes.map((sfx) => ({ s: es + sfx.s, c: ec + sfx.c }));
         for (const { s, c } of edgeSuffixes) {
@@ -292,7 +286,7 @@ function* genCompoundableSuggestions(root, word, options) {
         }
         p.r.delete(edge);
         const location = pathToLocation.get(p);
-        if ((location === null || location === void 0 ? void 0 : location.p) === p) {
+        if (location?.p === p) {
             location.sfx = location.sfx.concat(edgeSuffixes);
             if (!p.r.size) {
                 location.sbc = p.g;
@@ -416,7 +410,7 @@ function determineInitialNodes(root, ignoreCase) {
     const noCaseNodes = ignoreCase
         ? roots
             .filter((r) => r.stripCaseAndAccentsPrefix)
-            .map((n) => { var _a; return (_a = n.c) === null || _a === void 0 ? void 0 : _a.get(n.stripCaseAndAccentsPrefix); })
+            .map((n) => n.c?.get(n.stripCaseAndAccentsPrefix))
             .filter(isDefined)
         : [];
     const nodes = rootNodes.concat(noCaseNodes);

package/dist/lib/suggestions/suggestCollector.js

@@ -101,7 +101,7 @@ function suggestionCollector(wordToMatch, options) {
      */
     function collect(src, timeout, filter) {
         let stop = false;
-        timeout = timeout !== null && timeout !== void 0 ? timeout : timeRemaining;
+        timeout = timeout ?? timeRemaining;
         timeout = Math.min(timeout, timeRemaining);
         if (timeout < 0)
             return;
@@ -202,7 +202,7 @@ function impersonateCollector(collector, word) {
 exports.impersonateCollector = impersonateCollector;
 function isSuggestionResult(s) {
     const r = s;
-    return (r === null || r === void 0 ? void 0 : r.cost) !== undefined && r.word != undefined;
+    return r?.cost !== undefined && r.word != undefined;
 }
 exports.isSuggestionResult = isSuggestionResult;
 //# sourceMappingURL=suggestCollector.js.map

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

@@ -12,21 +12,20 @@ exports.hintedWalker = hintedWalker;
  * next(goDeeper: boolean):
  */
 function* hintedWalkerNext(root, ignoreCase, hint, compoundingMethod, emitWordSeparator = '') {
-    const _compoundingMethod = compoundingMethod !== null && compoundingMethod !== void 0 ? compoundingMethod : walkerTypes_1.CompoundWordsMethod.NONE;
+    const _compoundingMethod = compoundingMethod ?? walkerTypes_1.CompoundWordsMethod.NONE;
     const compoundCharacter = root.compoundCharacter;
     const noCaseCharacter = root.stripCaseAndAccentsPrefix;
     const rawRoots = [root, ignoreCase ? root.c.get(noCaseCharacter) : undefined].filter(trie_util_1.isDefined);
     const specialRootsPrefix = existMap([compoundCharacter, noCaseCharacter, root.forbiddenWordPrefix]);
     function filterRoot(root) {
-        var _a;
-        const children = (_a = root.c) === null || _a === void 0 ? void 0 : _a.entries();
+        const children = root.c?.entries();
         const c = children && [...children].filter(([v]) => !(v in specialRootsPrefix));
         return {
             c: c && new Map(c),
         };
     }
     const roots = rawRoots.map(filterRoot);
-    const compoundRoots = rawRoots.map((r) => { var _a; return (_a = r.c) === null || _a === void 0 ? void 0 : _a.get(compoundCharacter); }).filter(trie_util_1.isDefined);
+    const compoundRoots = rawRoots.map((r) => r.c?.get(compoundCharacter)).filter(trie_util_1.isDefined);
     const setOfCompoundRoots = new Set(compoundRoots);
     const rootsForCompoundMethods = roots.concat(compoundRoots);
     const compoundMethodRoots = {

package/dist/lib/trie-util.js

@@ -175,7 +175,7 @@ function mergeDefaults(value, defaultValue) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         for (const [k, v] of Object.entries(value)) {
             if (k in result) {
-                result[k] = v !== null && v !== void 0 ? v : result[k];
+                result[k] = v ?? result[k];
             }
         }
     }

package/dist/lib/trie.js

@@ -35,8 +35,7 @@ class Trie {
      * Number of words in the Trie
      */
     size() {
-        var _a;
-        this.count = (_a = this.count) !== null && _a !== void 0 ? _a : (0, trie_util_1.countWords)(this.root);
+        this.count = this.count ?? (0, trie_util_1.countWords)(this.root);
         return this.count;
     }
     isSizeKnown() {
@@ -96,7 +95,7 @@ class Trie {
         return !!f.found && !f.forbidden;
     }
     findWord(word, options) {
-        if (options === null || options === void 0 ? void 0 : options.useLegacyWordCompounds) {
+        if (options?.useLegacyWordCompounds) {
             const len = options.useLegacyWordCompounds !== true
                 ? options.useLegacyWordCompounds
                 : defaultLegacyMinCompoundLength;
@@ -106,7 +105,7 @@ class Trie {
             });
             return (0, find_1.findLegacyCompound)(this.root, word, findOptions);
         }
-        const findOptions = this.createFindOptions({ matchCase: options === null || options === void 0 ? void 0 : options.caseSensitive });
+        const findOptions = this.createFindOptions({ matchCase: options?.caseSensitive });
         return (0, find_1.findWord)(this.root, word, findOptions);
     }
     /**
@@ -185,9 +184,9 @@ class Trie {
     }
     calcIsLegacy() {
         const c = this.root.c;
-        return !((c === null || c === void 0 ? void 0 : c.get(this._options.compoundCharacter)) ||
-            (c === null || c === void 0 ? void 0 : c.get(this._options.stripCaseAndAccentsPrefix)) ||
-            (c === null || c === void 0 ? void 0 : c.get(this._options.forbiddenWordPrefix)));
+        return !(c?.get(this._options.compoundCharacter) ||
+            c?.get(this._options.stripCaseAndAccentsPrefix) ||
+            c?.get(this._options.forbiddenWordPrefix));
     }
     static create(words, options) {
         const root = (0, trie_util_1.createTriFromList)(words, options);

package/dist/lib/utils/PairingHeap.js

@@ -33,8 +33,7 @@ class PairingHeap {
         return { value };
     }
     peek() {
-        var _a;
-        return (_a = this._heap) === null || _a === void 0 ? void 0 : _a.v;
+        return this._heap?.v;
     }
     [Symbol.iterator]() {
         return this;

package/dist/lib/utils/memorizer.js

@@ -5,20 +5,18 @@ exports.memorizer = void 0;
 function memorizer(fn) {
     const r = {};
     function find(p) {
-        var _a;
         let n = r;
         for (const k of p) {
             if (!n)
                 break;
-            n = (_a = n.c) === null || _a === void 0 ? void 0 : _a.get(k);
+            n = n.c?.get(k);
         }
         return n;
     }
     function set(p, v) {
-        var _a;
         let n = r;
         for (const k of p) {
-            const c = (_a = n.c) === null || _a === void 0 ? void 0 : _a.get(k);
+            const c = n.c?.get(k);
             if (c) {
                 n = c;
                 continue;

package/dist/lib/utils/secondChanceCache.js

@@ -18,8 +18,7 @@ class SecondChanceCache {
         return false;
     }
     get(key) {
-        var _a;
-        return (_a = this.map0.get(key)) !== null && _a !== void 0 ? _a : this.get1(key);
+        return this.map0.get(key) ?? this.get1(key);
     }
     set(key, value) {
         if (this.map0.size >= this.maxL0Size && !this.map0.has(key)) {

package/dist/lib/utils/timer.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.polyHrTime = exports.toMilliseconds = exports.createTimer = void 0;
-const _hrTime = (process === null || process === void 0 ? void 0 : process.hrtime) || polyHrTime;
+const _hrTime = process?.hrtime || polyHrTime;
 function createTimer(hrTimeFn = _hrTime) {
     let start = hrTimeFn();
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-trie-lib",
-  "version": "6.1.0",
+  "version": "6.1.3-alpha.0",
   "description": "Trie Data Structure to support cspell.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,7 +37,7 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "^6.1.0",
+    "@cspell/cspell-pipe": "^6.1.3-alpha.0",
     "fs-extra": "^10.1.0",
     "gensequence": "^3.1.1"
   },
@@ -45,13 +45,13 @@
     "node": ">=14"
   },
   "devDependencies": {
-    "@cspell/cspell-types": "^6.1.0",
-    "@cspell/dict-en_us": "^2.2.5",
+    "@cspell/cspell-types": "^6.1.3-alpha.0",
+    "@cspell/dict-en_us": "^2.2.6",
     "@cspell/dict-es-es": "^2.2.0",
     "@types/fs-extra": "^9.0.13",
-    "@types/node": "^17.0.36",
-    "jest": "^28.1.0",
+    "@types/node": "^17.0.43",
+    "jest": "^28.1.1",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "eaf6991ced2c8eb2c60bd2914095e4c686a4266b"
+  "gitHead": "b3cde7e463fd8a6f2c03f990adc70b913239baeb"
 }