cspell-lib 9.4.0 → 9.6.1

package/dist/lib/Settings/{DictionarySettings.js → internal/DictionarySettings.js}

@@ -1,11 +1,11 @@
 import * as path from 'node:path';
 import { mapDictionaryInformationToWeightMap } from 'cspell-trie-lib';
-import { isDictionaryDefinitionInlineInternal } from '../Models/CSpellSettingsInternalDef.js';
-import { createAutoResolveWeakWeakCache } from '../util/AutoResolve.js';
-import { resolveRelativeTo } from '../util/resolveFile.js';
-import { toFilePathOrHref } from '../util/url.js';
-import { clean } from '../util/util.js';
-import { createDictionaryReferenceCollection } from './DictionaryReferenceCollection.js';
+import { createAutoResolveWeakWeakCache } from '../../util/AutoResolve.js';
+import { resolveRelativeTo } from '../../util/resolveFile.js';
+import { toFilePathOrHref } from '../../util/url.js';
+import { clean } from '../../util/util.js';
+import { createDictionaryReferenceCollection } from '../DictionaryReferenceCollection.js';
+import { isDictionaryDefinitionInlineInternal } from './InternalDictionaryDef.js';
 /**
  * Combines the list of desired dictionaries with the list of dictionary
  * definitions. Order does not matter, but the number of leading `!` does.
@@ -27,10 +27,12 @@ function fixPath(def) {
         return def;
     }
     const newPath = fixDicPath(def.path, def.file);
+    const newBTriePath = def.btrie ? fixDicPath(def.btrie, def.file) : undefined;
     return {
         ...def,
         file: undefined,
         path: newPath,
+        btrie: newBTriePath,
     };
 }
 function fixDicPath(defPath, defFile) {
@@ -97,21 +99,26 @@ class _DictionaryDefinitionInternalWithSource {
     ignoreForbiddenWords;
     scope;
     __source;
-    ddi;
+    #ddi;
+    #def;
     constructor(def, sourceURL) {
         this.sourceURL = sourceURL;
+        this.#def = def;
         this.__source = sourceURL.href;
         // this bit of assignment is to have the compiler help use if any new fields are added.
         const defAll = def;
-        const { path: relPath = '', file = '', addWords, description, dictionaryInformation, type, repMap, noSuggest, ignoreForbiddenWords, scope, supportNonStrictSearches, useCompounds, } = defAll;
+        const { path: relPath = '', file = '', btrie, addWords, description, dictionaryInformation, type, repMap, noSuggest, ignoreForbiddenWords, scope, supportNonStrictSearches, useCompounds, } = defAll;
         const defaultPath = sourceURL;
         const filePath = fixDicPath(relPath, file);
         const name = determineName(filePath, def);
         const resolvedPath = toFilePathOrHref(resolveRelativeTo(filePath, defaultPath));
+        let bTriePath = btrie ? fixDicPath(btrie, file) : undefined;
+        bTriePath = bTriePath ? toFilePathOrHref(resolveRelativeTo(bTriePath, defaultPath)) : undefined;
         const ddi = {
             name,
             file: undefined,
             path: resolvedPath,
+            btrie: bTriePath,
             addWords,
             description,
             dictionaryInformation,
@@ -124,7 +131,7 @@ class _DictionaryDefinitionInternalWithSource {
             useCompounds,
         };
         Object.assign(this, clean(ddi));
-        this.ddi = ddi;
+        this.#ddi = ddi;
         this.name = ddi.name;
         this.file = ddi.file;
         this.path = ddi.path;
@@ -136,7 +143,10 @@ class _DictionaryDefinitionInternalWithSource {
         return this._weightMap;
     }
     toJSON() {
-        return this.ddi;
+        return this.#ddi;
+    }
+    __getOriginalDefinition() {
+        return this.#def;
     }
 }
 //# sourceMappingURL=DictionarySettings.js.map

package/dist/lib/{Models/CSpellSettingsInternalDef.d.ts → Settings/internal/InternalDictionaryDef.d.ts}

@@ -1,17 +1,5 @@
-import type { AdvancedCSpellSettingsWithSourceTrace, CSpellSettingsWithSourceTrace, DictionaryDefinition, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionInline, DictionaryDefinitionPreferred, DictionaryDefinitionSimple, Parser } from '@cspell/cspell-types';
+import type { DictionaryDefinition, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionInline, DictionaryDefinitionPreferred, DictionaryDefinitionSimple } from '@cspell/cspell-types';
 import type { WeightMap } from 'cspell-trie-lib';
-import type { OptionalOrUndefined } from '../util/types.js';
-export declare const SymbolCSpellSettingsInternal: unique symbol;
-export interface CSpellSettingsInternal extends Omit<AdvancedCSpellSettingsWithSourceTrace, 'dictionaryDefinitions'> {
-    [SymbolCSpellSettingsInternal]: true;
-    dictionaryDefinitions?: DictionaryDefinitionInternal[];
-}
-export interface CSpellSettingsInternalFinalized extends CSpellSettingsInternal {
-    parserFn: Parser | undefined;
-    finalized: true;
-    ignoreRegExpList: RegExp[];
-    includeRegExpList: RegExp[];
-}
 type DictionaryDefinitionCustomUniqueFields = Omit<DictionaryDefinitionCustom, keyof DictionaryDefinitionPreferred>;
 export type DictionaryDefinitionInternal = DictionaryFileDefinitionInternal | DictionaryDefinitionInlineInternal | DictionaryDefinitionSimpleInternal;
 export type DictionaryDefinitionInlineInternal = DictionaryDefinitionInline & {
@@ -36,10 +24,7 @@ export interface DictionaryFileDefinitionInternalWithSource extends DictionaryFi
 export type DictionaryDefinitionInternalWithSource = DictionaryDefinitionInternal & {
     readonly __source: string;
 };
-export declare function cleanCSpellSettingsInternal(parts?: OptionalOrUndefined<Partial<CSpellSettingsInternal>>): CSpellSettingsInternal;
-export declare function createCSpellSettingsInternal(parts?: OptionalOrUndefined<Partial<CSpellSettingsInternal>>): CSpellSettingsInternal;
-export declare function isCSpellSettingsInternal(cs: CSpellSettingsInternal | CSpellSettingsWithSourceTrace | OptionalOrUndefined<CSpellSettingsInternal | CSpellSettingsWithSourceTrace>): cs is CSpellSettingsInternal;
 export declare function isDictionaryDefinitionInlineInternal(def: DictionaryDefinitionInternal | DictionaryDefinitionInline | DictionaryDefinition): def is DictionaryDefinitionInlineInternal;
 export declare function isDictionaryFileDefinitionInternal(def: DictionaryDefinitionInternal | DictionaryDefinitionInline | DictionaryDefinition): def is DictionaryFileDefinitionInternal;
 export {};
-//# sourceMappingURL=CSpellSettingsInternalDef.d.ts.map
+//# sourceMappingURL=InternalDictionaryDef.d.ts.map

package/dist/lib/Settings/internal/InternalDictionaryDef.js

@@ -0,0 +1,10 @@
+export function isDictionaryDefinitionInlineInternal(def) {
+    if (def.path)
+        return false;
+    const defInline = def;
+    return !!(defInline.words || defInline.flagWords || defInline.ignoreWords || defInline.suggestWords);
+}
+export function isDictionaryFileDefinitionInternal(def) {
+    return !!(def.path || def.file);
+}
+//# sourceMappingURL=InternalDictionaryDef.js.map

package/dist/lib/Settings/internal/index.d.ts

@@ -0,0 +1,6 @@
+export type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from './CSpellSettingsInternalDef.js';
+export { cleanCSpellSettingsInternal, createCSpellSettingsInternal, isCSpellSettingsInternal, } from './CSpellSettingsInternalDef.js';
+export { calcDictionaryDefsToLoad, filterDictDefsToLoad, mapDictDefsToInternal, mapDictDefToInternal, } from './DictionarySettings.js';
+export type { DictionaryDefinitionInlineInternal, DictionaryDefinitionInternal, DictionaryDefinitionSimpleInternal, DictionaryFileDefinitionInternal, } from './InternalDictionaryDef.js';
+export { isDictionaryDefinitionInlineInternal, isDictionaryFileDefinitionInternal } from './InternalDictionaryDef.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Settings/internal/index.js

@@ -0,0 +1,4 @@
+export { cleanCSpellSettingsInternal, createCSpellSettingsInternal, isCSpellSettingsInternal, } from './CSpellSettingsInternalDef.js';
+export { calcDictionaryDefsToLoad, filterDictDefsToLoad, mapDictDefsToInternal, mapDictDefToInternal, } from './DictionarySettings.js';
+export { isDictionaryDefinitionInlineInternal, isDictionaryFileDefinitionInternal } from './InternalDictionaryDef.js';
+//# sourceMappingURL=index.js.map

package/dist/lib/Settings/link.js

@@ -78,7 +78,7 @@ export async function removePathsFromGlobalImports(paths) {
         return c === Path.sep || c === Path.posix.sep;
     }
     function matchFilename(pathToRemove) {
-        return Path.dirname(pathToRemove) != '.'
+        return Path.dirname(pathToRemove) !== '.'
             ? ({ filename }) => compareFilenames(filename, pathToRemove)
             : () => false;
     }

package/dist/lib/Settings/mergeCache.d.ts

@@ -1,4 +1,4 @@
-import { CacheStats } from '../util/AutoResolve.js';
+import type { CacheStats } from '../util/AutoResolve.js';
 interface IDisposable {
     dispose(): void;
 }

package/dist/lib/Settings/mergeList.d.ts

@@ -1,4 +1,4 @@
-import { CacheStats } from '../util/AutoResolve.js';
+import type { CacheStats } from '../util/AutoResolve.js';
 /**
  * Merges two lists and removes duplicates.  Order is NOT preserved.
  */

package/dist/lib/Settings/sanitizeSettings.d.ts

@@ -0,0 +1,11 @@
+import type { CSpellSettingsWithSourceTrace } from '@cspell/cspell-types';
+import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from './internal/index.js';
+type CloneableSettings = CSpellSettingsWithSourceTrace | CSpellSettingsInternal | CSpellSettingsInternalFinalized;
+/**
+ * Sanitize settings for export by removing any internal only properties.
+ *
+ * @param settings - the input settings
+ */
+export declare function cloneSettingsForExport(settings: Readonly<CloneableSettings>): CSpellSettingsWithSourceTrace;
+export {};
+//# sourceMappingURL=sanitizeSettings.d.ts.map

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;