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

package/cspell-tools.config.schema.json

@@ -53,12 +53,6 @@
           "description": "Words in the `allowedSplitWords` are considered correct and can be used as a basis for splitting compound words.\n\nIf entries can be split so that all the words in the entry are allowed, then only the individual words are added, otherwise the entire entry is added. This is to prevent misspellings in CamelCase words from being introduced into the dictionary.",
           "markdownDescription": "Words in the `allowedSplitWords` are considered correct and can be used\nas a basis for splitting compound words.\n\nIf entries can be split so that all the words in the entry are allowed,\nthen only the individual words are added, otherwise the entire entry is added.\nThis is to prevent misspellings in CamelCase words from being introduced into the\ndictionary."
         },
-        "keepRawCase": {
-          "default": false,
-          "description": "Do not generate lower case / accent free versions of words.",
-          "markdownDescription": "Do not generate lower case / accent free versions of words.",
-          "type": "boolean"
-        },
         "listFile": {
           "$ref": "#/definitions/FilePath"
         },
@@ -128,12 +122,6 @@
         "filename": {
           "$ref": "#/definitions/FilePath"
         },
-        "keepRawCase": {
-          "default": false,
-          "description": "Do not generate lower case / accent free versions of words.",
-          "markdownDescription": "Do not generate lower case / accent free versions of words.",
-          "type": "boolean"
-        },
         "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.",
@@ -189,21 +177,6 @@
     "Target": {
       "additionalProperties": false,
       "properties": {
-        "allowedSplitWords": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/FilePath"
-            },
-            {
-              "items": {
-                "$ref": "#/definitions/FilePath"
-              },
-              "type": "array"
-            }
-          ],
-          "description": "Words in the `allowedSplitWords` are considered correct and can be used as a basis for splitting compound words.\n\nIf entries can be split so that all the words in the entry are allowed, then only the individual words are added, otherwise the entire entry is added. This is to prevent misspellings in CamelCase words from being introduced into the dictionary.",
-          "markdownDescription": "Words in the `allowedSplitWords` are considered correct and can be used\nas a basis for splitting compound words.\n\nIf entries can be split so that all the words in the entry are allowed,\nthen only the individual words are added, otherwise the entire entry is added.\nThis is to prevent misspellings in CamelCase words from being introduced into the\ndictionary."
-        },
         "bTrie": {
           "anyOf": [
             {
@@ -270,6 +243,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.",
@@ -327,21 +305,6 @@
       "markdownDescription": "Url to JSON Schema",
       "type": "string"
     },
-    "allowedSplitWords": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/FilePath"
-        },
-        {
-          "items": {
-            "$ref": "#/definitions/FilePath"
-          },
-          "type": "array"
-        }
-      ],
-      "description": "Words in the `allowedSplitWords` are considered correct and can be used as a basis for splitting compound words.\n\nIf entries can be split so that all the words in the entry are allowed, then only the individual words are added, otherwise the entire entry is added. This is to prevent misspellings in CamelCase words from being introduced into the dictionary.",
-      "markdownDescription": "Words in the `allowedSplitWords` are considered correct and can be used\nas a basis for splitting compound words.\n\nIf entries can be split so that all the words in the entry are allowed,\nthen only the individual words are added, otherwise the entire entry is added.\nThis is to prevent misspellings in CamelCase words from being introduced into the\ndictionary."
-    },
     "checksumFile": {
       "description": "Path to checksum file. `true` - defaults to `./checksum.txt`.",
       "markdownDescription": "Path to checksum file. `true` - defaults to `./checksum.txt`.",
@@ -364,22 +327,10 @@
       "markdownDescription": "Generate lower case / accent free versions of words.",
       "type": "boolean"
     },
-    "keepRawCase": {
-      "default": false,
-      "description": "Do not generate lower case / accent free versions of words.",
-      "markdownDescription": "Do not generate lower case / accent free versions of words.",
-      "type": "boolean"
-    },
-    "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.",
-      "type": "number"
-    },
-    "minCompoundLength": {
-      "default": 4,
-      "description": "Controls the minimum length of a compound word when storing words using `storeSplitWordsAsCompounds`. The compound words are prefixed / suffixed with `*`, to allow them to be combined with other compound words. If the length is too low, then the dictionary will consider many misspelled words as correct.",
-      "markdownDescription": "Controls the minimum length of a compound word when storing words using `storeSplitWordsAsCompounds`.\nThe compound words are prefixed / suffixed with `*`, to allow them to be combined with other compound words.\nIf the length is too low, then the dictionary will consider many misspelled words as correct.",
-      "type": "number"
+    "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"
     },
     "removeDuplicates": {
       "default": false,
@@ -398,26 +349,6 @@
       "markdownDescription": "Sort the words in the resulting dictionary.\nDoes not apply to `trie` based formats.",
       "type": "boolean"
     },
-    "split": {
-      "anyOf": [
-        {
-          "type": "boolean"
-        },
-        {
-          "const": "legacy",
-          "type": "string"
-        }
-      ],
-      "default": false,
-      "description": "Split lines into words.",
-      "markdownDescription": "Split lines into words."
-    },
-    "storeSplitWordsAsCompounds": {
-      "default": false,
-      "description": "Camel case words that have been split using the `allowedSplitWords` are added to the dictionary as compoundable words. These words are prefixed / suffixed with `*`.",
-      "markdownDescription": "Camel case words that have been split using the `allowedSplitWords` are added to the dictionary as compoundable words.\nThese words are prefixed / suffixed with `*`.",
-      "type": "boolean"
-    },
     "targets": {
       "description": "Optional Target Dictionaries to create.",
       "items": {

package/dist/app.d.mts

@@ -1,5 +1,4 @@
 import { Command } from "commander";
-//#region src/FeatureFlags/FeatureFlags.d.ts
 interface FeatureFlag {
   name: string;
   description: string;
@@ -26,9 +25,6 @@ declare class FeatureFlags {
   help(): string;
   fork(): FeatureFlags;
 }
-//#endregion
-//#region src/app.d.ts
-declare function run(program: Command, argv: string[], flags?: FeatureFlags): Promise<void>;
-//#endregion
-export { run };
+export declare function run(program: Command, argv: string[], flags?: FeatureFlags): Promise<void>;
+export {};
 //# sourceMappingURL=app.d.mts.map

package/dist/app.mjs

@@ -1,18 +1,27 @@
-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-CkIhBjXk.mjs";
 import { readFileSync } from "node:fs";
 import { CommanderError, Option } from "commander";
-import { writeFile } from "node:fs/promises";
+import { glob, writeFile } from "node:fs/promises";
 import * as path from "node:path";
-import { glob } from "glob";
+import { join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { toArray } from "@cspell/cspell-pipe";
 import { opConcatMap, pipe } from "@cspell/cspell-pipe/sync";
 import YAML from "yaml";
-//#region src/util/globP.ts
+// src/util/globP.ts
 function globP(pattern, options) {
 	const globs = (Array.isArray(pattern) ? pattern : [pattern]).map((pattern) => pattern.replaceAll("\\", "/"));
-	return glob(globs, options);
+	const cwd = options?.cwd ?? ".";
+	const root = resolve(cwd instanceof URL ? fileURLToPath(cwd) : cwd);
+	return options?.nodir ? globNonDirectories(globs, root) : toArray(glob(globs, { cwd: root }));
 }
-//#endregion
-//#region src/gzip/gzip.ts
+async function globNonDirectories(globs, root) {
+	return (await toArray(glob(globs, {
+		cwd: root,
+		withFileTypes: true
+	}))).filter((entry) => !entry.isDirectory()).map((entry) => relative(root, join(entry.parentPath, entry.name)));
+}
+// src/gzip/gzip.ts
 /**
 * GZip files matching the given globs.
 * @param globs - array of globs to gzip
@@ -22,24 +31,20 @@ async function gzipFiles(globs, os) {
 	const files = await globP(globs, { nodir: true });
 	for (const fileName of files) await compressFile(fileName, os);
 }
-//#endregion
-//#region src/compiler/createCompileRequest.ts
+// src/compiler/createCompileRequest.ts
 function createCompileRequest(sourceFiles, options) {
 	options = { ...options };
 	options.maxDepth ??= options.max_depth;
-	const { maxDepth, split, keepRawCase, useLegacySplitter } = options;
-	return {
-		targets: calcTargets([...sourceFiles, ...(options.listFile || []).map((listFile) => ({ listFile }))], options),
-		maxDepth: parseNumber(maxDepth),
-		split: useLegacySplitter ? "legacy" : split,
-		/**
-		* Do not generate lower case / accent free versions of words.
-		* @default false
-		*/
-		keepRawCase
+	return { targets: calcTargets([...sourceFiles, ...(options.listFile || []).map((listFile) => ({ listFile }))], options, calcSourceOptions(options)) };
+}
+function calcSourceOptions(options) {
+	const sourceOptions = {
+		maxDepth: parseNumber(options.maxDepth),
+		split: options.useLegacySplitter ? "legacy" : options.split
 	};
+	return Object.fromEntries(Object.entries(sourceOptions).filter(([, v]) => v !== void 0));
 }
-function calcTargets(sources, options) {
+function calcTargets(sources, options, sourceOptions) {
 	const { merge, output = ".", experimental = [] } = options;
 	const generateNonStrict = experimental.includes("compound") || void 0;
 	const format = calcFormat(options);
@@ -49,7 +54,7 @@ function calcTargets(sources, options) {
 		targetDirectory: output,
 		compress: options.compress,
 		format,
-		sources: sources.map(normalizeSource),
+		sources: sources.map((source) => normalizeSource(source, sourceOptions)),
 		sort,
 		trieBase: parseNumber(options.trieBase),
 		generateNonStrict,
@@ -61,7 +66,7 @@ function calcTargets(sources, options) {
 			targetDirectory: output,
 			compress: options.compress,
 			format,
-			sources: [normalizeSource(source)],
+			sources: [normalizeSource(source, sourceOptions)],
 			sort: options.sort,
 			trieBase: parseNumber(options.trieBase),
 			generateNonStrict,
@@ -85,26 +90,37 @@ function baseNameOfSource(source) {
 function isFileSource(source) {
 	return typeof source !== "string" && source.filename !== void 0;
 }
-function normalizeSource(source) {
-	if (typeof source === "string") return normalizeSourcePath(source);
-	if (isFileSource(source)) return {
-		...source,
-		filename: normalizeSourcePath(source.filename)
-	};
+function normalizeSource(source, sourceOptions) {
+	const hasOptions = Object.keys(sourceOptions).length > 0;
+	if (typeof source === "string") {
+		const filename = normalizeSourcePath(source);
+		return hasOptions ? {
+			filename,
+			...sourceOptions
+		} : filename;
+	}
+	if (isFileSource(source)) {
+		const { filename, ...rest } = source;
+		return {
+			filename: normalizeSourcePath(filename),
+			...sourceOptions,
+			...rest
+		};
+	}
+	const { listFile, ...rest } = source;
 	return {
-		...source,
-		listFile: normalizeSourcePath(source.listFile)
+		listFile: normalizeSourcePath(listFile),
+		...sourceOptions,
+		...rest
 	};
 }
 function normalizeSourcePath(source) {
 	const cwd = process.cwd();
 	return path.relative(cwd, source).replaceAll("\\", "/");
 }
-//#endregion
-//#region src/config/config.ts
+// src/config/config.ts
 const configFileSchemaURL = "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/packages/cspell-tools/cspell-tools.config.schema.json";
-//#endregion
-//#region src/FeatureFlags/FeatureFlags.ts
+// src/FeatureFlags/FeatureFlags.ts
 let systemFeatureFlags;
 /**
 * Feature Flags are used to turn on/off features.
@@ -195,8 +211,7 @@ function toBool(value) {
 	if (typeof value !== "string") return value;
 	return boolValues[value.toLowerCase()];
 }
-//#endregion
-//#region src/FeatureFlags/parseFlags.ts
+// src/FeatureFlags/parseFlags.ts
 const splitFlag = /[:=]/;
 const leadingEql = /^=/;
 function parseFlags(ff, flags) {
@@ -214,8 +229,7 @@ function parseFlags(ff, flags) {
 	}
 	return ff;
 }
-//#endregion
-//#region src/compile.ts
+// src/compile.ts
 getSystemFeatureFlags().register("compound", "Enable compound dictionary sources.");
 const defaultConfigFile = "cspell-tools.config.yaml";
 const configFileHeader = `# yaml-language-server: $schema=${configFileSchemaURL}\n\n`;
@@ -245,8 +259,7 @@ To build, use:
   cspell-tools-cli build
 `);
 }
-//#endregion
-//#region src/app.ts
+// src/app.ts
 const npmPackageRaw = readFileSync(new URL("../package.json", import.meta.url), "utf8");
 const npmPackage = JSON.parse(npmPackageRaw);
 setLogger(logWithTimestamp);
@@ -254,7 +267,9 @@ function collect(value, previous) {
 	return [...previous, value];
 }
 function addCompileOptions(compileCommand) {
-	return compileCommand.option("-o, --output <path>", "Specify the output directory, otherwise files are written back to the same location.").option("-n, --no-compress", "By default the files are GZipped, this will turn off GZ compression.").option("-m, --max_depth <limit>", "Maximum depth to apply suffix rules.").option("-M, --merge <target>", "Merge all files into a single target file (extensions are applied)").option("--split", "Split each line", void 0).option("--no-split", "Treat each line as a dictionary entry, do not split").option("--use-legacy-splitter", "Do not use legacy line splitter logic.").option("--keep-raw-case", "Do not normalize words before adding them to dictionary.").option("-x, --experimental <flag>", "Experimental flags, used for testing new concepts. Flags: compound", collect, []).option("--trie3", "Use file format trie3", false).option("--trie4", "Use file format trie4", false).option("--trie-base <number>", "Advanced: Set the trie base number. A value between 10 and 36").option("--list-file <filename...>", "Path to a file that contains the list of files to compile. A list file contains one file per line.").option("--init", "Create a build command `cspell-tools.config.yaml` file based upon the options given instead of building.");
+	return compileCommand.option("-o, --output <path>", "Specify the output directory, otherwise files are written back to the same location.").option("-n, --no-compress", "By default the files are GZipped, this will turn off GZ compression.").option("-m, --max_depth <limit>", "Maximum depth to apply suffix rules.").option("-M, --merge <target>", "Merge all files into a single target file (extensions are applied)").option("--split", "Split each line", void 0).option("--no-split", "Treat each line as a dictionary entry, do not split").option("--use-legacy-splitter", "Do not use legacy line splitter logic.").addOption(new Option("--keep-raw-case", "Has no effect.").hideHelp()).on("option:keep-raw-case", () => {
+		console.warn("--keep-raw-case has no effect and will be removed in future versions.");
+	}).option("-x, --experimental <flag>", "Experimental flags, used for testing new concepts. Flags: compound", collect, []).option("--trie3", "Use file format trie3", false).option("--trie4", "Use file format trie4", false).option("--trie-base <number>", "Advanced: Set the trie base number. A value between 10 and 36").option("--list-file <filename...>", "Path to a file that contains the list of files to compile. A list file contains one file per line.").option("--init", "Create a build command `cspell-tools.config.yaml` file based upon the options given instead of building.");
 }
 async function run(program, argv, flags) {
 	async function handleGzip(files) {
@@ -287,7 +302,6 @@ async function run(program, argv, flags) {
 	program.command("shasum [files...]").description("Calculate the checksum for files.").option("--list-file <list-file.txt...>", "Specify one or more files that contain paths of files to check.").option("-c, --check <checksum.txt>", "Verify the checksum of files against those stored in the checksum.txt file.").addOption(new Option("-u, --update <checksum.txt>", "Update checksums found in the file.").conflicts("--check")).option("-r, --root <root>", "Specify the root to use for relative paths. The current working directory is used by default.").action(shasum);
 	await program.parseAsync(argv);
 }
-//#endregion
 export { run };
 
 //# sourceMappingURL=app.mjs.map

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

@@ -6,15 +6,15 @@ import * as Trie from "cspell-trie-lib";
 import { COMPOUND_FIX, FORBID_PREFIX, createDictionaryLineParser, decodeTrie, encodeTrieDataToBTrie, parseDictionary } from "cspell-trie-lib";
 import { promisify } from "node:util";
 import { gunzip, gunzipSync, gzip } from "node:zlib";
+import { pipeAsync, toArray } from "@cspell/cspell-pipe";
 import { opAppend, opCombine, opConcatMap, opFilter, opMap, pipe } from "@cspell/cspell-pipe/sync";
 import * as HR from "hunspell-reader";
 import { uniqueFilter } from "hunspell-reader";
 import { cosmiconfig } from "cosmiconfig";
-import { pipeAsync, toArray } from "@cspell/cspell-pipe";
 import { opAwaitAsync, opMapAsync } from "@cspell/cspell-pipe/operators";
 import { createHash } from "node:crypto";
 import { Buffer } from "node:buffer";
-//#region src/gzip/compressFiles.ts
+// src/gzip/compressFiles.ts
 const gzip$1 = promisify(gzip);
 const gunzip$1 = promisify(gunzip);
 const OSSystemIDOffset = 9;
@@ -55,8 +55,7 @@ async function decompress(buf, encoding) {
 	if (!encoding) return dBuf;
 	return (await dBuf).toString(encoding);
 }
-//#endregion
-//#region src/util/writeFile.ts
+// src/util/writeFile.ts
 /**
 * Writes a file to disk and compress as needed.
 *
@@ -74,11 +73,9 @@ async function writeFile$1(filePath, data) {
 	const toWrite = filePath.endsWith(".gz") ? await compressIfNeeded(buf) : buf;
 	return fs.writeFile(filePath, toWrite);
 }
-//#endregion
-//#region src/compiler/readers/regHunspellFile.ts
+// src/compiler/readers/regHunspellFile.ts
 const regHunspellFile = /\.(dic|aff)$/i;
-//#endregion
-//#region src/compiler/readers/readHunspellFiles.ts
+// src/compiler/readers/readHunspellFiles.ts
 const DEDUPE_SIZE = 1e3;
 async function readHunspellFiles(filename, options) {
 	const dicFile = filename.replace(regHunspellFile, ".dic");
@@ -134,8 +131,7 @@ function* _mapAffWords(affWords) {
 		} else yield forbid + word;
 	}
 }
-//#endregion
-//#region src/compiler/readers/readTextFile.ts
+// src/compiler/readers/readTextFile.ts
 const isGzFile$1 = /\.gz$/;
 function readTextFile(filename) {
 	return readFile$2(filename).then((buffer) => {
@@ -145,8 +141,7 @@ function readTextFile(filename) {
 function readFile$2(filename) {
 	return promises.readFile(filename).then(async (buffer) => isGzFile$1.test(filename) ? decompress(buffer) : buffer);
 }
-//#endregion
-//#region src/compiler/readers/textFileReader.ts
+// src/compiler/readers/textFileReader.ts
 async function textFileReader$1(filename) {
 	const words = (await readTextFile(filename)).split("\n").map((s) => s.trim());
 	let trie;
@@ -165,8 +160,7 @@ async function textFileReader$1(filename) {
 		}
 	};
 }
-//#endregion
-//#region src/compiler/readers/trieFileReader.ts
+// src/compiler/readers/trieFileReader.ts
 async function trieFileReader(filename) {
 	return TrieFileReader.create(filename);
 }
@@ -197,8 +191,7 @@ var TrieFileReader = class TrieFileReader {
 		return new TrieFileReader(filename, trie);
 	}
 };
-//#endregion
-//#region src/compiler/Reader.ts
+// src/compiler/Reader.ts
 const readers = [
 	{
 		test: /\.trie\b/,
@@ -221,8 +214,7 @@ async function createReader(filename, options) {
 	const baseReader = await findMatchingReader(filename, options);
 	return Object.assign(baseReader, { [Symbol.iterator]: () => baseReader.lines[Symbol.iterator]() });
 }
-//#endregion
-//#region src/compiler/bTrie.ts
+// src/compiler/bTrie.ts
 async function generateBTrieFromFile(file, options) {
 	const log = options.logger || console.log.bind(console);
 	log(`Processing file: ${file}`);
@@ -253,13 +245,11 @@ async function createBTrieFromFile(file, buildOptions) {
 	const trie = (await createReader(file, {})).toTrie();
 	return encodeTrieDataToBTrie(trie.data, buildOptions);
 }
-//#endregion
-//#region src/bTrie.ts
+// src/bTrie.ts
 function generateBTrie(files, options) {
 	return generateBTrieFromFiles(files, options);
 }
-//#endregion
-//#region src/config/configUtils.ts
+// src/config/configUtils.ts
 function isFilePath(source) {
 	return typeof source === "string";
 }
@@ -271,8 +261,7 @@ function isFileListSource(source) {
 	if (!source || isFilePath(source)) return false;
 	return source.listFile !== void 0;
 }
-//#endregion
-//#region src/config/normalizeConfig.ts
+// src/config/normalizeConfig.ts
 function normalizeConfig(cfg) {
 	if (!cfg) return cfg;
 	const dir = path.dirname(cfg.filepath);
@@ -285,8 +274,7 @@ function normalizeConfig(cfg) {
 		filepath: cfg.filepath
 	};
 }
-//#endregion
-//#region src/shasum/checksum.ts
+// src/shasum/checksum.ts
 function calcChecksum(buf, alg = "SHA1") {
 	const hash = createHash(alg);
 	hash.update(buf);
@@ -298,8 +286,7 @@ async function calcFileChecksum(filename, alg) {
 async function checkFile(checksum, filename, alg) {
 	return await calcFileChecksum(filename, alg) === checksum;
 }
-//#endregion
-//#region src/util/errors.ts
+// src/util/errors.ts
 function toError(err) {
 	if (isError(err)) return err;
 	return /* @__PURE__ */ new Error(`${err}`);
@@ -308,13 +295,11 @@ function isError(err) {
 	if (err instanceof Error) return true;
 	return false;
 }
-//#endregion
-//#region src/util/index.ts
+// src/util/index.ts
 function isDefined$1(a) {
 	return !!a || a !== null && a !== void 0;
 }
-//#endregion
-//#region src/shasum/shasum.ts
+// src/shasum/shasum.ts
 async function shasumFile(filename, root) {
 	try {
 		return `${await calcFileChecksum(resolve(root || ".", filename))}  ${filename}`;
@@ -453,8 +438,7 @@ async function updateChecksumForFiles(filename, files, options) {
 function normalizeFilename(filename) {
 	return filename.split(sep).join("/");
 }
-//#endregion
-//#region src/util/textRegex.ts
+// src/util/textRegex.ts
 const regExMatchRegExParts = /^\s*\/([\s\S]*?)\/([gimuxy]*)\s*$/;
 function stringToRegExp(pattern, defaultFlags = "", forceFlags = "") {
 	if (pattern instanceof RegExp) return pattern;
@@ -549,8 +533,29 @@ function removeVerboseFromRegExp(pattern) {
 	while (result.idx < pattern.length) for (const r of reducers) if (r(result)) break;
 	return result.result;
 }
-//#endregion
-//#region src/compiler/WordsCollection.ts
+// 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);
+}
+// src/compiler/WordsCollection.ts
 const defaultAllowedSplitWords = Object.freeze({
 	size: 0,
 	has: () => true
@@ -559,8 +564,7 @@ Object.freeze({
 	size: 0,
 	has: () => false
 });
-//#endregion
-//#region src/compiler/createWordsCollection.ts
+// src/compiler/createWordsCollection.ts
 var AllowedSplitWordsImpl = class {
 	collection;
 	size;
@@ -572,15 +576,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 +593,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,94 +603,90 @@ 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];
-}
-//#endregion
-//#region src/compiler/logWithTimestamp.ts
+	if (Array.isArray(filePathOrArray)) return filePathOrArray;
+	const found = filePaths.get(filePathOrArray);
+	if (found) return found;
+	const paths = [filePathOrArray];
+	filePaths.set(filePathOrArray, paths);
+	return paths;
+}
+// src/compiler/logWithTimestamp.ts
 const logWithTimestamp = (message, ...optionalParams) => {
 	console.log(`${(/* @__PURE__ */ new Date()).toISOString()} ${message}`, ...optionalParams);
 };
-//#endregion
-//#region src/config/configDefaults.ts
+// src/config/configDefaults.ts
 const defaultCompileSourceOptions = {
 	maxDepth: void 0,
 	split: false,
-	keepRawCase: false,
 	allowedSplitWords: void 0,
 	storeSplitWordsAsCompounds: false,
 	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
+// 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 lowerCaseUnlessAcronyms(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 = lowerCaseUnlessAcronyms(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 lowerCaseUnlessAcronyms(words, allowedWords, keepCase, locale) {
+	return words.map((w) => lowerCaseUnlessAcronym(w, allowedWords, keepCase, locale));
 }
-function adjustCase(word, allowedWords, keepCase) {
-	const lc = word.toLowerCase();
+function lowerCaseUnlessAcronym(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) {
@@ -713,21 +713,20 @@ function calcWordIndex(word, words) {
 		return wIndex;
 	});
 }
-//#endregion
-//#region src/compiler/legacyLineToWords.ts
+// src/compiler/legacyLineToWords.ts
 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
+// src/compiler/wordListParser.ts
 function normalizeTargetWords(options) {
 	const lineParser = createDictionaryLineParser({
 		stripCaseAndAccents: options.generateNonStrict,
+		locale: options.locale,
 		stripCaseAndAccentsOnForbidden: true,
 		keepOptionalCompoundCharacter: true
 	});
@@ -771,7 +770,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 +783,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 +841,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) {
@@ -890,8 +890,7 @@ function replacementsToMapOperator(replacements) {
 		return word;
 	});
 }
-//#endregion
-//#region src/compiler/SourceReader.ts
+// src/compiler/SourceReader.ts
 async function createSourceReader(filename, options) {
 	const reader = await createReader(filename, options);
 	if (reader.type !== "TextFile") return {
@@ -911,7 +910,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 +918,8 @@ async function textFileReader(reader, options) {
 		keepCase: void 0,
 		allowedSplitWords,
 		storeSplitWordsAsCompounds,
-		minCompoundLength
+		minCompoundLength,
+		locale
 	};
 	const words = [...parseFileLines(reader.lines, parseOptions)];
 	return {
@@ -927,13 +927,11 @@ async function textFileReader(reader, options) {
 		words
 	};
 }
-//#endregion
-//#region src/compiler/streamSourceWordsFromFile.ts
+// src/compiler/streamSourceWordsFromFile.ts
 async function streamSourceWordsFromFile(filename, options) {
 	return (await createSourceReader(filename, options)).words;
 }
-//#endregion
-//#region src/compiler/logger.ts
+// src/compiler/logger.ts
 const defaultLogger = console.log;
 let log = defaultLogger;
 function setLogger(logger) {
@@ -942,8 +940,7 @@ function setLogger(logger) {
 function getLogger() {
 	return log;
 }
-//#endregion
-//#region src/compiler/writeTextToFile.ts
+// src/compiler/writeTextToFile.ts
 const isGzFile = /\.gz$/;
 async function writeTextToFile(filename, data, useGzCompress) {
 	const dataStr = typeof data === "string" ? data : Array.isArray(data) ? data.join("") : [...data].join("");
@@ -954,8 +951,7 @@ async function writeTextToFile(filename, data, useGzCompress) {
 	const buffer = useGz ? await compress(buf) : buf;
 	await promises.writeFile(filename, buffer);
 }
-//#endregion
-//#region src/compiler/wordListCompiler.ts
+// src/compiler/wordListCompiler.ts
 const mkdirp = async (p) => {
 	await mkdir(p, { recursive: true });
 };
@@ -974,7 +970,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 +978,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 +997,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 +1008,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;
 		}
 	}
@@ -1084,8 +1080,7 @@ function createTrieCompiler(options) {
 		});
 	};
 }
-//#endregion
-//#region src/compiler/compile.ts
+// src/compiler/compile.ts
 async function compile(request, options) {
 	const { targets } = request;
 	const rootDir = path.resolve(request.rootDir || ".");
@@ -1093,6 +1088,7 @@ async function compile(request, options) {
 	const targetOptions = {
 		sort: request.sort,
 		generateNonStrict: request.generateNonStrict,
+		locale: request.locale,
 		removeDuplicates: request.removeDuplicates,
 		replacements: void 0
 	};
@@ -1105,7 +1101,7 @@ async function compile(request, options) {
 		(await compileTarget({
 			...targetOptions,
 			...target
-		}, request, {
+		}, {
 			rootDir,
 			cwd,
 			conditional,
@@ -1123,11 +1119,11 @@ function resolveChecksumFile(checksumFile, root) {
 	const cFilename = typeof checksumFile === "string" && checksumFile || checksumFile && "./checksum.txt" || void 0;
 	return cFilename && path.resolve(root, cFilename);
 }
-async function compileTarget(target, options, compileOptions) {
+async function compileTarget(target, compileOptions) {
 	logWithTimestamp(`Start compile: ${target.name}`);
 	const buildOptions = genBuildTargetDictionaryOptions(target, compileOptions);
 	const deps = /* @__PURE__ */ new Set();
-	addToSet(deps, await buildTargetDictionary(target, options, compileOptions, buildOptions), await compressDictionaryFileIfNeeded(buildOptions), await genBTrieForTarget(target, buildOptions));
+	addToSet(deps, await buildTargetDictionary(target, compileOptions, buildOptions), await compressDictionaryFileIfNeeded(buildOptions), await genBTrieForTarget(target, buildOptions));
 	logWithTimestamp(`Done compile: ${target.name}`);
 	const checksumRoot = buildOptions.checksumRoot;
 	return [...deps].map((d) => path.relative(checksumRoot, d));
@@ -1151,24 +1147,26 @@ function genBuildTargetDictionaryOptions(target, compileOptions) {
 		checksumRoot: checksumFile && path.dirname(checksumFile) || rootDir
 	};
 }
-async function buildTargetDictionary(target, options, compileOptions, buildOptions) {
+async function buildTargetDictionary(target, compileOptions, buildOptions) {
 	const { rootDir, checksumFile, conditional } = compileOptions;
 	const { format, sources, trieBase, sort = true, generateNonStrict = false, excludeWordsFrom = [], excludeWordsNotFoundIn = [], excludeWordsMatchingRegex, replacements } = target;
 	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, locale)), opAwaitAsync());
 	const filesToProcess = await toArray(filesToProcessAsync);
 	const normalizer = normalizeTargetWords({
 		sort: useTrie || sort,
 		generateNonStrict,
+		locale,
 		filter: excludeFilter,
 		dictionaryDirectives,
 		replacements
@@ -1188,6 +1186,7 @@ async function buildTargetDictionary(target, options, compileOptions, buildOptio
 		}) : createWordListCompiler({
 			sort,
 			generateNonStrict,
+			locale,
 			dictionaryDirectives,
 			removeDuplicates,
 			replacements
@@ -1284,17 +1283,17 @@ 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) {
-	const { filename, keepRawCase = sourceOptions.keepRawCase || false, split = sourceOptions.split || false, maxDepth, storeSplitWordsAsCompounds, minCompoundLength } = fileSource;
+async function readFileSource(fileSource, locale) {
+	const { filename, split = false, maxDepth, storeSplitWordsAsCompounds, minCompoundLength } = fileSource;
 	const legacy = split === "legacy";
 	const readerOptions = {
 		maxDepth,
 		legacy,
 		splitWords: legacy ? false : split,
-		keepCase: keepRawCase,
-		allowedSplitWords: await createAllowedSplitWordsFromFiles(fileSource.allowedSplitWords || sourceOptions.allowedSplitWords),
+		allowedSplitWords: await createAllowedSplitWordsFromFiles(fileSource.allowedSplitWords, locale),
 		storeSplitWordsAsCompounds,
-		minCompoundLength
+		minCompoundLength,
+		locale
 	};
 	logWithTimestamp(`Reading ${path.basename(filename)}`);
 	const stream = await streamSourceWordsFromFile(filename, readerOptions);
@@ -1304,6 +1303,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 +1333,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);
 }
 /**
@@ -1356,8 +1370,7 @@ function iterableToString(iter) {
 function addToSet(set, ...sources) {
 	for (const items of sources) for (const item of items) set.add(item);
 }
-//#endregion
-//#region src/build.ts
+// src/build.ts
 const moduleName = "cspell-tools";
 const searchPlaces = [
 	`${moduleName}.config.json`,
@@ -1389,14 +1402,13 @@ async function build(targets, options) {
 	});
 }
 function normalizeRequest(buildInfo, root) {
-	const { rootDir = root, targets = [], checksumFile } = buildInfo;
+	const { rootDir = root, targets = [], ...rest } = buildInfo;
 	return {
+		...rest,
 		rootDir: path.resolve(rootDir),
-		targets,
-		checksumFile
+		targets
 	};
 }
-//#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-CkIhBjXk.mjs.map

package/dist/index.d.mts

@@ -1,4 +1,3 @@
-//#region src/config/config.d.ts
 interface BTrieOptions {
   /** compress the resulting file */
   compress?: boolean | undefined;
@@ -7,21 +6,13 @@ interface BTrieOptions {
   /** use a string table to reduce size */
   useStringTable?: boolean | undefined;
 }
-//#endregion
-//#region src/compiler/logger.d.ts
 type Logger = (message?: any, ...optionalParams: any[]) => void;
-//#endregion
-//#region src/compiler/bTrie.d.ts
 interface GenerateBTrieOptions extends BTrieOptions {
   /** output directory */
   output?: string;
   logger?: Logger;
 }
-//#endregion
-//#region src/bTrie.d.ts
-declare function generateBTrie(files: string[], options: GenerateBTrieOptions): Promise<void>;
-//#endregion
-//#region src/build.d.ts
+export declare function generateBTrie(files: string[], options: GenerateBTrieOptions): Promise<void>;
 interface BuildOptions {
   /** Optional path to config file */
   config?: string | undefined;
@@ -32,7 +23,6 @@ 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>;
-//#endregion
-export { build, generateBTrie };
+export declare function build(targets: string[] | undefined, options: BuildOptions): Promise<void>;
+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-CkIhBjXk.mjs";

package/package.json

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