cspell 9.1.2 → 9.1.5

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

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

package/dist/esm/emitters/DictionaryPathFormat.js

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

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

@@ -1,19 +0,0 @@
-import type { ListDictionariesResult } from '../dictionaries/index.js';
-import type { DictionariesOptions } from '../options.js';
-import type { DictionaryPathFormat } from './DictionaryPathFormat.js';
-import { type PathInterface } from './helpers.js';
-export interface EmitDictOptions {
-    /** current working directory */
-    cwd: string;
-    lineWidth?: number;
-    dictionaryPathFormat: DictionaryPathFormat;
-    iPath?: PathInterface;
-    color?: boolean | undefined;
-    options: DictionariesOptions;
-}
-export declare function emitListDictionariesResults(results: ListDictionariesResult[], options: EmitDictOptions): void;
-export declare function calcListDictsResultsReport(results: ListDictionariesResult[], options: EmitDictOptions): {
-    table: string;
-    errors: string;
-};
-//# sourceMappingURL=dictionaryListEmitter.d.ts.map

package/dist/esm/emitters/dictionaryListEmitter.js

@@ -1,82 +0,0 @@
-import * as iPath from 'node:path';
-import chalk from 'chalk';
-import { console } from '../console.js';
-import { pruneAnsiTextEnd, pruneAnsiTextStart } from '../util/pad.js';
-import { tableToLines } from '../util/table.js';
-import { formatDictionaryLocation } from './helpers.js';
-const maxWidth = 120;
-export function emitListDictionariesResults(results, options) {
-    const report = calcListDictsResultsReport(results, options);
-    console.log(report.table);
-    if (report.errors) {
-        console.error('Errors:');
-        console.error(report.errors);
-    }
-}
-export function calcListDictsResultsReport(results, options) {
-    if (options.color === true) {
-        chalk.level = 2;
-    }
-    else if (options.color === false) {
-        chalk.level = 0;
-    }
-    const col = new Intl.Collator();
-    results.sort((a, b) => col.compare(a.name, b.name));
-    const header = calcHeaders(options);
-    const rows = results.map((r) => dictTableRowToTableRow(emitDictResult(r, options)));
-    const t = tableToLines({
-        header,
-        rows,
-        terminalWidth: options.lineWidth || process.stdout.columns || maxWidth,
-        deliminator: ' ',
-        maxColumnWidths: {
-            locales: 12,
-            fileTypes: 40,
-        },
-    });
-    return {
-        table: t.map((line) => line.trimEnd()).join('\n'),
-        errors: '',
-    };
-}
-function calcHeaders(options) {
-    const showLocation = options.dictionaryPathFormat !== 'hide' && (options.options.showLocation ?? true);
-    const showLocales = options.options.showLocales ?? true;
-    const showFileTypes = options.options.showFileTypes ?? true;
-    const headers = [['name', 'Dictionary']];
-    showLocales && headers.push(['locales', 'Locales']);
-    showFileTypes && headers.push(['fileTypes', 'File Types']);
-    showLocation && headers.push(['location', 'Dictionary Location']);
-    return headers;
-}
-function emitDictResult(r, options) {
-    const a = r.enabled ? '*' : ' ';
-    const dictColor = r.enabled ? chalk.yellowBright : chalk.rgb(200, 128, 50);
-    const n = (width) => dictColor(pruneAnsiTextEnd(r.name, width && width - a.length) + a);
-    const c = colorize(chalk.white);
-    const locales = (width) => c(pruneAnsiTextEnd(r.locales?.join(',') || '', width));
-    const fileTypes = (width) => c(pruneAnsiTextEnd(r.fileTypes?.join(',') || '', width));
-    if (!r.path) {
-        return {
-            name: n,
-            location: c(r.inline?.join(', ') || ''),
-            locales,
-            fileTypes,
-        };
-    }
-    return {
-        name: n,
-        location: (widthSrc) => c((r.path &&
-            pruneAnsiTextStart(formatDictionaryLocation(r.path, widthSrc ?? maxWidth, { iPath, ...options }), widthSrc ?? maxWidth)) ||
-            ''),
-        locales,
-        fileTypes,
-    };
-}
-function dictTableRowToTableRow(row) {
-    return Object.fromEntries(Object.entries(row));
-}
-function colorize(fn) {
-    return (s) => (s ? fn(s) : '');
-}
-//# sourceMappingURL=dictionaryListEmitter.js.map

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

@@ -1,14 +0,0 @@
-import type { DictionaryPathFormat } from './DictionaryPathFormat.js';
-export interface PathInterface {
-    relative(from: string, to: string): string;
-    basename(path: string): string;
-    sep: string;
-}
-export declare function trimMidPath(s: string, w: number, sep: string): string;
-export declare function trimMid(s: string, w: number): string;
-export declare function formatDictionaryLocation(dictSource: string, maxWidth: number, { cwd, dictionaryPathFormat: format, iPath, }: {
-    cwd: string;
-    dictionaryPathFormat: DictionaryPathFormat;
-    iPath: PathInterface;
-}): string;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/esm/emitters/helpers.js

@@ -1,67 +0,0 @@
-export function trimMidPath(s, w, sep) {
-    if (s.length <= w)
-        return s;
-    const parts = s.split(sep);
-    if (parts[parts.length - 1].length > w)
-        return trimMid(s, w);
-    function join(left, right) {
-        // if (left === right) return parts.join(sep);
-        return [...parts.slice(0, left), '…', ...parts.slice(right)].join(sep);
-    }
-    let left = 0, right = parts.length, last = '';
-    for (let i = 0; i < parts.length; ++i) {
-        const incLeft = i & 1 ? 1 : 0;
-        const incRight = incLeft ? 0 : -1;
-        const next = join(left + incLeft, right + incRight);
-        if (next.length > w)
-            break;
-        left += incLeft;
-        right += incRight;
-        last = next;
-    }
-    for (let i = left + 1; i < right; ++i) {
-        const next = join(i, right);
-        if (next.length > w)
-            break;
-        last = next;
-    }
-    for (let i = right - 1; i > left; --i) {
-        const next = join(left, i);
-        if (next.length > w)
-            break;
-        last = next;
-    }
-    return last || trimMid(s, w);
-}
-export function trimMid(s, w) {
-    s = s.trim();
-    if (s.length <= w) {
-        return s;
-    }
-    const l = Math.floor((w - 1) / 2);
-    const r = Math.ceil((w - 1) / 2);
-    return s.slice(0, l) + '…' + s.slice(-r);
-}
-export function formatDictionaryLocation(dictSource, maxWidth, { cwd, dictionaryPathFormat: format, iPath, }) {
-    let relPath = cwd ? iPath.relative(cwd, dictSource) : dictSource;
-    const idxNodeModule = relPath.lastIndexOf('node_modules');
-    const isNodeModule = idxNodeModule >= 0;
-    if (format === 'hide')
-        return '';
-    if (format === 'short') {
-        const prefix = isNodeModule
-            ? '[node_modules]/'
-            : relPath.startsWith('..' + iPath.sep + '..')
-                ? '…/'
-                : relPath.startsWith('..' + iPath.sep)
-                    ? '../'
-                    : '';
-        return prefix + iPath.basename(dictSource);
-    }
-    if (format === 'full')
-        return dictSource;
-    relPath = isNodeModule ? relPath.slice(idxNodeModule) : relPath;
-    const usePath = relPath.length < dictSource.length ? relPath : dictSource;
-    return trimMidPath(usePath, maxWidth, iPath.sep);
-}
-//# sourceMappingURL=helpers.js.map

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

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

package/dist/esm/emitters/suggestionsEmitter.js

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

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

@@ -1,19 +0,0 @@
-import type { TraceResult } from '../application.mjs';
-import type { DictionaryPathFormat } from './DictionaryPathFormat.js';
-import { type PathInterface } from './helpers.js';
-export interface EmitTraceOptions {
-    /** current working directory */
-    cwd: string;
-    lineWidth?: number;
-    dictionaryPathFormat: DictionaryPathFormat;
-    iPath?: PathInterface;
-    prefix?: string;
-    showWordFound?: boolean;
-    color?: boolean | undefined;
-}
-export declare function emitTraceResults(word: string, found: boolean, results: TraceResult[], options: EmitTraceOptions): void;
-export declare function calcTraceResultsReport(word: string, found: boolean, results: TraceResult[], options: EmitTraceOptions): {
-    table: string;
-    errors: string;
-};
-//# sourceMappingURL=traceEmitter.d.ts.map

package/dist/esm/emitters/traceEmitter.js

@@ -1,87 +0,0 @@
-import * as iPath from 'node:path';
-import chalk from 'chalk';
-import { console } from '../console.js';
-import { tableToLines } from '../util/table.js';
-import { formatDictionaryLocation } from './helpers.js';
-const maxWidth = 120;
-const colWidthDictionaryName = 20;
-export function emitTraceResults(word, found, results, options) {
-    const report = calcTraceResultsReport(word, found, results, options);
-    console.log(report.table);
-    if (report.errors) {
-        console.error('Errors:');
-        console.error(report.errors);
-    }
-}
-export function calcTraceResultsReport(word, found, results, options) {
-    if (options.color === true) {
-        chalk.level = 2;
-    }
-    else if (options.color === false) {
-        chalk.level = 0;
-    }
-    const col = new Intl.Collator();
-    results.sort((a, b) => col.compare(a.dictName, b.dictName));
-    options.showWordFound && console.log(`${options.prefix || ''}${word}: ${found ? 'Found' : 'Not Found'}`);
-    const header = emitHeader(options.dictionaryPathFormat !== 'hide');
-    const rows = results.map((r) => emitTraceResult(r, options));
-    const t = tableToLines({
-        header,
-        rows,
-        terminalWidth: options.lineWidth || process.stdout.columns || maxWidth,
-        deliminator: ' ',
-    });
-    return {
-        table: t.map((line) => line.trimEnd()).join('\n'),
-        errors: emitErrors(results).join('\n'),
-    };
-}
-function emitHeader(location) {
-    const headers = ['Word', 'F', 'Dictionary'];
-    location && headers.push('Dictionary Location');
-    return headers;
-}
-function emitTraceResult(r, options) {
-    const errors = !!r.errors?.length;
-    const word = r.foundWord || r.word;
-    const cWord = word.replaceAll('+', chalk.yellow('+'));
-    const sug = r.preferredSuggestions?.map((s) => chalk.yellowBright(s)).join(', ') || '';
-    const w = (r.forbidden ? chalk.red(cWord) : chalk.green(cWord)) + (sug ? `->(${sug})` : '');
-    const f = calcFoundChar(r);
-    const a = r.dictActive ? '*' : ' ';
-    const dictName = r.dictName.slice(0, colWidthDictionaryName - 1) + a;
-    const dictColor = r.dictActive ? chalk.yellowBright : chalk.rgb(200, 128, 50);
-    const n = dictColor(dictName);
-    const c = colorize(errors ? chalk.red : chalk.white);
-    return [
-        w,
-        f,
-        n,
-        (widthSrc) => c(formatDictionaryLocation(r.dictSource, widthSrc ?? maxWidth, { iPath, ...options })),
-    ];
-}
-function emitErrors(results) {
-    const errorResults = results.filter((r) => r.errors?.length);
-    return errorResults.map((r) => {
-        const errors = r.errors?.map((e) => e.message)?.join('\n\t') || '';
-        return chalk.bold(r.dictName) + '\n\t' + chalk.red(errors);
-    });
-}
-function calcFoundChar(r) {
-    const errors = r.errors?.map((e) => e.message)?.join('\n\t') || '';
-    let color = chalk.dim;
-    color = r.found ? chalk.whiteBright : color;
-    color = r.forbidden ? chalk.red : color;
-    color = r.noSuggest ? chalk.yellowBright : color;
-    color = errors ? chalk.red : color;
-    let char = '-';
-    char = r.found ? '*' : char;
-    char = r.forbidden ? '!' : char;
-    char = r.noSuggest ? 'I' : char;
-    char = errors ? 'X' : char;
-    return color(char);
-}
-function colorize(fn) {
-    return (s) => (s ? fn(s) : '');
-}
-//# sourceMappingURL=traceEmitter.js.map

package/dist/esm/environment.d.ts

@@ -1,39 +0,0 @@
-export interface CSpellEnvironmentVariables {
-    /**
-     * Enable logging ALL dictionary requests.
-     * Acceptable values are: 'true', 'false', 't', 'f', 'on', 'off', 'yes', 'no', '1', '0'
-     */
-    CSPELL_ENABLE_DICTIONARY_LOGGING?: string;
-    /**
-     * The path to the dictionary log file.
-     */
-    CSPELL_ENABLE_DICTIONARY_LOG_FILE?: string;
-    /**
-     * A Csv list of fields to log.
-     * Fields:
-     * - time: the time the check was made in milliseconds
-     * - word: the word being checked
-     * - value: the result of the check
-     */
-    CSPELL_ENABLE_DICTIONARY_LOG_FIELDS?: string;
-    CSPELL_GLOB_ROOT?: string;
-    /**
-     * Path to a specific CSpell config file.
-     */
-    CSPELL_CONFIG_PATH?: string;
-    /**
-     * Path to the default CSpell config file, used if no other config is found.
-     */
-    CSPELL_DEFAULT_CONFIG_PATH?: string;
-}
-export type EnvironmentKeys = keyof CSpellEnvironmentVariables;
-type EnvironmentKeyNames = {
-    [K in EnvironmentKeys]: K;
-};
-export declare const environmentKeys: EnvironmentKeyNames;
-export declare function getEnvironmentVariables(): CSpellEnvironmentVariables;
-export declare function setEnvironmentVariable<K extends EnvironmentKeys>(key: K, value: CSpellEnvironmentVariables[K]): void;
-export declare function getEnvironmentVariable<K extends EnvironmentKeys>(key: K): CSpellEnvironmentVariables[K] | undefined;
-export declare function truthy(value: string | undefined): boolean;
-export {};
-//# sourceMappingURL=environment.d.ts.map

package/dist/esm/environment.js

@@ -1,30 +0,0 @@
-export const environmentKeys = {
-    CSPELL_ENABLE_DICTIONARY_LOGGING: 'CSPELL_ENABLE_DICTIONARY_LOGGING',
-    CSPELL_ENABLE_DICTIONARY_LOG_FILE: 'CSPELL_ENABLE_DICTIONARY_LOG_FILE',
-    CSPELL_ENABLE_DICTIONARY_LOG_FIELDS: 'CSPELL_ENABLE_DICTIONARY_LOG_FIELDS',
-    CSPELL_GLOB_ROOT: 'CSPELL_GLOB_ROOT',
-    CSPELL_CONFIG_PATH: 'CSPELL_CONFIG_PATH',
-    CSPELL_DEFAULT_CONFIG_PATH: 'CSPELL_DEFAULT_CONFIG_PATH',
-};
-export function getEnvironmentVariables() {
-    return process.env;
-}
-export function setEnvironmentVariable(key, value) {
-    process.env[key] = value;
-}
-export function getEnvironmentVariable(key) {
-    return process.env[key];
-}
-export function truthy(value) {
-    switch (value?.toLowerCase().trim()) {
-        case 't':
-        case 'true':
-        case 'on':
-        case 'yes':
-        case '1': {
-            return true;
-        }
-    }
-    return false;
-}
-//# sourceMappingURL=environment.js.map

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

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

package/dist/esm/featureFlags/featureFlags.js

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

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

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

package/dist/esm/featureFlags/index.js

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

package/dist/esm/index.d.mts

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

package/dist/esm/index.mjs

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

package/dist/esm/link.d.ts

@@ -1,8 +0,0 @@
-import { Link } from 'cspell-lib';
-import type { Table } from './util/table.js';
-export declare const listGlobalImports: typeof Link.listGlobalImports;
-export declare const addPathsToGlobalImports: typeof Link.addPathsToGlobalImports;
-export declare const removePathsFromGlobalImports: typeof Link.removePathsFromGlobalImports;
-export declare function listGlobalImportsResultToTable(results: Link.ListGlobalImportsResult[]): Table;
-export declare function addPathsToGlobalImportsResultToTable(results: Link.AddPathsToGlobalImportsResults): Table;
-//# sourceMappingURL=link.d.ts.map

package/dist/esm/link.js

@@ -1,39 +0,0 @@
-import chalk from 'chalk';
-import { Link } from 'cspell-lib';
-export const listGlobalImports = Link.listGlobalImports;
-export const addPathsToGlobalImports = Link.addPathsToGlobalImports;
-export const removePathsFromGlobalImports = Link.removePathsFromGlobalImports;
-export function listGlobalImportsResultToTable(results) {
-    const header = ['id', 'package', 'name', 'filename', 'dictionaries', 'errors'];
-    const decorate = (isError) => (isError ? (s) => chalk.red(s) : (s) => s);
-    function toColumns(r) {
-        return [
-            r.id,
-            r.package?.name,
-            r.name,
-            r.filename,
-            r.dictionaryDefinitions?.map((def) => def.name).join(', '),
-            r.error ? 'Failed to read file.' : '',
-        ]
-            .map((c) => c || '')
-            .map(decorate(!!r.error));
-    }
-    return {
-        header,
-        rows: results.map(toColumns),
-    };
-}
-export function addPathsToGlobalImportsResultToTable(results) {
-    const header = ['filename', 'errors'];
-    const decorate = (isError) => (isError ? (s) => chalk.red(s) : (s) => s);
-    function toColumns(r) {
-        return [r.resolvedToFilename || r.filename, r.error ? 'Failed to read file.' : '']
-            .map((c) => c || '')
-            .map(decorate(!!r.error));
-    }
-    return {
-        header,
-        rows: results.resolvedSettings.map(toColumns),
-    };
-}
-//# sourceMappingURL=link.js.map

package/dist/esm/lint/LintRequest.d.ts

@@ -1,26 +0,0 @@
-import { type CSpellUserSettings, type UnknownWordsConfiguration } from '@cspell/cspell-types';
-import type { CSpellConfigFile, LinterCliOptions, LinterOptions } from '../options.js';
-import type { GlobSrcInfo } from '../util/glob.js';
-import type { FinalizedReporter } from '../util/reporters.js';
-interface Deprecated {
-    fileLists?: LinterOptions['fileList'];
-    local?: LinterOptions['locale'];
-}
-export declare class LintRequest {
-    readonly fileGlobs: string[];
-    readonly options: LinterCliOptions & Deprecated;
-    readonly reporter: FinalizedReporter;
-    readonly locale: string;
-    readonly configFile: string | CSpellConfigFile | undefined;
-    readonly excludes: GlobSrcInfo[];
-    readonly root: string;
-    readonly showContext: number;
-    readonly enableGlobDot: boolean | undefined;
-    readonly fileLists: string[];
-    readonly files: string[] | undefined;
-    readonly cspellSettingsFromCliOptions: CSpellUserSettings;
-    constructor(fileGlobs: string[], options: LinterCliOptions & Deprecated, reporter: FinalizedReporter);
-}
-export declare function extractUnknownWordsConfig(options: LinterCliOptions): UnknownWordsConfiguration;
-export {};
-//# sourceMappingURL=LintRequest.d.ts.map