cspell-lib 5.16.0 → 5.18.0

package/dist/Settings/configLoader.js

@@ -0,0 +1,523 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.extractImportErrors = exports.clearCachedSettingsFiles = exports.getCachedFileSize = exports.getGlobalSettings = exports.readSettingsFiles = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfig = exports.searchForConfig = exports.readSettings = exports.defaultConfigFilenames = exports.defaultFileName = exports.sectionCSpell = void 0;
+const json = __importStar(require("comment-json"));
+const cosmiconfig_1 = require("cosmiconfig");
+const path = __importStar(require("path"));
+const vscode_uri_1 = require("vscode-uri");
+const CSpellSettingsInternalDef_1 = require("../Models/CSpellSettingsInternalDef");
+const logger_1 = require("../util/logger");
+const resolveFile_1 = require("../util/resolveFile");
+const util = __importStar(require("../util/util"));
+const CSpellSettingsServer_1 = require("./CSpellSettingsServer");
+const DictionarySettings_1 = require("./DictionarySettings");
+const GlobalSettings_1 = require("./GlobalSettings");
+const ImportError_1 = require("./ImportError");
+const pnpLoader_1 = require("./pnpLoader");
+const supportedCSpellConfigVersions = [CSpellSettingsServer_1.configSettingsFileVersion0_2];
+const setOfSupportedConfigVersions = new Set(supportedCSpellConfigVersions);
+exports.sectionCSpell = 'cSpell';
+exports.defaultFileName = 'cspell.json';
+/**
+ * Logic of the locations:
+ * - Support backward compatibility with the VS Code Spell Checker
+ *   the spell checker extension can only write to `.json` files because
+ *   it would be too difficult to automatically modify a `.js` or `.cjs` file.
+ * - To support `cspell.config.js` in a VS Code environment, have a `cspell.json` import
+ *   the `cspell.config.js`.
+ */
+const searchPlaces = [
+    'package.json',
+    // Original locations
+    '.cspell.json',
+    'cspell.json',
+    '.cSpell.json',
+    'cSpell.json',
+    // Original locations jsonc
+    '.cspell.jsonc',
+    'cspell.jsonc',
+    // Alternate locations
+    '.vscode/cspell.json',
+    '.vscode/cSpell.json',
+    '.vscode/.cspell.json',
+    // Standard Locations
+    'cspell.config.json',
+    'cspell.config.jsonc',
+    'cspell.config.yaml',
+    'cspell.config.yml',
+    'cspell.yaml',
+    'cspell.yml',
+    // Dynamic config is looked for last
+    'cspell.config.js',
+    'cspell.config.cjs',
+];
+const cspellCosmiconfig = {
+    searchPlaces,
+    loaders: {
+        '.json': parseJson,
+        '.jsonc': parseJson,
+    },
+};
+function parseJson(_filename, content) {
+    return json.parse(content);
+}
+exports.defaultConfigFilenames = Object.freeze(searchPlaces.concat());
+const cspellConfigExplorer = (0, cosmiconfig_1.cosmiconfig)('cspell', cspellCosmiconfig);
+const cspellConfigExplorerSync = (0, cosmiconfig_1.cosmiconfigSync)('cspell', cspellCosmiconfig);
+let globalSettings;
+const defaultSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
+    id: 'default',
+    name: 'default',
+    version: CSpellSettingsServer_1.currentSettingsFileVersion,
+});
+const defaultPnPSettings = {};
+const cachedFiles = new Map();
+/**
+ * Read a config file and inject the fileRef.
+ * @param fileRef - filename plus context, injected into the resulting config.
+ */
+function readConfig(fileRef) {
+    // cspellConfigExplorerSync
+    const { filename } = fileRef;
+    const s = {};
+    try {
+        const r = cspellConfigExplorerSync.load(filename);
+        if (!(r === null || r === void 0 ? void 0 : r.config))
+            throw new Error(`not found: "${filename}"`);
+        Object.assign(s, r.config);
+        normalizeRawConfig(s);
+        validateRawConfig(s, fileRef);
+    }
+    catch (err) {
+        fileRef.error =
+            err instanceof ImportError_1.ImportError ? err : new ImportError_1.ImportError(`Failed to read config file: "${filename}"`, err);
+    }
+    s.__importRef = fileRef;
+    return s;
+}
+/**
+ * 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.
+ */
+function normalizeSettings(rawSettings, pathToSettingsFile, pnpSettings) {
+    const id = rawSettings.id ||
+        [path.basename(path.dirname(pathToSettingsFile)), path.basename(pathToSettingsFile)].join('/');
+    const name = rawSettings.name || id;
+    // Try to load any .pnp files before reading dictionaries or other config files.
+    const { usePnP = pnpSettings.usePnP, pnpFiles = pnpSettings.pnpFiles } = rawSettings;
+    const pnpSettingsToUse = {
+        usePnP,
+        pnpFiles,
+    };
+    const pathToSettingsDir = path.dirname(pathToSettingsFile);
+    loadPnPSync(pnpSettingsToUse, vscode_uri_1.URI.file(pathToSettingsDir));
+    // Fix up dictionaryDefinitions
+    const settings = {
+        version: defaultSettings.version,
+        ...rawSettings,
+        id,
+        name,
+        globRoot: resolveGlobRoot(rawSettings, pathToSettingsFile),
+        languageSettings: normalizeLanguageSettings(rawSettings.languageSettings),
+    };
+    const pathToSettings = path.dirname(pathToSettingsFile);
+    const normalizedDictionaryDefs = normalizeDictionaryDefs(settings, pathToSettingsFile);
+    const normalizedSettingsGlobs = normalizeSettingsGlobs(settings, pathToSettingsFile);
+    const normalizedOverrides = normalizeOverrides(settings, pathToSettingsFile);
+    const normalizedReporters = normalizeReporters(settings, pathToSettingsFile);
+    const normalizedGitignoreRoot = normalizeGitignoreRoot(settings, pathToSettingsFile);
+    const normalizedCacheSettings = normalizeCacheSettings(settings, pathToSettingsDir);
+    const imports = typeof settings.import === 'string' ? [settings.import] : settings.import || [];
+    const source = settings.source || {
+        name: settings.name,
+        filename: pathToSettingsFile,
+    };
+    const fileSettings = (0, CSpellSettingsInternalDef_1.createCSpellSettingsInternal)({
+        ...settings,
+        source,
+        ...normalizedDictionaryDefs,
+        ...normalizedSettingsGlobs,
+        ...normalizedOverrides,
+        ...normalizedReporters,
+        ...normalizedGitignoreRoot,
+        ...normalizedCacheSettings,
+    });
+    if (!imports.length) {
+        return fileSettings;
+    }
+    const importedSettings = imports
+        .map((name) => resolveFilename(name, pathToSettings))
+        .map((ref) => ((ref.referencedBy = [source]), ref))
+        .map((ref) => importSettings(ref, undefined, pnpSettingsToUse))
+        .reduce((a, b) => (0, CSpellSettingsServer_1.mergeSettings)(a, b));
+    const finalizeSettings = (0, CSpellSettingsServer_1.mergeSettings)(importedSettings, fileSettings);
+    finalizeSettings.name = settings.name || finalizeSettings.name || '';
+    finalizeSettings.id = settings.id || finalizeSettings.id || '';
+    return finalizeSettings;
+}
+function mergeSourceList(orig, append) {
+    const collection = new Map(orig.map((s) => [s.name + (s.filename || ''), s]));
+    for (const s of append || []) {
+        const key = s.name + (s.filename || '');
+        if (!collection.has(key)) {
+            collection.set(key, s);
+        }
+    }
+    return [...collection.values()];
+}
+function importSettings(fileRef, defaultValues, pnpSettings) {
+    defaultValues = defaultValues !== null && defaultValues !== void 0 ? defaultValues : defaultSettings;
+    let { filename } = fileRef;
+    filename = path.resolve(filename);
+    const importRef = { ...fileRef, filename };
+    const cached = cachedFiles.get(filename);
+    if (cached) {
+        const cachedImportRef = cached.__importRef || importRef;
+        cachedImportRef.referencedBy = mergeSourceList(cachedImportRef.referencedBy || [], importRef.referencedBy);
+        cached.__importRef = cachedImportRef;
+        return cached;
+    }
+    const id = [path.basename(path.dirname(filename)), path.basename(filename)].join('/');
+    const name = id;
+    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));
+    const finalizeSrc = { name: path.basename(filename), ...finalizeSettings.source };
+    finalizeSettings.source = { ...finalizeSrc, filename };
+    cachedFiles.set(filename, finalizeSettings);
+    return finalizeSettings;
+}
+function readSettings(filename, relativeToOrDefault, defaultValue) {
+    const relativeTo = typeof relativeToOrDefault === 'string' ? relativeToOrDefault : process.cwd();
+    defaultValue = defaultValue || (typeof relativeToOrDefault !== 'string' ? relativeToOrDefault : undefined);
+    const ref = resolveFilename(filename, relativeTo);
+    return importSettings(ref, defaultValue, defaultValue || defaultPnPSettings);
+}
+exports.readSettings = readSettings;
+async function normalizeSearchForConfigResult(searchPath, searchResult, pnpSettings) {
+    var _a;
+    let result;
+    let error;
+    try {
+        result = (await searchResult) || undefined;
+    }
+    catch (cause) {
+        error = new ImportError_1.ImportError(`Failed to find config file at: "${searchPath}"`, cause);
+    }
+    const filepath = result === null || result === void 0 ? void 0 : result.filepath;
+    if (filepath) {
+        const cached = cachedFiles.get(filepath);
+        if (cached) {
+            return {
+                config: cached,
+                filepath,
+                error,
+            };
+        }
+    }
+    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 = (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));
+    return {
+        config: finalizeSettings,
+        filepath,
+        error,
+    };
+}
+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) {
+        return Promise.resolve(cached);
+    }
+    return normalizeSearchForConfigResult(file, cspellConfigExplorer.load(file), pnpSettings).then((r) => r.config);
+}
+exports.loadConfig = loadConfig;
+function loadPnP(pnpSettings, searchFrom) {
+    if (!pnpSettings.usePnP) {
+        return Promise.resolve(undefined);
+    }
+    const loader = (0, pnpLoader_1.pnpLoader)(pnpSettings.pnpFiles);
+    return loader.load(searchFrom);
+}
+exports.loadPnP = loadPnP;
+function loadPnPSync(pnpSettings, searchFrom) {
+    if (!pnpSettings.usePnP) {
+        return undefined;
+    }
+    const loader = (0, pnpLoader_1.pnpLoader)(pnpSettings.pnpFiles);
+    return loader.loadSync(searchFrom);
+}
+exports.loadPnPSync = loadPnPSync;
+function readRawSettings(filename, relativeTo) {
+    relativeTo = relativeTo || process.cwd();
+    const ref = resolveFilename(filename, relativeTo);
+    return readConfig(ref);
+}
+exports.readRawSettings = readRawSettings;
+/**
+ *
+ * @param filenames - settings files to read
+ * @returns combined configuration
+ * @deprecated true
+ */
+function readSettingsFiles(filenames) {
+    return filenames.map((filename) => readSettings(filename)).reduce((a, b) => (0, CSpellSettingsServer_1.mergeSettings)(a, b), defaultSettings);
+}
+exports.readSettingsFiles = readSettingsFiles;
+function resolveFilename(filename, relativeTo) {
+    const r = (0, resolveFile_1.resolveFile)(filename, relativeTo);
+    return {
+        filename: r.filename,
+        error: r.found ? undefined : new Error(`Failed to resolve file: "${filename}"`),
+    };
+}
+function getGlobalSettings() {
+    if (!globalSettings) {
+        const globalConf = (0, GlobalSettings_1.getRawGlobalSettings)();
+        globalSettings = {
+            id: 'global_config',
+            ...normalizeSettings(globalConf || {}, './global_config', {}),
+        };
+    }
+    return globalSettings;
+}
+exports.getGlobalSettings = getGlobalSettings;
+function getCachedFileSize() {
+    return cachedFiles.size;
+}
+exports.getCachedFileSize = getCachedFileSize;
+function clearCachedSettingsFiles() {
+    globalSettings = undefined;
+    cachedFiles.clear();
+    cspellConfigExplorer.clearCaches();
+    cspellConfigExplorerSync.clearCaches();
+}
+exports.clearCachedSettingsFiles = clearCachedSettingsFiles;
+function mergeImportRefs(left, right = {}) {
+    var _a;
+    const imports = new Map(left.__imports || []);
+    if (left.__importRef) {
+        imports.set(left.__importRef.filename, left.__importRef);
+    }
+    if (right.__importRef) {
+        imports.set(right.__importRef.filename, right.__importRef);
+    }
+    const rightImports = ((_a = right.__imports) === null || _a === void 0 ? void 0 : _a.values()) || [];
+    for (const ref of rightImports) {
+        imports.set(ref.filename, ref);
+    }
+    return imports.size ? imports : undefined;
+}
+function isImportFileRefWithError(ref) {
+    return !!ref.error;
+}
+function extractImportErrors(settings) {
+    const imports = mergeImportRefs(settings);
+    return !imports ? [] : [...imports.values()].filter(isImportFileRefWithError);
+}
+exports.extractImportErrors = extractImportErrors;
+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[CSpellSettingsServer_1.ENV_CSPELL_GLOB_ROOT];
+    const defaultGlobRoot = envGlobRoot !== null && envGlobRoot !== void 0 ? envGlobRoot : '${cwd}';
+    const rawRoot = (_a = settings.globRoot) !== null && _a !== void 0 ? _a : (settings.version === CSpellSettingsServer_1.configSettingsFileVersion0_1 ||
+        (envGlobRoot && !settings.version) ||
+        (isVSCode && !settings.version)
+        ? defaultGlobRoot
+        : settingsFileDir);
+    const globRoot = rawRoot.startsWith('${cwd}') ? rawRoot : path.resolve(settingsFileDir, rawRoot);
+    return globRoot;
+}
+function resolveFilePath(filename, pathToSettingsFile) {
+    const cwd = process.cwd();
+    return path.resolve(pathToSettingsFile, filename.replace('${cwd}', cwd));
+}
+function toGlobDef(g, root, source) {
+    if (g === undefined)
+        return undefined;
+    if (Array.isArray(g)) {
+        return g.map((g) => toGlobDef(g, root, source));
+    }
+    if (typeof g === 'string') {
+        return toGlobDef({
+            glob: g,
+            root,
+        }, root, source);
+    }
+    if (source) {
+        return { ...g, source };
+    }
+    return g;
+}
+function normalizeDictionaryDefs(settings, pathToSettingsFile) {
+    var _a;
+    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.mapDictDefsToInternal)(langSetting.dictionaryDefinitions, pathToSettingsFile),
+    }));
+    return util.clean({
+        dictionaryDefinitions,
+        languageSettings,
+    });
+}
+function normalizeOverrides(settings, pathToSettingsFile) {
+    var _a;
+    const { globRoot = path.dirname(pathToSettingsFile) } = settings;
+    const overrides = (_a = settings.overrides) === null || _a === void 0 ? void 0 : _a.map((override) => {
+        const filename = toGlobDef(override.filename, globRoot, pathToSettingsFile);
+        const { dictionaryDefinitions, languageSettings } = normalizeDictionaryDefs(override, pathToSettingsFile);
+        return util.clean({
+            ...override,
+            filename,
+            dictionaryDefinitions,
+            languageSettings: normalizeLanguageSettings(languageSettings),
+        });
+    });
+    return overrides ? { overrides } : {};
+}
+function normalizeReporters(settings, pathToSettingsFile) {
+    if (settings.reporters === undefined)
+        return {};
+    const folder = path.dirname(pathToSettingsFile);
+    function resolve(s) {
+        const r = (0, resolveFile_1.resolveFile)(s, folder);
+        if (!r.found) {
+            throw new Error(`Not found: "${s}"`);
+        }
+        return r.filename;
+    }
+    function resolveReporter(s) {
+        if (typeof s === 'string') {
+            return resolve(s);
+        }
+        if (!Array.isArray(s) || typeof s[0] !== 'string')
+            throw new Error('Invalid Reporter');
+        // Preserve the shape of Reporter Setting while resolving the reporter file.
+        const [r, ...rest] = s;
+        return [resolve(r), ...rest];
+    }
+    return {
+        reporters: settings.reporters.map(resolveReporter),
+    };
+}
+function normalizeLanguageSettings(languageSettings) {
+    if (!languageSettings)
+        return undefined;
+    function fixLocale(s) {
+        const { local: locale, ...rest } = s;
+        return { locale, ...rest };
+    }
+    return languageSettings.map(fixLocale);
+}
+function normalizeGitignoreRoot(settings, pathToSettingsFile) {
+    const { gitignoreRoot } = settings;
+    if (!gitignoreRoot)
+        return {};
+    const dir = path.dirname(pathToSettingsFile);
+    const roots = Array.isArray(gitignoreRoot) ? gitignoreRoot : [gitignoreRoot];
+    return {
+        gitignoreRoot: roots.map((p) => path.resolve(dir, p)),
+    };
+}
+function normalizeSettingsGlobs(settings, pathToSettingsFile) {
+    const { globRoot } = settings;
+    if (settings.ignorePaths === undefined)
+        return {};
+    const ignorePaths = toGlobDef(settings.ignorePaths, globRoot, pathToSettingsFile);
+    return {
+        ignorePaths,
+    };
+}
+function normalizeCacheSettings(settings, pathToSettingsDir) {
+    const { cache } = settings;
+    if (cache === undefined)
+        return {};
+    const { cacheLocation } = cache;
+    if (cacheLocation === undefined)
+        return { cache };
+    return { cache: { ...cache, cacheLocation: resolveFilePath(cacheLocation, pathToSettingsDir) } };
+}
+function validationMessage(msg, fileRef) {
+    return msg + `\n  File: "${fileRef.filename}"`;
+}
+function validateRawConfigVersion(config, fileRef) {
+    const { version } = config;
+    if (version === undefined)
+        return;
+    if (typeof version !== 'string') {
+        (0, logger_1.logError)(validationMessage(`Unsupported config file version: "${version}", string expected`, fileRef));
+        return;
+    }
+    if (setOfSupportedConfigVersions.has(version))
+        return;
+    if (!/^\d+(\.\d+)*$/.test(version)) {
+        (0, logger_1.logError)(validationMessage(`Unsupported config file version: "${version}"`, fileRef));
+        return;
+    }
+    const msg = version > CSpellSettingsServer_1.currentSettingsFileVersion
+        ? `Newer config file version found: "${version}". Supported version is "${CSpellSettingsServer_1.currentSettingsFileVersion}"`
+        : `Legacy config file version found: "${version}", upgrade to "${CSpellSettingsServer_1.currentSettingsFileVersion}"`;
+    (0, logger_1.logWarning)(validationMessage(msg, fileRef));
+}
+function validateRawConfigExports(config, fileRef) {
+    if (config.default) {
+        throw new ImportError_1.ImportError(validationMessage('Module `export default` is not supported.\n  Use `module.exports =` instead.', fileRef));
+    }
+}
+function normalizeRawConfig(config) {
+    if (typeof config.version === 'number') {
+        config.version = config.version.toString();
+    }
+}
+function validateRawConfig(config, fileRef) {
+    const validations = [validateRawConfigExports, validateRawConfigVersion];
+    validations.forEach((fn) => fn(config, fileRef));
+}
+exports.__testing__ = {
+    normalizeCacheSettings,
+    normalizeSettings,
+    validateRawConfigExports,
+    validateRawConfigVersion,
+};
+//# sourceMappingURL=configLoader.js.map

package/dist/Settings/index.d.ts

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

package/dist/Settings/index.js

@@ -1,17 +1,33 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@cspell/cspell-types"), exports);
-__exportStar(require("./CSpellSettingsServer"), exports);
-__exportStar(require("./DefaultSettings"), exports);
-__exportStar(require("./ImportError"), exports);
+exports.ImportError = exports.getDefaultSettings = exports.mergeSettings = exports.mergeInDocSettings = exports.getSources = exports.finalizeSettings = exports.extractDependencies = exports.ENV_CSPELL_GLOB_ROOT = exports.currentSettingsFileVersion = exports.checkFilenameMatchesGlob = exports.calcOverrideSettings = exports.sectionCSpell = exports.searchForConfig = exports.readSettingsFiles = exports.readSettings = exports.readRawSettings = exports.loadPnPSync = exports.loadPnP = exports.loadConfig = exports.getGlobalSettings = exports.getCachedFileSize = exports.extractImportErrors = exports.defaultFileName = exports.defaultConfigFilenames = exports.clearCachedSettingsFiles = void 0;
+var configLoader_1 = require("./configLoader");
+Object.defineProperty(exports, "clearCachedSettingsFiles", { enumerable: true, get: function () { return configLoader_1.clearCachedSettingsFiles; } });
+Object.defineProperty(exports, "defaultConfigFilenames", { enumerable: true, get: function () { return configLoader_1.defaultConfigFilenames; } });
+Object.defineProperty(exports, "defaultFileName", { enumerable: true, get: function () { return configLoader_1.defaultFileName; } });
+Object.defineProperty(exports, "extractImportErrors", { enumerable: true, get: function () { return configLoader_1.extractImportErrors; } });
+Object.defineProperty(exports, "getCachedFileSize", { enumerable: true, get: function () { return configLoader_1.getCachedFileSize; } });
+Object.defineProperty(exports, "getGlobalSettings", { enumerable: true, get: function () { return configLoader_1.getGlobalSettings; } });
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return configLoader_1.loadConfig; } });
+Object.defineProperty(exports, "loadPnP", { enumerable: true, get: function () { return configLoader_1.loadPnP; } });
+Object.defineProperty(exports, "loadPnPSync", { enumerable: true, get: function () { return configLoader_1.loadPnPSync; } });
+Object.defineProperty(exports, "readRawSettings", { enumerable: true, get: function () { return configLoader_1.readRawSettings; } });
+Object.defineProperty(exports, "readSettings", { enumerable: true, get: function () { return configLoader_1.readSettings; } });
+Object.defineProperty(exports, "readSettingsFiles", { enumerable: true, get: function () { return configLoader_1.readSettingsFiles; } });
+Object.defineProperty(exports, "searchForConfig", { enumerable: true, get: function () { return configLoader_1.searchForConfig; } });
+Object.defineProperty(exports, "sectionCSpell", { enumerable: true, get: function () { return configLoader_1.sectionCSpell; } });
+var CSpellSettingsServer_1 = require("./CSpellSettingsServer");
+Object.defineProperty(exports, "calcOverrideSettings", { enumerable: true, get: function () { return CSpellSettingsServer_1.calcOverrideSettings; } });
+Object.defineProperty(exports, "checkFilenameMatchesGlob", { enumerable: true, get: function () { return CSpellSettingsServer_1.checkFilenameMatchesGlob; } });
+Object.defineProperty(exports, "currentSettingsFileVersion", { enumerable: true, get: function () { return CSpellSettingsServer_1.currentSettingsFileVersion; } });
+Object.defineProperty(exports, "ENV_CSPELL_GLOB_ROOT", { enumerable: true, get: function () { return CSpellSettingsServer_1.ENV_CSPELL_GLOB_ROOT; } });
+Object.defineProperty(exports, "extractDependencies", { enumerable: true, get: function () { return CSpellSettingsServer_1.extractDependencies; } });
+Object.defineProperty(exports, "finalizeSettings", { enumerable: true, get: function () { return CSpellSettingsServer_1.finalizeSettings; } });
+Object.defineProperty(exports, "getSources", { enumerable: true, get: function () { return CSpellSettingsServer_1.getSources; } });
+Object.defineProperty(exports, "mergeInDocSettings", { enumerable: true, get: function () { return CSpellSettingsServer_1.mergeInDocSettings; } });
+Object.defineProperty(exports, "mergeSettings", { enumerable: true, get: function () { return CSpellSettingsServer_1.mergeSettings; } });
+var DefaultSettings_1 = require("./DefaultSettings");
+Object.defineProperty(exports, "getDefaultSettings", { enumerable: true, get: function () { return DefaultSettings_1.getDefaultSettings; } });
+var ImportError_1 = require("./ImportError");
+Object.defineProperty(exports, "ImportError", { enumerable: true, get: function () { return ImportError_1.ImportError; } });
 //# sourceMappingURL=index.js.map

package/dist/Settings/index.link.d.ts

@@ -0,0 +1,3 @@
+export { addPathsToGlobalImports, listGlobalImports, removePathsFromGlobalImports } from './link';
+export type { AddPathsToGlobalImportsResults, ListGlobalImportsResult, ListGlobalImportsResults, RemovePathsFromGlobalImportsResult, ResolveSettingsResult, } from './link';
+//# sourceMappingURL=index.link.d.ts.map

package/dist/Settings/index.link.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removePathsFromGlobalImports = exports.listGlobalImports = exports.addPathsToGlobalImports = void 0;
+var link_1 = require("./link");
+Object.defineProperty(exports, "addPathsToGlobalImports", { enumerable: true, get: function () { return link_1.addPathsToGlobalImports; } });
+Object.defineProperty(exports, "listGlobalImports", { enumerable: true, get: function () { return link_1.listGlobalImports; } });
+Object.defineProperty(exports, "removePathsFromGlobalImports", { enumerable: true, get: function () { return link_1.removePathsFromGlobalImports; } });
+//# sourceMappingURL=index.link.js.map

package/dist/Settings/link.js

@@ -22,7 +22,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.removePathsFromGlobalImports = exports.addPathsToGlobalImports = exports.listGlobalImports = void 0;
 const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
-const CSpellSettingsServer_1 = require("./CSpellSettingsServer");
+const configLoader_1 = require("./configLoader");
 const GlobalSettings_1 = require("./GlobalSettings");
 function listGlobalImports() {
     const globalSettings = (0, GlobalSettings_1.getRawGlobalSettings)();
@@ -125,7 +125,7 @@ function removePathsFromGlobalImports(paths) {
 exports.removePathsFromGlobalImports = removePathsFromGlobalImports;
 function resolveSettings(filename) {
     var _a;
-    const settings = (0, CSpellSettingsServer_1.readRawSettings)(filename);
+    const settings = (0, configLoader_1.readRawSettings)(filename);
     const ref = settings.__importRef;
     const resolvedToFilename = ref === null || ref === void 0 ? void 0 : ref.filename;
     const error = ((_a = ref === null || ref === void 0 ? void 0 : ref.error) === null || _a === void 0 ? void 0 : _a.message) || (!resolvedToFilename && 'File not Found') || undefined;

package/dist/SpellingDictionary/Dictionaries.d.ts

@@ -1,7 +1,7 @@
-import type { CSpellUserSettings, DictionaryDefinitionPreferred } from '@cspell/cspell-types';
-import { SpellingDictionaryCollection } from './index';
+import { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
 import { SpellingDictionary } from './SpellingDictionary';
-export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionPreferred[]): Promise<SpellingDictionary>[];
+import { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
+export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
 export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
-export declare function getDictionary(settings: CSpellUserSettings): Promise<SpellingDictionaryCollection>;
+export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
 //# sourceMappingURL=Dictionaries.d.ts.map