cspell-trie-lib 9.2.1 → 9.2.2

package/dist/index.js

@@ -19,19 +19,18 @@ function memorizeLastCall(fn) {
 
 //#endregion
 //#region src/lib/ITrieNode/find.ts
-const defaultLegacyMinCompoundLength$3 = 3;
+const defaultLegacyMinCompoundLength$2 = 3;
 const _defaultFindOptions$1 = {
 	matchCase: false,
 	compoundMode: "compound",
-	legacyMinCompoundLength: defaultLegacyMinCompoundLength$3
+	legacyMinCompoundLength: defaultLegacyMinCompoundLength$2
 };
 Object.freeze(_defaultFindOptions$1);
-const arrayCompoundModes$1 = [
+const knownCompoundModes$1 = new Map([
 	"none",
 	"compound",
 	"legacy"
-];
-const knownCompoundModes$1 = new Map(arrayCompoundModes$1.map((a) => [a, a]));
+].map((a) => [a, a]));
 const notFound = {
 	found: false,
 	compoundUsed: false,
@@ -89,23 +88,18 @@ function _findWordNode$1(root, word, options) {
 	const checkForbidden = options?.checkForbidden ?? true;
 	function __findCompound() {
 		const f = findCompoundWord$1(root, word, compoundPrefix, ignoreCasePrefix);
-		if (f.found !== false && (mustCheckForbidden || f.compoundUsed && checkForbidden)) {
-			const r = !f.caseMatched ? walk$2(root, root.caseInsensitivePrefix) : root;
-			f.forbidden = isForbiddenWord$1(r, word, root.forbidPrefix);
-		}
+		if (f.found !== false && (mustCheckForbidden || f.compoundUsed && checkForbidden)) f.forbidden = isForbiddenWord$1(!f.caseMatched ? walk$2(root, root.caseInsensitivePrefix) : root, word, root.forbidPrefix);
 		return f;
 	}
 	function __findExact() {
 		const n = root.getNode ? root.getNode(word) : walk$2(root, word);
-		const isFound = isEndOfWordNode$1(n);
-		const result = {
-			found: isFound && word,
+		return {
+			found: isEndOfWordNode$1(n) && word,
 			compoundUsed: false,
 			forbidden: checkForbidden ? isForbiddenWord$1(root, word, root.forbidPrefix) : void 0,
 			node: n,
 			caseMatched: true
 		};
-		return result;
 	}
 	switch (compoundMode) {
 		case "none": return matchCase ? __findExact() : __findCompound();
@@ -116,7 +110,7 @@ function _findWordNode$1(root, word, options) {
 function findLegacyCompound$1(root, word, options) {
 	const roots = [root];
 	if (!options?.matchCase) roots.push(walk$2(root, root.caseInsensitivePrefix));
-	return findLegacyCompoundNode$1(roots, word, options?.legacyMinCompoundLength || defaultLegacyMinCompoundLength$3);
+	return findLegacyCompoundNode$1(roots, word, options?.legacyMinCompoundLength || defaultLegacyMinCompoundLength$2);
 }
 function findCompoundNode$1(root, word, compoundCharacter, ignoreCasePrefix) {
 	const stack = [{
@@ -179,15 +173,13 @@ function findCompoundNode$1(root, word, compoundCharacter, ignoreCasePrefix) {
 			break;
 		}
 	}
-	const found = i === word.length && word || false;
-	const result = {
-		found,
+	return {
+		found: i === word.length && word || false,
 		compoundUsed,
 		node,
 		forbidden: void 0,
 		caseMatched
 	};
-	return result;
 }
 function findCompoundWord$1(root, word, compoundCharacter, ignoreCasePrefix) {
 	const { found, compoundUsed, node, caseMatched } = findCompoundNode$1(root, word, compoundCharacter, ignoreCasePrefix);
@@ -244,8 +236,7 @@ function findLegacyCompoundNode$1(roots, word, minCompoundLength) {
 	while (true) {
 		const s = stack[i];
 		const h = w[i++];
-		const n = s.cr || s.n;
-		const c = n?.get(h);
+		const c = (s.cr || s.n)?.get(h);
 		if (c && i < wLen) stack[i] = {
 			n: c,
 			usedRoots: 0,
@@ -285,15 +276,13 @@ function findLegacyCompoundNode$1(roots, word, minCompoundLength) {
 		}
 		return letters.join("");
 	}
-	const found = extractWord();
-	const result = {
-		found,
+	return {
+		found: extractWord(),
 		compoundUsed,
 		node,
 		forbidden: void 0,
 		caseMatched
 	};
-	return result;
 }
 function isForbiddenWord$1(root, word, forbiddenPrefix) {
 	const r = root;
@@ -368,12 +357,11 @@ function* compoundWalker$1(root, compoundingMethod) {
 		while (s.ci < s.c.length) {
 			const [char, node] = s.c[s.ci++];
 			const text = baseText + char;
-			const goDeeper = yield {
+			if ((yield {
 				text,
 				node,
 				depth
-			};
-			if (goDeeper ?? true) {
+			}) ?? true) {
 				depth++;
 				baseText = text;
 				stack[depth] = {
@@ -408,12 +396,11 @@ function* nodeWalker$1(root) {
 			const idx$1 = s.ci++;
 			const [char, node] = s.c[idx$1];
 			const text = baseText + char;
-			const goDeeper = yield {
+			if ((yield {
 				text,
 				node,
 				depth
-			};
-			if (goDeeper !== false) {
+			}) !== false) {
 				depth++;
 				baseText = text;
 				const s$1 = stack[depth];
@@ -449,11 +436,10 @@ function* walkerWordsITrie(root) {
 	let depth = 0;
 	const stack = [];
 	const entries = root.entries();
-	const c = Array.isArray(entries) ? entries : [...entries];
 	stack[depth] = {
 		t: "",
 		n: root,
-		c,
+		c: Array.isArray(entries) ? entries : [...entries],
 		ci: 0
 	};
 	while (depth >= 0) {
@@ -467,17 +453,17 @@ function* walkerWordsITrie(root) {
 			depth++;
 			baseText = text;
 			const entries$1 = node.entries();
-			const c$1 = Array.isArray(entries$1) ? entries$1 : [...entries$1];
+			const c = Array.isArray(entries$1) ? entries$1 : [...entries$1];
 			if (stack[depth]) {
 				s = stack[depth];
 				s.t = text;
 				s.n = node;
-				s.c = c$1;
+				s.c = c;
 				s.ci = 0;
 			} else stack[depth] = {
 				t: text,
 				n: node,
-				c: c$1,
+				c,
 				ci: 0
 			};
 			s = stack[depth];
@@ -542,8 +528,7 @@ function* hintedWalkerNext(root, ignoreCase, hint, compoundingMethod, emitWordSe
 		root.forbiddenWordPrefix
 	]);
 	function filterRoot(root$1) {
-		const children$1 = root$1.c && Object.entries(root$1.c);
-		const c = children$1?.filter(([v]) => !(v in specialRootsPrefix));
+		const c = (root$1.c && Object.entries(root$1.c))?.filter(([v]) => !(v in specialRootsPrefix));
 		return { c: c && Object.fromEntries(c) };
 	}
 	const roots = rawRoots.map(filterRoot);
@@ -720,8 +705,7 @@ var ImplITrieRoot = class extends ImplITrieNode {
 		return false;
 	}
 	resolveId(id) {
-		const n = id;
-		return new ImplITrieNode(n);
+		return new ImplITrieNode(id);
 	}
 	get forbidPrefix() {
 		return this.root.forbiddenWordPrefix;
@@ -770,12 +754,11 @@ function* compoundWalker(root, compoundingMethod) {
 		while (s.ci < s.c.length) {
 			const [char, node] = s.c[s.ci++];
 			const text = baseText + char;
-			const goDeeper = yield {
+			if ((yield {
 				text,
 				node,
 				depth
-			};
-			if (goDeeper ?? true) {
+			}) ?? true) {
 				depth++;
 				baseText = text;
 				stack[depth] = {
@@ -814,12 +797,11 @@ function* nodeWalker(root) {
 			const char = s.c[s.ci++];
 			const node = s.n[char];
 			const text = baseText + char;
-			const goDeeper = yield {
+			if ((yield {
 				text,
 				node,
 				depth
-			};
-			if (goDeeper !== false) {
+			}) !== false) {
 				depth++;
 				baseText = text;
 				const s$1 = stack[depth];
@@ -904,14 +886,11 @@ const defaultSuggestionOptions = {
 	includeTies: true,
 	timeout: 5e3
 };
-const keyMapOfGenSuggestionOptionsStrict = {
+const keyMapOfSuggestionOptionsStrict = {
 	changeLimit: "changeLimit",
 	compoundMethod: "compoundMethod",
 	ignoreCase: "ignoreCase",
-	compoundSeparator: "compoundSeparator"
-};
-const keyMapOfSuggestionOptionsStrict = {
-	...keyMapOfGenSuggestionOptionsStrict,
+	compoundSeparator: "compoundSeparator",
 	filter: "filter",
 	includeTies: "includeTies",
 	numSuggestions: "numSuggestions",
@@ -1077,8 +1056,7 @@ const visualLetterGroups = [
 function forms(letters) {
 	const n = letters.normalize("NFC").replaceAll(/\p{M}/gu, "");
 	const na = n.normalize("NFD").replaceAll(/\p{M}/gu, "");
-	const s = new Set(n + n.toLowerCase() + n.toUpperCase() + na + na.toLowerCase() + na.toUpperCase());
-	return [...s].join("");
+	return [...new Set(n + n.toLowerCase() + n.toUpperCase() + na + na.toLowerCase() + na.toUpperCase())].join("");
 }
 /**
 * This is a map of letters to groups mask values.
@@ -1123,8 +1101,7 @@ function addDefsToWeightMap(map, defs) {
 	}
 	for (const _def of defs) {
 		const def = normalizeDef(_def);
-		const mapSets = splitMap$1(def);
-		mapSets.forEach((s) => addSet(s, def));
+		splitMap$1(def).forEach((s) => addSet(s, def));
 	}
 	return map;
 }
@@ -1182,8 +1159,7 @@ function splitMapSubstrings(map) {
 */
 function splitMap$1(def) {
 	const { map } = def;
-	const sets = map.split("|");
-	return sets.map(splitMapSubstrings).filter((s) => s.length > 0);
+	return map.split("|").map(splitMapSubstrings).filter((s) => s.length > 0);
 }
 function addToTrieCost(trie, str, cost, penalties) {
 	if (!str) return;
@@ -1201,8 +1177,7 @@ function addToTrieTrieCost(trie, left, right, cost, penalties) {
 		const n = t.n = t.n || Object.create(null);
 		t = n[c] = n[c] || Object.create(null);
 	}
-	const trieCost = t.t = t.t || Object.create(null);
-	addToTrieCost(trieCost, right, cost, penalties);
+	addToTrieCost(t.t = t.t || Object.create(null), right, cost, penalties);
 }
 function addSetToTrieCost(trie, set, cost, penalties) {
 	if (cost === void 0) return;
@@ -1403,12 +1378,11 @@ function _distanceAStarWeightedEx(wordA, wordB, map, cost = 100) {
 			c,
 			p
 		};
-		const costCalculations = [
+		[
 			map.calcInsDelCosts(pos),
 			map.calcSwapCosts(pos),
 			map.calcReplaceCosts(pos)
-		];
-		costCalculations.forEach((iter) => {
+		].forEach((iter) => {
 			for (const nn of iter) candidates.add({
 				...nn,
 				f: n
@@ -1437,7 +1411,6 @@ var CandidatePool = class {
 	next() {
 		let n;
 		while (n = this.pool.dequeue()) if (!n.d) return n;
-		return void 0;
 	}
 	add(n) {
 		const i = idx(n.ai, n.bi, this.bN);
@@ -1628,8 +1601,7 @@ function createPerfTimer() {
 			at: 0,
 			elapsed: 0
 		});
-		const lines = lineElements.map((e) => `${e.at.padStart(lengths.at)}  ${e.name.padEnd(lengths.name)}  ${e.elapsed.padStart(lengths.elapsed)}`);
-		return lines.join("\n");
+		return lineElements.map((e) => `${e.at.padStart(lengths.at)}  ${e.name.padEnd(lengths.name)}  ${e.elapsed.padStart(lengths.elapsed)}`).join("\n");
 	}
 	function measureFn(name, fn) {
 		const s = start(name);
@@ -1675,8 +1647,7 @@ function isDefined$1(a) {
 * @returns t
 */
 function cleanCopy(t) {
-	const r = { ...t };
-	return clean$1(r);
+	return clean$1({ ...t });
 }
 /**
 * Remove any fields with an `undefined` value.
@@ -1714,8 +1685,7 @@ function replaceAllFactory(match, replaceWithText) {
 const defaultMaxNumberSuggestions = 10;
 const BASE_COST = 100;
 const MAX_NUM_CHANGES = 5;
-const MAX_COST_SCALE = .5;
-const MAX_ALLOWED_COST_SCALE = 1.03 * MAX_COST_SCALE;
+const MAX_ALLOWED_COST_SCALE = 1.03 * .5;
 const collator = new Intl.Collator();
 const regexSeparator = new RegExp(`[${regexQuote(WORD_SEPARATOR)}]`, "g");
 const wordLengthCost = [
@@ -1730,9 +1700,7 @@ const EXTRA_WORD_COST = 5;
 const DEFAULT_COLLECTOR_TIMEOUT = 1e3;
 const symStopProcessing = Symbol("Collector Stop Processing");
 function compSuggestionResults(a, b) {
-	const aPref = a.isPreferred && -1 || 0;
-	const bPref = b.isPreferred && -1 || 0;
-	return aPref - bPref || a.cost - b.cost || a.word.length - b.word.length || collator.compare(a.word, b.word);
+	return (a.isPreferred && -1 || 0) - (b.isPreferred && -1 || 0) || a.cost - b.cost || a.word.length - b.word.length || collator.compare(a.word, b.word);
 }
 const defaultSuggestionCollectorOptions = Object.freeze({
 	numSuggestions: defaultMaxNumberSuggestions,
@@ -1841,12 +1809,11 @@ function suggestionCollector(wordToMatch, options) {
 		const NF = "NFD";
 		const nWordToMatch = wordToMatch.normalize(NF);
 		const rawValues = [...sugs.values()];
-		const values = weightMap ? rawValues.map(({ word, cost, isPreferred }) => ({
+		const sorted = (weightMap ? rawValues.map(({ word, cost, isPreferred }) => ({
 			word,
 			cost: isPreferred ? cost : editDistanceWeighted(nWordToMatch, word.normalize(NF), weightMap, 110),
 			isPreferred
-		})) : rawValues;
-		const sorted = values.sort(compSuggestionResults).map(cleanCompoundResult);
+		})) : rawValues).sort(compSuggestionResults).map(cleanCompoundResult);
 		let i = Math.min(sorted.length, numSuggestions) - 1;
 		const limit = includeTies ? sorted.length : Math.min(sorted.length, numSuggestions);
 		const iCost = sorted[i].cost;
@@ -1855,7 +1822,7 @@ function suggestionCollector(wordToMatch, options) {
 		sorted.length = i;
 		return sorted;
 	}
-	const collector = {
+	return {
 		collect,
 		add: function(suggestion) {
 			collectSuggestion(suggestion);
@@ -1881,7 +1848,6 @@ function suggestionCollector(wordToMatch, options) {
 		symbolStopProcessing: symStopProcessing,
 		genSuggestionOptions
 	};
-	return collector;
 }
 /**
 * Impersonating a Collector, allows searching for multiple variants on the same word.
@@ -1987,15 +1953,13 @@ function* getSuggestionsAStar(trie, srcWord, options = {}) {
 	return;
 	function compareSuggestion(a, b) {
 		const pa = a.isPreferred && 1 || 0;
-		const pb = b.isPreferred && 1 || 0;
-		return pb - pa || a.cost - b.cost || Math.abs(a.word.charCodeAt(0) - srcWord.charCodeAt(0)) - Math.abs(b.word.charCodeAt(0) - srcWord.charCodeAt(0));
+		return (b.isPreferred && 1 || 0) - pa || a.cost - b.cost || Math.abs(a.word.charCodeAt(0) - srcWord.charCodeAt(0)) - Math.abs(b.word.charCodeAt(0) - srcWord.charCodeAt(0));
 	}
 	function processPath(p) {
 		const len = srcLetters.length;
 		if (p.n.eow && p.i === len) {
-			const word = pNodeToWord(p);
 			const result = {
-				word,
+				word: pNodeToWord(p),
 				cost: p.c
 			};
 			resultHeap.add(result);
@@ -2020,14 +1984,12 @@ function* getSuggestionsAStar(trie, srcWord, options = {}) {
 			storePath(t, n, i + 1, cost, "", p, "d", "");
 			for (const [ss, node] of n.entries()) {
 				if (node.id === m?.id || ss in sc) continue;
-				const g = visMap[ss] || 0;
-				const c = sg & g ? costVis : cost;
+				const c = sg & (visMap[ss] || 0) ? costVis : cost;
 				storePath(t, node, i + 1, c, ss, p, "r", ss);
 			}
 			if (n.eow && i && compoundMethod) storePath(t, root, i, costLegacyCompound, wordSeparator, p, "L", wordSeparator);
 			if (ns) {
-				const n1 = n.get(ns);
-				const n2 = n1?.get(s);
+				const n2 = n.get(ns)?.get(s);
 				if (n2) {
 					const ss = ns + s;
 					storePath(t, n2, i + 2, cost0 + opCosts.swapCost, ss, p, "s", ss);
@@ -2058,8 +2020,7 @@ function* getSuggestionsAStar(trie, srcWord, options = {}) {
 	*/
 	function storePath(t, n, i, c, s, p, a, ss) {
 		const tt = getCostTrie(t, ss);
-		const curr = tt.c[i];
-		if (curr <= c || c > limit) return void 0;
+		if (tt.c[i] <= c || c > limit) return void 0;
 		tt.c[i] = c;
 		pathHeap.add({
 			n,
@@ -2270,12 +2231,11 @@ function caseForms(letter, locale) {
 * @returns combined set of possible forms.
 */
 function accentForms(letter) {
-	const forms$1 = new Set([
+	return new Set([
 		letter,
 		letter.normalize("NFC"),
 		letter.normalize("NFD")
 	]);
-	return forms$1;
 }
 /**
 * Remove all accents.
@@ -2296,8 +2256,7 @@ function stripNonAccents(characters) {
 function isValidUtf16Character(char) {
 	const len = char.length;
 	const code = char.charCodeAt(0) & 64512;
-	const valid = len === 1 && (code & 63488) !== 55296 || len === 2 && (code & 64512) === 55296 && (char.charCodeAt(1) & 64512) === 56320;
-	return valid;
+	return len === 1 && (code & 63488) !== 55296 || len === 2 && (code & 64512) === 55296 && (char.charCodeAt(1) & 64512) === 56320;
 }
 function assertValidUtf16Character(char) {
 	if (!isValidUtf16Character(char)) {
@@ -2359,17 +2318,17 @@ var Utf8Accumulator = class Utf8Accumulator {
 		if ((byte & 224) === 192) {
 			this.value = byte & 31;
 			this.remaining = 1;
-			return void 0;
+			return;
 		}
 		if ((byte & 240) === 224) {
 			this.value = byte & 15;
 			this.remaining = 2;
-			return void 0;
+			return;
 		}
 		if ((byte & 248) === 240) {
 			this.value = byte & 7;
 			this.remaining = 3;
-			return void 0;
+			return;
 		}
 		return this.reset();
 	}
@@ -2433,8 +2392,7 @@ function encodeTextToUtf8(text) {
 
 //#endregion
 //#region src/lib/TrieBlob/CharIndex.ts
-const emptySeq = [0];
-Object.freeze(emptySeq);
+Object.freeze([0]);
 var CharIndex = class {
 	#charToUtf8SeqMap;
 	#lastWord = "";
@@ -2679,8 +2637,7 @@ var FastTrieBlobINode = class FastTrieBlobINode {
 	entries() {
 		if (this._entries) return this._entries;
 		if (!this._count) return EmptyEntries$1;
-		const entries = this.getNodesEntries();
-		this._entries = entries.map(([key, value]) => [key, new FastTrieBlobINode(this.trie, value)]);
+		this._entries = this.getNodesEntries().map(([key, value]) => [key, new FastTrieBlobINode(this.trie, value)]);
 		return this._entries;
 	}
 	/** get child ITrieNode */
@@ -2695,16 +2652,14 @@ var FastTrieBlobINode = class FastTrieBlobINode {
 		return new FastTrieBlobINode(this.trie, idx$1);
 	}
 	has(char) {
-		const idx$1 = this.trie.nodeGetChild(this.id, char);
-		return idx$1 !== void 0;
+		return this.trie.nodeGetChild(this.id, char) !== void 0;
 	}
 	hasChildren() {
 		return this._count > 0;
 	}
 	child(keyIdx) {
 		if (!this._values && !this.containsChainedIndexes()) {
-			const n = this.node[keyIdx + 1];
-			const nodeIdx = n >>> this.trie.NodeChildRefShift;
+			const nodeIdx = this.node[keyIdx + 1] >>> this.trie.NodeChildRefShift;
 			return new FastTrieBlobINode(this.trie, nodeIdx);
 		}
 		return this.values()[keyIdx];
@@ -2742,8 +2697,7 @@ var FastTrieBlobINode = class FastTrieBlobINode {
 		const len = this._count;
 		const node = this.node;
 		for (let i = 1; i <= len && !found; ++i) {
-			const entry = node[i];
-			const codePoint = entry & NodeMaskChildCharIndex;
+			const codePoint = node[i] & NodeMaskChildCharIndex;
 			found = Utf8Accumulator.isMultiByte(codePoint);
 		}
 		this._chained = !!found;
@@ -2941,8 +2895,7 @@ var TrieBlobINode = class TrieBlobINode {
 	entries() {
 		if (this._entries) return this._entries;
 		if (!this._count) return EmptyEntries;
-		const entries = this.getNodesEntries();
-		this._entries = entries.map(([key, value]) => [key, new TrieBlobINode(this.trie, value)]);
+		this._entries = this.getNodesEntries().map(([key, value]) => [key, new TrieBlobINode(this.trie, value)]);
 		return this._entries;
 	}
 	/** get child ITrieNode */
@@ -2957,8 +2910,7 @@ var TrieBlobINode = class TrieBlobINode {
 	}
 	child(keyIdx) {
 		if (!this._values && !this.containsChainedIndexes()) {
-			const n = this.trie.nodes[this.nodeIdx + keyIdx + 1];
-			const nodeIdx = n >>> this.trie.NodeChildRefShift;
+			const nodeIdx = this.trie.nodes[this.nodeIdx + keyIdx + 1] >>> this.trie.NodeChildRefShift;
 			return new TrieBlobINode(this.trie, nodeIdx);
 		}
 		return this.values()[keyIdx];
@@ -3004,8 +2956,7 @@ var TrieBlobINode = class TrieBlobINode {
 		const nodes = this.trie.nodes;
 		const len = this._count;
 		for (let i = 0; i < len && !found; ++i) {
-			const entry = nodes[i + offset];
-			const charIdx = entry & NodeMaskChildCharIndex;
+			const charIdx = nodes[i + offset] & NodeMaskChildCharIndex;
 			found = Utf8Accumulator.isMultiByte(charIdx);
 		}
 		this._chained = !!found;
@@ -3121,8 +3072,7 @@ var TrieBlobIRoot = class extends TrieBlobINode {
 //#region src/lib/TrieBlob/TrieBlob.ts
 const NodeHeaderNumChildrenBits = 8;
 const NodeHeaderNumChildrenShift = 0;
-const HEADER_SIZE_UINT32 = 8;
-const HEADER_SIZE = HEADER_SIZE_UINT32 * 4;
+const HEADER_SIZE = 32;
 const HEADER_OFFSET = 0;
 const HEADER_OFFSET_SIG = HEADER_OFFSET;
 const HEADER_OFFSET_ENDIAN = HEADER_OFFSET_SIG + 8;
@@ -3130,7 +3080,6 @@ const HEADER_OFFSET_VERSION = HEADER_OFFSET_ENDIAN + 4;
 const HEADER_OFFSET_NODES = HEADER_OFFSET_VERSION + 4;
 const HEADER_OFFSET_NODES_LEN = HEADER_OFFSET_NODES + 4;
 const HEADER_OFFSET_CHAR_INDEX = HEADER_OFFSET_NODES_LEN + 4;
-const HEADER_OFFSET_CHAR_INDEX_LEN = HEADER_OFFSET_CHAR_INDEX + 4;
 const HEADER = {
 	header: HEADER_OFFSET,
 	sig: HEADER_OFFSET_SIG,
@@ -3139,7 +3088,7 @@ const HEADER = {
 	nodes: HEADER_OFFSET_NODES,
 	nodesLen: HEADER_OFFSET_NODES_LEN,
 	charIndex: HEADER_OFFSET_CHAR_INDEX,
-	charIndexLen: HEADER_OFFSET_CHAR_INDEX_LEN
+	charIndexLen: HEADER_OFFSET_CHAR_INDEX + 4
 };
 const headerSig = "TrieBlob";
 const version = "00.01.00";
@@ -3193,8 +3142,7 @@ var TrieBlob = class TrieBlob {
 	*/
 	find(word, strict) {
 		if (!this.hasCompoundWords) {
-			const found = this.#hasWord(0, word);
-			if (found) return {
+			if (this.#hasWord(0, word)) return {
 				found: word,
 				compoundUsed: false,
 				caseMatched: true
@@ -3210,13 +3158,12 @@ var TrieBlob = class TrieBlob {
 				caseMatched: false
 			};
 		}
-		return void 0;
 	}
 	getRoot() {
 		return this.#iTrieRoot ??= this._getRoot();
 	}
 	_getRoot() {
-		const trieData = new TrieBlobInternals(this.nodes, this.charIndex, {
+		return new TrieBlobIRoot(new TrieBlobInternals(this.nodes, this.charIndex, {
 			NodeMaskEOW: TrieBlob.NodeMaskEOW,
 			NodeMaskNumChildren: TrieBlob.NodeMaskNumChildren,
 			NodeMaskChildCharIndex: TrieBlob.NodeMaskChildCharIndex,
@@ -3230,8 +3177,7 @@ var TrieBlob = class TrieBlob {
 			hasCompoundWords: this.hasCompoundWords,
 			hasForbiddenWords: this.hasForbiddenWords,
 			hasNonStrictWords: this.hasNonStrictWords
-		});
-		return new TrieBlobIRoot(trieData, 0, this.info, { find: (word, strict) => this.find(word, strict) });
+		}), 0, this.info, { find: (word, strict) => this.find(word, strict) });
 	}
 	getNode(prefix) {
 		return findNode$1(this.getRoot(), prefix);
@@ -3296,8 +3242,7 @@ var TrieBlob = class TrieBlob {
 	*/
 	_lookupNode(nodeIdx, char) {
 		const indexSeq = this.letterToNodeCharIndexSequence(char);
-		const currNodeIdx = this.#lookupNode(nodeIdx, indexSeq);
-		return currNodeIdx;
+		return this.#lookupNode(nodeIdx, indexSeq);
 	}
 	*words() {
 		const NodeMaskNumChildren = TrieBlob.NodeMaskNumChildren;
@@ -3316,13 +3261,11 @@ var TrieBlob = class TrieBlob {
 			const { nodeIdx, pos, word, acc } = stack[depth];
 			const node = nodes[nodeIdx];
 			if (!pos && node & NodeMaskEOW) yield word;
-			const len = node & NodeMaskNumChildren;
-			if (pos >= len) {
+			if (pos >= (node & NodeMaskNumChildren)) {
 				--depth;
 				continue;
 			}
-			const nextPos = ++stack[depth].pos;
-			const entry = nodes[nodeIdx + nextPos];
+			const entry = nodes[nodeIdx + ++stack[depth].pos];
 			const nAcc = acc.clone();
 			const codePoint = nAcc.decode(entry & NodeMaskChildCharIndex);
 			const letter = codePoint && String.fromCodePoint(codePoint) || "";
@@ -3357,8 +3300,7 @@ var TrieBlob = class TrieBlob {
 	}
 	encodeBin() {
 		const charIndex = Buffer.from(this.charIndex.charIndex.join("\n"));
-		const charIndexLen = charIndex.byteLength + 3 & -4;
-		const nodeOffset = HEADER_SIZE + charIndexLen;
+		const nodeOffset = HEADER_SIZE + (charIndex.byteLength + 3 & -4);
 		const size = nodeOffset + this.nodes.length * 4;
 		const useLittle = isLittleEndian();
 		const buffer$1 = Buffer.alloc(size);
@@ -3385,9 +3327,7 @@ var TrieBlob = class TrieBlob {
 		const offsetCharIndex = header.getUint32(HEADER.charIndex, useLittle);
 		const lenCharIndex = header.getUint32(HEADER.charIndexLen, useLittle);
 		const charIndex = Buffer.from(blob.subarray(offsetCharIndex, offsetCharIndex + lenCharIndex)).toString("utf8").split("\n");
-		const nodes = new Uint32Array(blob.buffer, offsetNodes, lenNodes);
-		const trieBlob = new TrieBlob(nodes, new CharIndex(charIndex), defaultTrieInfo);
-		return trieBlob;
+		return new TrieBlob(new Uint32Array(blob.buffer, offsetNodes, lenNodes), new CharIndex(charIndex), defaultTrieInfo);
 	}
 	static NodeMaskEOW = 256;
 	static NodeMaskNumChildren = (1 << NodeHeaderNumChildrenBits) - 1 & 65535;
@@ -3412,13 +3352,11 @@ function isLittleEndian() {
 		3,
 		4
 	]);
-	const view = new DataView(buf.buffer);
-	return view.getUint32(0, true) === 67305985;
+	return new DataView(buf.buffer).getUint32(0, true) === 67305985;
 }
 function checkSig(blob) {
 	if (blob.length < HEADER_SIZE) return false;
-	const buf = Buffer.from(blob, 0, 8);
-	if (buf.toString("utf8", 0, 8) !== headerSig) return false;
+	if (Buffer.from(blob, 0, 8).toString("utf8", 0, 8) !== headerSig) return false;
 	return true;
 }
 var ErrorDecodeTrieBlob = class extends Error {
@@ -3475,8 +3413,7 @@ function trieBlobSort(data) {
 			last = cIdx;
 		}
 		if (i === end) continue;
-		const sorted = data.slice(start, end).sort((a, b) => (a & MaskChildCharIndex) - (b & MaskChildCharIndex));
-		sorted.forEach((v, i$1) => data[start + i$1] = v);
+		data.slice(start, end).sort((a, b) => (a & MaskChildCharIndex) - (b & MaskChildCharIndex)).forEach((v, i$1) => data[start + i$1] = v);
 	}
 }
 
@@ -3525,8 +3462,7 @@ var FastTrieBlob = class FastTrieBlob {
 		const charIndexes = this.wordToUtf8Seq(word);
 		const found = this.#lookupNode(nodeIdx, charIndexes);
 		if (found === void 0) return false;
-		const node = this.nodes[found];
-		return !!(node[0] & this.bitMasksInfo.NodeMaskEOW);
+		return !!(this.nodes[found][0] & this.bitMasksInfo.NodeMaskEOW);
 	}
 	/**
 	* Find the node index for the given Utf8 character sequence.
@@ -3564,26 +3500,24 @@ var FastTrieBlob = class FastTrieBlob {
 		const NodeChildRefShift = this.bitMasksInfo.NodeChildRefShift;
 		const NodeMaskEOW = this.bitMasksInfo.NodeMaskEOW;
 		const nodes = this.nodes;
-		const accumulator = Utf8Accumulator.create();
 		const stack = [{
 			nodeIdx: 0,
 			pos: 0,
 			word: "",
-			accumulator
+			accumulator: Utf8Accumulator.create()
 		}];
 		let depth = 0;
 		while (depth >= 0) {
-			const { nodeIdx, pos, word, accumulator: accumulator$1 } = stack[depth];
+			const { nodeIdx, pos, word, accumulator } = stack[depth];
 			const node = nodes[nodeIdx];
 			if (!pos && node[0] & NodeMaskEOW) yield word;
 			if (pos >= node.length - 1) {
 				--depth;
 				continue;
 			}
-			const nextPos = ++stack[depth].pos;
-			const entry = node[nextPos];
+			const entry = node[++stack[depth].pos];
 			const charIdx = entry & NodeMaskChildCharIndex;
-			const acc = accumulator$1.clone();
+			const acc = accumulator.clone();
 			const codePoint = acc.decode(charIdx);
 			const letter = codePoint && String.fromCodePoint(codePoint) || "";
 			++depth;
@@ -3684,13 +3618,10 @@ var FastTrieBlob = class FastTrieBlob {
 		for (let p = 1; p < n.length; ++p) {
 			const v = n[p];
 			const cIdx = v & this.bitMasksInfo.NodeMaskChildCharIndex;
-			const a = acc.clone();
-			const codePoint = a.decode(cIdx);
-			const c = codePoint !== void 0 ? String.fromCodePoint(codePoint) : "∎";
-			const i = v >>> this.bitMasksInfo.NodeChildRefShift;
+			const codePoint = acc.clone().decode(cIdx);
 			children[p] = {
-				c,
-				i,
+				c: codePoint !== void 0 ? String.fromCodePoint(codePoint) : "∎",
+				i: v >>> this.bitMasksInfo.NodeChildRefShift,
 				cIdx
 			};
 		}
@@ -3913,13 +3844,12 @@ var FastTrieBlobBuilder = class FastTrieBlobBuilder {
 			for (let n = num; n > 0; --n) depth = stack[depth].pDepth;
 			nodeIdx = stack[depth + 1].nodeIdx;
 		};
-		const c = {
+		return {
 			insertChar,
 			markEOW,
 			reference,
 			backStep
 		};
-		return c;
 	}
 	_insert(word) {
 		word = word.trim();
@@ -3935,8 +3865,7 @@ var FastTrieBlobBuilder = class FastTrieBlobBuilder {
 		for (let p = 0; p < len; ++p) {
 			const seq = utf8Seq[p];
 			const node = nodes[nodeIdx];
-			const count = node.length;
-			let i = count - 1;
+			let i = node.length - 1;
 			for (; i > 0; --i) if ((node[i] & NodeMaskChildCharIndex) === seq) break;
 			if (i > 0) {
 				nodeIdx = node[i] >>> NodeChildRefShift;
@@ -3966,8 +3895,7 @@ var FastTrieBlobBuilder = class FastTrieBlobBuilder {
 		let node = nodes[nodeIdx];
 		for (let p = 0; p < len; ++p, node = nodes[nodeIdx]) {
 			const letterIdx = charIndexes[p];
-			const count = node.length;
-			let i = count - 1;
+			let i = node.length - 1;
 			for (; i > 0; --i) if ((node[i] & NodeMaskChildCharIndex) === letterIdx) break;
 			if (i < 1) return false;
 			nodeIdx = node[i] >>> NodeChildRefShift;
@@ -3997,8 +3925,7 @@ var FastTrieBlobBuilder = class FastTrieBlobBuilder {
 		assert(!this.isReadonly(), "FastTrieBlobBuilder is readonly");
 	}
 	static fromWordList(words, options) {
-		const ft = new FastTrieBlobBuilder(options);
-		return ft.insert(words).build();
+		return new FastTrieBlobBuilder(options).insert(words).build();
 	}
 	static fromTrieRoot(root) {
 		const bitMasksInfo = FastTrieBlobBuilder.DefaultBitMaskInfo;
@@ -4039,8 +3966,7 @@ var FastTrieBlobBuilder = class FastTrieBlobBuilder {
 				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$1;
+					node[pos] = tf.nodes.push(next) - 1 << NodeChildRefShift | idx$1;
 					node = next;
 				}
 			}
@@ -4071,7 +3997,7 @@ function clean(t) {
 
 //#endregion
 //#region src/lib/ITrie.ts
-const defaultLegacyMinCompoundLength$2 = 3;
+const defaultLegacyMinCompoundLength$1 = 3;
 var ITrieImpl = class ITrieImpl {
 	_info;
 	root;
@@ -4118,10 +4044,7 @@ var ITrieImpl = class ITrieImpl {
 	}
 	has(word, minLegacyCompoundLength) {
 		if (this.hasWord(word, false)) return true;
-		if (minLegacyCompoundLength) {
-			const f = this.findWord(word, { useLegacyWordCompounds: minLegacyCompoundLength });
-			return !!f.found;
-		}
+		if (minLegacyCompoundLength) return !!this.findWord(word, { useLegacyWordCompounds: minLegacyCompoundLength }).found;
 		return false;
 	}
 	/**
@@ -4131,15 +4054,14 @@ var ITrieImpl = class ITrieImpl {
 	* @returns true if the word was found and is not forbidden.
 	*/
 	hasWord(word, caseSensitive) {
-		const f = this.findWord(word, {
+		return !!this.findWord(word, {
 			caseSensitive,
 			checkForbidden: false
-		});
-		return !!f.found;
+		}).found;
 	}
 	findWord(word, options) {
 		if (options?.useLegacyWordCompounds) {
-			const len = options.useLegacyWordCompounds !== true ? options.useLegacyWordCompounds : defaultLegacyMinCompoundLength$2;
+			const len = options.useLegacyWordCompounds !== true ? options.useLegacyWordCompounds : defaultLegacyMinCompoundLength$1;
 			const findOptions = this.createFindOptions({
 				legacyMinCompoundLength: len,
 				matchCase: options.caseSensitive || false
@@ -4228,12 +4150,10 @@ var ITrieImpl = class ITrieImpl {
 	static create(words, info) {
 		const builder = new FastTrieBlobBuilder(info);
 		builder.insert(words);
-		const root = builder.build();
-		return new ITrieImpl(root, void 0);
+		return new ITrieImpl(builder.build(), void 0);
 	}
 	createFindOptions(options) {
-		const findOptions = createFindOptions$1(options);
-		return findOptions;
+		return createFindOptions$1(options);
 	}
 };
 
@@ -4303,9 +4223,8 @@ function iteratorTrieWords(node) {
 	return walkerWords(node);
 }
 function createTrieRoot(options) {
-	const fullOptions = mergeOptionalWithDefaults(options);
 	return {
-		...fullOptions,
+		...mergeOptionalWithDefaults(options),
 		c: Object.create(null)
 	};
 }
@@ -4365,15 +4284,13 @@ function checkCircular(root) {
 		};
 		if (inStack.has(n)) {
 			const stack = [...inStack, n];
-			const word = trieStackToWord(stack);
-			const pos = stack.indexOf(n);
 			return {
 				isCircular: true,
 				allSeen: false,
 				ref: {
 					stack,
-					word,
-					pos
+					word: trieStackToWord(stack),
+					pos: stack.indexOf(n)
 				}
 			};
 		}
@@ -4412,9 +4329,8 @@ function isCircular(root) {
 	return checkCircular(root).isCircular;
 }
 function trieNodeToRoot(node, options) {
-	const newOptions = mergeOptionalWithDefaults(options);
 	return {
-		...newOptions,
+		...mergeOptionalWithDefaults(options),
 		c: node.c || Object.create(null)
 	};
 }
@@ -4432,9 +4348,7 @@ function consolidate(root) {
 	const knownMap = /* @__PURE__ */ new Map();
 	if (isCircular(root)) throw new Error("Trie is circular.");
 	function signature$1(n) {
-		const isWord = n.f ? "*" : "";
-		const ref = n.c ? JSON.stringify(Object.entries(n.c).map(([k, n$1]) => [k, cached.get(n$1)])) : "";
-		return isWord + ref;
+		return (n.f ? "*" : "") + (n.c ? JSON.stringify(Object.entries(n.c).map(([k, n$1]) => [k, cached.get(n$1)])) : "");
 	}
 	function findEow(n) {
 		if (n.f && !n.c) return n;
@@ -4499,21 +4413,19 @@ function consolidate(root) {
 
 //#endregion
 //#region src/lib/TrieNode/find.ts
-const defaultLegacyMinCompoundLength$1 = 3;
 const _defaultFindOptions = {
 	matchCase: false,
 	compoundMode: "compound",
 	forbidPrefix: FORBID_PREFIX,
 	compoundFix: COMPOUND_FIX,
 	caseInsensitivePrefix: CASE_INSENSITIVE_PREFIX,
-	legacyMinCompoundLength: defaultLegacyMinCompoundLength$1
+	legacyMinCompoundLength: 3
 };
-const arrayCompoundModes = [
+const knownCompoundModes = new Map([
 	"none",
 	"compound",
 	"legacy"
-];
-const knownCompoundModes = new Map(arrayCompoundModes.map((a) => [a, a]));
+].map((a) => [a, a]));
 /**
 *
 * @param root Trie root node. root.c contains the compound root and forbidden root.
@@ -4555,23 +4467,18 @@ function _findWordNode(root, word, options) {
 	function __findCompound() {
 		const f = findCompoundWord(root, word, compoundPrefix, ignoreCasePrefix);
 		const result = { ...f };
-		if (f.found !== false && f.compoundUsed) {
-			const r = !f.caseMatched ? walk$1(root, options.caseInsensitivePrefix) : root;
-			result.forbidden = isForbiddenWord(r, word, options.forbidPrefix);
-		}
+		if (f.found !== false && f.compoundUsed) result.forbidden = isForbiddenWord(!f.caseMatched ? walk$1(root, options.caseInsensitivePrefix) : root, word, options.forbidPrefix);
 		return result;
 	}
 	function __findExact() {
 		const n = walk$1(root, word);
-		const isFound = isEndOfWordNode(n);
-		const result = {
-			found: isFound && word,
+		return {
+			found: isEndOfWordNode(n) && word,
 			compoundUsed: false,
 			forbidden: isForbiddenWord(root, word, options.forbidPrefix),
 			node: n,
 			caseMatched: true
 		};
-		return result;
 	}
 	switch (compoundMode) {
 		case "none": return options.matchCase ? __findExact() : __findCompound();
@@ -4615,8 +4522,7 @@ function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix) {
 	while (true) {
 		const s = stack[i];
 		const h = w[i++];
-		const n = s.cr || s.n;
-		const c = n?.c?.[h];
+		const c = (s.cr || s.n)?.c?.[h];
 		if (c && i < word.length) {
 			caseMatched = s.caseMatched;
 			stack[i] = {
@@ -4645,15 +4551,13 @@ function findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix) {
 			break;
 		}
 	}
-	const found = i && i === word.length && word || false;
-	const result = {
-		found,
+	return {
+		found: i && i === word.length && word || false,
 		compoundUsed,
 		node,
 		forbidden: void 0,
 		caseMatched
 	};
-	return result;
 }
 function findCompoundWord(root, word, compoundCharacter, ignoreCasePrefix) {
 	const { found, compoundUsed, node, caseMatched } = findCompoundNode(root, word, compoundCharacter, ignoreCasePrefix);
@@ -4708,8 +4612,7 @@ function findLegacyCompoundNode(roots, word, minCompoundLength) {
 	while (true) {
 		const s = stack[i];
 		const h = w[i++];
-		const n = s.cr || s.n;
-		const c = n?.c?.[h];
+		const c = (s.cr || s.n)?.c?.[h];
 		if (c && i < wLen) stack[i] = {
 			n: c,
 			usedRoots: 0,
@@ -4749,15 +4652,13 @@ function findLegacyCompoundNode(roots, word, minCompoundLength) {
 		}
 		return letters.join("");
 	}
-	const found = extractWord();
-	const result = {
-		found,
+	return {
+		found: extractWord(),
 		compoundUsed,
 		node,
 		forbidden: void 0,
 		caseMatched
 	};
-	return result;
 }
 function isForbiddenWord(root, word, forbiddenPrefix) {
 	return findWordExact(root?.c?.[forbiddenPrefix], word);
@@ -4806,12 +4707,10 @@ var TrieNodeTrie = class TrieNodeTrie {
 		return this._size ??= countNodes(this.root);
 	}
 	static createFromWords(words, options) {
-		const root = createTrieRootFromList(words, options);
-		return new TrieNodeTrie(root);
+		return new TrieNodeTrie(createTrieRootFromList(words, options));
 	}
 	static createFromWordsAndConsolidate(words, options) {
-		const root = createTrieRootFromList(words, options);
-		return new TrieNodeTrie(consolidate(root));
+		return new TrieNodeTrie(consolidate(createTrieRootFromList(words, options)));
 	}
 };
 
@@ -4874,11 +4773,10 @@ function convertToTrieRefNodes(root) {
 	function convert(n) {
 		const { f, c } = n;
 		const r = c ? Object.entries(c).sort((a, b) => a[0] < b[0] ? -1 : 1).map(([s, n$1]) => [s, cached.get(n$1)]) : void 0;
-		const rn = r ? f ? {
+		return r ? f ? {
 			f,
 			r
 		} : { r } : { f };
-		return rn;
 	}
 	function* walk$3(root$1) {
 		cached.set(eow, count++);
@@ -4918,7 +4816,7 @@ function trieToExportString(node, base) {
 	return genSequence(walk$3(node));
 }
 function generateHeader$3(base, comment) {
-	const header = [
+	return genSequence([
 		...[
 			"#!/usr/bin/env cspell-trie reader",
 			"TrieXv1",
@@ -4926,8 +4824,7 @@ function generateHeader$3(base, comment) {
 		],
 		...comment ? comment.split("\n").map((a) => "# " + a) : [],
 		...["# Data:"]
-	];
-	return genSequence(header).map((a) => a + "\n");
+	]).map((a) => a + "\n");
 }
 /**
 * Serialize a TrieNode.
@@ -4940,8 +4837,7 @@ function serializeTrie$4(root, options = 16) {
 	const { base = 16, comment = "" } = options;
 	const radix = base > 36 ? 36 : base < 10 ? 10 : base;
 	const rows = toReferences(root).map((node) => {
-		const row = [...trieToExportString(node, radix), "\n"].join("").replaceAll(regExTrailingComma, "$1");
-		return row;
+		return [...trieToExportString(node, radix), "\n"].join("").replaceAll(regExTrailingComma, "$1");
 	});
 	return generateHeader$3(radix, comment).concat(rows);
 }
@@ -4976,22 +4872,20 @@ function importTrie$5(linesX) {
 	const regUnescape = /[\\](.)/g;
 	const flagsWord = { f: FLAG_WORD };
 	function splitLine$1(line) {
-		const pattern = "$1__COMMA__";
-		return line.replaceAll(regNotEscapedCommas, pattern).split(regUnescapeCommas).map((a) => a.replaceAll(regUnescape, "$1"));
+		return line.replaceAll(regNotEscapedCommas, "$1__COMMA__").split(regUnescapeCommas).map((a) => a.replaceAll(regUnescape, "$1"));
 	}
 	function decodeLine$1(line, nodes) {
 		const isWord = line[0] === EOW$3;
 		line = isWord ? line.slice(1) : line;
 		const flags = isWord ? flagsWord : {};
 		const children = splitLine$1(line).filter((a) => !!a).map((a) => [a[0], Number.parseInt(a.slice(1) || "0", radix)]).map(([k, i]) => [k, nodes[i]]);
-		const cNode = children.length ? { c: Object.fromEntries(children) } : {};
 		return {
-			...cNode,
+			...children.length ? { c: Object.fromEntries(children) } : {},
 			...flags
 		};
 	}
 	readHeader(iter);
-	const n = genSequence([DATA$4]).concat(iter).map((a) => a.replace(/\r?\n/, "")).filter((a) => !!a).reduce((acc, line) => {
+	return trieNodeToRoot(genSequence([DATA$4]).concat(iter).map((a) => a.replace(/\r?\n/, "")).filter((a) => !!a).reduce((acc, line) => {
 		const { lines, nodes } = acc;
 		const root = decodeLine$1(line, nodes);
 		nodes[lines] = root;
@@ -5004,8 +4898,7 @@ function importTrie$5(linesX) {
 		lines: 0,
 		nodes: [],
 		root: {}
-	});
-	return trieNodeToRoot(n.root, { isCaseAware: false });
+	}).root, { isCaseAware: false });
 }
 
 //#endregion
@@ -5071,15 +4964,14 @@ function toLine(node, base) {
 	return node.s + flags + refs;
 }
 function generateHeader$2(base, comment) {
-	const header = [
+	return genSequence([
 		"#!/usr/bin/env cspell-trie reader",
 		"TrieXv2",
 		"base=" + base,
 		...comment ? comment.split("\n").map((a) => "# " + a) : [],
 		"# Data:",
 		DATA$3
-	];
-	return genSequence(header);
+	]);
 }
 /**
 * Serialize a TrieNode.
@@ -5091,11 +4983,10 @@ function serializeTrie$3(root, options = 16) {
 	options = typeof options === "number" ? { base: options } : options;
 	const { base = 16, comment = "" } = options;
 	const radix = base > 36 ? 36 : base < 10 ? 10 : base;
-	const rootRef = {
+	const rows = flattenToReferences({
 		...root,
 		s: "^"
-	};
-	const rows = flattenToReferences(rootRef).map((n) => toLine(n, base));
+	}).map((n) => toLine(n, base));
 	return generateHeader$2(radix, comment).concat(rows).map((a) => a + "\n");
 }
 function* toIterableIterator(iter) {
@@ -5138,16 +5029,15 @@ function importTrie$4(linesX) {
 	function decodeLine$1(line, nodes) {
 		const { letter, isWord, refs } = parseLine(line, radix);
 		const flags = isWord ? flagsWord : {};
-		const children = refs.map((r) => nodes[r]).sort((a, b) => a.s < b.s ? -1 : 1).map((n$1) => [n$1.s, n$1]);
-		const cNode = children.length ? { c: Object.fromEntries(children) } : {};
+		const children = refs.map((r) => nodes[r]).sort((a, b) => a.s < b.s ? -1 : 1).map((n) => [n.s, n]);
 		return {
 			s: letter,
-			...cNode,
+			...children.length ? { c: Object.fromEntries(children) } : {},
 			...flags
 		};
 	}
 	readHeader(iter);
-	const n = genSequence(iter).map((a) => a.replace(/\r?\n/, "")).filter((a) => !!a).reduce((acc, line) => {
+	return trieNodeToRoot(genSequence(iter).map((a) => a.replace(/\r?\n/, "")).filter((a) => !!a).reduce((acc, line) => {
 		const { nodes } = acc;
 		const root = decodeLine$1(line, nodes);
 		nodes.push(root);
@@ -5161,8 +5051,7 @@ function importTrie$4(linesX) {
 			s: "",
 			c: Object.create(null)
 		}
-	});
-	return trieNodeToRoot(n.root, { isCaseAware: false });
+	}).root, { isCaseAware: false });
 }
 
 //#endregion
@@ -5236,12 +5125,11 @@ const specialPrefix$1 = stringToCharSet$2("~!");
 const WORDS_PER_LINE$1 = 20;
 const DATA$2 = "__DATA__";
 function generateHeader$1(base, comment) {
-	const comments = comment.split("\n").map((a) => "# " + a.trimEnd()).join("\n");
 	return `\
 #!/usr/bin/env cspell-trie reader
 TrieXv4
 base=${base}
-${comments}
+${comment.split("\n").map((a) => "# " + a.trimEnd()).join("\n")}
 # Data:
 ${DATA$2}
 `;
@@ -5315,10 +5203,7 @@ function serializeTrie$2(root, options = 16) {
 			return;
 		}
 		if (node.c) {
-			if (depth > 0 && depth <= 2) {
-				const chars = wordChars.slice(0, depth).map(escape).join("");
-				yield* emit(comment_begin + chars + comment_end);
-			}
+			if (depth > 0 && depth <= 2) yield* emit(comment_begin + wordChars.slice(0, depth).map(escape).join("") + comment_end);
 			cache.set(node, count++);
 			const c = Object.entries(node.c).sort((a, b) => a[0] < b[0] ? -1 : 1);
 			for (const [s, n] of c) {
@@ -5337,8 +5222,7 @@ function serializeTrie$2(root, options = 16) {
 		yield* flush();
 	}
 	const lines = [...bufferLines(serialize(root), 1e3, "")];
-	const resolvedReferences = refMap.refCounts.map(([node]) => cache.get(node) || 0);
-	const reference = "[\n" + resolvedReferences.map((n) => n.toString(radix)).join(",").replaceAll(/.{110,130}[,]/g, "$&\n") + "\n]\n";
+	const reference = "[\n" + refMap.refCounts.map(([node]) => cache.get(node) || 0).map((n) => n.toString(radix)).join(",").replaceAll(/.{110,130}[,]/g, "$&\n") + "\n]\n";
 	return pipe([generateHeader$1(radix, comment), reference], opAppend(lines));
 }
 function buildReferenceMap(root, base) {
@@ -5361,16 +5245,14 @@ function buildReferenceMap(root, base) {
 	const refCountAndNode = [...pipe(refCount, opFilter(([_, ref]) => ref.c >= 2))].sort((a, b) => b[1].c - a[1].c || a[1].n - b[1].n);
 	let adj = 0;
 	const baseLogScale = 1 / Math.log(base);
-	const refs = refCountAndNode.filter(([_, ref], idx$1) => {
+	return { refCounts: refCountAndNode.filter(([_, ref], idx$1) => {
 		const i = idx$1 - adj;
 		const charsIdx = Math.ceil(Math.log(i) * baseLogScale);
 		const charsNode = Math.ceil(Math.log(ref.n) * baseLogScale);
-		const savings = ref.c * (charsNode - charsIdx) - charsIdx;
-		const keep = savings > 0;
+		const keep = ref.c * (charsNode - charsIdx) - charsIdx > 0;
 		adj += keep ? 0 : 1;
 		return keep;
-	}).map(([n, ref]) => [n, ref.c]);
-	return { refCounts: refs };
+	}).map(([n, ref]) => [n, ref.c]) };
 }
 function importTrie$3(linesX) {
 	linesX = typeof linesX === "string" ? linesX.split(/^/m) : linesX;
@@ -5395,8 +5277,7 @@ function importTrie$3(linesX) {
 		parseHeaderRows(headerRows);
 	}
 	readHeader(iter);
-	const root = parseStream$1(radix, iter);
-	return root;
+	return parseStream$1(radix, iter);
 }
 const numbersSet = stringToCharSet$2("0123456789");
 function parseStream$1(radix, iter) {
@@ -5483,8 +5364,7 @@ function parseStream$1(radix, iter) {
 	function parseCharacter(acc, s) {
 		const parser = void 0;
 		const { root: root$1, nodes, stack } = acc;
-		const top = stack[stack.length - 1];
-		const node = top.node;
+		const node = stack[stack.length - 1].node;
 		const c = node.c ?? Object.create(null);
 		const n = {
 			f: void 0,
@@ -5553,8 +5433,7 @@ function parseStream$1(radix, iter) {
 		[INLINE_DATA_COMMENT_LINE, parseComment]
 	]);
 	function parserMain(acc, s) {
-		const parser = acc.parser ?? parsers[s] ?? parseCharacter;
-		return parser(acc, s);
+		return (acc.parser ?? parsers[s] ?? parseCharacter)(acc, s);
 	}
 	const charsetSpaces = stringToCharSet$2(" \r\n	");
 	function parseReferenceIndex(acc, s) {
@@ -5691,15 +5570,15 @@ var TrieNodeBuilder = class {
 			assertIsValidChar(char);
 			if (currNode.k) {
 				const s$1 = stack[depth];
-				const { k: _, c: c$2,...copy } = currNode;
+				const { k: _, c: c$1,...copy } = currNode;
 				currNode = s$1.n.c[s$1.c] = copy;
-				if (c$2) currNode.c = Object.assign(Object.create(null), c$2);
+				if (c$1) currNode.c = Object.assign(Object.create(null), c$1);
 				nodes.push(currNode);
 			}
-			const c$1 = currNode.c || Object.create(null);
-			currNode.c = c$1;
+			const c = currNode.c || Object.create(null);
+			currNode.c = c;
 			const n = currNode;
-			const next = c$1[char] = c$1[char] || {};
+			const next = c[char] = c[char] || {};
 			nodes.push(next);
 			++depth;
 			const s = stack[depth];
@@ -5731,13 +5610,12 @@ var TrieNodeBuilder = class {
 			depth -= num;
 			currNode = stack[depth + 1].n;
 		};
-		const c = {
+		return {
 			insertChar,
 			markEOW,
 			reference,
 			backStep
 		};
-		return c;
 	}
 	sortChildren(node) {
 		const entries = Object.entries(node.c).sort((a, b) => compare(a[0], b[0]));
@@ -5759,8 +5637,7 @@ const specialCharacterMap$1 = new Map([
 const characterMap = new Map([...specialCharacterMap$1].map((a) => [a[1], a[0]]));
 const DATA$1 = "__DATA__";
 function importTrieV3AsTrieRoot(srcLines) {
-	const builder = new TrieNodeBuilder();
-	return importTrieV3WithBuilder(builder, srcLines);
+	return importTrieV3WithBuilder(new TrieNodeBuilder(), srcLines);
 }
 function importTrieV3WithBuilder(builder, srcLines) {
 	const timer = getGlobalPerfTimer();
@@ -5776,10 +5653,7 @@ function importTrieV3WithBuilder(builder, srcLines) {
 		radix = Number.parseInt(header.replace(headerReg$2, "$1"), 10);
 	}
 	function findStartOfData(data) {
-		for (let i = 0; i < data.length; ++i) {
-			const line = data[i];
-			if (line.includes(DATA$1)) return i;
-		}
+		for (let i = 0; i < data.length; ++i) if (data[i].includes(DATA$1)) return i;
 		return -1;
 	}
 	function readHeader(data) {
@@ -5795,9 +5669,8 @@ function importTrieV3WithBuilder(builder, srcLines) {
 	const startOfData = findStartOfData(dataLines);
 	if (startOfData < 0) throw new Error("Unknown file format");
 	readHeader(dataLines.slice(0, startOfData));
-	const cursor = builder.getCursor();
 	let node = {
-		cursor,
+		cursor: builder.getCursor(),
 		parser: void 0
 	};
 	const parser = parseStream(radix);
@@ -5879,8 +5752,7 @@ function parseStream(radix) {
 		[LF, parseIgnore]
 	]);
 	function parserMain(acc, s) {
-		const parser = acc.parser ?? parsers.get(s) ?? parseCharacter;
-		return parser(acc, s);
+		return (acc.parser ?? parsers.get(s) ?? parseCharacter)(acc, s);
 	}
 	return parserMain;
 }
@@ -5931,8 +5803,7 @@ function importTrie$2(input) {
 		}
 		return headerRows;
 	}
-	const headerLines = readHeader(lines);
-	const version$1 = parseHeaderRows(headerLines);
+	const version$1 = parseHeaderRows(readHeader(lines));
 	const method = deserializers$1[version$1];
 	if (!method) throw new Error(`Unsupported version: ${version$1}`);
 	return method(lines);
@@ -5941,8 +5812,7 @@ function importTrie$2(input) {
 //#endregion
 //#region src/lib/decodeTrie.ts
 function decodeTrie(raw) {
-	const data = decodeTrieData(raw);
-	return new ITrieImpl(data);
+	return new ITrieImpl(decodeTrieData(raw));
 }
 
 //#endregion
@@ -5967,15 +5837,14 @@ const specialPrefix = stringToCharSet("~!");
 const WORDS_PER_LINE = 20;
 const DATA = "__DATA__";
 function generateHeader(base, comment) {
-	const header = [
+	return [
 		"#!/usr/bin/env cspell-trie reader",
 		"TrieXv3",
 		"base=" + base,
 		...comment ? comment.split("\n").map((a) => "# " + a) : [],
 		"# Data:",
 		DATA
-	];
-	return header.map((a) => a + "\n");
+	].map((a) => a + "\n");
 }
 /**
 * Serialize a TrieRoot.
@@ -6080,8 +5949,7 @@ function serializeTrie$1(root, options = 16) {
 	return pipe(generateHeader(radix, comment), opAppend(bufferLines(serialize(root), 1200, "")));
 }
 function importTrie$1(srcLines) {
-	const trie = importTrieV3AsTrieRoot(srcLines);
-	return trie.root;
+	return importTrieV3AsTrieRoot(srcLines).root;
 }
 function stringToCharSet(values) {
 	const set = Object.create(null);
@@ -6138,8 +6006,7 @@ function importTrie(input) {
 		}
 		return headerRows;
 	}
-	const headerLines = readHeader(lines);
-	const version$1 = parseHeaderRows(headerLines);
+	const version$1 = parseHeaderRows(readHeader(lines));
 	const method = deserializers[version$1];
 	if (!method) throw new Error(`Unsupported version: ${version$1}`);
 	return method(lines);
@@ -8282,9 +8149,7 @@ function normalizeLocale(locale) {
 	if (regExTwoLetter.test(locale)) return locale.toLowerCase();
 	const m = locale.match(regExLocaleWithCountry);
 	if (!m) return locale;
-	const lang = m[1].toLowerCase();
-	const variant = m[2].toUpperCase();
-	return `${lang}-${variant}`;
+	return `${m[1].toLowerCase()}-${m[2].toUpperCase()}`;
 }
 function isStandardLocale(locale) {
 	return regExValidLocale.test(locale);
@@ -8348,39 +8213,31 @@ function mapEditCosts(costs = {}) {
 * @param letters - letters to join
 */
 function joinLetters(letters) {
-	const v = [...letters];
-	return v.map((a) => a.length > 1 || !a.length ? `(${a})` : a).join("");
+	return [...letters].map((a) => a.length > 1 || !a.length ? `(${a})` : a).join("");
 }
 
 //#endregion
 //#region src/lib/mappers/mapToSuggestionCostDef.ts
 function parseAlphabet(cs, locale, editCost) {
 	const { cost, penalty } = cs;
-	const characters = expandCharacterSet(cs.characters);
-	const charForms = [...pipe(characters, opMap((c) => caseForms(c, locale).sort()))];
-	const alphabet = joinLetters([...pipe(charForms, opFlatten(), opMap((letter) => accentForms(letter)), opFlatten(), opUnique())].sort());
-	const sugAlpha = clean$1({
-		map: alphabet,
-		replace: cost,
-		insDel: cost,
-		swap: cost,
-		penalty
-	});
+	const alphabet = joinLetters([...pipe([...pipe(expandCharacterSet(cs.characters), opMap((c) => caseForms(c, locale).sort()))], opFlatten(), opMap((letter) => accentForms(letter)), opFlatten(), opUnique())].sort());
 	return [
-		sugAlpha,
+		clean$1({
+			map: alphabet,
+			replace: cost,
+			insDel: cost,
+			swap: cost,
+			penalty
+		}),
 		parseAlphabetCaps(cs.characters, locale, editCost),
 		...calcCostsForAccentedLetters(alphabet, locale, editCost)
 	];
 }
 function parseAlphabetCaps(alphabet, locale, editCost) {
-	const characters = expandCharacterSet(alphabet);
-	const charForms = [...pipe(characters, opMap((c) => caseForms(c, locale).sort()))];
-	const caps = charForms.map((a) => joinLetters(a)).join("|");
-	const sugCaps = {
-		map: caps,
+	return {
+		map: [...pipe(expandCharacterSet(alphabet), opMap((c) => caseForms(c, locale).sort()))].map((a) => joinLetters(a)).join("|"),
 		replace: editCost.capsCosts
 	};
-	return sugCaps;
 }
 function calcFirstCharacterReplaceDefs(alphabets, editCost) {
 	return alphabets.map((cs) => calcFirstCharacterReplace(cs, editCost));
@@ -8388,10 +8245,9 @@ function calcFirstCharacterReplaceDefs(alphabets, editCost) {
 function calcFirstCharacterReplace(cs, editCost) {
 	const mapOfFirstLetters = [...pipe(expandCharacterSet(cs.characters), opUnique(), opMap((letter) => `(^${letter})`))].sort().join("") + "(^)";
 	const penalty = editCost.firstLetterPenalty;
-	const cost = cs.cost - penalty;
 	return {
 		map: mapOfFirstLetters,
-		replace: cost,
+		replace: cs.cost - penalty,
 		penalty: penalty * 2
 	};
 }
@@ -8408,8 +8264,7 @@ function parseAccents(cs, _editCost) {
 }
 function calcCostsForAccentedLetters(simpleMap, locale, costs) {
 	const charactersWithAccents = [...pipe(splitMap(simpleMap), opMap((char) => caseForms(char, locale)), opFlatten(), opMap((char) => [...accentForms(char)]), opFilter((forms$1) => forms$1.length > 1))];
-	const characters = pipe(charactersWithAccents, opMap((forms$1) => new Set([...forms$1, ...forms$1.map((char) => stripAccents(char))])), opMap((forms$1) => [...forms$1].sort()), opFilter((forms$1) => forms$1.length > 1), opMap(joinLetters), opUnique());
-	const replaceAccentMap = [...characters].join("|");
+	const replaceAccentMap = [...pipe(charactersWithAccents, opMap((forms$1) => new Set([...forms$1, ...forms$1.map((char) => stripAccents(char))])), opMap((forms$1) => [...forms$1].sort()), opFilter((forms$1) => forms$1.length > 1), opMap(joinLetters), opUnique())].join("|");
 	const cost = costs.accentCosts;
 	const costToReplaceAccent = !replaceAccentMap ? [] : [{
 		map: replaceAccentMap,
@@ -8469,20 +8324,16 @@ function hunspellInformationToSuggestionCostDef(hunInfo, locales) {
 	function parseAff(aff, costs$1) {
 		const regSupportedAff = /^(?:MAP|KEY|TRY|NO-TRY|ICONV|OCONV|REP)\s/;
 		const rejectAff = /^(?:MAP|KEY|TRY|ICONV|OCONV|REP)\s+\d+$/;
-		const lines = aff.split("\n").map((a) => a.replace(/#.*/, "")).map((a) => a.trim()).filter((a) => regSupportedAff.test(a)).filter((a) => !rejectAff.test(a));
-		const defs = pipe(lines, opMap((line) => pipe(operations, opMap((fn) => fn(line, costs$1)), opMap(asArrayOf), opFlatten())), opFlatten(), opFilter(isDefined$1));
-		return [...defs];
+		return [...pipe(aff.split("\n").map((a) => a.replace(/#.*/, "")).map((a) => a.trim()).filter((a) => regSupportedAff.test(a)).filter((a) => !rejectAff.test(a)), opMap((line) => pipe(operations, opMap((fn) => fn(line, costs$1)), opMap(asArrayOf), opFlatten())), opFlatten(), opFilter(isDefined$1))];
 	}
 	return parseAff(hunInfo.aff, costs);
 }
 function calcCosts(costs = {}, locale) {
 	const useLocale = locale?.length ? locale.map((loc) => loc.locale) : void 0;
-	const hunCosts = mapHunspellCosts(costs);
-	const c = {
-		...hunCosts,
+	return {
+		...mapHunspellCosts(costs),
 		locale: useLocale
 	};
-	return c;
 }
 const regExpMap = /^(?:MAP)\s+(\S+)$/;
 function affMap(line, costs) {
@@ -8501,8 +8352,7 @@ function affTry(line, costs) {
 	const m = line.match(regExpTry);
 	if (!m) return void 0;
 	const cost = costs.tryCharCost;
-	const tryChars = m[1];
-	const characters = tryChars;
+	const characters = m[1];
 	return parseAlphabet({
 		characters,
 		cost
@@ -8522,9 +8372,8 @@ const regExpNoTry = /^NO-TRY\s+(\S+)$/;
 function affNoTry(line, costs) {
 	const m = line.match(regExpNoTry);
 	if (!m) return void 0;
-	const map = m[1];
 	return {
-		map,
+		map: m[1],
 		insDel: Math.max(costs.nonAlphabetCosts - costs.tryCharCost, 0),
 		penalty: costs.nonAlphabetCosts + costs.tryCharCost
 	};
@@ -8587,9 +8436,7 @@ function affMapAccents(line, costs) {
 }
 function parseCaps(value, costs) {
 	const locale = costs.locale;
-	const letters = [...splitMap(value)].filter((a) => a !== "|");
-	const withCases = letters.map((s) => caseForms(s, locale)).filter((forms$1) => forms$1.length > 1).map(joinLetters);
-	const map = unique(withCases).join("|");
+	const map = unique([...splitMap(value)].filter((a) => a !== "|").map((s) => caseForms(s, locale)).filter((forms$1) => forms$1.length > 1).map(joinLetters)).join("|");
 	const cost = costs.capsCosts;
 	if (!map) return void 0;
 	return {
@@ -8636,8 +8483,7 @@ function toCharSets(cs, defaultValue, cost, penalty) {
 	return cs;
 }
 function processAccents(accents, editCost) {
-	const cs = toCharSets(accents, "̀-́", editCost.accentCosts);
-	return cs.map((cs$1) => parseAccents(cs$1, editCost)).filter(isDefined$1);
+	return toCharSets(accents, "̀-́", editCost.accentCosts).map((cs) => parseAccents(cs, editCost)).filter(isDefined$1);
 }
 function mapDictionaryInformationToAdjustment(dictInfo) {
 	if (!dictInfo.adjustments) return [];
@@ -8687,8 +8533,7 @@ function mapDictionaryInformationToWeightMap(dictInfo) {
 //#endregion
 //#region src/lib/suggestions/suggest.ts
 const baseCost = opCosts.baseCost;
-const swapCost = opCosts.swapCost;
-const postSwapCost = swapCost - baseCost;
+const postSwapCost = opCosts.swapCost - baseCost;
 const insertSpaceCost = -1;
 const mapSubCost = opCosts.visuallySimilar;
 const maxCostScale = opCosts.wordLengthCostFactor;
@@ -8696,8 +8541,7 @@ const discourageInsertCost = baseCost;
 const setOfSeparators = new Set([JOIN_SEPARATOR, WORD_SEPARATOR]);
 function suggest(root, word, options = {}) {
 	const opts = createSuggestionOptions(options);
-	const collectorOpts = clean(opts);
-	const collector = suggestionCollector(word, collectorOpts);
+	const collector = suggestionCollector(word, clean(opts));
 	collector.collect(genSuggestions(root, word, {
 		...opts,
 		...collector.genSuggestionOptions
@@ -8707,7 +8551,6 @@ function suggest(root, word, options = {}) {
 function* genSuggestions(root, word, options = {}) {
 	const roots = Array.isArray(root) ? root : [root];
 	for (const r of roots) yield* genCompoundableSuggestions(r, word, options);
-	return void 0;
 }
 function* genCompoundableSuggestions(root, word, options = {}) {
 	const { compoundMethod = CompoundWordsMethod.NONE, changeLimit, ignoreCase } = createSuggestionOptions(options);
@@ -8747,8 +8590,7 @@ function* genCompoundableSuggestions(root, word, options = {}) {
 		a,
 		b
 	};
-	const hint = word;
-	const iWalk = hintedWalker(root, ignoreCase, hint, compoundMethod, options.compoundSeparator);
+	const iWalk = hintedWalker(root, ignoreCase, word, compoundMethod, options.compoundSeparator);
 	let goDeeper = true;
 	for (let r = iWalk.next({ goDeeper }); !stopNow && !r.done; r = iWalk.next({ goDeeper })) {
 		const { text, node, depth } = r.value;
@@ -8766,22 +8608,16 @@ function* genCompoundableSuggestions(root, word, options = {}) {
 				goDeeper = false;
 				const { i: i$1, w: w$1, m } = ht;
 				if (i$1 >= history.length) continue;
-				const r$1 = history[i$1];
-				if (r$1.word.slice(0, w$1.length) !== w$1) continue;
+				if (history[i$1].word.slice(0, w$1.length) !== w$1) continue;
 				const dc = mxMin - m;
 				for (let p = i$1; p < history.length; ++p) {
 					const { word: word$1, cost: hCost } = history[p];
-					const fix = word$1.slice(0, w$1.length);
-					if (fix !== w$1) break;
+					if (word$1.slice(0, w$1.length) !== w$1) break;
 					const cost$1 = hCost + dc;
-					if (cost$1 <= costLimit) {
-						const suffix = word$1.slice(w$1.length);
-						const emit = text + suffix;
-						updateCostLimit(yield {
-							word: emit,
-							cost: cost$1
-						});
-					}
+					if (cost$1 <= costLimit) updateCostLimit(yield {
+						word: text + word$1.slice(w$1.length),
+						cost: cost$1
+					});
 				}
 				continue;
 			} else historyTags.set(tag, {
@@ -8844,7 +8680,6 @@ function* genCompoundableSuggestions(root, word, options = {}) {
 		} else updateCostLimit(yield void 0);
 		goDeeper = min <= costLimit;
 	}
-	return void 0;
 }
 
 //#endregion
@@ -8896,10 +8731,7 @@ var Trie = class Trie {
 	}
 	has(word, minLegacyCompoundLength) {
 		if (this.hasWord(word, false)) return true;
-		if (minLegacyCompoundLength) {
-			const f = this.findWord(word, { useLegacyWordCompounds: minLegacyCompoundLength });
-			return !!f.found;
-		}
+		if (minLegacyCompoundLength) return !!this.findWord(word, { useLegacyWordCompounds: minLegacyCompoundLength }).found;
 		return false;
 	}
 	/**
@@ -9010,11 +8842,10 @@ var Trie = class Trie {
 		return new Trie(root, void 0);
 	}
 	createFindOptions(options = {}) {
-		const findOptions = createFindOptions({
+		return createFindOptions({
 			...this._findOptionsDefaults,
 			...options
 		});
-		return findOptions;
 	}
 	lastCreateFindOptionsMatchCaseMap = /* @__PURE__ */ new Map();
 	createFindOptionsMatchCase(matchCase) {
@@ -9074,7 +8905,6 @@ var SecondChanceCache = class {
 			this.map0.set(key, v);
 			return v;
 		}
-		return void 0;
 	}
 	toArray() {
 		return [...this.map1, ...this.map0];
@@ -9098,8 +8928,7 @@ function buildTrie(words, trieOptions) {
 * @param trieOptions options for the Trie
 */
 function buildTrieFast(words, trieOptions) {
-	const root = createTrieRootFromList(words, trieOptions);
-	return new Trie(root, void 0);
+	return new Trie(createTrieRootFromList(words, trieOptions), void 0);
 }
 const MAX_NUM_SIGS = 1e5;
 const MAX_TRANSFORMS = 1e6;
@@ -9140,9 +8969,7 @@ var TrieBuilder = class {
 		const isWord = n.f ? "*" : "";
 		const entries = n.c ? Object.entries(n.c) : void 0;
 		const c = entries ? entries.map(([k, n$1]) => [k, this.cached.get(n$1)]) : void 0;
-		const ref = c ? JSON.stringify(c) : "";
-		const sig = isWord + ref;
-		return sig;
+		return isWord + (c ? JSON.stringify(c) : "");
 	}
 	_canBeCached(n) {
 		if (!n.c) return true;
@@ -9245,8 +9072,7 @@ var TrieBuilder = class {
 		const chars = [...word];
 		let d = 1;
 		for (const s of chars) {
-			const p = this.lastPath[d];
-			if (p?.s !== s) break;
+			if (this.lastPath[d]?.s !== s) break;
 			d++;
 		}
 		if (chars.length < d) d = chars.length;
@@ -9305,20 +9131,15 @@ var TrieBuilder = class {
 		return stack.map((n) => this.debNodeInfo(n));
 	}
 	debNodeInfo(node) {
-		const id = node.id ?? "?";
-		const cid = this.cached.get(node) ?? "?";
-		const f = node.f || 0;
-		const c = node.c ? Object.fromEntries(Object.entries(node.c).map(([k, n]) => [k, {
-			id: n.id,
-			r: this.cached.get(n)
-		}])) : void 0;
-		const L = Object.isFrozen(node);
 		return {
-			id,
-			cid,
-			f,
-			c,
-			L
+			id: node.id ?? "?",
+			cid: this.cached.get(node) ?? "?",
+			f: node.f || 0,
+			c: node.c ? Object.fromEntries(Object.entries(node.c).map(([k, n]) => [k, {
+				id: n.id,
+				r: this.cached.get(n)
+			}])) : void 0,
+			L: Object.isFrozen(node)
 		};
 	}
 	logDebug(methodName, contentOrFunction) {
@@ -9378,7 +9199,6 @@ const normalizeWordForCaseInsensitive = (text) => {
 
 //#endregion
 //#region src/lib/SimpleDictionaryParser.ts
-const RegExpSplit = /[\s,;]/g;
 const _defaultOptions = {
 	commentCharacter: LINE_COMMENT,
 	optionalCompoundCharacter: OPTIONAL_COMPOUND_FIX,
@@ -9391,7 +9211,7 @@ const _defaultOptions = {
 	stripCaseAndAccentsOnForbidden: false,
 	split: false,
 	splitKeepBoth: false,
-	splitSeparator: RegExpSplit,
+	splitSeparator: /[\s,;]/g,
 	keepOptionalCompoundCharacter: false
 };
 const defaultParseDictionaryOptions = Object.freeze(_defaultOptions);
@@ -9479,9 +9299,7 @@ function createDictionaryLineParserMapper(options) {
 	function* splitWords(lines) {
 		for (const line of lines) {
 			if (split) {
-				const lineEscaped = line.includes("\"") ? line.replaceAll(/".*?"/g, (quoted) => " " + quoted.replaceAll(/(\s)/g, "\\$1") + " ") : line;
-				const words = splitLine(lineEscaped, splitSeparator);
-				yield* words.map((escaped) => escaped.replaceAll("\\", ""));
+				yield* splitLine(line.includes("\"") ? line.replaceAll(/".*?"/g, (quoted) => " " + quoted.replaceAll(/(\s)/g, "\\$1") + " ") : line, splitSeparator).map((escaped) => escaped.replaceAll("\\", ""));
 				if (!splitKeepBoth) continue;
 			}
 			yield line;
@@ -9491,8 +9309,7 @@ function createDictionaryLineParserMapper(options) {
 		for (const paragraph of paragraphs) yield* paragraph.split("\n");
 	}
 	const mapCompounds = keepOptionalCompoundCharacter ? [] : [opConcatMap(mapOptionalPrefix), opConcatMap(mapOptionalSuffix)];
-	const processLines = opCombine(opFilter(isString), splitLines, opMap(removeComments), splitWords, opMap(trim), opFilter(filterEmptyLines), ...mapCompounds, opConcatMap(mapNormalize), opMap(removeDoublePrefix));
-	return processLines;
+	return opCombine(opFilter(isString), splitLines, opMap(removeComments), splitWords, opMap(trim), opFilter(filterEmptyLines), ...mapCompounds, opConcatMap(mapNormalize), opMap(removeDoublePrefix));
 }
 /**
 * Normalizes a dictionary words based upon prefix / suffixes.