cspell 9.1.2 → 9.1.5

package/dist/esm/app.mjs

@@ -1,34 +0,0 @@
-import { Option as CommanderOption, program } from 'commander';
-import { satisfies as semverSatisfies } from 'semver';
-import { commandCheck } from './commandCheck.js';
-import { commandDictionaries } from './commandDictionaries.js';
-import { commandInit } from './commandInit.js';
-import { commandLink } from './commandLink.js';
-import { commandLint } from './commandLint.js';
-import { commandSuggestion } from './commandSuggestion.js';
-import { commandTrace } from './commandTrace.js';
-import { npmPackage } from './pkgInfo.js';
-import { ApplicationError } from './util/errors.js';
-export { ApplicationError, CheckFailed } from './util/errors.js';
-export async function run(command, argv) {
-    const prog = command || program;
-    const args = argv || process.argv;
-    prog.exitOverride();
-    prog.version(npmPackage.version).description('Spelling Checker for Code').name('cspell');
-    if (!semverSatisfies(process.versions.node, npmPackage.engines.node)) {
-        throw new ApplicationError(`Unsupported NodeJS version (${process.versions.node}); ${npmPackage.engines.node} is required`);
-    }
-    const optionFlags = new CommanderOption('-f,--flag <flag:value>', 'Declare an execution flag value')
-        .hideHelp()
-        .argParser((value, prev) => prev?.concat(value) || [value]);
-    commandLint(prog).addOption(optionFlags);
-    commandTrace(prog).addOption(optionFlags);
-    commandCheck(prog).addOption(optionFlags);
-    commandSuggestion(prog).addOption(optionFlags);
-    commandInit(prog).addOption(optionFlags);
-    commandLink(prog);
-    commandDictionaries(prog);
-    prog.exitOverride();
-    await prog.parseAsync(args);
-}
-//# sourceMappingURL=app.mjs.map

package/dist/esm/application.d.mts

@@ -1,17 +0,0 @@
-import type { CSpellReporter, RunResult } from '@cspell/cspell-types';
-import type { CheckTextInfo, FeatureFlags, TraceWordResult } from 'cspell-lib';
-import { type InitOptions } from './config/index.js';
-import type { TimedSuggestionsForWordResult } from './emitters/suggestionsEmitter.js';
-import type { BaseOptions, LegacyOptions, LinterCliOptions, SuggestionOptions, TraceOptions } from './options.js';
-export { listDictionaries } from './dictionaries/index.js';
-export type { TraceResult } from 'cspell-lib';
-export { IncludeExcludeFlag } from 'cspell-lib';
-export type AppError = NodeJS.ErrnoException;
-export declare function lint(fileGlobs: string[], options: LinterCliOptions, reporter?: CSpellReporter): Promise<RunResult>;
-export declare function trace(words: string[], options: TraceOptions): AsyncIterableIterator<TraceWordResult>;
-export type CheckTextResult = CheckTextInfo;
-export declare function checkText(filename: string, options: BaseOptions & LegacyOptions): Promise<CheckTextResult>;
-export declare function suggestions(words: string[], options: SuggestionOptions): AsyncIterable<TimedSuggestionsForWordResult>;
-export declare function createInit(options: InitOptions): Promise<void>;
-export declare function parseApplicationFeatureFlags(flags: string[] | undefined): FeatureFlags;
-//# sourceMappingURL=application.d.mts.map

package/dist/esm/application.mjs

@@ -1,99 +0,0 @@
-import { opMap, opTap, pipeAsync, toAsyncIterable } from '@cspell/cspell-pipe';
-import { checkTextDocument, getDefaultSettings, getGlobalSettingsAsync, mergeSettings, SuggestionError, suggestionsForWords, traceWordsAsync, } from 'cspell-lib';
-import { getReporter } from './cli-reporter.js';
-import { configInit } from './config/index.js';
-import { console } from './console.js';
-import { getFeatureFlags, parseFeatureFlags } from './featureFlags/index.js';
-import { extractUnknownWordsConfig, LintRequest, runLint } from './lint/index.js';
-import { fixLegacy } from './options.js';
-import { simpleRepl } from './repl/index.js';
-import { readConfig } from './util/configFileHelper.js';
-import { fileInfoToDocument, readFileInfo } from './util/fileHelper.js';
-import { finalizeReporter } from './util/reporters.js';
-import { readStdin } from './util/stdin.js';
-import { getTimeMeasurer } from './util/timer.js';
-import * as util from './util/util.js';
-export { listDictionaries } from './dictionaries/index.js';
-export { IncludeExcludeFlag } from 'cspell-lib';
-export function lint(fileGlobs, options, reporter) {
-    options = fixLegacy(options);
-    const unknownWordsConfig = extractUnknownWordsConfig(options);
-    const useOptions = { ...options, ...unknownWordsConfig };
-    const reporterOptions = { ...useOptions, console };
-    const cfg = new LintRequest(fileGlobs, useOptions, finalizeReporter(reporter) ?? getReporter({ ...useOptions, fileGlobs }, reporterOptions));
-    return runLint(cfg);
-}
-export async function* trace(words, options) {
-    options = fixLegacy(options);
-    const iWords = options.stdin ? toAsyncIterable(words, readStdin()) : words;
-    const { languageId, locale, allowCompoundWords, ignoreCase } = options;
-    const configFile = await readConfig(options.config, undefined);
-    const loadDefault = options.defaultConfiguration ?? configFile.config.loadDefaultConfiguration ?? true;
-    const additionalSettings = {};
-    if (options.dictionary) {
-        additionalSettings.dictionaries = options.dictionary;
-    }
-    const config = mergeSettings(await getDefaultSettings(loadDefault), await getGlobalSettingsAsync(), configFile.config, additionalSettings);
-    yield* traceWordsAsync(iWords, config, util.clean({ languageId, locale, ignoreCase, allowCompoundWords }));
-}
-export async function checkText(filename, options) {
-    options = fixLegacy(options);
-    const fileInfo = await readFileInfo(filename);
-    const { locale, languageId, validateDirectives } = options;
-    const doc = fileInfoToDocument(fileInfo, languageId, locale);
-    const checkOptions = {
-        configFile: options.config,
-        validateDirectives,
-    };
-    const settingsFromCommandLine = util.clean({
-        languageId,
-        language: locale,
-        loadDefaultConfiguration: options.defaultConfiguration,
-    });
-    return checkTextDocument(doc, util.clean({ ...checkOptions }), settingsFromCommandLine);
-}
-export async function* suggestions(words, options) {
-    options = fixLegacy(options);
-    const configFile = await readConfig(options.config, undefined);
-    let timer;
-    function tapStart() {
-        timer = getTimeMeasurer();
-    }
-    function mapStart(v) {
-        tapStart();
-        return v;
-    }
-    function mapEnd(v) {
-        const elapsedTimeMs = timer?.();
-        return elapsedTimeMs ? { ...v, elapsedTimeMs } : v;
-    }
-    const iWords = options.repl
-        ? pipeAsync(toAsyncIterable(words, simpleRepl()), opTap(tapStart))
-        : options.useStdin
-            ? pipeAsync(toAsyncIterable(words, readStdin()), opTap(tapStart))
-            : words.map(mapStart);
-    try {
-        const results = pipeAsync(suggestionsForWords(iWords, util.clean({ ...options }), configFile.config), opMap(mapEnd));
-        yield* results;
-    }
-    catch (e) {
-        if (!(e instanceof SuggestionError))
-            throw e;
-        console.error(e.message);
-        process.exitCode = 1;
-    }
-}
-export function createInit(options) {
-    return configInit(options);
-}
-function registerApplicationFeatureFlags() {
-    const ff = getFeatureFlags();
-    const flags = [{ name: 'timer', description: 'Display elapsed time for command.' }];
-    flags.forEach((flag) => ff.register(flag));
-    return ff;
-}
-export function parseApplicationFeatureFlags(flags) {
-    const ff = registerApplicationFeatureFlags();
-    return parseFeatureFlags(flags, ff);
-}
-//# sourceMappingURL=application.mjs.map

package/dist/esm/cli-reporter.d.ts

@@ -1,38 +0,0 @@
-import type { Issue } from '@cspell/cspell-types';
-import type { ChalkInstance } from 'chalk';
-import { CSpellReporterConfiguration } from './models.js';
-import type { LinterCliOptions } from './options.js';
-import type { FinalizedReporter } from './util/reporters.js';
-export interface TemplateSubstitutions extends Record<string, string> {
-    $col: string;
-    $contextFull: string;
-    $contextLeft: string;
-    $contextRight: string;
-    $filename: string;
-    $padContext: string;
-    $padRowCol: string;
-    $row: string;
-    $suggestions: string;
-    $text: string;
-    $uri: string;
-    $quickFix: string;
-    $message: string;
-    $messageColored: string;
-}
-export interface ReporterIssue extends Issue {
-    filename: string;
-}
-interface IOChalk {
-    readonly chalk: ChalkInstance;
-}
-export interface ReporterOptions extends Pick<LinterCliOptions, 'color' | 'debug' | 'issues' | 'issuesSummaryReport' | 'legacy' | 'progress' | 'relative' | 'root' | 'showContext' | 'showPerfSummary' | 'showSuggestions' | 'silent' | 'summary' | 'verbose' | 'wordsOnly'> {
-    fileGlobs: string[];
-}
-export declare function getReporter(options: ReporterOptions, config?: CSpellReporterConfiguration): FinalizedReporter;
-declare function formatIssue(io: IOChalk, templateStr: string, issue: ReporterIssue, maxIssueTextWidth: number): string;
-export declare function checkTemplate(template: string): true | Error;
-export declare const __testing__: {
-    formatIssue: typeof formatIssue;
-};
-export {};
-//# sourceMappingURL=cli-reporter.d.ts.map

package/dist/esm/cli-reporter.js

@@ -1,386 +0,0 @@
-import assert from 'node:assert';
-import { formatWithOptions } from 'node:util';
-import { toFileDirURL, toFilePathOrHref, toFileURL, urlRelative } from '@cspell/url';
-import { Chalk } from 'chalk';
-import { makeTemplate } from 'chalk-template';
-import { isSpellingDictionaryLoadError } from 'cspell-lib';
-import { console as customConsole } from './console.js';
-import { ApplicationError } from './util/errors.js';
-import { uniqueFilterFnGenerator } from './util/util.js';
-const templateIssue = `{green $filename}:{yellow $row:$col} - $message ({red $text}) $quickFix`;
-const templateIssueNoFix = `{green $filename}:{yellow $row:$col} - $message ({red $text})`;
-const templateIssueWithSuggestions = `{green $filename}:{yellow $row:$col} - $message ({red $text}) Suggestions: {yellow [$suggestions]}`;
-const templateIssueWithContext = `{green $filename}:{yellow $row:$col} $padRowCol- $message ({red $text})$padContext -- {gray $contextLeft}{red {underline $text}}{gray $contextRight}`;
-const templateIssueWithContextWithSuggestions = `{green $filename}:{yellow $row:$col} $padRowCol- $message ({red $text})$padContext -- {gray $contextLeft}{red {underline $text}}{gray $contextRight}\n\t Suggestions: {yellow [$suggestions]}`;
-const templateIssueLegacy = `{green $filename}[$row, $col]: $message: {red $text}`;
-const templateIssueWordsOnly = '$text';
-const console = undefined;
-assert(!console);
-/**
- *
- * @param template - The template to use for the issue.
- * @param uniqueIssues - If true, only unique issues will be reported.
- * @param reportedIssuesCollection - optional collection to store reported issues.
- * @returns issueEmitter function
- */
-function genIssueEmitter(stdIO, errIO, template, uniqueIssues, reportedIssuesCollection) {
-    const uniqueFilter = uniqueIssues ? uniqueFilterFnGenerator((issue) => issue.text) : () => true;
-    const defaultWidth = 10;
-    let maxWidth = defaultWidth;
-    let uri;
-    return function issueEmitter(issue) {
-        if (!uniqueFilter(issue))
-            return;
-        if (uri !== issue.uri) {
-            maxWidth = defaultWidth;
-            uri = issue.uri;
-        }
-        maxWidth = Math.max(maxWidth * 0.999, issue.text.length, 10);
-        const issueText = formatIssue(stdIO, template, issue, Math.ceil(maxWidth));
-        reportedIssuesCollection?.push(formatIssue(errIO, template, issue, Math.ceil(maxWidth)));
-        stdIO.writeLine(issueText);
-    };
-}
-function nullEmitter() {
-    /* empty */
-}
-function relativeUriFilename(uri, rootURL) {
-    const url = toFileURL(uri);
-    const rel = urlRelative(rootURL, url);
-    if (rel.startsWith('..'))
-        return toFilePathOrHref(url);
-    return rel;
-}
-function reportProgress(io, p, cwdURL, options) {
-    if (p.type === 'ProgressFileComplete') {
-        return reportProgressFileComplete(io, p, cwdURL, options);
-    }
-    if (p.type === 'ProgressFileBegin') {
-        return reportProgressFileBegin(io, p, cwdURL);
-    }
-}
-function determineFilename(io, p, cwd) {
-    const fc = '' + p.fileCount;
-    const fn = (' '.repeat(fc.length) + p.fileNum).slice(-fc.length);
-    const idx = fn + '/' + fc;
-    const filename = io.chalk.gray(relativeUriFilename(p.filename, cwd));
-    return { idx, filename };
-}
-function reportProgressFileBegin(io, p, cwdURL) {
-    const { idx, filename } = determineFilename(io, p, cwdURL);
-    if (io.getColorLevel() > 0) {
-        io.clearLine?.(0);
-        io.write(`${idx} ${filename}\r`);
-    }
-}
-function reportProgressFileComplete(io, p, cwd, options) {
-    const { idx, filename } = determineFilename(io, p, cwd);
-    const { verbose, debug } = options;
-    const time = reportTime(io, p.elapsedTimeMs, !!p.cached);
-    const skipped = p.processed === false ? ' skipped' : '';
-    const hasErrors = p.numErrors ? io.chalk.red ` X` : '';
-    const newLine = (skipped && (verbose || debug)) || hasErrors || isSlow(p.elapsedTimeMs) || io.getColorLevel() < 1 ? '\n' : '';
-    const msg = `${idx} ${filename} ${time}${skipped}${hasErrors}${newLine || '\r'}`;
-    io.write(msg);
-}
-function reportTime(io, elapsedTimeMs, cached) {
-    if (cached)
-        return io.chalk.green('cached');
-    if (elapsedTimeMs === undefined)
-        return '-';
-    const slow = isSlow(elapsedTimeMs);
-    const color = !slow ? io.chalk.white : slow === 1 ? io.chalk.yellow : io.chalk.redBright;
-    return color(elapsedTimeMs.toFixed(2) + 'ms');
-}
-function isSlow(elapsedTmeMs) {
-    if (!elapsedTmeMs || elapsedTmeMs < 1000)
-        return 0;
-    if (elapsedTmeMs < 2000)
-        return 1;
-    return 2;
-}
-export function getReporter(options, config) {
-    const perfStats = {
-        filesProcessed: 0,
-        filesSkipped: 0,
-        filesCached: 0,
-        elapsedTimeMs: 0,
-        perf: Object.create(null),
-    };
-    const noColor = options.color === false;
-    const forceColor = options.color === true;
-    const uniqueIssues = config?.unique || false;
-    const defaultIssueTemplate = options.wordsOnly
-        ? templateIssueWordsOnly
-        : options.legacy
-            ? templateIssueLegacy
-            : options.showContext
-                ? options.showSuggestions
-                    ? templateIssueWithContextWithSuggestions
-                    : templateIssueWithContext
-                : options.showSuggestions
-                    ? templateIssueWithSuggestions
-                    : options.showSuggestions === false
-                        ? templateIssueNoFix
-                        : templateIssue;
-    const { fileGlobs, silent, summary, issues, progress: showProgress, verbose, debug } = options;
-    const issueTemplate = config?.issueTemplate || defaultIssueTemplate;
-    assertCheckTemplate(issueTemplate);
-    const console = config?.console || customConsole;
-    const colorLevel = noColor ? 0 : forceColor ? 2 : console.stdoutChannel.getColorLevel();
-    const stdio = {
-        ...console.stdoutChannel,
-        chalk: new Chalk({ level: colorLevel }),
-    };
-    const stderr = {
-        ...console.stderrChannel,
-        chalk: new Chalk({ level: colorLevel }),
-    };
-    const consoleError = (msg) => stderr.writeLine(msg);
-    function createInfoLog(wrap) {
-        return (msg) => console.info(wrap(msg));
-    }
-    const emitters = {
-        Debug: !silent && debug ? createInfoLog(stdio.chalk.cyan) : nullEmitter,
-        Info: !silent && verbose ? createInfoLog(stdio.chalk.yellow) : nullEmitter,
-        Warning: createInfoLog(stdio.chalk.yellow),
-    };
-    function infoEmitter(message, msgType) {
-        emitters[msgType]?.(message);
-    }
-    const rootURL = toFileDirURL(options.root || process.cwd());
-    function relativeIssue(fn) {
-        const fnFilename = options.relative
-            ? (uri) => relativeUriFilename(uri, rootURL)
-            : (uri) => toFilePathOrHref(toFileURL(uri, rootURL));
-        return (i) => {
-            const fullFilename = i.uri ? toFilePathOrHref(toFileURL(i.uri, rootURL)) : '';
-            const filename = i.uri ? fnFilename(i.uri) : '';
-            const r = { ...i, filename, fullFilename };
-            fn(r);
-        };
-    }
-    /*
-     * Turn off repeated issues see https://github.com/streetsidesoftware/cspell/pull/6058
-     * We might want to add a CLI option later to turn this back on.
-     */
-    const repeatIssues = false;
-    const issuesCollection = showProgress && repeatIssues ? [] : undefined;
-    const errorCollection = [];
-    function errorEmitter(message, error) {
-        if (isSpellingDictionaryLoadError(error)) {
-            error = error.cause;
-        }
-        const errorText = formatWithOptions({ colors: stderr.stream.hasColors?.() }, stderr.chalk.red(message), debug ? error : error.toString());
-        errorCollection?.push(errorText);
-        consoleError(errorText);
-    }
-    const resultEmitter = (result) => {
-        if (!fileGlobs.length && !result.files) {
-            return;
-        }
-        const { files, issues, cachedFiles, filesWithIssues, errors } = result;
-        const numFilesWithIssues = filesWithIssues.size;
-        if (stderr.getColorLevel() > 0) {
-            stderr.write('\r');
-            stderr.clearLine(0);
-        }
-        if (issuesCollection?.length || errorCollection?.length) {
-            consoleError('-------------------------------------------');
-        }
-        if (issuesCollection?.length) {
-            consoleError('Issues found:');
-            issuesCollection.forEach((issue) => consoleError(issue));
-        }
-        const cachedFilesText = cachedFiles ? ` (${cachedFiles} from cache)` : '';
-        const withErrorsText = errors ? ` with ${errors} error${errors === 1 ? '' : 's'}` : '';
-        const numFilesWidthIssuesText = numFilesWithIssues === 1 ? '1 file' : `${numFilesWithIssues} files`;
-        const summaryMessage = `CSpell\u003A Files checked: ${files}${cachedFilesText}, Issues found: ${issues} in ${numFilesWidthIssuesText}${withErrorsText}.`;
-        consoleError(summaryMessage);
-        if (errorCollection?.length && issues > 5) {
-            consoleError('-------------------------------------------');
-            consoleError('Errors:');
-            errorCollection.forEach((error) => consoleError(error));
-        }
-        if (options.showPerfSummary) {
-            consoleError('-------------------------------------------');
-            consoleError('Performance Summary:');
-            consoleError(`  Files Processed: ${perfStats.filesProcessed.toString().padStart(6)}`);
-            consoleError(`  Files Skipped  : ${perfStats.filesSkipped.toString().padStart(6)}`);
-            consoleError(`  Files Cached   : ${perfStats.filesCached.toString().padStart(6)}`);
-            consoleError(`  Processing Time: ${perfStats.elapsedTimeMs.toFixed(2).padStart(9)}ms`);
-            consoleError('Stats:');
-            const stats = Object.entries(perfStats.perf)
-                .filter((p) => !!p[1])
-                .map(([key, value]) => [key, value.toFixed(2)]);
-            const padName = Math.max(...stats.map((s) => s[0].length));
-            const padValue = Math.max(...stats.map((s) => s[1].length));
-            stats.sort((a, b) => a[0].localeCompare(b[0]));
-            for (const [key, value] of stats) {
-                value && consoleError(`  ${key.padEnd(padName)}: ${value.padStart(padValue)}ms`);
-            }
-        }
-    };
-    function collectPerfStats(p) {
-        if (p.cached) {
-            perfStats.filesCached++;
-            return;
-        }
-        perfStats.filesProcessed += p.processed ? 1 : 0;
-        perfStats.filesSkipped += !p.processed ? 1 : 0;
-        perfStats.elapsedTimeMs += p.elapsedTimeMs || 0;
-        if (!p.perf)
-            return;
-        for (const [key, value] of Object.entries(p.perf)) {
-            if (typeof value === 'number') {
-                perfStats.perf[key] = (perfStats.perf[key] || 0) + value;
-            }
-        }
-    }
-    function progress(p) {
-        if (!silent && showProgress) {
-            reportProgress(stderr, p, rootURL, options);
-        }
-        if (p.type === 'ProgressFileComplete') {
-            collectPerfStats(p);
-        }
-    }
-    return {
-        issue: relativeIssue(silent || !issues
-            ? nullEmitter
-            : genIssueEmitter(stdio, stderr, issueTemplate, uniqueIssues, issuesCollection)),
-        error: silent ? nullEmitter : errorEmitter,
-        info: infoEmitter,
-        debug: emitters.Debug,
-        progress,
-        result: !silent && summary ? resultEmitter : nullEmitter,
-        features: undefined,
-    };
-}
-function formatIssue(io, templateStr, issue, maxIssueTextWidth) {
-    function clean(t) {
-        return t.replace(/\s+/, ' ');
-    }
-    const { uri = '', filename, row, col, text, context = issue.line, offset } = issue;
-    const contextLeft = clean(context.text.slice(0, offset - context.offset));
-    const contextRight = clean(context.text.slice(offset + text.length - context.offset));
-    const contextFull = clean(context.text);
-    const padContext = ' '.repeat(Math.max(maxIssueTextWidth - text.length, 0));
-    const rowText = row.toString();
-    const colText = col.toString();
-    const padRowCol = ' '.repeat(Math.max(1, 8 - (rowText.length + colText.length)));
-    const suggestions = formatSuggestions(io, issue);
-    const msg = issue.message || (issue.isFlagged ? 'Forbidden word' : 'Unknown word');
-    const messageColored = issue.isFlagged ? `{yellow ${msg}}` : msg;
-    const substitutions = {
-        $col: colText,
-        $contextFull: contextFull,
-        $contextLeft: contextLeft,
-        $contextRight: contextRight,
-        $filename: filename,
-        $padContext: padContext,
-        $padRowCol: padRowCol,
-        $row: rowText,
-        $suggestions: suggestions,
-        $text: text,
-        $uri: uri,
-        $quickFix: formatQuickFix(io, issue),
-        $message: msg,
-        $messageColored: messageColored,
-    };
-    const t = templateStr.replaceAll('$messageColored', messageColored);
-    const chalkTemplate = makeTemplate(io.chalk);
-    return substitute(chalkTemplate(t), substitutions).trimEnd();
-}
-function formatSuggestions(io, issue) {
-    if (issue.suggestionsEx) {
-        return issue.suggestionsEx
-            .map((sug) => sug.isPreferred
-            ? io.chalk.italic(io.chalk.bold(sug.wordAdjustedToMatchCase || sug.word)) + '*'
-            : sug.wordAdjustedToMatchCase || sug.word)
-            .join(', ');
-    }
-    if (issue.suggestions) {
-        return issue.suggestions.join(', ');
-    }
-    return '';
-}
-function formatQuickFix(io, issue) {
-    if (!issue.suggestionsEx?.length)
-        return '';
-    const preferred = issue.suggestionsEx
-        .filter((sug) => sug.isPreferred)
-        .map((sug) => sug.wordAdjustedToMatchCase || sug.word);
-    if (!preferred.length)
-        return '';
-    const fixes = preferred.map((w) => io.chalk.italic(io.chalk.yellow(w)));
-    return `fix: (${fixes.join(', ')})`;
-}
-function substitute(text, substitutions) {
-    const subs = [];
-    for (const [match, replaceWith] of Object.entries(substitutions)) {
-        const len = match.length;
-        for (let i = text.indexOf(match); i >= 0; i = text.indexOf(match, i)) {
-            const end = i + len;
-            const reg = /\b/y;
-            reg.lastIndex = end;
-            if (reg.test(text)) {
-                subs.push([i, end, replaceWith]);
-            }
-            i = end;
-        }
-    }
-    subs.sort((a, b) => a[0] - b[0]);
-    let i = 0;
-    function sub(r) {
-        const [a, b, t] = r;
-        const prefix = text.slice(i, a);
-        i = b;
-        return prefix + t;
-    }
-    const parts = subs.map(sub);
-    return parts.join('') + text.slice(i);
-}
-function assertCheckTemplate(template) {
-    const r = checkTemplate(template);
-    if (r instanceof Error) {
-        throw r;
-    }
-}
-export function checkTemplate(template) {
-    const chalk = new Chalk();
-    const chalkTemplate = makeTemplate(chalk);
-    const substitutions = {
-        $col: '<col>',
-        $contextFull: '<contextFull>',
-        $contextLeft: '<contextLeft>',
-        $contextRight: '<contextRight>',
-        $filename: '<filename>',
-        $padContext: '<padContext>',
-        $padRowCol: '<padRowCol>',
-        $row: '<row>',
-        $suggestions: '<suggestions>',
-        $text: '<text>',
-        $uri: '<uri>',
-        $quickFix: '<quickFix>',
-        $message: '<message>',
-        $messageColored: '<messageColored>',
-    };
-    try {
-        const t = chalkTemplate(template);
-        const result = substitute(t, substitutions);
-        const problems = [...result.matchAll(/\$[a-z]+/gi)].map((m) => m[0]);
-        if (problems.length) {
-            throw new Error(`Unresolved template variable${problems.length > 1 ? 's' : ''}: ${problems.map((v) => `'${v}'`).join(', ')}`);
-        }
-        return true;
-    }
-    catch (e) {
-        const msg = e instanceof Error ? e.message : `${e}`;
-        return new ApplicationError(msg);
-    }
-}
-export const __testing__ = {
-    formatIssue,
-};
-//# sourceMappingURL=cli-reporter.js.map

package/dist/esm/commandCheck.d.ts

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

package/dist/esm/commandCheck.js

@@ -1,52 +0,0 @@
-import chalk from 'chalk';
-import { Option as CommanderOption } from 'commander';
-import * as App from './application.mjs';
-import { checkText } from './application.mjs';
-import { console } from './console.js';
-import { CheckFailed } from './util/errors.js';
-export function commandCheck(prog) {
-    return prog
-        .command('check <files...>')
-        .description('Spell check file(s) and display the result. The full file is displayed in color.')
-        .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
-        .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')
-        .option('--no-exit-code', 'Do not return an exit code if issues are found.')
-        .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.'))
-        .action(async (files, options) => {
-        const useExitCode = options.exitCode ?? true;
-        App.parseApplicationFeatureFlags(options.flag);
-        let issueCount = 0;
-        for (const filename of files) {
-            console.log(chalk.yellowBright(`Check file: ${filename}`));
-            console.log();
-            try {
-                const result = await checkText(filename, options);
-                for (const item of result.items) {
-                    const fn = item.flagIE === App.IncludeExcludeFlag.EXCLUDE
-                        ? chalk.gray
-                        : item.isError
-                            ? chalk.red
-                            : chalk.whiteBright;
-                    const t = fn(item.text);
-                    process.stdout.write(t);
-                    issueCount += item.isError ? 1 : 0;
-                }
-                console.log();
-            }
-            catch {
-                console.error(`File not found "${filename}"`);
-                throw new CheckFailed('File not found', 1);
-            }
-            console.log();
-        }
-        if (issueCount) {
-            const exitCode = (useExitCode ?? true) ? 1 : 0;
-            throw new CheckFailed('Issues found', exitCode);
-        }
-    });
-}
-//# sourceMappingURL=commandCheck.js.map

package/dist/esm/commandConfig.d.ts

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

package/dist/esm/commandConfig.js

@@ -1,18 +0,0 @@
-import { collect, crOpt } from './commandHelpers.js';
-import { updateConfig } from './config/updateConfig.js';
-export function commandInit(prog) {
-    const command = prog
-        .command('config')
-        .description('Update a CSpell configuration file.')
-        .option('-c, --config <path>', 'Path to the CSpell configuration file.')
-        .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.', 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.')
-        .action((options) => {
-        return updateConfig(options);
-    });
-    return command;
-}
-//# sourceMappingURL=commandConfig.js.map

package/dist/esm/commandDictionaries.d.ts

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