@cspell/cspell-tools 10.4.0-alpha.1 → 10.4.0

package/cspell-tools.config.schema.json

@@ -270,6 +270,11 @@
           "markdownDescription": "If `compress` is true, setting this value to true will also keep an uncompressed version of the dictionary.",
           "type": "boolean"
         },
+        "locale": {
+          "description": "The locale of the dictionary's words: a language and an optional region, such as `tr` or `tr-TR`. Words are lower-cased with this locale's case rules, for example, when generating the case insensitive forms with `generateNonStrict`. Without it, the default case rules are used.\n\nSet `dictionaryInformation.locale` in the dictionary definition to the same locale, so cspell searches the dictionary with the case rules it was built with. If the definition lists more than one locale, cspell uses the first valid one for case rules, so put this locale first.",
+          "markdownDescription": "The locale of the dictionary's words: a language and an optional region, such as `tr` or `tr-TR`.\nWords are lower-cased with this locale's case rules, for example, when generating the case insensitive\nforms with `generateNonStrict`. Without it, the default case rules are used.\n\nSet `dictionaryInformation.locale` in the dictionary definition to the same locale, so cspell searches the\ndictionary with the case rules it was built with. If the definition lists more than one locale, cspell uses the\nfirst valid one for case rules, so put this locale first.",
+          "type": "string"
+        },
         "name": {
           "description": "Name of target, used as the basis of target file name.",
           "markdownDescription": "Name of target, used as the basis of target file name.",
@@ -370,6 +375,11 @@
       "markdownDescription": "Do not generate lower case / accent free versions of words.",
       "type": "boolean"
     },
+    "locale": {
+      "description": "The locale of the dictionary's words: a language and an optional region, such as `tr` or `tr-TR`. Words are lower-cased with this locale's case rules, for example, when generating the case insensitive forms with `generateNonStrict`. Without it, the default case rules are used.\n\nSet `dictionaryInformation.locale` in the dictionary definition to the same locale, so cspell searches the dictionary with the case rules it was built with. If the definition lists more than one locale, cspell uses the first valid one for case rules, so put this locale first.",
+      "markdownDescription": "The locale of the dictionary's words: a language and an optional region, such as `tr` or `tr-TR`.\nWords are lower-cased with this locale's case rules, for example, when generating the case insensitive\nforms with `generateNonStrict`. Without it, the default case rules are used.\n\nSet `dictionaryInformation.locale` in the dictionary definition to the same locale, so cspell searches the\ndictionary with the case rules it was built with. If the definition lists more than one locale, cspell uses the\nfirst valid one for case rules, so put this locale first.",
+      "type": "string"
+    },
     "maxDepth": {
       "description": "Maximum number of nested Hunspell Rules to apply. This is needed for recursive dictionaries like Hebrew.",
       "markdownDescription": "Maximum number of nested Hunspell Rules to apply.\nThis is needed for recursive dictionaries like Hebrew.",

package/dist/app.d.mts

@@ -28,7 +28,7 @@ declare class FeatureFlags {
 }
 //#endregion
 //#region src/app.d.ts
-declare function run(program: Command, argv: string[], flags?: FeatureFlags): Promise<void>;
+export declare function run(program: Command, argv: string[], flags?: FeatureFlags): Promise<void>;
 //#endregion
-export { run };
+export {};
 //# sourceMappingURL=app.d.mts.map

package/dist/app.mjs

@@ -1,4 +1,4 @@
-import { a as reportCheckChecksumFile, c as toError, i as logWithTimestamp, l as generateBTrie, n as compile, o as reportChecksumForFiles, r as setLogger, s as updateChecksumForFiles, t as build, u as compressFile } from "./build-Fod7lDHd.mjs";
+import { a as reportCheckChecksumFile, c as toError, i as logWithTimestamp, l as generateBTrie, n as compile, o as reportChecksumForFiles, r as setLogger, s as updateChecksumForFiles, t as build, u as compressFile } from "./build-DitWkAJE.mjs";
 import { readFileSync } from "node:fs";
 import { CommanderError, Option } from "commander";
 import { writeFile } from "node:fs/promises";

package/dist/{build-Fod7lDHd.mjs → build-DitWkAJE.mjs}

@@ -550,6 +550,29 @@ function removeVerboseFromRegExp(pattern) {
 	return result.result;
 }
 //#endregion
+//#region src/compiler/text.ts
+const regExSplitWords = /([\p{Ll}])([\p{Lu}])/gu;
+const regExSplitWords2 = /(\p{Lu})(\p{Lu}\p{Ll})/gu;
+const regExpIsLetter = /^\p{L}\p{M}{0,2}$/u;
+/**
+* Split camelCase words into an array of strings.
+*/
+function splitCamelCaseWord(word) {
+	return word.replaceAll(regExSplitWords, "$1|$2").replaceAll(regExSplitWords2, "$1|$2").replaceAll(/[\d_]+/g, "|").split("|").filter((a) => !!a);
+}
+/**
+* Lower-case a word.
+* @param word - the word to lower-case.
+* @param locale - the locale whose case rules are used. Default rules are used if not given.
+* @returns the lower-case word.
+*/
+function lowerCase(word, locale) {
+	return locale ? word.toLocaleLowerCase(locale) : word.toLowerCase();
+}
+function isSingleLetter(c) {
+	return regExpIsLetter.test(c);
+}
+//#endregion
 //#region src/compiler/WordsCollection.ts
 const defaultAllowedSplitWords = Object.freeze({
 	size: 0,
@@ -572,15 +595,15 @@ var AllowedSplitWordsImpl = class {
 		return !this.size || this.collection.has(word, caseSensitive);
 	}
 };
-async function createAllowedSplitWordsFromFiles(files) {
+async function createAllowedSplitWordsFromFiles(files, locale) {
 	if (!files || !files.length) return defaultAllowedSplitWords;
-	return new AllowedSplitWordsImpl(await createWordsCollectionFromFiles(files));
+	return new AllowedSplitWordsImpl(await createWordsCollectionFromFiles(files, locale));
 }
-function buildHasFn(dict) {
+function buildHasFn(dict, locale) {
 	function has(word, caseSensitive) {
 		const r = dict.hasWord(word, true);
 		if (r || caseSensitive) return r;
-		const lc = word.toLowerCase();
+		const lc = lowerCase(word, locale);
 		if (lc === word) return false;
 		return dict.hasWord(lc, true);
 	}
@@ -589,9 +612,9 @@ function buildHasFn(dict) {
 async function readFile$1(filename) {
 	return await createReader(filename, {});
 }
-function readersToCollection(readers) {
-	const dictReaders = readers.filter(isDictionaryReader).map(dictReaderToCollection);
-	const nonDictCollection = lineReadersToCollection(readers.filter((a) => !isDictionaryReader(a)));
+function readersToCollection(readers, locale) {
+	const dictReaders = readers.filter(isDictionaryReader).map((reader) => dictReaderToCollection(reader, locale));
+	const nonDictCollection = lineReadersToCollection(readers.filter((a) => !isDictionaryReader(a)), locale);
 	const collections = [...dictReaders, nonDictCollection];
 	return {
 		size: collections.reduce((s, a) => s + a.size, 0),
@@ -599,35 +622,49 @@ function readersToCollection(readers) {
 	};
 }
 const cache = /* @__PURE__ */ new WeakMap();
-async function createWordsCollectionFromFiles(files) {
+const filePaths = /* @__PURE__ */ new Map();
+function createWordsCollectionFromFiles(files, locale) {
 	files = toFilePathArray(files);
-	const cached = cache.get(files);
+	let byLocale = cache.get(files);
+	if (!byLocale) {
+		byLocale = /* @__PURE__ */ new Map();
+		cache.set(files, byLocale);
+	}
+	const cached = byLocale.get(locale);
 	if (cached) return cached;
-	const collection = readersToCollection(await Promise.all(files.map((file) => readFile$1(file))));
-	cache.set(files, collection);
+	const collection = _createWordsCollectionFromFiles(files, locale);
+	byLocale.set(locale, collection);
 	return collection;
 }
+async function _createWordsCollectionFromFiles(files, locale) {
+	return readersToCollection(await Promise.all(files.map((file) => readFile$1(file))), locale);
+}
 function isDictionaryReader(reader) {
 	return "hasWord" in reader && !!reader.hasWord;
 }
-function dictReaderToCollection(reader) {
+function dictReaderToCollection(reader, locale) {
 	return {
 		size: reader.size,
-		has: buildHasFn(reader)
+		has: buildHasFn(reader, locale)
 	};
 }
-function lineReadersToCollection(readers) {
+function lineReadersToCollection(readers, locale) {
 	function* words() {
 		for (const reader of readers) yield* reader.lines;
 	}
 	const dict = parseDictionary(words(), { stripCaseAndAccents: false });
 	return {
 		size: dict.size,
-		has: buildHasFn(dict)
+		has: buildHasFn(dict, locale)
 	};
 }
 function toFilePathArray(filePathOrArray) {
-	return Array.isArray(filePathOrArray) ? filePathOrArray : [filePathOrArray];
+	if (Array.isArray(filePathOrArray)) return filePathOrArray;
+	const found = filePaths.get(filePathOrArray);
+	if (found) return found;
+	const paths = [filePathOrArray];
+	filePaths.set(filePathOrArray, paths);
+	return paths;
 }
 //#endregion
 //#region src/compiler/logWithTimestamp.ts
@@ -645,48 +682,34 @@ const defaultCompileSourceOptions = {
 	minCompoundLength: 4
 };
 //#endregion
-//#region src/compiler/text.ts
-const regExSplitWords = /([\p{Ll}])([\p{Lu}])/gu;
-const regExSplitWords2 = /(\p{Lu})(\p{Lu}\p{Ll})/gu;
-const regExpIsLetter = /^\p{L}\p{M}{0,2}$/u;
-/**
-* Split camelCase words into an array of strings.
-*/
-function splitCamelCaseWord(word) {
-	return word.replaceAll(regExSplitWords, "$1|$2").replaceAll(regExSplitWords2, "$1|$2").replaceAll(/[\d_]+/g, "|").split("|").filter((a) => !!a);
-}
-function isSingleLetter(c) {
-	return regExpIsLetter.test(c);
-}
-//#endregion
 //#region src/compiler/splitCamelCaseIfAllowed.ts
 const regExpSpaceOrDash = /[- ]+/g;
 const regExpIsNumber = /^\d+$/;
-function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, minCompoundLength) {
+function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, minCompoundLength, locale) {
 	const split = [...splitCamelCase(word)];
-	if (split.length === 1) return adjustCases(split, allowedWords, keepCase);
+	if (split.length === 1) return adjustCases(split, allowedWords, keepCase, locale);
 	if (split.some((w) => isUnknown(w, allowedWords))) return [word];
 	const wordIndexes = calcWordIndex(word, split);
-	const adjusted = adjustCases(split, allowedWords, keepCase);
+	const adjusted = adjustCases(split, allowedWords, keepCase, locale);
 	return !compoundPrefix ? adjusted : adjusted.map((w, i) => {
 		const { px, sx } = wordIndexes[i];
 		const canCompound = w.length >= minCompoundLength;
-		const lc = w.toLowerCase();
+		const lc = lowerCase(w, locale);
 		const p = canCompound && isSingleLetter(px) ? compoundPrefix : "";
 		const s = canCompound && isSingleLetter(sx) ? compoundPrefix : "";
 		if (lc.length < 4 || allowedWords.has(w, true)) return p + w + s;
 		return p + lc + s;
 	});
 }
-function adjustCases(words, allowedWords, keepCase) {
-	return words.map((w) => adjustCase(w, allowedWords, keepCase));
+function adjustCases(words, allowedWords, keepCase, locale) {
+	return words.map((w) => adjustCase(w, allowedWords, keepCase, locale));
 }
-function adjustCase(word, allowedWords, keepCase) {
-	const lc = word.toLowerCase();
+function adjustCase(word, allowedWords, keepCase, locale) {
+	const lc = lowerCase(word, locale);
 	if (!allowedWords.has(lc, true)) return word;
 	if (lc === word) return word;
 	if (word.slice(1).toLowerCase() === word.slice(1)) return lc;
-	if (!keepCase && word.toUpperCase() === word) return word.toLowerCase();
+	if (!keepCase && word.toUpperCase() === word) return lc;
 	return word;
 }
 function isUnknown(word, allowedWords) {
@@ -718,16 +741,17 @@ function calcWordIndex(word, words) {
 const regNonWord = /[^\p{L}\p{M}' _\d]+/giu;
 const regExpRepeatChars = /(.)\1{5}/i;
 const minCompoundLength = defaultCompileSourceOptions.minCompoundLength;
-function legacyLineToWords(line, keepCase, allowedSplitWords) {
+function legacyLineToWords(line, keepCase, allowedSplitWords, locale) {
 	const wordGroups = line.replaceAll(regNonWord, "|").split("|");
 	const _minCompoundLength = minCompoundLength;
-	return pipe(wordGroups, opConcatMap((a) => a.split(regExpSpaceOrDash)), opConcatMap((a) => splitCamelCaseIfAllowed(a, allowedSplitWords, keepCase, "", _minCompoundLength)), opMap((a) => a.trim()), opFilter((a) => !!a), opFilter((s) => !regExpRepeatChars.test(s)));
+	return pipe(wordGroups, opConcatMap((a) => a.split(regExpSpaceOrDash)), opConcatMap((a) => splitCamelCaseIfAllowed(a, allowedSplitWords, keepCase, "", _minCompoundLength, locale)), opMap((a) => a.trim()), opFilter((a) => !!a), opFilter((s) => !regExpRepeatChars.test(s)));
 }
 //#endregion
 //#region src/compiler/wordListParser.ts
 function normalizeTargetWords(options) {
 	const lineParser = createDictionaryLineParser({
 		stripCaseAndAccents: options.generateNonStrict,
+		locale: options.locale,
 		stripCaseAndAccentsOnForbidden: true,
 		keepOptionalCompoundCharacter: true
 	});
@@ -771,7 +795,8 @@ const _defaultOptions = {
 		size: 0
 	},
 	storeSplitWordsAsCompounds: defaultCompileSourceOptions.storeSplitWordsAsCompounds,
-	minCompoundLength: defaultCompileSourceOptions.minCompoundLength
+	minCompoundLength: defaultCompileSourceOptions.minCompoundLength,
+	locale: void 0
 };
 Object.freeze(_defaultOptions);
 const cSpellToolDirective = "cspell-tools:";
@@ -783,7 +808,7 @@ const cSpellToolDirective = "cspell-tools:";
 */
 function createParseFileLineMapper(options) {
 	const _options = options || _defaultOptions;
-	const { splitKeepBoth = _defaultOptions.splitKeepBoth, allowedSplitWords = _defaultOptions.allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength = _defaultOptions.minCompoundLength } = _options;
+	const { splitKeepBoth = _defaultOptions.splitKeepBoth, allowedSplitWords = _defaultOptions.allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength = _defaultOptions.minCompoundLength, locale } = _options;
 	let { legacy = _defaultOptions.legacy } = _options;
 	let { split = _defaultOptions.split, keepCase = legacy ? false : _defaultOptions.keepCase } = _options;
 	const compoundFix = storeSplitWordsAsCompounds ? "+" : "";
@@ -841,12 +866,12 @@ function createParseFileLineMapper(options) {
 		return line.split("|").map((a) => a.trim()).filter((a) => !!a).filter((a) => !/^[0-9_-]+$/.test(a)).filter((a) => !/^0[xo][0-9A-F]+$/i.test(a));
 	}
 	function splitWordIntoWords(word) {
-		return splitCamelCaseIfAllowed(word, allowedSplitWords, keepCase, compoundFix, minCompoundLength);
+		return splitCamelCaseIfAllowed(word, allowedSplitWords, keepCase, compoundFix, minCompoundLength, locale);
 	}
 	function* splitWords(lines) {
 		for (const line of lines) {
 			if (legacy) {
-				yield* legacyLineToWords(line, keepCase, allowedSplitWords);
+				yield* legacyLineToWords(line, keepCase, allowedSplitWords, locale);
 				continue;
 			}
 			if (split) {
@@ -911,7 +936,7 @@ function splitLines(lines, options) {
 	return split();
 }
 async function textFileReader(reader, options) {
-	const { legacy, splitWords: split, allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength } = options;
+	const { legacy, splitWords: split, allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength, locale } = options;
 	const parseOptions = {
 		legacy,
 		split,
@@ -919,7 +944,8 @@ async function textFileReader(reader, options) {
 		keepCase: void 0,
 		allowedSplitWords,
 		storeSplitWordsAsCompounds,
-		minCompoundLength
+		minCompoundLength,
+		locale
 	};
 	const words = [...parseFileLines(reader.lines, parseOptions)];
 	return {
@@ -974,7 +1000,7 @@ function createWordListCompiler(options) {
 }
 function normalize(lines, options) {
 	const filter = normalizeTargetWords(options);
-	const cleanLines = options.removeDuplicates ? removeDuplicates(lines) : lines;
+	const cleanLines = options.removeDuplicates ? removeDuplicates(lines, options.locale) : lines;
 	const iter = pipe(cleanLines, filter);
 	if (!options.sort) return iter;
 	return [...new Set(iter)].sort();
@@ -982,11 +1008,11 @@ function normalize(lines, options) {
 function stripCompoundAFix(word) {
 	return word.replaceAll("*", "").replaceAll("+", "");
 }
-function* removeDuplicates(words) {
+function* removeDuplicates(words, locale) {
 	const wordSet = new Set(words);
 	const wordForms = /* @__PURE__ */ new Map();
 	for (const word of wordSet) {
-		const lc = stripCompoundAFix(word.toLowerCase());
+		const lc = stripCompoundAFix(lowerCase(word, locale));
 		const forms = wordForms.get(lc) ?? [];
 		forms.push(word);
 		wordForms.set(lc, forms);
@@ -1001,7 +1027,7 @@ function* removeDuplicates(words) {
 			for (const form of mForms.values()) yield* form;
 			continue;
 		}
-		const lc = [...mForms.keys()][0].toLowerCase();
+		const lc = lowerCase([...mForms.keys()][0], locale);
 		const lcForm = mForms.get(lc);
 		if (!lcForm) {
 			for (const form of mForms.values()) yield* form;
@@ -1012,7 +1038,7 @@ function* removeDuplicates(words) {
 		yield* lcForm;
 		if (sLcForms.has("*" + lc + "*")) continue;
 		for (const forms of mForms.values()) for (const form of forms) {
-			if (sLcForms.has(form.toLowerCase())) continue;
+			if (sLcForms.has(lowerCase(form, locale))) continue;
 			yield form;
 		}
 	}
@@ -1093,6 +1119,7 @@ async function compile(request, options) {
 	const targetOptions = {
 		sort: request.sort,
 		generateNonStrict: request.generateNonStrict,
+		locale: request.locale,
 		removeDuplicates: request.removeDuplicates,
 		replacements: void 0
 	};
@@ -1157,18 +1184,20 @@ async function buildTargetDictionary(target, options, compileOptions, buildOptio
 	const { filename, useTrie, generateOnlyCompressedDictionary, checksumRoot } = buildOptions;
 	const dictionaryDirectives = target.dictionaryDirectives ?? compileOptions.dictionaryDirectives;
 	const removeDuplicates = target.removeDuplicates ?? false;
-	const excludeFromFilter = await createExcludeFilter(excludeWordsFrom);
-	const includeFromFilter = await createIncludeFilter(excludeWordsNotFoundIn);
+	const locale = canonicalLocale(target);
+	const excludeFromFilter = await createExcludeFilter(excludeWordsFrom, locale);
+	const includeFromFilter = await createIncludeFilter(excludeWordsNotFoundIn, locale);
 	const excludeRegexFilter = createExcludeRegexFilter(excludeWordsMatchingRegex);
 	const excludeFilter = (word) => {
 		return excludeFromFilter(word) && includeFromFilter(word) && excludeRegexFilter(word);
 	};
 	const compress = generateOnlyCompressedDictionary;
-	const filesToProcessAsync = pipeAsync(readSourceList(sources, rootDir), opMapAsync((src) => readFileSource(src, options)), opAwaitAsync());
+	const filesToProcessAsync = pipeAsync(readSourceList(sources, rootDir), opMapAsync((src) => readFileSource(src, options, locale)), opAwaitAsync());
 	const filesToProcess = await toArray(filesToProcessAsync);
 	const normalizer = normalizeTargetWords({
 		sort: useTrie || sort,
 		generateNonStrict,
+		locale,
 		filter: excludeFilter,
 		dictionaryDirectives,
 		replacements
@@ -1188,6 +1217,7 @@ async function buildTargetDictionary(target, options, compileOptions, buildOptio
 		}) : createWordListCompiler({
 			sort,
 			generateNonStrict,
+			locale,
 			dictionaryDirectives,
 			removeDuplicates,
 			replacements
@@ -1284,7 +1314,7 @@ function readSourceList(sources, rootDir) {
 async function readFileList(fileList) {
 	return (await readTextFile(fileList)).split("\n").map((a) => a.trim()).filter((a) => !!a);
 }
-async function readFileSource(fileSource, sourceOptions) {
+async function readFileSource(fileSource, sourceOptions, locale) {
 	const { filename, keepRawCase = sourceOptions.keepRawCase || false, split = sourceOptions.split || false, maxDepth, storeSplitWordsAsCompounds, minCompoundLength } = fileSource;
 	const legacy = split === "legacy";
 	const readerOptions = {
@@ -1292,9 +1322,10 @@ async function readFileSource(fileSource, sourceOptions) {
 		legacy,
 		splitWords: legacy ? false : split,
 		keepCase: keepRawCase,
-		allowedSplitWords: await createAllowedSplitWordsFromFiles(fileSource.allowedSplitWords || sourceOptions.allowedSplitWords),
+		allowedSplitWords: await createAllowedSplitWordsFromFiles(fileSource.allowedSplitWords || sourceOptions.allowedSplitWords, locale),
 		storeSplitWordsAsCompounds,
-		minCompoundLength
+		minCompoundLength,
+		locale
 	};
 	logWithTimestamp(`Reading ${path.basename(filename)}`);
 	const stream = await streamSourceWordsFromFile(filename, readerOptions);
@@ -1304,6 +1335,19 @@ async function readFileSource(fileSource, sourceOptions) {
 		words: stream
 	};
 }
+const regExpLocale = /^([a-z]{2})(?:[-_]([a-z]{2}))?$/i;
+/**
+* @returns the target's locale in its canonical form, such as `tr-TR` for `tr_tr`.
+* @throws if the locale isn't a language and an optional region.
+*/
+function canonicalLocale(target) {
+	const { locale } = target;
+	if (locale === void 0) return void 0;
+	const m = regExpLocale.exec(locale);
+	if (!m) throw new Error(`Invalid locale "${locale}" in target "${target.name}". Use a language and an optional region, such as "tr" or "tr-TR".`);
+	const [, language, region] = m;
+	return region ? `${language.toLowerCase()}-${region.toUpperCase()}` : language.toLowerCase();
+}
 function normalizeTargetName(name) {
 	return name.replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, "").replaceAll(/[^\p{L}\p{M}.\w\\/-]/gu, "_");
 }
@@ -1321,20 +1365,22 @@ function logProgress(freq = 1e5) {
 }
 /**
 * @param excludeWordsFrom - List of files to read words from.
+* @param locale - the locale used to lower-case words when matching them.
 * @returns a function that returns true if the word is not in the exclude list.
 */
-async function createExcludeFilter(excludeWordsFrom) {
+async function createExcludeFilter(excludeWordsFrom, locale) {
 	if (!excludeWordsFrom || !excludeWordsFrom.length) return () => true;
-	const excludeWords = await createWordsCollectionFromFiles(excludeWordsFrom);
+	const excludeWords = await createWordsCollectionFromFiles(excludeWordsFrom, locale);
 	return (word) => !excludeWords.has(word, word.toUpperCase() !== word);
 }
 /**
 * @param includeWordsFrom - List of files to read words from.
+* @param locale - the locale used to lower-case words when matching them.
 * @returns a function that returns true if the word is in the include list.
 */
-async function createIncludeFilter(includeWordsFrom) {
+async function createIncludeFilter(includeWordsFrom, locale) {
 	if (!includeWordsFrom || !includeWordsFrom.length) return () => true;
-	const excludeWords = await createWordsCollectionFromFiles(includeWordsFrom);
+	const excludeWords = await createWordsCollectionFromFiles(includeWordsFrom, locale);
 	return (word) => excludeWords.has(word, word.toUpperCase() !== word);
 }
 /**
@@ -1399,4 +1445,4 @@ function normalizeRequest(buildInfo, root) {
 //#endregion
 export { reportCheckChecksumFile as a, toError as c, logWithTimestamp as i, generateBTrie as l, compile as n, reportChecksumForFiles as o, setLogger as r, updateChecksumForFiles as s, build as t, compressFile as u };
 
-//# sourceMappingURL=build-Fod7lDHd.mjs.map
+//# sourceMappingURL=build-DitWkAJE.mjs.map

package/dist/index.d.mts

@@ -19,7 +19,7 @@ interface GenerateBTrieOptions extends BTrieOptions {
 }
 //#endregion
 //#region src/bTrie.d.ts
-declare function generateBTrie(files: string[], options: GenerateBTrieOptions): Promise<void>;
+export declare function generateBTrie(files: string[], options: GenerateBTrieOptions): Promise<void>;
 //#endregion
 //#region src/build.d.ts
 interface BuildOptions {
@@ -32,7 +32,7 @@ interface BuildOptions {
   /** Conditional build based upon the targets matching the `checksum.txt` file. */
   conditional?: boolean;
 }
-declare function build(targets: string[] | undefined, options: BuildOptions): Promise<void>;
+export declare function build(targets: string[] | undefined, options: BuildOptions): Promise<void>;
 //#endregion
-export { build, generateBTrie };
+export {};
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,2 +1 @@
-import { l as generateBTrie, t as build } from "./build-Fod7lDHd.mjs";
-export { build, generateBTrie };
+export { t as build, l as generateBTrie } from "./build-DitWkAJE.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspell/cspell-tools",
-  "version": "10.4.0-alpha.1",
+  "version": "10.4.0",
   "description": "Tools to assist with the development of cSpell",
   "publishConfig": {
     "access": "public",
@@ -65,12 +65,12 @@
     "watch": "tsdown -w"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "10.4.0-alpha.1",
+    "@cspell/cspell-pipe": "10.4.0",
     "commander": "^15.0.0",
     "cosmiconfig": "10.0.1",
-    "cspell-trie-lib": "10.4.0-alpha.1",
+    "cspell-trie-lib": "10.4.0",
     "glob": "^13.0.6",
-    "hunspell-reader": "10.4.0-alpha.1",
+    "hunspell-reader": "10.4.0",
     "yaml": "^2.9.1"
   },
   "devDependencies": {
@@ -80,5 +80,5 @@
   "engines": {
     "node": ">=22.18.0"
   },
-  "gitHead": "628768a6e62b792e628189b41e63e12e5d3d8fe3"
+  "gitHead": "7e2bbb5e866c827ac5d2cf6b84bf3e1a016d0823"
 }