cspell-lib 9.6.0 → 9.6.2

package/dist/lib/Settings/sanitizeSettings.js

@@ -0,0 +1,254 @@
+import { cloneInto, copy0, copy1, skip } from '../util/clone.js';
+/**
+ * Sanitize settings for export by removing any internal only properties.
+ *
+ * @param settings - the input settings
+ */
+export function cloneSettingsForExport(settings) {
+    const result = {};
+    const handlers = getHandlers();
+    cloneInto(settings, result, handlers);
+    return result;
+}
+const handlers = {
+    $schema: skip,
+    __importRef: copyImportRefField,
+    __imports: copyImportsField,
+    source: copySourceField,
+    id: skip,
+    version: skip,
+    allowCompoundWords: copy1,
+    cache: skip,
+    caseSensitive: copy1,
+    description: skip,
+    dictionaries: copy1,
+    dictionaryDefinitions: copyDictionaryDefinitions,
+    enabled: copy1,
+    enabledLanguageIds: copy1,
+    enableFiletypes: copy1,
+    enabledFileTypes: copy1,
+    enableGlobDot: copy1,
+    failFast: copy1,
+    features: skip,
+    files: copyGlobsSettingsFields,
+    flagWords: copy1,
+    gitignoreRoot: copy1,
+    globRoot: copy1,
+    ignorePaths: copyGlobsSettingsFields,
+    ignoreRegExpList: copy1,
+    ignoreWords: copy1,
+    ignoreRandomStrings: copy1,
+    import: skip,
+    includeRegExpList: copy1,
+    language: copy1,
+    languageId: copy1,
+    languageSettings: copyLanguageSettings,
+    loadDefaultConfiguration: copy1,
+    maxDuplicateProblems: copy1,
+    maxFileSize: copy1,
+    maxNumberOfProblems: copy1,
+    minWordLength: copy1,
+    minRandomLength: copy1,
+    name: skip,
+    noConfigSearch: copy1,
+    noSuggestDictionaries: copy1,
+    numSuggestions: copy1,
+    overrides: copyOverrides,
+    patterns: copyPatternsField,
+    pnpFiles: skip,
+    readonly: skip,
+    reporters: skip,
+    showStatus: copy1,
+    spellCheckDelayMs: copy1,
+    suggestionNumChanges: copy1,
+    suggestionsTimeout: copy1,
+    suggestWords: copy1,
+    unknownWords: copy1,
+    useGitignore: copy1,
+    usePnP: skip,
+    userWords: copy1,
+    validateDirectives: copy1,
+    words: copy1,
+    // Experimental
+    parser: skip,
+};
+function getHandlers() {
+    return handlers;
+}
+function copyImportRefField(src, dst, key) {
+    const ref = src[key];
+    if (!ref)
+        return;
+    dst[key] = copyImportFileRef(ref);
+}
+function copyImportsField(src, dst, key) {
+    const imports = src[key];
+    if (!imports)
+        return;
+    dst[key] = new Map([...imports.entries()].map(([k, v]) => [k, copyImportFileRef(v)]));
+}
+function copyImportFileRef(src) {
+    const ref = { filename: src.filename };
+    copy0(src, ref, 'error');
+    return ref;
+}
+function copySourceField(src, dst, key) {
+    if (!src[key])
+        return;
+    dst[key] = copySource(src[key]);
+}
+function copySource(src) {
+    const source = { name: src.name };
+    cpy(src, source, 'filename');
+    return source;
+}
+function copyGlobsSettingsFields(src, dst, key) {
+    const globs = src[key];
+    if (!globs)
+        return;
+    dst[key] = copyGlobOrGlobs(globs);
+}
+function copyGlobsOverrideFields(src, dst, key) {
+    const globs = src[key];
+    if (!globs)
+        return;
+    dst[key] = copyGlobOrGlobs(globs);
+}
+function copyGlobOrGlobs(globOrGlobs) {
+    if (Array.isArray(globOrGlobs)) {
+        return globOrGlobs.map(copyGlob);
+    }
+    return copyGlob(globOrGlobs);
+}
+function copyGlob(glob) {
+    if (typeof glob === 'string') {
+        return glob;
+    }
+    const g = { glob: glob.glob };
+    cpy(glob, g, 'root');
+    return g;
+}
+function copyDictionaryDefinitions(src, dst, key) {
+    const defs = src[key];
+    if (!defs)
+        return;
+    dst[key] = defs.map(copyDictionaryDefinition);
+}
+function copyDictionaryDefinition(src) {
+    const def = { name: src.name };
+    cpy(src, def, 'path');
+    cpy(src, def, 'type');
+    cpy(src, def, 'description');
+    return def;
+}
+function copyLanguageSettings(src, dst, key) {
+    const langSettings = src[key];
+    if (!langSettings)
+        return;
+    dst[key] = langSettings.map((src) => {
+        const dst = { languageId: src.languageId };
+        copyLanguageSetting(src, dst);
+        return dst;
+    });
+}
+function cpy(src, dst, key) {
+    const value = src[key];
+    if (value === undefined)
+        return;
+    dst[key] = value;
+}
+const LanguageSettingsHandlers = {
+    id: cpy,
+    locale: cpy,
+    local: cpy,
+    allowCompoundWords: copy1,
+    caseSensitive: copy1,
+    description: skip,
+    dictionaries: copy1,
+    dictionaryDefinitions: copyDictionaryDefinitions,
+    enabled: copy1,
+    flagWords: copy1,
+    ignoreRegExpList: copy1,
+    ignoreWords: copy1,
+    includeRegExpList: copy1,
+    languageId: copy1,
+    name: skip,
+    noSuggestDictionaries: copy1,
+    patterns: copyPatternsField,
+    suggestWords: copy1,
+    unknownWords: copy1,
+    words: copy1,
+    // Experimental
+    parser: skip,
+};
+function copyLanguageSetting(src, dst) {
+    cloneInto(src, dst, LanguageSettingsHandlers);
+}
+const RegExpPatternDefinitionHandlers = {
+    name: cpy,
+    pattern: copy1,
+    description: cpy,
+};
+function copyPatternsField(src, dst, key) {
+    const patterns = src[key];
+    if (!patterns)
+        return;
+    dst[key] = patterns.map((p) => {
+        const dst = { pattern: p.pattern, name: p.name };
+        copyRegExpPatternDefinition(p, dst);
+        return dst;
+    });
+}
+function copyRegExpPatternDefinition(src, dst) {
+    cloneInto(src, dst, RegExpPatternDefinitionHandlers);
+}
+const OverridesHandlers = {
+    id: copy1,
+    allowCompoundWords: copy1,
+    caseSensitive: copy1,
+    description: copy1,
+    dictionaries: copy1,
+    dictionaryDefinitions: copyDictionaryDefinitions,
+    enabled: copy1,
+    enabledFileTypes: copy1,
+    enabledLanguageIds: copy1,
+    enableFiletypes: copy1,
+    filename: copyGlobsOverrideFields,
+    flagWords: copy1,
+    ignoreRandomStrings: copy1,
+    ignoreRegExpList: copy1,
+    ignoreWords: copy1,
+    includeRegExpList: copy1,
+    language: copy1,
+    languageId: copy1,
+    languageSettings: copyLanguageSettings,
+    loadDefaultConfiguration: copy1,
+    maxDuplicateProblems: copy1,
+    maxFileSize: copy1,
+    maxNumberOfProblems: copy1,
+    minRandomLength: copy1,
+    minWordLength: copy1,
+    name: skip,
+    noSuggestDictionaries: copy1,
+    numSuggestions: copy1,
+    patterns: copyPatternsField,
+    pnpFiles: skip,
+    suggestionNumChanges: copy1,
+    suggestionsTimeout: copy1,
+    suggestWords: copy1,
+    unknownWords: copy1,
+    usePnP: skip,
+    words: copy1,
+    parser: skip,
+};
+function copyOverrides(src, dst, key) {
+    const overrides = src[key];
+    if (!overrides)
+        return;
+    dst[key] = overrides.map((src) => {
+        const dst = {};
+        cloneInto(src, dst, OverridesHandlers);
+        return dst;
+    });
+}
+//# sourceMappingURL=sanitizeSettings.js.map

package/dist/lib/Settings/util/settingsToJson.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Walks a value and converts it into a JSON-serializable representation.
+ *
+ * This function recursively traverses complex structures and normalizes them
+ * so they can be safely passed to {@link JSON.stringify}. The following
+ * conversions are applied:
+ *
+ * - Primitive types (`string`, `number`, `boolean`, `undefined`) are returned as-is.
+ * - `null` is returned as `null`.
+ * - Objects implementing `toJSON()` are serialized using that method.
+ * - `RegExp` instances are converted to their string form (e.g. `/pattern/gi`).
+ * - `Map` instances become arrays of `[key, value]` entry pairs, with both keys
+ *   and values processed through `walkToJSONObj`.
+ * - `Set` instances become arrays of their values, each processed through
+ *   `walkToJSONObj`.
+ * - Boxed `String` objects are converted to primitive strings.
+ * - Arrays are mapped element-wise via `walkToJSONObj`.
+ * - Plain objects are converted to new objects whose property values are
+ *   processed via `walkToJSONObj`.
+ * - `bigint` values are currently returned as-is (note: not natively supported
+ *   by `JSON.stringify`).
+ * - Functions are converted to `undefined`.
+ *
+ * @param value - The value to transform into a JSON-serializable structure.
+ * @returns A JSON-serializable representation of the input value.
+ */
+export declare function walkToJSONObj(value: unknown): unknown;
+//# sourceMappingURL=settingsToJson.d.ts.map

package/dist/lib/Settings/util/settingsToJson.js

@@ -0,0 +1,125 @@
+/* eslint-disable unicorn/no-null */
+/**
+ * Walks a value and converts it into a JSON-serializable representation.
+ *
+ * This function recursively traverses complex structures and normalizes them
+ * so they can be safely passed to {@link JSON.stringify}. The following
+ * conversions are applied:
+ *
+ * - Primitive types (`string`, `number`, `boolean`, `undefined`) are returned as-is.
+ * - `null` is returned as `null`.
+ * - Objects implementing `toJSON()` are serialized using that method.
+ * - `RegExp` instances are converted to their string form (e.g. `/pattern/gi`).
+ * - `Map` instances become arrays of `[key, value]` entry pairs, with both keys
+ *   and values processed through `walkToJSONObj`.
+ * - `Set` instances become arrays of their values, each processed through
+ *   `walkToJSONObj`.
+ * - Boxed `String` objects are converted to primitive strings.
+ * - Arrays are mapped element-wise via `walkToJSONObj`.
+ * - Plain objects are converted to new objects whose property values are
+ *   processed via `walkToJSONObj`.
+ * - `bigint` values are currently returned as-is (note: not natively supported
+ *   by `JSON.stringify`).
+ * - Functions are converted to `undefined`.
+ *
+ * @param value - The value to transform into a JSON-serializable structure.
+ * @returns A JSON-serializable representation of the input value.
+ */
+export function walkToJSONObj(value) {
+    const mapVisited = new WeakMap();
+    function walk(value) {
+        switch (typeof value) {
+            case 'string':
+            case 'number':
+            case 'boolean':
+            case 'undefined': {
+                return value;
+            }
+            case 'object': {
+                return walkObj(value);
+            }
+            case 'bigint': {
+                return value; // return as is for now
+            }
+            case 'function': {
+                return undefined; // `[function ${value.name || 'anonymous'}]`;
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }
+    /**
+     * Adds the value/result pair to the visited map.
+     * @param value - the original object
+     * @param result - the processed or to be processed result
+     * @returns result
+     */
+    function rememberObj(value, result) {
+        mapVisited.set(value, result);
+        return result;
+    }
+    /**
+     * Adds an array to the visited map and processes its entries in place.
+     * @param value - the original object
+     * @param entries - the array entries, it will be modified in place.
+     * @param map - an optional mapping function to apply to each entry.
+     * @returns the processed array.
+     */
+    function rememberArrayAndMapValuesInPlace(value, entries, map = (entry) => walk(entry)) {
+        const result = rememberObj(value, entries);
+        for (let i = 0; i < entries.length; i++) {
+            entries[i] = map(entries[i], i);
+        }
+        return result;
+    }
+    /**
+     * Walk an object.
+     * This function handles circular references.
+     *
+     * It does this by adding a placeholder to the visited map before processing the object.
+     * The placeholder is updated in place with the final result after processing.
+     *
+     * @param value - the object to walk
+     * @returns the walked object
+     */
+    function walkObj(value) {
+        const visited = mapVisited.get(value);
+        // Note: it is possible that the value is in mapVisited but maps to undefined.
+        // It is not worth the cost of checking for that case since the result will be the same.
+        if (visited !== undefined) {
+            return visited;
+        }
+        if (value === null) {
+            return null;
+        }
+        if ('toJSON' in value && typeof value.toJSON === 'function') {
+            // We trust the toJSON implementation to handle circular references itself.
+            return rememberObj(value, value.toJSON());
+        }
+        if (value instanceof RegExp) {
+            return rememberObj(value, value.toString());
+        }
+        if (value instanceof Map) {
+            return rememberArrayAndMapValuesInPlace(value, [...value.entries()], (entry) => {
+                entry[0] = walk(entry[0]);
+                entry[1] = walk(entry[1]);
+                return entry;
+            });
+        }
+        if (value instanceof Set) {
+            return rememberArrayAndMapValuesInPlace(value, [...value.values()]);
+        }
+        if (value instanceof String) {
+            return rememberObj(value, value.toString());
+        }
+        if (Array.isArray(value)) {
+            return rememberArrayAndMapValuesInPlace(value, [...value]);
+        }
+        // Plain object - process its properties
+        const obj = rememberObj(value, {});
+        return Object.assign(obj, Object.fromEntries(Object.entries(value).map(([key, val]) => [key, walk(val)])));
+    }
+    return walk(value);
+}
+//# sourceMappingURL=settingsToJson.js.map

package/dist/lib/SpellingDictionary/Dictionaries.d.ts

@@ -1,6 +1,6 @@
 import type { CSpellSettings } from '@cspell/cspell-types';
 import type { SpellingDictionary, SpellingDictionaryCollection } from 'cspell-dictionary';
-import type { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef.js';
+import type { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Settings/index.js';
 export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
 export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
 export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;

package/dist/lib/SpellingDictionary/Dictionaries.js

@@ -1,5 +1,5 @@
 import { createCollection, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createSpellingDictionary, createSuggestDictionary, } from 'cspell-dictionary';
-import { calcDictionaryDefsToLoad } from '../Settings/DictionarySettings.js';
+import { calcDictionaryDefsToLoad } from '../Settings/index.js';
 import { isDefined } from '../util/util.js';
 import { loadDictionary, refreshCacheEntries } from './DictionaryLoader.js';
 export function loadDictionaryDefs(defsToLoad) {

package/dist/lib/SpellingDictionary/DictionaryController/DictionaryLoader.d.ts

@@ -1,6 +1,6 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
 import type { VFileSystem } from 'cspell-io';
-import type { DictionaryDefinitionInternal } from '../../Models/CSpellSettingsInternalDef.js';
+import type { DictionaryDefinitionInternal } from '../../Settings/index.js';
 export type LoadOptions = DictionaryDefinitionInternal;
 export declare class DictionaryLoader {
     private fs;

package/dist/lib/SpellingDictionary/DictionaryController/DictionaryLoader.js

@@ -1,9 +1,61 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { opConcatMap, opFilter, opMap, pipe } from '@cspell/cspell-pipe/sync';
 import { StrongWeakMap } from '@cspell/strong-weak-map';
 import { createFailedToLoadDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, } from 'cspell-dictionary';
 import { compareStats, toFileURL, urlBasename } from 'cspell-io';
-import { isDictionaryDefinitionInlineInternal, isDictionaryFileDefinitionInternal, } from '../../Models/CSpellSettingsInternalDef.js';
-import { measurePerfFn } from '../../perf/index.js';
+import { measurePerf } from '../../perf/index.js';
+import { isDictionaryDefinitionInlineInternal, isDictionaryFileDefinitionInternal } from '../../Settings/index.js';
 import { AutoResolveWeakCache, AutoResolveWeakWeakCache } from '../../util/AutoResolve.js';
 import { toError } from '../../util/errors.js';
 import { SimpleCache } from '../../util/simpleCache.js';
@@ -187,36 +239,63 @@ async function load(reader, uri, options) {
     return loader(reader, uri, options);
 }
 async function legacyWordList(reader, filename, options) {
-    const lines = await reader.readLines(filename);
-    return measurePerfFn('legacyWords', () => _legacyWordListSync(lines, filename, options));
-}
-function _legacyWordListSync(lines, filename, options) {
-    const words = pipe(lines, 
-    // Remove comments
-    opMap((line) => line.replaceAll(/#.*/g, '')), 
-    // Split on everything else
-    opConcatMap((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), opFilter((word) => !!word));
-    return createSpellingDictionary(words, options.name, filename.toString(), options, true);
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const lines = await reader.readLines(filename);
+        const _ = __addDisposableResource(env_1, measurePerf('legacyWords'), false);
+        const words = pipe(lines, 
+        // Remove comments
+        opMap((line) => line.replaceAll(/#.*/g, '')), 
+        // Split on everything else
+        opConcatMap((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), opFilter((word) => !!word));
+        return createSpellingDictionary(words, options.name, filename.toString(), options, true);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
 }
 async function wordsPerLineWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
-    return measurePerfFn('wordsPerLineWordList', () => _wordsPerLineWordList(lines, filename.toString(), options));
-}
-function _wordsPerLineWordList(lines, filename, options) {
     const words = pipe(lines, 
     // Remove comments
     opMap((line) => line.replaceAll(/#.*/g, '')), 
     // Split on everything else
     opConcatMap((line) => line.split(/\s+/gu)), opFilter((word) => !!word));
-    return createSpellingDictionary(words, options.name, filename, options, true);
+    return createSpellingDictionary(words, options.name, filename.href, options, true);
 }
 async function loadSimpleWordList(reader, filename, options) {
-    const lines = await reader.readLines(filename);
-    return measurePerfFn('loadSimpleWordList', () => createSpellingDictionary(lines, options.name, filename.href, options));
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const lines = await reader.readLines(filename);
+        const _ = __addDisposableResource(env_2, measurePerf('loadSimpleWordList'), false);
+        return createSpellingDictionary(lines, options.name, filename.href, options);
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
 }
 async function loadTrie(reader, filename, options) {
-    const content = await reader.read(filename);
-    return measurePerfFn('loadTrie', () => createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options));
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const content = await reader.read(filename);
+        const _ = __addDisposableResource(env_3, measurePerf('loadTrie'), false);
+        return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        __disposeResources(env_3);
+    }
 }
 function toLines(content) {
     return content.split(/\n|\r\n|\r/);

package/dist/lib/SpellingDictionary/DictionaryLoader.d.ts

@@ -1,6 +1,6 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
 import type { VFileSystem } from '../fileSystem.js';
-import type { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef.js';
+import type { DictionaryDefinitionInternal } from '../Settings/index.js';
 import { DictionaryLoader } from './DictionaryController/index.js';
 export type { LoadOptions } from './DictionaryController/index.js';
 export declare function getDictionaryLoader(vfs?: VFileSystem): DictionaryLoader;

package/dist/lib/index.d.ts

@@ -13,11 +13,11 @@ export { createTextDocument, updateTextDocument } from './Models/TextDocument.js
 export type { PerfTimer } from './perf/index.js';
 export { createPerfTimer } from './perf/index.js';
 export type { ConfigurationDependencies, CSpellConfigFile, ICSpellConfigFile, ImportFileRefWithError, } from './Settings/index.js';
-export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readConfigFile, readRawSettings, readSettings, readSettingsFiles, resolveConfigFileImports, searchForConfig, sectionCSpell, } from './Settings/index.js';
+export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readConfigFile, readRawSettings, readSettings, readSettingsFiles, resolveConfigFileImports, searchForConfig, sectionCSpell, toCSpellSettingsWithOutSourceTrace, } from './Settings/index.js';
 export { defaultFileName as defaultSettingsFilename } from './Settings/index.js';
 export * as Link from './Settings/index.link.js';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings.js';
-export { determineFinalDocumentSettings, type DetermineFinalDocumentSettingsResult, spellCheckDocument, spellCheckFile, type SpellCheckFileOptions, type SpellCheckFilePerf, type SpellCheckFileResult, } from './spellCheckFile.js';
+export { determineFinalDocumentSettings, type DetermineFinalDocumentSettingsResult, spellCheckDocument, spellCheckDocumentRPC, spellCheckFile, type SpellCheckFileOptions, type SpellCheckFilePerf, type SpellCheckFileResult, } from './spellCheckFile.js';
 export { CompoundWordsMethod, createSpellingDictionary, createCollection as createSpellingDictionaryCollection, isSpellingDictionaryLoadError, refreshDictionaryCache, type SpellingDictionary, type SpellingDictionaryCollection, SpellingDictionaryLoadError, type SuggestionCollector, type SuggestionResult, type SuggestOptions, } from './SpellingDictionary/index.js';
 export type { SuggestedWord, SuggestionOptions, SuggestionsForWordResult } from './suggestions.js';
 export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions.js';

package/dist/lib/index.js

@@ -7,11 +7,11 @@ export { getLanguagesForBasename as getLanguageIdsForBaseFilename, getLanguagesF
 export { getDictionary } from './getDictionary.js';
 export { createTextDocument, updateTextDocument } from './Models/TextDocument.js';
 export { createPerfTimer } from './perf/index.js';
-export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readConfigFile, readRawSettings, readSettings, readSettingsFiles, resolveConfigFileImports, searchForConfig, sectionCSpell, } from './Settings/index.js';
+export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readConfigFile, readRawSettings, readSettings, readSettingsFiles, resolveConfigFileImports, searchForConfig, sectionCSpell, toCSpellSettingsWithOutSourceTrace, } from './Settings/index.js';
 export { defaultFileName as defaultSettingsFilename } from './Settings/index.js';
 export * as Link from './Settings/index.link.js';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings.js';
-export { determineFinalDocumentSettings, spellCheckDocument, spellCheckFile, } from './spellCheckFile.js';
+export { determineFinalDocumentSettings, spellCheckDocument, spellCheckDocumentRPC, spellCheckFile, } from './spellCheckFile.js';
 export { CompoundWordsMethod, createSpellingDictionary, createCollection as createSpellingDictionaryCollection, isSpellingDictionaryLoadError, refreshDictionaryCache, SpellingDictionaryLoadError, } from './SpellingDictionary/index.js';
 export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions.js';
 export { DocumentValidator, shouldCheckDocument } from './textValidation/index.js';

package/dist/lib/perf/index.d.ts

@@ -1,4 +1,4 @@
-export { measurePerf, measurePerfEnd, measurePerfFn, measurePerfStart } from './performance.js';
 export type { PerfTimer } from './timer.js';
 export { createPerfTimer } from './timer.js';
+export { measurePerf } from '@cspell/cspell-performance-monitor';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/perf/index.js

@@ -1,3 +1,3 @@
-export { measurePerf, measurePerfEnd, measurePerfFn, measurePerfStart } from './performance.js';
 export { createPerfTimer } from './timer.js';
+export { measurePerf } from '@cspell/cspell-performance-monitor';
 //# sourceMappingURL=index.js.map

package/dist/lib/spellCheckFile.d.ts

@@ -1,6 +1,7 @@
 import type { CSpellSettingsWithSourceTrace, CSpellUserSettings } from '@cspell/cspell-types';
 import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { Document, DocumentWithText } from './Document/index.js';
+import type { ImportFileRefWithError } from './Settings/index.js';
 import type { Uri } from './util/IUri.js';
 import type { ValidateTextOptions, ValidationIssue } from './validator.js';
 export interface SpellCheckFileOptions extends ValidateTextOptions, Pick<CSpellUserSettings, 'unknownWords'> {
@@ -38,6 +39,8 @@ export interface SpellCheckFileResult {
     issues: ValidationIssue[];
     checked: boolean;
     errors: Error[] | undefined;
+    configErrors?: ImportFileRefWithError[] | undefined;
+    dictionaryErrors?: Map<string, Error[]> | undefined;
     perf?: SpellCheckFilePerf;
 }
 /**
@@ -54,6 +57,13 @@ export declare function spellCheckFile(file: string | Uri | URL, options: SpellC
  * @param settings - default settings to use.
  */
 export declare function spellCheckDocument(document: Document | DocumentWithText, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
+/**
+ * Spell Check a Document.
+ * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
+ * @param options - options to control checking
+ * @param settings - default settings to use.
+ */
+export declare function spellCheckDocumentRPC(document: Document | DocumentWithText, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
 export interface DetermineFinalDocumentSettingsResult {
     document: DocumentWithText;
     settings: CSpellSettingsWithSourceTrace;