@cspell/cspell-tools 10.4.0 → 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": [
             {
@@ -332,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`.",
@@ -369,28 +327,11 @@
       "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"
-    },
     "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.",
-      "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"
-    },
     "removeDuplicates": {
       "default": false,
       "description": "Remove duplicate words, favor lower case words over mixed case words. Combine compound prefixes where possible.",
@@ -408,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
 export declare function run(program: Command, argv: string[], flags?: FeatureFlags): Promise<void>;
-//#endregion
 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-DitWkAJE.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-DitWkAJE.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,7 @@ function removeVerboseFromRegExp(pattern) {
 	while (result.idx < pattern.length) for (const r of reducers) if (r(result)) break;
 	return result.result;
 }
-//#endregion
-//#region src/compiler/text.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;
@@ -572,8 +555,7 @@ function lowerCase(word, locale) {
 function isSingleLetter(c) {
 	return regExpIsLetter.test(c);
 }
-//#endregion
-//#region src/compiler/WordsCollection.ts
+// src/compiler/WordsCollection.ts
 const defaultAllowedSplitWords = Object.freeze({
 	size: 0,
 	has: () => true
@@ -582,8 +564,7 @@ Object.freeze({
 	size: 0,
 	has: () => false
 });
-//#endregion
-//#region src/compiler/createWordsCollection.ts
+// src/compiler/createWordsCollection.ts
 var AllowedSplitWordsImpl = class {
 	collection;
 	size;
@@ -666,31 +647,27 @@ function toFilePathArray(filePathOrArray) {
 	filePaths.set(filePathOrArray, paths);
 	return paths;
 }
-//#endregion
-//#region src/compiler/logWithTimestamp.ts
+// 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/splitCamelCaseIfAllowed.ts
+// src/compiler/splitCamelCaseIfAllowed.ts
 const regExpSpaceOrDash = /[- ]+/g;
 const regExpIsNumber = /^\d+$/;
 function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, minCompoundLength, locale) {
 	const split = [...splitCamelCase(word)];
-	if (split.length === 1) return adjustCases(split, allowedWords, keepCase, locale);
+	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, locale);
+	const adjusted = lowerCaseUnlessAcronyms(split, allowedWords, keepCase, locale);
 	return !compoundPrefix ? adjusted : adjusted.map((w, i) => {
 		const { px, sx } = wordIndexes[i];
 		const canCompound = w.length >= minCompoundLength;
@@ -701,10 +678,10 @@ function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, m
 		return p + lc + s;
 	});
 }
-function adjustCases(words, allowedWords, keepCase, locale) {
-	return words.map((w) => adjustCase(w, allowedWords, keepCase, locale));
+function lowerCaseUnlessAcronyms(words, allowedWords, keepCase, locale) {
+	return words.map((w) => lowerCaseUnlessAcronym(w, allowedWords, keepCase, locale));
 }
-function adjustCase(word, allowedWords, keepCase, locale) {
+function lowerCaseUnlessAcronym(word, allowedWords, keepCase, locale) {
 	const lc = lowerCase(word, locale);
 	if (!allowedWords.has(lc, true)) return word;
 	if (lc === word) return word;
@@ -736,8 +713,7 @@ 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;
@@ -746,8 +722,7 @@ function legacyLineToWords(line, keepCase, allowedSplitWords, locale) {
 	const _minCompoundLength = minCompoundLength;
 	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,
@@ -915,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 {
@@ -953,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) {
@@ -968,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("");
@@ -980,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 });
 };
@@ -1110,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 || ".");
@@ -1132,7 +1101,7 @@ async function compile(request, options) {
 		(await compileTarget({
 			...targetOptions,
 			...target
-		}, request, {
+		}, {
 			rootDir,
 			cwd,
 			conditional,
@@ -1150,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));
@@ -1178,7 +1147,7 @@ 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;
@@ -1192,7 +1161,7 @@ async function buildTargetDictionary(target, options, compileOptions, buildOptio
 		return excludeFromFilter(word) && includeFromFilter(word) && excludeRegexFilter(word);
 	};
 	const compress = generateOnlyCompressedDictionary;
-	const filesToProcessAsync = pipeAsync(readSourceList(sources, rootDir), opMapAsync((src) => readFileSource(src, options, locale)), opAwaitAsync());
+	const filesToProcessAsync = pipeAsync(readSourceList(sources, rootDir), opMapAsync((src) => readFileSource(src, locale)), opAwaitAsync());
 	const filesToProcess = await toArray(filesToProcessAsync);
 	const normalizer = normalizeTargetWords({
 		sort: useTrie || sort,
@@ -1314,15 +1283,14 @@ 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, locale) {
-	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, locale),
+		allowedSplitWords: await createAllowedSplitWordsFromFiles(fileSource.allowedSplitWords, locale),
 		storeSplitWordsAsCompounds,
 		minCompoundLength,
 		locale
@@ -1402,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`,
@@ -1435,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-DitWkAJE.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
 export declare function generateBTrie(files: string[], options: GenerateBTrieOptions): Promise<void>;
-//#endregion
-//#region src/build.d.ts
 interface BuildOptions {
   /** Optional path to config file */
   config?: string | undefined;
@@ -33,6 +24,5 @@ interface BuildOptions {
   conditional?: boolean;
 }
 export declare function build(targets: string[] | undefined, options: BuildOptions): Promise<void>;
-//#endregion
 export {};
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1 +1 @@
-export { t as build, l as generateBTrie } from "./build-DitWkAJE.mjs";
+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",
+  "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",
+    "@cspell/cspell-pipe": "10.4.1",
     "commander": "^15.0.0",
     "cosmiconfig": "10.0.1",
-    "cspell-trie-lib": "10.4.0",
-    "glob": "^13.0.6",
-    "hunspell-reader": "10.4.0",
+    "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": "7e2bbb5e866c827ac5d2cf6b84bf3e1a016d0823"
+  "gitHead": "ddb1699a4bfc2766675c2c97412a813d775772eb"
 }