@cspell/cspell-tools 9.6.1 → 9.6.3

package/dist/app.mjs

@@ -1,4 +1,4 @@
-import { a as reportCheckChecksumFile, c as toError, d as compressFile, i as logWithTimestamp, l as generateBTrie, n as compile, o as reportChecksumForFiles, r as setLogger, s as updateChecksumForFiles, t as build, u as OSFlags } from "./build-OgMPaXPZ.mjs";
+import { a as reportCheckChecksumFile, c as toError, d as compressFile, i as logWithTimestamp, l as generateBTrie, n as compile, o as reportChecksumForFiles, r as setLogger, s as updateChecksumForFiles, t as build, u as OSFlags } from "./build-BGL2P0c2.mjs";
 import { readFileSync } from "node:fs";
 import { CommanderError, Option } from "commander";
 import { writeFile } from "node:fs/promises";
@@ -9,7 +9,7 @@ import YAML from "yaml";
 
 //#region src/util/globP.ts
 function globP(pattern, options) {
-	return glob((Array.isArray(pattern) ? pattern : [pattern]).map((pattern$1) => pattern$1.replaceAll("\\", "/")), options);
+	return glob((Array.isArray(pattern) ? pattern : [pattern]).map((pattern) => pattern.replaceAll("\\", "/")), options);
 }
 
 //#endregion

package/dist/{build-OgMPaXPZ.mjs → build-BGL2P0c2.mjs}

@@ -1,7 +1,7 @@
 import { promises } from "node:fs";
 import fs, { mkdir, readFile, writeFile } from "node:fs/promises";
 import * as path from "node:path";
-import fsPath, { resolve, sep } from "node:path";
+import fsPath, { dirname, relative, resolve, sep } from "node:path";
 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";
@@ -18,14 +18,14 @@ import { Buffer } from "node:buffer";
 //#region src/gzip/compressFiles.ts
 const gzip$1 = promisify(gzip);
 const gunzip$1 = promisify(gunzip);
-let OSFlags = /* @__PURE__ */ function(OSFlags$1) {
-	OSFlags$1[OSFlags$1["auto"] = -1] = "auto";
-	OSFlags$1[OSFlags$1["FAT"] = 0] = "FAT";
-	OSFlags$1[OSFlags$1["Unix"] = 3] = "Unix";
-	OSFlags$1[OSFlags$1["HPFS"] = 6] = "HPFS";
-	OSFlags$1[OSFlags$1["MACOS"] = 7] = "MACOS";
-	OSFlags$1[OSFlags$1["NTFS"] = 11] = "NTFS";
-	return OSFlags$1;
+let OSFlags = /* @__PURE__ */ function(OSFlags) {
+	OSFlags[OSFlags["auto"] = -1] = "auto";
+	OSFlags[OSFlags["FAT"] = 0] = "FAT";
+	OSFlags[OSFlags["Unix"] = 3] = "Unix";
+	OSFlags[OSFlags["HPFS"] = 6] = "HPFS";
+	OSFlags[OSFlags["MACOS"] = 7] = "MACOS";
+	OSFlags[OSFlags["NTFS"] = 11] = "NTFS";
+	return OSFlags;
 }({});
 const OSSystemIDOffset = 9;
 async function compressFile(file, os) {
@@ -238,15 +238,17 @@ async function createReader(filename, options) {
 //#endregion
 //#region src/compiler/bTrie.ts
 async function generateBTrieFromFile(file, options) {
-	console.log(`Processing file: ${file}`);
+	const log = options.logger || console.log.bind(console);
+	log(`Processing file: ${file}`);
 	const btrie = await createBTrieFromFile(file, options);
 	const outFile = bTrieFileName(file, options);
 	await mkdir(fsPath.dirname(outFile), { recursive: true });
 	await writeFile$1(outFile, btrie);
-	console.log(`Written BTrie to: ${outFile}`);
+	log(`Written BTrie to: ${outFile}`);
+	return outFile;
 }
 async function generateBTrieFromFiles(files, options) {
-	console.log(`Generating BTrie for ${files.length} file(s).`);
+	(options.logger || console.log.bind(console))(`Generating BTrie for ${files.length} file(s).`);
 	for (const file of files) await generateBTrieFromFile(file, options);
 }
 function bTrieFileName(inputFilename, options) {
@@ -343,17 +345,18 @@ async function shasumFile(filename, root) {
 /**
 *
 * @param filename - name of checksum file
-* @param files - optional list of files to check
+* @param files - optional list of files to check - they will be resolved relative to the checksum file.
 * @param root - optional root, default cwd.
 */
 async function checkShasumFile(filename, files, root) {
 	files = !files ? files : files.length ? files : void 0;
+	const resolvedRoot = resolve(root || ".");
+	const fileDir = dirname(resolve(resolvedRoot, filename));
 	const shaFiles = await readAndParseShasumFile(filename);
-	const filesToCheck = !files ? shaFiles.map(({ filename: filename$1 }) => filename$1) : files;
+	const relFilesToCheck = (!files ? shaFiles.map(({ filename }) => filename) : files).map((f) => relative(fileDir, resolve(fileDir, f)));
 	const mapNameToChecksum = new Map(shaFiles.map((r) => [normalizeFilename(r.filename), r.checksum]));
-	const resolvedRoot = resolve(root || ".");
-	const results = await Promise.all(filesToCheck.map(normalizeFilename).map((filename$1) => {
-		return tryToCheckFile(filename$1, resolvedRoot, mapNameToChecksum.get(filename$1));
+	const results = await Promise.all(relFilesToCheck.map(normalizeFilename).map((filename) => {
+		return tryToCheckFile(filename, resolvedRoot, mapNameToChecksum.get(filename));
 	}));
 	return {
 		passed: !results.some((v) => !v.passed),
@@ -416,7 +419,7 @@ async function reportChecksumForFiles(files, options) {
 async function reportCheckChecksumFile(filename, files, options) {
 	const root = options.root;
 	const results = (await checkShasumFile(filename, await resolveFileList(files, options.listFile), root)).results;
-	const lines = results.map(({ filename: filename$1, passed: passed$1, error }) => `${filename$1}: ${passed$1 ? "OK" : "FAILED"} ${error ? "- " + error.message : ""}`.trim());
+	const lines = results.map(({ filename, passed, error }) => `${filename}: ${passed ? "OK" : "FAILED"} ${error ? "- " + error.message : ""}`.trim());
 	const withErrors = results.filter((a) => !a.passed);
 	const passed = !withErrors.length;
 	if (!passed) lines.push(`shasum: WARNING: ${withErrors.length} computed checksum${withErrors.length > 1 ? "s" : ""} did NOT match`);
@@ -446,7 +449,7 @@ async function calcUpdateChecksumForFiles(filename, files, options) {
 	}));
 	const entriesToUpdate = new Set([...filesToCheck, ...currentEntries.map((e) => e.filename)]);
 	const mustExist = new Set(filesToCheck);
-	const checksumMap = new Map(currentEntries.map(({ filename: filename$1, checksum }) => [filename$1, checksum]));
+	const checksumMap = new Map(currentEntries.map(({ filename, checksum }) => [filename, checksum]));
 	for (const file of entriesToUpdate) try {
 		const checksum = await calcFileChecksum(resolve(root, file));
 		checksumMap.set(file, checksum);
@@ -454,8 +457,8 @@ async function calcUpdateChecksumForFiles(filename, files, options) {
 		if (mustExist.has(file) || toError(e).code !== "ENOENT") throw e;
 		checksumMap.delete(file);
 	}
-	return [...checksumMap].map(([filename$1, checksum]) => ({
-		filename: filename$1,
+	return [...checksumMap].map(([filename, checksum]) => ({
+		filename,
 		checksum
 	})).sort((a, b) => a.filename < b.filename ? -1 : 1).map((e) => `${e.checksum}  ${e.filename}`).join("\n") + "\n";
 }
@@ -530,11 +533,11 @@ function removeVerboseFromRegExp(pattern) {
 		acc.idx++;
 		let escCount = 0;
 		while (acc.idx < pattern.length) {
-			const char$1 = pattern[acc.idx];
-			acc.result += char$1;
+			const char = pattern[acc.idx];
+			acc.result += char;
 			acc.idx++;
-			if (char$1 === "]" && !(escCount & 1)) break;
-			escCount = char$1 === "\\" ? escCount + 1 : 0;
+			if (char === "]" && !(escCount & 1)) break;
+			escCount = char === "\\" ? escCount + 1 : 0;
 		}
 		return acc;
 	}
@@ -609,9 +612,9 @@ function buildHasFn(dict) {
 async function readFile$1(filename) {
 	return await createReader(filename, {});
 }
-function readersToCollection(readers$1) {
-	const dictReaders = readers$1.filter(isDictionaryReader).map(dictReaderToCollection);
-	const nonDictCollection = lineReadersToCollection(readers$1.filter((a) => !isDictionaryReader(a)));
+function readersToCollection(readers) {
+	const dictReaders = readers.filter(isDictionaryReader).map(dictReaderToCollection);
+	const nonDictCollection = lineReadersToCollection(readers.filter((a) => !isDictionaryReader(a)));
 	const collections = [...dictReaders, nonDictCollection];
 	return {
 		size: collections.reduce((s, a) => s + a.size, 0),
@@ -636,9 +639,9 @@ function dictReaderToCollection(reader) {
 		has: buildHasFn(reader)
 	};
 }
-function lineReadersToCollection(readers$1) {
+function lineReadersToCollection(readers) {
 	function* words() {
-		for (const reader of readers$1) yield* reader.lines;
+		for (const reader of readers) yield* reader.lines;
 	}
 	const dict = parseDictionary(words(), { stripCaseAndAccents: false });
 	return {
@@ -686,7 +689,7 @@ function isSingleLetter(c) {
 //#region src/compiler/splitCamelCaseIfAllowed.ts
 const regExpSpaceOrDash = /[- ]+/g;
 const regExpIsNumber = /^\d+$/;
-function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, minCompoundLength$1) {
+function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, minCompoundLength) {
 	const split = [...splitCamelCase(word)];
 	if (split.length === 1) return adjustCases(split, allowedWords, keepCase);
 	if (split.some((w) => isUnknown(w, allowedWords))) return [word];
@@ -694,7 +697,7 @@ function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, m
 	const adjusted = adjustCases(split, allowedWords, keepCase);
 	return !compoundPrefix ? adjusted : adjusted.map((w, i) => {
 		const { px, sx } = wordIndexes[i];
-		const canCompound = w.length >= minCompoundLength$1;
+		const canCompound = w.length >= minCompoundLength;
 		const lc = w.toLowerCase();
 		const p = canCompound && isSingleLetter(px) ? compoundPrefix : "";
 		const s = canCompound && isSingleLetter(sx) ? compoundPrefix : "";
@@ -718,7 +721,7 @@ function isUnknown(word, allowedWords) {
 	return !allowedWords.has(word, false);
 }
 function splitCamelCase(word) {
-	const splitWords = splitCamelCaseWord(word).filter((word$1) => !regExpIsNumber.test(word$1));
+	const splitWords = splitCamelCaseWord(word).filter((word) => !regExpIsNumber.test(word));
 	if (splitWords.length > 1 && regExpSpaceOrDash.test(word)) return splitWords.flatMap((w) => w.split(regExpSpaceOrDash));
 	return splitWords;
 }
@@ -807,7 +810,7 @@ const cSpellToolDirective = "cspell-tools:";
 */
 function createParseFileLineMapper(options) {
 	const _options = options || _defaultOptions;
-	const { splitKeepBoth = _defaultOptions.splitKeepBoth, allowedSplitWords = _defaultOptions.allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength: minCompoundLength$1 = _defaultOptions.minCompoundLength } = _options;
+	const { splitKeepBoth = _defaultOptions.splitKeepBoth, allowedSplitWords = _defaultOptions.allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength = _defaultOptions.minCompoundLength } = _options;
 	let { legacy = _defaultOptions.legacy } = _options;
 	let { split = _defaultOptions.split, keepCase = legacy ? false : _defaultOptions.keepCase } = _options;
 	const compoundFix = storeSplitWordsAsCompounds ? "+" : "";
@@ -866,7 +869,7 @@ 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$1);
+		return splitCamelCaseIfAllowed(word, allowedSplitWords, keepCase, compoundFix, minCompoundLength);
 	}
 	function* splitWords(lines) {
 		for (const line of lines) {
@@ -890,10 +893,10 @@ function createParseFileLineMapper(options) {
 			yield line;
 		}
 	}
-	function* splitLines$1(paragraphs) {
+	function* splitLines(paragraphs) {
 		for (const paragraph of paragraphs) yield* paragraph.split("\n");
 	}
-	return opCombine(opFilter(isString), splitLines$1, opMap(removeComments), splitWords, opMap(trim), opFilter(filterEmptyLines), unique);
+	return opCombine(opFilter(isString), splitLines, opMap(removeComments), splitWords, opMap(trim), opFilter(filterEmptyLines), unique);
 }
 /**
 * Normalizes a dictionary words based upon prefix / suffixes.
@@ -927,7 +930,7 @@ function splitLines(lines, options) {
 	return split();
 }
 async function textFileReader(reader, options) {
-	const { legacy, splitWords: split, allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength: minCompoundLength$1 } = options;
+	const { legacy, splitWords: split, allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength } = options;
 	const parseOptions = {
 		legacy,
 		split,
@@ -935,7 +938,7 @@ async function textFileReader(reader, options) {
 		keepCase: void 0,
 		allowedSplitWords,
 		storeSplitWordsAsCompounds,
-		minCompoundLength: minCompoundLength$1
+		minCompoundLength
 	};
 	const words = [...parseFileLines(reader.lines, parseOptions)];
 	return {
@@ -1031,7 +1034,7 @@ function* removeDuplicates(words) {
 		const sLcForms = new Set(lcForm);
 		yield* lcForm;
 		if (sLcForms.has("*" + lc + "*")) continue;
-		for (const forms$1 of mForms.values()) for (const form of forms$1) {
+		for (const forms of mForms.values()) for (const form of forms) {
 			if (sLcForms.has(form.toLowerCase())) continue;
 			yield form;
 		}
@@ -1044,14 +1047,14 @@ function* removeDuplicates(words) {
 * required_prefix+
 * required_suffix+
 */
-var Flags = /* @__PURE__ */ function(Flags$1) {
-	Flags$1[Flags$1["base"] = 0] = "base";
-	Flags$1[Flags$1["none"] = 1] = "none";
-	Flags$1[Flags$1["both"] = 2] = "both";
-	Flags$1[Flags$1["pfx"] = 4] = "pfx";
-	Flags$1[Flags$1["sfx"] = 8] = "sfx";
-	Flags$1[Flags$1["all"] = 15] = "all";
-	return Flags$1;
+var Flags = /* @__PURE__ */ function(Flags) {
+	Flags[Flags["base"] = 0] = "base";
+	Flags[Flags["none"] = 1] = "none";
+	Flags[Flags["both"] = 2] = "both";
+	Flags[Flags["pfx"] = 4] = "pfx";
+	Flags[Flags["sfx"] = 8] = "sfx";
+	Flags[Flags["all"] = 15] = "all";
+	return Flags;
 }(Flags || {});
 function applyFlags(word, flags) {
 	if (flags === Flags.none) return [word];
@@ -1096,22 +1099,22 @@ function removeDuplicateForms(forms) {
 		return [form, applyFlags(form, flag)];
 	}));
 }
-async function createTargetFile(destFilename, seq, compress$1) {
-	const rel$1 = path.relative(process.cwd(), destFilename).replaceAll(path.sep, "/");
-	getLogger()(`Writing to file ${rel$1}${compress$1 ? ".gz" : ""}`);
+async function createTargetFile(destFilename, seq, compress) {
+	const rel = path.relative(process.cwd(), destFilename).replaceAll(path.sep, "/");
+	getLogger()(`Writing to file ${rel}${compress ? ".gz" : ""}`);
 	await mkdirp(path.dirname(destFilename));
-	await writeTextToFile(destFilename, seq, compress$1);
+	await writeTextToFile(destFilename, seq, compress);
 }
 function createTrieCompiler(options) {
 	return (words) => {
-		const log$1 = getLogger();
-		log$1("Reading Words into Trie");
+		const log = getLogger();
+		log("Reading Words into Trie");
 		const base = options.base ?? 32;
 		const version = options.trie4 ? 4 : options.trie3 ? 3 : 1;
 		const root = Trie.buildTrie(words).root;
-		log$1("Reduce duplicate word endings");
+		log("Reduce duplicate word endings");
 		const trie = Trie.consolidate(root);
-		log$1("Trie compilation complete");
+		log("Trie compilation complete");
 		return Trie.serializeTrie(trie, {
 			base,
 			comment: "Built by cspell-tools.",
@@ -1160,27 +1163,45 @@ function resolveChecksumFile(checksumFile, root) {
 }
 async function compileTarget(target, options, compileOptions) {
 	logWithTimestamp(`Start compile: ${target.name}`);
-	const { rootDir, cwd, checksumFile, conditional } = compileOptions;
-	const { format, sources, trieBase, sort = true, generateNonStrict = false, excludeWordsFrom = [], excludeWordsNotFoundIn = [], excludeWordsMatchingRegex } = target;
+	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));
+	logWithTimestamp(`Done compile: ${target.name}`);
+	const checksumRoot = buildOptions.checksumRoot;
+	return [...deps].map((d) => path.relative(checksumRoot, d));
+}
+function genBuildTargetDictionaryOptions(target, compileOptions) {
+	const { rootDir, checksumFile, cwd } = compileOptions;
 	let targetDirectory = target.targetDirectory ?? cwd ?? process.cwd();
 	targetDirectory = targetDirectory.replace("${cwd}", cwd ?? process.cwd());
 	targetDirectory = path.resolve(rootDir, targetDirectory);
+	const name = normalizeTargetName(target.name);
+	const useTrie = target.format.startsWith("trie");
+	const generateCompressed = target.compress ?? false;
+	const generateUncompressed = target.keepUncompressed ?? false;
+	const generateOnlyCompressedDictionary = generateCompressed && !generateUncompressed;
+	return {
+		name,
+		filename: resolveTarget(name, targetDirectory, useTrie),
+		useTrie,
+		generateOnlyCompressedDictionary,
+		generateCompressed,
+		checksumRoot: checksumFile && path.dirname(checksumFile) || rootDir
+	};
+}
+async function buildTargetDictionary(target, options, compileOptions, buildOptions) {
+	const { rootDir, checksumFile, conditional } = compileOptions;
+	const { format, sources, trieBase, sort = true, generateNonStrict = false, excludeWordsFrom = [], excludeWordsNotFoundIn = [], excludeWordsMatchingRegex } = target;
+	const { filename, useTrie, generateOnlyCompressedDictionary, checksumRoot } = buildOptions;
 	const dictionaryDirectives = target.dictionaryDirectives ?? compileOptions.dictionaryDirectives;
-	const removeDuplicates$1 = target.removeDuplicates ?? false;
+	const removeDuplicates = target.removeDuplicates ?? false;
 	const excludeFromFilter = await createExcludeFilter(excludeWordsFrom);
 	const includeFromFilter = await createIncludeFilter(excludeWordsNotFoundIn);
 	const excludeRegexFilter = createExcludeRegexFilter(excludeWordsMatchingRegex);
 	const excludeFilter = (word) => {
 		return excludeFromFilter(word) && includeFromFilter(word) && excludeRegexFilter(word);
 	};
-	const name = normalizeTargetName(target.name);
-	const useTrie = format.startsWith("trie");
-	const generateCompressed = target.compress ?? false;
-	const generateUncompressed = target.keepUncompressed ?? false;
-	const genSet = /* @__PURE__ */ new Set();
-	genSet.add(generateCompressed);
-	if (generateUncompressed) genSet.add(false);
-	const filename = resolveTarget(name, targetDirectory, useTrie);
+	const compress = generateOnlyCompressedDictionary;
 	const filesToProcess = await toArray(pipeAsync(readSourceList(sources, rootDir), opMapAsync((src) => readFileSource(src, options)), opAwaitAsync()));
 	const normalizer = normalizeTargetWords({
 		sort: useTrie || sort,
@@ -1188,8 +1209,7 @@ async function compileTarget(target, options, compileOptions) {
 		filter: excludeFilter,
 		dictionaryDirectives
 	});
-	const checksumRoot = checksumFile && path.dirname(checksumFile) || rootDir;
-	const deps = [...calculateDependencies(filename + (generateCompressed ? ".gz" : ""), filesToProcess, [...excludeWordsFrom, ...excludeWordsNotFoundIn], checksumRoot)];
+	const deps = [...calculateDependencies(filename + (compress ? ".gz" : ""), filesToProcess, [...excludeWordsFrom, ...excludeWordsNotFoundIn], checksumRoot)];
 	if (conditional && checksumFile) {
 		if ((await checkShasumFile(checksumFile, deps, checksumRoot).catch(() => void 0))?.passed) {
 			logWithTimestamp(`Skip ${target.name}, nothing changed.`);
@@ -1197,7 +1217,7 @@ async function compileTarget(target, options, compileOptions) {
 		}
 	}
 	async function action(words, dst) {
-		const data = iterableToString(pipe(words, normalizer, useTrie ? createTrieCompiler({
+		await createTargetFile(dst, iterableToString(pipe(words, normalizer, useTrie ? createTrieCompiler({
 			base: trieBase,
 			trie3: format === "trie3",
 			trie4: format === "trie4"
@@ -1205,35 +1225,46 @@ async function compileTarget(target, options, compileOptions) {
 			sort,
 			generateNonStrict,
 			dictionaryDirectives,
-			removeDuplicates: removeDuplicates$1
-		})));
-		for (const compress$1 of genSet) await createTargetFile(dst, data, compress$1);
+			removeDuplicates
+		}))), compress);
 	}
 	await processFiles({
 		action,
 		filesToProcess,
 		mergeTarget: filename
 	});
-	if (target.bTrie) await generateBTrieFromFile(filename, {
-		compress: true,
-		optimize: true,
-		useStringTable: true,
-		...typeof target.bTrie === "object" ? target.bTrie : {}
-	});
-	logWithTimestamp(`Done compile: ${target.name}`);
 	return deps;
 }
-function calculateDependencies(targetFile, filesToProcess, extraDependencyFiles, rootDir) {
+async function compressDictionaryFileIfNeeded(buildOptions) {
+	const { filename, generateCompressed, generateOnlyCompressedDictionary } = buildOptions;
+	if (generateOnlyCompressedDictionary || !generateCompressed) return [];
+	logWithTimestamp(`Compress: ${filename}`);
+	return [filename, await compressFile(filename)];
+}
+async function genBTrieForTarget(target, buildOptions) {
+	if (!target.bTrie) return [];
+	const cfg = typeof target.bTrie === "object" ? target.bTrie : {};
+	const { filename, generateOnlyCompressedDictionary } = buildOptions;
+	const srcFilename = filename + (generateOnlyCompressedDictionary ? ".gz" : "");
+	logWithTimestamp(`Generate BTrie from: ${srcFilename}`);
+	return [srcFilename, await generateBTrieFromFile(srcFilename, {
+		compress: cfg.compress ?? true,
+		optimize: cfg.optimize ?? true,
+		useStringTable: cfg.useStringTable ?? true,
+		logger: logWithTimestamp
+	})];
+}
+function calculateDependencies(targetFile, filesToProcess, extraDependencyFiles, checksumRoot) {
 	const dependencies = /* @__PURE__ */ new Set();
 	addDependency(targetFile);
 	extraDependencyFiles?.forEach((f) => addDependency(f));
 	filesToProcess.forEach((f) => addDependency(f.src));
 	return dependencies;
 	function addDependency(filename) {
-		const rel$1 = path.relative(rootDir, filename);
-		dependencies.add(rel$1);
-		dependencies.add(rel$1.replace(/\.aff$/, ".dic"));
-		dependencies.add(rel$1.replace(/\.dic$/, ".aff"));
+		const abs = path.resolve(checksumRoot, filename);
+		dependencies.add(abs);
+		dependencies.add(abs.replace(/\.aff$/, ".dic"));
+		dependencies.add(abs.replace(/\.dic$/, ".aff"));
 	}
 }
 function rel(filePath) {
@@ -1288,7 +1319,7 @@ 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: minCompoundLength$1 } = fileSource;
+	const { filename, keepRawCase = sourceOptions.keepRawCase || false, split = sourceOptions.split || false, maxDepth, storeSplitWordsAsCompounds, minCompoundLength } = fileSource;
 	const legacy = split === "legacy";
 	const readerOptions = {
 		maxDepth,
@@ -1297,7 +1328,7 @@ async function readFileSource(fileSource, sourceOptions) {
 		keepCase: keepRawCase,
 		allowedSplitWords: await createAllowedSplitWordsFromFiles(fileSource.allowedSplitWords || sourceOptions.allowedSplitWords),
 		storeSplitWordsAsCompounds,
-		minCompoundLength: minCompoundLength$1
+		minCompoundLength
 	};
 	logWithTimestamp(`Reading ${path.basename(filename)}`);
 	const stream = await streamSourceWordsFromFile(filename, readerOptions);
@@ -1311,7 +1342,7 @@ function normalizeTargetName(name) {
 	return name.replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, "").replaceAll(/[^\p{L}\p{M}.\w\\/-]/gu, "_");
 }
 function logProgress(freq = 1e5) {
-	function* logProgress$1(iter) {
+	function* logProgress(iter) {
 		const _freq = freq;
 		let count = 0;
 		for (const v of iter) {
@@ -1320,7 +1351,7 @@ function logProgress(freq = 1e5) {
 			yield v;
 		}
 	}
-	return logProgress$1;
+	return logProgress;
 }
 /**
 * @param excludeWordsFrom - List of files to read words from.
@@ -1356,6 +1387,9 @@ function createExcludeRegexFilter(excludeWordsMatchingRegex) {
 function iterableToString(iter) {
 	return Array.isArray(iter) ? iter.join("") : [...iter].join("");
 }
+function addToSet(set, ...sources) {
+	for (const items of sources) for (const item of items) set.add(item);
+}
 
 //#endregion
 //#region src/build.ts
@@ -1400,4 +1434,4 @@ function normalizeRequest(buildInfo, root) {
 
 //#endregion
 export { reportCheckChecksumFile as a, toError as c, compressFile as d, logWithTimestamp as i, generateBTrie as l, compile as n, reportChecksumForFiles as o, setLogger as r, updateChecksumForFiles as s, build as t, OSFlags as u };
-//# sourceMappingURL=build-OgMPaXPZ.mjs.map
+//# sourceMappingURL=build-BGL2P0c2.mjs.map

package/dist/index.d.mts

@@ -1,5 +1,4 @@
 //#region src/config/config.d.ts
-
 interface BTrieOptions {
   /** compress the resulting file */
   compress?: boolean | undefined;
@@ -9,10 +8,14 @@ interface BTrieOptions {
   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

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { l as generateBTrie, t as build } from "./build-OgMPaXPZ.mjs";
+import { l as generateBTrie, t as build } from "./build-BGL2P0c2.mjs";
 
 export { build, generateBTrie };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspell/cspell-tools",
-  "version": "9.6.1",
+  "version": "9.6.3",
   "description": "Tools to assist with the development of cSpell",
   "publishConfig": {
     "access": "public",
@@ -64,12 +64,12 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-tools#readme",
   "dependencies": {
-    "@cspell/cspell-pipe": "9.6.1",
-    "commander": "^14.0.2",
+    "@cspell/cspell-pipe": "9.6.3",
+    "commander": "^14.0.3",
     "cosmiconfig": "9.0.0",
-    "cspell-trie-lib": "9.6.1",
+    "cspell-trie-lib": "9.6.3",
     "glob": "^13.0.0",
-    "hunspell-reader": "9.6.1",
+    "hunspell-reader": "9.6.3",
     "yaml": "^2.8.2"
   },
   "engines": {
@@ -80,5 +80,5 @@
     "ts-json-schema-generator": "^2.4.0"
   },
   "module": "bin.mjs",
-  "gitHead": "666fb79096d25c53af9519cad07030e7aca597e1"
+  "gitHead": "500b996b6c0a6ff025c42ef98db44776f43a9e72"
 }