cspell-lib 6.6.1 → 6.8.1

package/dist/Settings/CSpellSettingsServer.js

@@ -269,9 +269,9 @@ function mergeSources(left, right) {
     };
 }
 function max(a, b) {
-    if (a === undefined)
+    if (a === undefined || a === null)
         return b;
-    if (b === undefined)
+    if (b === undefined || b === null)
         return a;
     return a > b ? a : b;
 }

package/dist/Settings/Controller/ImportError.d.ts

@@ -0,0 +1,11 @@
+export declare class ImportError extends Error {
+    readonly cause: Error | undefined;
+    constructor(msg: string, cause?: Error | unknown);
+}
+export declare class UnsupportedSchema extends Error {
+    constructor(msg: string);
+}
+export declare class UnsupportedPnpFile extends Error {
+    constructor(msg: string);
+}
+//# sourceMappingURL=ImportError.d.ts.map

package/dist/Settings/Controller/ImportError.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedPnpFile = exports.UnsupportedSchema = exports.ImportError = void 0;
+const errors_1 = require("../../util/errors");
+class ImportError extends Error {
+    constructor(msg, cause) {
+        super(msg);
+        this.cause = (0, errors_1.isError)(cause) ? cause : undefined;
+    }
+}
+exports.ImportError = ImportError;
+class UnsupportedSchema extends Error {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.UnsupportedSchema = UnsupportedSchema;
+class UnsupportedPnpFile extends Error {
+    constructor(msg) {
+        super(msg);
+    }
+}
+exports.UnsupportedPnpFile = UnsupportedPnpFile;
+//# sourceMappingURL=ImportError.js.map

package/dist/Settings/Controller/SettingsController.d.ts

@@ -0,0 +1,9 @@
+import { CSpellIO } from 'cspell-io';
+/**
+ * The settings controller manages requests to resolve configuration settings and files.
+ */
+export declare class SettingsController {
+    readonly cspellIO: CSpellIO;
+    constructor(cspellIO: CSpellIO);
+}
+//# sourceMappingURL=SettingsController.d.ts.map

package/dist/Settings/Controller/SettingsController.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsController = void 0;
+/**
+ * The settings controller manages requests to resolve configuration settings and files.
+ */
+class SettingsController {
+    constructor(cspellIO) {
+        this.cspellIO = cspellIO;
+    }
+}
+exports.SettingsController = SettingsController;
+//# sourceMappingURL=SettingsController.js.map

package/dist/Settings/{configLoader.d.ts → Controller/configLoader.d.ts}

@@ -1,7 +1,7 @@
 import type { CSpellSettingsWithSourceTrace, CSpellUserSettings, ImportFileRef, PnPSettings as PnPSettingsStrict } from '@cspell/cspell-types';
 import { URI } from 'vscode-uri';
-import { CSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef';
-import { OptionalOrUndefined } from '../util/types';
+import { CSpellSettingsInternal } from '../../Models/CSpellSettingsInternalDef';
+import { OptionalOrUndefined } from '../../util/types';
 import { LoaderResult } from './pnpLoader';
 declare type CSpellSettingsWST = CSpellSettingsWithSourceTrace;
 declare type CSpellSettingsI = CSpellSettingsInternal;

package/dist/Settings/{configLoader.js → Controller/configLoader.js}

@@ -28,13 +28,13 @@ 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 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];

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

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

package/dist/Settings/Controller/index.js

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

package/dist/Settings/{pnpLoader.d.ts → Controller/pnpLoader.d.ts}

@@ -28,11 +28,5 @@ export declare class PnpLoader {
     private calcKey;
 }
 export declare function pnpLoader(pnpFiles?: string[]): PnpLoader;
-export declare class UnsupportedSchema extends Error {
-    constructor(msg: string);
-}
-export declare class UnsupportedPnpFile extends Error {
-    constructor(msg: string);
-}
 export declare function clearPnPGlobalCache(): Promise<undefined>;
 //# sourceMappingURL=pnpLoader.d.ts.map

package/dist/Settings/{pnpLoader.js → Controller/pnpLoader.js}

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearPnPGlobalCache = exports.UnsupportedPnpFile = exports.UnsupportedSchema = exports.pnpLoader = exports.PnpLoader = void 0;
+exports.clearPnPGlobalCache = exports.pnpLoader = exports.PnpLoader = void 0;
 /**
  * Handles loading of `.pnp.js` and `.pnp.js` files.
  */
@@ -11,6 +11,7 @@ const vscode_uri_1 = require("vscode-uri");
 const import_fresh_1 = __importDefault(require("import-fresh"));
 const find_up_1 = __importDefault(require("find-up"));
 const clear_module_1 = __importDefault(require("clear-module"));
+const ImportError_1 = require("./ImportError");
 const defaultPnpFiles = ['.pnp.cjs', '.pnp.js'];
 const supportedSchemas = new Set(['file']);
 const cachedRequests = new Map();
@@ -28,6 +29,8 @@ class PnpLoader {
      * @returns promise - rejects on error - success if loaded or not found.
      */
     async load(uriDirectory) {
+        if (!supportedSchemas.has(uriDirectory.scheme))
+            return undefined;
         await lock;
         const cacheKey = this.calcKey(uriDirectory);
         const cached = cachedRequests.get(cacheKey);
@@ -40,6 +43,8 @@ class PnpLoader {
         return result;
     }
     async peek(uriDirectory) {
+        if (!supportedSchemas.has(uriDirectory.scheme))
+            return undefined;
         await lock;
         const cacheKey = this.calcKey(uriDirectory);
         return cachedRequests.get(cacheKey) ?? Promise.resolve(undefined);
@@ -50,6 +55,8 @@ class PnpLoader {
      * @returns promise - rejects on error - success if loaded or not found.
      */
     loadSync(uriDirectory) {
+        if (!supportedSchemas.has(uriDirectory.scheme))
+            return undefined;
         const cacheKey = this.calcKey(uriDirectory);
         const cached = cachedRequestsSync.get(cacheKey);
         if (cached)
@@ -60,6 +67,8 @@ class PnpLoader {
         return r;
     }
     peekSync(uriDirectory) {
+        if (!supportedSchemas.has(uriDirectory.scheme))
+            return undefined;
         const cacheKey = this.calcKey(uriDirectory);
         return cachedRequestsSync.get(cacheKey);
     }
@@ -78,23 +87,10 @@ function pnpLoader(pnpFiles) {
     return new PnpLoader(pnpFiles);
 }
 exports.pnpLoader = pnpLoader;
-class UnsupportedSchema extends Error {
-    constructor(msg) {
-        super(msg);
-    }
-}
-exports.UnsupportedSchema = UnsupportedSchema;
-class UnsupportedPnpFile extends Error {
-    constructor(msg) {
-        super(msg);
-    }
-}
-exports.UnsupportedPnpFile = UnsupportedPnpFile;
 /**
  * @param uriDirectory - directory to start at.
  */
 async function findPnpAndLoad(uriDirectory, pnpFiles) {
-    validateSchema(uriDirectory);
     const found = await (0, find_up_1.default)(pnpFiles, { cwd: uriDirectory.fsPath });
     return loadPnpIfNeeded(found);
 }
@@ -102,7 +98,6 @@ async function findPnpAndLoad(uriDirectory, pnpFiles) {
  * @param uriDirectory - directory to start at.
  */
 function findPnpAndLoadSync(uriDirectory, pnpFiles) {
-    validateSchema(uriDirectory);
     const found = find_up_1.default.sync(pnpFiles, { cwd: uriDirectory.fsPath });
     return loadPnpIfNeeded(found);
 }
@@ -122,13 +117,7 @@ function loadPnp(pnpFile) {
         pnp.setup();
         return vscode_uri_1.URI.file(pnpFile);
     }
-    throw new UnsupportedPnpFile(`Unsupported pnp file: "${pnpFile}"`);
-}
-function validateSchema(uri) {
-    if (!supportedSchemas.has(uri.scheme)) {
-        throw new UnsupportedSchema(`Unsupported schema for PNP: "${uri.scheme}"`);
-    }
-    return true;
+    throw new ImportError_1.UnsupportedPnpFile(`Unsupported pnp file: "${pnpFile}"`);
 }
 function clearPnPGlobalCache() {
     if (lock)

package/dist/Settings/DefaultSettings.js

@@ -28,7 +28,7 @@ const cspell_grammar_1 = require("cspell-grammar");
 const CSpellSettingsInternalDef_1 = require("../Models/CSpellSettingsInternalDef");
 const PatternRegExp_1 = require("../Models/PatternRegExp");
 const resolveFile_1 = require("../util/resolveFile");
-const configLoader_1 = require("./configLoader");
+const configLoader_1 = require("./Controller/configLoader");
 const index_1 = require("./index");
 const LanguageSettings = __importStar(require("./LanguageSettings"));
 const RegPat = __importStar(require("./RegExpPatterns"));

package/dist/Settings/InDocSettings.d.ts

@@ -1,7 +1,23 @@
 import type { CSpellUserSettings } from '@cspell/cspell-types';
 import { Sequence } from 'gensequence';
 export declare type CSpellUserSettingsKeys = keyof CSpellUserSettings;
+export interface DirectiveIssue {
+    /**
+     * the start and end offsets within the document of the issue.
+     */
+    range: [start: number, end: number];
+    /**
+     * The text causing the issue.
+     */
+    text: string;
+    message: string;
+    suggestions: string[];
+}
 export declare function getInDocumentSettings(text: string): CSpellUserSettings;
+export declare function validateInDocumentSettings(docText: string, _settings: CSpellUserSettings): Iterable<DirectiveIssue>;
+export declare const regExSpellingGuardBlock: RegExp;
+export declare const regExSpellingGuardNext: RegExp;
+export declare const regExSpellingGuardLine: RegExp;
 declare function parseCompoundWords(match: string): CSpellUserSettings;
 declare function parseWords(match: string): CSpellUserSettings;
 declare function parseIgnoreWords(match: string): CSpellUserSettings;

package/dist/Settings/InDocSettings.js

@@ -23,14 +23,70 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.internal = exports.getIgnoreRegExpFromDocument = exports.getIgnoreWordsFromDocument = exports.getInDocumentSettings = void 0;
+exports.internal = exports.getIgnoreRegExpFromDocument = exports.getIgnoreWordsFromDocument = exports.regExSpellingGuardLine = exports.regExSpellingGuardNext = exports.regExSpellingGuardBlock = exports.validateInDocumentSettings = exports.getInDocumentSettings = void 0;
+const cspell_pipe_1 = require("@cspell/cspell-pipe");
 const gensequence_1 = require("gensequence");
+const SpellingDictionary_1 = require("../SpellingDictionary");
 const Text = __importStar(require("../util/text"));
 const util_1 = require("../util/util");
 const CSpellSettingsServer_1 = require("./CSpellSettingsServer");
 // cspell:ignore gimuy
 const regExMatchRegEx = /\/.*\/[gimuy]*/;
-const regExInFileSettings = [/(?:spell-?checker|c?spell)::?(.*)/gi, /(LocalWords:?.*)/g];
+const regExCSpellInDocDirective = /(?:spell-?checker|c?spell)::?(.*)/gi;
+const regExCSpellDirectiveKey = /(?<=(?:spell-?checker|c?spell)::?)(?!:)(.*)/i;
+const regExInFileSettings = [regExCSpellInDocDirective, /(LocalWords:?.*)/g];
+const officialDirectives = [
+    'enable',
+    'disable',
+    'disable-line',
+    'disable-next',
+    'disable-next-line',
+    'word',
+    'words',
+    'ignore',
+    'ignoreWord',
+    'ignoreWords',
+    'ignore-word',
+    'ignore-words',
+    'includeRegExp',
+    'ignoreRegExp',
+    'local',
+    'locale',
+    'language',
+    'dictionaries',
+    'dictionary',
+    'forbid',
+    'forbidWord',
+    'forbid-word',
+    'flag',
+    'flagWord',
+    'flag-word',
+    'enableCompoundWords',
+    'enableAllowCompoundWords',
+    'disableCompoundWords',
+    'disableAllowCompoundWords',
+    'enableCaseSensitive',
+    'disableCaseSensitive',
+];
+const noSuggestDirectives = new Set(['local']);
+const preferredDirectives = [
+    'enable',
+    'disable',
+    'disable-line',
+    'disable-next-line',
+    'words',
+    'ignore',
+    'forbid',
+    'locale',
+    'dictionary',
+    'dictionaries',
+    'enableCaseSensitive',
+    'disableCaseSensitive',
+];
+const allDirectives = new Set(preferredDirectives.concat(officialDirectives));
+const dictInDocSettings = (0, SpellingDictionary_1.createSpellingDictionary)(allDirectives, 'Directives', 'Directive List', {
+    supportNonStrictSearches: false,
+});
 const EmptyWords = [];
 Object.freeze(EmptyWords);
 function getInDocumentSettings(text) {
@@ -43,21 +99,66 @@ function getInDocumentSettings(text) {
     return settings;
 }
 exports.getInDocumentSettings = getInDocumentSettings;
+function validateInDocumentSettings(docText, _settings) {
+    return (0, cspell_pipe_1.pipeSync)(getPossibleInDocSettings(docText), (0, cspell_pipe_1.opMap)(parseSettingMatchValidation), (0, cspell_pipe_1.opFilter)(util_1.isDefined));
+}
+exports.validateInDocumentSettings = validateInDocumentSettings;
+const settingParsers = [
+    [/^(?:enable|disable)(?:allow)?CompoundWords\b/i, parseCompoundWords],
+    [/^(?:enable|disable)CaseSensitive\b/i, parseCaseSensitive],
+    [/^enable\b(?!-)/i, parseEnable],
+    [/^disable(-line|-next(-line)?)?\b(?!-)/i, parseDisable],
+    [/^words?\b/i, parseWords],
+    [/^ignore(?:-?words?)?\b/i, parseIgnoreWords],
+    [/^(?:flag|forbid)(?:-?words?)?\b/i, parseFlagWords],
+    [/^ignore_?Reg_?Exp\s+.+$/i, parseIgnoreRegExp],
+    [/^include_?Reg_?Exp\s+.+$/i, parseIncludeRegExp],
+    [/^locale?\b/i, parseLocale],
+    [/^language\s/i, parseLocale],
+    [/^dictionar(?:y|ies)\b/i, parseDictionaries],
+    [/^LocalWords:/, (w) => parseWords(w.replace(/^LocalWords:?/gi, ' '))],
+];
+exports.regExSpellingGuardBlock = /(\bc?spell(?:-?checker)?::?)\s*disable(?!-line|-next)\b[\s\S]*?((?:\1\s*enable\b)|$)/gi;
+exports.regExSpellingGuardNext = /\bc?spell(?:-?checker)?::?\s*disable-next\b.*\s\s?.*/gi;
+exports.regExSpellingGuardLine = /^.*\bc?spell(?:-?checker)?::?\s*disable-line\b.*/gim;
+const issueMessages = {
+    unknownDirective: 'Unknown CSpell directive',
+};
+function parseSettingMatchValidation(matchArray) {
+    const [fullMatch = ''] = matchArray;
+    const directiveMatch = fullMatch.match(regExCSpellDirectiveKey);
+    if (!directiveMatch)
+        return undefined;
+    const match = directiveMatch[1];
+    const possibleSetting = match.trim();
+    if (!possibleSetting)
+        return undefined;
+    const start = (matchArray.index || 0) + (directiveMatch.index || 0) + (match.length - match.trimStart().length);
+    const text = possibleSetting.replace(/^([-\w]+)?.*/, '$1');
+    const end = start + text.length;
+    if (!text)
+        return undefined;
+    const matchingParsers = settingParsers.filter(([regex]) => regex.test(possibleSetting));
+    if (matchingParsers.length > 0)
+        return undefined;
+    // No matches were found, let make some suggestions.
+    const dictSugs = dictInDocSettings
+        .suggest(text, { ignoreCase: false })
+        .map((sug) => sug.word)
+        .filter((a) => !noSuggestDirectives.has(a));
+    const sugs = new Set((0, cspell_pipe_1.pipeSync)(dictSugs, (0, cspell_pipe_1.opAppend)(allDirectives)));
+    const suggestions = [...sugs].slice(0, 8);
+    const issue = {
+        range: [start, end],
+        text,
+        message: issueMessages.unknownDirective,
+        suggestions,
+    };
+    return issue;
+}
 function parseSettingMatch(matchArray) {
     const [, match = ''] = matchArray;
     const possibleSetting = match.trim();
-    const settingParsers = [
-        [/^(?:enable|disable)(?:allow)?CompoundWords/i, parseCompoundWords],
-        [/^(?:enable|disable)CaseSensitive/i, parseCaseSensitive],
-        [/^words?\s/i, parseWords],
-        [/^ignore(?:words?)?\s/i, parseIgnoreWords],
-        [/^ignore_?Reg_?Exp\s+.+$/i, parseIgnoreRegExp],
-        [/^include_?Reg_?Exp\s+.+$/i, parseIncludeRegExp],
-        [/^locale?\s/i, parseLocale],
-        [/^language\s/i, parseLocale],
-        [/^dictionaries\s/i, parseDictionaries],
-        [/^LocalWords:/, (w) => parseWords(w.replace(/LocalWords:?/gi, ' '))],
-    ];
     return settingParsers
         .filter(([regex]) => regex.test(possibleSetting))
         .map(([, fn]) => fn)
@@ -72,7 +173,11 @@ function parseCaseSensitive(match) {
     return { id: 'in-doc-caseSensitive', caseSensitive };
 }
 function parseWords(match) {
-    const words = match.split(/[,\s]+/g).slice(1);
+    const words = match
+        // .replace(/[@#$%^&={}/"]/g, ' ')
+        .split(/[,\s;]+/g)
+        .slice(1)
+        .filter((a) => !!a);
     return { id: 'in-doc-words', words };
 }
 function parseLocale(match) {
@@ -84,6 +189,10 @@ function parseIgnoreWords(match) {
     const wordsSetting = parseWords(match);
     return (0, util_1.clean)({ id: 'in-doc-ignore', ignoreWords: wordsSetting.words });
 }
+function parseFlagWords(match) {
+    const wordsSetting = parseWords(match);
+    return (0, util_1.clean)({ id: 'in-doc-forbid', flagWords: wordsSetting.words });
+}
 function parseRegEx(match) {
     const patterns = [match.replace(/^[^\s]+\s+/, '')].map((a) => {
         const m = a.match(regExMatchRegEx);
@@ -113,6 +222,14 @@ function getWordsFromDocument(text) {
     const { words = EmptyWords } = getInDocumentSettings(text);
     return words;
 }
+function parseEnable(_match) {
+    // Do nothing. Enable / Disable is handled in a different way.
+    return {};
+}
+function parseDisable(_match) {
+    // Do nothing. Enable / Disable is handled in a different way.
+    return {};
+}
 function getIgnoreWordsFromDocument(text) {
     const { ignoreWords = EmptyWords } = getInDocumentSettings(text);
     return ignoreWords;

package/dist/Settings/RegExpPatterns.js

@@ -12,7 +12,7 @@ exports.regExCStyleHexValue = /\b0x[0-9a-f]+\b/gi;
 exports.regExCSSHexValue = /#[0-9a-f]{3,8}\b/gi;
 exports.regExUUID = /\b[0-9a-fx]{8}-[0-9a-fx]{4}-[0-9a-fx]{4}-[0-9a-fx]{4}-[0-9a-fx]{12}\b/gi; // x - represents placeholder values
 exports.regExUnicodeRef = /\bU\+[0-9a-f]{4,5}(?:-[0-9a-f]{4,5})?/gi;
-exports.regExSpellingGuardBlock = /(\bc?spell(?:-?checker)?::?)\s*disable(?!-line|-next)\b[\s\S]*?((?:\1\s*enable\b)|$)/gi;
+exports.regExSpellingGuardBlock = /(\bc?spell(?:-?checker)?::?)\s*disable(?!-line|-next)\b(?!-)[\s\S]*?((?:\1\s*enable\b)|$)/gi;
 exports.regExSpellingGuardNext = /\bc?spell(?:-?checker)?::?\s*disable-next\b.*\s\s?.*/gi;
 exports.regExSpellingGuardLine = /^.*\bc?spell(?:-?checker)?::?\s*disable-line\b.*/gim;
 exports.regExIgnoreSpellingDirectives = /\bc?spell(?:-?checker)?::?\s*ignoreRegExp.*/gim;

package/dist/Settings/index.d.ts

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

package/dist/Settings/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportError = exports.getDefaultBundledSettings = 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");
+var configLoader_1 = require("./Controller/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; } });
@@ -29,6 +29,6 @@ Object.defineProperty(exports, "mergeSettings", { enumerable: true, get: functio
 var DefaultSettings_1 = require("./DefaultSettings");
 Object.defineProperty(exports, "getDefaultSettings", { enumerable: true, get: function () { return DefaultSettings_1.getDefaultSettings; } });
 Object.defineProperty(exports, "getDefaultBundledSettings", { enumerable: true, get: function () { return DefaultSettings_1.getDefaultBundledSettings; } });
-var ImportError_1 = require("./ImportError");
+var ImportError_1 = require("./Controller/ImportError");
 Object.defineProperty(exports, "ImportError", { enumerable: true, get: function () { return ImportError_1.ImportError; } });
 //# sourceMappingURL=index.js.map

package/dist/Settings/link.js

@@ -27,7 +27,7 @@ exports.__testing__ = exports.removePathsFromGlobalImports = exports.addPathsToG
 const fs = __importStar(require("fs"));
 const Path = __importStar(require("path"));
 const util_1 = require("../util/util");
-const configLoader_1 = require("./configLoader");
+const configLoader_1 = require("./Controller/configLoader");
 const GlobalSettings_1 = require("./GlobalSettings");
 function listGlobalImports() {
     const globalSettings = (0, GlobalSettings_1.getRawGlobalSettings)();

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

@@ -0,0 +1,30 @@
+import { CSpellIO } from 'cspell-io';
+import { DictionaryDefinitionInternal } from '../../Models/CSpellSettingsInternalDef';
+import { SpellingDictionary } from '../SpellingDictionary';
+export declare type LoadOptions = DictionaryDefinitionInternal;
+export declare class DictionaryLoader {
+    private cspellIO;
+    private dictionaryCache;
+    private dictionaryCacheByDef;
+    private reader;
+    private readerSync;
+    constructor(cspellIO: CSpellIO);
+    loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
+    loadDictionarySync(def: DictionaryDefinitionInternal): SpellingDictionary;
+    /**
+     * Check to see if any of the cached dictionaries have changed. If one has changed, reload it.
+     * @param maxAge - Only check the dictionary if it has been at least `maxAge` ms since the last check.
+     * @param now - optional timestamp representing now. (Mostly used in testing)
+     */
+    refreshCacheEntries(maxAge?: number, now?: number): Promise<void>;
+    private getCacheEntry;
+    private setCacheEntry;
+    private refreshEntry;
+    private loadEntry;
+    private loadEntrySync;
+    private getStat;
+    private getStatSync;
+    private isEqual;
+    private normalizeOptions;
+}
+//# sourceMappingURL=DictionaryLoader.d.ts.map