cspell 9.0.1 → 9.1.0

package/dist/esm/config/adjustConfig.js

@@ -0,0 +1,137 @@
+import assert from 'node:assert';
+import { promises as fs } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { toFileDirURL, urlRelative } from '@cspell/url';
+import { isCfgArrayNode, MutableCSpellConfigFile } from 'cspell-config-lib';
+import { toError } from '../util/errors.js';
+async function fileExists(url) {
+    if (url.protocol !== 'file:') {
+        return false; // Only check file URLs
+    }
+    try {
+        const stats = await fs.stat(url);
+        return stats.isFile();
+    }
+    catch (e) {
+        const err = toError(e);
+        if (err.code === 'ENOENT')
+            return false;
+        throw e;
+    }
+}
+export async function resolveImports(configFile, imports) {
+    const fromConfigDir = new URL('./', configFile.url);
+    const fromCurrentDir = toFileDirURL('./');
+    const require = createRequire(fromConfigDir);
+    function isPackageName(name) {
+        try {
+            require.resolve(name, { paths: [fileURLToPath(fromConfigDir)] });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    const _imports = [];
+    for (const imp of imports) {
+        const url = new URL(imp, fromCurrentDir);
+        if (url.protocol !== 'file:') {
+            _imports.push(imp);
+            continue;
+        }
+        if (await fileExists(url)) {
+            let rel = urlRelative(fromConfigDir, url);
+            if (!(rel.startsWith('./') || rel.startsWith('../'))) {
+                rel = './' + rel; // Ensure relative path starts with './' or '../'
+            }
+            _imports.push(rel);
+            continue;
+        }
+        if (url.protocol !== 'file:') {
+            _imports.push(url.href);
+            continue;
+        }
+        if (isPackageName(imp)) {
+            _imports.push(imp);
+            continue;
+        }
+        throw new Error(`Cannot resolve import: ${imp}`);
+    }
+    return _imports;
+}
+function addImportsToMutableConfigFile(configFile, resolvedImports, comment) {
+    let importNode = configFile.getNode('import', []);
+    if (importNode.type === 'scalar') {
+        configFile.setValue('import', [importNode.value]);
+        importNode = configFile.getNode('import', []);
+    }
+    assert(isCfgArrayNode(importNode));
+    const knownImports = new Set(importNode.value);
+    for (const imp of resolvedImports) {
+        if (knownImports.has(imp))
+            continue;
+        importNode.push(imp);
+    }
+    if (comment) {
+        configFile.setComment('import', comment);
+    }
+}
+export async function addImportsToConfigFile(configFile, imports, comment) {
+    const resolvedImports = await resolveImports(configFile, imports);
+    if (configFile instanceof MutableCSpellConfigFile) {
+        return addImportsToMutableConfigFile(configFile, resolvedImports, comment);
+    }
+    const settings = configFile.settings;
+    let importNode = settings.import;
+    if (!Array.isArray(importNode)) {
+        importNode = typeof importNode === 'string' ? [importNode] : [];
+        settings.import = importNode;
+        if (comment) {
+            configFile.setComment('import', comment);
+        }
+    }
+    assert(Array.isArray(importNode));
+    const knownImports = new Set(importNode);
+    for (const imp of resolvedImports) {
+        if (knownImports.has(imp))
+            continue;
+        importNode.push(imp);
+    }
+}
+export function setConfigFieldValue(configFile, key, value, comment) {
+    configFile.setValue(key, value);
+    if (comment !== undefined) {
+        configFile.setComment(key, comment);
+    }
+}
+export function addDictionariesToConfigFile(configFile, dictionaries, comment) {
+    if (configFile instanceof MutableCSpellConfigFile) {
+        const found = configFile.getValue('dictionaries');
+        const dicts = configFile.getNode('dictionaries', []);
+        assert(isCfgArrayNode(dicts));
+        const knownDicts = new Set(dicts.value);
+        for (const dict of dictionaries) {
+            if (!knownDicts.has(dict)) {
+                dicts.push(dict);
+                knownDicts.add(dict);
+            }
+        }
+        if (!found && comment) {
+            // Set the comment on the field, not the list.
+            configFile.setComment('dictionaries', comment);
+        }
+        return;
+    }
+    const settings = configFile.settings;
+    const dicts = settings.dictionaries || [];
+    const knownDicts = new Set(dicts);
+    for (const dict of dictionaries) {
+        if (!knownDicts.has(dict)) {
+            dicts.push(dict);
+            knownDicts.add(dict);
+        }
+    }
+    setConfigFieldValue(configFile, 'dictionaries', dicts, comment);
+}
+//# sourceMappingURL=adjustConfig.js.map

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

@@ -0,0 +1,5 @@
+import type { CSpellSettings } from '@cspell/cspell-types';
+import type { CSpellConfigFile } from 'cspell-config-lib';
+import type { CommentConfig } from './constants.js';
+export declare function applyValuesToConfigFile(config: CSpellConfigFile, settings: CSpellSettings, defaultValues: CommentConfig, addComments: boolean): CSpellConfigFile;
+//# sourceMappingURL=config.d.ts.map

package/dist/esm/config/config.js

@@ -0,0 +1,18 @@
+import { setConfigFieldValue } from './adjustConfig.js';
+export function applyValuesToConfigFile(config, settings, defaultValues, addComments) {
+    const currentSettings = config.settings || {};
+    for (const [k, entry] of Object.entries(defaultValues)) {
+        const { value: defaultValue, comment } = entry;
+        const key = k;
+        const newValue = settings[key];
+        const oldValue = currentSettings[key];
+        const value = newValue ?? oldValue ?? defaultValue;
+        if ((newValue === undefined && oldValue !== undefined) || value === undefined) {
+            continue;
+        }
+        const useComment = (addComments && oldValue === undefined && comment) || undefined;
+        setConfigFieldValue(config, key, value, useComment);
+    }
+    return config;
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,3 @@
+import type { InitOptions } from './options.js';
+export declare function configInit(options: InitOptions): Promise<void>;
+//# sourceMappingURL=configInit.d.ts.map

package/dist/esm/config/configInit.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs/promises';
+import { toFileDirURL, toFileURL } from '@cspell/url';
+import { createReaderWriter, cspellConfigFileSchema, } from 'cspell-config-lib';
+import { console } from '../console.js';
+import { addDictionariesToConfigFile, addImportsToConfigFile } from './adjustConfig.js';
+import { applyValuesToConfigFile } from './config.js';
+import { defaultConfig } from './constants.js';
+const schemaRef = cspellConfigFileSchema;
+const defaultConfigJson = `\
+{
+}
+`;
+const defaultConfigYaml = `
+`;
+export async function configInit(options) {
+    const rw = createReaderWriter();
+    const url = determineFileNameURL(options);
+    const configFile = await createConfigFile(rw, url, options);
+    await applyOptionsToConfigFile(configFile, options);
+    await fs.mkdir(new URL('./', configFile.url), { recursive: true });
+    if (options.stdout) {
+        console.stdoutChannel.write(rw.serialize(configFile));
+    }
+    else {
+        await rw.writeConfig(configFile);
+    }
+}
+async function applyOptionsToConfigFile(configFile, options) {
+    const settings = {};
+    const addComments = options.comments ||
+        (options.comments === undefined && !options.removeComments && !configFile.url.pathname.endsWith('.json'));
+    if (options.comments === false) {
+        configFile.removeAllComments();
+    }
+    if (options.schema ?? true) {
+        configFile.setSchema(schemaRef);
+    }
+    if (options.locale) {
+        settings.language = options.locale;
+    }
+    applyValuesToConfigFile(configFile, settings, defaultConfig, addComments);
+    if (options.import) {
+        await addImportsToConfigFile(configFile, options.import, (addComments && defaultConfig.import?.comment) || undefined);
+    }
+    if (options.dictionary) {
+        addDictionariesToConfigFile(configFile, options.dictionary, (addComments && defaultConfig.dictionaries?.comment) || undefined);
+    }
+    return configFile;
+}
+function determineFileNameURL(options) {
+    if (options.config) {
+        return toFileURL(options.config);
+    }
+    const defaultFileName = determineDefaultFileName(options);
+    const outputUrl = toFileURL(options.output || defaultFileName);
+    const path = outputUrl.pathname;
+    if (path.endsWith('.json') || path.endsWith('.jsonc') || path.endsWith('.yaml') || path.endsWith('.yml')) {
+        return outputUrl;
+    }
+    if (/\.{m,c}?{j,t}s$/.test(path)) {
+        throw new Error(`Unsupported file extension: ${path}`);
+    }
+    return new URL(defaultFileName, toFileDirURL(outputUrl));
+}
+function determineDefaultFileName(options) {
+    switch (options.format || 'yaml') {
+        case 'json': {
+            return 'cspell.json';
+        }
+        case 'jsonc': {
+            return 'cspell.jsonc';
+        }
+        case 'yaml': {
+            return 'cspell.config.yaml';
+        }
+        case 'yml': {
+            return 'cspell.config.yml';
+        }
+    }
+    throw new Error(`Unsupported format: ${options.format}`);
+}
+function getDefaultContent(options) {
+    switch (options.format) {
+        case undefined:
+        case 'yaml': {
+            return defaultConfigYaml;
+        }
+        case 'json':
+        case 'jsonc': {
+            return defaultConfigJson;
+        }
+        default: {
+            throw new Error(`Unsupported format: ${options.format}`);
+        }
+    }
+}
+async function createConfigFile(rw, url, options) {
+    if (url.pathname.endsWith('package.json')) {
+        return rw.readConfig(url);
+    }
+    const content = await fs.readFile(url, 'utf8').catch(() => getDefaultContent(options));
+    return rw.parse({ url, content });
+}
+//# sourceMappingURL=configInit.js.map

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

@@ -0,0 +1,17 @@
+import type { CSpellSettings } from '@cspell/cspell-types';
+export declare const defaultConfig: CommentConfig;
+export interface ConfigEntry<T, K extends keyof T> {
+    key?: K;
+    value: T[K];
+    comment?: string;
+}
+export interface ApplyToConfigEntry<T, K extends keyof T> extends ConfigEntry<T, K> {
+    update?: (prev: T[K], next: T[K]) => T[K];
+}
+export type CommentConfig = {
+    [K in keyof CSpellSettings]?: ConfigEntry<CSpellSettings, K>;
+};
+export type ApplyToConfig<T = CSpellSettings> = {
+    [K in keyof T]?: ApplyToConfigEntry<T, K>;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/esm/config/constants.js

@@ -0,0 +1,23 @@
+export const defaultConfig = {
+    $schema: { value: undefined, comment: ' The schema for the configuration file.' },
+    version: { value: '0.2', comment: ' The version of the configuration file format.' },
+    name: { value: undefined, comment: ' The name of the configuration. Use for display purposes only.' },
+    description: { value: undefined, comment: ' A description of the configuration.' },
+    language: { value: 'en', comment: ' The locale to use when spell checking. (e.g., en, en-GB, de-DE' },
+    import: { value: undefined, comment: ' Configuration or packages to import.' },
+    dictionaryDefinitions: { value: undefined, comment: ' Define user dictionaries.' },
+    dictionaries: { value: undefined, comment: ' Enable the dictionaries.' },
+    ignorePaths: { value: undefined, comment: ' Glob patterns of files to be skipped.' },
+    files: { value: undefined, comment: ' Glob patterns of files to be included.' },
+    words: { value: undefined, comment: ' Words to be considered correct.' },
+    ignoreWords: { value: undefined, comment: ' Words to be ignored.' },
+    flagWords: { value: undefined, comment: ' Words to be flagged as incorrect.' },
+    overrides: { value: undefined, comment: ' Set configuration based upon file globs.' },
+    languageSettings: { value: undefined, comment: ' Define language specific settings.' },
+    enabledFileTypes: { value: undefined, comment: ' Enable for specific file types.' },
+    caseSensitive: { value: undefined, comment: ' Enable case sensitive spell checking.' },
+    patterns: { value: undefined, comment: ' Regular expression patterns.' },
+    ignoreRegExpList: { value: undefined, comment: ' Regular expressions / patterns of text to be ignored.' },
+    includeRegExpList: { value: undefined, comment: ' Regular expressions / patterns of text to be included.' },
+};
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,3 @@
+export { configInit } from './configInit.js';
+export type { InitOptions } from './options.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/config/index.js

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

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

@@ -0,0 +1,62 @@
+export interface BaseConfigOptions {
+    /**
+     * The path to the configuration file to create / update.
+     * If not provided, a default file name will be used based on the format.
+     */
+    config?: string;
+    /**
+     * The list of configuration files or dictionary packages to import.
+     * This can be a list of file paths, package names, or URLs.
+     */
+    import?: string[];
+    /**
+     * The locale to use when spell checking (e.g., en, en-US, de).
+     */
+    locale?: string;
+    /**
+     * Whether to add comments to the configuration file.
+     * - `true` - comments will be added to the configuration file.
+     * - `false` - no comments will be added.
+     * - `undefined` - the default behavior will be used based on the format.
+     */
+    comments?: boolean;
+    /**
+     * Whether to remove all comments from the configuration file.
+     * - `true` - all comments will be removed.
+     * - `false` | `undefined` - no comments will be removed.
+     * @implies `comments: false`
+     */
+    removeComments?: boolean;
+    /**
+     * Whether to add the schema reference to the configuration file.
+     * - `true` - the schema reference will be added / updated.
+     * - `false` - no schema reference will be added.
+     */
+    schema?: boolean;
+    /**
+     * The list of dictionaries to enable in the configuration file.
+     * These are added to an existing configuration file or a new one.
+     * Existing dictionaries will not be removed.
+     */
+    dictionary?: string[];
+    /**
+     * Whether to write the configuration to stdout instead of a file.
+     */
+    stdout?: boolean;
+}
+export interface InitOptions extends BaseConfigOptions {
+    /**
+     * The path where the configuration file will be written, it can be a file path or a URL.
+     * If not provided, a default file name will be used based on the format.
+     * The default will be `cspell.config.yaml` or `cspell.json` based on the format.
+     * @conflicts `config` - If `config` is provided, it will be used instead of `output`.
+     */
+    output?: string;
+    /**
+     * The format of the configuration file.
+     * @conflicts `config` - If `config` is provided, the format will be inferred from the file extension.
+     */
+    format?: 'yaml' | 'yml' | 'json' | 'jsonc';
+}
+export type UpdateConfigOptions = BaseConfigOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/esm/config/options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=options.js.map

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

@@ -0,0 +1,3 @@
+import { UpdateConfigOptions } from './options.js';
+export declare function updateConfig(_options: UpdateConfigOptions): Promise<void>;
+//# sourceMappingURL=updateConfig.d.ts.map

package/dist/esm/config/updateConfig.js

@@ -0,0 +1,2 @@
+export async function updateConfig(_options) { }
+//# sourceMappingURL=updateConfig.js.map

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

@@ -0,0 +1,3 @@
+export type { ListDictionariesResult } from './listDictionaries.js';
+export { listDictionaries } from './listDictionaries.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/dictionaries/index.js

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

package/dist/esm/dictionaries/listDictionaries.d.ts

@@ -0,0 +1,33 @@
+import type { DictionariesOptions } from '../options.js';
+export interface ListDictionariesResult {
+    /**
+     * The name of the dictionary.
+     */
+    name: string;
+    /**
+     * The description of the dictionary.
+     */
+    description?: string | undefined;
+    /**
+     * The path to the dictionary file.
+     */
+    path?: string | undefined;
+    /**
+     * True if the dictionary is enabled.
+     */
+    enabled: boolean;
+    /**
+     * The inline dictionaries supported by the dictionary.
+     */
+    inline?: string[] | undefined;
+    /**
+     * the languages locales supported by the dictionary.
+     */
+    locales?: string[] | undefined;
+    /**
+     * The file types supported by the dictionary.
+     */
+    fileTypes?: string[] | undefined;
+}
+export declare function listDictionaries(options: DictionariesOptions): Promise<ListDictionariesResult[]>;
+//# sourceMappingURL=listDictionaries.d.ts.map

package/dist/esm/dictionaries/listDictionaries.js

@@ -0,0 +1,131 @@
+import { combineTextAndLanguageSettings, getDefaultSettings, getGlobalSettingsAsync, mergeSettings } from 'cspell-lib';
+import { readConfig } from '../util/configFileHelper.js';
+const inlineDictionaries = {
+    '[words]': {
+        name: '[words]',
+        description: 'List of words to be included in the spell check.',
+        enabled: true,
+    },
+    '[flagWords]': {
+        name: '[flagWords]',
+        description: 'List of words to be flagged as incorrect.',
+        enabled: true,
+    },
+    '[ignoreWords]': {
+        name: '[ignoreWords]',
+        description: 'List of words to be ignored in the spell check.',
+        enabled: true,
+    },
+    '[suggestWords]': {
+        name: '[suggestWords]',
+        description: 'List of spelling suggestions for words.',
+        enabled: true,
+    },
+};
+function splitList(list) {
+    if (!list)
+        return [];
+    if (typeof list === 'string') {
+        return list
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => !!s);
+    }
+    return list.flatMap((s) => splitList(s));
+}
+function extractDictionaryLocalesAndFileTypes(config) {
+    const map = new Map();
+    function getDict(name) {
+        const found = map.get(name);
+        if (found)
+            return found;
+        const dict = { locales: new Set(), fileTypes: new Set() };
+        map.set(name, dict);
+        return dict;
+    }
+    const languageSettings = config.languageSettings || [];
+    for (const lang of languageSettings) {
+        const locales = splitList(lang.locale);
+        const fileTypes = splitList(lang.languageId);
+        const dicts = lang.dictionaries || [];
+        for (const dictName of dicts) {
+            const dict = getDict(dictName);
+            for (const locale of locales) {
+                if (locale)
+                    dict.locales.add(locale);
+            }
+            for (const fileType of fileTypes) {
+                if (fileType)
+                    dict.fileTypes.add(fileType);
+            }
+        }
+    }
+    return map;
+}
+function extractInlineDictionaries(dict) {
+    const iDict = dict;
+    const inline = [];
+    if (iDict.words?.length) {
+        inline.push('[words]');
+    }
+    if (iDict.flagWords?.length) {
+        inline.push('[flagWords]');
+    }
+    if (iDict.ignoreWords?.length) {
+        inline.push('[ignoreWords]');
+    }
+    if (iDict.suggestWords?.length) {
+        inline.push('[suggestWords]');
+    }
+    return inline.length ? inline : undefined;
+}
+function extractSpecialDictionaries(config) {
+    const specialDictionaries = [];
+    if (config.words?.length) {
+        specialDictionaries.push(inlineDictionaries['[words]']);
+    }
+    if (config.flagWords?.length) {
+        specialDictionaries.push(inlineDictionaries['[flagWords]']);
+    }
+    if (config.ignoreWords?.length) {
+        specialDictionaries.push(inlineDictionaries['[ignoreWords]']);
+    }
+    if (config.suggestWords?.length) {
+        specialDictionaries.push(inlineDictionaries['[suggestWords]']);
+    }
+    return specialDictionaries;
+}
+export async function listDictionaries(options) {
+    const configFile = await readConfig(options.config, undefined);
+    const loadDefault = options.defaultConfiguration ?? configFile.config.loadDefaultConfiguration ?? true;
+    const configBase = mergeSettings(await getDefaultSettings(loadDefault), await getGlobalSettingsAsync(), configFile.config);
+    const useFileType = options.fileType === 'text' ? 'plaintext' : options.fileType;
+    if (options.locale) {
+        configBase.language = options.locale;
+    }
+    const config = combineTextAndLanguageSettings(configBase, '', useFileType || configBase.languageId || 'plaintext');
+    const dictionaryLocalesAndFileTypes = extractDictionaryLocalesAndFileTypes(config);
+    const enabledDictionaries = new Set(config.dictionaries || []);
+    function toListDictionariesResult(dict) {
+        const inline = extractInlineDictionaries(dict);
+        return {
+            name: dict.name,
+            description: dict.description,
+            enabled: enabledDictionaries.has(dict.name),
+            path: dict.path,
+            inline,
+            locales: [...(dictionaryLocalesAndFileTypes.get(dict.name)?.locales || [])].sort(),
+            fileTypes: [...(dictionaryLocalesAndFileTypes.get(dict.name)?.fileTypes || [])].sort(),
+        };
+    }
+    function filterDicts(dict) {
+        if (options.enabled === undefined)
+            return true;
+        return options.enabled === enabledDictionaries.has(dict.name);
+    }
+    const dictionaryDefinitions = (config.dictionaryDefinitions || []).filter(filterDicts);
+    dictionaryDefinitions.sort((a, b) => a.name.localeCompare(b.name));
+    const specialDicts = options.enabled !== false ? extractSpecialDictionaries(config) : [];
+    return [...specialDicts, ...dictionaryDefinitions.map(toListDictionariesResult)];
+}
+//# sourceMappingURL=listDictionaries.js.map

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

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

@@ -0,0 +1,82 @@
+import * as iPath from 'node:path';
+import chalk from 'chalk';
+import { console } from '../console.js';
+import { pruneTextEnd, pruneTextStart } 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(pruneTextEnd(r.name, width && width - a.length) + a);
+    const c = colorize(chalk.white);
+    const locales = (width) => c(pruneTextEnd(r.locales?.join(',') || '', width));
+    const fileTypes = (width) => c(pruneTextEnd(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 &&
+            pruneTextStart(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