cspell 7.0.2 → 7.2.0

package/dist/esm/commandLint.js

@@ -0,0 +1,127 @@
+import { Option as CommanderOption } from 'commander';
+import * as App from './application.js';
+import { DEFAULT_CACHE_LOCATION } from './util/cache/index.js';
+import { CheckFailed } from './util/errors.js';
+// interface InitOptions extends Options {}
+const usage = `\
+[options] [globs...] [file://<path> ...] [stdin[://<path>]]
+
+Patterns:
+ - [globs...]            Glob Patterns
+ - [stdin]               Read from "stdin" assume text file.
+ - [stdin://<path>]      Read from "stdin", use <path> for file type and config.
+ - [file://<path>]       Check the file at <path>
+
+Examples:
+    cspell .                        Recursively check all files.
+    cspell lint .                   The same as "cspell ."
+    cspell "*.js"                   Check all .js files in the current directory
+    cspell "**/*.js"                Check all .js files recursively
+    cspell "src/**/*.js"            Only check .js under src
+    cspell "**/*.txt" "**/*.js"     Check both .js and .txt files.
+    cspell "**/*.{txt,js,md}"       Check .txt, .js, and .md files.
+    cat LICENSE | cspell stdin      Check stdin
+    cspell stdin://docs/doc.md      Check stdin as if it was "./docs/doc.md"\
+`;
+const advanced = `
+More Examples:
+
+    cspell "**/*.js" --reporter @cspell/cspell-json-reporter
+        This will spell check all ".js" files recursively and use
+        "@cspell/cspell-json-reporter".
+
+    cspell . --reporter default
+        This will force the default reporter to be used overriding
+        any reporters defined in the configuration.
+
+    cspell . --reporter ./<path>/reporter.cjs
+        Use a custom reporter. See API for details.
+
+References:
+    https://cspell.org
+    https://github.com/streetsidesoftware/cspell
+`;
+function collect(value, previous) {
+    if (!previous) {
+        return [value];
+    }
+    return previous.concat([value]);
+}
+export function commandLint(prog) {
+    const spellCheckCommand = prog.command('lint', { isDefault: true });
+    spellCheckCommand
+        .description('Check spelling')
+        .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
+        .option('-v, --verbose', 'Display more information about the files being checked and the configuration.')
+        .option('--locale <locale>', 'Set language locales. i.e. "en,fr" for English and French, or "en-GB" for British English.')
+        .option('--language-id <language>', 'Force programming language for unknown extensions. i.e. "php" or "scala"')
+        .addOption(new CommanderOption('--languageId <language>', 'Force programming language for unknown extensions. i.e. "php" or "scala"').hideHelp())
+        .option('--words-only', 'Only output the words not found in the dictionaries.')
+        .addOption(new CommanderOption('--wordsOnly', 'Only output the words not found in the dictionaries.').hideHelp())
+        .option('-u, --unique', 'Only output the first instance of a word not found in the dictionaries.')
+        .option('-e, --exclude <glob>', 'Exclude files matching the glob pattern. This option can be used multiple times to add multiple globs. ', collect)
+        .option('--file-list <path or stdin>', 'Specify a list of files to be spell checked.' +
+        ' The list is filtered against the glob file patterns.' +
+        ' Note: the format is 1 file path per line.', collect)
+        .option('--no-issues', 'Do not show the spelling errors.')
+        .option('--no-progress', 'Turn off progress messages')
+        .option('--no-summary', 'Turn off summary message in console.')
+        .option('-s, --silent', 'Silent mode, suppress error messages.')
+        .addOption(new CommanderOption('--quiet', 'Only show spelling issues or errors.').implies({
+        summary: false,
+        progress: false,
+    }))
+        .option('--fail-fast', 'Exit after first file with an issue or error.')
+        .addOption(new CommanderOption('--no-fail-fast', 'Process all files even if there is an error.').hideHelp())
+        .option('-r, --root <root folder>', 'Root directory, defaults to current directory.')
+        .option('--relative', 'Issues are displayed relative to root.')
+        .option('--show-context', 'Show the surrounding text around an issue.')
+        .option('--show-suggestions', 'Show spelling suggestions.')
+        .addOption(new CommanderOption('--no-show-suggestions', 'Do not show spelling suggestions or fixes.').default(undefined))
+        .addOption(new CommanderOption('--must-find-files', 'Error if no files are found.').default(true).hideHelp())
+        .option('--no-must-find-files', 'Do not error if no files are found.')
+        // The following options are planned features
+        // .option('-w, --watch', 'Watch for any changes to the matching files and report any errors')
+        // .option('--force', 'Force the exit value to always be 0')
+        .addOption(new CommanderOption('--legacy', 'Legacy output').hideHelp())
+        .addOption(new CommanderOption('--local <local>', 'Deprecated -- Use: --locale').hideHelp())
+        .option('--cache', 'Use cache to only check changed files.')
+        .option('--no-cache', 'Do not use cache.')
+        .option('--cache-reset', 'Reset the cache file.')
+        .addOption(new CommanderOption('--cache-strategy <strategy>', 'Strategy to use for detecting changed files.').choices([
+        'metadata',
+        'content',
+    ]))
+        .option('--cache-location <path>', `Path to the cache file or directory. (default: "${DEFAULT_CACHE_LOCATION}")`)
+        .option('--dot', 'Include files and directories starting with `.` (period) when matching globs.')
+        .option('--gitignore', 'Ignore files matching glob patterns found in .gitignore files.')
+        .option('--no-gitignore', 'Do NOT use .gitignore files.')
+        .option('--gitignore-root <path>', 'Prevent searching for .gitignore files past root.', collect)
+        .option('--validate-directives', 'Validate in-document CSpell directives.')
+        .option('--no-validate-directives', 'Do not validate in-document CSpell directives.')
+        .option('--no-color', 'Turn off color.')
+        .option('--color', 'Force color.')
+        .addOption(new CommanderOption('--default-configuration', 'Load the default configuration and dictionaries.').hideHelp())
+        .addOption(new CommanderOption('--no-default-configuration', 'Do not load the default configuration and dictionaries.'))
+        .option('--debug', 'Output information useful for debugging cspell.json files.')
+        .option('--reporter <module|path>', 'Specify one or more reporters to use.', collect)
+        .usage(usage)
+        .addHelpText('after', advanced)
+        .arguments('[globs...]')
+        .action((fileGlobs, options) => {
+        App.parseApplicationFeatureFlags(options.flag);
+        const { mustFindFiles, fileList } = options;
+        return App.lint(fileGlobs, options).then((result) => {
+            if (!fileGlobs.length && !result.files && !result.errors && !fileList) {
+                spellCheckCommand.outputHelp();
+                throw new CheckFailed('outputHelp', 1);
+            }
+            if (result.issues || result.errors || (mustFindFiles && !result.files)) {
+                throw new CheckFailed('check failed', 1);
+            }
+            return;
+        });
+    });
+    return spellCheckCommand;
+}
+//# sourceMappingURL=commandLint.js.map

package/dist/esm/commandLint.mjs

@@ -67,7 +67,10 @@ export function commandLint(prog) {
         .option('--no-progress', 'Turn off progress messages')
         .option('--no-summary', 'Turn off summary message in console.')
         .option('-s, --silent', 'Silent mode, suppress error messages.')
-        .addOption(new CommanderOption('--quiet', 'An alias of --silent').implies({ silent: true }))
+        .addOption(new CommanderOption('--quiet', 'Only show spelling issues or errors.').implies({
+        summary: false,
+        progress: false,
+    }))
         .option('--fail-fast', 'Exit after first file with an issue or error.')
         .addOption(new CommanderOption('--no-fail-fast', 'Process all files even if there is an error.').hideHelp())
         .option('-r, --root <root folder>', 'Root directory, defaults to current directory.')
@@ -121,3 +124,4 @@ export function commandLint(prog) {
     });
     return spellCheckCommand;
 }
+//# sourceMappingURL=commandLint.mjs.map

package/dist/esm/commandSuggestion.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function commandSuggestion(prog: Command): Command;
+//# sourceMappingURL=commandSuggestion.d.ts.map

package/dist/esm/commandSuggestion.js

@@ -0,0 +1,61 @@
+import { Option as CommanderOption } from 'commander';
+import * as App from './application.js';
+import { emitSuggestionResult } from './emitters/suggestionsEmitter.js';
+import { CheckFailed } from './util/errors.js';
+function collect(value, previous) {
+    value = value.replace(/^=/, '');
+    if (!previous) {
+        return [value];
+    }
+    return previous.concat([value]);
+}
+function count(_, previous) {
+    return (previous || 0) + 1;
+}
+function asNumber(value, prev) {
+    return parseInt(value, 10) ?? prev;
+}
+export function commandSuggestion(prog) {
+    const suggestionCommand = prog.command('suggestions');
+    suggestionCommand
+        .aliases(['sug', 'suggest'])
+        .description('Spelling Suggestions for words.')
+        .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
+        .option('--locale <locale>', 'Set language locales. i.e. "en,fr" for English and French, or "en-GB" for British English.')
+        .option('--language-id <language>', 'Use programming language. i.e. "php" or "scala".')
+        .addOption(new CommanderOption('--languageId <language>', 'Use programming language. i.e. "php" or "scala".').hideHelp())
+        .option('-s, --no-strict', 'Ignore case and accents when searching for words.')
+        .option('--ignore-case', 'Alias of --no-strict.')
+        .option('--num-changes <number>', 'Number of changes allowed to a word', asNumber, 4)
+        .option('--num-suggestions <number>', 'Number of suggestions', asNumber, 8)
+        .option('--no-include-ties', 'Force the number of suggested to be limited, by not including suggestions that have the same edit cost.')
+        .option('--stdin', 'Use stdin for input.')
+        .addOption(new CommanderOption('--repl', 'REPL interface for looking up suggestions.'))
+        .option('-v, --verbose', 'Show detailed output.', count, 0)
+        .option('-d, --dictionary <dictionary name>', 'Use the dictionary specified. Only dictionaries specified will be used.', collect)
+        .option('--dictionaries <dictionary names...>', 'Use the dictionaries specified. Only dictionaries specified will be used.')
+        .option('--no-color', 'Turn off color.')
+        .option('--color', 'Force color')
+        .arguments('[words...]')
+        .action(async (words, options) => {
+        App.parseApplicationFeatureFlags(options.flag);
+        options.useStdin = options.stdin;
+        options.dictionaries = mergeArrays(options.dictionaries, options.dictionary);
+        if (!words.length && !options.useStdin && !options.repl) {
+            suggestionCommand.outputHelp();
+            throw new CheckFailed('outputHelp', 1);
+        }
+        for await (const r of App.suggestions(words, options)) {
+            emitSuggestionResult(r, options);
+        }
+    });
+    return suggestionCommand;
+}
+function mergeArrays(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return a.concat(b);
+}
+//# sourceMappingURL=commandSuggestion.js.map

package/dist/esm/commandSuggestion.mjs

@@ -58,3 +58,4 @@ function mergeArrays(a, b) {
         return a;
     return a.concat(b);
 }
+//# sourceMappingURL=commandSuggestion.mjs.map

package/dist/esm/commandTrace.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function commandTrace(prog: Command): Command;
+//# sourceMappingURL=commandTrace.d.ts.map

package/dist/esm/commandTrace.js

@@ -0,0 +1,60 @@
+import { Option as CommanderOption } from 'commander';
+import * as App from './application.js';
+import { isDictionaryPathFormat } from './emitters/DictionaryPathFormat.js';
+import { emitTraceResults } from './emitters/traceEmitter.js';
+import { CheckFailed } from './util/errors.js';
+export function commandTrace(prog) {
+    return prog
+        .command('trace')
+        .description(`Trace words -- Search for words in the configuration and dictionaries.`)
+        .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
+        .option('--locale <locale>', 'Set language locales. i.e. "en,fr" for English and French, or "en-GB" for British English.')
+        .option('--language-id <language>', 'Use programming language. i.e. "php" or "scala".')
+        .addOption(new CommanderOption('--languageId <language>', 'Use programming language. i.e. "php" or "scala".').hideHelp())
+        .option('--allow-compound-words', 'Turn on allowCompoundWords')
+        .addOption(new CommanderOption('--allowCompoundWords', 'Turn on allowCompoundWords.').hideHelp())
+        .option('--no-allow-compound-words', 'Turn off allowCompoundWords')
+        .option('--ignore-case', 'Ignore case and accents when searching for words.')
+        .option('--no-ignore-case', 'Do not ignore case and accents when searching for words.')
+        .addOption(new CommanderOption('--dictionary-path <format>', 'Configure how to display the dictionary path.')
+        .choices(['hide', 'short', 'long', 'full'])
+        .default('long', 'Display most of the path.'))
+        .option('--stdin', 'Read words from stdin.')
+        .option('--all', 'Show all dictionaries.')
+        .addOption(new CommanderOption('--only-found', 'Show only dictionaries that have the words.').conflicts('all'))
+        .option('--no-color', 'Turn off color.')
+        .option('--color', 'Force color')
+        .addOption(new CommanderOption('--default-configuration', 'Load the default configuration and dictionaries.').hideHelp())
+        .addOption(new CommanderOption('--no-default-configuration', 'Do not load the default configuration and dictionaries.'))
+        .arguments('[words...]')
+        .action(async (words, options) => {
+        App.parseApplicationFeatureFlags(options.flag);
+        let numFound = 0;
+        const dictionaryPathFormat = isDictionaryPathFormat(options.dictionaryPath)
+            ? options.dictionaryPath
+            : 'long';
+        for await (const results of App.trace(words, options)) {
+            const filtered = filterTraceResults(results, options);
+            emitTraceResults(filtered, { cwd: process.cwd(), dictionaryPathFormat });
+            numFound += results.reduce((n, r) => n + (r.found ? 1 : 0), 0);
+            const numErrors = results.map((r) => r.errors?.length || 0).reduce((n, r) => n + r, 0);
+            if (numErrors) {
+                console.error('Dictionary Errors.');
+                throw new CheckFailed('dictionary errors', 1);
+            }
+        }
+        if (!numFound) {
+            console.error('No matches found');
+            throw new CheckFailed('no matches', 1);
+        }
+    });
+}
+function filterTraceResults(results, options) {
+    if (options.all)
+        return results;
+    return results.filter((r) => filterTraceResult(r, options.onlyFound));
+}
+function filterTraceResult(result, onlyFound) {
+    return result.found || result.forbidden || result.noSuggest || (!onlyFound && result.dictActive);
+}
+//# sourceMappingURL=commandTrace.js.map

package/dist/esm/commandTrace.mjs

@@ -57,3 +57,4 @@ function filterTraceResults(results, options) {
 function filterTraceResult(result, onlyFound) {
     return result.found || result.forbidden || result.noSuggest || (!onlyFound && result.dictActive);
 }
+//# sourceMappingURL=commandTrace.mjs.map

package/dist/esm/emitters/DictionaryPathFormat.d.ts

@@ -0,0 +1,3 @@
+export type DictionaryPathFormat = 'hide' | 'long' | 'short' | 'full';
+export declare function isDictionaryPathFormat(value: string | undefined): value is DictionaryPathFormat;
+//# sourceMappingURL=DictionaryPathFormat.d.ts.map

package/dist/esm/emitters/DictionaryPathFormat.js

@@ -0,0 +1,12 @@
+const formats = {
+    full: true,
+    hide: true,
+    long: true,
+    short: true,
+};
+export function isDictionaryPathFormat(value) {
+    if (!value || typeof value !== 'string')
+        return false;
+    return value in formats;
+}
+//# sourceMappingURL=DictionaryPathFormat.js.map

package/dist/esm/emitters/DictionaryPathFormat.mjs

@@ -9,3 +9,4 @@ export function isDictionaryPathFormat(value) {
         return false;
     return value in formats;
 }
+//# sourceMappingURL=DictionaryPathFormat.mjs.map

package/dist/esm/emitters/suggestionsEmitter.d.ts

@@ -0,0 +1,13 @@
+import type { SuggestionsForWordResult } from 'cspell-lib';
+export interface EmitSuggestionOptions {
+    verbose?: number;
+    lineWidth?: number;
+    output?: {
+        log: (text: string) => void;
+    };
+}
+export interface TimedSuggestionsForWordResult extends SuggestionsForWordResult {
+    elapsedTimeMs?: number;
+}
+export declare function emitSuggestionResult(result: TimedSuggestionsForWordResult, options: EmitSuggestionOptions): void;
+//# sourceMappingURL=suggestionsEmitter.d.ts.map

package/dist/esm/emitters/suggestionsEmitter.js

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import { padLeft, padWidth, width } from '../util/util.js';
+const regExpRTL = /([\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC י]+)/g;
+function reverseRtlText(s) {
+    return s.replace(regExpRTL, (s) => s.split('').reverse().join(''));
+}
+export function emitSuggestionResult(result, options) {
+    const { word, suggestions } = result;
+    const { verbose, output = console } = options;
+    const elapsed = verbose && verbose > 1 && result.elapsedTimeMs ? ` ${result.elapsedTimeMs.toFixed(2)} ms` : '';
+    const rWord = reverseRtlText(word);
+    const wordEx = rWord !== word ? ` (${chalk.yellow(rWord)})` : '';
+    output.log((word ? chalk.yellow(word) + wordEx : chalk.yellow('<empty>')) + ':' + elapsed);
+    if (!suggestions.length) {
+        console.log(chalk.yellow(' <no suggestions>'));
+        return;
+    }
+    function handleRtl(word) {
+        const r = reverseRtlText(word);
+        return r === word ? word : `${word} (${r})`;
+    }
+    if (verbose) {
+        const mappedSugs = suggestions.map((s) => ({
+            ...s,
+            w: handleRtl(s.compoundWord || s.wordAdjustedToMatchCase || s.word),
+        }));
+        const sugWidths = mappedSugs.map((s) => width(s.w));
+        const maxWidth = sugWidths.reduce((max, len) => Math.max(max, len), 0);
+        for (const sug of mappedSugs) {
+            const { cost, dictionaries, w } = sug;
+            const padding = ' '.repeat(padWidth(w, maxWidth));
+            const forbid = sug.forbidden && sug.isPreferred
+                ? chalk.red('*')
+                : sug.forbidden
+                    ? chalk.red('X')
+                    : sug.isPreferred
+                        ? chalk.yellow('*')
+                        : ' ';
+            const ignore = sug.noSuggest ? chalk.yellow('N') : ' ';
+            const strCost = padLeft(cost.toString(10), 4);
+            const dicts = dictionaries.map((n) => chalk.gray(n)).join(', ');
+            output.log(` - ${formatWord(w, sug)}${padding} ${forbid}${ignore} - ${chalk.yellow(strCost)} ${dicts}`);
+        }
+    }
+    else {
+        const mappedSugs = suggestions.map((s) => ({ ...s, word: handleRtl(s.wordAdjustedToMatchCase || s.word) }));
+        for (const r of mappedSugs) {
+            output.log(` - ${formatWordSingle(r)}`);
+        }
+    }
+}
+function formatWord(word, r) {
+    return r.forbidden || r.noSuggest
+        ? chalk.gray(chalk.strikethrough(word))
+        : word === r.wordAdjustedToMatchCase
+            ? diff(word, r.word)
+            : word;
+}
+function diff(wordA, wordB) {
+    const a = [...wordA];
+    const b = [...wordB];
+    const parts = [];
+    for (let idx = 0; idx < a.length; ++idx) {
+        const aa = a[idx];
+        const bb = b[idx];
+        parts.push(aa === bb ? aa : chalk.yellow(aa));
+    }
+    return parts.join('');
+}
+function formatWordSingle(s) {
+    let word = formatWord(s.word, s);
+    word = s.forbidden ? word + chalk.red(' X') : word;
+    word = s.noSuggest ? word + chalk.yellow(' Not suggested.') : word;
+    word = s.isPreferred ? chalk.yellow(word + ' *') : word;
+    return word;
+}
+//# sourceMappingURL=suggestionsEmitter.js.map

package/dist/esm/emitters/suggestionsEmitter.mjs

@@ -74,3 +74,4 @@ function formatWordSingle(s) {
     word = s.isPreferred ? chalk.yellow(word + ' *') : word;
     return word;
 }
+//# sourceMappingURL=suggestionsEmitter.mjs.map

package/dist/esm/emitters/traceEmitter.d.ts

@@ -0,0 +1,21 @@
+import type { TraceResult } from '../application.js';
+import type { DictionaryPathFormat } from './DictionaryPathFormat.js';
+interface PathInterface {
+    relative(from: string, to: string): string;
+    basename(path: string): string;
+    sep: string;
+}
+export interface EmitTraceOptions {
+    /** current working directory */
+    cwd: string;
+    lineWidth?: number;
+    dictionaryPathFormat: DictionaryPathFormat;
+    iPath?: PathInterface;
+}
+export declare function emitTraceResults(results: TraceResult[], options: EmitTraceOptions): void;
+declare function trimMidPath(s: string, w: number, sep: string): string;
+export declare const __testing__: {
+    trimMidPath: typeof trimMidPath;
+};
+export {};
+//# sourceMappingURL=traceEmitter.d.ts.map

package/dist/esm/emitters/traceEmitter.js

@@ -0,0 +1,141 @@
+import chalk from 'chalk';
+import * as iPath from 'path';
+import strip from 'strip-ansi';
+import { pad, width } from '../util/util.js';
+const colWidthDictionaryName = 20;
+export function emitTraceResults(results, options) {
+    const maxWordLength = results
+        .map((r) => r.foundWord || r.word)
+        .reduce((a, b) => Math.max(a, width(b)), 'Word'.length);
+    const maxDictNameLength = results
+        .map((r) => r.dictName.length)
+        .reduce((a, b) => Math.max(a, b), colWidthDictionaryName);
+    const cols = {
+        word: maxWordLength,
+        dictName: maxDictNameLength,
+        terminalWidth: options.lineWidth ?? (process.stdout.columns || 120),
+        location: options.dictionaryPathFormat === 'hide' ? 0 : 30,
+    };
+    const col = new Intl.Collator();
+    results.sort((a, b) => col.compare(a.dictName, b.dictName));
+    emitHeader(cols);
+    results.forEach((r) => emitTraceResult(r, cols, options));
+}
+function emitHeader(colWidths) {
+    const line = [
+        pad('Word', colWidths.word),
+        'F',
+        pad('Dictionary', colWidths.dictName),
+        colWidths.location ? pad('Dictionary Location', colWidths.location) : '',
+    ];
+    console.log(chalk.underline(line.join(' ').trim().slice(0, colWidths.terminalWidth)));
+}
+function emitTraceResult(r, colWidths, options) {
+    const { word: wordColWidth, terminalWidth, dictName: widthName } = colWidths;
+    const errors = r.errors?.map((e) => e.message)?.join('\n\t') || '';
+    const word = pad(r.foundWord || r.word, wordColWidth);
+    const cWord = word.replace(/[+]/g, chalk.yellow('+'));
+    const w = r.forbidden ? chalk.red(cWord) : chalk.green(cWord);
+    const f = calcFoundChar(r);
+    const a = r.dictActive ? '*' : ' ';
+    const dictName = pad(r.dictName.slice(0, widthName - 1) + a, widthName);
+    const dictColor = r.dictActive ? chalk.yellowBright : chalk.rgb(200, 128, 50);
+    const n = dictColor(dictName);
+    const info = [w, f, n].join(' ') + ' ';
+    const used = width(strip(info));
+    const widthSrc = terminalWidth - used;
+    const c = colorize(errors ? chalk.red : chalk.white);
+    const s = c(formatDictionaryLocation(r.dictSource, widthSrc, { iPath, ...options }));
+    const line = info + s;
+    console.log(line.trim());
+    if (errors) {
+        console.error('\t' + chalk.red(errors));
+    }
+}
+function trimMid(s, w) {
+    s = s.trim();
+    if (s.length <= w) {
+        return s;
+    }
+    const l = Math.floor((w - 3) / 2);
+    const r = Math.ceil((w - 3) / 2);
+    return s.slice(0, l) + '...' + s.slice(-r);
+}
+function calcFoundChar(r) {
+    const errors = r.errors?.map((e) => e.message)?.join('\n\t') || '';
+    let color = chalk.dim;
+    color = r.found ? chalk.whiteBright : color;
+    color = r.forbidden ? chalk.red : color;
+    color = r.noSuggest ? chalk.yellowBright : color;
+    color = errors ? chalk.red : color;
+    let char = '-';
+    char = r.found ? '*' : char;
+    char = r.forbidden ? '!' : char;
+    char = r.noSuggest ? 'I' : char;
+    char = errors ? 'X' : char;
+    return color(char);
+}
+function formatDictionaryLocation(dictSource, maxWidth, { cwd, dictionaryPathFormat: format, iPath, }) {
+    let relPath = cwd ? iPath.relative(cwd, dictSource) : dictSource;
+    const idxNodeModule = relPath.lastIndexOf('node_modules');
+    const isNodeModule = idxNodeModule >= 0;
+    if (format === 'hide')
+        return '';
+    if (format === 'short') {
+        const prefix = isNodeModule
+            ? '[node_modules]/'
+            : relPath.startsWith('..' + iPath.sep + '..')
+                ? '.../'
+                : relPath.startsWith('..' + iPath.sep)
+                    ? '../'
+                    : '';
+        return prefix + iPath.basename(dictSource);
+    }
+    if (format === 'full')
+        return dictSource;
+    relPath = isNodeModule ? relPath.slice(idxNodeModule) : relPath;
+    const usePath = relPath.length < dictSource.length ? relPath : dictSource;
+    return trimMidPath(usePath, maxWidth, iPath.sep);
+}
+function colorize(fn) {
+    return (s) => (s ? fn(s) : '');
+}
+function trimMidPath(s, w, sep) {
+    if (s.length <= w)
+        return s;
+    const parts = s.split(sep);
+    if (parts[parts.length - 1].length > w)
+        return trimMid(s, w);
+    function join(left, right) {
+        // if (left === right) return parts.join(sep);
+        return [...parts.slice(0, left), '...', ...parts.slice(right)].join(sep);
+    }
+    let left = 0, right = parts.length, last = '';
+    for (let i = 0; i < parts.length; ++i) {
+        const incLeft = i & 1 ? 1 : 0;
+        const incRight = incLeft ? 0 : -1;
+        const next = join(left + incLeft, right + incRight);
+        if (next.length > w)
+            break;
+        left += incLeft;
+        right += incRight;
+        last = next;
+    }
+    for (let i = left + 1; i < right; ++i) {
+        const next = join(i, right);
+        if (next.length > w)
+            break;
+        last = next;
+    }
+    for (let i = right - 1; i > left; --i) {
+        const next = join(left, i);
+        if (next.length > w)
+            break;
+        last = next;
+    }
+    return last || trimMid(s, w);
+}
+export const __testing__ = {
+    trimMidPath,
+};
+//# sourceMappingURL=traceEmitter.js.map

package/dist/esm/emitters/traceEmitter.mjs

@@ -138,3 +138,4 @@ function trimMidPath(s, w, sep) {
 export const __testing__ = {
     trimMidPath,
 };
+//# sourceMappingURL=traceEmitter.mjs.map

package/dist/esm/featureFlags/featureFlags.d.ts

@@ -0,0 +1,4 @@
+import type { FeatureFlags } from 'cspell-lib';
+export declare function getFeatureFlags(): FeatureFlags;
+export declare function parseFeatureFlags(flags: string[] | undefined, featureFlags?: FeatureFlags): FeatureFlags;
+//# sourceMappingURL=featureFlags.d.ts.map

package/dist/esm/featureFlags/featureFlags.js

@@ -0,0 +1,20 @@
+import { getSystemFeatureFlags } from 'cspell-lib';
+export function getFeatureFlags() {
+    return getSystemFeatureFlags();
+}
+export function parseFeatureFlags(flags, featureFlags = getFeatureFlags()) {
+    if (!flags)
+        return featureFlags;
+    const flagsKvP = flags.map((f) => f.split(':', 2));
+    for (const flag of flagsKvP) {
+        const [name, value] = flag;
+        try {
+            featureFlags.setFlag(name, value);
+        }
+        catch (e) {
+            console.warn(`Unknown flag: "${name}"`);
+        }
+    }
+    return featureFlags;
+}
+//# sourceMappingURL=featureFlags.js.map

package/dist/esm/featureFlags/featureFlags.mjs

@@ -17,3 +17,4 @@ export function parseFeatureFlags(flags, featureFlags = getFeatureFlags()) {
     }
     return featureFlags;
 }
+//# sourceMappingURL=featureFlags.mjs.map

package/dist/esm/featureFlags/index.d.ts

@@ -0,0 +1,2 @@
+export { getFeatureFlags, parseFeatureFlags } from './featureFlags.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/featureFlags/index.js

@@ -0,0 +1,2 @@
+export { getFeatureFlags, parseFeatureFlags } from './featureFlags.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/featureFlags/index.mjs

@@ -1 +1,2 @@
 export { getFeatureFlags, parseFeatureFlags } from './featureFlags.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './application.js';
+export { getReporter as getDefaultReporter } from './cli-reporter.js';
+export type { BaseOptions, LinterCliOptions as CSpellApplicationOptions, TraceOptions } from './options.js';
+export * from '@cspell/cspell-types';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from './application.js';
+export { getReporter as getDefaultReporter } from './cli-reporter.js';
+export * from '@cspell/cspell-types';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
 export * from './application.mjs';
 export { getReporter as getDefaultReporter } from './cli-reporter.mjs';
 export * from '@cspell/cspell-types';
+//# sourceMappingURL=index.mjs.map