cspell 9.1.2 → 9.1.5

package/dist/esm/config/adjustConfig.js

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

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

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

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

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

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

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

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

package/dist/esm/config/index.js

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

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

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

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

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

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

package/dist/esm/config/updateConfig.js

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

package/dist/esm/console.d.ts

@@ -1,25 +0,0 @@
-import type { WriteStream } from 'node:tty';
-type Log = (format?: any, ...params: any[]) => void;
-type IOStream = NodeJS.WritableStream & Pick<WriteStream, 'isTTY' | 'rows' | 'columns'> & Pick<Partial<WriteStream>, 'hasColors' | 'clearLine' | 'getColorDepth'>;
-export interface IConsole {
-    readonly log: Log;
-    readonly error: Log;
-    readonly info: Log;
-    readonly warn: Log;
-    readonly stderrChannel: Channel;
-    readonly stdoutChannel: Channel;
-}
-export declare const console: IConsole;
-export declare function log(...p: Parameters<typeof console.log>): void;
-export declare function error(...p: Parameters<typeof console.error>): void;
-export interface Channel {
-    stream: IOStream;
-    write: (msg: string) => void;
-    writeLine: (msg: string) => void;
-    clearLine: (dir: -1 | 0 | 1, callback?: () => void) => boolean;
-    printLine: (format?: any, ...params: any[]) => void;
-    getColorLevel: () => 0 | 1 | 2 | 3;
-}
-export declare function getColorLevel(stream: IOStream): 0 | 1 | 2 | 3;
-export {};
-//# sourceMappingURL=console.d.ts.map

package/dist/esm/console.js

@@ -1,53 +0,0 @@
-import { formatWithOptions } from 'node:util';
-class ImplChannel {
-    stream;
-    constructor(stream) {
-        this.stream = stream;
-    }
-    write = (msg) => this.stream.write(msg);
-    writeLine = (msg) => this.write(msg + '\n');
-    clearLine = (dir, callback) => this.stream.clearLine?.(dir, callback) ?? false;
-    printLine = (...params) => this.writeLine((params.length && formatWithOptions({ colors: this.stream.hasColors?.() }, ...params)) || '');
-    getColorLevel = () => getColorLevel(this.stream);
-}
-class Console {
-    stdout;
-    stderr;
-    stderrChannel;
-    stdoutChannel;
-    constructor(stdout = process.stdout, stderr = process.stderr) {
-        this.stdout = stdout;
-        this.stderr = stderr;
-        this.stderrChannel = new ImplChannel(this.stderr);
-        this.stdoutChannel = new ImplChannel(this.stdout);
-    }
-    log = (...p) => this.stdoutChannel.printLine(...p);
-    error = (...p) => this.stderrChannel.printLine(...p);
-    info = this.log;
-    warn = this.error;
-}
-export const console = new Console();
-export function log(...p) {
-    console.log(...p);
-}
-export function error(...p) {
-    console.error(...p);
-}
-export function getColorLevel(stream) {
-    const depth = stream.getColorDepth?.() || 0;
-    switch (depth) {
-        case 1: {
-            return 1;
-        }
-        case 4: {
-            return 2;
-        }
-        case 24: {
-            return 3;
-        }
-        default: {
-            return 0;
-        }
-    }
-}
-//# sourceMappingURL=console.js.map

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

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

package/dist/esm/dictionaries/index.js

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

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

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

@@ -1,131 +0,0 @@
-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/dirname.d.ts

@@ -1,2 +0,0 @@
-export declare const pkgDir: string;
-//# sourceMappingURL=dirname.d.ts.map

package/dist/esm/dirname.js

@@ -1,13 +0,0 @@
-// This file is generated by tools/patch-version.mjs
-import { fileURLToPath } from 'node:url';
-let _dirname;
-try {
-    if (typeof import.meta.url !== 'string')
-        throw new Error('assert');
-    _dirname = fileURLToPath(new URL('.', import.meta.url));
-}
-catch {
-    _dirname = __dirname;
-}
-export const pkgDir = _dirname;
-//# sourceMappingURL=dirname.js.map