@cspell/cspell-tools 9.5.0 → 9.6.0

package/dist/compiler/WordsCollection.js

@@ -1,3 +0,0 @@
-export const defaultAllowedSplitWords = Object.freeze({ size: 0, has: () => true });
-export const defaultExcludeWordsCollection = Object.freeze({ size: 0, has: () => false });
-//# sourceMappingURL=WordsCollection.js.map

package/dist/compiler/compile.d.ts

@@ -1,26 +0,0 @@
-import type { CompileRequest, CompileSourceOptions as CompileSourceConfig, Target } from '../config/index.js';
-interface CompileOptions {
-    /**
-     * Optional filter function to filter targets.
-     */
-    filter?: ((target: Target) => boolean) | undefined;
-    /**
-     * The current working directory. Defaults to process.cwd()
-     */
-    cwd?: string | undefined;
-    /**
-     * `true` - only build if files do not match checksum.
-     */
-    conditionalBuild: boolean;
-}
-export declare function compile(request: CompileRequest, options?: CompileOptions): Promise<void>;
-interface CompileTargetOptions {
-    rootDir: string;
-    cwd: string | undefined;
-    conditional: boolean;
-    checksumFile: string | undefined;
-    dictionaryDirectives: string[] | undefined;
-}
-export declare function compileTarget(target: Target, options: CompileSourceConfig, compileOptions: CompileTargetOptions): Promise<string[]>;
-export {};
-//# sourceMappingURL=compile.d.ts.map

package/dist/compiler/compile.js

@@ -1,270 +0,0 @@
-import * as path from 'node:path';
-import { pipeAsync, toArray } from '@cspell/cspell-pipe';
-import { opAwaitAsync, opMapAsync } from '@cspell/cspell-pipe/operators';
-import { opConcatMap, opMap, pipe } from '@cspell/cspell-pipe/sync';
-import { isFileListSource, isFilePath, isFileSource } from '../config/index.js';
-import { checkShasumFile, updateChecksumForFiles } from '../shasum/index.js';
-import { stringToRegExp } from '../util/textRegex.js';
-import { createAllowedSplitWordsFromFiles, createWordsCollectionFromFiles } from './createWordsCollection.js';
-import { logWithTimestamp } from './logWithTimestamp.js';
-import { readTextFile } from './readers/readTextFile.js';
-import { streamSourceWordsFromFile } from './streamSourceWordsFromFile.js';
-import { createTargetFile, createTrieCompiler, createWordListCompiler } from './wordListCompiler.js';
-import { normalizeTargetWords } from './wordListParser.js';
-export async function compile(request, options) {
-    const { targets } = request;
-    // console.warn('Request: %o', 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 = new Set();
-    for (const target of targets) {
-        const keep = options?.filter?.(target) ?? true;
-        if (!keep)
-            continue;
-        const adjustedTarget = { ...targetOptions, ...target };
-        // console.warn('adjustedTarget: %o', adjustedTarget);
-        const deps = await compileTarget(adjustedTarget, request, {
-            rootDir,
-            cwd,
-            conditional,
-            checksumFile,
-            dictionaryDirectives,
-        });
-        deps.forEach((dep) => dependencies.add(dep));
-    }
-    if (checksumFile && dependencies.size) {
-        logWithTimestamp('%s', `Update checksum: ${checksumFile}`);
-        await updateChecksumForFiles(checksumFile, [...dependencies], { root: path.dirname(checksumFile) });
-    }
-    logWithTimestamp(`Complete.`);
-    return;
-}
-function resolveChecksumFile(checksumFile, root) {
-    const cFilename = (typeof checksumFile === 'string' && checksumFile) || (checksumFile && './checksum.txt') || undefined;
-    const file = cFilename && path.resolve(root, cFilename);
-    // console.warn('%o', { checksumFile, cFilename, file });
-    return file;
-}
-export 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 targetDirectory = path.resolve(rootDir, target.targetDirectory ?? cwd ?? process.cwd());
-    const dictionaryDirectives = target.dictionaryDirectives ?? compileOptions.dictionaryDirectives;
-    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 = new Set();
-    genSet.add(generateCompressed);
-    if (generateUncompressed) {
-        genSet.add(false);
-    }
-    const filename = resolveTarget(name, targetDirectory, useTrie);
-    const filesToProcessAsync = pipeAsync(readSourceList(sources, rootDir), opMapAsync((src) => readFileSource(src, options)), opAwaitAsync());
-    const filesToProcess = await toArray(filesToProcessAsync);
-    const normalizer = normalizeTargetWords({
-        sort: useTrie || sort,
-        generateNonStrict,
-        filter: excludeFilter,
-        dictionaryDirectives,
-        // removeDuplicates, // Add this in if we use it.
-    });
-    const checksumRoot = (checksumFile && path.dirname(checksumFile)) || rootDir;
-    const deps = [
-        ...calculateDependencies(filename + (generateCompressed ? '.gz' : ''), filesToProcess, [...excludeWordsFrom, ...excludeWordsNotFoundIn], checksumRoot),
-    ];
-    if (conditional && checksumFile) {
-        const check = await checkShasumFile(checksumFile, deps, checksumRoot).catch(() => undefined);
-        if (check?.passed) {
-            logWithTimestamp(`Skip ${target.name}, nothing changed.`);
-            return [];
-        }
-    }
-    async function action(words, dst) {
-        const compiler = useTrie
-            ? createTrieCompiler({
-                base: trieBase,
-                trie3: format === 'trie3',
-                trie4: format === 'trie4',
-            })
-            : createWordListCompiler({
-                sort,
-                generateNonStrict,
-                dictionaryDirectives,
-                removeDuplicates,
-            });
-        const data = iterableToString(pipe(words, normalizer, compiler));
-        for (const compress of genSet) {
-            await createTargetFile(dst, data, compress);
-        }
-    }
-    await processFiles({ action, filesToProcess, mergeTarget: filename });
-    logWithTimestamp(`Done compile: ${target.name}`);
-    return deps;
-}
-function calculateDependencies(targetFile, filesToProcess, extraDependencyFiles, rootDir) {
-    const dependencies = new Set();
-    addDependency(targetFile);
-    extraDependencyFiles?.forEach((f) => addDependency(f));
-    filesToProcess.forEach((f) => addDependency(f.src));
-    return dependencies;
-    function addDependency(filename) {
-        const rel = path.relative(rootDir, filename);
-        dependencies.add(rel);
-        dependencies.add(rel.replace(/\.aff$/, '.dic'));
-        dependencies.add(rel.replace(/\.dic$/, '.aff'));
-    }
-}
-function rel(filePath) {
-    return path.relative(process.cwd(), filePath);
-}
-async function processFiles({ action, filesToProcess, mergeTarget }) {
-    const toProcess = filesToProcess;
-    const dst = mergeTarget;
-    const words = 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));
-    }), 
-    // opMap((a) => (console.warn(a), a))
-    logProgress());
-    await action(words, dst);
-    logWithTimestamp('Done "%s"', rel(dst));
-}
-function resolveTarget(name, directory, useTrie) {
-    const ext = (useTrie && '.trie') || '.txt';
-    const filename = name + ext;
-    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) {
-    const content = await readTextFile(fileList);
-    return content
-        .split('\n')
-        .map((a) => a.trim())
-        .filter((a) => !!a);
-}
-async function readFileSource(fileSource, sourceOptions) {
-    const { filename, keepRawCase = sourceOptions.keepRawCase || false, split = sourceOptions.split || false, maxDepth, storeSplitWordsAsCompounds, minCompoundLength, } = fileSource;
-    const legacy = split === 'legacy';
-    const splitWords = legacy ? false : split;
-    // console.warn('fileSource: %o,\n targetOptions %o, \n opt: %o', fileSource, targetOptions, opt);
-    const allowedSplitWords = await createAllowedSplitWordsFromFiles(fileSource.allowedSplitWords || sourceOptions.allowedSplitWords);
-    const readerOptions = {
-        maxDepth,
-        legacy,
-        splitWords,
-        keepCase: keepRawCase,
-        allowedSplitWords,
-        storeSplitWordsAsCompounds,
-        minCompoundLength,
-    };
-    logWithTimestamp(`Reading ${path.basename(filename)}`);
-    const stream = await streamSourceWordsFromFile(filename, readerOptions);
-    logWithTimestamp(`Done reading ${path.basename(filename)}`);
-    const f = {
-        src: filename,
-        words: stream,
-    };
-    return f;
-}
-function normalizeTargetName(name) {
-    return name.replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, '').replaceAll(/[^\p{L}\p{M}.\w\\/-]/gu, '_');
-}
-function logProgress(freq = 100_000) {
-    function* logProgress(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;
-}
-/**
- * @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('');
-}
-//# sourceMappingURL=compile.js.map

package/dist/compiler/createCompileRequest.d.ts

@@ -1,4 +0,0 @@
-import type { CompileCommonAppOptions } from '../AppOptions.js';
-import type { CompileRequest } from '../config/index.js';
-export declare function createCompileRequest(sourceFiles: string[], options: CompileCommonAppOptions): CompileRequest;
-//# sourceMappingURL=createCompileRequest.d.ts.map

package/dist/compiler/createCompileRequest.js

@@ -1,84 +0,0 @@
-import * as path from 'node:path';
-export function createCompileRequest(sourceFiles, options) {
-    options = { ...options };
-    options.maxDepth ??= options.max_depth;
-    const { maxDepth, split, keepRawCase, useLegacySplitter } = options;
-    const sources = [...sourceFiles, ...(options.listFile || []).map((listFile) => ({ listFile }))];
-    const targets = calcTargets(sources, options);
-    const req = {
-        targets,
-        maxDepth: parseNumber(maxDepth),
-        split: useLegacySplitter ? 'legacy' : split,
-        /**
-         * Do not generate lower case / accent free versions of words.
-         * @default false
-         */
-        keepRawCase,
-    };
-    return req;
-}
-function calcTargets(sources, options) {
-    const { merge, output = '.', experimental = [] } = options;
-    const generateNonStrict = experimental.includes('compound') || undefined;
-    // console.log('%o', sources);
-    const format = calcFormat(options);
-    const sort = (format === 'plaintext' && options.sort) || undefined;
-    if (merge) {
-        const target = {
-            name: merge,
-            targetDirectory: output,
-            compress: options.compress,
-            format,
-            sources: sources.map(normalizeSource),
-            sort,
-            trieBase: parseNumber(options.trieBase),
-            generateNonStrict,
-        };
-        return [target];
-    }
-    const targets = sources.map((source) => {
-        const name = toTargetName(baseNameOfSource(source));
-        const target = {
-            name,
-            targetDirectory: output,
-            compress: options.compress,
-            format,
-            sources: [normalizeSource(source)],
-            sort: options.sort,
-            trieBase: parseNumber(options.trieBase),
-            generateNonStrict,
-        };
-        return target;
-    });
-    return targets;
-}
-function calcFormat(options) {
-    return (options.trie4 && 'trie4') || (options.trie3 && 'trie3') || (options.trie && 'trie') || 'plaintext';
-}
-function toTargetName(sourceFile) {
-    return path.basename(sourceFile).replace(/((\.txt|\.dic|\.aff|\.trie)(\.gz)?)?$/, '');
-}
-function parseNumber(s) {
-    const n = Number.parseInt(s ?? '');
-    return Number.isNaN(n) ? undefined : n;
-}
-function baseNameOfSource(source) {
-    return typeof source === 'string' ? source : isFileSource(source) ? source.filename : source.listFile;
-}
-function isFileSource(source) {
-    return typeof source !== 'string' && source.filename !== undefined;
-}
-function normalizeSource(source) {
-    if (typeof source === 'string') {
-        return normalizeSourcePath(source);
-    }
-    if (isFileSource(source))
-        return { ...source, filename: normalizeSourcePath(source.filename) };
-    return { ...source, listFile: normalizeSourcePath(source.listFile) };
-}
-function normalizeSourcePath(source) {
-    const cwd = process.cwd();
-    const rel = path.relative(cwd, source);
-    return rel.split('\\').join('/');
-}
-//# sourceMappingURL=createCompileRequest.js.map

package/dist/compiler/createWordsCollection.d.ts

@@ -1,10 +0,0 @@
-import type { FilePath, FilePathOrFilePathArray } from '../config/config.js';
-import type { AllowedSplitWordsCollection, ExcludeWordsCollection, WordsCollection } from './WordsCollection.js';
-export declare function createAllowedSplitWordsFromFiles(files: FilePathOrFilePathArray | undefined): Promise<AllowedSplitWordsCollection>;
-export declare function createAllowedSplitWords(words: Iterable<string> | undefined): AllowedSplitWordsCollection;
-export declare function createWordsCollectionFromFiles(files: FilePathOrFilePathArray): Promise<WordsCollection>;
-export declare function createWordsCollection(words: Iterable<string>): WordsCollection;
-export declare function createExcludeWordsCollectionFromFiles(files: FilePathOrFilePathArray | undefined): Promise<ExcludeWordsCollection>;
-export declare function createExcludeWordsCollection(words: Iterable<string> | undefined): ExcludeWordsCollection;
-export declare function toFilePathArray(filePathOrArray: FilePathOrFilePathArray): FilePath[];
-//# sourceMappingURL=createWordsCollection.d.ts.map

package/dist/compiler/createWordsCollection.js

@@ -1,111 +0,0 @@
-import { parseDictionary } from 'cspell-trie-lib';
-import { createReader } from './Reader.js';
-import { defaultAllowedSplitWords, defaultExcludeWordsCollection } from './WordsCollection.js';
-class AllowedSplitWordsImpl {
-    collection;
-    size;
-    constructor(collection) {
-        this.collection = collection;
-        this.size = collection.size;
-    }
-    has(word, caseSensitive) {
-        return !this.size || this.collection.has(word, caseSensitive);
-    }
-}
-export async function createAllowedSplitWordsFromFiles(files) {
-    if (!files || !files.length)
-        return defaultAllowedSplitWords;
-    const collection = await createWordsCollectionFromFiles(files);
-    return new AllowedSplitWordsImpl(collection);
-}
-export function createAllowedSplitWords(words) {
-    if (!words)
-        return defaultAllowedSplitWords;
-    return new AllowedSplitWordsImpl(createWordsCollection(words));
-}
-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(filename) {
-    return await createReader(filename, {});
-}
-function readersToCollection(readers) {
-    const dictReaders = readers.filter(isDictionaryReader).map(dictReaderToCollection);
-    const nonDictCollection = lineReadersToCollection(readers.filter((a) => !isDictionaryReader(a)));
-    const collections = [...dictReaders, nonDictCollection];
-    const collection = {
-        size: collections.reduce((s, a) => s + a.size, 0),
-        has: (word, caseSensitive) => collections.some((a) => a.has(word, caseSensitive)),
-    };
-    return collection;
-}
-const cache = new WeakMap();
-export async function createWordsCollectionFromFiles(files) {
-    files = toFilePathArray(files);
-    const cached = cache.get(files);
-    if (cached)
-        return cached;
-    const sources = await Promise.all(files.map((file) => readFile(file)));
-    const collection = readersToCollection(sources);
-    cache.set(files, collection);
-    return collection;
-}
-export function createWordsCollection(words) {
-    if (words instanceof Set)
-        return words;
-    const arrWords = (Array.isArray(words) ? words : [...words])
-        .map((a) => a.trim())
-        .filter((a) => !!a)
-        .filter((a) => !a.startsWith('#'));
-    const setOfWords = new Set(arrWords);
-    const has = buildHasFn({ hasWord: (word) => setOfWords.has(word) });
-    return { size: setOfWords.size, has };
-}
-class ExcludeWordsCollectionImpl {
-    collection;
-    size;
-    constructor(collection) {
-        this.collection = collection;
-        this.size = collection.size;
-    }
-    has(word, caseSensitive) {
-        return this.collection.has(word, caseSensitive);
-    }
-}
-export async function createExcludeWordsCollectionFromFiles(files) {
-    if (!files || !files.length)
-        return defaultExcludeWordsCollection;
-    const collection = await createWordsCollectionFromFiles(files);
-    return new ExcludeWordsCollectionImpl(collection);
-}
-export function createExcludeWordsCollection(words) {
-    return new ExcludeWordsCollectionImpl(words ? createWordsCollection(words) : new Set());
-}
-function isDictionaryReader(reader) {
-    return 'hasWord' in reader && !!reader.hasWord;
-}
-function dictReaderToCollection(reader) {
-    return { size: reader.size, has: buildHasFn(reader) };
-}
-function lineReadersToCollection(readers) {
-    function* words() {
-        for (const reader of readers) {
-            yield* reader.lines;
-        }
-    }
-    const dict = parseDictionary(words(), { stripCaseAndAccents: false });
-    return { size: dict.size, has: buildHasFn(dict) };
-}
-export function toFilePathArray(filePathOrArray) {
-    return Array.isArray(filePathOrArray) ? filePathOrArray : [filePathOrArray];
-}
-//# sourceMappingURL=createWordsCollection.js.map

package/dist/compiler/index.d.ts

@@ -1,4 +0,0 @@
-export type { CompileRequest, CompileTargetOptions, RunConfig } from '../config/index.js';
-export { compile, compileTarget } from './compile.js';
-export { type Logger, setLogger } from './logger.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/compiler/index.js

@@ -1,3 +0,0 @@
-export { compile, compileTarget } from './compile.js';
-export { setLogger } from './logger.js';
-//# sourceMappingURL=index.js.map

package/dist/compiler/legacyLineToWords.d.ts

@@ -1,4 +0,0 @@
-import type { AllowedSplitWordsCollection } from './WordsCollection.js';
-export declare function legacyLineToWords(line: string, keepCase: boolean, allowedSplitWords: AllowedSplitWordsCollection): Iterable<string>;
-export declare function legacyLinesToWords(lines: Iterable<string>, keepCase: boolean, allowedSplitWords: AllowedSplitWordsCollection): Iterable<string>;
-//# sourceMappingURL=legacyLineToWords.d.ts.map

package/dist/compiler/legacyLineToWords.js

@@ -1,20 +0,0 @@
-import { opConcatMap, opFilter, opMap, pipe } from '@cspell/cspell-pipe/sync';
-import { defaultCompileSourceOptions } from '../config/configDefaults.js';
-import { regExpSpaceOrDash, splitCamelCaseIfAllowed } from './splitCamelCaseIfAllowed.js';
-const regNonWord = /[^\p{L}\p{M}' _\d]+/giu;
-const regExpRepeatChars = /(.)\1{5}/i;
-const minCompoundLength = defaultCompileSourceOptions.minCompoundLength;
-export function legacyLineToWords(line, keepCase, allowedSplitWords) {
-    // Remove punctuation and non-letters.
-    const filteredLine = line.replaceAll(regNonWord, '|');
-    const wordGroups = filteredLine.split('|');
-    const _minCompoundLength = minCompoundLength;
-    const words = pipe(wordGroups, opConcatMap((a) => a.split(regExpSpaceOrDash)), opConcatMap((a) => splitCamelCaseIfAllowed(a, allowedSplitWords, keepCase, '', _minCompoundLength)), opMap((a) => a.trim()), opFilter((a) => !!a), opFilter((s) => !regExpRepeatChars.test(s)));
-    return words;
-}
-export function* legacyLinesToWords(lines, keepCase, allowedSplitWords) {
-    for (const line of lines) {
-        yield* legacyLineToWords(line, keepCase, allowedSplitWords);
-    }
-}
-//# sourceMappingURL=legacyLineToWords.js.map

package/dist/compiler/logWithTimestamp.d.ts

@@ -1,3 +0,0 @@
-import type { Logger } from './logger.js';
-export declare const logWithTimestamp: Logger;
-//# sourceMappingURL=logWithTimestamp.d.ts.map

package/dist/compiler/logWithTimestamp.js

@@ -1,5 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const logWithTimestamp = (message, ...optionalParams) => {
-    console.log(`${new Date().toISOString()} ${message}`, ...optionalParams);
-};
-//# sourceMappingURL=logWithTimestamp.js.map

package/dist/compiler/logger.d.ts

@@ -1,4 +0,0 @@
-export type Logger = (message?: any, ...optionalParams: any[]) => void;
-export declare function setLogger(logger?: Logger): void;
-export declare function getLogger(): Logger;
-//# sourceMappingURL=logger.d.ts.map

package/dist/compiler/logger.js

@@ -1,9 +0,0 @@
-const defaultLogger = console.log;
-let log = defaultLogger;
-export function setLogger(logger) {
-    log = logger ?? defaultLogger;
-}
-export function getLogger() {
-    return log;
-}
-//# sourceMappingURL=logger.js.map

package/dist/compiler/readers/ReaderOptions.d.ts

@@ -1,19 +0,0 @@
-export interface ReaderOptions {
-    /**
-     * Max Hunspell recursive depth.
-     */
-    maxDepth?: number | undefined;
-}
-export type AnnotatedWord = string;
-export interface BaseReader {
-    size: number;
-    type: 'Hunspell' | 'TextFile' | 'Trie';
-    lines: Iterable<AnnotatedWord>;
-    readonly hasWord?: (word: string, caseSensitive: boolean) => boolean;
-}
-export interface Reader extends BaseReader {
-}
-export interface DictionaryReader extends BaseReader {
-    readonly hasWord: (word: string, caseSensitive: boolean) => boolean;
-}
-//# sourceMappingURL=ReaderOptions.d.ts.map

package/dist/compiler/readers/ReaderOptions.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ReaderOptions.js.map

package/dist/compiler/readers/readHunspellFiles.d.ts

@@ -1,3 +0,0 @@
-import type { BaseReader, ReaderOptions } from './ReaderOptions.js';
-export declare function readHunspellFiles(filename: string, options: ReaderOptions): Promise<BaseReader>;
-//# sourceMappingURL=readHunspellFiles.d.ts.map

package/dist/compiler/readers/readHunspellFiles.js

@@ -1,57 +0,0 @@
-import { pipe } from '@cspell/cspell-pipe/sync';
-import { COMPOUND_FIX, FORBID_PREFIX } from 'cspell-trie-lib';
-import * as HR from 'hunspell-reader';
-import { regHunspellFile } from './regHunspellFile.js';
-const DEDUPE_SIZE = 1000;
-export 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 !== undefined ? options.maxDepth : reader.maxDepth;
-    const words = pipe(reader.seqAffWords(), _mapAffWords, dedupeAndSort);
-    return {
-        type: 'Hunspell',
-        size: reader.dic.length,
-        lines: words,
-    };
-}
-function* dedupeAndSort(words) {
-    const buffer = 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;
-        // For now do not include words with special characters.
-        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;
-        }
-    }
-}
-//# sourceMappingURL=readHunspellFiles.js.map