cspell 9.1.2 → 9.1.5

package/dist/esm/commandDictionaries.js

@@ -1,40 +0,0 @@
-import * as App from './application.mjs';
-import { crOpt } from './commandHelpers.js';
-import { emitListDictionariesResults } from './emitters/dictionaryListEmitter.js';
-import { isDictionaryPathFormat } from './emitters/DictionaryPathFormat.js';
-import { canUseColor } from './util/canUseColor.js';
-// interface InitOptions extends Options {}
-export function commandDictionaries(prog) {
-    return prog
-        .command('dictionaries')
-        .description(`List dictionaries`)
-        .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
-        .addOption(crOpt('--path-format <format>', 'Configure how to display the dictionary path.')
-        .choices(['hide', 'short', 'long', 'full'])
-        .default('long', 'Display most of the path.'))
-        .addOption(crOpt('--enabled', 'Show only enabled dictionaries.').default(undefined))
-        .addOption(crOpt('--no-enabled', 'Do not show enabled dictionaries.'))
-        .option('--locale <locale>', 'Set language locales. i.e. "en,fr" for English and French, or "en-GB" for British English.')
-        .option('--file-type <fileType>', 'File type to use. i.e. "html", "golang", or "javascript".')
-        .option('--no-show-location', 'Do not show the location of the dictionary.')
-        .option('--show-file-types', 'Show the file types supported by the dictionary.', false)
-        .addOption(crOpt('--no-show-file-types', 'Do not show the file types supported by the dictionary.').hideHelp())
-        .option('--show-locales', 'Show the language locales supported by the dictionary.', false)
-        .addOption(crOpt('--no-show-locales', 'Do not show the locales supported by the dictionary.').hideHelp())
-        .addOption(crOpt('--color', 'Force color.').default(undefined))
-        .addOption(crOpt('--no-color', 'Turn off color.').default(undefined))
-        .addOption(crOpt('--default-configuration', 'Load the default configuration and dictionaries.').hideHelp())
-        .addOption(crOpt('--no-default-configuration', 'Do not load the default configuration and dictionaries.'))
-        .action(async (options) => {
-        const dictionaryPathFormat = isDictionaryPathFormat(options.pathFormat) ? options.pathFormat : 'long';
-        const useColor = canUseColor(options.color);
-        const listResult = await App.listDictionaries(options);
-        emitListDictionariesResults(listResult, {
-            cwd: process.cwd(),
-            dictionaryPathFormat,
-            color: useColor,
-            options,
-        });
-    });
-}
-//# sourceMappingURL=commandDictionaries.js.map

package/dist/esm/commandHelpers.d.ts

@@ -1,18 +0,0 @@
-import { Option as CommanderOption } from 'commander';
-/**
- * Collects string values into an array.
- * @param value the new value(s) to collect.
- * @param previous the previous values.
- * @returns the new values appended to the previous values.
- */
-export declare function collect(value: string | string[], previous: string[] | undefined): string[];
-/**
- * Create Option - a helper function to create a commander option.
- * @param name - the name of the option
- * @param description - the description of the option
- * @param parseArg - optional function to parse the argument
- * @param defaultValue - optional default value
- * @returns CommanderOption
- */
-export declare function crOpt<T>(name: string, description: string, parseArg?: (value: string, previous: T) => T, defaultValue?: T): CommanderOption;
-//# sourceMappingURL=commandHelpers.d.ts.map

package/dist/esm/commandHelpers.js

@@ -1,30 +0,0 @@
-import { Option as CommanderOption } from 'commander';
-/**
- * Collects string values into an array.
- * @param value the new value(s) to collect.
- * @param previous the previous values.
- * @returns the new values appended to the previous values.
- */
-export function collect(value, previous) {
-    const values = Array.isArray(value) ? value : [value];
-    return previous ? [...previous, ...values] : values;
-}
-/**
- * Create Option - a helper function to create a commander option.
- * @param name - the name of the option
- * @param description - the description of the option
- * @param parseArg - optional function to parse the argument
- * @param defaultValue - optional default value
- * @returns CommanderOption
- */
-export function crOpt(name, description, parseArg, defaultValue) {
-    const option = new CommanderOption(name, description);
-    if (parseArg) {
-        option.argParser(parseArg);
-    }
-    if (defaultValue !== undefined) {
-        option.default(defaultValue);
-    }
-    return option;
-}
-//# sourceMappingURL=commandHelpers.js.map

package/dist/esm/commandInit.d.ts

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

package/dist/esm/commandInit.js

@@ -1,25 +0,0 @@
-import { createInit } from './application.mjs';
-import { collect, crOpt } from './commandHelpers.js';
-export function commandInit(prog) {
-    const command = prog
-        .command('init')
-        .description('Initialize a CSpell configuration file.')
-        .addOption(crOpt('-c, --config <path>', 'Path to the CSpell configuration file. Conflicts with --output and --format.').conflicts(['output', 'format']))
-        .option('-o, --output <path>', 'Define where to write file.')
-        .addOption(crOpt('--format <format>', 'Define the format of the file.')
-        .choices(['yaml', 'yml', 'json', 'jsonc'])
-        .default('yaml'))
-        .option('--import <path|package>', 'Import a configuration file or dictionary package.', collect)
-        .option('--locale <locale>', 'Define the locale to use when spell checking (e.g., en, en-US, de).')
-        .addOption(crOpt('--dictionary <dictionary>', 'Enable a dictionary. Can be used multiple times.', collect).default(undefined))
-        .addOption(crOpt('--comments', 'Add comments to the config file.').default(undefined).hideHelp())
-        .option('--no-comments', 'Do not add comments to the config file.')
-        .addOption(crOpt('--remove-comments', 'Remove all comments from the config file.').implies({ comments: false }))
-        .option('--no-schema', 'Do not add the schema reference to the config file.')
-        .option('--stdout', 'Write the configuration to stdout instead of a file.')
-        .action((options) => {
-        return createInit(options);
-    });
-    return command;
-}
-//# sourceMappingURL=commandInit.js.map

package/dist/esm/commandLink.d.ts

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

package/dist/esm/commandLink.js

@@ -1,48 +0,0 @@
-import { console } from './console.js';
-import { addPathsToGlobalImports, addPathsToGlobalImportsResultToTable, listGlobalImports, listGlobalImportsResultToTable, removePathsFromGlobalImports, } from './link.js';
-import { CheckFailed } from './util/errors.js';
-import { tableToLines } from './util/table.js';
-export function commandLink(prog) {
-    const linkCommand = prog
-        .command('link')
-        .description('Link dictionaries and other settings to the cspell global config.');
-    linkCommand
-        .command('list', { isDefault: true })
-        .alias('ls')
-        .description('List currently linked configurations.')
-        .action(async () => {
-        const imports = await listGlobalImports();
-        const table = listGlobalImportsResultToTable(imports.list);
-        tableToLines(table).forEach((line) => console.log(line));
-        return;
-    });
-    linkCommand
-        .command('add <dictionaries...>')
-        .alias('a')
-        .description('Add dictionaries any other settings to the cspell global config.')
-        .action(async (dictionaries) => {
-        const r = await addPathsToGlobalImports(dictionaries);
-        const table = addPathsToGlobalImportsResultToTable(r);
-        console.log('Adding:');
-        tableToLines(table).forEach((line) => console.log(line));
-        if (r.error) {
-            throw new CheckFailed(r.error, 1);
-        }
-        return;
-    });
-    linkCommand
-        .command('remove <paths...>')
-        .alias('r')
-        .description('Remove matching paths / packages from the global config.')
-        .action(async (dictionaries) => {
-        const r = await removePathsFromGlobalImports(dictionaries);
-        console.log('Removing:');
-        if (r.error) {
-            throw new CheckFailed(r.error, 1);
-        }
-        r.removed.map((f) => console.log(f));
-        return;
-    });
-    return linkCommand;
-}
-//# sourceMappingURL=commandLink.js.map

package/dist/esm/commandLint.d.ts

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

package/dist/esm/commandLint.js

@@ -1,226 +0,0 @@
-import * as App from './application.mjs';
-import { collect, crOpt } from './commandHelpers.js';
-import { ReportChoicesAll } from './options.js';
-import { DEFAULT_CACHE_LOCATION } from './util/cache/index.js';
-import { canUseColor } from './util/canUseColor.js';
-import { CheckFailed } from './util/errors.js';
-import { unindent } from './util/unindent.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.
-
-    cspell "*.md" --exclude CHANGELOG.md --files README.md CHANGELOG.md
-        Spell check only check "README.md" but NOT "CHANGELOG.md".
-
-    cspell "/*.md" --no-must-find-files --files $FILES
-        Only spell check the "/*.md" files in $FILES,
-        where $FILES is a shell variable that contains the list of files.
-
-    cspell --help --verbose
-        Show all options including hidden options.
-
-References:
-    https://cspell.org
-    https://github.com/streetsidesoftware/cspell
-`;
-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.')
-        .addOption(crOpt('--config-search', 'Allow searching for configuration files.', undefined).hideHelp())
-        .option('--no-config-search', 'Disable automatic searching for additional configuration files in parent directories. Only the specified config file (if any) will be used.')
-        .option('--stop-config-search-at <dir>', 'Specify a directory at which to stop searching for configuration files when walking up from the files being checked. Useful for limiting config inheritance.', collect)
-        .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 <file-type>', 'Force programming language for unknown extensions. i.e. "php" or "scala"')
-        .addOption(crOpt('--languageId <file-type>', 'Alias of "--language-id". 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(crOpt('--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('--include <glob>', 'Include files matching the glob pattern. This option can be used multiple times.', 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('--file [file...]', 'Specify files to spell check. They are filtered by the [globs...].', collect)
-        .addOption(crOpt('--files [file...]', 'Alias of "--file". Files to spell check.', collect).hideHelp())
-        .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.')
-        .option('--no-exit-code', 'Do not return an exit code if issues are found.')
-        .addOption(crOpt('--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(crOpt('--no-fail-fast', 'Process all files even if there is an error.').hideHelp())
-        .option('--continue-on-error', 'Continue processing files even if there is a configuration error.')
-        .option('-r, --root <root folder>', 'Root directory, defaults to current directory.')
-        .addOption(crOpt('--relative', 'Issues are displayed relative to the root.').default(true).hideHelp())
-        .option('--no-relative', 'Issues are displayed with absolute path instead of relative to the root.')
-        .option('--show-context', 'Show the surrounding text around an issue.')
-        .option('--show-suggestions', 'Show spelling suggestions.')
-        .addOption(crOpt('--no-show-suggestions', 'Do not show spelling suggestions or fixes.').default(undefined))
-        .addOption(crOpt('--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 --filter-files option is still under design review.
-        // .option('--filter-files', 'Use the `files` configuration to filter files found.')
-        // .option(
-        //     '--no-filter-files',
-        //     'Do NOT use the `files` configuration to filter files (Only applies to --files options).',
-        // )
-        // 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(crOpt('--legacy', 'Legacy output').hideHelp())
-        .addOption(crOpt('--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(crOpt('--cache-strategy <strategy>', 'Strategy to use for detecting changed files.')
-        .choices(['content', 'metadata'])
-        .default('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.')
-        .addOption(crOpt('--no-validate-directives', 'Do not validate in-document CSpell directives.').hideHelp())
-        .addOption(crOpt('--color', 'Force color.').default(undefined))
-        .addOption(crOpt('--no-color', 'Turn off color.').default(undefined))
-        .addOption(crOpt('--default-configuration', 'Load the default configuration and dictionaries.').hideHelp())
-        .addOption(crOpt('--no-default-configuration', 'Do not load the default configuration and dictionaries.'))
-        .option('--dictionary <name>', 'Enable a dictionary by name.', collect)
-        .option('--disable-dictionary <name>', 'Disable a dictionary by name.', collect)
-        .option('--reporter <module|path>', 'Specify one or more reporters to use.', collect)
-        .addOption(crOpt('--report <level>', 'Set how unknown words are reported').choices(ReportChoicesAll))
-        .addOption(crOpt('--skip-validation', 'Collect and process documents, but do not spell check.')
-        .implies({ cache: false })
-        .hideHelp())
-        .addOption(crOpt('--issues-summary-report', 'Output a summary of issues found.').hideHelp())
-        .addOption(crOpt('--show-perf-summary', 'Output a performance summary report.').hideHelp())
-        .option('--issue-template [template]', 'Use a custom issue template. See --help --issue-template for details.')
-        .addOption(crOpt('--debug', 'Output information useful for debugging cspell.json files.').hideHelp())
-        // Planned options
-        // .option('--import', 'Import a configuration file.', collect)
-        .usage(usage)
-        .addHelpText('after', augmentCommandHelp)
-        .arguments('[globs...]')
-        .action(async (fileGlobs, options) => {
-        // console.error('lint: %o', { fileGlobs, options });
-        const useExitCode = options.exitCode ?? true;
-        if (options.skipValidation) {
-            options.cache = false;
-        }
-        options.color ??= canUseColor(options.color);
-        App.parseApplicationFeatureFlags(options.flag);
-        const { mustFindFiles, fileList, files, file } = options;
-        const result = await App.lint(fileGlobs, options);
-        if (!fileGlobs.length && !result.files && !result.errors && !fileList && !files?.length && !file?.length) {
-            spellCheckCommand.outputHelp();
-            throw new CheckFailed('outputHelp', 1);
-        }
-        if (result.errors || (mustFindFiles && !result.files)) {
-            throw new CheckFailed('check failed', 1);
-        }
-        if (result.issues) {
-            const exitCode = useExitCode ? 1 : 0;
-            throw new CheckFailed('check failed', exitCode);
-        }
-        return;
-    });
-    return spellCheckCommand;
-}
-function helpIssueTemplate(opts) {
-    if (!('issueTemplate' in opts))
-        return '';
-    return unindent `
-      Issue Template:
-        Use "--issue-template"  to set the template to use when reporting issues.
-
-        The template is a string that can contain the following placeholders:
-        - $filename - the file name
-        - $col - the column number
-        - $row - the row number
-        - $text - the word that is misspelled
-        - $message - the issues message: "unknown word", "word is misspelled", etc.
-        - $messageColored - the issues message with color based upon the message type.
-        - $uri - the URI of the file
-        - $suggestions - suggestions for the misspelled word (if requested)
-        - $quickFix - possible quick fixes for the misspelled word.
-        - $contextFull - the full context of the misspelled word.
-        - $contextLeft - the context to the left of the misspelled word.
-        - $contextRight - the context to the right of the misspelled word.
-
-        Color is supported using the following template pattern:
-        - \`{<style[.style]> <text>}\` - where \`<style>\` is a style name and \`<text>\` is the text to style.
-
-        Styles
-        - \`bold\`, \`italic\`, \`underline\`, \`strikethrough\`, \`dim\`, \`inverse\`
-        - \`black\`, \`red\`, \`green\`, \`yellow\`, \`blue\`, \`magenta\`, \`cyan\`, \`white\`
-
-        Example:
-          --issue-template '{green $filename}:{yellow $row}:{yellow $col} $message {red $text} $quickFix {dim $suggestions}'
-    `;
-}
-/**
- * Add additional help text to the command.
- * When the verbose flag is set, show the hidden options.
- * @param context
- * @returns
- */
-function augmentCommandHelp(context) {
-    const output = [];
-    const command = context.command;
-    const opts = command.opts();
-    const showHidden = !!opts.verbose;
-    const hiddenHelp = [];
-    const help = command.createHelp();
-    help.helpWidth = process.stdout.columns || 80;
-    const hiddenOptions = command.options.filter((opt) => opt.hidden && showHidden);
-    const flagColWidth = Math.max(...command.options.map((opt) => opt.flags.length), 0);
-    // const indent = flagColWidth + 4;
-    for (const options of hiddenOptions) {
-        if (!hiddenHelp.length) {
-            hiddenHelp.push('\nHidden Options:');
-        }
-        hiddenHelp.push(help.formatItem(options.flags, flagColWidth, options.description, help));
-    }
-    output.push(...hiddenHelp, advanced);
-    return helpIssueTemplate(opts) + output.join('\n');
-}
-//# sourceMappingURL=commandLint.js.map

package/dist/esm/commandSuggestion.d.ts

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

package/dist/esm/commandSuggestion.js

@@ -1,61 +0,0 @@
-import { Option as CommanderOption } from 'commander';
-import * as App from './application.mjs';
-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, value];
-}
-function count(_, previous) {
-    return (previous || 0) + 1;
-}
-function asNumber(value, prev) {
-    return Number.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, ...b];
-}
-//# sourceMappingURL=commandSuggestion.js.map

package/dist/esm/commandTrace.d.ts

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

package/dist/esm/commandTrace.js

@@ -1,91 +0,0 @@
-import { Option as CommanderOption } from 'commander';
-import * as App from './application.mjs';
-import { collect } from './commandHelpers.js';
-import { console } from './console.js';
-import { isDictionaryPathFormat } from './emitters/DictionaryPathFormat.js';
-import { emitTraceResults } from './emitters/traceEmitter.js';
-import { canUseColor } from './util/canUseColor.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.')
-        .option('--dictionary <name>', 'Enable a dictionary by name. Can be used multiple times.', collect)
-        .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'))
-        .addOption(new CommanderOption('--color', 'Force color.').default(undefined))
-        .addOption(new CommanderOption('--no-color', 'Turn off color.').default(undefined))
-        .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';
-        let prefix = '';
-        const useColor = canUseColor(options.color);
-        for await (const results of App.trace(words, options)) {
-            const byWord = groupBy(results, (r) => r.word);
-            for (const split of results.splits) {
-                const splitResults = byWord.get(split.word) || [];
-                const filtered = filterTraceResults(splitResults, options);
-                emitTraceResults(split.word, split.found, filtered, {
-                    cwd: process.cwd(),
-                    dictionaryPathFormat,
-                    prefix,
-                    showWordFound: results.splits.length > 1,
-                    color: useColor,
-                });
-                prefix = '\n';
-                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 ||
-        !!result.preferredSuggestions ||
-        (!onlyFound && result.dictActive));
-}
-function groupBy(items, key) {
-    const map = new Map();
-    for (const item of items) {
-        const k = key(item);
-        const a = map.get(k) || [];
-        a.push(item);
-        map.set(k, a);
-    }
-    return map;
-}
-//# sourceMappingURL=commandTrace.js.map

package/dist/esm/config/adjustConfig.d.ts

@@ -1,7 +0,0 @@
-import { CSpellSettings } from '@cspell/cspell-types';
-import { CSpellConfigFile } from 'cspell-config-lib';
-export declare function resolveImports(configFile: CSpellConfigFile, imports: string[]): Promise<string[]>;
-export declare function addImportsToConfigFile(configFile: CSpellConfigFile, imports: string[], comment: string | undefined): Promise<void>;
-export declare function setConfigFieldValue<K extends keyof CSpellSettings>(configFile: CSpellConfigFile, key: K, value: CSpellSettings[K], comment?: string | undefined): void;
-export declare function addDictionariesToConfigFile(configFile: CSpellConfigFile, dictionaries: string[], comment?: string | undefined): void;
-//# sourceMappingURL=adjustConfig.d.ts.map