cspell 5.16.0 → 5.17.0-alpha.0

package/README.md

@@ -11,6 +11,9 @@ A Spell Checker for Code!
 ## Support Future Development
 
 - Become a [<img src="https://github.githubassets.com/images/modules/site/icons/funding_platforms/patreon.svg" width="16" height="16" alt="Patreon">Patreon!](https://patreon.com/streetsidesoftware)
+- [Support through ![PayPal](https://raw.githubusercontent.com/streetsidesoftware/vscode-spell-checker/main/images/PayPal/paypal-logo-wide-18.png)](https://www.paypal.com/donate/?hosted_button_id=26LNBP2Q6MKCY)
+- [Open Collective](https://opencollective.com/cspell)
+- [Street Side Software](https://streetsidesoftware.com/support)
 
 ## Features
 
@@ -110,6 +113,7 @@ Options:
   --no-progress                Turn off progress messages
   --no-summary                 Turn off summary message in console.
   -s, --silent                 Silent mode, suppress error messages.
+  --fail-fast                  Exit after first file with an issue or error.
   -r, --root <root folder>     Root directory, defaults to current directory.
   --relative                   Issues are displayed relative to root.
   --show-context               Show the surrounding text around an issue.
@@ -206,7 +210,7 @@ npm install -SD cspell
 ```
 #!/bin/sh
 
-exec git diff --cached --name-only | npx cspell -- --no-summary --no-progress --no-must-find-files --file-list stdin
+exec git diff --cached --name-only | npx cspell --no-summary --no-progress --no-must-find-files --file-list stdin
 ```
 
 ## Requirements

package/dist/app.js

@@ -27,6 +27,7 @@ const commandCheck_1 = require("./commandCheck");
 const commandLink_1 = require("./commandLink");
 const commandLint_1 = require("./commandLint");
 const commandTrace_1 = require("./commandTrace");
+const commandSuggestion_1 = require("./commandSuggestion");
 const errors_1 = require("./util/errors");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const npmPackage = require(path.join(__dirname, '..', 'package.json'));
@@ -44,6 +45,7 @@ async function run(program, argv) {
     (0, commandTrace_1.commandTrace)(prog);
     (0, commandCheck_1.commandCheck)(prog);
     (0, commandLink_1.commandLink)(prog);
+    (0, commandSuggestion_1.commandSuggestion)(prog);
     /*
         program
             .command('init')

package/dist/application.d.ts

@@ -1,13 +1,15 @@
 /// <reference types="node" />
 import type { CSpellReporter, RunResult } from '@cspell/cspell-types';
+import * as cspell from 'cspell-lib';
 import { CheckTextInfo, TraceResult } from 'cspell-lib';
-import { BaseOptions, LinterOptions, TraceOptions } from './options';
+import { BaseOptions, LegacyOptions, LinterOptions, SuggestionOptions, TraceOptions } from './options';
 export { IncludeExcludeFlag } from 'cspell-lib';
 export type { TraceResult } from 'cspell-lib';
 export declare type AppError = NodeJS.ErrnoException;
 export declare function lint(fileGlobs: string[], options: LinterOptions, emitters: CSpellReporter): Promise<RunResult>;
-export declare function trace(words: string[], options: TraceOptions): Promise<TraceResult[]>;
+export declare function trace(words: string[], options: TraceOptions): AsyncIterableIterator<TraceResult[]>;
 export declare type CheckTextResult = CheckTextInfo;
-export declare function checkText(filename: string, options: BaseOptions): Promise<CheckTextResult>;
+export declare function checkText(filename: string, options: BaseOptions & LegacyOptions): Promise<CheckTextResult>;
+export declare function suggestions(words: string[], options: SuggestionOptions): AsyncIterable<cspell.SuggestionsForWordResult>;
 export declare function createInit(): Promise<void>;
 //# sourceMappingURL=application.d.ts.map

package/dist/application.js

@@ -19,30 +19,35 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInit = exports.checkText = exports.trace = exports.lint = exports.IncludeExcludeFlag = void 0;
+exports.createInit = exports.suggestions = exports.checkText = exports.trace = exports.lint = exports.IncludeExcludeFlag = void 0;
 const cspell = __importStar(require("cspell-lib"));
 const cspell_lib_1 = require("cspell-lib");
 const path = __importStar(require("path"));
-const fileHelper_1 = require("./fileHelper");
+const fileHelper_1 = require("./util/fileHelper");
 const lint_1 = require("./lint");
+const options_1 = require("./options");
+const stdin_1 = require("./util/stdin");
 const util = __importStar(require("./util/util"));
+const async = __importStar(require("./util/async"));
 var cspell_lib_2 = require("cspell-lib");
 Object.defineProperty(exports, "IncludeExcludeFlag", { enumerable: true, get: function () { return cspell_lib_2.IncludeExcludeFlag; } });
 function lint(fileGlobs, options, emitters) {
+    options = (0, options_1.fixLegacy)(options);
     const cfg = new lint_1.LintRequest(fileGlobs, options, emitters);
     return (0, lint_1.runLint)(cfg);
 }
 exports.lint = lint;
-async function trace(words, options) {
-    const { local } = options;
-    const { languageId, locale = local, allowCompoundWords, ignoreCase } = options;
+async function* trace(words, options) {
+    options = (0, options_1.fixLegacy)(options);
+    const iWords = options.stdin ? async.mergeAsyncIterables(words, (0, stdin_1.readStdin)()) : words;
+    const { languageId, locale, allowCompoundWords, ignoreCase } = options;
     const configFile = await (0, fileHelper_1.readConfig)(options.config, undefined);
     const config = cspell.mergeSettings(cspell.getDefaultSettings(), cspell.getGlobalSettings(), configFile.config);
-    const results = await (0, cspell_lib_1.traceWords)(words, config, { languageId, locale, ignoreCase, allowCompoundWords });
-    return results;
+    yield* (0, cspell_lib_1.traceWordsAsync)(iWords, config, { languageId, locale, ignoreCase, allowCompoundWords });
 }
 exports.trace = trace;
 async function checkText(filename, options) {
+    options = (0, options_1.fixLegacy)(options);
     const pSettings = (0, fileHelper_1.readConfig)(options.config, path.dirname(filename));
     const [foundSettings, text] = await Promise.all([pSettings, (0, fileHelper_1.readFile)(filename)]);
     const settingsFromCommandLine = util.clean({
@@ -53,6 +58,22 @@ async function checkText(filename, options) {
     return cspell.checkText(text, info.configInfo.config);
 }
 exports.checkText = checkText;
+async function* suggestions(words, options) {
+    options = (0, options_1.fixLegacy)(options);
+    const configFile = await (0, fileHelper_1.readConfig)(options.config, undefined);
+    const iWords = options.useStdin ? async.mergeAsyncIterables(words, (0, stdin_1.readStdin)()) : words;
+    try {
+        const results = (0, cspell_lib_1.suggestionsForWords)(iWords, options, configFile.config);
+        yield* results;
+    }
+    catch (e) {
+        if (!(e instanceof cspell_lib_1.SuggestionError))
+            throw e;
+        console.error(e.message);
+        process.exitCode = 1;
+    }
+}
+exports.suggestions = suggestions;
 function createInit() {
     return Promise.reject();
 }

package/dist/commandLink.js

@@ -7,7 +7,7 @@ const table_1 = require("./util/table");
 function commandLink(prog) {
     const linkCommand = prog
         .command('link')
-        .description('Link dictionaries any other settings to the cspell global config.');
+        .description('Link dictionaries and other settings to the cspell global config.');
     linkCommand
         .command('list', { isDefault: true })
         .alias('ls')

package/dist/commandLint.js

@@ -62,6 +62,8 @@ 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.')
+        .option('--fail-fast', 'Exit after first file with an issue or error.')
+        .addOption(new commander_1.Option('--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.')

package/dist/commandSuggestion.d.ts

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

package/dist/commandSuggestion.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commandSuggestion = void 0;
+const commander_1 = require("commander");
+const App = __importStar(require("./application"));
+const suggestionsEmitter_1 = require("./emitters/suggestionsEmitter");
+const errors_1 = require("./util/errors");
+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) {
+    var _a;
+    return (_a = parseInt(value, 10)) !== null && _a !== void 0 ? _a : prev;
+}
+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 commander_1.Option('--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.')
+        .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) => {
+        options.useStdin = options.stdin;
+        options.dictionaries = mergeArrays(options.dictionaries, options.dictionary);
+        if (!words.length && !options.useStdin) {
+            suggestionCommand.outputHelp();
+            throw new errors_1.CheckFailed('outputHelp', 1);
+        }
+        for await (const r of App.suggestions(words, options)) {
+            (0, suggestionsEmitter_1.emitSuggestionResult)(r, options);
+        }
+    });
+    return suggestionCommand;
+}
+exports.commandSuggestion = commandSuggestion;
+function mergeArrays(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return a.concat(b);
+}
+//# sourceMappingURL=commandSuggestion.js.map

package/dist/commandTrace.js

@@ -22,13 +22,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.commandTrace = void 0;
 const commander_1 = require("commander");
 const App = __importStar(require("./application"));
-const traceEmitter_1 = require("./traceEmitter");
+const traceEmitter_1 = require("./emitters/traceEmitter");
 const errors_1 = require("./util/errors");
 function commandTrace(prog) {
     return prog
         .command('trace')
-        .description(`Trace words
-  Search for words in the configuration and dictionaries.`)
+        .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"')
@@ -37,22 +36,25 @@ function commandTrace(prog) {
         .addOption(new commander_1.Option('--allowCompoundWords', 'Turn on allowCompoundWords').hideHelp())
         .option('--no-allow-compound-words', 'Turn off allowCompoundWords')
         .option('--no-ignore-case', 'Do not ignore case and accents when searching for words')
+        .option('--stdin', 'Read words from stdin.')
         .option('--no-color', 'Turn off color.')
         .option('--color', 'Force color')
-        .arguments('<words...>')
+        .arguments('[words...]')
         .action(async (words, options) => {
-        const results = await App.trace(words, options);
-        (0, traceEmitter_1.emitTraceResults)(results, { cwd: process.cwd() });
-        const numFound = results.reduce((n, r) => n + (r.found ? 1 : 0), 0);
+        let numFound = 0;
+        for await (const results of App.trace(words, options)) {
+            (0, traceEmitter_1.emitTraceResults)(results, { cwd: process.cwd() });
+            numFound += results.reduce((n, r) => n + (r.found ? 1 : 0), 0);
+            const numErrors = results.map((r) => { var _a; return ((_a = r.errors) === null || _a === void 0 ? void 0 : _a.length) || 0; }).reduce((n, r) => n + r, 0);
+            if (numErrors) {
+                console.error('Dictionary Errors.');
+                throw new errors_1.CheckFailed('dictionary errors', 1);
+            }
+        }
         if (!numFound) {
             console.error('No matches found');
             throw new errors_1.CheckFailed('no matches', 1);
         }
-        const numErrors = results.map((r) => { var _a; return ((_a = r.errors) === null || _a === void 0 ? void 0 : _a.length) || 0; }).reduce((n, r) => n + r, 0);
-        if (numErrors) {
-            console.error('Dictionary Errors.');
-            throw new errors_1.CheckFailed('dictionary errors', 1);
-        }
     });
 }
 exports.commandTrace = commandTrace;

package/dist/emitters/suggestionsEmitter.d.ts

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

package/dist/emitters/suggestionsEmitter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitSuggestionResult = void 0;
+const chalk = require("chalk");
+const util_1 = require("../util/util");
+function emitSuggestionResult(result, options) {
+    const { word, suggestions } = result;
+    const { verbose, output = console } = options;
+    output.log(word ? chalk.green(word) : chalk.yellow('<empty>') + ':');
+    if (!suggestions.length) {
+        console.log(chalk.yellow(' <no suggestions>'));
+        return;
+    }
+    if (verbose) {
+        const maxWidth = suggestions.map((r) => r.word.length).reduce((max, len) => Math.max(max, len), 0);
+        for (const sug of suggestions) {
+            const { word, cost, dictionaries } = sug;
+            const padding = ' '.repeat(maxWidth - word.length);
+            const forbid = sug.forbidden ? chalk.red('X') : ' ';
+            const ignore = sug.noSuggest ? chalk.yellow('N') : ' ';
+            const strCost = (0, util_1.padLeft)(cost.toString(10), 4);
+            const dicts = dictionaries.map((n) => chalk.gray(n)).join(', ');
+            output.log(` - ${formatWord(word, sug)}${padding} ${forbid}${ignore} - ${chalk.yellow(strCost)} ${dicts}`);
+        }
+    }
+    else {
+        for (const r of suggestions) {
+            output.log(` - ${formatWordSingle(r)}`);
+        }
+    }
+}
+exports.emitSuggestionResult = emitSuggestionResult;
+function formatWord(word, r) {
+    return r.forbidden || r.noSuggest ? chalk.gray(chalk.strikethrough(word)) : word;
+}
+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;
+    return word;
+}
+//# sourceMappingURL=suggestionsEmitter.js.map

package/dist/{traceEmitter.d.ts → emitters/traceEmitter.d.ts}

@@ -1,4 +1,4 @@
-import { TraceResult } from './application';
+import { TraceResult } from '../application';
 export interface EmitTraceOptions {
     /** current working directory */
     cwd: string;

package/dist/{traceEmitter.js → emitters/traceEmitter.js}

@@ -23,9 +23,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitTraceResults = void 0;
-const chalk = require("chalk");
-const strip_ansi_1 = __importDefault(require("strip-ansi"));
 const Path = __importStar(require("path"));
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const util_1 = require("../util/util");
+const chalk = require("chalk");
 const colWidthDictionaryName = 20;
 function emitTraceResults(results, options) {
     var _a;
@@ -45,10 +46,10 @@ function emitTraceResults(results, options) {
 exports.emitTraceResults = emitTraceResults;
 function emitHeader(colWidths) {
     const line = [
-        pad('Word', colWidths.word),
+        (0, util_1.pad)('Word', colWidths.word),
         'F',
-        pad('Dictionary', colWidths.dictName),
-        pad('Dictionary Location', 30),
+        (0, util_1.pad)('Dictionary', colWidths.dictName),
+        (0, util_1.pad)('Dictionary Location', 30),
     ];
     console.log(chalk.underline(line.join(' ').slice(0, colWidths.terminalWidth)));
 }
@@ -56,12 +57,12 @@ function emitTraceResult(r, colWidths, options) {
     var _a, _b;
     const { word: wordColWidth, terminalWidth, dictName: widthName } = colWidths;
     const errors = ((_b = (_a = r.errors) === null || _a === void 0 ? void 0 : _a.map((e) => e.message)) === null || _b === void 0 ? void 0 : _b.join('\n\t')) || '';
-    const word = pad(r.foundWord || r.word, wordColWidth);
+    const word = (0, util_1.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 dictName = (0, util_1.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(' ') + ' ';
@@ -75,9 +76,6 @@ function emitTraceResult(r, colWidths, options) {
         console.error('\t' + chalk.red(errors));
     }
 }
-function pad(s, w) {
-    return (s + ' '.repeat(w)).substr(0, w);
-}
 function trimMid(s, w) {
     s = s.trim();
     if (s.length <= w) {
@@ -85,7 +83,7 @@ function trimMid(s, w) {
     }
     const l = Math.floor((w - 3) / 2);
     const r = Math.ceil((w - 3) / 2);
-    return s.substr(0, l) + '...' + s.substr(-r);
+    return s.slice(0, l) + '...' + s.slice(-r);
 }
 function calcFoundChar(r) {
     var _a, _b;

package/dist/lint/LintRequest.js

@@ -32,7 +32,7 @@ class LintRequest {
         this.root = path.resolve(options.root || process.cwd());
         this.configFile = options.config;
         this.excludes = (0, glob_1.calcExcludeGlobInfo)(this.root, options.exclude);
-        this.locale = options.locale || options.local || '';
+        this.locale = options.locale || '';
         this.enableGlobDot = options.dot;
         this.uniqueFilter = options.unique ? util.uniqueFilterFnGenerator((issue) => issue.text) : () => true;
         this.showContext =

package/dist/lint/lint.js

@@ -28,16 +28,16 @@ const cspell = __importStar(require("cspell-lib"));
 const path = __importStar(require("path"));
 const util_1 = require("util");
 const vscode_uri_1 = require("vscode-uri");
-const fileHelper_1 = require("../fileHelper");
+const fileHelper_1 = require("../util/fileHelper");
 const cache_1 = require("../util/cache");
 const errors_1 = require("../util/errors");
 const glob_1 = require("../util/glob");
 const reporters_1 = require("../util/reporters");
 const timer_1 = require("../util/timer");
 const util = __importStar(require("../util/util"));
+const async_1 = require("../util/async");
 async function runLint(cfg) {
     let { reporter } = cfg;
-    const { fileLists } = cfg;
     cspell.setLogger(getLoggerFromReporter(reporter));
     const configErrors = new Set();
     const lintResult = await run();
@@ -108,13 +108,15 @@ async function runLint(cfg) {
         return { ...tdo, context };
     }
     async function processFiles(files, configInfo, cacheSettings) {
-        const fileCount = files.length;
+        var _a, _b;
+        const fileCount = files instanceof Array ? files.length : undefined;
         const status = runResult();
         const cache = (0, cache_1.createCache)(cacheSettings);
+        const failFast = (_b = (_a = cfg.options.failFast) !== null && _a !== void 0 ? _a : configInfo.config.failFast) !== null && _b !== void 0 ? _b : false;
         const emitProgress = (filename, fileNum, result) => reporter.progress({
             type: 'ProgressFileComplete',
             fileNum,
-            fileCount,
+            fileCount: fileCount !== null && fileCount !== void 0 ? fileCount : fileNum,
             filename,
             elapsedTimeMs: result === null || result === void 0 ? void 0 : result.elapsedTimeMs,
             processed: result === null || result === void 0 ? void 0 : result.processed,
@@ -122,10 +124,11 @@ async function runLint(cfg) {
             cached: result === null || result === void 0 ? void 0 : result.cached,
         });
         async function* loadAndProcessFiles() {
-            for (let i = 0; i < files.length; i++) {
-                const filename = files[i];
+            let i = 0;
+            for await (const filename of files) {
+                ++i;
                 const result = await processFile(filename, configInfo, cache);
-                yield { filename, fileNum: i + 1, result };
+                yield { filename, fileNum: i, result };
             }
         }
         for await (const fileP of loadAndProcessFiles()) {
@@ -139,6 +142,9 @@ async function runLint(cfg) {
                 status.filesWithIssues.add(filename);
                 status.issues += result.issues.length;
                 status.errors += result.errors;
+                if (failFast) {
+                    return status;
+                }
             }
             status.errors += result.configErrors;
         }
@@ -180,25 +186,15 @@ async function runLint(cfg) {
         return reportConfigurationErrors(configInfo.config);
     }
     async function run() {
-        var _a, _b, _c, _d;
         if (cfg.options.root) {
             process.env[cspell.ENV_CSPELL_GLOB_ROOT] = cfg.root;
         }
         const configInfo = await (0, fileHelper_1.readConfig)(cfg.configFile, cfg.root);
         reporter = (0, reporters_1.mergeReporters)(cfg.reporter, ...(0, reporters_1.loadReporters)(configInfo.config));
         cspell.setLogger(getLoggerFromReporter(reporter));
-        const useGitignore = (_b = (_a = cfg.options.gitignore) !== null && _a !== void 0 ? _a : configInfo.config.useGitignore) !== null && _b !== void 0 ? _b : false;
-        const gitignoreRoots = (_c = cfg.options.gitignoreRoot) !== null && _c !== void 0 ? _c : configInfo.config.gitignoreRoot;
-        const gitIgnore = useGitignore ? await generateGitIgnore(gitignoreRoots) : undefined;
-        const cliGlobs = cfg.fileGlobs;
-        const allGlobs = cliGlobs.length ? cliGlobs : configInfo.config.files || [];
-        const combinedGlobs = (0, glob_1.normalizeGlobsToRoot)(allGlobs, cfg.root, false);
-        const cliExcludeGlobs = (0, glob_1.extractPatterns)(cfg.excludes).map((p) => p.glob);
-        const normalizedExcludes = (0, glob_1.normalizeGlobsToRoot)(cliExcludeGlobs, cfg.root, true);
-        const includeGlobs = combinedGlobs.filter((g) => !g.startsWith('!'));
-        const excludeGlobs = combinedGlobs.filter((g) => g.startsWith('!')).concat(normalizedExcludes);
-        const fileGlobs = includeGlobs;
-        const hasFileLists = !!fileLists.length;
+        const globInfo = await determineGlobs(configInfo, cfg);
+        const { fileGlobs, excludeGlobs } = globInfo;
+        const hasFileLists = !!cfg.fileLists.length;
         if (!fileGlobs.length && !hasFileLists) {
             // Nothing to do.
             return runResult();
@@ -210,27 +206,9 @@ async function runLint(cfg) {
             return runResult({ errors: configErrors });
         // Get Exclusions from the config files.
         const { root } = cfg;
-        const globsToExclude = (configInfo.config.ignorePaths || []).concat(excludeGlobs);
-        const globMatcher = (0, glob_1.buildGlobMatcher)(globsToExclude, root, true);
-        const ignoreGlobs = (0, glob_1.extractGlobsFromMatcher)(globMatcher);
-        // cspell:word nodir
-        const globOptions = {
-            root,
-            cwd: root,
-            ignore: ignoreGlobs.concat(normalizedExcludes),
-            nodir: true,
-        };
-        const enableGlobDot = (_d = cfg.enableGlobDot) !== null && _d !== void 0 ? _d : configInfo.config.enableGlobDot;
-        if (enableGlobDot !== undefined) {
-            globOptions.dot = enableGlobDot;
-        }
         try {
             const cacheSettings = await (0, cache_1.calcCacheSettings)(configInfo.config, cfg.options, root);
-            const foundFiles = await (hasFileLists
-                ? useFileLists(fileLists, allGlobs, root, enableGlobDot)
-                : (0, fileHelper_1.findFiles)(fileGlobs, globOptions));
-            const filtered = gitIgnore ? await gitIgnore.filterOutIgnored(foundFiles) : foundFiles;
-            const files = filterFiles(filtered, globMatcher);
+            const files = await determineFilesToCheck(configInfo, cfg, reporter, globInfo);
             return await processFiles(files, configInfo, cacheSettings);
         }
         catch (e) {
@@ -253,6 +231,55 @@ Options:
     unique:    ${yesNo(!!cfg.options.unique)}
 `, cspell_types_1.MessageTypes.Info);
     }
+}
+exports.runLint = runLint;
+async function determineGlobs(configInfo, cfg) {
+    var _a, _b, _c;
+    const useGitignore = (_b = (_a = cfg.options.gitignore) !== null && _a !== void 0 ? _a : configInfo.config.useGitignore) !== null && _b !== void 0 ? _b : false;
+    const gitignoreRoots = (_c = cfg.options.gitignoreRoot) !== null && _c !== void 0 ? _c : configInfo.config.gitignoreRoot;
+    const gitIgnore = useGitignore ? await generateGitIgnore(gitignoreRoots) : undefined;
+    const cliGlobs = cfg.fileGlobs;
+    const allGlobs = cliGlobs.length ? cliGlobs : configInfo.config.files || [];
+    const combinedGlobs = (0, glob_1.normalizeGlobsToRoot)(allGlobs, cfg.root, false);
+    const cliExcludeGlobs = (0, glob_1.extractPatterns)(cfg.excludes).map((p) => p.glob);
+    const normalizedExcludes = (0, glob_1.normalizeGlobsToRoot)(cliExcludeGlobs, cfg.root, true);
+    const includeGlobs = combinedGlobs.filter((g) => !g.startsWith('!'));
+    const excludeGlobs = combinedGlobs.filter((g) => g.startsWith('!')).concat(normalizedExcludes);
+    const fileGlobs = includeGlobs;
+    return { allGlobs, gitIgnore, fileGlobs, excludeGlobs, normalizedExcludes };
+}
+async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
+    async function _determineFilesToCheck() {
+        var _a;
+        const { fileLists } = cfg;
+        const hasFileLists = !!fileLists.length;
+        const { allGlobs, gitIgnore, fileGlobs, excludeGlobs, normalizedExcludes } = globInfo;
+        // Get Exclusions from the config files.
+        const { root } = cfg;
+        const globsToExclude = (configInfo.config.ignorePaths || []).concat(excludeGlobs);
+        const globMatcher = (0, glob_1.buildGlobMatcher)(globsToExclude, root, true);
+        const ignoreGlobs = (0, glob_1.extractGlobsFromMatcher)(globMatcher);
+        // cspell:word nodir
+        const globOptions = {
+            root,
+            cwd: root,
+            ignore: ignoreGlobs.concat(normalizedExcludes),
+            nodir: true,
+        };
+        const enableGlobDot = (_a = cfg.enableGlobDot) !== null && _a !== void 0 ? _a : configInfo.config.enableGlobDot;
+        if (enableGlobDot !== undefined) {
+            globOptions.dot = enableGlobDot;
+        }
+        const filterFiles = (0, async_1.filter)(filterFilesFn(globMatcher));
+        const foundFiles = await (hasFileLists
+            ? useFileLists(fileLists, allGlobs, root, enableGlobDot)
+            : (0, fileHelper_1.findFiles)(fileGlobs, globOptions));
+        const filtered = gitIgnore ? await gitIgnore.filterOutIgnored(foundFiles) : foundFiles;
+        const files = (0, async_1.isAsyncIterable)(filtered)
+            ? (0, async_1.pipeAsync)(filtered, filterFiles)
+            : [...(0, async_1.pipeSync)(filtered, filterFiles)];
+        return files;
+    }
     function isExcluded(filename, globMatcherExclude) {
         if (cspell.isBinaryFile(vscode_uri_1.URI.file(filename))) {
             return true;
@@ -266,25 +293,17 @@ Options:
         }
         return r.matched;
     }
-    function extractGlobSource(g) {
-        const { glob, rawGlob, source } = g;
-        return {
-            glob: rawGlob || glob,
-            source,
-        };
-    }
-    function filterFiles(files, globMatcherExclude) {
+    function filterFilesFn(globMatcherExclude) {
         const patterns = globMatcherExclude.patterns;
         const excludeInfo = patterns
             .map(extractGlobSource)
             .map(({ glob, source }) => `Glob: ${glob} from ${source}`)
             .filter(util.uniqueFn());
         reporter.info(`Exclusion Globs: \n    ${excludeInfo.join('\n    ')}\n`, cspell_types_1.MessageTypes.Info);
-        const result = files.filter(util.uniqueFn()).filter((filename) => !isExcluded(filename, globMatcherExclude));
-        return result;
+        return (filename) => !isExcluded(filename, globMatcherExclude);
     }
+    return _determineFilesToCheck();
 }
-exports.runLint = runLint;
 function extractContext(tdo, contextRange) {
     const { line, offset } = tdo;
     const textOffsetInLine = offset - line.offset;
@@ -313,6 +332,13 @@ function extractContext(tdo, contextRange) {
     };
     return context;
 }
+function extractGlobSource(g) {
+    const { glob, rawGlob, source } = g;
+    return {
+        glob: rawGlob || glob,
+        source,
+    };
+}
 function runResult(init = {}) {
     const { files = 0, filesWithIssues = new Set(), issues = 0, errors = 0, cachedFiles = 0 } = init;
     return { files, filesWithIssues, issues, errors, cachedFiles };
@@ -357,6 +383,7 @@ async function useFileLists(fileListFiles, includeGlobPatterns, root, dot) {
     }
     const globMatcher = new cspell_glob_1.GlobMatcher(includeGlobPatterns, options);
     const files = await (0, fileHelper_1.readFileListFiles)(fileListFiles);
-    return files.filter((file) => globMatcher.match(file));
+    const filterFiles = (file) => globMatcher.match(file);
+    return files instanceof Array ? files.filter(filterFiles) : (0, async_1.pipeAsync)(files, (0, async_1.filter)(filterFiles));
 }
 //# sourceMappingURL=lint.js.map

package/dist/options.d.ts

@@ -58,11 +58,50 @@ export interface LinterOptions extends BaseOptions, CacheOptions {
      * Files must be found and processed otherwise it is considered an error.
      */
     mustFindFiles?: boolean;
+    /**
+     * Stop processing and exit if an issue or error is found.
+     */
+    failFast?: boolean;
 }
 export interface TraceOptions extends BaseOptions {
+    stdin?: boolean;
     allowCompoundWords?: boolean;
     ignoreCase?: boolean;
 }
+export interface SuggestionOptions extends BaseOptions {
+    /**
+     * Strict case and accent checking
+     * @default true
+     */
+    strict?: boolean;
+    /**
+     * List of dictionaries to use. If specified, only that list of dictionaries will be used.
+     */
+    dictionaries?: string[];
+    /**
+     * The number of suggestions to make.
+     * @default 8
+     */
+    numSuggestions?: number;
+    /**
+     * Max number of changes / edits to the word to get to a suggestion matching suggestion.
+     * @default 4
+     */
+    numChanges?: number;
+    /**
+     * If multiple suggestions have the same edit / change "cost", then included them even if
+     * it causes more than `numSuggestions` to be returned.
+     * @default true
+     */
+    includeTies?: boolean;
+    /**
+     * Use stdin for the input
+     */
+    useStdin?: boolean;
+}
+export interface LegacyOptions {
+    local?: string;
+}
 export interface BaseOptions {
     /**
      * Path to configuration file.
@@ -76,10 +115,6 @@ export interface BaseOptions {
      * Locale to use.
      */
     locale?: string;
-    /**
-     * @deprecated
-     */
-    local?: string;
 }
 export interface LinterCliOptions extends Omit<LinterOptions, 'fileLists'> {
     legacy?: boolean;
@@ -97,4 +132,5 @@ export interface LinterCliOptions extends Omit<LinterOptions, 'fileLists'> {
      */
     fileList?: string[];
 }
+export declare function fixLegacy<T extends BaseOptions>(opts: T & LegacyOptions): Omit<T & LegacyOptions, 'local'>;
 //# sourceMappingURL=options.d.ts.map

package/dist/options.js

@@ -1,3 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixLegacy = void 0;
+function fixLegacy(opts) {
+    const { local, ...rest } = opts;
+    if (local && !rest.locale) {
+        rest.locale = local;
+    }
+    return rest;
+}
+exports.fixLegacy = fixLegacy;
 //# sourceMappingURL=options.js.map

package/dist/util/async.d.ts

@@ -0,0 +1,46 @@
+export declare const map: <T, U>(fn: (v: T) => U) => PipeFn<T, U>;
+export declare function asyncAwait<T>(): (iter: AsyncIterable<T>) => AsyncIterable<Awaited<T>>;
+export declare const filter: <T>(fn: (i: T) => boolean) => PipeFn<T, T>;
+interface PipeFnSync<T, U> {
+    (iter: Iterable<T>): Iterable<U>;
+    /** This is just to help TypeScript figure out the type. */
+    __PipeFnSync__?: [T, U];
+}
+interface PipeFnAsync<T, U> {
+    (iter: AsyncIterable<T>): AsyncIterable<U>;
+    /** This is just to help TypeScript figure out the type. */
+    __PipeFnAsync__?: [T, U];
+}
+declare type PipeFn<T, U> = PipeFnSync<T, U> & PipeFnAsync<T, U>;
+export declare function pipeAsync<T>(i: AnyIterable<T>): AsyncIterable<T>;
+export declare function pipeAsync<T, T0>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0]>): AsyncIterable<T0>;
+export declare function pipeAsync<T, T0, T1>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1]>): AsyncIterable<T1>;
+export declare function pipeAsync<T, T0, T1, T2>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2]>): AsyncIterable<T2>;
+export declare function pipeAsync<T, T0, T1, T2, T3>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3]>): AsyncIterable<T3>;
+export declare function pipeAsync<T, T0, T1, T2, T3, T4>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4]>): AsyncIterable<T4>;
+export declare function pipeAsync<T, T0, T1, T2, T3, T4, T5>(i: AnyIterable<T>, ...f: PipeAsyncTx<[T, T0, T1, T2, T3, T4, T5]>): AsyncIterable<T5>;
+declare type PsFn<T, U> = PipeFnSync<T, U> | ((i: Iterable<T>) => Iterable<U>);
+export declare function pipeSync<T>(i: Iterable<T>): Iterable<T>;
+export declare function pipeSync<T, T0 = T>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0]>): Iterable<T0>;
+export declare function pipeSync<T, T0, T1>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1]>): Iterable<T1>;
+export declare function pipeSync<T, T0, T1, T2>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2]>): Iterable<T2>;
+export declare function pipeSync<T, T0, T1, T2, T3>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3]>): Iterable<T3>;
+export declare function pipeSync<T, T0, T1, T2, T3, T4>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3, T4]>): Iterable<T4>;
+export declare function pipeSync<T, T0, T1, T2, T3, T4, T5>(i: Iterable<T>, ...f: PipeSyncTx<[T, T0, T1, T2, T3, T4, T5]>): Iterable<T5>;
+declare type AnyIterable<T> = Iterable<T> | AsyncIterable<T> | Promise<Iterable<T>> | Iterable<Promise<T>>;
+export declare function mergeAsyncIterables<T>(iter: Iterable<T>): AsyncIterable<T>;
+export declare function mergeAsyncIterables<T>(iter: AsyncIterable<T>): AsyncIterable<T>;
+export declare function mergeAsyncIterables<T>(iter: Promise<Iterable<T>>): AsyncIterable<T>;
+export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>): AsyncIterable<T>;
+export declare function mergeAsyncIterables<T>(iter: AnyIterable<T>, ...rest: AnyIterable<T>[]): AsyncIterable<T>;
+/**
+ * Convert one or more iterables to an AsyncIterable
+ */
+export declare const toAsyncIterable: typeof mergeAsyncIterables;
+export declare function asyncIterableToArray<T>(iter: Iterable<T> | AsyncIterable<T>): Promise<Awaited<T>[]>;
+export declare function isAsyncIterable<T>(i: AnyIterable<T>): i is AsyncIterable<T>;
+declare type PaFn<T, U> = PipeFnAsync<T, U> | ((i: AsyncIterable<T>) => AsyncIterable<U>);
+declare type PipeAsyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PaFn<Left, Right>, ...PipeAsyncTx<[Right, ...Rest]>] : [PaFn<Left, Right>] : never;
+declare type PipeSyncTx<T extends [...any]> = T extends [infer Left, infer Right, ...infer Rest] ? Rest extends [any, ...any] ? [PsFn<Left, Right>, ...PipeSyncTx<[Right, ...Rest]>] : [PsFn<Left, Right>] : never;
+export {};
+//# sourceMappingURL=async.d.ts.map

package/dist/util/async.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAsyncIterable = exports.asyncIterableToArray = exports.toAsyncIterable = exports.mergeAsyncIterables = exports.pipeSync = exports.pipeAsync = exports.filter = exports.asyncAwait = exports.map = void 0;
+function asyncMap(mapFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            yield mapFn(v);
+        }
+    }
+    return fn;
+}
+function syncMap(mapFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            yield mapFn(v);
+        }
+    }
+    return fn;
+}
+const map = (fn) => toPipeFn(syncMap(fn), asyncMap(fn));
+exports.map = map;
+function asyncFilter(filterFn) {
+    async function* fn(iter) {
+        for await (const v of iter) {
+            if (filterFn(v))
+                yield v;
+        }
+    }
+    return fn;
+}
+function syncFilter(filterFn) {
+    function* fn(iter) {
+        for (const v of iter) {
+            if (filterFn(v))
+                yield v;
+        }
+    }
+    return fn;
+}
+async function* _asyncAwait(iter) {
+    for await (const v of iter) {
+        yield v;
+    }
+}
+function asyncAwait() {
+    return _asyncAwait;
+}
+exports.asyncAwait = asyncAwait;
+const filter = (fn) => toPipeFn(syncFilter(fn), asyncFilter(fn));
+exports.filter = filter;
+function toPipeFn(syncFn, asyncFn) {
+    function _(i) {
+        return isAsyncIterable(i) ? asyncFn(i) : syncFn(i);
+    }
+    return _;
+}
+function pipeAsync(i, ...fns) {
+    let iter = (0, exports.toAsyncIterable)(i);
+    for (const fn of fns) {
+        iter = fn(iter);
+    }
+    return iter;
+}
+exports.pipeAsync = pipeAsync;
+function pipeSync(i, ...fns) {
+    let iter = i;
+    for (const fn of fns) {
+        iter = fn(iter);
+    }
+    return iter;
+}
+exports.pipeSync = pipeSync;
+/**
+ * Merge multiple iterables into an AsyncIterable
+ * @param iter - initial iterable.
+ * @param rest - iterables to merge.
+ */
+async function* mergeAsyncIterables(iter, ...rest) {
+    for await (const i of [iter, ...rest]) {
+        yield* i;
+    }
+}
+exports.mergeAsyncIterables = mergeAsyncIterables;
+/**
+ * Convert one or more iterables to an AsyncIterable
+ */
+exports.toAsyncIterable = mergeAsyncIterables;
+async function asyncIterableToArray(iter) {
+    const r = [];
+    for await (const t of iter) {
+        r.push(t);
+    }
+    return r;
+}
+exports.asyncIterableToArray = asyncIterableToArray;
+function isAsyncIterable(i) {
+    return typeof i[Symbol.asyncIterator] === 'function';
+}
+exports.isAsyncIterable = isAsyncIterable;
+//  type Last<T extends [...any]> = T extends [infer U, ...infer R] ? (R extends [any, ...any] ? Last<R> : U) : never;
+//# sourceMappingURL=async.js.map

package/dist/util/cache/CSpellLintResultCache.d.ts

@@ -1,4 +1,4 @@
-import { FileResult } from '../../fileHelper';
+import { FileResult } from '../../util/fileHelper';
 export interface CSpellLintResultCache {
     /**
      * Retrieve cached lint results for a given file name, if present in the cache.

package/dist/util/cache/DiskCache.d.ts

@@ -1,5 +1,5 @@
 import type { FileDescriptor } from 'file-entry-cache';
-import type { FileResult } from '../../fileHelper';
+import type { FileResult } from '../../util/fileHelper';
 import type { CSpellLintResultCache } from './CSpellLintResultCache';
 export declare type CachedFileResult = Omit<FileResult, 'fileInfo' | 'elapsedTimeMs'>;
 /**

package/dist/util/cache/DiskCache.js

@@ -22,7 +22,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiskCache = void 0;
 const fileEntryCache = __importStar(require("file-entry-cache"));
 const path_1 = require("path");
-const fileHelper_1 = require("../../fileHelper");
+const fileHelper_1 = require("../../util/fileHelper");
 /**
  * Caches cspell results on disk
  */

package/dist/util/cache/getConfigHash.d.ts

@@ -1,4 +1,4 @@
-import { ConfigInfo } from '../../fileHelper';
+import { ConfigInfo } from '../../util/fileHelper';
 /**
  * Hashes ConfigInfo and cspell version for using in DiskCache
  */

package/dist/{fileHelper.d.ts → util/fileHelper.d.ts}

@@ -1,4 +1,4 @@
-import { GlobOptions } from './util/glob';
+import { GlobOptions } from './glob';
 import { CSpellUserSettings, Document, Issue } from 'cspell-lib';
 export interface ConfigInfo {
     source: string;
@@ -43,7 +43,7 @@ export declare function calcFinalConfigInfo(configInfo: ConfigInfo, settingsFrom
  *   file will be resolved relative to the containing file.
  * @returns - a list of files to be processed.
  */
-export declare function readFileListFiles(listFiles: string[]): Promise<string[]>;
+export declare function readFileListFiles(listFiles: string[]): Promise<string[] | AsyncIterable<string>>;
 /**
  * Read a `listFile` and return the containing file paths resolved relative to the `listFile`.
  * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each

package/dist/{fileHelper.js → util/fileHelper.js}

@@ -26,10 +26,12 @@ exports.readFileListFile = exports.readFileListFiles = exports.calcFinalConfigIn
 const cspell = __importStar(require("cspell-lib"));
 const fsp = __importStar(require("fs-extra"));
 const get_stdin_1 = __importDefault(require("get-stdin"));
-const glob_1 = require("./util/glob");
+const glob_1 = require("./glob");
 const path = __importStar(require("path"));
 const cspell_lib_1 = require("cspell-lib");
-const errors_1 = require("./util/errors");
+const errors_1 = require("./errors");
+const async_1 = require("./async");
+const stdin_1 = require("./stdin");
 const UTF8 = 'utf8';
 const STDIN = 'stdin';
 async function readConfig(configFile, root) {
@@ -106,7 +108,15 @@ exports.calcFinalConfigInfo = calcFinalConfigInfo;
  * @returns - a list of files to be processed.
  */
 async function readFileListFiles(listFiles) {
-    return flatten(await Promise.all(listFiles.map(readFileListFile)));
+    let useStdin = false;
+    const files = listFiles.filter((file) => {
+        const isStdin = file === 'stdin';
+        useStdin = useStdin || isStdin;
+        return !isStdin;
+    });
+    const found = flatten(await Promise.all(files.map(readFileListFile)));
+    // Move `stdin` to the end.
+    return useStdin ? (0, async_1.mergeAsyncIterables)(found, (0, stdin_1.readStdin)()) : found;
 }
 exports.readFileListFiles = readFileListFiles;
 /**

package/dist/util/stdin.d.ts

@@ -0,0 +1,2 @@
+export declare function readStdin(): AsyncIterable<string>;
+//# sourceMappingURL=stdin.d.ts.map

package/dist/util/stdin.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStdin = void 0;
+const readline = __importStar(require("readline"));
+function readStdin() {
+    return readline.createInterface(process.stdin);
+}
+exports.readStdin = readStdin;
+//# sourceMappingURL=stdin.js.map

package/dist/util/util.d.ts

@@ -4,5 +4,7 @@ export declare function uniqueFilterFnGenerator<T>(): FilterFn<T>;
 export declare function uniqueFilterFnGenerator<T, U>(extractFn: (v: T) => U): FilterFn<T>;
 export declare function unique<T>(src: T[]): T[];
 export declare function clean<T>(src: T): T;
+export declare function pad(s: string, w: number): string;
+export declare function padLeft(s: string, w: number): string;
 export {};
 //# sourceMappingURL=util.d.ts.map

package/dist/util/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
+exports.padLeft = exports.pad = exports.clean = exports.unique = exports.uniqueFilterFnGenerator = exports.uniqueFn = void 0;
 // alias for uniqueFilterFnGenerator
 exports.uniqueFn = uniqueFilterFnGenerator;
 function uniqueFilterFnGenerator(extractFn) {
@@ -28,4 +28,16 @@ function clean(src) {
     return r;
 }
 exports.clean = clean;
+function pad(s, w) {
+    if (s.length >= w)
+        return s;
+    return (s + ' '.repeat(w)).slice(0, w);
+}
+exports.pad = pad;
+function padLeft(s, w) {
+    if (s.length >= w)
+        return s;
+    return (' '.repeat(w) + s).slice(-w);
+}
+exports.padLeft = padLeft;
 //# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "5.16.0",
+  "version": "5.17.0-alpha.0",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -72,9 +72,9 @@
     "chalk": "^4.1.2",
     "commander": "^8.3.0",
     "comment-json": "^4.1.1",
-    "cspell-gitignore": "^5.16.0",
-    "cspell-glob": "^5.16.0",
-    "cspell-lib": "^5.16.0",
+    "cspell-gitignore": "^5.17.0-alpha.0",
+    "cspell-glob": "^5.17.0-alpha.0",
+    "cspell-lib": "^5.17.0-alpha.0",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^6.0.1",
     "fs-extra": "^10.0.0",
@@ -89,8 +89,8 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-json-reporter": "^5.16.0",
-    "@cspell/cspell-types": "^5.16.0",
+    "@cspell/cspell-json-reporter": "^5.17.0-alpha.0",
+    "@cspell/cspell-types": "^5.17.0-alpha.0",
     "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
     "@types/glob": "^7.2.0",
@@ -103,5 +103,5 @@
     "minimatch": "^3.0.4",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "c5d994f58bdb48c4d16f1708607b28c8a7b52a65"
+  "gitHead": "d884218703cac72186fd69e8ba1e9eb78558c7ca"
 }