@cspell/cspell-tools 9.5.0 → 9.6.0

package/dist/build-OgMPaXPZ.mjs

@@ -0,0 +1,1403 @@
+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 * 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 { 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
+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;
+}({});
+const OSSystemIDOffset = 9;
+async function compressFile(file, os) {
+	if (file.endsWith(".gz")) return file;
+	const targetFile = file + ".gz";
+	await writeFile(targetFile, await compress(await readFile(file), os));
+	return targetFile;
+}
+async function compress(buf, os) {
+	return fixOSSystemID(await gzip$1(buf), os);
+}
+/**
+* Compresses the data if it is not already compressed.
+* @param data
+* @returns
+*/
+async function compressIfNeeded(data) {
+	return isGZipped(data) ? data : compress(data);
+}
+/**
+* Checks if the data is GZipped.
+* @param data
+* @returns true if the data is GZipped
+*/
+function isGZipped(data) {
+	if (typeof data === "string") return false;
+	return data[0] === 31 && data[1] === 139;
+}
+function fixOSSystemID(zBuf, os = OSFlags.Unix) {
+	zBuf[OSSystemIDOffset] = os === OSFlags.auto ? zBuf[OSSystemIDOffset] : os;
+	return zBuf;
+}
+async function decompress(buf, encoding) {
+	const dBuf = gunzip$1(buf);
+	if (!encoding) return dBuf;
+	return (await dBuf).toString(encoding);
+}
+
+//#endregion
+//#region src/util/writeFile.ts
+/**
+* Writes a file to disk and compress as needed.
+*
+* Strings will be encoded as UTF-8.
+*
+* Compression logic:
+* - If the data is a string and the filePath and in `.gz` it is compressed.
+* - If the data is a Uint8Array and the filePath ends in `.gz` the first
+*
+* @param filePath - path to write the file to
+* @param data - data to write
+*/
+async function writeFile$1(filePath, data) {
+	const buf = typeof data === "string" ? new TextEncoder().encode(data) : data;
+	const toWrite = filePath.endsWith(".gz") ? await compressIfNeeded(buf) : buf;
+	return fs.writeFile(filePath, toWrite);
+}
+
+//#endregion
+//#region src/compiler/readers/regHunspellFile.ts
+const regHunspellFile = /\.(dic|aff)$/i;
+
+//#endregion
+//#region src/compiler/readers/readHunspellFiles.ts
+const DEDUPE_SIZE = 1e3;
+async function readHunspellFiles(filename, options) {
+	const dicFile = filename.replace(regHunspellFile, ".dic");
+	const affFile = filename.replace(regHunspellFile, ".aff");
+	const reader = await HR.IterableHunspellReader.createFromFiles(affFile, dicFile);
+	reader.maxDepth = options.maxDepth !== void 0 ? options.maxDepth : reader.maxDepth;
+	let trie;
+	function lines() {
+		return pipe(reader.seqAffWords(), _mapAffWords, dedupeAndSort);
+	}
+	return {
+		filename,
+		type: "Hunspell",
+		size: reader.dic.length,
+		get lines() {
+			return lines();
+		},
+		toTrie: () => {
+			if (trie) return trie;
+			trie = parseDictionary(lines(), {
+				stripCaseAndAccents: false,
+				optimize: true
+			});
+			return trie;
+		}
+	};
+}
+function* dedupeAndSort(words) {
+	const buffer = /* @__PURE__ */ new Set();
+	function flush() {
+		const result = [...buffer].sort();
+		buffer.clear();
+		return result;
+	}
+	for (const word of words) {
+		buffer.add(word);
+		if (buffer.size >= DEDUPE_SIZE) yield* flush();
+	}
+	yield* flush();
+}
+function* _mapAffWords(affWords) {
+	const hasSpecial = /[~+!]/;
+	for (const affWord of affWords) {
+		const { word, flags } = affWord;
+		if (hasSpecial.test(word)) continue;
+		const compound = flags.isCompoundForbidden ? "" : COMPOUND_FIX;
+		const forbid = flags.isForbiddenWord ? FORBID_PREFIX : "";
+		if (!forbid) {
+			if (flags.canBeCompoundBegin || flags.isCompoundPermitted) yield word + compound;
+			if (flags.canBeCompoundEnd || flags.isCompoundPermitted) yield compound + word;
+			if (flags.canBeCompoundMiddle || flags.isCompoundPermitted) yield compound + word + compound;
+			if (!flags.isOnlyAllowedInCompound) yield word;
+		} else yield forbid + word;
+	}
+}
+
+//#endregion
+//#region src/compiler/readers/readTextFile.ts
+const isGzFile$1 = /\.gz$/;
+function readTextFile(filename) {
+	return readFile$2(filename).then((buffer) => {
+		return new TextDecoder("utf-8").decode(buffer);
+	});
+}
+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
+async function textFileReader$1(filename) {
+	const words = (await readTextFile(filename)).split("\n").map((s) => s.trim());
+	let trie;
+	return {
+		filename,
+		type: "TextFile",
+		size: words.length,
+		lines: words,
+		toTrie: () => {
+			if (trie) return trie;
+			trie = parseDictionary(words, {
+				stripCaseAndAccents: false,
+				optimize: true
+			});
+			return trie;
+		}
+	};
+}
+
+//#endregion
+//#region src/compiler/readers/trieFileReader.ts
+async function trieFileReader(filename) {
+	return TrieFileReader.create(filename);
+}
+var TrieFileReader = class TrieFileReader {
+	#trie;
+	type = "Trie";
+	filename;
+	constructor(filename, trie) {
+		this.filename = filename;
+		this.#trie = trie;
+	}
+	get size() {
+		return this.#trie.size;
+	}
+	get lines() {
+		return this.#trie.words();
+	}
+	hasWord(word, caseSensitive) {
+		return this.#trie.hasWord(word, caseSensitive);
+	}
+	toTrie() {
+		return this.#trie;
+	}
+	static async create(filename) {
+		const rawBuffer = await readFile(filename);
+		return new TrieFileReader(filename, decodeTrie(filename.endsWith(".gz") ? gunzipSync(rawBuffer) : rawBuffer));
+	}
+};
+
+//#endregion
+//#region src/compiler/Reader.ts
+const readers = [
+	{
+		test: /\.trie\b/,
+		method: trieFileReader
+	},
+	{
+		test: /\.btrie\b/,
+		method: trieFileReader
+	},
+	{
+		test: regHunspellFile,
+		method: readHunspellFiles
+	}
+];
+function findMatchingReader(filename, options) {
+	for (const reader of readers) if (reader.test.test(filename)) return reader.method(filename, options);
+	return textFileReader$1(filename);
+}
+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
+async function generateBTrieFromFile(file, options) {
+	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}`);
+}
+async function generateBTrieFromFiles(files, options) {
+	console.log(`Generating BTrie for ${files.length} file(s).`);
+	for (const file of files) await generateBTrieFromFile(file, options);
+}
+function bTrieFileName(inputFilename, options) {
+	let filename = inputFilename;
+	filename = filename.replace(/\.gz$/i, "");
+	filename = filename.replace(/\.(aff|dic|txt|b?trie)$/i, "");
+	filename = filename + `.btrie`;
+	if (options.compress) filename += ".gz";
+	if (options.output) {
+		const base = fsPath.basename(filename);
+		filename = fsPath.join(fsPath.resolve(options.output), base);
+	}
+	return filename;
+}
+async function createBTrieFromFile(file, buildOptions) {
+	return encodeTrieDataToBTrie((await createReader(file, {})).toTrie().data, buildOptions);
+}
+
+//#endregion
+//#region src/bTrie.ts
+function generateBTrie(files, options) {
+	return generateBTrieFromFiles(files, options);
+}
+
+//#endregion
+//#region src/config/configUtils.ts
+function isFilePath(source) {
+	return typeof source === "string";
+}
+function isFileSource(source) {
+	if (!source || isFilePath(source)) return false;
+	return source.filename !== void 0;
+}
+function isFileListSource(source) {
+	if (!source || isFilePath(source)) return false;
+	return source.listFile !== void 0;
+}
+
+//#endregion
+//#region src/config/normalizeConfig.ts
+function normalizeConfig(cfg) {
+	if (!cfg) return cfg;
+	const dir = path.dirname(cfg.filepath);
+	const config = cfg.config;
+	return {
+		config: {
+			...config,
+			rootDir: path.resolve(dir, config.rootDir || ".")
+		},
+		filepath: cfg.filepath
+	};
+}
+
+//#endregion
+//#region src/shasum/checksum.ts
+function calcChecksum(buf, alg = "SHA1") {
+	const hash = createHash(alg);
+	hash.update(buf);
+	return hash.digest("hex");
+}
+async function calcFileChecksum(filename, alg) {
+	return calcChecksum(await readFile(filename), alg);
+}
+async function checkFile(checksum, filename, alg) {
+	return await calcFileChecksum(filename, alg) === checksum;
+}
+
+//#endregion
+//#region src/util/errors.ts
+function toError(err) {
+	if (isError(err)) return err;
+	return /* @__PURE__ */ new Error(`${err}`);
+}
+function isError(err) {
+	if (err instanceof Error) return true;
+	return false;
+}
+
+//#endregion
+//#region src/util/index.ts
+function isDefined$1(a) {
+	return !!a || a !== null && a !== void 0;
+}
+
+//#endregion
+//#region src/shasum/shasum.ts
+async function shasumFile(filename, root) {
+	try {
+		return `${await calcFileChecksum(resolve(root || ".", filename))}  ${filename}`;
+	} catch {
+		return Promise.reject(`shasum: ${filename}: Unable to read file.`);
+	}
+}
+/**
+*
+* @param filename - name of checksum file
+* @param files - optional list of files to check
+* @param root - optional root, default cwd.
+*/
+async function checkShasumFile(filename, files, root) {
+	files = !files ? files : files.length ? files : void 0;
+	const shaFiles = await readAndParseShasumFile(filename);
+	const filesToCheck = !files ? shaFiles.map(({ filename: filename$1 }) => filename$1) : files;
+	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));
+	}));
+	return {
+		passed: !results.some((v) => !v.passed),
+		results
+	};
+}
+async function tryToCheckFile(filename, root, checksum) {
+	if (!checksum) return {
+		filename,
+		passed: false,
+		error: /* @__PURE__ */ new Error("Missing Checksum.")
+	};
+	const file = resolve(root, filename);
+	try {
+		return {
+			filename,
+			passed: await checkFile(checksum, file)
+		};
+	} catch {
+		return {
+			filename,
+			passed: false,
+			error: /* @__PURE__ */ new Error("Failed to read file.")
+		};
+	}
+}
+const regLine = /([a-f0-9]{40,}) {2}(.*)/;
+async function readAndParseShasumFile(filename) {
+	return parseShasumFile(await readFile(resolve(filename), "utf8"));
+}
+function parseShasumFile(content) {
+	return content.split(/\r?\n|\r/g).map(parseLine).filter(isDefined$1);
+	function parseLine(line, index) {
+		const m = line.match(regLine);
+		const lineNumber = index + 1;
+		if (!m) {
+			if (line.trim()) throw new Error(`Failed to parse line ${lineNumber} of checksum file.`);
+			return;
+		}
+		return {
+			checksum: m[1],
+			filename: m[2],
+			lineNumber
+		};
+	}
+}
+async function reportChecksumForFiles(files, options) {
+	const root = options.root;
+	const filesToCheck = await resolveFileList(files, options.listFile);
+	let numFailed = 0;
+	return {
+		report: (await Promise.all(filesToCheck.map((file) => shasumFile(file, root).catch((e) => {
+			++numFailed;
+			if (typeof e !== "string") throw e;
+			return e;
+		})))).join("\n"),
+		passed: !numFailed
+	};
+}
+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 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`);
+	return {
+		report: lines.join("\n"),
+		passed
+	};
+}
+async function resolveFileList(files, listFile) {
+	files = files || [];
+	listFile = listFile || [];
+	const setOfFiles = new Set(files);
+	const pending = listFile.map((filename) => readFile(filename, "utf8"));
+	for await (const content of pending) content.split("\n").map((a) => a.trim()).filter((a) => a).forEach((file) => setOfFiles.add(file));
+	return [...setOfFiles].map(normalizeFilename);
+}
+async function calcUpdateChecksumForFiles(filename, files, options) {
+	const root = options.root || ".";
+	const filesToCheck = await resolveFileList(files, options.listFile);
+	const currentEntries = (await readAndParseShasumFile(filename).catch((err) => {
+		const e = toError(err);
+		if (e.code !== "ENOENT") throw e;
+		return [];
+	})).map((entry) => ({
+		...entry,
+		filename: normalizeFilename(entry.filename)
+	}));
+	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]));
+	for (const file of entriesToUpdate) try {
+		const checksum = await calcFileChecksum(resolve(root, file));
+		checksumMap.set(file, checksum);
+	} catch (e) {
+		if (mustExist.has(file) || toError(e).code !== "ENOENT") throw e;
+		checksumMap.delete(file);
+	}
+	return [...checksumMap].map(([filename$1, checksum]) => ({
+		filename: filename$1,
+		checksum
+	})).sort((a, b) => a.filename < b.filename ? -1 : 1).map((e) => `${e.checksum}  ${e.filename}`).join("\n") + "\n";
+}
+async function updateChecksumForFiles(filename, files, options) {
+	const content = await calcUpdateChecksumForFiles(filename, files, options);
+	await writeFile(filename, content);
+	return {
+		passed: true,
+		report: content
+	};
+}
+function normalizeFilename(filename) {
+	return filename.split(sep).join("/");
+}
+
+//#endregion
+//#region src/util/textRegex.ts
+const regExMatchRegExParts = /^\s*\/([\s\S]*?)\/([gimuxy]*)\s*$/;
+function stringToRegExp(pattern, defaultFlags = "", forceFlags = "") {
+	if (pattern instanceof RegExp) return pattern;
+	try {
+		const [, pat, flag] = [...pattern.match(regExMatchRegExParts) || [
+			"",
+			pattern.trim(),
+			defaultFlags
+		], forceFlags];
+		if (pat) {
+			const regPattern = flag.includes("x") ? removeVerboseFromRegExp(pat) : pat;
+			const flags = [...new Set(forceFlags + flag)].join("").replaceAll(/[^gimuy]/g, "");
+			return new RegExp(regPattern, flags);
+		}
+	} catch {}
+}
+const SPACES = {
+	" ": true,
+	"\n": true,
+	"\r": true,
+	"	": true
+};
+/**
+* Remove all whitespace and comments from a regexp string. The format follows Pythons Verbose.
+* Note: this is a best attempt. Special cases for comments: `#` and spaces should be proceeded with a `\`
+*
+* All space must be proceeded by a `\` or in a character class `[]`
+*
+* @param pattern - the pattern to clean
+*/
+function removeVerboseFromRegExp(pattern) {
+	function escape(acc) {
+		if (pattern[acc.idx] !== "\\") return void 0;
+		const next = pattern[++acc.idx];
+		acc.idx++;
+		if (next === "#") {
+			acc.result += "#";
+			return acc;
+		}
+		if (!(next in SPACES)) {
+			acc.result += "\\" + next;
+			return acc;
+		}
+		acc.result += next;
+		if (next === "\r" && pattern[acc.idx] === "\n") {
+			acc.result += "\n";
+			acc.idx++;
+		}
+		return acc;
+	}
+	function braces(acc) {
+		const char = pattern[acc.idx];
+		if (char !== "[") return void 0;
+		acc.result += char;
+		acc.idx++;
+		let escCount = 0;
+		while (acc.idx < pattern.length) {
+			const char$1 = pattern[acc.idx];
+			acc.result += char$1;
+			acc.idx++;
+			if (char$1 === "]" && !(escCount & 1)) break;
+			escCount = char$1 === "\\" ? escCount + 1 : 0;
+		}
+		return acc;
+	}
+	function spaces(acc) {
+		if (!(pattern[acc.idx] in SPACES)) return void 0;
+		acc.idx++;
+		return acc;
+	}
+	function comments(acc) {
+		if (pattern[acc.idx] !== "#") return void 0;
+		while (acc.idx < pattern.length && pattern[acc.idx] !== "\n") acc.idx++;
+		return acc;
+	}
+	function copy(acc) {
+		const char = pattern[acc.idx++];
+		acc.result += char;
+		return acc;
+	}
+	const reducers = [
+		escape,
+		braces,
+		spaces,
+		comments,
+		copy
+	];
+	const result = {
+		idx: 0,
+		result: ""
+	};
+	while (result.idx < pattern.length) for (const r of reducers) if (r(result)) break;
+	return result.result;
+}
+
+//#endregion
+//#region src/compiler/WordsCollection.ts
+const defaultAllowedSplitWords = Object.freeze({
+	size: 0,
+	has: () => true
+});
+const defaultExcludeWordsCollection = Object.freeze({
+	size: 0,
+	has: () => false
+});
+
+//#endregion
+//#region src/compiler/createWordsCollection.ts
+var AllowedSplitWordsImpl = class {
+	collection;
+	size;
+	constructor(collection) {
+		this.collection = collection;
+		this.size = collection.size;
+	}
+	has(word, caseSensitive) {
+		return !this.size || this.collection.has(word, caseSensitive);
+	}
+};
+async function createAllowedSplitWordsFromFiles(files) {
+	if (!files || !files.length) return defaultAllowedSplitWords;
+	return new AllowedSplitWordsImpl(await createWordsCollectionFromFiles(files));
+}
+function buildHasFn(dict) {
+	function has(word, caseSensitive) {
+		const r = dict.hasWord(word, true);
+		if (r || caseSensitive) return r;
+		const lc = word.toLowerCase();
+		if (lc === word) return false;
+		return dict.hasWord(lc, true);
+	}
+	return has;
+}
+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)));
+	const collections = [...dictReaders, nonDictCollection];
+	return {
+		size: collections.reduce((s, a) => s + a.size, 0),
+		has: (word, caseSensitive) => collections.some((a) => a.has(word, caseSensitive))
+	};
+}
+const cache = /* @__PURE__ */ new WeakMap();
+async function createWordsCollectionFromFiles(files) {
+	files = toFilePathArray(files);
+	const cached = cache.get(files);
+	if (cached) return cached;
+	const collection = readersToCollection(await Promise.all(files.map((file) => readFile$1(file))));
+	cache.set(files, collection);
+	return collection;
+}
+function isDictionaryReader(reader) {
+	return "hasWord" in reader && !!reader.hasWord;
+}
+function dictReaderToCollection(reader) {
+	return {
+		size: reader.size,
+		has: buildHasFn(reader)
+	};
+}
+function lineReadersToCollection(readers$1) {
+	function* words() {
+		for (const reader of readers$1) yield* reader.lines;
+	}
+	const dict = parseDictionary(words(), { stripCaseAndAccents: false });
+	return {
+		size: dict.size,
+		has: buildHasFn(dict)
+	};
+}
+function toFilePathArray(filePathOrArray) {
+	return Array.isArray(filePathOrArray) ? filePathOrArray : [filePathOrArray];
+}
+
+//#endregion
+//#region src/compiler/logWithTimestamp.ts
+const logWithTimestamp = (message, ...optionalParams) => {
+	console.log(`${(/* @__PURE__ */ new Date()).toISOString()} ${message}`, ...optionalParams);
+};
+
+//#endregion
+//#region 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
+const regExpSpaceOrDash = /[- ]+/g;
+const regExpIsNumber = /^\d+$/;
+function splitCamelCaseIfAllowed(word, allowedWords, keepCase, compoundPrefix, minCompoundLength$1) {
+	const split = [...splitCamelCase(word)];
+	if (split.length === 1) return adjustCases(split, allowedWords, keepCase);
+	if (split.some((w) => isUnknown(w, allowedWords))) return [word];
+	const wordIndexes = calcWordIndex(word, split);
+	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 lc = w.toLowerCase();
+		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 adjustCase(word, allowedWords, keepCase) {
+	const lc = word.toLowerCase();
+	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();
+	return word;
+}
+function isUnknown(word, allowedWords) {
+	if (word === "ERROR") return !allowedWords.has(word, false);
+	return !allowedWords.has(word, false);
+}
+function splitCamelCase(word) {
+	const splitWords = splitCamelCaseWord(word).filter((word$1) => !regExpIsNumber.test(word$1));
+	if (splitWords.length > 1 && regExpSpaceOrDash.test(word)) return splitWords.flatMap((w) => w.split(regExpSpaceOrDash));
+	return splitWords;
+}
+function calcWordIndex(word, words) {
+	let i = 0;
+	return words.map((w) => {
+		const j = word.indexOf(w, i);
+		const k = j + w.length;
+		const wIndex = {
+			word: w,
+			i: j,
+			px: word[j - 1] || "",
+			sx: word[k] || ""
+		};
+		i = k;
+		return wIndex;
+	});
+}
+
+//#endregion
+//#region 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) {
+	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)));
+}
+
+//#endregion
+//#region src/compiler/wordListParser.ts
+function normalizeTargetWords(options) {
+	const lineParser = createDictionaryLineParser({
+		stripCaseAndAccents: options.generateNonStrict,
+		stripCaseAndAccentsOnForbidden: true,
+		keepOptionalCompoundCharacter: true
+	});
+	return opCombine(...[
+		opFilter((a) => !!a),
+		lineParser,
+		options.sort ? createInlineBufferedSort(1e4) : void 0,
+		opFilter(uniqueFilter(1e4)),
+		options.filter ? opFilter(options.filter) : void 0
+	].filter(isDefined));
+}
+function isDefined(v) {
+	return v !== void 0;
+}
+function createInlineBufferedSort(bufferSize = 1e3) {
+	function* inlineBufferedSort(lines) {
+		const buffer = [];
+		for (const line of lines) {
+			buffer.push(line);
+			if (buffer.length >= bufferSize) {
+				buffer.sort();
+				yield* buffer;
+				buffer.length = 0;
+			}
+		}
+		buffer.sort();
+		yield* buffer;
+	}
+	return inlineBufferedSort;
+}
+const commentCharacter = "#";
+const _defaultOptions = {
+	keepCase: true,
+	legacy: false,
+	split: false,
+	splitKeepBoth: false,
+	allowedSplitWords: {
+		has: () => true,
+		size: 0
+	},
+	storeSplitWordsAsCompounds: defaultCompileSourceOptions.storeSplitWordsAsCompounds,
+	minCompoundLength: defaultCompileSourceOptions.minCompoundLength
+};
+const defaultParseDictionaryOptions = Object.freeze(_defaultOptions);
+const cSpellToolDirective = "cspell-tools:";
+/**
+* Normalizes a dictionary words based upon prefix / suffixes.
+* Case insensitive versions are also generated.
+* @param options - defines prefixes used when parsing lines.
+* @returns words that have been normalized.
+*/
+function createParseFileLineMapper(options) {
+	const _options = options || _defaultOptions;
+	const { splitKeepBoth = _defaultOptions.splitKeepBoth, allowedSplitWords = _defaultOptions.allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength: minCompoundLength$1 = _defaultOptions.minCompoundLength } = _options;
+	let { legacy = _defaultOptions.legacy } = _options;
+	let { split = _defaultOptions.split, keepCase = legacy ? false : _defaultOptions.keepCase } = _options;
+	const compoundFix = storeSplitWordsAsCompounds ? "+" : "";
+	function isString(line) {
+		return typeof line === "string";
+	}
+	function trim(line) {
+		return line.trim();
+	}
+	function removeComments(line) {
+		const idx = line.indexOf(commentCharacter);
+		if (idx < 0) return line;
+		const idxDirective = line.indexOf(cSpellToolDirective, idx);
+		if (idxDirective >= 0) {
+			const flags = line.slice(idxDirective).split(/[\s,;]/g).map((s) => s.trim()).filter((a) => !!a);
+			for (const flag of flags) switch (flag) {
+				case "split":
+					split = true;
+					break;
+				case "no-split":
+					split = false;
+					break;
+				case "keep-case":
+					keepCase = true;
+					legacy = false;
+					break;
+				case "no-keep-case":
+					keepCase = false;
+					break;
+				case "legacy":
+					keepCase = false;
+					legacy = true;
+					break;
+			}
+		}
+		return line.slice(0, idx).trim();
+	}
+	function filterEmptyLines(line) {
+		return !!line;
+	}
+	const regNonWordOrDigit = /[^\p{L}\p{M}'\w-]+/giu;
+	function splitLine(line) {
+		line = line.replace(/#.*/, "");
+		line = line.trim();
+		line = line.replaceAll(/\bU\+[0-9A-F]{4}\b/gi, "|");
+		line = line.replaceAll(/\\U[0-9A-F]{4}/gi, "|");
+		line = line.replaceAll(regNonWordOrDigit, "|");
+		line = line.replaceAll(/'(?=\|)/g, "");
+		line = line.replace(/'$/, "");
+		line = line.replaceAll(/(?<=\|)'/g, "");
+		line = line.replace(/^'/, "");
+		line = line.replaceAll(/\s*\|\s*/g, "|");
+		line = line.replaceAll(/[|]+/g, "|");
+		line = line.replace(/^\|/, "");
+		line = line.replace(/\|$/, "");
+		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);
+	}
+	function* splitWords(lines) {
+		for (const line of lines) {
+			if (legacy) {
+				yield* legacyLineToWords(line, keepCase, allowedSplitWords);
+				continue;
+			}
+			if (split) {
+				const words = splitLine(line);
+				yield* !allowedSplitWords.size ? words : words.flatMap((word) => splitWordIntoWords(word));
+				if (!splitKeepBoth) continue;
+			}
+			yield line.replaceAll(/["]/g, "");
+		}
+	}
+	function* unique(lines) {
+		const known = /* @__PURE__ */ new Set();
+		for (const line of lines) {
+			if (known.has(line)) continue;
+			known.add(line);
+			yield line;
+		}
+	}
+	function* splitLines$1(paragraphs) {
+		for (const paragraph of paragraphs) yield* paragraph.split("\n");
+	}
+	return opCombine(opFilter(isString), splitLines$1, opMap(removeComments), splitWords, opMap(trim), opFilter(filterEmptyLines), unique);
+}
+/**
+* Normalizes a dictionary words based upon prefix / suffixes.
+* Case insensitive versions are also generated.
+* @param lines - one word per line
+* @param _options - defines prefixes used when parsing lines.
+* @returns words that have been normalized.
+*/
+function parseFileLines(lines, options) {
+	return createParseFileLineMapper(options)(typeof lines === "string" ? [lines] : lines);
+}
+
+//#endregion
+//#region src/compiler/SourceReader.ts
+async function createSourceReader(filename, options) {
+	const reader = await createReader(filename, options);
+	if (reader.type !== "TextFile") return {
+		words: splitLines(reader.lines, options),
+		get size() {
+			return reader.size;
+		}
+	};
+	return textFileReader(reader, options);
+}
+function splitLines(lines, options) {
+	if (!options.splitWords) return lines;
+	function* split() {
+		const regNonWordOrDigit = /[^\p{L}\p{M}'\w-]+/giu;
+		for (const line of lines) yield* line.split(regNonWordOrDigit);
+	}
+	return split();
+}
+async function textFileReader(reader, options) {
+	const { legacy, splitWords: split, allowedSplitWords, storeSplitWordsAsCompounds, minCompoundLength: minCompoundLength$1 } = options;
+	const parseOptions = {
+		legacy,
+		split,
+		splitKeepBoth: void 0,
+		keepCase: void 0,
+		allowedSplitWords,
+		storeSplitWordsAsCompounds,
+		minCompoundLength: minCompoundLength$1
+	};
+	const words = [...parseFileLines(reader.lines, parseOptions)];
+	return {
+		size: words.length,
+		words
+	};
+}
+
+//#endregion
+//#region src/compiler/streamSourceWordsFromFile.ts
+async function streamSourceWordsFromFile(filename, options) {
+	return (await createSourceReader(filename, options)).words;
+}
+
+//#endregion
+//#region src/compiler/logger.ts
+const defaultLogger = console.log;
+let log = defaultLogger;
+function setLogger(logger) {
+	log = logger ?? defaultLogger;
+}
+function getLogger() {
+	return log;
+}
+
+//#endregion
+//#region 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("");
+	const hasGzExt = isGzFile.test(filename);
+	const useGz = useGzCompress ?? hasGzExt;
+	if (useGz && !hasGzExt) filename += ".gz";
+	const buf = Buffer.from(dataStr, "utf8");
+	const buffer = useGz ? await compress(buf) : buf;
+	await promises.writeFile(filename, buffer);
+}
+
+//#endregion
+//#region src/compiler/wordListCompiler.ts
+const mkdirp = async (p) => {
+	await mkdir(p, { recursive: true });
+};
+const wordListHeader = `
+# cspell-tools: keep-case no-split`;
+const wordListHeaderLines = wordListHeader.split("\n").map((a) => a.trim());
+function createWordListCompiler(options) {
+	return (lines) => {
+		const finalLines = normalize(lines, options);
+		const directivesLines = (options.dictionaryDirectives ?? []).map((a) => `# cspell-dictionary: ${a}`);
+		return pipe([
+			...wordListHeaderLines,
+			...directivesLines,
+			""
+		], opAppend(finalLines), opMap((a) => a + "\n"));
+	};
+}
+function normalize(lines, options) {
+	const filter = normalizeTargetWords(options);
+	const iter = pipe(options.removeDuplicates ? removeDuplicates(lines) : lines, filter);
+	if (!options.sort) return iter;
+	return [...new Set(iter)].sort();
+}
+function stripCompoundAFix(word) {
+	return word.replaceAll("*", "").replaceAll("+", "");
+}
+function* removeDuplicates(words) {
+	const wordSet = new Set(words);
+	const wordForms = /* @__PURE__ */ new Map();
+	for (const word of wordSet) {
+		const lc = stripCompoundAFix(word.toLowerCase());
+		const forms = wordForms.get(lc) ?? [];
+		forms.push(word);
+		wordForms.set(lc, forms);
+	}
+	for (const forms of wordForms.values()) {
+		if (forms.length <= 1) {
+			yield* forms;
+			continue;
+		}
+		const mForms = removeDuplicateForms(forms);
+		if (mForms.size <= 1) {
+			for (const form of mForms.values()) yield* form;
+			continue;
+		}
+		const lc = [...mForms.keys()][0].toLowerCase();
+		const lcForm = mForms.get(lc);
+		if (!lcForm) {
+			for (const form of mForms.values()) yield* form;
+			continue;
+		}
+		mForms.delete(lc);
+		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) {
+			if (sLcForms.has(form.toLowerCase())) continue;
+			yield form;
+		}
+	}
+}
+/**
+* solo
+* optional_prefix*
+* optional_suffix*
+* 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;
+}(Flags || {});
+function applyFlags(word, flags) {
+	if (flags === Flags.none) return [word];
+	if (flags === Flags.all) return ["*" + word + "*"];
+	if (flags === Flags.both) return ["+" + word + "+"];
+	if (flags === Flags.pfx) return [word + "+"];
+	if (flags === Flags.sfx) return ["+" + word];
+	if (flags === (Flags.none | Flags.sfx)) return ["*" + word];
+	if (flags === (Flags.none | Flags.pfx)) return [word + "*"];
+	if (flags === (Flags.none | Flags.pfx | Flags.sfx)) return [word + "*", "*" + word];
+	if (flags === (Flags.none | Flags.both)) return ["*" + word + "*"];
+	if (flags === (Flags.none | Flags.both | Flags.sfx)) return [word, "+" + word + "*"];
+	if (flags === (Flags.none | Flags.both | Flags.pfx)) return [word, "*" + word + "+"];
+	if (flags === (Flags.both | Flags.pfx)) return ["*" + word + "+"];
+	if (flags === (Flags.both | Flags.sfx)) return ["+" + word + "*"];
+	if (flags === (Flags.both | Flags.pfx | Flags.sfx)) return ["+" + word + "*", "*" + word + "+"];
+	return ["+" + word, word + "+"];
+}
+function removeDuplicateForms(forms) {
+	function flags(word, flag = 0) {
+		const canBePrefix = word.endsWith("*");
+		const mustBePrefix = !canBePrefix && word.endsWith("+");
+		const isPrefix = canBePrefix || mustBePrefix;
+		const canBeSuffix = word.startsWith("*");
+		const mustBeSuffix = !canBeSuffix && word.startsWith("+");
+		const isSuffix = canBeSuffix || mustBeSuffix;
+		if (canBePrefix && canBeSuffix) return flag | Flags.all;
+		if (mustBePrefix && mustBeSuffix) return flag | Flags.both;
+		if (!isPrefix && !isSuffix) return flag | Flags.none;
+		flag |= isPrefix && !isSuffix ? Flags.pfx : 0;
+		flag |= isSuffix && !isPrefix ? Flags.sfx : 0;
+		flag |= canBePrefix && !mustBeSuffix ? Flags.none : 0;
+		flag |= canBeSuffix && !mustBePrefix ? Flags.none : 0;
+		return flag;
+	}
+	const m = /* @__PURE__ */ new Map();
+	for (const form of forms) {
+		const k = stripCompoundAFix(form);
+		m.set(k, flags(form, m.get(k)));
+	}
+	return new Map([...m.entries()].map(([form, flag]) => {
+		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" : ""}`);
+	await mkdirp(path.dirname(destFilename));
+	await writeTextToFile(destFilename, seq, compress$1);
+}
+function createTrieCompiler(options) {
+	return (words) => {
+		const log$1 = getLogger();
+		log$1("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");
+		const trie = Trie.consolidate(root);
+		log$1("Trie compilation complete");
+		return Trie.serializeTrie(trie, {
+			base,
+			comment: "Built by cspell-tools.",
+			version
+		});
+	};
+}
+
+//#endregion
+//#region src/compiler/compile.ts
+async function compile(request, options) {
+	const { targets } = request;
+	const rootDir = path.resolve(request.rootDir || ".");
+	const cwd = options?.cwd;
+	const targetOptions = {
+		sort: request.sort,
+		generateNonStrict: request.generateNonStrict,
+		removeDuplicates: request.removeDuplicates
+	};
+	const conditional = options?.conditionalBuild || false;
+	const checksumFile = resolveChecksumFile(request.checksumFile || conditional, rootDir);
+	const dictionaryDirectives = request.dictionaryDirectives;
+	const dependencies = /* @__PURE__ */ new Set();
+	for (const target of targets) {
+		if (!(options?.filter?.(target) ?? true)) continue;
+		(await compileTarget({
+			...targetOptions,
+			...target
+		}, request, {
+			rootDir,
+			cwd,
+			conditional,
+			checksumFile,
+			dictionaryDirectives
+		})).forEach((dep) => dependencies.add(dep));
+	}
+	if (checksumFile && dependencies.size) {
+		logWithTimestamp("%s", `Update checksum: ${checksumFile}`);
+		await updateChecksumForFiles(checksumFile, [...dependencies], { root: path.dirname(checksumFile) });
+	}
+	logWithTimestamp(`Complete.`);
+}
+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) {
+	logWithTimestamp(`Start compile: ${target.name}`);
+	const { rootDir, cwd, checksumFile, conditional } = compileOptions;
+	const { format, sources, trieBase, sort = true, generateNonStrict = false, excludeWordsFrom = [], excludeWordsNotFoundIn = [], excludeWordsMatchingRegex } = target;
+	let targetDirectory = target.targetDirectory ?? cwd ?? process.cwd();
+	targetDirectory = targetDirectory.replace("${cwd}", cwd ?? process.cwd());
+	targetDirectory = path.resolve(rootDir, targetDirectory);
+	const dictionaryDirectives = target.dictionaryDirectives ?? compileOptions.dictionaryDirectives;
+	const removeDuplicates$1 = 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 filesToProcess = await toArray(pipeAsync(readSourceList(sources, rootDir), opMapAsync((src) => readFileSource(src, options)), opAwaitAsync()));
+	const normalizer = normalizeTargetWords({
+		sort: useTrie || sort,
+		generateNonStrict,
+		filter: excludeFilter,
+		dictionaryDirectives
+	});
+	const checksumRoot = checksumFile && path.dirname(checksumFile) || rootDir;
+	const deps = [...calculateDependencies(filename + (generateCompressed ? ".gz" : ""), filesToProcess, [...excludeWordsFrom, ...excludeWordsNotFoundIn], checksumRoot)];
+	if (conditional && checksumFile) {
+		if ((await checkShasumFile(checksumFile, deps, checksumRoot).catch(() => void 0))?.passed) {
+			logWithTimestamp(`Skip ${target.name}, nothing changed.`);
+			return [];
+		}
+	}
+	async function action(words, dst) {
+		const data = iterableToString(pipe(words, normalizer, useTrie ? createTrieCompiler({
+			base: trieBase,
+			trie3: format === "trie3",
+			trie4: format === "trie4"
+		}) : createWordListCompiler({
+			sort,
+			generateNonStrict,
+			dictionaryDirectives,
+			removeDuplicates: removeDuplicates$1
+		})));
+		for (const compress$1 of genSet) await createTargetFile(dst, data, compress$1);
+	}
+	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) {
+	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"));
+	}
+}
+function rel(filePath) {
+	return path.relative(process.cwd(), filePath);
+}
+async function processFiles({ action, filesToProcess, mergeTarget }) {
+	const toProcess = filesToProcess;
+	const dst = mergeTarget;
+	await action(pipe(toProcess, opMap((ftp) => {
+		const { src } = ftp;
+		logWithTimestamp("Process \"%s\" to \"%s\"", rel(src), rel(dst));
+		return ftp;
+	}), opConcatMap(function* (ftp) {
+		yield* ftp.words;
+		logWithTimestamp("Done processing %s", rel(ftp.src));
+	}), logProgress()), dst);
+	logWithTimestamp("Done \"%s\"", rel(dst));
+}
+function resolveTarget(name, directory, useTrie) {
+	const filename = name + (useTrie && ".trie" || ".txt");
+	return path.resolve(directory, filename);
+}
+function readSourceList(sources, rootDir) {
+	async function* mapSrc() {
+		for (const src of sources) {
+			if (isFilePath(src)) {
+				yield { filename: path.resolve(rootDir, src) };
+				continue;
+			}
+			if (isFileSource(src)) {
+				yield {
+					...src,
+					filename: path.resolve(rootDir, src.filename)
+				};
+				continue;
+			}
+			if (isFileListSource(src)) {
+				const { listFile, ...rest } = src;
+				const absListFile = path.resolve(rootDir, listFile);
+				const listFileDir = path.dirname(absListFile);
+				const files = await readFileList(absListFile);
+				for (const filename of files) yield {
+					...rest,
+					filename: path.resolve(listFileDir, filename)
+				};
+			}
+		}
+	}
+	return mapSrc();
+}
+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 legacy = split === "legacy";
+	const readerOptions = {
+		maxDepth,
+		legacy,
+		splitWords: legacy ? false : split,
+		keepCase: keepRawCase,
+		allowedSplitWords: await createAllowedSplitWordsFromFiles(fileSource.allowedSplitWords || sourceOptions.allowedSplitWords),
+		storeSplitWordsAsCompounds,
+		minCompoundLength: minCompoundLength$1
+	};
+	logWithTimestamp(`Reading ${path.basename(filename)}`);
+	const stream = await streamSourceWordsFromFile(filename, readerOptions);
+	logWithTimestamp(`Done reading ${path.basename(filename)}`);
+	return {
+		src: filename,
+		words: stream
+	};
+}
+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) {
+		const _freq = freq;
+		let count = 0;
+		for (const v of iter) {
+			++count;
+			if (!(count % _freq)) logWithTimestamp("Progress: Words Processed - %s", count.toLocaleString());
+			yield v;
+		}
+	}
+	return logProgress$1;
+}
+/**
+* @param excludeWordsFrom - List of files to read words from.
+* @returns a function that returns true if the word is not in the exclude list.
+*/
+async function createExcludeFilter(excludeWordsFrom) {
+	if (!excludeWordsFrom || !excludeWordsFrom.length) return () => true;
+	const excludeWords = await createWordsCollectionFromFiles(excludeWordsFrom);
+	return (word) => !excludeWords.has(word, word.toUpperCase() !== word);
+}
+/**
+* @param includeWordsFrom - List of files to read words from.
+* @returns a function that returns true if the word is in the include list.
+*/
+async function createIncludeFilter(includeWordsFrom) {
+	if (!includeWordsFrom || !includeWordsFrom.length) return () => true;
+	const excludeWords = await createWordsCollectionFromFiles(includeWordsFrom);
+	return (word) => excludeWords.has(word, word.toUpperCase() !== word);
+}
+/**
+* @param excludeWordsMatchingRegex - List of regex patterns to exclude.
+* @returns a function that returns true if the word does not match any of the regex patterns.
+*/
+function createExcludeRegexFilter(excludeWordsMatchingRegex) {
+	if (!excludeWordsMatchingRegex || !excludeWordsMatchingRegex.length) return () => true;
+	const regexes = excludeWordsMatchingRegex.map((a) => stringToRegExp(a)).filter((a, i) => {
+		if (a) return true;
+		console.warn("Invalid regex: \"%s\"", excludeWordsMatchingRegex[i]);
+		return false;
+	});
+	return (word) => !regexes.some((r) => r.test(word));
+}
+function iterableToString(iter) {
+	return Array.isArray(iter) ? iter.join("") : [...iter].join("");
+}
+
+//#endregion
+//#region src/build.ts
+const moduleName = "cspell-tools";
+const searchPlaces = [
+	`${moduleName}.config.json`,
+	`${moduleName}.config.yaml`,
+	`${moduleName}.config.yml`,
+	"package.json"
+];
+async function build(targets, options) {
+	const allowedTargets = new Set(targets || []);
+	function filter(target) {
+		return !allowedTargets.size || allowedTargets.has(target.name);
+	}
+	const searchDir = path.resolve(options.root || options.cwd || ".");
+	const explorer = cosmiconfig(moduleName, {
+		searchPlaces,
+		stopDir: searchDir,
+		transform: normalizeConfig
+	});
+	const config = await (options.config ? explorer.load(options.config) : explorer.search(searchDir));
+	if (!config?.config) {
+		console.error("root: %s", options.root);
+		throw "cspell-tools.config not found.";
+	}
+	const configDir = path.dirname(config.filepath);
+	await compile(normalizeRequest(config.config, path.resolve(configDir, options.root || configDir)), {
+		filter,
+		cwd: options.cwd,
+		conditionalBuild: options.conditional || false
+	});
+}
+function normalizeRequest(buildInfo, root) {
+	const { rootDir = root, targets = [], checksumFile } = buildInfo;
+	return {
+		rootDir: path.resolve(rootDir),
+		targets,
+		checksumFile
+	};
+}
+
+//#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