@codemerge/hunspell 2.4.0

package/dist/index.mjs

@@ -0,0 +1,434 @@
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/check.ts
+/** Typographic apostrophe → ASCII (dictionary-en stems use U+0027). */
+function normalizeWord(word) {
+	return word.replaceAll("’", "'");
+}
+function flattenFlags(ruleCodes) {
+	if (ruleCodes === null || ruleCodes === void 0) return [];
+	return ruleCodes.flat();
+}
+/**
+* Whether `word` carries the named affix flag (e.g. `KEEPCASE`, `NOSUGGEST`).
+*/
+function hasFlag(state, word, flag, wordFlags) {
+	const flagValue = state.flags[flag];
+	if (flagValue === void 0) return false;
+	return (wordFlags ?? flattenFlags(state.dictionaryTable.get(word) ?? void 0)).includes(flagValue);
+}
+/**
+* Exact dictionary lookup (no capitalization folding). Also matches compound rules.
+*/
+function checkExact(state, word) {
+	if (word.length > 256) return false;
+	const ruleCodes = state.dictionaryTable.get(word);
+	if (ruleCodes === void 0) {
+		const compoundMin = state.flags.COMPOUNDMIN;
+		if (compoundMin !== void 0 && word.length >= Number(compoundMin) && word.length <= 256) {
+			for (const rule of state.compoundRules) if (rule.test(word)) return true;
+		}
+		return false;
+	}
+	if (ruleCodes === null) return true;
+	for (const codes of ruleCodes) if (!hasFlag(state, word, "ONLYINCOMPOUND", codes)) return true;
+	return false;
+}
+/**
+* Spell-check with capitalization variants (all-caps / Capitalized).
+*/
+function check(state, aWord) {
+	if (aWord.length === 0) return false;
+	const trimmedWord = normalizeWord(aWord).replace(/^\s+/, "").replace(/\s+$/, "");
+	if (checkExact(state, trimmedWord)) return true;
+	const first = trimmedWord.charAt(0);
+	if (trimmedWord.toUpperCase() === trimmedWord) {
+		const capitalizedWord = first + trimmedWord.slice(1).toLowerCase();
+		if (hasFlag(state, capitalizedWord, "KEEPCASE")) return false;
+		if (checkExact(state, capitalizedWord)) return true;
+		if (checkExact(state, trimmedWord.toLowerCase())) return true;
+	}
+	const uncapitalizedWord = first.toLowerCase() + trimmedWord.slice(1);
+	if (uncapitalizedWord !== trimmedWord) {
+		if (hasFlag(state, uncapitalizedWord, "KEEPCASE")) return false;
+		if (checkExact(state, uncapitalizedWord)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/parseRuleCodes.ts
+/**
+* Split a Hunspell flag string according to the `.aff` `FLAG` mode.
+* Default: one character per flag.
+*/
+function parseRuleCodes(textCodes, flags) {
+	if (!textCodes) return [];
+	if (!("FLAG" in flags)) return textCodes.split("");
+	if (flags.FLAG === "long") {
+		const out = [];
+		for (let i = 0; i < textCodes.length; i += 2) out.push(textCodes.slice(i, i + 2));
+		return out;
+	}
+	if (flags.FLAG === "num") return textCodes.split(",");
+	if (flags.FLAG === "UTF-8") return Array.from(textCodes);
+	return textCodes.split("");
+}
+//#endregion
+//#region src/parseAff.ts
+function removeAffixComments(line) {
+	if (/^\s*#/.test(line)) return "";
+	return line;
+}
+function tryCompileAffixRegex(source) {
+	if (source.length > 80) return;
+	try {
+		return new RegExp(source);
+	} catch {
+		return;
+	}
+}
+/**
+* Parse Hunspell `.aff` content into rules, named flags, compound patterns, and REP pairs.
+*/
+function parseAff(data) {
+	const rules = {};
+	const flags = {};
+	const compoundRulePatterns = [];
+	const replacementTable = [];
+	const lines = data.split(/\r?\n/);
+	for (let i = 0; i < lines.length; i++) {
+		let line = removeAffixComments(lines[i] ?? "").trim();
+		if (!line) continue;
+		const definitionParts = line.split(/\s+/);
+		const ruleType = definitionParts[0];
+		if (!ruleType) continue;
+		if (ruleType === "PFX" || ruleType === "SFX") {
+			const ruleCode = definitionParts[1];
+			const combineable = definitionParts[2];
+			const numEntries = Math.trunc(Number(definitionParts[3] ?? "0"));
+			if (!ruleCode || Number.isNaN(numEntries) || numEntries < 0 || numEntries > 1e4) {
+				if (!Number.isNaN(numEntries) && numEntries > 0) i += Math.min(numEntries, lines.length);
+				continue;
+			}
+			const entries = [];
+			for (let j = i + 1; j < i + 1 + numEntries; j++) {
+				const lineParts = (lines[j] ?? "").split(/\s+/);
+				const charactersToRemove = lineParts[2] ?? "0";
+				const additionParts = (lineParts[3] ?? "0").split("/");
+				let charactersToAdd = additionParts[0] ?? "";
+				if (charactersToAdd === "0") charactersToAdd = "";
+				const continuationClasses = parseRuleCodes(additionParts[1], flags);
+				const regexToMatch = lineParts[4] ?? ".";
+				const entry = { add: charactersToAdd };
+				if (continuationClasses.length > 0) entry.continuationClasses = continuationClasses;
+				if (regexToMatch !== ".") {
+					const match = ruleType === "SFX" ? tryCompileAffixRegex(`${regexToMatch}$`) : tryCompileAffixRegex(`^${regexToMatch}`);
+					if (match === void 0) continue;
+					entry.match = match;
+				}
+				if (charactersToRemove !== "0") {
+					if (ruleType === "SFX") {
+						const remove = tryCompileAffixRegex(`${charactersToRemove}$`);
+						if (remove === void 0) continue;
+						entry.remove = remove;
+					} else if (charactersToRemove.length <= 80) entry.remove = charactersToRemove;
+					else continue;
+				}
+				entries.push(entry);
+			}
+			rules[ruleCode] = {
+				type: ruleType,
+				combineable: combineable === "Y",
+				entries
+			};
+			i += numEntries;
+		} else if (ruleType === "COMPOUNDRULE") {
+			const numEntries = Math.trunc(Number(definitionParts[1] ?? "0"));
+			if (Number.isNaN(numEntries) || numEntries < 0 || numEntries > 1e4) {
+				if (!Number.isNaN(numEntries) && numEntries > 0) i += Math.min(numEntries, lines.length);
+				continue;
+			}
+			for (let j = i + 1; j < i + 1 + numEntries; j++) {
+				const pattern = (lines[j] ?? "").split(/\s+/)[1];
+				if (pattern) compoundRulePatterns.push(pattern);
+			}
+			i += numEntries;
+		} else if (ruleType === "REP") {
+			const from = definitionParts[1];
+			const to = definitionParts[2];
+			if (from !== void 0 && to !== void 0 && definitionParts.length === 3) replacementTable.push([from, to]);
+		} else {
+			const value = definitionParts[1];
+			if (value !== void 0) flags[ruleType] = value;
+		}
+	}
+	return {
+		rules,
+		flags,
+		compoundRulePatterns,
+		replacementTable
+	};
+}
+//#endregion
+//#region src/applyRule.ts
+/**
+* Apply one affix rule (and any continuation classes) to a stem.
+*/
+function applyRule(word, rule, rules, depth = 0) {
+	const newWords = [];
+	if (depth > 12) return newWords;
+	for (const entry of rule.entries) {
+		if (entry.match !== void 0 && !entry.match.test(word)) continue;
+		let newWord = word;
+		if (entry.remove !== void 0) newWord = newWord.replace(entry.remove, "");
+		newWord = rule.type === "SFX" ? newWord + entry.add : entry.add + newWord;
+		newWords.push(newWord);
+		const cont = entry.continuationClasses;
+		if (cont === void 0) continue;
+		for (const code of cont) {
+			const continuationRule = rules[code];
+			if (continuationRule !== void 0) newWords.push(...applyRule(newWord, continuationRule, rules, depth + 1));
+		}
+	}
+	return newWords;
+}
+//#endregion
+//#region src/parseDic.ts
+function removeDicComments(data) {
+	return data.replace(/^\t.*$/gm, "");
+}
+/**
+* Parse Hunspell `.dic` content into a word→flags lookup table.
+* Also expands affix forms into the table (Typo.js approach).
+*/
+function parseDic(data, options) {
+	const { rules, flags, compoundRuleCodes } = options;
+	const lines = removeDicComments(data).split(/\r?\n/);
+	const dictionaryTable = /* @__PURE__ */ new Map();
+	function addWord(word, ruleCodes) {
+		if (!dictionaryTable.has(word)) dictionaryTable.set(word, null);
+		if (ruleCodes.length === 0) return;
+		if (dictionaryTable.get(word) === null) dictionaryTable.set(word, []);
+		const existing = dictionaryTable.get(word);
+		if (Array.isArray(existing)) existing.push(ruleCodes);
+	}
+	for (let i = 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (line === void 0 || line.length === 0) continue;
+		const parts = line.replace(/\s.*$/, "").split("/", 2);
+		const word = parts[0] ?? "";
+		if (word.length === 0) continue;
+		if (parts.length > 1) {
+			const ruleCodesArray = parseRuleCodes(parts[1], flags);
+			const needAffix = flags.NEEDAFFIX;
+			if (needAffix === void 0 || !ruleCodesArray.includes(needAffix)) addWord(word, ruleCodesArray);
+			for (let j = 0; j < ruleCodesArray.length; j++) {
+				const code = ruleCodesArray[j];
+				if (code === void 0) continue;
+				const rule = rules[code];
+				if (rule !== void 0) {
+					const newWords = applyRule(word, rule, rules);
+					for (const newWord of newWords) {
+						addWord(newWord, []);
+						if (rule.combineable) for (let k = j + 1; k < ruleCodesArray.length; k++) {
+							const combineCode = ruleCodesArray[k];
+							if (combineCode === void 0) continue;
+							const combineRule = rules[combineCode];
+							if (combineRule !== void 0 && combineRule.combineable && rule.type !== combineRule.type) for (const other of applyRule(newWord, combineRule, rules)) addWord(other, []);
+						}
+					}
+				}
+				const compoundStems = compoundRuleCodes[code];
+				if (compoundStems !== void 0) compoundStems.push(word);
+			}
+		} else addWord(word.trim(), []);
+	}
+	return dictionaryTable;
+}
+//#endregion
+//#region src/suggest.ts
+function ensureAlphabet(state) {
+	if (state.alphabet.length > 0) return state.alphabet;
+	const LATIN_FALLBACK = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	let alphabet = "";
+	if (state.flags.TRY !== void 0 && state.flags.TRY.length > 0) alphabet = state.flags.TRY;
+	else alphabet = LATIN_FALLBACK;
+	if (state.flags.WORDCHARS !== void 0) alphabet += state.flags.WORDCHARS;
+	const seen = /* @__PURE__ */ new Set();
+	let unique = "";
+	for (const ch of alphabet) if (!seen.has(ch)) {
+		seen.add(ch);
+		unique += ch;
+	}
+	state.alphabet = unique;
+	return unique;
+}
+function edits1(state, words, knownOnly) {
+	const alphabet = ensureAlphabet(state);
+	const rv = {};
+	const bump = (edit) => {
+		if (knownOnly && !check(state, edit)) return;
+		rv[edit] = (rv[edit] ?? 0) + 1;
+	};
+	for (const word of Object.keys(words)) for (let i = 0; i <= word.length; i++) {
+		const left = word.slice(0, i);
+		const right = word.slice(i);
+		if (right.length > 0) bump(left + right.slice(1));
+		const right0 = right[0];
+		const right1 = right[1];
+		if (right.length > 1 && right1 !== void 0 && right0 !== void 0 && right1 !== right0) bump(left + right1 + right0 + right.slice(2));
+		if (right.length > 0) {
+			const lettercase = right.slice(0, 1).toUpperCase() === right.slice(0, 1) ? "uppercase" : "lowercase";
+			for (const ch of alphabet) {
+				let replacementLetter = ch;
+				if (lettercase === "uppercase") replacementLetter = replacementLetter.toUpperCase();
+				if (replacementLetter !== right.slice(0, 1)) bump(left + replacementLetter + right.slice(1));
+			}
+		}
+		if (right.length > 0) {
+			const leftTail = left.slice(-1);
+			const rightHead = right.slice(0, 1);
+			const lettercase = leftTail.toUpperCase() === leftTail && rightHead.toUpperCase() === rightHead ? "uppercase" : "lowercase";
+			for (const ch of alphabet) {
+				let replacementLetter = ch;
+				if (lettercase === "uppercase") replacementLetter = replacementLetter.toUpperCase();
+				bump(left + replacementLetter + right);
+			}
+		}
+	}
+	return rv;
+}
+function rankCorrections(state, word, limit) {
+	const tier1 = edits1(state, { [word]: true }, true);
+	let weighted = tier1;
+	if (Object.keys(tier1).length === 0) {
+		const ed1 = edits1(state, { [word]: true }, false);
+		const unknownSeeds = {};
+		let seedCount = 0;
+		const MAX_ED2_SEEDS = 64;
+		for (const [candidate, weight] of Object.entries(ed1)) {
+			if (check(state, candidate)) {
+				weighted[candidate] = (weighted[candidate] ?? 0) + weight;
+				continue;
+			}
+			if (seedCount >= MAX_ED2_SEEDS) continue;
+			unknownSeeds[candidate] = weight;
+			seedCount += 1;
+		}
+		if (Object.keys(unknownSeeds).length > 0) {
+			const ed2 = edits1(state, unknownSeeds, true);
+			for (const [candidate, weight] of Object.entries(ed2)) weighted[candidate] = (weighted[candidate] ?? 0) + weight;
+		}
+	}
+	const sorted = [];
+	for (const [candidate, weight] of Object.entries(weighted)) {
+		let w = weight;
+		if (hasFlag(state, candidate, "PRIORITYSUGGEST")) w += 1e3;
+		sorted.push([candidate, w]);
+	}
+	sorted.sort((a, b) => {
+		if (a[1] !== b[1]) return b[1] - a[1];
+		return a[0].localeCompare(b[0]);
+	});
+	let capitalizationScheme = "lowercase";
+	if (word.toUpperCase() === word) capitalizationScheme = "uppercase";
+	else if (word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase() === word) capitalizationScheme = "capitalized";
+	const rv = [];
+	let workingLimit = limit;
+	for (let i = 0; i < Math.min(workingLimit, sorted.length); i++) {
+		const entry = sorted[i];
+		if (entry === void 0) break;
+		let suggestion = entry[0];
+		if (capitalizationScheme === "uppercase") suggestion = suggestion.toUpperCase();
+		else if (capitalizationScheme === "capitalized") suggestion = suggestion.slice(0, 1).toUpperCase() + suggestion.slice(1);
+		if (!hasFlag(state, suggestion, "NOSUGGEST") && !rv.includes(suggestion)) rv.push(suggestion);
+		else workingLimit++;
+	}
+	return rv;
+}
+/**
+* Suggest corrections for a misspelling (REP table + edit-distance ranking).
+*/
+function suggest(state, word, limit = 5) {
+	if (word.length === 0 || word.length > 64) return [];
+	const normalized = word.replaceAll("’", "'");
+	const memo = state.memoized[normalized];
+	if (memo !== void 0 && (limit <= memo.limit || memo.suggestions.length < memo.limit)) return memo.suggestions.slice(0, limit);
+	if (check(state, normalized)) return [];
+	for (const [from, to] of state.replacementTable) if (normalized.includes(from)) {
+		const corrected = normalized.replace(from, to);
+		if (check(state, corrected)) {
+			const suggestions = [corrected];
+			remember(state, normalized, suggestions, limit);
+			return suggestions;
+		}
+	}
+	const suggestions = rankCorrections(state, normalized, limit);
+	remember(state, normalized, suggestions, limit);
+	return suggestions;
+}
+function remember(state, word, suggestions, limit) {
+	const keys = Object.keys(state.memoized);
+	if (keys.length >= 512) {
+		const drop = keys[0];
+		if (drop !== void 0) delete state.memoized[drop];
+	}
+	state.memoized[word] = {
+		suggestions,
+		limit
+	};
+}
+//#endregion
+//#region src/dictionary.ts
+function buildCompoundRegexes(patterns, compoundRuleCodes) {
+	const out = [];
+	for (const ruleText of patterns) {
+		let expressionText = "";
+		for (const character of ruleText) if (Object.hasOwn(compoundRuleCodes, character)) {
+			const stems = compoundRuleCodes[character] ?? [];
+			expressionText += `(${stems.map(escapeRegExp).join("|")})`;
+		} else expressionText += character;
+		if (expressionText.length > 4096) continue;
+		try {
+			out.push(new RegExp(`^${expressionText}$`, "i"));
+		} catch {}
+	}
+	return out;
+}
+/**
+* Build a Hunspell dictionary from raw `.aff` and `.dic` file contents.
+* Dictionaries are not bundled — callers fetch/load the files.
+*/
+function createDictionary(affData, dicData) {
+	if (affData.length > 8388608 || dicData.length > 8388608) throw new Error("dictionary too large");
+	const { rules, flags, compoundRulePatterns, replacementTable } = parseAff(affData);
+	const compoundRuleCodes = {};
+	for (const pattern of compoundRulePatterns) for (const ch of pattern) compoundRuleCodes[ch] = [];
+	if (flags.ONLYINCOMPOUND !== void 0) compoundRuleCodes[flags.ONLYINCOMPOUND] = [];
+	const dictionaryTable = parseDic(dicData, {
+		rules,
+		flags,
+		compoundRuleCodes
+	});
+	for (const code of Object.keys(compoundRuleCodes)) if ((compoundRuleCodes[code] ?? []).length === 0) delete compoundRuleCodes[code];
+	const state = {
+		dictionaryTable,
+		compoundRules: buildCompoundRegexes(compoundRulePatterns, compoundRuleCodes),
+		replacementTable,
+		flags,
+		memoized: {},
+		alphabet: ""
+	};
+	return {
+		loaded: true,
+		check: (word) => check(state, word),
+		checkExact: (word) => checkExact(state, word),
+		suggest: (word, limit) => suggest(state, word, limit)
+	};
+}
+//#endregion
+export { createDictionary };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/limits.ts","../src/check.ts","../src/parseRuleCodes.ts","../src/parseAff.ts","../src/applyRule.ts","../src/parseDic.ts","../src/suggest.ts","../src/dictionary.ts"],"sourcesContent":["/** Resource bounds for untrusted / oversized Hunspell inputs. */\n\nexport const MAX_AFF_BYTES = 8_388_608;\nexport const MAX_DIC_BYTES = 8_388_608;\nexport const MAX_AFFIX_ENTRIES = 10_000;\nexport const MAX_APPLY_RULE_DEPTH = 12;\nexport const MAX_COMPOUND_REGEX_SOURCE = 4096;\nexport const MAX_AFFIX_PATTERN_LEN = 80;\nexport const MAX_CHECK_WORD_LEN = 256;\nexport const MAX_SUGGEST_WORD_LEN = 64;\nexport const MAX_SUGGEST_MEMO = 512;\n\nexport function escapeRegExp(text: string): string {\n  return text.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n","import { MAX_CHECK_WORD_LEN } from './limits';\nimport type { HunspellState } from './types';\n\n/** Typographic apostrophe → ASCII (dictionary-en stems use U+0027). */\nfunction normalizeWord(word: string): string {\n  return word.replaceAll('\\u2019', \"'\");\n}\n\nfunction flattenFlags(ruleCodes: string[][] | null | undefined): string[] {\n  if (ruleCodes === null || ruleCodes === undefined) {\n    return [];\n  }\n  return ruleCodes.flat();\n}\n\n/**\n * Whether `word` carries the named affix flag (e.g. `KEEPCASE`, `NOSUGGEST`).\n */\nexport function hasFlag(\n  state: HunspellState,\n  word: string,\n  flag: string,\n  wordFlags?: string[]\n): boolean {\n  const flagValue = state.flags[flag];\n  if (flagValue === undefined) {\n    return false;\n  }\n  const codes = wordFlags ?? flattenFlags(state.dictionaryTable.get(word) ?? undefined);\n  return codes.includes(flagValue);\n}\n\n/**\n * Exact dictionary lookup (no capitalization folding). Also matches compound rules.\n */\nexport function checkExact(state: HunspellState, word: string): boolean {\n  if (word.length > MAX_CHECK_WORD_LEN) {\n    return false;\n  }\n\n  const ruleCodes = state.dictionaryTable.get(word);\n\n  if (ruleCodes === undefined) {\n    const compoundMin = state.flags.COMPOUNDMIN;\n    if (\n      compoundMin !== undefined &&\n      word.length >= Number(compoundMin) &&\n      word.length <= MAX_CHECK_WORD_LEN\n    ) {\n      for (const rule of state.compoundRules) {\n        if (rule.test(word)) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  if (ruleCodes === null) {\n    return true;\n  }\n\n  for (const codes of ruleCodes) {\n    if (!hasFlag(state, word, 'ONLYINCOMPOUND', codes)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Spell-check with capitalization variants (all-caps / Capitalized).\n */\nexport function check(state: HunspellState, aWord: string): boolean {\n  if (aWord.length === 0) {\n    return false;\n  }\n\n  const trimmedWord = normalizeWord(aWord).replace(/^\\s+/, '').replace(/\\s+$/, '');\n  if (checkExact(state, trimmedWord)) {\n    return true;\n  }\n\n  const first = trimmedWord.charAt(0);\n  if (trimmedWord.toUpperCase() === trimmedWord) {\n    const capitalizedWord = first + trimmedWord.slice(1).toLowerCase();\n    if (hasFlag(state, capitalizedWord, 'KEEPCASE')) {\n      return false;\n    }\n    if (checkExact(state, capitalizedWord)) {\n      return true;\n    }\n    if (checkExact(state, trimmedWord.toLowerCase())) {\n      return true;\n    }\n  }\n\n  const uncapitalizedWord = first.toLowerCase() + trimmedWord.slice(1);\n  if (uncapitalizedWord !== trimmedWord) {\n    if (hasFlag(state, uncapitalizedWord, 'KEEPCASE')) {\n      return false;\n    }\n    if (checkExact(state, uncapitalizedWord)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n","import type { AffFlags } from './types';\n\n/**\n * Split a Hunspell flag string according to the `.aff` `FLAG` mode.\n * Default: one character per flag.\n */\nexport function parseRuleCodes(textCodes: string | undefined, flags: AffFlags): string[] {\n  if (!textCodes) {\n    return [];\n  }\n  if (!('FLAG' in flags)) {\n    return textCodes.split('');\n  }\n  if (flags.FLAG === 'long') {\n    const out: string[] = [];\n    for (let i = 0; i < textCodes.length; i += 2) {\n      out.push(textCodes.slice(i, i + 2));\n    }\n    return out;\n  }\n  if (flags.FLAG === 'num') {\n    return textCodes.split(',');\n  }\n  if (flags.FLAG === 'UTF-8') {\n    return Array.from(textCodes);\n  }\n  return textCodes.split('');\n}\n","import type { AffFlags, AffixEntry, AffixRules, ReplacementPair } from './types';\nimport { MAX_AFFIX_ENTRIES, MAX_AFFIX_PATTERN_LEN } from './limits';\nimport { parseRuleCodes } from './parseRuleCodes';\n\nexport type AffParseResult = {\n  rules: AffixRules;\n  flags: AffFlags;\n  /** Raw COMPOUNDRULE pattern strings (not yet RegExp). */\n  compoundRulePatterns: string[];\n  replacementTable: ReplacementPair[];\n};\n\nfunction removeAffixComments(line: string): string {\n  // Only strip full-line comments — COMPOUNDRULE may use `#` as a flag char.\n  if (/^\\s*#/.test(line)) {\n    return '';\n  }\n  return line;\n}\n\nfunction tryCompileAffixRegex(source: string): RegExp | undefined {\n  if (source.length > MAX_AFFIX_PATTERN_LEN) {\n    return undefined;\n  }\n  try {\n    return new RegExp(source);\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Parse Hunspell `.aff` content into rules, named flags, compound patterns, and REP pairs.\n */\nexport function parseAff(data: string): AffParseResult {\n  const rules: AffixRules = {};\n  const flags: AffFlags = {};\n  const compoundRulePatterns: string[] = [];\n  const replacementTable: ReplacementPair[] = [];\n\n  const lines = data.split(/\\r?\\n/);\n\n  for (let i = 0; i < lines.length; i++) {\n    let line = removeAffixComments(lines[i] ?? '').trim();\n    if (!line) {\n      continue;\n    }\n\n    const definitionParts = line.split(/\\s+/);\n    const ruleType = definitionParts[0];\n    if (!ruleType) {\n      continue;\n    }\n\n    if (ruleType === 'PFX' || ruleType === 'SFX') {\n      const ruleCode = definitionParts[1];\n      const combineable = definitionParts[2];\n      const numEntries = Math.trunc(Number(definitionParts[3] ?? '0'));\n      if (\n        !ruleCode ||\n        Number.isNaN(numEntries) ||\n        numEntries < 0 ||\n        numEntries > MAX_AFFIX_ENTRIES\n      ) {\n        if (!Number.isNaN(numEntries) && numEntries > 0) {\n          i += Math.min(numEntries, lines.length);\n        }\n        continue;\n      }\n\n      const entries: AffixEntry[] = [];\n      for (let j = i + 1; j < i + 1 + numEntries; j++) {\n        const subline = lines[j] ?? '';\n        const lineParts = subline.split(/\\s+/);\n        const charactersToRemove = lineParts[2] ?? '0';\n        const additionParts = (lineParts[3] ?? '0').split('/');\n        let charactersToAdd = additionParts[0] ?? '';\n        if (charactersToAdd === '0') {\n          charactersToAdd = '';\n        }\n        const continuationClasses = parseRuleCodes(additionParts[1], flags);\n        const regexToMatch = lineParts[4] ?? '.';\n\n        const entry: AffixEntry = { add: charactersToAdd };\n        if (continuationClasses.length > 0) {\n          entry.continuationClasses = continuationClasses;\n        }\n        if (regexToMatch !== '.') {\n          const match =\n            ruleType === 'SFX'\n              ? tryCompileAffixRegex(`${regexToMatch}$`)\n              : tryCompileAffixRegex(`^${regexToMatch}`);\n          if (match === undefined) {\n            continue;\n          }\n          entry.match = match;\n        }\n        if (charactersToRemove !== '0') {\n          if (ruleType === 'SFX') {\n            const remove = tryCompileAffixRegex(`${charactersToRemove}$`);\n            if (remove === undefined) {\n              continue;\n            }\n            entry.remove = remove;\n          } else if (charactersToRemove.length <= MAX_AFFIX_PATTERN_LEN) {\n            entry.remove = charactersToRemove;\n          } else {\n            continue;\n          }\n        }\n        entries.push(entry);\n      }\n\n      rules[ruleCode] = {\n        type: ruleType,\n        combineable: combineable === 'Y',\n        entries,\n      };\n      i += numEntries;\n    } else if (ruleType === 'COMPOUNDRULE') {\n      const numEntries = Math.trunc(Number(definitionParts[1] ?? '0'));\n      if (Number.isNaN(numEntries) || numEntries < 0 || numEntries > MAX_AFFIX_ENTRIES) {\n        if (!Number.isNaN(numEntries) && numEntries > 0) {\n          i += Math.min(numEntries, lines.length);\n        }\n        continue;\n      }\n      for (let j = i + 1; j < i + 1 + numEntries; j++) {\n        const parts = (lines[j] ?? '').split(/\\s+/);\n        const pattern = parts[1];\n        if (pattern) {\n          compoundRulePatterns.push(pattern);\n        }\n      }\n      i += numEntries;\n    } else if (ruleType === 'REP') {\n      const from = definitionParts[1];\n      const to = definitionParts[2];\n      if (from !== undefined && to !== undefined && definitionParts.length === 3) {\n        replacementTable.push([from, to]);\n      }\n    } else {\n      // ONLYINCOMPOUND, COMPOUNDMIN, FLAG, KEEPCASE, NEEDAFFIX, TRY, WORDCHARS, NOSUGGEST, …\n      const value = definitionParts[1];\n      if (value !== undefined) {\n        flags[ruleType] = value;\n      }\n    }\n  }\n\n  return { rules, flags, compoundRulePatterns, replacementTable };\n}\n","import { MAX_APPLY_RULE_DEPTH } from './limits';\nimport type { AffixRule, AffixRules } from './types';\n\n/**\n * Apply one affix rule (and any continuation classes) to a stem.\n */\nexport function applyRule(word: string, rule: AffixRule, rules: AffixRules, depth = 0): string[] {\n  const newWords: string[] = [];\n  if (depth > MAX_APPLY_RULE_DEPTH) {\n    return newWords;\n  }\n\n  for (const entry of rule.entries) {\n    if (entry.match !== undefined && !entry.match.test(word)) {\n      continue;\n    }\n\n    let newWord = word;\n    if (entry.remove !== undefined) {\n      newWord = newWord.replace(entry.remove, '');\n    }\n    newWord = rule.type === 'SFX' ? newWord + entry.add : entry.add + newWord;\n    newWords.push(newWord);\n\n    const cont = entry.continuationClasses;\n    if (cont === undefined) {\n      continue;\n    }\n    for (const code of cont) {\n      const continuationRule = rules[code];\n      if (continuationRule !== undefined) {\n        newWords.push(...applyRule(newWord, continuationRule, rules, depth + 1));\n      }\n    }\n  }\n\n  return newWords;\n}\n","import { applyRule } from './applyRule';\nimport { parseRuleCodes } from './parseRuleCodes';\nimport type { AffFlags, AffixRules, DictionaryTable } from './types';\n\nfunction removeDicComments(data: string): string {\n  // de_DE and some others use tab-indented comment lines.\n  return data.replace(/^\\t.*$/gm, '');\n}\n\nexport type ParseDicOptions = {\n  rules: AffixRules;\n  flags: AffFlags;\n  /** Mutated: flag code → stems that carry that compound flag. */\n  compoundRuleCodes: Record<string, string[]>;\n};\n\n/**\n * Parse Hunspell `.dic` content into a word→flags lookup table.\n * Also expands affix forms into the table (Typo.js approach).\n */\nexport function parseDic(data: string, options: ParseDicOptions): DictionaryTable {\n  const { rules, flags, compoundRuleCodes } = options;\n  const cleaned = removeDicComments(data);\n  const lines = cleaned.split(/\\r?\\n/);\n  const dictionaryTable: DictionaryTable = new Map();\n\n  function addWord(word: string, ruleCodes: string[]): void {\n    if (!dictionaryTable.has(word)) {\n      dictionaryTable.set(word, null);\n    }\n    if (ruleCodes.length === 0) {\n      return;\n    }\n    if (dictionaryTable.get(word) === null) {\n      dictionaryTable.set(word, []);\n    }\n    const existing = dictionaryTable.get(word);\n    if (Array.isArray(existing)) {\n      existing.push(ruleCodes);\n    }\n  }\n\n  // First line is the word count — skip it.\n  for (let i = 1; i < lines.length; i++) {\n    const line = lines[i];\n    if (line === undefined || line.length === 0) {\n      continue;\n    }\n\n    // Drop morphological fields (`xx:abc`); keep `word` or `word/flags`.\n    const justWordAndFlags = line.replace(/\\s.*$/, '');\n    const parts = justWordAndFlags.split('/', 2);\n    const word = parts[0] ?? '';\n    if (word.length === 0) {\n      continue;\n    }\n\n    if (parts.length > 1) {\n      const ruleCodesArray = parseRuleCodes(parts[1], flags);\n      const needAffix = flags.NEEDAFFIX;\n      if (needAffix === undefined || !ruleCodesArray.includes(needAffix)) {\n        addWord(word, ruleCodesArray);\n      }\n\n      for (let j = 0; j < ruleCodesArray.length; j++) {\n        const code = ruleCodesArray[j];\n        if (code === undefined) {\n          continue;\n        }\n        const rule = rules[code];\n        if (rule !== undefined) {\n          const newWords = applyRule(word, rule, rules);\n          for (const newWord of newWords) {\n            addWord(newWord, []);\n            if (rule.combineable) {\n              for (let k = j + 1; k < ruleCodesArray.length; k++) {\n                const combineCode = ruleCodesArray[k];\n                if (combineCode === undefined) {\n                  continue;\n                }\n                const combineRule = rules[combineCode];\n                if (\n                  combineRule !== undefined &&\n                  combineRule.combineable &&\n                  rule.type !== combineRule.type\n                ) {\n                  for (const other of applyRule(newWord, combineRule, rules)) {\n                    addWord(other, []);\n                  }\n                }\n              }\n            }\n          }\n        }\n        const compoundStems = compoundRuleCodes[code];\n        if (compoundStems !== undefined) {\n          compoundStems.push(word);\n        }\n      }\n    } else {\n      addWord(word.trim(), []);\n    }\n  }\n\n  return dictionaryTable;\n}\n","import { check, hasFlag } from './check';\nimport { MAX_SUGGEST_MEMO, MAX_SUGGEST_WORD_LEN } from './limits';\nimport type { HunspellState } from './types';\n\nfunction ensureAlphabet(state: HunspellState): string {\n  if (state.alphabet.length > 0) {\n    return state.alphabet;\n  }\n\n  // Hunspell: suggestion edits come from TRY (+ WORDCHARS). Latin fallback is only\n  // for incomplete .aff files — do not force English letters onto every locale.\n  const LATIN_FALLBACK = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\n  let alphabet = '';\n  if (state.flags.TRY !== undefined && state.flags.TRY.length > 0) {\n    alphabet = state.flags.TRY;\n  } else {\n    alphabet = LATIN_FALLBACK;\n  }\n  if (state.flags.WORDCHARS !== undefined) {\n    alphabet += state.flags.WORDCHARS;\n  }\n\n  const seen = new Set<string>();\n  let unique = '';\n  for (const ch of alphabet) {\n    if (!seen.has(ch)) {\n      seen.add(ch);\n      unique += ch;\n    }\n  }\n  state.alphabet = unique;\n  return unique;\n}\n\ntype EditCounts = Record<string, number>;\n\nfunction edits1(\n  state: HunspellState,\n  words: Record<string, true | number>,\n  knownOnly: boolean\n): EditCounts {\n  const alphabet = ensureAlphabet(state);\n  const rv: EditCounts = {};\n\n  const bump = (edit: string): void => {\n    if (knownOnly && !check(state, edit)) {\n      return;\n    }\n    rv[edit] = (rv[edit] ?? 0) + 1;\n  };\n\n  for (const word of Object.keys(words)) {\n    for (let i = 0; i <= word.length; i++) {\n      const left = word.slice(0, i);\n      const right = word.slice(i);\n\n      if (right.length > 0) {\n        bump(left + right.slice(1));\n      }\n\n      const right0 = right[0];\n      const right1 = right[1];\n      if (right.length > 1 && right1 !== undefined && right0 !== undefined && right1 !== right0) {\n        bump(left + right1 + right0 + right.slice(2));\n      }\n\n      if (right.length > 0) {\n        const lettercase =\n          right.slice(0, 1).toUpperCase() === right.slice(0, 1) ? 'uppercase' : 'lowercase';\n        for (const ch of alphabet) {\n          let replacementLetter = ch;\n          if (lettercase === 'uppercase') {\n            replacementLetter = replacementLetter.toUpperCase();\n          }\n          if (replacementLetter !== right.slice(0, 1)) {\n            bump(left + replacementLetter + right.slice(1));\n          }\n        }\n      }\n\n      if (right.length > 0) {\n        // Capitalize insert when both neighbors are uppercase.\n        const leftTail = left.slice(-1);\n        const rightHead = right.slice(0, 1);\n        const lettercase =\n          leftTail.toUpperCase() === leftTail && rightHead.toUpperCase() === rightHead\n            ? 'uppercase'\n            : 'lowercase';\n        for (const ch of alphabet) {\n          let replacementLetter = ch;\n          if (lettercase === 'uppercase') {\n            replacementLetter = replacementLetter.toUpperCase();\n          }\n          bump(left + replacementLetter + right);\n        }\n      }\n    }\n  }\n\n  return rv;\n}\n\nfunction rankCorrections(state: HunspellState, word: string, limit: number): string[] {\n  // Norvig tier-1: known edit-distance-1 first (fast path for near-misses).\n  const tier1 = edits1(state, { [word]: true }, true);\n  let weighted: EditCounts = tier1;\n\n  if (Object.keys(tier1).length === 0) {\n    // Tier-2: expand unknown ed1 seeds, then keep only known ed2 forms.\n    const ed1 = edits1(state, { [word]: true }, false);\n    const unknownSeeds: Record<string, true | number> = {};\n    let seedCount = 0;\n    const MAX_ED2_SEEDS = 64;\n    for (const [candidate, weight] of Object.entries(ed1)) {\n      if (check(state, candidate)) {\n        weighted[candidate] = (weighted[candidate] ?? 0) + weight;\n        continue;\n      }\n      if (seedCount >= MAX_ED2_SEEDS) {\n        continue;\n      }\n      unknownSeeds[candidate] = weight;\n      seedCount += 1;\n    }\n    if (Object.keys(unknownSeeds).length > 0) {\n      const ed2 = edits1(state, unknownSeeds, true);\n      for (const [candidate, weight] of Object.entries(ed2)) {\n        weighted[candidate] = (weighted[candidate] ?? 0) + weight;\n      }\n    }\n  }\n\n  const sorted: Array<[string, number]> = [];\n  for (const [candidate, weight] of Object.entries(weighted)) {\n    let w = weight;\n    if (hasFlag(state, candidate, 'PRIORITYSUGGEST')) {\n      w += 1000;\n    }\n    sorted.push([candidate, w]);\n  }\n\n  sorted.sort((a, b) => {\n    if (a[1] !== b[1]) {\n      return b[1] - a[1];\n    }\n    return a[0].localeCompare(b[0]);\n  });\n\n  let capitalizationScheme: 'lowercase' | 'uppercase' | 'capitalized' = 'lowercase';\n  if (word.toUpperCase() === word) {\n    capitalizationScheme = 'uppercase';\n  } else if (word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase() === word) {\n    capitalizationScheme = 'capitalized';\n  }\n\n  const rv: string[] = [];\n  let workingLimit = limit;\n  for (let i = 0; i < Math.min(workingLimit, sorted.length); i++) {\n    const entry = sorted[i];\n    if (entry === undefined) {\n      break;\n    }\n    let suggestion = entry[0];\n    if (capitalizationScheme === 'uppercase') {\n      suggestion = suggestion.toUpperCase();\n    } else if (capitalizationScheme === 'capitalized') {\n      suggestion = suggestion.slice(0, 1).toUpperCase() + suggestion.slice(1);\n    }\n    if (!hasFlag(state, suggestion, 'NOSUGGEST') && !rv.includes(suggestion)) {\n      rv.push(suggestion);\n    } else {\n      workingLimit++;\n    }\n  }\n  return rv;\n}\n\n/**\n * Suggest corrections for a misspelling (REP table + edit-distance ranking).\n */\nexport function suggest(state: HunspellState, word: string, limit = 5): string[] {\n  if (word.length === 0 || word.length > MAX_SUGGEST_WORD_LEN) {\n    return [];\n  }\n\n  const normalized = word.replaceAll('\\u2019', \"'\");\n  const memo = state.memoized[normalized];\n  if (memo !== undefined && (limit <= memo.limit || memo.suggestions.length < memo.limit)) {\n    return memo.suggestions.slice(0, limit);\n  }\n\n  if (check(state, normalized)) {\n    return [];\n  }\n\n  for (const [from, to] of state.replacementTable) {\n    if (normalized.includes(from)) {\n      const corrected = normalized.replace(from, to);\n      if (check(state, corrected)) {\n        const suggestions = [corrected];\n        remember(state, normalized, suggestions, limit);\n        return suggestions;\n      }\n    }\n  }\n\n  const suggestions = rankCorrections(state, normalized, limit);\n  remember(state, normalized, suggestions, limit);\n  return suggestions;\n}\n\nfunction remember(state: HunspellState, word: string, suggestions: string[], limit: number): void {\n  const keys = Object.keys(state.memoized);\n  if (keys.length >= MAX_SUGGEST_MEMO) {\n    const drop = keys[0];\n    if (drop !== undefined) {\n      delete state.memoized[drop];\n    }\n  }\n  state.memoized[word] = { suggestions, limit };\n}\n","import { check, checkExact } from './check';\nimport { escapeRegExp, MAX_AFF_BYTES, MAX_COMPOUND_REGEX_SOURCE, MAX_DIC_BYTES } from './limits';\nimport { parseAff } from './parseAff';\nimport { parseDic } from './parseDic';\nimport { suggest } from './suggest';\nimport type { HunspellDictionary, HunspellState } from './types';\n\nfunction buildCompoundRegexes(\n  patterns: string[],\n  compoundRuleCodes: Record<string, string[]>\n): RegExp[] {\n  const out: RegExp[] = [];\n  for (const ruleText of patterns) {\n    let expressionText = '';\n    for (const character of ruleText) {\n      if (Object.hasOwn(compoundRuleCodes, character)) {\n        const stems = compoundRuleCodes[character] ?? [];\n        expressionText += `(${stems.map(escapeRegExp).join('|')})`;\n      } else {\n        // Hunspell COMPOUNDRULE operators (e.g. `*` in `n*1t`) must stay unescaped.\n        expressionText += character;\n      }\n    }\n    if (expressionText.length > MAX_COMPOUND_REGEX_SOURCE) {\n      continue;\n    }\n    try {\n      out.push(new RegExp(`^${expressionText}$`, 'i'));\n    } catch {\n      // Malformed pattern after escaping — skip this compound rule.\n    }\n  }\n  return out;\n}\n\n/**\n * Build a Hunspell dictionary from raw `.aff` and `.dic` file contents.\n * Dictionaries are not bundled — callers fetch/load the files.\n */\nexport function createDictionary(affData: string, dicData: string): HunspellDictionary {\n  if (affData.length > MAX_AFF_BYTES || dicData.length > MAX_DIC_BYTES) {\n    throw new Error('dictionary too large');\n  }\n\n  const { rules, flags, compoundRulePatterns, replacementTable } = parseAff(affData);\n\n  const compoundRuleCodes: Record<string, string[]> = {};\n  for (const pattern of compoundRulePatterns) {\n    for (const ch of pattern) {\n      compoundRuleCodes[ch] = [];\n    }\n  }\n  if (flags.ONLYINCOMPOUND !== undefined) {\n    compoundRuleCodes[flags.ONLYINCOMPOUND] = [];\n  }\n\n  const dictionaryTable = parseDic(dicData, { rules, flags, compoundRuleCodes });\n\n  for (const code of Object.keys(compoundRuleCodes)) {\n    if ((compoundRuleCodes[code] ?? []).length === 0) {\n      delete compoundRuleCodes[code];\n    }\n  }\n\n  const compoundRules = buildCompoundRegexes(compoundRulePatterns, compoundRuleCodes);\n\n  const state: HunspellState = {\n    dictionaryTable,\n    compoundRules,\n    replacementTable,\n    flags,\n    memoized: {},\n    alphabet: '',\n  };\n\n  return {\n    loaded: true,\n    check: (word: string) => check(state, word),\n    checkExact: (word: string) => checkExact(state, word),\n    suggest: (word: string, limit?: number) => suggest(state, word, limit),\n  };\n}\n"],"mappings":"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"}

package/dist/limits.d.cts

@@ -0,0 +1,12 @@
+/** Resource bounds for untrusted / oversized Hunspell inputs. */
+export declare const MAX_AFF_BYTES = 8388608;
+export declare const MAX_DIC_BYTES = 8388608;
+export declare const MAX_AFFIX_ENTRIES = 10000;
+export declare const MAX_APPLY_RULE_DEPTH = 12;
+export declare const MAX_COMPOUND_REGEX_SOURCE = 4096;
+export declare const MAX_AFFIX_PATTERN_LEN = 80;
+export declare const MAX_CHECK_WORD_LEN = 256;
+export declare const MAX_SUGGEST_WORD_LEN = 64;
+export declare const MAX_SUGGEST_MEMO = 512;
+export declare function escapeRegExp(text: string): string;
+//# sourceMappingURL=limits.d.ts.map

package/dist/limits.d.ts

@@ -0,0 +1,12 @@
+/** Resource bounds for untrusted / oversized Hunspell inputs. */
+export declare const MAX_AFF_BYTES = 8388608;
+export declare const MAX_DIC_BYTES = 8388608;
+export declare const MAX_AFFIX_ENTRIES = 10000;
+export declare const MAX_APPLY_RULE_DEPTH = 12;
+export declare const MAX_COMPOUND_REGEX_SOURCE = 4096;
+export declare const MAX_AFFIX_PATTERN_LEN = 80;
+export declare const MAX_CHECK_WORD_LEN = 256;
+export declare const MAX_SUGGEST_WORD_LEN = 64;
+export declare const MAX_SUGGEST_MEMO = 512;
+export declare function escapeRegExp(text: string): string;
+//# sourceMappingURL=limits.d.ts.map

package/dist/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../src/limits.ts"],"names":[],"mappings":"AAAA,iEAAiE;AAEjE,eAAO,MAAM,aAAa,UAAY,CAAC;AACvC,eAAO,MAAM,aAAa,UAAY,CAAC;AACvC,eAAO,MAAM,iBAAiB,QAAS,CAAC;AACxC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAC9C,eAAO,MAAM,qBAAqB,KAAK,CAAC;AACxC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AACtC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AACvC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD"}

package/dist/parseAff.d.cts

@@ -0,0 +1,13 @@
+import { AffFlags, AffixRules, ReplacementPair } from './types';
+export type AffParseResult = {
+    rules: AffixRules;
+    flags: AffFlags;
+    /** Raw COMPOUNDRULE pattern strings (not yet RegExp). */
+    compoundRulePatterns: string[];
+    replacementTable: ReplacementPair[];
+};
+/**
+ * Parse Hunspell `.aff` content into rules, named flags, compound patterns, and REP pairs.
+ */
+export declare function parseAff(data: string): AffParseResult;
+//# sourceMappingURL=parseAff.d.ts.map

package/dist/parseAff.d.ts

@@ -0,0 +1,13 @@
+import { AffFlags, AffixRules, ReplacementPair } from './types';
+export type AffParseResult = {
+    rules: AffixRules;
+    flags: AffFlags;
+    /** Raw COMPOUNDRULE pattern strings (not yet RegExp). */
+    compoundRulePatterns: string[];
+    replacementTable: ReplacementPair[];
+};
+/**
+ * Parse Hunspell `.aff` content into rules, named flags, compound patterns, and REP pairs.
+ */
+export declare function parseAff(data: string): AffParseResult;
+//# sourceMappingURL=parseAff.d.ts.map

package/dist/parseAff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseAff.d.ts","sourceRoot":"","sources":["../src/parseAff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAc,UAAU,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAIjF,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,QAAQ,CAAC;IAChB,yDAAyD;IACzD,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,gBAAgB,EAAE,eAAe,EAAE,CAAC;CACrC,CAAC;AAqBF;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAqHrD"}

package/dist/parseDic.d.cts

@@ -0,0 +1,13 @@
+import { AffFlags, AffixRules, DictionaryTable } from './types';
+export type ParseDicOptions = {
+    rules: AffixRules;
+    flags: AffFlags;
+    /** Mutated: flag code → stems that carry that compound flag. */
+    compoundRuleCodes: Record<string, string[]>;
+};
+/**
+ * Parse Hunspell `.dic` content into a word→flags lookup table.
+ * Also expands affix forms into the table (Typo.js approach).
+ */
+export declare function parseDic(data: string, options: ParseDicOptions): DictionaryTable;
+//# sourceMappingURL=parseDic.d.ts.map

package/dist/parseDic.d.ts

@@ -0,0 +1,13 @@
+import { AffFlags, AffixRules, DictionaryTable } from './types';
+export type ParseDicOptions = {
+    rules: AffixRules;
+    flags: AffFlags;
+    /** Mutated: flag code → stems that carry that compound flag. */
+    compoundRuleCodes: Record<string, string[]>;
+};
+/**
+ * Parse Hunspell `.dic` content into a word→flags lookup table.
+ * Also expands affix forms into the table (Typo.js approach).
+ */
+export declare function parseDic(data: string, options: ParseDicOptions): DictionaryTable;
+//# sourceMappingURL=parseDic.d.ts.map

package/dist/parseDic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseDic.d.ts","sourceRoot":"","sources":["../src/parseDic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAOrE,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,QAAQ,CAAC;IAChB,gEAAgE;IAChE,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC7C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,eAAe,CAqFhF"}

package/dist/parseRuleCodes.d.cts

@@ -0,0 +1,7 @@
+import { AffFlags } from './types';
+/**
+ * Split a Hunspell flag string according to the `.aff` `FLAG` mode.
+ * Default: one character per flag.
+ */
+export declare function parseRuleCodes(textCodes: string | undefined, flags: AffFlags): string[];
+//# sourceMappingURL=parseRuleCodes.d.ts.map

package/dist/parseRuleCodes.d.ts

@@ -0,0 +1,7 @@
+import { AffFlags } from './types';
+/**
+ * Split a Hunspell flag string according to the `.aff` `FLAG` mode.
+ * Default: one character per flag.
+ */
+export declare function parseRuleCodes(textCodes: string | undefined, flags: AffFlags): string[];
+//# sourceMappingURL=parseRuleCodes.d.ts.map

package/dist/parseRuleCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseRuleCodes.d.ts","sourceRoot":"","sources":["../src/parseRuleCodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,EAAE,CAqBvF"}

package/dist/suggest.d.cts

@@ -0,0 +1,6 @@
+import { HunspellState } from './types';
+/**
+ * Suggest corrections for a misspelling (REP table + edit-distance ranking).
+ */
+export declare function suggest(state: HunspellState, word: string, limit?: number): string[];
+//# sourceMappingURL=suggest.d.ts.map

package/dist/suggest.d.ts

@@ -0,0 +1,6 @@
+import { HunspellState } from './types';
+/**
+ * Suggest corrections for a misspelling (REP table + edit-distance ranking).
+ */
+export declare function suggest(state: HunspellState, word: string, limit?: number): string[];
+//# sourceMappingURL=suggest.d.ts.map

package/dist/suggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest.d.ts","sourceRoot":"","sources":["../src/suggest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AA+K7C;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,MAAM,EAAE,CA6B/E"}