cspell-lib 5.15.2 → 5.17.0

package/dist/Models/CSpellSettingsInternalDef.d.ts

@@ -0,0 +1,23 @@
+import { CSpellSettingsWithSourceTrace, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionPreferred } from '@cspell/cspell-types';
+import { WeightMap } from 'cspell-trie-lib';
+export declare const SymbolCSpellSettingsInternal: unique symbol;
+export interface CSpellSettingsInternal extends Omit<CSpellSettingsWithSourceTrace, 'dictionaryDefinitions'> {
+    [SymbolCSpellSettingsInternal]: true;
+    dictionaryDefinitions?: DictionaryDefinitionInternal[];
+}
+declare type DictionaryDefinitionCustomUniqueFields = Omit<DictionaryDefinitionCustom, keyof DictionaryDefinitionPreferred>;
+export interface DictionaryDefinitionInternal extends DictionaryDefinitionPreferred, Partial<DictionaryDefinitionCustomUniqueFields>, DictionaryDefinitionAugmented {
+    /**
+     * Optional weight map used to improve suggestions.
+     */
+    weightMap?: WeightMap;
+    /** The path to the config file that contains this dictionary definition */
+    __source?: string;
+}
+export interface DictionaryDefinitionInternalWithSource extends DictionaryDefinitionInternal {
+    __source: string;
+}
+export declare function createCSpellSettingsInternal(parts?: Partial<CSpellSettingsInternal>): CSpellSettingsInternal;
+export declare function isCSpellSettingsInternal(cs: CSpellSettingsInternal | CSpellSettingsWithSourceTrace): cs is CSpellSettingsInternal;
+export {};
+//# sourceMappingURL=CSpellSettingsInternalDef.d.ts.map

package/dist/Models/CSpellSettingsInternalDef.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCSpellSettingsInternal = exports.createCSpellSettingsInternal = exports.SymbolCSpellSettingsInternal = void 0;
+exports.SymbolCSpellSettingsInternal = Symbol('CSpellSettingsInternal');
+function createCSpellSettingsInternal(parts = {}) {
+    return {
+        ...parts,
+        [exports.SymbolCSpellSettingsInternal]: true,
+    };
+}
+exports.createCSpellSettingsInternal = createCSpellSettingsInternal;
+function isCSpellSettingsInternal(cs) {
+    return !!cs[exports.SymbolCSpellSettingsInternal];
+}
+exports.isCSpellSettingsInternal = isCSpellSettingsInternal;
+//# sourceMappingURL=CSpellSettingsInternalDef.js.map

package/dist/Settings/CSpellSettingsServer.d.ts

@@ -1,62 +1,90 @@
 import type { CSpellSettingsWithSourceTrace, CSpellUserSettings, Glob, ImportFileRef, PnPSettings } from '@cspell/cspell-types';
 import { URI } from 'vscode-uri';
+import { CSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef';
 import { LoaderResult } from './pnpLoader';
+declare type CSpellSettingsWST = CSpellSettingsWithSourceTrace;
+declare type CSpellSettingsI = CSpellSettingsInternal;
 export declare const currentSettingsFileVersion = "0.2";
 export declare const sectionCSpell = "cSpell";
 export declare const defaultFileName = "cspell.json";
 export declare const ENV_CSPELL_GLOB_ROOT = "CSPELL_GLOB_ROOT";
 export declare const defaultConfigFilenames: readonly string[];
-declare type CSpellSettings = CSpellSettingsWithSourceTrace;
 /**
  * normalizeSettings handles correcting all relative paths, anchoring globs, and importing other config files.
  * @param rawSettings - raw configuration settings
  * @param pathToSettingsFile - path to the source file of the configuration settings.
  */
-declare function normalizeSettings(rawSettings: CSpellSettings, pathToSettingsFile: string, pnpSettings: PnPSettings): CSpellSettings;
-export declare function readSettings(filename: string): CSpellSettings;
-export declare function readSettings(filename: string, defaultValues: CSpellSettings): CSpellSettings;
-export declare function readSettings(filename: string, relativeTo: string): CSpellSettings;
-export declare function readSettings(filename: string, relativeTo: string, defaultValues: CSpellSettings): CSpellSettings;
-export declare function searchForConfig(searchFrom: string | undefined, pnpSettings?: PnPSettings): Promise<CSpellSettings | undefined>;
-export declare function loadConfig(file: string, pnpSettings?: PnPSettings): Promise<CSpellSettings>;
+declare function normalizeSettings(rawSettings: CSpellSettingsWST, pathToSettingsFile: string, pnpSettings: PnPSettings): CSpellSettingsI;
+export declare function readSettings(filename: string): CSpellSettingsI;
+export declare function readSettings(filename: string, defaultValues: CSpellSettingsWST): CSpellSettingsI;
+export declare function readSettings(filename: string, relativeTo: string): CSpellSettingsI;
+export declare function readSettings(filename: string, relativeTo: string, defaultValues: CSpellSettingsWST): CSpellSettingsI;
+export declare function searchForConfig(searchFrom: string | undefined, pnpSettings?: PnPSettings): Promise<CSpellSettingsI | undefined>;
+/**
+ * Load a CSpell configuration files.
+ * @param file - path or package reference to load.
+ * @param pnpSettings - PnP settings
+ * @returns normalized CSpellSettings
+ */
+export declare function loadConfig(file: string, pnpSettings?: PnPSettings): Promise<CSpellSettingsI>;
 export declare function loadPnP(pnpSettings: PnPSettings, searchFrom: URI): Promise<LoaderResult>;
 export declare function loadPnPSync(pnpSettings: PnPSettings, searchFrom: URI): LoaderResult;
-export declare function readRawSettings(filename: string, relativeTo?: string): CSpellSettings;
+export declare function readRawSettings(filename: string, relativeTo?: string): CSpellSettingsWST;
 /**
  *
  * @param filenames - settings files to read
  * @returns combined configuration
  * @deprecated true
  */
-export declare function readSettingsFiles(filenames: string[]): CSpellSettings;
-export declare function mergeSettings(left: CSpellSettings, ...settings: CSpellSettings[]): CSpellSettings;
-export declare function mergeInDocSettings(left: CSpellSettings, right: CSpellSettings): CSpellSettings;
-export declare function calcOverrideSettings(settings: CSpellSettings, filename: string): CSpellSettings;
-export declare function finalizeSettings(settings: CSpellSettings): CSpellSettings;
-export declare function getGlobalSettings(): CSpellSettings;
+export declare function readSettingsFiles(filenames: string[]): CSpellSettingsI;
+declare function mergeObjects(left: undefined, right: undefined): undefined;
+declare function mergeObjects<T>(left: T, right: undefined): T;
+declare function mergeObjects<T>(left: T, right: T): T;
+declare function mergeObjects<T>(left: undefined, right: T): T;
+export declare function mergeSettings(left: CSpellSettingsWST | CSpellSettingsI, ...settings: (CSpellSettingsWST | CSpellSettingsI)[]): CSpellSettingsI;
+export declare function mergeInDocSettings(left: CSpellSettingsWST, right: CSpellSettingsWST): CSpellSettingsWST;
+export declare function calcOverrideSettings(settings: CSpellSettingsWST, filename: string): CSpellSettingsI;
+/**
+ *
+ * @param settings - settings to finalize
+ * @returns settings where all globs and file paths have been resolved.
+ */
+export declare function finalizeSettings(settings: CSpellSettingsWST | CSpellSettingsI): CSpellSettingsI;
+export declare function toInternalSettings(settings: undefined): undefined;
+export declare function toInternalSettings(settings: CSpellSettingsI | CSpellSettingsWST): CSpellSettingsI;
+export declare function toInternalSettings(settings?: CSpellSettingsI | CSpellSettingsWST): CSpellSettingsI | undefined;
+export declare function getGlobalSettings(): CSpellSettingsI;
 export declare function getCachedFileSize(): number;
 export declare function clearCachedSettingsFiles(): void;
+/**
+ * @param filename - filename
+ * @param globs - globs
+ * @returns true if it matches
+ * @deprecated true
+ * @deprecationMessage No longer actively supported. Use package: `cspell-glob`.
+ */
 export declare function checkFilenameMatchesGlob(filename: string, globs: Glob | Glob[]): boolean;
 /**
  * Return a list of Setting Sources used to create this Setting.
  * @param settings the settings to search
  */
-export declare function getSources(settings: CSpellSettings): CSpellSettings[];
+export declare function getSources(settings: CSpellSettingsWST): CSpellSettingsWST[];
 export interface ImportFileRefWithError extends ImportFileRef {
     error: Error;
 }
-export declare function extractImportErrors(settings: CSpellSettings): ImportFileRefWithError[];
+export declare function extractImportErrors(settings: CSpellSettingsWST): ImportFileRefWithError[];
 export interface ConfigurationDependencies {
     configFiles: string[];
     dictionaryFiles: string[];
 }
-export declare function extractDependencies(settings: CSpellSettings): ConfigurationDependencies;
-declare function normalizeCacheSettings(settings: Pick<CSpellSettings, 'cache'>, pathToSettingsDir: string): Pick<CSpellSettings, 'cache'>;
+export declare function extractDependencies(settings: CSpellSettingsWST | CSpellSettingsI): ConfigurationDependencies;
+declare function normalizeCacheSettings(settings: Pick<CSpellUserSettings, 'cache'>, pathToSettingsDir: string): Pick<CSpellUserSettings, 'cache'>;
 declare function validateRawConfigVersion(config: CSpellUserSettings | {
     version: unknown;
 }, fileRef: ImportFileRef): void;
 declare function validateRawConfigExports(config: CSpellUserSettings, fileRef: ImportFileRef): void;
 export declare const __testing__: {
+    mergeObjects: typeof mergeObjects;
     normalizeCacheSettings: typeof normalizeCacheSettings;
     normalizeSettings: typeof normalizeSettings;
     validateRawConfigExports: typeof validateRawConfigExports;

package/dist/Settings/CSpellSettingsServer.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.extractDependencies = exports.extractImportErrors = exports.getSources = exports.checkFilenameMatchesGlob = exports.clearCachedSettingsFiles = exports.getCachedFileSize = exports.getGlobalSettings = exports.finalizeSettings = exports.calcOverrideSettings = exports.mergeInDocSettings = exports.mergeSettings = exports.readSettingsFiles = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfig = exports.searchForConfig = exports.readSettings = exports.defaultConfigFilenames = exports.ENV_CSPELL_GLOB_ROOT = exports.defaultFileName = exports.sectionCSpell = exports.currentSettingsFileVersion = void 0;
+exports.__testing__ = exports.extractDependencies = exports.extractImportErrors = exports.getSources = exports.checkFilenameMatchesGlob = exports.clearCachedSettingsFiles = exports.getCachedFileSize = exports.getGlobalSettings = exports.toInternalSettings = exports.finalizeSettings = exports.calcOverrideSettings = exports.mergeInDocSettings = exports.mergeSettings = exports.readSettingsFiles = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfig = exports.searchForConfig = exports.readSettings = exports.defaultConfigFilenames = exports.ENV_CSPELL_GLOB_ROOT = exports.defaultFileName = exports.sectionCSpell = exports.currentSettingsFileVersion = void 0;
 const json = __importStar(require("comment-json"));
 const cosmiconfig_1 = require("cosmiconfig");
 const cspell_glob_1 = require("cspell-glob");
@@ -28,6 +28,7 @@ const vscode_uri_1 = require("vscode-uri");
 const logger_1 = require("../util/logger");
 const resolveFile_1 = require("../util/resolveFile");
 const util = __importStar(require("../util/util"));
+const CSpellSettingsInternalDef_1 = require("../Models/CSpellSettingsInternalDef");
 const DictionarySettings_1 = require("./DictionarySettings");
 const GlobalSettings_1 = require("./GlobalSettings");
 const ImportError_1 = require("./ImportError");
@@ -87,11 +88,11 @@ function parseJson(_filename, content) {
 exports.defaultConfigFilenames = Object.freeze(searchPlaces.concat());
 const cspellConfigExplorer = (0, cosmiconfig_1.cosmiconfig)('cspell', cspellCosmiconfig);
 const cspellConfigExplorerSync = (0, cosmiconfig_1.cosmiconfigSync)('cspell', cspellCosmiconfig);
-const defaultSettings = {
+const defaultSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
     id: 'default',
     name: 'default',
     version: exports.currentSettingsFileVersion,
-};
+});
 const defaultPnPSettings = {};
 let globalSettings;
 const cachedFiles = new Map();
@@ -156,7 +157,7 @@ function normalizeSettings(rawSettings, pathToSettingsFile, pnpSettings) {
         name: settings.name,
         filename: pathToSettingsFile,
     };
-    const fileSettings = {
+    const fileSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
         ...settings,
         source,
         ...normalizedDictionaryDefs,
@@ -165,7 +166,7 @@ function normalizeSettings(rawSettings, pathToSettingsFile, pnpSettings) {
         ...normalizedReporters,
         ...normalizedGitignoreRoot,
         ...normalizedCacheSettings,
-    };
+    });
     if (!imports.length) {
         return fileSettings;
     }
@@ -203,7 +204,7 @@ function importSettings(fileRef, defaultValues, pnpSettings) {
     }
     const id = [path.basename(path.dirname(filename)), path.basename(filename)].join('/');
     const name = id;
-    const finalizeSettings = { id, name, __importRef: importRef };
+    const finalizeSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({ id, name, __importRef: importRef });
     cachedFiles.set(filename, finalizeSettings); // add an empty entry to prevent circular references.
     const settings = { ...defaultValues, id, name, ...readConfig(importRef) };
     Object.assign(finalizeSettings, normalizeSettings(settings, filename, pnpSettings));
@@ -240,12 +241,12 @@ async function normalizeSearchForConfigResult(searchPath, searchResult, pnpSetti
             };
         }
     }
-    const { config = {} } = result || {};
+    const { config = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({}) } = result || {};
     const filename = (_a = result === null || result === void 0 ? void 0 : result.filepath) !== null && _a !== void 0 ? _a : searchPath;
     const importRef = { filename: filename, error };
     const id = [path.basename(path.dirname(filename)), path.basename(filename)].join('/');
     const name = (result === null || result === void 0 ? void 0 : result.filepath) ? id : `Config not found: ${id}`;
-    const finalizeSettings = { id, name, __importRef: importRef };
+    const finalizeSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({ id, name, __importRef: importRef });
     const settings = { id, ...config };
     cachedFiles.set(filename, finalizeSettings); // add an empty entry to prevent circular references.
     Object.assign(finalizeSettings, normalizeSettings(settings, filename, pnpSettings));
@@ -259,6 +260,12 @@ function searchForConfig(searchFrom, pnpSettings = defaultPnPSettings) {
     return normalizeSearchForConfigResult(searchFrom || process.cwd(), cspellConfigExplorer.search(searchFrom), pnpSettings).then((r) => (r.filepath ? r.config : undefined));
 }
 exports.searchForConfig = searchForConfig;
+/**
+ * Load a CSpell configuration files.
+ * @param file - path or package reference to load.
+ * @param pnpSettings - PnP settings
+ * @returns normalized CSpellSettings
+ */
 function loadConfig(file, pnpSettings = defaultPnPSettings) {
     const cached = cachedFiles.get(path.resolve(file));
     if (cached) {
@@ -314,6 +321,13 @@ function mergeList(left, right) {
         return left;
     return left.concat(right);
 }
+function mergeObjects(left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    return { ...left, ...right };
+}
 function tagLanguageSettings(tag, settings = []) {
     return settings.map((s) => ({
         id: tag + '.' + (s.id || s.locale || s.languageId),
@@ -328,7 +342,7 @@ function replaceIfNotEmpty(left = [], right = []) {
     return left;
 }
 function mergeSettings(left, ...settings) {
-    const rawSettings = settings.reduce(merge, left);
+    const rawSettings = settings.reduce(merge, toInternalSettings(left));
     return util.clean(rawSettings);
 }
 exports.mergeSettings = mergeSettings;
@@ -337,55 +351,59 @@ function isEmpty(obj) {
     return Object.keys(obj).length === 0 && obj.constructor === Object;
 }
 function merge(left, right) {
+    const _left = toInternalSettings(left);
+    const _right = toInternalSettings(right);
     if (left === right) {
-        return left;
+        return _left;
     }
     if (isEmpty(right)) {
-        return left;
+        return _left;
     }
     if (isEmpty(left)) {
-        return right;
+        return _right;
     }
-    if (isLeftAncestorOfRight(left, right)) {
-        return right;
+    if (isLeftAncestorOfRight(_left, _right)) {
+        return _right;
     }
-    if (doesLeftHaveRightAncestor(left, right)) {
-        return left;
+    if (doesLeftHaveRightAncestor(_left, _right)) {
+        return _left;
     }
-    const leftId = left.id || left.languageId || '';
-    const rightId = right.id || right.languageId || '';
-    const includeRegExpList = takeRightOtherwiseLeft(left.includeRegExpList, right.includeRegExpList);
+    const leftId = _left.id || _left.languageId || '';
+    const rightId = _right.id || _right.languageId || '';
+    const includeRegExpList = takeRightOtherwiseLeft(_left.includeRegExpList, _right.includeRegExpList);
     const optionals = (includeRegExpList === null || includeRegExpList === void 0 ? void 0 : includeRegExpList.length) ? { includeRegExpList } : {};
-    const version = max(left.version, right.version);
-    const settings = {
-        ...left,
-        ...right,
+    const version = max(_left.version, _right.version);
+    const settings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
+        ..._left,
+        ..._right,
         ...optionals,
         version,
         id: [leftId, rightId].join('|'),
-        name: [left.name || '', right.name || ''].join('|'),
-        words: mergeList(left.words, right.words),
-        userWords: mergeList(left.userWords, right.userWords),
-        flagWords: mergeListUnique(left.flagWords, right.flagWords),
-        ignoreWords: mergeListUnique(left.ignoreWords, right.ignoreWords),
-        enabledLanguageIds: replaceIfNotEmpty(left.enabledLanguageIds, right.enabledLanguageIds),
-        enableFiletypes: mergeList(left.enableFiletypes, right.enableFiletypes),
-        ignoreRegExpList: mergeListUnique(left.ignoreRegExpList, right.ignoreRegExpList),
-        patterns: mergeListUnique(left.patterns, right.patterns),
-        dictionaryDefinitions: mergeListUnique(left.dictionaryDefinitions, right.dictionaryDefinitions),
-        dictionaries: mergeListUnique(left.dictionaries, right.dictionaries),
-        noSuggestDictionaries: mergeListUnique(left.noSuggestDictionaries, right.noSuggestDictionaries),
-        languageSettings: mergeList(tagLanguageSettings(leftId, left.languageSettings), tagLanguageSettings(rightId, right.languageSettings)),
-        enabled: right.enabled !== undefined ? right.enabled : left.enabled,
-        files: mergeListUnique(left.files, right.files),
-        ignorePaths: versionBasedMergeList(left.ignorePaths, right.ignorePaths, version),
-        overrides: versionBasedMergeList(left.overrides, right.overrides, version),
-        source: mergeSources(left, right),
+        name: [_left.name || '', _right.name || ''].join('|'),
+        words: mergeList(_left.words, _right.words),
+        userWords: mergeList(_left.userWords, _right.userWords),
+        flagWords: mergeListUnique(_left.flagWords, _right.flagWords),
+        ignoreWords: mergeListUnique(_left.ignoreWords, _right.ignoreWords),
+        enabledLanguageIds: replaceIfNotEmpty(_left.enabledLanguageIds, _right.enabledLanguageIds),
+        enableFiletypes: mergeList(_left.enableFiletypes, _right.enableFiletypes),
+        ignoreRegExpList: mergeListUnique(_left.ignoreRegExpList, _right.ignoreRegExpList),
+        patterns: mergeListUnique(_left.patterns, _right.patterns),
+        dictionaryDefinitions: mergeListUnique(_left.dictionaryDefinitions, _right.dictionaryDefinitions),
+        dictionaries: mergeListUnique(_left.dictionaries, _right.dictionaries),
+        noSuggestDictionaries: mergeListUnique(_left.noSuggestDictionaries, _right.noSuggestDictionaries),
+        languageSettings: mergeList(tagLanguageSettings(leftId, _left.languageSettings), tagLanguageSettings(rightId, _right.languageSettings)),
+        enabled: _right.enabled !== undefined ? _right.enabled : _left.enabled,
+        files: mergeListUnique(_left.files, _right.files),
+        ignorePaths: versionBasedMergeList(_left.ignorePaths, _right.ignorePaths, version),
+        overrides: versionBasedMergeList(_left.overrides, _right.overrides, version),
+        features: mergeObjects(_left.features, _right.features),
+        source: mergeSources(_left, _right),
+        description: undefined,
         globRoot: undefined,
         import: undefined,
-        __imports: mergeImportRefs(left, right),
+        __imports: mergeImportRefs(_left, _right),
         __importRef: undefined,
-    };
+    });
     return settings;
 }
 function versionBasedMergeList(left, right, version) {
@@ -437,14 +455,24 @@ function takeRightOtherwiseLeft(left, right) {
     return left || right;
 }
 function calcOverrideSettings(settings, filename) {
-    const overrides = settings.overrides || [];
+    const _settings = toInternalSettings(settings);
+    const overrides = _settings.overrides || [];
     const result = overrides
         .filter((override) => checkFilenameMatchesGlob(filename, override.filename))
-        .reduce((settings, override) => mergeSettings(settings, override), settings);
+        .reduce((settings, override) => mergeSettings(settings, override), _settings);
     return result;
 }
 exports.calcOverrideSettings = calcOverrideSettings;
+/**
+ *
+ * @param settings - settings to finalize
+ * @returns settings where all globs and file paths have been resolved.
+ */
 function finalizeSettings(settings) {
+    return _finalizeSettings(toInternalSettings(settings));
+}
+exports.finalizeSettings = finalizeSettings;
+function _finalizeSettings(settings) {
     // apply patterns to any RegExpLists.
     const finalized = {
         ...settings,
@@ -455,7 +483,21 @@ function finalizeSettings(settings) {
     finalized.source = { name: settings.name || 'src', sources: [settings] };
     return finalized;
 }
-exports.finalizeSettings = finalizeSettings;
+function toInternalSettings(settings) {
+    var _a;
+    if (settings === undefined)
+        return undefined;
+    if ((0, CSpellSettingsInternalDef_1.isCSpellSettingsInternal)(settings))
+        return settings;
+    const { dictionaryDefinitions: defs, ...rest } = settings;
+    const dictionaryDefinitions = (0, DictionarySettings_1.mapDictDefsToInternal)(defs, filenameToDirectory((_a = settings.source) === null || _a === void 0 ? void 0 : _a.filename) || resolveCwd());
+    const setting = dictionaryDefinitions ? { ...rest, dictionaryDefinitions } : rest;
+    return (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)(setting);
+}
+exports.toInternalSettings = toInternalSettings;
+function filenameToDirectory(filename) {
+    return filename ? path.dirname(filename) : undefined;
+}
 function resolveFilename(filename, relativeTo) {
     const r = (0, resolveFile_1.resolveFile)(filename, relativeTo);
     return {
@@ -485,18 +527,15 @@ function clearCachedSettingsFiles() {
     cspellConfigExplorerSync.clearCaches();
 }
 exports.clearCachedSettingsFiles = clearCachedSettingsFiles;
-const globMatcherCache = new Map();
-const globMatcherCacheMaxSize = 1000;
+/**
+ * @param filename - filename
+ * @param globs - globs
+ * @returns true if it matches
+ * @deprecated true
+ * @deprecationMessage No longer actively supported. Use package: `cspell-glob`.
+ */
 function checkFilenameMatchesGlob(filename, globs) {
-    const matcher = globMatcherCache.get(globs);
-    if (matcher) {
-        return matcher.match(filename);
-    }
-    if (globMatcherCache.size >= globMatcherCacheMaxSize) {
-        globMatcherCache.clear();
-    }
     const m = new cspell_glob_1.GlobMatcher(globs);
-    globMatcherCache.set(globs, m);
     return m.match(filename);
 }
 exports.checkFilenameMatchesGlob = checkFilenameMatchesGlob;
@@ -561,28 +600,33 @@ function extractImportErrors(settings) {
 }
 exports.extractImportErrors = extractImportErrors;
 function extractDependencies(settings) {
-    const configFiles = [...(mergeImportRefs(settings) || [])].map(([filename]) => filename);
-    const dictionaryFiles = (0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings).map((dict) => dict.path);
+    const settingsI = toInternalSettings(settings);
+    const configFiles = [...(mergeImportRefs(settingsI) || [])].map(([filename]) => filename);
+    const dictionaryFiles = (0, DictionarySettings_1.calcDictionaryDefsToLoad)(settingsI).map((dict) => dict.path);
     return {
         configFiles,
         dictionaryFiles,
     };
 }
 exports.extractDependencies = extractDependencies;
+function resolveCwd() {
+    const envGlobRoot = process.env[exports.ENV_CSPELL_GLOB_ROOT];
+    const cwd = envGlobRoot || process.cwd();
+    return cwd;
+}
 function resolveGlobRoot(settings, pathToSettingsFile) {
     var _a;
     const settingsFileDirRaw = path.dirname(pathToSettingsFile);
     const isVSCode = path.basename(settingsFileDirRaw) === '.vscode';
     const settingsFileDir = isVSCode ? path.dirname(settingsFileDirRaw) : settingsFileDirRaw;
     const envGlobRoot = process.env[exports.ENV_CSPELL_GLOB_ROOT];
-    const cwd = envGlobRoot || process.cwd();
     const defaultGlobRoot = envGlobRoot !== null && envGlobRoot !== void 0 ? envGlobRoot : '${cwd}';
     const rawRoot = (_a = settings.globRoot) !== null && _a !== void 0 ? _a : (settings.version === configSettingsFileVersion0_1 ||
         (envGlobRoot && !settings.version) ||
         (isVSCode && !settings.version)
         ? defaultGlobRoot
         : settingsFileDir);
-    const globRoot = path.resolve(settingsFileDir, rawRoot.replace('${cwd}', cwd));
+    const globRoot = rawRoot.startsWith('${cwd}') ? rawRoot : path.resolve(settingsFileDir, rawRoot);
     return globRoot;
 }
 function resolveFilePath(filename, pathToSettingsFile) {
@@ -608,10 +652,10 @@ function toGlobDef(g, root, source) {
 }
 function normalizeDictionaryDefs(settings, pathToSettingsFile) {
     var _a;
-    const dictionaryDefinitions = (0, DictionarySettings_1.normalizePathForDictDefs)(settings.dictionaryDefinitions, pathToSettingsFile);
+    const dictionaryDefinitions = (0, DictionarySettings_1.mapDictDefsToInternal)(settings.dictionaryDefinitions, pathToSettingsFile);
     const languageSettings = (_a = settings.languageSettings) === null || _a === void 0 ? void 0 : _a.map((langSetting) => util.clean({
         ...langSetting,
-        dictionaryDefinitions: (0, DictionarySettings_1.normalizePathForDictDefs)(langSetting.dictionaryDefinitions, pathToSettingsFile),
+        dictionaryDefinitions: (0, DictionarySettings_1.mapDictDefsToInternal)(langSetting.dictionaryDefinitions, pathToSettingsFile),
     }));
     return util.clean({
         dictionaryDefinitions,
@@ -732,6 +776,7 @@ function validateRawConfig(config, fileRef) {
     validations.forEach((fn) => fn(config, fileRef));
 }
 exports.__testing__ = {
+    mergeObjects,
     normalizeCacheSettings,
     normalizeSettings,
     validateRawConfigExports,

package/dist/Settings/DefaultSettings.d.ts

@@ -1,4 +1,4 @@
-import type { CSpellSettings, CSpellSettingsWithSourceTrace } from '@cspell/cspell-types';
-export declare const _defaultSettings: Readonly<CSpellSettingsWithSourceTrace>;
-export declare function getDefaultSettings(): CSpellSettings;
+import { CSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef';
+export declare const _defaultSettings: Readonly<CSpellSettingsInternal>;
+export declare function getDefaultSettings(): CSpellSettingsInternal;
 //# sourceMappingURL=DefaultSettings.d.ts.map

package/dist/Settings/DefaultSettings.js

@@ -21,6 +21,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDefaultSettings = exports._defaultSettings = void 0;
 const resolveFile_1 = require("../util/resolveFile");
+const CSpellSettingsInternalDef_1 = require("../Models/CSpellSettingsInternalDef");
 const CSpellSettingsServer_1 = require("./CSpellSettingsServer");
 const index_1 = require("./index");
 const LanguageSettings = __importStar(require("./LanguageSettings"));
@@ -87,7 +88,7 @@ const definedDefaultRegExpExcludeList = [
 ];
 // This bit of copying is done to have the complier ensure that the defaults exist.
 const defaultRegExpExcludeList = definedDefaultRegExpExcludeList;
-exports._defaultSettings = {
+exports._defaultSettings = Object.freeze((0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
     id: 'static_defaults',
     language: 'en',
     name: 'Static Defaults',
@@ -131,7 +132,7 @@ exports._defaultSettings = {
     languageSettings: LanguageSettings.getDefaultLanguageSettings(),
     source: { name: 'defaultSettings' },
     reporters: [],
-};
+}));
 const getSettings = (function () {
     let settings = undefined;
     return function () {

package/dist/Settings/DictionarySettings.d.ts

@@ -1,9 +1,6 @@
-import type { DictionaryDefinition, DictionaryDefinitionPreferred, DictionaryReference, CSpellSettingsWithSourceTrace } from '@cspell/cspell-types';
-export interface DictionaryDefinitionWithSource extends DictionaryDefinitionPreferred {
-    /** The path to the config file that contains this dictionary definition */
-    __source: string;
-}
-export declare type DefMapArrayItem = [string, DictionaryDefinitionPreferred];
+import type { DictionaryDefinition, DictionaryReference } from '@cspell/cspell-types';
+import { CSpellSettingsInternal, DictionaryDefinitionInternal, DictionaryDefinitionInternalWithSource } from '../Models/CSpellSettingsInternalDef';
+export declare type DefMapArrayItem = [string, DictionaryDefinitionInternal];
 /**
  * Combines the list of desired dictionaries with the list of dictionary
  * definitions. Order does not matter, but the number of leading `!` does.
@@ -16,11 +13,11 @@ export declare type DefMapArrayItem = [string, DictionaryDefinitionPreferred];
  * @param defs - dictionary definitions
  * @returns map from dictIds to definitions
  */
-export declare function filterDictDefsToLoad(dictRefIds: DictionaryReference[], defs: DictionaryDefinition[]): DictionaryDefinitionPreferred[];
-export declare function normalizePathForDictDefs(defs: undefined, pathToSettingsFile: string): undefined;
-export declare function normalizePathForDictDefs(defs: DictionaryDefinition[], pathToSettingsFile: string): DictionaryDefinitionWithSource[];
-export declare function normalizePathForDictDefs(defs: DictionaryDefinition[] | undefined, pathToSettingsFile: string): DictionaryDefinitionWithSource[] | undefined;
-export declare function normalizePathForDictDef(def: DictionaryDefinition, pathToSettingsFile: string): DictionaryDefinitionWithSource;
-export declare function isDictionaryDefinitionWithSource(d: DictionaryDefinition | DictionaryDefinitionWithSource): d is DictionaryDefinitionWithSource;
-export declare function calcDictionaryDefsToLoad(settings: CSpellSettingsWithSourceTrace): DictionaryDefinitionPreferred[];
+export declare function filterDictDefsToLoad(dictRefIds: DictionaryReference[], defs: DictionaryDefinitionInternal[]): DictionaryDefinitionInternal[];
+export declare function mapDictDefsToInternal(defs: undefined, pathToSettingsFile: string): undefined;
+export declare function mapDictDefsToInternal(defs: DictionaryDefinition[], pathToSettingsFile: string): DictionaryDefinitionInternalWithSource[];
+export declare function mapDictDefsToInternal(defs: DictionaryDefinition[] | undefined, pathToSettingsFile: string): DictionaryDefinitionInternalWithSource[] | undefined;
+export declare function mapDictDefToInternal(def: DictionaryDefinition, pathToSettingsFile: string): DictionaryDefinitionInternalWithSource;
+export declare function isDictionaryDefinitionWithSource(d: DictionaryDefinition | DictionaryDefinitionInternalWithSource): d is DictionaryDefinitionInternalWithSource;
+export declare function calcDictionaryDefsToLoad(settings: CSpellSettingsInternal): DictionaryDefinitionInternal[];
 //# sourceMappingURL=DictionarySettings.d.ts.map

package/dist/Settings/DictionarySettings.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcDictionaryDefsToLoad = exports.isDictionaryDefinitionWithSource = exports.normalizePathForDictDef = exports.normalizePathForDictDefs = exports.filterDictDefsToLoad = void 0;
+exports.calcDictionaryDefsToLoad = exports.isDictionaryDefinitionWithSource = exports.mapDictDefToInternal = exports.mapDictDefsToInternal = exports.filterDictDefsToLoad = void 0;
 const path = __importStar(require("path"));
 const resolveFile_1 = require("../util/resolveFile");
 const DictionaryReferenceCollection_1 = require("./DictionaryReferenceCollection");
@@ -56,11 +56,11 @@ function getFullPathName(def) {
     }
     return path.join(filePath, file);
 }
-function normalizePathForDictDefs(defs, pathToSettingsFile) {
-    return defs === null || defs === void 0 ? void 0 : defs.map((def) => normalizePathForDictDef(def, pathToSettingsFile));
+function mapDictDefsToInternal(defs, pathToSettingsFile) {
+    return defs === null || defs === void 0 ? void 0 : defs.map((def) => mapDictDefToInternal(def, pathToSettingsFile));
 }
-exports.normalizePathForDictDefs = normalizePathForDictDefs;
-function normalizePathForDictDef(def, pathToSettingsFile) {
+exports.mapDictDefsToInternal = mapDictDefsToInternal;
+function mapDictDefToInternal(def, pathToSettingsFile) {
     const defaultPath = path.dirname(pathToSettingsFile);
     const { path: relPath = '', file = '', ...rest } = def;
     const filePath = path.join(relPath, file);
@@ -76,10 +76,11 @@ function normalizePathForDictDef(def, pathToSettingsFile) {
         ...rest,
         name,
         path: r.filename,
+        weightMap: undefined,
         __source: pathToSettingsFile,
     };
 }
-exports.normalizePathForDictDef = normalizePathForDictDef;
+exports.mapDictDefToInternal = mapDictDefToInternal;
 function isDictionaryDefinitionWithSource(d) {
     return d.__source !== undefined;
 }

package/dist/Settings/index.d.ts

@@ -1,5 +1,5 @@
-export * from '@cspell/cspell-types';
-export * from './CSpellSettingsServer';
-export * from './DefaultSettings';
-export * from './ImportError';
+export { calcOverrideSettings, checkFilenameMatchesGlob, clearCachedSettingsFiles, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getGlobalSettings, getSources, loadConfig, loadPnP, loadPnPSync, mergeInDocSettings, mergeSettings, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './CSpellSettingsServer';
+export type { ConfigurationDependencies, ImportFileRefWithError } from './CSpellSettingsServer';
+export { getDefaultSettings } from './DefaultSettings';
+export { ImportError } from './ImportError';
 //# sourceMappingURL=index.d.ts.map