cspell 7.1.1 → 7.3.0

package/dist/esm/index.mjs

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

package/dist/esm/link.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,39 @@
+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/link.mjs

@@ -36,3 +36,4 @@ export function addPathsToGlobalImportsResultToTable(results) {
         rows: results.resolvedSettings.map(toColumns),
     };
 }
+//# sourceMappingURL=link.mjs.map

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

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

package/dist/esm/lint/LintRequest.js

@@ -0,0 +1,21 @@
+import * as path from 'path';
+import { calcExcludeGlobInfo } from '../util/glob.js';
+import * as util from '../util/util.js';
+const defaultContextRange = 20;
+export class LintRequest {
+    constructor(fileGlobs, options, reporter) {
+        this.fileGlobs = fileGlobs;
+        this.options = options;
+        this.reporter = reporter;
+        this.root = path.resolve(options.root || process.cwd());
+        this.configFile = options.config;
+        this.excludes = calcExcludeGlobInfo(this.root, options.exclude);
+        this.locale = options.locale || '';
+        this.enableGlobDot = options.dot;
+        this.uniqueFilter = options.unique ? util.uniqueFilterFnGenerator((issue) => issue.text) : () => true;
+        this.showContext =
+            options.showContext === true ? defaultContextRange : options.showContext ? options.showContext : 0;
+        this.fileLists = (options.fileList ?? options.fileLists) || [];
+    }
+}
+//# sourceMappingURL=LintRequest.js.map

package/dist/esm/lint/LintRequest.mjs

@@ -18,3 +18,4 @@ export class LintRequest {
         this.fileLists = (options.fileList ?? options.fileLists) || [];
     }
 }
+//# sourceMappingURL=LintRequest.mjs.map

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

@@ -0,0 +1,3 @@
+export { runLint } from './lint.js';
+export { LintRequest } from './LintRequest.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/lint/index.js

@@ -0,0 +1,3 @@
+export { runLint } from './lint.js';
+export { LintRequest } from './LintRequest.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/lint/index.mjs

@@ -1,2 +1,3 @@
 export { runLint } from './lint.mjs';
 export { LintRequest } from './LintRequest.mjs';
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1,4 @@
+import type { RunResult } from '@cspell/cspell-types';
+import type { LintRequest } from './LintRequest.js';
+export declare function runLint(cfg: LintRequest): Promise<RunResult>;
+//# sourceMappingURL=lint.d.ts.map

package/dist/esm/lint/lint.js

@@ -0,0 +1,469 @@
+import { isAsyncIterable, operators, opFilter, pipeAsync, pipeSync } from '@cspell/cspell-pipe';
+import { opMap, pipe } from '@cspell/cspell-pipe/sync';
+import { MessageTypes } from '@cspell/cspell-types';
+import chalk from 'chalk';
+import { findRepoRoot, GitIgnore } from 'cspell-gitignore';
+import { GlobMatcher } from 'cspell-glob';
+import * as cspell from 'cspell-lib';
+import * as path from 'path';
+import { format } from 'util';
+import { npmPackage } from '../../lib/pkgInfo.cjs';
+import { URI } from '../../lib/uri.cjs';
+import { getFeatureFlags } from '../featureFlags/index.js';
+import { calcCacheSettings, createCache } from '../util/cache/index.js';
+import { CheckFailed, toApplicationError, toError } from '../util/errors.js';
+import { fileInfoToDocument, filenameToUri, findFiles, isBinaryFile, isNotDir, readConfig, readFileInfo, readFileListFiles, } from '../util/fileHelper.js';
+import { buildGlobMatcher, extractGlobsFromMatcher, extractPatterns, normalizeFileOrGlobsToRoot, normalizeGlobsToRoot, } from '../util/glob.js';
+import { prefetchIterable } from '../util/prefetch.js';
+import { loadReporters, mergeReporters } from '../util/reporters.js';
+import { getTimeMeasurer } from '../util/timer.js';
+import * as util from '../util/util.js';
+const version = npmPackage.version;
+const BATCH_SIZE = 8;
+const { opFilterAsync } = operators;
+export async function runLint(cfg) {
+    let { reporter } = cfg;
+    cspell.setLogger(getLoggerFromReporter(reporter));
+    const configErrors = new Set();
+    const timer = getTimeMeasurer();
+    const lintResult = await run();
+    await reporter.result(lintResult);
+    const elapsed = timer();
+    if (getFeatureFlags().getFlag('timer')) {
+        console.log(`Elapsed Time: ${elapsed.toFixed(2)}ms`);
+    }
+    return lintResult;
+    function prefetch(filename, configInfo, cache) {
+        if (isBinaryFile(filename, cfg.root))
+            return { filename, result: Promise.resolve({ skip: true }) };
+        async function fetch() {
+            const getElapsedTimeMs = getTimeMeasurer();
+            const cachedResult = await cache.getCachedLintResults(filename);
+            if (cachedResult) {
+                reporter.debug(`Filename: ${filename}, using cache`);
+                const fileResult = { ...cachedResult, elapsedTimeMs: getElapsedTimeMs() };
+                return { fileResult };
+            }
+            const uri = filenameToUri(filename, cfg.root);
+            const checkResult = await cspell.shouldCheckDocument({ uri }, {}, configInfo.config);
+            if (!checkResult.shouldCheck)
+                return { skip: true };
+            const fileInfo = await readFileInfo(filename, undefined, true);
+            return { fileInfo };
+        }
+        const result = fetch();
+        return { filename, result };
+    }
+    async function processFile(filename, configInfo, cache, prefetch) {
+        if (prefetch?.fileResult)
+            return prefetch.fileResult;
+        const getElapsedTimeMs = getTimeMeasurer();
+        const cachedResult = await cache.getCachedLintResults(filename);
+        if (cachedResult) {
+            reporter.debug(`Filename: ${filename}, using cache`);
+            return { ...cachedResult, elapsedTimeMs: getElapsedTimeMs() };
+        }
+        const result = {
+            fileInfo: {
+                filename,
+            },
+            issues: [],
+            processed: false,
+            errors: 0,
+            configErrors: 0,
+            elapsedTimeMs: 0,
+        };
+        const fileInfo = prefetch?.fileInfo || (await readFileInfo(filename, undefined, true));
+        if (fileInfo.errorCode) {
+            if (fileInfo.errorCode !== 'EISDIR' && cfg.options.mustFindFiles) {
+                const err = toError(`File not found: "${filename}"`);
+                reporter.error('Linter:', err);
+                result.errors += 1;
+            }
+            return result;
+        }
+        const doc = fileInfoToDocument(fileInfo, cfg.options.languageId, cfg.locale);
+        const { text } = fileInfo;
+        result.fileInfo = fileInfo;
+        let spellResult = {};
+        reporter.info(`Checking: ${filename}, File type: ${doc.languageId ?? 'auto'}, Language: ${doc.locale ?? 'default'}`, MessageTypes.Info);
+        try {
+            const { showSuggestions: generateSuggestions, validateDirectives } = cfg.options;
+            const numSuggestions = configInfo.config.numSuggestions ?? 5;
+            const validateOptions = util.clean({ generateSuggestions, numSuggestions, validateDirectives });
+            const r = await cspell.spellCheckDocument(doc, validateOptions, configInfo.config);
+            spellResult = r;
+            result.processed = r.checked;
+            result.issues = cspell.Text.calculateTextDocumentOffsets(doc.uri, text, r.issues).map(mapIssue);
+        }
+        catch (e) {
+            reporter.error(`Failed to process "${filename}"`, toError(e));
+            result.errors += 1;
+        }
+        result.elapsedTimeMs = getElapsedTimeMs();
+        const config = spellResult.settingsUsed ?? {};
+        result.configErrors += await reportConfigurationErrors(config);
+        const elapsed = result.elapsedTimeMs / 1000.0;
+        const dictionaries = config.dictionaries || [];
+        reporter.info(`Checked: ${filename}, File type: ${config.languageId}, Language: ${config.language} ... Issues: ${result.issues.length} ${elapsed}S`, MessageTypes.Info);
+        reporter.info(`Config file Used: ${spellResult.localConfigFilepath || configInfo.source}`, MessageTypes.Info);
+        reporter.info(`Dictionaries Used: ${dictionaries.join(', ')}`, MessageTypes.Info);
+        if (cfg.options.debug) {
+            const { id: _id, name: _name, __imports, __importRef, ...cfg } = config;
+            const debugCfg = {
+                filename,
+                languageId: doc.languageId ?? cfg.languageId ?? 'default',
+                config: { ...cfg, source: null },
+                source: spellResult.localConfigFilepath,
+            };
+            reporter.debug(JSON.stringify(debugCfg, undefined, 2));
+        }
+        const dep = calcDependencies(config);
+        cache.setCachedLintResults(result, dep.files);
+        return result;
+    }
+    function mapIssue({ doc: _, ...tdo }) {
+        const context = cfg.showContext
+            ? extractContext(tdo, cfg.showContext)
+            : { text: tdo.line.text.trimEnd(), offset: tdo.line.offset };
+        return util.clean({ ...tdo, context });
+    }
+    async function processFiles(files, configInfo, cacheSettings) {
+        const fileCount = files instanceof Array ? files.length : undefined;
+        const status = runResult();
+        const cache = createCache(cacheSettings);
+        const failFast = cfg.options.failFast ?? configInfo.config.failFast ?? false;
+        const emitProgressBegin = (filename, fileNum, fileCount) => reporter.progress({
+            type: 'ProgressFileBegin',
+            fileNum,
+            fileCount,
+            filename,
+        });
+        const emitProgressComplete = (filename, fileNum, fileCount, result) => reporter.progress(util.clean({
+            type: 'ProgressFileComplete',
+            fileNum,
+            fileCount,
+            filename,
+            elapsedTimeMs: result?.elapsedTimeMs,
+            processed: result?.processed,
+            numErrors: result?.issues.length || result?.errors,
+            cached: result?.cached,
+        }));
+        function* prefetchFiles(files) {
+            const iter = prefetchIterable(pipe(files, opMap((filename) => prefetch(filename, configInfo, cache))), BATCH_SIZE);
+            for (const v of iter) {
+                yield v;
+            }
+        }
+        async function* prefetchFilesAsync(files) {
+            for await (const filename of files) {
+                yield prefetch(filename, configInfo, cache);
+            }
+        }
+        const emptyResult = {
+            fileInfo: { filename: '' },
+            issues: [],
+            processed: false,
+            errors: 0,
+            configErrors: 0,
+            elapsedTimeMs: 1,
+        };
+        async function processPrefetchFileResult(pf, index) {
+            const { filename, result: pFetchResult } = pf;
+            const getElapsedTimeMs = getTimeMeasurer();
+            const fetchResult = await pFetchResult;
+            emitProgressBegin(filename, index, fileCount ?? index);
+            if (fetchResult?.skip) {
+                return {
+                    filename,
+                    fileNum: index,
+                    result: { ...emptyResult, fileInfo: { filename }, elapsedTimeMs: getElapsedTimeMs() },
+                };
+            }
+            const result = await processFile(filename, configInfo, cache, fetchResult);
+            return { filename, fileNum: index, result };
+        }
+        async function* loadAndProcessFiles() {
+            let i = 0;
+            if (isAsyncIterable(files)) {
+                for await (const pf of prefetchFilesAsync(files)) {
+                    yield processPrefetchFileResult(pf, ++i);
+                }
+            }
+            else {
+                for (const pf of prefetchFiles(files)) {
+                    await pf.result;
+                    yield await processPrefetchFileResult(pf, ++i);
+                }
+            }
+        }
+        for await (const fileP of loadAndProcessFiles()) {
+            const { filename, fileNum, result } = await fileP;
+            status.files += 1;
+            status.cachedFiles = (status.cachedFiles || 0) + (result.cached ? 1 : 0);
+            emitProgressComplete(filename, fileNum, fileCount ?? fileNum, result);
+            // Show the spelling errors after emitting the progress.
+            result.issues.filter(cfg.uniqueFilter).forEach((issue) => reporter.issue(issue));
+            if (result.issues.length || result.errors) {
+                status.filesWithIssues.add(filename);
+                status.issues += result.issues.length;
+                status.errors += result.errors;
+                if (failFast) {
+                    return status;
+                }
+            }
+            status.errors += result.configErrors;
+        }
+        cache.reconcile();
+        return status;
+    }
+    function calcDependencies(config) {
+        const { configFiles, dictionaryFiles } = cspell.extractDependencies(config);
+        return { files: configFiles.concat(dictionaryFiles) };
+    }
+    async function reportConfigurationErrors(config) {
+        const errors = cspell.extractImportErrors(config);
+        let count = 0;
+        errors.forEach((ref) => {
+            const key = ref.error.toString();
+            if (configErrors.has(key))
+                return;
+            configErrors.add(key);
+            count += 1;
+            reporter.error('Configuration', ref.error);
+        });
+        const dictCollection = await cspell.getDictionary(config);
+        dictCollection.dictionaries.forEach((dict) => {
+            const dictErrors = dict.getErrors?.() || [];
+            const msg = `Dictionary Error with (${dict.name})`;
+            dictErrors.forEach((error) => {
+                const key = msg + error.toString();
+                if (configErrors.has(key))
+                    return;
+                configErrors.add(key);
+                count += 1;
+                reporter.error(msg, error);
+            });
+        });
+        return count;
+    }
+    function countConfigErrors(configInfo) {
+        return reportConfigurationErrors(configInfo.config);
+    }
+    async function run() {
+        if (cfg.options.root) {
+            process.env[cspell.ENV_CSPELL_GLOB_ROOT] = cfg.root;
+        }
+        const configInfo = await readConfig(cfg.configFile, cfg.root);
+        if (cfg.options.defaultConfiguration !== undefined) {
+            configInfo.config.loadDefaultConfiguration = cfg.options.defaultConfiguration;
+        }
+        const reporterConfig = util.clean({
+            maxNumberOfProblems: configInfo.config.maxNumberOfProblems,
+            maxDuplicateProblems: configInfo.config.maxDuplicateProblems,
+            minWordLength: configInfo.config.minWordLength,
+            ...cfg.options,
+        });
+        const reporters = cfg.options.reporter ?? configInfo.config.reporters;
+        reporter = mergeReporters(...(await loadReporters(reporters, cfg.reporter, reporterConfig)));
+        cspell.setLogger(getLoggerFromReporter(reporter));
+        const globInfo = await determineGlobs(configInfo, cfg);
+        const { fileGlobs, excludeGlobs } = globInfo;
+        const hasFileLists = !!cfg.fileLists.length;
+        if (!fileGlobs.length && !hasFileLists) {
+            // Nothing to do.
+            return runResult();
+        }
+        header(fileGlobs, excludeGlobs);
+        checkGlobs(fileGlobs, reporter);
+        reporter.info(`Config Files Found:\n    ${configInfo.source}\n`, MessageTypes.Info);
+        const configErrors = await countConfigErrors(configInfo);
+        if (configErrors)
+            return runResult({ errors: configErrors });
+        // Get Exclusions from the config files.
+        const { root } = cfg;
+        try {
+            const cacheSettings = await calcCacheSettings(configInfo.config, { ...cfg.options, version }, root);
+            const files = await determineFilesToCheck(configInfo, cfg, reporter, globInfo);
+            return await processFiles(files, configInfo, cacheSettings);
+        }
+        catch (e) {
+            const err = toApplicationError(e);
+            reporter.error('Linter', err);
+            return runResult({ errors: 1 });
+        }
+    }
+    function header(files, cliExcludes) {
+        const formattedFiles = files.length > 100 ? files.slice(0, 100).concat(['...']) : files;
+        reporter.info(`
+cspell;
+Date: ${new Date().toUTCString()}
+Options:
+    verbose:   ${yesNo(!!cfg.options.verbose)}
+    config:    ${cfg.configFile || 'default'}
+    exclude:   ${cliExcludes.join('\n               ')}
+    files:     ${formattedFiles}
+    wordsOnly: ${yesNo(!!cfg.options.wordsOnly)}
+    unique:    ${yesNo(!!cfg.options.unique)}
+`, MessageTypes.Info);
+    }
+}
+function checkGlobs(globs, reporter) {
+    globs
+        .filter((g) => g.startsWith("'") || g.endsWith("'"))
+        .map((glob) => chalk.yellow(glob))
+        .forEach((glob) => reporter.error('Linter', new CheckFailed(`Glob starting or ending with ' (single quote) is not likely to match any files: ${glob}.`)));
+}
+async function determineGlobs(configInfo, cfg) {
+    const useGitignore = cfg.options.gitignore ?? configInfo.config.useGitignore ?? false;
+    const gitignoreRoots = cfg.options.gitignoreRoot ?? configInfo.config.gitignoreRoot;
+    const gitIgnore = useGitignore ? await generateGitIgnore(gitignoreRoots) : undefined;
+    const cliGlobs = cfg.fileGlobs;
+    const allGlobs = cliGlobs.length ? cliGlobs : configInfo.config.files || [];
+    const combinedGlobs = await normalizeFileOrGlobsToRoot(allGlobs, cfg.root);
+    const cliExcludeGlobs = extractPatterns(cfg.excludes).map((p) => p.glob);
+    const normalizedExcludes = 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 appGlobs = { allGlobs, gitIgnore, fileGlobs, excludeGlobs, normalizedExcludes };
+    return appGlobs;
+}
+async function determineFilesToCheck(configInfo, cfg, reporter, globInfo) {
+    async function _determineFilesToCheck() {
+        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 = buildGlobMatcher(globsToExclude, root, true);
+        const ignoreGlobs = extractGlobsFromMatcher(globMatcher);
+        // cspell:word nodir
+        const globOptions = {
+            root,
+            cwd: root,
+            ignore: ignoreGlobs.concat(normalizedExcludes),
+            nodir: true,
+        };
+        const enableGlobDot = cfg.enableGlobDot ?? configInfo.config.enableGlobDot;
+        if (enableGlobDot !== undefined) {
+            globOptions.dot = enableGlobDot;
+        }
+        const filterFiles = opFilter(filterFilesFn(globMatcher));
+        const foundFiles = await (hasFileLists
+            ? useFileLists(fileLists, allGlobs, root, enableGlobDot)
+            : findFiles(fileGlobs, globOptions));
+        const filtered = gitIgnore ? await gitIgnore.filterOutIgnored(foundFiles) : foundFiles;
+        const files = isAsyncIterable(filtered)
+            ? pipeAsync(filtered, filterFiles)
+            : [...pipeSync(filtered, filterFiles)];
+        return files;
+    }
+    function isExcluded(filename, globMatcherExclude) {
+        if (cspell.isBinaryFile(URI.file(filename))) {
+            return true;
+        }
+        const { root } = cfg;
+        const absFilename = path.resolve(root, filename);
+        const r = globMatcherExclude.matchEx(absFilename);
+        if (r.matched) {
+            const { glob, source } = extractGlobSource(r.pattern);
+            reporter.info(`Excluded File: ${path.relative(root, absFilename)}; Excluded by ${glob} from ${source}`, MessageTypes.Info);
+        }
+        return r.matched;
+    }
+    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`, MessageTypes.Info);
+        return (filename) => !isExcluded(filename, globMatcherExclude);
+    }
+    return _determineFilesToCheck();
+}
+function extractContext(tdo, contextRange) {
+    const { line, offset } = tdo;
+    const textOffsetInLine = offset - line.offset;
+    let left = Math.max(textOffsetInLine - contextRange, 0);
+    let right = Math.min(line.text.length, textOffsetInLine + contextRange + tdo.text.length);
+    const lineText = line.text;
+    const isLetter = /^[a-z]$/i;
+    const isSpace = /^\s$/;
+    for (let n = contextRange / 2; n > 0 && left > 0; n--, left--) {
+        if (!isLetter.test(lineText[left - 1])) {
+            break;
+        }
+    }
+    for (let n = contextRange / 2; n > 0 && right < lineText.length; n--, right++) {
+        if (!isLetter.test(lineText[right])) {
+            break;
+        }
+    }
+    // remove leading space
+    for (; left < textOffsetInLine && isSpace.test(lineText[left]); left++) {
+        /* do nothing */
+    }
+    const context = {
+        text: line.text.slice(left, right).trimEnd(),
+        offset: left + line.offset,
+    };
+    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 };
+}
+function yesNo(value) {
+    return value ? 'Yes' : 'No';
+}
+function getLoggerFromReporter(reporter) {
+    const log = (...params) => {
+        const msg = format(...params);
+        reporter.info(msg, 'Info');
+    };
+    const error = (...params) => {
+        const msg = format(...params);
+        const err = { message: '', name: 'error', toString: () => '' };
+        reporter.error(msg, err);
+    };
+    const warn = (...params) => {
+        const msg = format(...params);
+        reporter.info(msg, 'Warning');
+    };
+    return {
+        log,
+        warn,
+        error,
+    };
+}
+async function generateGitIgnore(roots) {
+    const root = (typeof roots === 'string' ? [roots].filter((r) => !!r) : roots) || [];
+    if (!root?.length) {
+        const cwd = process.cwd();
+        const repo = (await findRepoRoot(cwd)) || cwd;
+        root.push(repo);
+    }
+    return new GitIgnore(root?.map((p) => path.resolve(p)));
+}
+async function useFileLists(fileListFiles, includeGlobPatterns, root, dot) {
+    includeGlobPatterns = includeGlobPatterns.length ? includeGlobPatterns : ['**'];
+    const options = { root, mode: 'include' };
+    if (dot !== undefined) {
+        options.dot = dot;
+    }
+    const globMatcher = new GlobMatcher(includeGlobPatterns, options);
+    const filterFiles = (file) => globMatcher.match(file);
+    const files = readFileListFiles(fileListFiles);
+    return pipeAsync(files, opFilter(filterFiles), opFilterAsync(isNotDir));
+}
+//# sourceMappingURL=lint.js.map

package/dist/esm/lint/lint.mjs

@@ -466,3 +466,4 @@ async function useFileLists(fileListFiles, includeGlobPatterns, root, dot) {
     const files = readFileListFiles(fileListFiles);
     return pipeAsync(files, opFilter(filterFiles), opFilterAsync(isNotDir));
 }
+//# sourceMappingURL=lint.mjs.map