cspell-lib 6.22.0 → 6.23.0

package/dist/LanguageIds.js

@@ -8,6 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLanguagesForBasename = exports.getLanguagesForExt = exports.buildLanguageExtensionMapSet = exports.isGenerated = exports.isGeneratedFile = exports.isGeneratedExt = exports.isBinary = exports.isBinaryFile = exports.isBinaryExt = exports.languageIds = exports.generatedFiles = exports.binaryLanguages = exports.languageExtensionDefinitions = void 0;
+const AutoResolve_1 = require("./util/AutoResolve");
 exports.languageExtensionDefinitions = [
     { id: 'ada', extensions: ['.adb', '.ads'] },
     { id: 'apiblueprint', extensions: ['.apib', '.apiblueprint'] },
@@ -276,16 +277,8 @@ function doesSetContainAnyOf(setOfIds, languageId) {
 }
 function buildLanguageExtensionMapSet(defs) {
     return defs.reduce((map, def) => {
-        function getMapSet(value) {
-            const found = map.get(value);
-            if (found)
-                return found;
-            const s = new Set();
-            map.set(value, s);
-            return s;
-        }
         function addId(value) {
-            getMapSet(value).add(def.id);
+            (0, AutoResolve_1.autoResolve)(map, value, () => new Set()).add(def.id);
         }
         def.extensions.forEach(addId);
         def.filenames?.forEach(addId);

package/dist/Models/CSpellSettingsInternalDef.d.ts

@@ -1,4 +1,4 @@
-import type { AdvancedCSpellSettingsWithSourceTrace, CSpellSettingsWithSourceTrace, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionPreferred, Parser } from '@cspell/cspell-types';
+import type { AdvancedCSpellSettingsWithSourceTrace, CSpellSettingsWithSourceTrace, DictionaryDefinition, DictionaryDefinitionAugmented, DictionaryDefinitionCustom, DictionaryDefinitionInline, DictionaryDefinitionPreferred, Parser } from '@cspell/cspell-types';
 import type { WeightMap } from 'cspell-trie-lib';
 import type { OptionalOrUndefined } from '../util/types';
 export declare const SymbolCSpellSettingsInternal: unique symbol;
@@ -13,7 +13,12 @@ export interface CSpellSettingsInternalFinalized extends CSpellSettingsInternal
     includeRegExpList: RegExp[];
 }
 type DictionaryDefinitionCustomUniqueFields = Omit<DictionaryDefinitionCustom, keyof DictionaryDefinitionPreferred>;
-export interface DictionaryDefinitionInternal extends Readonly<DictionaryDefinitionPreferred>, Readonly<Partial<DictionaryDefinitionCustomUniqueFields>>, Readonly<DictionaryDefinitionAugmented> {
+export type DictionaryDefinitionInternal = DictionaryFileDefinitionInternal | DictionaryDefinitionInlineInternal;
+export type DictionaryDefinitionInlineInternal = DictionaryDefinitionInline & {
+    /** The path to the config file that contains this dictionary definition */
+    readonly __source?: string | undefined;
+};
+export interface DictionaryFileDefinitionInternal extends Readonly<DictionaryDefinitionPreferred>, Readonly<Partial<DictionaryDefinitionCustomUniqueFields>>, Readonly<DictionaryDefinitionAugmented> {
     /**
      * Optional weight map used to improve suggestions.
      */
@@ -21,10 +26,14 @@ export interface DictionaryDefinitionInternal extends Readonly<DictionaryDefinit
     /** The path to the config file that contains this dictionary definition */
     readonly __source?: string | undefined;
 }
-export interface DictionaryDefinitionInternalWithSource extends DictionaryDefinitionInternal {
+export interface DictionaryFileDefinitionInternalWithSource extends DictionaryFileDefinitionInternal {
     readonly __source: string;
 }
+export type DictionaryDefinitionInternalWithSource = DictionaryDefinitionInternal & {
+    readonly __source: string;
+};
 export declare function createCSpellSettingsInternal(parts?: OptionalOrUndefined<Partial<CSpellSettingsInternal>>): CSpellSettingsInternal;
 export declare function isCSpellSettingsInternal(cs: CSpellSettingsInternal | CSpellSettingsWithSourceTrace | OptionalOrUndefined<CSpellSettingsInternal | CSpellSettingsWithSourceTrace>): cs is CSpellSettingsInternal;
+export declare function isDictionaryDefinitionInlineInternal(def: DictionaryDefinitionInternal | DictionaryDefinitionInline | DictionaryDefinition): def is DictionaryDefinitionInlineInternal;
 export {};
 //# sourceMappingURL=CSpellSettingsInternalDef.d.ts.map

package/dist/Models/CSpellSettingsInternalDef.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCSpellSettingsInternal = exports.createCSpellSettingsInternal = exports.SymbolCSpellSettingsInternal = void 0;
+exports.isDictionaryDefinitionInlineInternal = exports.isCSpellSettingsInternal = exports.createCSpellSettingsInternal = exports.SymbolCSpellSettingsInternal = void 0;
 const util_1 = require("../util/util");
 exports.SymbolCSpellSettingsInternal = Symbol('CSpellSettingsInternal');
 function createCSpellSettingsInternal(parts = {}) {
@@ -14,4 +14,11 @@ function isCSpellSettingsInternal(cs) {
     return !!cs[exports.SymbolCSpellSettingsInternal];
 }
 exports.isCSpellSettingsInternal = isCSpellSettingsInternal;
+function isDictionaryDefinitionInlineInternal(def) {
+    if (def.path)
+        return false;
+    const defInline = def;
+    return !!(defInline.words || defInline.flagWords || defInline.ignoreWords);
+}
+exports.isDictionaryDefinitionInlineInternal = isDictionaryDefinitionInlineInternal;
 //# sourceMappingURL=CSpellSettingsInternalDef.js.map

package/dist/Settings/CSpellSettingsServer.js

@@ -31,6 +31,7 @@ const assert_1 = __importDefault(require("assert"));
 const cspell_glob_1 = require("cspell-glob");
 const path = __importStar(require("path"));
 const CSpellSettingsInternalDef_1 = require("../Models/CSpellSettingsInternalDef");
+const AutoResolve_1 = require("../util/AutoResolve");
 const util = __importStar(require("../util/util"));
 const constants_1 = require("./constants");
 const DictionarySettings_1 = require("./DictionarySettings");
@@ -310,7 +311,9 @@ function mergeImportRefs(left, right = {}) {
 function extractDependencies(settings) {
     const settingsI = toInternalSettings(settings);
     const configFiles = [...(mergeImportRefs(settingsI) || [])].map(([filename]) => filename);
-    const dictionaryFiles = (0, DictionarySettings_1.calcDictionaryDefsToLoad)(settingsI).map((dict) => dict.path);
+    const dictionaryFiles = (0, DictionarySettings_1.calcDictionaryDefsToLoad)(settingsI)
+        .map((dict) => dict.path)
+        .filter(util.isDefined);
     return {
         configFiles,
         dictionaryFiles,
@@ -334,26 +337,24 @@ function resolveParser(settings) {
     (0, assert_1.default)(parser, `Parser "${parserName}" not found.`);
     return parser;
 }
-const parserCache = new WeakMap();
+const parserCache = new AutoResolve_1.AutoResolveWeakCache();
 const emptyParserMap = new Map();
+function* parsers(plugins) {
+    for (const plugin of plugins) {
+        if (!plugin.parsers)
+            continue;
+        for (const parser of plugin.parsers) {
+            yield [parser.name, parser];
+        }
+    }
+}
+function mapPlugins(plugins) {
+    return new Map(parsers(plugins));
+}
 function extractParsers(plugins) {
     if (!plugins || !plugins.length)
         return emptyParserMap;
-    const found = parserCache.get(plugins);
-    if (found)
-        return found;
-    function* parsers(plugins) {
-        for (const plugin of plugins) {
-            if (!plugin.parsers)
-                continue;
-            for (const parser of plugin.parsers) {
-                yield [parser.name, parser];
-            }
-        }
-    }
-    const map = new Map(parsers(plugins));
-    parserCache.set(plugins, map);
-    return map;
+    return parserCache.get(plugins, mapPlugins);
 }
 exports.__testing__ = {
     mergeObjects,

package/dist/Settings/Controller/configLoader/normalizeRawSettings.d.ts

@@ -16,9 +16,6 @@ export declare function normalizeDictionaryDefs(settings: NormalizeDictionaryDef
         name?: string;
         description?: string;
         enabled?: boolean;
-        words?: string[];
-        flagWords?: string[];
-        ignoreWords?: string[];
         allowCompoundWords?: boolean;
         caseSensitive?: boolean;
         dictionaries?: string[];
@@ -26,6 +23,9 @@ export declare function normalizeDictionaryDefs(settings: NormalizeDictionaryDef
         ignoreRegExpList?: import("@cspell/cspell-types").RegExpPatternList;
         includeRegExpList?: import("@cspell/cspell-types").RegExpPatternList;
         patterns?: import("@cspell/cspell-types").RegExpPatternDefinition[];
+        words?: string[];
+        flagWords?: string[];
+        ignoreWords?: string[];
         parser?: string;
     }>[] | undefined;
 }>;

package/dist/Settings/DictionarySettings.d.ts

@@ -1,5 +1,5 @@
 import type { DictionaryDefinition } from '@cspell/cspell-types';
-import type { CSpellSettingsInternal, DictionaryDefinitionInternal, DictionaryDefinitionInternalWithSource } from '../Models/CSpellSettingsInternalDef';
+import type { CSpellSettingsInternal, DictionaryDefinitionInternal, DictionaryDefinitionInternalWithSource, DictionaryFileDefinitionInternalWithSource } from '../Models/CSpellSettingsInternalDef';
 import type { DictionaryReferenceCollection } from './DictionaryReferenceCollection';
 export type DefMapArrayItem = [string, DictionaryDefinitionInternal];
 /**
@@ -19,7 +19,9 @@ export declare function mapDictDefsToInternal(defs: undefined, pathToSettingsFil
 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[];
+export declare function isDictionaryDefinitionWithSource(d: DictionaryDefinition | DictionaryDefinitionInternalWithSource): d is DictionaryDefinitionInternalWithSource;
 export declare function isDictionaryDefinitionInternal(def: DictionaryDefinition | DictionaryDefinitionInternal): def is DictionaryDefinitionInternal;
+export declare function isDictionaryFileDefinitionInternalWithSource(def: DictionaryDefinition | DictionaryDefinitionInternal): def is DictionaryFileDefinitionInternalWithSource;
+export declare function isDictionaryDefinitionInlineInternalWithSource(def: DictionaryDefinition | DictionaryDefinitionInternal): def is DictionaryDefinitionInternalWithSource;
 //# sourceMappingURL=DictionarySettings.d.ts.map

package/dist/Settings/DictionarySettings.js

@@ -23,9 +23,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDictionaryDefinitionInternal = exports.calcDictionaryDefsToLoad = exports.isDictionaryDefinitionWithSource = exports.mapDictDefToInternal = exports.mapDictDefsToInternal = exports.filterDictDefsToLoad = void 0;
+exports.isDictionaryDefinitionInlineInternalWithSource = exports.isDictionaryFileDefinitionInternalWithSource = exports.isDictionaryDefinitionInternal = exports.isDictionaryDefinitionWithSource = exports.calcDictionaryDefsToLoad = exports.mapDictDefToInternal = exports.mapDictDefsToInternal = exports.filterDictDefsToLoad = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const path = __importStar(require("path"));
+const CSpellSettingsInternalDef_1 = require("../Models/CSpellSettingsInternalDef");
+const AutoResolve_1 = require("../util/AutoResolve");
 const resolveFile_1 = require("../util/resolveFile");
 const util_1 = require("../util/util");
 const DictionaryReferenceCollection_1 = require("./DictionaryReferenceCollection");
@@ -65,17 +67,20 @@ function mapDictDefsToInternal(defs, pathToSettingsFile) {
     return defs?.map((def) => mapDictDefToInternal(def, pathToSettingsFile));
 }
 exports.mapDictDefsToInternal = mapDictDefsToInternal;
+const internalDefs = new AutoResolve_1.AutoResolveWeakCache();
 function mapDictDefToInternal(def, pathToSettingsFile) {
+    return internalDefs.get(def, (def) => _mapDictDefToInternal(def, pathToSettingsFile));
+}
+exports.mapDictDefToInternal = mapDictDefToInternal;
+function _mapDictDefToInternal(def, pathToSettingsFile) {
     if (isDictionaryDefinitionWithSource(def)) {
         return def;
     }
+    if ((0, CSpellSettingsInternalDef_1.isDictionaryDefinitionInlineInternal)(def)) {
+        return { ...def, __source: pathToSettingsFile };
+    }
     return new _DictionaryDefinitionInternalWithSource(def, pathToSettingsFile);
 }
-exports.mapDictDefToInternal = mapDictDefToInternal;
-function isDictionaryDefinitionWithSource(d) {
-    return d instanceof _DictionaryDefinitionInternalWithSource;
-}
-exports.isDictionaryDefinitionWithSource = isDictionaryDefinitionWithSource;
 function determineName(filename, options) {
     return options.name || path.basename(filename);
 }
@@ -92,10 +97,22 @@ function calcDictionaryDefsToLoad(settings) {
     return filterDictDefsToLoad(colDicts, modDefs);
 }
 exports.calcDictionaryDefsToLoad = calcDictionaryDefsToLoad;
+function isDictionaryDefinitionWithSource(d) {
+    return isDictionaryFileDefinitionInternalWithSource(d) || isDictionaryDefinitionInlineInternalWithSource(d);
+}
+exports.isDictionaryDefinitionWithSource = isDictionaryDefinitionWithSource;
 function isDictionaryDefinitionInternal(def) {
     return def instanceof _DictionaryDefinitionInternalWithSource;
 }
 exports.isDictionaryDefinitionInternal = isDictionaryDefinitionInternal;
+function isDictionaryFileDefinitionInternalWithSource(def) {
+    return def instanceof _DictionaryDefinitionInternalWithSource;
+}
+exports.isDictionaryFileDefinitionInternalWithSource = isDictionaryFileDefinitionInternalWithSource;
+function isDictionaryDefinitionInlineInternalWithSource(def) {
+    return (0, CSpellSettingsInternalDef_1.isDictionaryDefinitionInlineInternal)(def) && !!def.__source;
+}
+exports.isDictionaryDefinitionInlineInternalWithSource = isDictionaryDefinitionInlineInternalWithSource;
 class _DictionaryDefinitionInternalWithSource {
     constructor(def, __source) {
         this.__source = __source;

package/dist/Settings/InDocSettings.js

@@ -87,7 +87,7 @@ const allDirectives = new Set(preferredDirectives.concat(officialDirectives));
 const allDirectiveSuggestions = [
     ...(0, sync_1.pipeSync)(allDirectives, (0, sync_1.opMap)((word) => ({ word }))),
 ];
-const dictInDocSettings = (0, SpellingDictionary_1.getSpellDictInterface)().createSpellingDictionary(allDirectives, 'Directives', 'Directive List', {
+const dictInDocSettings = (0, SpellingDictionary_1.createSpellingDictionary)(allDirectives, 'Directives', 'Directive List', {
     supportNonStrictSearches: false,
 });
 const EmptyWords = [];

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

@@ -5,6 +5,7 @@ export type LoadOptions = DictionaryDefinitionInternal;
 export declare class DictionaryLoader {
     private cspellIO;
     private dictionaryCache;
+    private inlineDictionaryCache;
     private dictionaryCacheByDef;
     private reader;
     private readerSync;
@@ -26,5 +27,6 @@ export declare class DictionaryLoader {
     private getStatSync;
     private isEqual;
     private normalizeOptions;
+    private loadInlineDict;
 }
 //# sourceMappingURL=DictionaryLoader.d.ts.map

package/dist/SpellingDictionary/DictionaryController/DictionaryLoader.js

@@ -4,6 +4,8 @@ exports.DictionaryLoader = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
 const strong_weak_map_1 = require("@cspell/strong-weak-map");
 const cspell_dictionary_1 = require("cspell-dictionary");
+const CSpellSettingsInternalDef_1 = require("../../Models/CSpellSettingsInternalDef");
+const AutoResolve_1 = require("../../util/AutoResolve");
 const errors_1 = require("../../util/errors");
 const SpellingDictionaryError_1 = require("../SpellingDictionaryError");
 const MAX_AGE = 10000;
@@ -30,11 +32,15 @@ class DictionaryLoader {
     constructor(cspellIO) {
         this.cspellIO = cspellIO;
         this.dictionaryCache = new strong_weak_map_1.StrongWeakMap();
+        this.inlineDictionaryCache = new AutoResolve_1.AutoResolveWeakCache();
         this.dictionaryCacheByDef = new strong_weak_map_1.StrongWeakMap();
         this.reader = toReader(cspellIO);
         this.readerSync = toReaderSync(cspellIO);
     }
     loadDictionary(def) {
+        if ((0, CSpellSettingsInternalDef_1.isDictionaryDefinitionInlineInternal)(def)) {
+            return Promise.resolve(this.loadInlineDict(def));
+        }
         const { key, entry } = this.getCacheEntry(def);
         if (entry) {
             return entry.pending.then(([dictionary]) => dictionary);
@@ -44,6 +50,9 @@ class DictionaryLoader {
         return loadedEntry.pending.then(([dictionary]) => dictionary);
     }
     loadDictionarySync(def) {
+        if ((0, CSpellSettingsInternalDef_1.isDictionaryDefinitionInlineInternal)(def)) {
+            return this.loadInlineDict(def);
+        }
         const { key, entry } = this.getCacheEntry(def);
         if (entry?.dictionary && entry.loadingState === LoadingState.Loaded) {
             return entry.dictionary;
@@ -179,6 +188,9 @@ class DictionaryLoader {
             return options;
         return { ...options, name: this.cspellIO.uriBasename(uri) };
     }
+    loadInlineDict(def) {
+        return this.inlineDictionaryCache.get(def, (def) => (0, cspell_dictionary_1.createInlineSpellingDictionary)(def, def.__source || 'memory'));
+    }
 }
 exports.DictionaryLoader = DictionaryLoader;
 function toReader(cspellIO) {

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -1,15 +1,4 @@
-import * as cspellDictModule from 'cspell-dictionary';
-export { CompoundWordsMethod } from 'cspell-trie-lib';
-declare const SpellingDictionaryModule: {
-    readonly createCollection: typeof cspellDictModule.createCollection;
-    readonly createForbiddenWordsDictionary: typeof cspellDictModule.createFlagWordsDictionary;
-    readonly createSpellingDictionary: typeof cspellDictModule.createSpellingDictionary;
-    readonly createIgnoreWordsDictionary: typeof cspellDictModule.createIgnoreWordsDictionary;
-    readonly createSpellingDictionaryFromTrieFile: typeof cspellDictModule.createSpellingDictionaryFromTrieFile;
-};
-type SpellDictInterface = typeof SpellingDictionaryModule;
 export type { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from 'cspell-dictionary';
-export declare function getSpellDictInterface(): SpellDictInterface;
-export declare const createSpellingDictionary: typeof cspellDictModule.createSpellingDictionary;
-export declare const createCollection: typeof cspellDictModule.createCollection;
+export { createCollection, createInlineSpellingDictionary, createSpellingDictionary } from 'cspell-dictionary';
+export { CompoundWordsMethod } from 'cspell-trie-lib';
 //# sourceMappingURL=SpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionary.js

@@ -1,43 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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.createCollection = exports.createSpellingDictionary = exports.getSpellDictInterface = exports.CompoundWordsMethod = void 0;
-const cspellDictModule = __importStar(require("cspell-dictionary"));
+exports.CompoundWordsMethod = exports.createSpellingDictionary = exports.createInlineSpellingDictionary = exports.createCollection = void 0;
+var cspell_dictionary_1 = require("cspell-dictionary");
+Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return cspell_dictionary_1.createCollection; } });
+Object.defineProperty(exports, "createInlineSpellingDictionary", { enumerable: true, get: function () { return cspell_dictionary_1.createInlineSpellingDictionary; } });
+Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return cspell_dictionary_1.createSpellingDictionary; } });
 var cspell_trie_lib_1 = require("cspell-trie-lib");
 Object.defineProperty(exports, "CompoundWordsMethod", { enumerable: true, get: function () { return cspell_trie_lib_1.CompoundWordsMethod; } });
-const SpellingDictionaryModule = {
-    createCollection: cspellDictModule.createCollection,
-    createForbiddenWordsDictionary: cspellDictModule.createForbiddenWordsDictionary,
-    createSpellingDictionary: cspellDictModule.createSpellingDictionary,
-    createIgnoreWordsDictionary: cspellDictModule.createIgnoreWordsDictionary,
-    createSpellingDictionaryFromTrieFile: cspellDictModule.createSpellingDictionaryFromTrieFile,
-};
-function getSpellDictInterface() {
-    return SpellingDictionaryModule;
-}
-exports.getSpellDictInterface = getSpellDictInterface;
-exports.createSpellingDictionary = getSpellDictInterface().createSpellingDictionary;
-exports.createCollection = getSpellDictInterface().createCollection;
 //# sourceMappingURL=SpellingDictionary.js.map

package/dist/util/AutoResolve.d.ts

@@ -0,0 +1,21 @@
+export declare function autoResolve<K, V>(map: Map<K, V>, key: K, resolve: (k: K) => V): V;
+export declare class AutoResolveCache<K, V> {
+    readonly map: Map<K, V>;
+    get(k: K): V | undefined;
+    get(k: K, resolve: (k: K) => V): V;
+    get(k: K, resolve?: (k: K) => V): V | undefined;
+    has(k: K): boolean;
+    set(k: K, v: V): this;
+}
+export declare function createAutoResolveCache<K, V>(): AutoResolveCache<K, V>;
+export declare function autoResolveWeak<K extends object, V>(map: WeakMap<K, V>, key: K, resolve: (k: K) => V): V;
+export declare class AutoResolveWeakCache<K extends object, V> {
+    readonly map: WeakMap<K, V>;
+    get(k: K): V | undefined;
+    get(k: K, resolve: (k: K) => V): V;
+    get(k: K, resolve?: (k: K) => V): V | undefined;
+    has(k: K): boolean;
+    set(k: K, v: V): this;
+}
+export declare function createAutoResolveWeakCache<K extends object, V>(): AutoResolveWeakCache<K, V>;
+//# sourceMappingURL=AutoResolve.d.ts.map

package/dist/util/AutoResolve.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAutoResolveWeakCache = exports.AutoResolveWeakCache = exports.autoResolveWeak = exports.createAutoResolveCache = exports.AutoResolveCache = exports.autoResolve = void 0;
+function autoResolve(map, key, resolve) {
+    const found = map.get(key);
+    if (found !== undefined || map.has(key))
+        return found;
+    const value = resolve(key);
+    map.set(key, value);
+    return value;
+}
+exports.autoResolve = autoResolve;
+class AutoResolveCache {
+    constructor() {
+        this.map = new Map();
+    }
+    get(k, resolve) {
+        return resolve ? autoResolve(this.map, k, resolve) : this.map.get(k);
+    }
+    has(k) {
+        return this.map.has(k);
+    }
+    set(k, v) {
+        this.map.set(k, v);
+        return this;
+    }
+}
+exports.AutoResolveCache = AutoResolveCache;
+function createAutoResolveCache() {
+    return new AutoResolveCache();
+}
+exports.createAutoResolveCache = createAutoResolveCache;
+function autoResolveWeak(map, key, resolve) {
+    const found = map.get(key);
+    if (found !== undefined || map.has(key))
+        return found;
+    const value = resolve(key);
+    map.set(key, value);
+    return value;
+}
+exports.autoResolveWeak = autoResolveWeak;
+class AutoResolveWeakCache {
+    constructor() {
+        this.map = new WeakMap();
+    }
+    get(k, resolve) {
+        return resolve ? autoResolveWeak(this.map, k, resolve) : this.map.get(k);
+    }
+    has(k) {
+        return this.map.has(k);
+    }
+    set(k, v) {
+        this.map.set(k, v);
+        return this;
+    }
+}
+exports.AutoResolveWeakCache = AutoResolveWeakCache;
+function createAutoResolveWeakCache() {
+    return new AutoResolveWeakCache();
+}
+exports.createAutoResolveWeakCache = createAutoResolveWeakCache;
+//# sourceMappingURL=AutoResolve.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.22.0",
+  "version": "6.23.0",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,19 +48,19 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "6.22.0",
-    "@cspell/cspell-pipe": "6.22.0",
-    "@cspell/cspell-types": "6.22.0",
-    "@cspell/strong-weak-map": "6.22.0",
+    "@cspell/cspell-bundled-dicts": "6.23.0",
+    "@cspell/cspell-pipe": "6.23.0",
+    "@cspell/cspell-types": "6.23.0",
+    "@cspell/strong-weak-map": "6.23.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^5.0.1",
     "cosmiconfig": "^8.0.0",
-    "cspell-dictionary": "6.22.0",
-    "cspell-glob": "6.22.0",
-    "cspell-grammar": "6.22.0",
-    "cspell-io": "6.22.0",
-    "cspell-trie-lib": "6.22.0",
+    "cspell-dictionary": "6.23.0",
+    "cspell-glob": "6.23.0",
+    "cspell-grammar": "6.23.0",
+    "cspell-io": "6.23.0",
+    "cspell-trie-lib": "6.23.0",
     "fast-equals": "^4.0.3",
     "find-up": "^5.0.0",
     "gensequence": "^4.0.3",
@@ -84,13 +84,13 @@
     "@cspell/dict-python": "^4.0.1",
     "@types/configstore": "^5.0.1",
     "@types/jest": "^29.4.0",
-    "@types/node": "^18.11.19",
+    "@types/node": "^18.13.0",
     "cspell-dict-nl-nl": "^1.1.2",
-    "jest": "^29.4.1",
+    "jest": "^29.4.2",
     "lorem-ipsum": "^2.0.8",
     "rollup": "^3.14.0",
     "rollup-plugin-dts": "^5.1.1",
     "ts-jest": "^29.0.5"
   },
-  "gitHead": "a133874ed7590cbe140f5067cfa80db84b644a5d"
+  "gitHead": "a7cfbfa6cf42c9d9746dd8229d9f1317472e5af8"
 }