cspell-lib 8.2.1 → 8.2.4

package/dist/esm/Models/TextDocument.js

@@ -1,6 +1,6 @@
 import assert from 'assert';
-import { promises as fs } from 'fs';
 import { TextDocument as VsTextDocument } from 'vscode-languageserver-textdocument';
+import { getFileSystem } from '../fileSystem.js';
 import { getLanguagesForBasename } from '../LanguageIds.js';
 import * as Uri from '../util/Uri.js';
 class TextDocumentImpl {
@@ -103,8 +103,9 @@ function isTextDocumentImpl(doc) {
 }
 export async function loadTextDocument(filename, languageId) {
     const uri = Uri.toUri(filename);
-    const content = await fs.readFile(Uri.uriToFilePath(uri), 'utf8');
-    return createTextDocument({ uri, languageId, content });
+    const url = new URL(uri.toString());
+    const file = await getFileSystem().readFile(url);
+    return createTextDocument({ uri, languageId, content: file.getText() });
 }
 export const isTextDocument = isTextDocumentImpl;
 //# sourceMappingURL=TextDocument.js.map

package/dist/esm/Settings/Controller/configLoader/configLoader.js

@@ -5,7 +5,7 @@ import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { URI, Utils as UriUtils } from 'vscode-uri';
 import { onClearCache } from '../../../events/index.js';
-import { createTextFileResource, getVirtualFS } from '../../../fileSystem.js';
+import { getVirtualFS } from '../../../fileSystem.js';
 import { createCSpellSettingsInternal as csi } from '../../../Models/CSpellSettingsInternalDef.js';
 import { AutoResolveCache } from '../../../util/AutoResolve.js';
 import { logError, logWarning } from '../../../util/logger.js';
@@ -321,6 +321,8 @@ export class ConfigLoader {
     async resolveFilename(filename, relativeTo) {
         if (filename instanceof URL)
             return { filename: toFilePathOrHref(filename) };
+        if (isUrlLike(filename))
+            return { filename: toFilePathOrHref(filename) };
         const r = await this.fileResolver.resolveFile(filename, relativeTo);
         if (r.warning) {
             logWarning(r.warning);
@@ -406,7 +408,7 @@ export function getDefaultConfigLoaderInternal() {
     return (defaultConfigLoader = createConfigLoaderInternal());
 }
 function createIO(fs) {
-    const readFile = (url) => fs.readFile(url).then((file) => ({ url: file.url, content: createTextFileResource(file).getText() }));
+    const readFile = (url) => fs.readFile(url).then((file) => ({ url: file.url, content: file.getText() }));
     const writeFile = (file) => fs.writeFile(file);
     return {
         readFile,

package/dist/esm/Settings/Controller/configLoader/configSearch.d.ts

@@ -1,4 +1,4 @@
-import { type VFileSystem } from '../../../fileSystem.js';
+import type { VFileSystem } from '../../../fileSystem.js';
 export declare class ConfigSearch {
     readonly searchPlaces: readonly string[];
     private fs;
@@ -10,6 +10,7 @@ export declare class ConfigSearch {
     private findUpConfigPath;
     private hasConfig;
     private createHasFileDirSearch;
+    private readDir;
     private createHasFileStatCheck;
     private hasConfigDir;
 }

package/dist/esm/Settings/Controller/configLoader/configSearch.js

@@ -1,5 +1,4 @@
 import { urlBasename } from 'cspell-io';
-import { createTextFileResource } from '../../../fileSystem.js';
 import { createAutoResolveCache } from '../../../util/AutoResolve.js';
 import { findUpFromUrl } from '../../../util/findUpFromUrl.js';
 export class ConfigSearch {
@@ -68,14 +67,33 @@ export class ConfigSearch {
         const dirInfoCache = createAutoResolveCache();
         const hasFile = async (filename) => {
             const dir = new URL('.', filename);
+            const parent = new URL('..', dir);
+            const parentHref = parent.href;
+            const parentInfoP = dirInfoCache.get(parentHref);
+            if (parentInfoP) {
+                const parentInfo = await parentInfoP;
+                const name = urlBasename(dir).slice(0, -1);
+                const found = parentInfo.get(name);
+                if (!found?.isDirectory() && !found?.isSymbolicLink())
+                    return false;
+            }
             const dirUrlHref = dir.href;
-            const dirInfo = await dirInfoCache.get(dirUrlHref, async () => new Map((await this.fs.readDirectory(dir).catch(() => [])).map((ent) => [ent.name, ent])));
+            const dirInfo = await dirInfoCache.get(dirUrlHref, async () => await this.readDir(dir));
             const name = urlBasename(filename);
             const found = dirInfo.get(name);
-            return !!found?.isFile();
+            return found?.isFile() || found?.isSymbolicLink() || false;
         };
         return hasFile;
     }
+    async readDir(dir) {
+        try {
+            const dirInfo = await this.fs.readDirectory(dir);
+            return new Map(dirInfo.map((ent) => [ent.name, ent]));
+        }
+        catch (e) {
+            return new Map();
+        }
+    }
     createHasFileStatCheck() {
         const hasFile = async (filename) => {
             const stat = await this.fs.stat(filename).catch(() => undefined);
@@ -102,7 +120,7 @@ export class ConfigSearch {
 }
 async function checkPackageJson(fs, filename) {
     try {
-        const file = createTextFileResource(await fs.readFile(filename));
+        const file = await fs.readFile(filename);
         const pkg = JSON.parse(file.getText());
         return typeof pkg.cspell === 'object';
     }
@@ -110,11 +128,4 @@ async function checkPackageJson(fs, filename) {
         return false;
     }
 }
-// async function isDirectory(virtualFs: VirtualFS, path: URL): Promise<boolean> {
-//     try {
-//         return (await virtualFs.fs.stat(path)).isDirectory();
-//     } catch (e) {
-//         return false;
-//     }
-// }
 //# sourceMappingURL=configSearch.js.map

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

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

package/dist/esm/Settings/Controller/index.js

@@ -1,2 +1,2 @@
-export { SettingsController } from './SettingsController.js';
+export { defaultConfigFilenames } from './configLoader/index.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/Settings/DictionarySettings.js

@@ -1,7 +1,7 @@
 import { mapDictionaryInformationToWeightMap } from 'cspell-trie-lib';
 import * as path from 'path';
 import { isDictionaryDefinitionInlineInternal } from '../Models/CSpellSettingsInternalDef.js';
-import { AutoResolveWeakCache } from '../util/AutoResolve.js';
+import { createAutoResolveWeakWeakCache } from '../util/AutoResolve.js';
 import { resolveRelativeTo } from '../util/resolveFile.js';
 import { toFilePathOrHref } from '../util/url.js';
 import { clean } from '../util/util.js';
@@ -40,7 +40,7 @@ function fixDicPath(defPath, defFile) {
 export function mapDictDefsToInternal(defs, pathToSettingsFile) {
     return defs?.map((def) => mapDictDefToInternal(def, pathToSettingsFile));
 }
-const internalDefs = new AutoResolveWeakCache();
+const internalDefs = createAutoResolveWeakWeakCache();
 export function mapDictDefToInternal(def, pathToSettingsFile) {
     return internalDefs.get(def, (def) => _mapDictDefToInternal(def, pathToSettingsFile));
 }

package/dist/esm/SpellingDictionary/Dictionaries.d.ts

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

package/dist/esm/SpellingDictionary/Dictionaries.js

@@ -1,13 +1,10 @@
 import { createCollection, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createSpellingDictionary, createSuggestDictionary, } from 'cspell-dictionary';
 import { calcDictionaryDefsToLoad } from '../Settings/DictionarySettings.js';
 import { isDefined } from '../util/util.js';
-import { loadDictionary, loadDictionarySync, refreshCacheEntries } from './DictionaryLoader.js';
+import { loadDictionary, refreshCacheEntries } from './DictionaryLoader.js';
 export function loadDictionaryDefs(defsToLoad) {
     return defsToLoad.map(loadDictionary);
 }
-export function loadDictionaryDefsSync(defsToLoad) {
-    return defsToLoad.map(loadDictionarySync);
-}
 export function refreshDictionaryCache(maxAge) {
     return refreshCacheEntries(maxAge);
 }
@@ -16,10 +13,6 @@ export async function getDictionaryInternal(settings) {
     const spellDictionaries = await Promise.all(loadDictionaryDefs(calcDictionaryDefsToLoad(settings)));
     return _getDictionaryInternal(settings, spellDictionaries);
 }
-export function getDictionaryInternalSync(settings) {
-    const spellDictionaries = loadDictionaryDefsSync(calcDictionaryDefsToLoad(settings));
-    return _getDictionaryInternal(settings, spellDictionaries);
-}
 function _getDictionaryInternal(settings, spellDictionaries) {
     const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords, suggestWords = emptyWords, } = settings;
     const settingsWordsDictionary = createSpellingDictionary(words, '[words]', 'From Settings `words`', {

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

@@ -1,16 +1,17 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
-import type { CSpellIO } from 'cspell-io';
+import type { VFileSystem } from 'cspell-io';
 import type { DictionaryDefinitionInternal } from '../../Models/CSpellSettingsInternalDef.js';
 export type LoadOptions = DictionaryDefinitionInternal;
 export declare class DictionaryLoader {
-    private cspellIO;
+    private fs;
     private dictionaryCache;
     private inlineDictionaryCache;
     private dictionaryCacheByDef;
     private reader;
-    constructor(cspellIO: CSpellIO);
+    /** The keepAliveCache is to hold onto the most recently loaded dictionaries. */
+    private keepAliveCache;
+    constructor(fs: VFileSystem, keepAliveSize?: number);
     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.
@@ -21,9 +22,7 @@ export declare class DictionaryLoader {
     private setCacheEntry;
     private refreshEntry;
     private loadEntry;
-    private loadEntrySync;
     private getStat;
-    private getStatSync;
     private isEqual;
     private normalizeOptions;
     private loadInlineDict;

package/dist/esm/SpellingDictionary/DictionaryController/DictionaryLoader.js

@@ -1,9 +1,11 @@
 import { opConcatMap, opFilter, opMap, pipe } from '@cspell/cspell-pipe/sync';
 import { StrongWeakMap } from '@cspell/strong-weak-map';
 import { createFailedToLoadDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, } from 'cspell-dictionary';
+import { compareStats, toFileURL, urlBasename } from 'cspell-io';
 import { isDictionaryDefinitionInlineInternal } from '../../Models/CSpellSettingsInternalDef.js';
-import { AutoResolveWeakCache } from '../../util/AutoResolve.js';
+import { AutoResolveWeakCache, AutoResolveWeakWeakCache } from '../../util/AutoResolve.js';
 import { toError } from '../../util/errors.js';
+import { SimpleCache } from '../../util/simpleCache.js';
 import { SpellingDictionaryLoadError } from '../SpellingDictionaryError.js';
 const MAX_AGE = 10000;
 const loaders = {
@@ -13,27 +15,23 @@ const loaders = {
     T: loadTrie,
     default: loadSimpleWordList,
 };
-const loadersSync = {
-    S: loadSimpleWordListSync,
-    C: legacyWordListSync,
-    W: wordsPerLineWordListSync,
-    T: loadTrieSync,
-    default: loadSimpleWordListSync,
-};
 var LoadingState;
 (function (LoadingState) {
     LoadingState[LoadingState["Loaded"] = 0] = "Loaded";
     LoadingState[LoadingState["Loading"] = 1] = "Loading";
 })(LoadingState || (LoadingState = {}));
 export class DictionaryLoader {
-    cspellIO;
+    fs;
     dictionaryCache = new StrongWeakMap();
     inlineDictionaryCache = new AutoResolveWeakCache();
-    dictionaryCacheByDef = new StrongWeakMap();
+    dictionaryCacheByDef = new AutoResolveWeakWeakCache();
     reader;
-    constructor(cspellIO) {
-        this.cspellIO = cspellIO;
-        this.reader = toReader(cspellIO);
+    /** The keepAliveCache is to hold onto the most recently loaded dictionaries. */
+    keepAliveCache;
+    constructor(fs, keepAliveSize = 10) {
+        this.fs = fs;
+        this.reader = toReader(fs);
+        this.keepAliveCache = new SimpleCache(keepAliveSize);
     }
     loadDictionary(def) {
         if (isDictionaryDefinitionInlineInternal(def)) {
@@ -45,20 +43,9 @@ export class DictionaryLoader {
         }
         const loadedEntry = this.loadEntry(def.path, def);
         this.setCacheEntry(key, loadedEntry, def);
+        this.keepAliveCache.set(def, loadedEntry);
         return loadedEntry.pending.then(([dictionary]) => dictionary);
     }
-    loadDictionarySync(def) {
-        if (isDictionaryDefinitionInlineInternal(def)) {
-            return this.loadInlineDict(def);
-        }
-        const { key, entry } = this.getCacheEntry(def);
-        if (entry?.dictionary && entry.loadingState === LoadingState.Loaded) {
-            return entry.dictionary;
-        }
-        const loadedEntry = this.loadEntrySync(this.cspellIO.toFileURL(def.path), def);
-        this.setCacheEntry(key, loadedEntry, def);
-        return loadedEntry.dictionary;
-    }
     /**
      * 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.
@@ -70,6 +57,7 @@ export class DictionaryLoader {
     getCacheEntry(def) {
         const defEntry = this.dictionaryCacheByDef.get(def);
         if (defEntry) {
+            this.keepAliveCache.get(def);
             return defEntry;
         }
         const key = this.calcKey(def);
@@ -77,6 +65,7 @@ export class DictionaryLoader {
         if (entry) {
             // replace old entry so it can be released.
             entry.options = def;
+            this.keepAliveCache.set(def, entry);
         }
         return { key, entry };
     }
@@ -104,9 +93,9 @@ export class DictionaryLoader {
         }
     }
     loadEntry(fileOrUri, options, now = Date.now()) {
-        const url = this.cspellIO.toFileURL(fileOrUri);
+        const url = toFileURL(fileOrUri);
         options = this.normalizeOptions(url, options);
-        const pDictionary = load(this.reader, this.cspellIO.toFileURL(fileOrUri), options).catch((e) => createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, e, 'failed to load'), options));
+        const pDictionary = load(this.reader, toFileURL(fileOrUri), options).catch((e) => createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, e, 'failed to load'), options));
         const pStat = this.getStat(fileOrUri);
         const pending = Promise.all([pDictionary, pStat]);
         const sig = now + Math.random();
@@ -129,51 +118,8 @@ export class DictionaryLoader {
         });
         return entry;
     }
-    loadEntrySync(fileOrUri, options, now = Date.now()) {
-        const url = this.cspellIO.toFileURL(fileOrUri);
-        options = this.normalizeOptions(url, options);
-        const stat = this.getStatSync(url);
-        const sig = now + Math.random();
-        try {
-            const dictionary = loadSync(this.reader, url, options);
-            const pending = Promise.resolve([dictionary, stat]);
-            return {
-                uri: url.href,
-                options,
-                ts: now,
-                stat,
-                dictionary,
-                pending,
-                loadingState: LoadingState.Loaded,
-                sig,
-            };
-        }
-        catch (e) {
-            const error = toError(e);
-            const dictionary = createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, error, 'failed to load'), options);
-            const pending = Promise.resolve([dictionary, stat]);
-            return {
-                uri: url.href,
-                options,
-                ts: now,
-                stat,
-                dictionary,
-                pending,
-                loadingState: LoadingState.Loaded,
-                sig,
-            };
-        }
-    }
     getStat(uri) {
-        return this.cspellIO.getStat(this.cspellIO.toFileURL(uri)).catch(toError);
-    }
-    getStatSync(uri) {
-        try {
-            return this.cspellIO.getStatSync(this.cspellIO.toFileURL(uri));
-        }
-        catch (e) {
-            return toError(e);
-        }
+        return this.fs.stat(toFileURL(uri)).catch(toError);
     }
     isEqual(a, b) {
         if (!b)
@@ -181,30 +127,31 @@ export class DictionaryLoader {
         if (isError(a)) {
             return isError(b) && a.message === b.message && a.name === b.name;
         }
-        return !isError(b) && !this.cspellIO.compareStats(a, b);
+        return !isError(b) && !compareStats(a, b);
     }
     normalizeOptions(uri, options) {
         if (options.name)
             return options;
-        return { ...options, name: this.cspellIO.urlBasename(uri) };
+        return { ...options, name: urlBasename(uri) };
     }
     loadInlineDict(def) {
         return this.inlineDictionaryCache.get(def, (def) => createInlineSpellingDictionary(def, def.__source || 'memory'));
     }
     calcKey(def) {
         const path = def.path;
-        const loaderType = determineType(this.cspellIO.toFileURL(path), def);
+        const loaderType = determineType(toFileURL(path), def);
         const optValues = importantOptionKeys.map((k) => def[k]?.toString() || '');
         const parts = [path, loaderType].concat(optValues);
         return parts.join('|');
     }
 }
-function toReader(cspellIO) {
+function toReader(fs) {
+    async function readFile(url) {
+        return (await fs.readFile(url)).getText();
+    }
     return {
-        read: async (filename) => (await cspellIO.readFile(filename)).getText(),
-        readLines: async (filename) => toLines((await cspellIO.readFile(filename)).getText()),
-        readSync: (filename) => cspellIO.readFileSync(filename).getText(),
-        readLinesSync: (filename) => toLines(cspellIO.readFileSync(filename).getText()),
+        read: readFile,
+        readLines: async (filename) => toLines(await readFile(filename)),
     };
 }
 const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
@@ -224,19 +171,10 @@ function load(reader, uri, options) {
     const loader = loaders[type] || loaders.default;
     return loader(reader, uri, options);
 }
-function loadSync(reader, uri, options) {
-    const type = determineType(uri, options);
-    const loader = loadersSync[type] || loaders.default;
-    return loader(reader, uri, options);
-}
 async function legacyWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
     return _legacyWordListSync(lines, filename, options);
 }
-function legacyWordListSync(reader, filename, options) {
-    const lines = reader.readLinesSync(filename);
-    return _legacyWordListSync(lines, filename, options);
-}
 function _legacyWordListSync(lines, filename, options) {
     const words = pipe(lines, 
     // Remove comments
@@ -249,10 +187,6 @@ async function wordsPerLineWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
     return _wordsPerLineWordList(lines, filename.toString(), options);
 }
-function wordsPerLineWordListSync(reader, filename, options) {
-    const lines = reader.readLinesSync(filename);
-    return _wordsPerLineWordList(lines, filename.toString(), options);
-}
 function _wordsPerLineWordList(lines, filename, options) {
     const words = pipe(lines, 
     // Remove comments
@@ -265,18 +199,10 @@ async function loadSimpleWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
     return createSpellingDictionary(lines, options.name, filename.href, options);
 }
-function loadSimpleWordListSync(reader, filename, options) {
-    const lines = reader.readLinesSync(filename);
-    return createSpellingDictionary(lines, options.name, filename.href, options);
-}
 async function loadTrie(reader, filename, options) {
     const content = await reader.read(filename);
     return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
 }
-function loadTrieSync(reader, filename, options) {
-    const content = reader.readSync(filename);
-    return createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options);
-}
 function toLines(content) {
     return content.split(/\n|\r\n|\r/);
 }

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

@@ -1,11 +1,10 @@
 import type { SpellingDictionary } from 'cspell-dictionary';
-import type { CSpellIO } from 'cspell-io';
+import type { VFileSystem } from '../fileSystem.js';
 import type { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef.js';
 import { DictionaryLoader } from './DictionaryController/index.js';
 export type { LoadOptions } from './DictionaryController/index.js';
-export declare function getDictionaryLoader(cspellIO?: CSpellIO): DictionaryLoader;
+export declare function getDictionaryLoader(vfs?: VFileSystem): DictionaryLoader;
 export declare function loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;
-export declare function 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.

package/dist/esm/SpellingDictionary/DictionaryLoader.js

@@ -1,17 +1,14 @@
-import { getCSpellIO } from '../fileSystem.js';
+import { getFileSystem } from '../fileSystem.js';
 import { DictionaryLoader } from './DictionaryController/index.js';
 let loader;
-export function getDictionaryLoader(cspellIO) {
+export function getDictionaryLoader(vfs) {
     if (loader)
         return loader;
-    return (loader = new DictionaryLoader(cspellIO || getCSpellIO()));
+    return (loader = new DictionaryLoader(vfs || getFileSystem()));
 }
 export function loadDictionary(def) {
     return getDictionaryLoader().loadDictionary(def);
 }
-export function loadDictionarySync(def) {
-    return getDictionaryLoader().loadDictionarySync(def);
-}
 /**
  * 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.

package/dist/esm/fileSystem.d.ts

@@ -1,8 +1,8 @@
-import type { CSpellIO, VFileSystemProvider } from 'cspell-io';
+import type { TextEncoding, VFileSystemProvider } from 'cspell-io';
 export type { VFileSystemProvider, VfsDirEntry, VirtualFS } from 'cspell-io';
-export { createTextFileResource, FSCapabilityFlags, VFileSystem } from 'cspell-io';
-export declare function getCSpellIO(): CSpellIO;
+export { FSCapabilityFlags, VFileSystem } from 'cspell-io';
 export declare function getVirtualFS(): import("cspell-io").VirtualFS;
 export declare function getFileSystem(): Required<import("cspell-io").VFileSystem>;
 export declare function registerCSpell(fsp: VFileSystemProvider): void;
+export declare function readTextFile(url: URL, encoding?: TextEncoding): Promise<string>;
 //# sourceMappingURL=fileSystem.d.ts.map

package/dist/esm/fileSystem.js

@@ -1,8 +1,5 @@
-import { getDefaultCSpellIO, getDefaultVirtualFs } from 'cspell-io';
-export { createTextFileResource, FSCapabilityFlags } from 'cspell-io';
-export function getCSpellIO() {
-    return getDefaultCSpellIO();
-}
+import { getDefaultVirtualFs } from 'cspell-io';
+export { FSCapabilityFlags } from 'cspell-io';
 export function getVirtualFS() {
     return getDefaultVirtualFs();
 }
@@ -13,4 +10,8 @@ export function registerCSpell(fsp) {
     const vfs = getVirtualFS();
     vfs.registerFileSystemProvider(fsp);
 }
+export async function readTextFile(url, encoding = 'utf8') {
+    const file = await getFileSystem().readFile(url, encoding);
+    return file.getText();
+}
 //# sourceMappingURL=fileSystem.js.map

package/dist/esm/textValidation/docValidator.d.ts

@@ -72,6 +72,21 @@ export declare class DocumentValidator {
     checkDocumentDirectives(forceCheck?: boolean): ValidationIssue[];
     get document(): TextDocument;
     updateDocumentText(text: string): Promise<void>;
+    /**
+     * Get the calculated ranges of text that should be included in the spell checking.
+     * @returns MatchRanges of text to include.
+     */
+    getCheckedTextRanges(): MatchRange[];
+    traceWord(word: string): {
+        word: string;
+        found: boolean;
+        foundWord: string | undefined;
+        forbidden: boolean;
+        noSuggest: boolean;
+        dictName: string;
+        dictSource: string;
+        errors: Error[] | undefined;
+    }[];
     private defaultParser;
     private _checkParsedText;
     private addPossibleError;

package/dist/esm/textValidation/docValidator.js

@@ -6,11 +6,12 @@ import { updateTextDocument } from '../Models/TextDocument.js';
 import { createPerfTimer } from '../perf/index.js';
 import { finalizeSettings, loadConfig, mergeSettings, searchForConfig } from '../Settings/index.js';
 import { validateInDocumentSettings } from '../Settings/InDocSettings.js';
-import { getDictionaryInternal, getDictionaryInternalSync } from '../SpellingDictionary/index.js';
+import { getDictionaryInternal } from '../SpellingDictionary/index.js';
 import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
 import { catchPromiseError, toError } from '../util/errors.js';
 import { AutoCache } from '../util/simpleCache.js';
 import { uriToFilePath } from '../util/Uri.js';
+import { toFilePathOrHref } from '../util/url.js';
 import { defaultMaxDuplicateProblems, defaultMaxNumberOfProblems } from './defaultConstants.js';
 import { determineTextDocumentSettings } from './determineTextDocumentSettings.js';
 import { textValidatorFactory } from './lineValidatorFactory.js';
@@ -108,7 +109,7 @@ export class DocumentValidator {
         const timer = createPerfTimer('_updatePrep');
         const prep = this._preparations;
         const docSettings = await determineTextDocumentSettings(this._document, prep.config);
-        const dict = getDictionaryInternalSync(docSettings);
+        const dict = await getDictionaryInternal(docSettings);
         const shouldCheck = docSettings.enabled ?? true;
         const finalSettings = finalizeSettings(docSettings);
         const validateOptions = settingsToValidateOptions(finalSettings);
@@ -237,6 +238,36 @@ export class DocumentValidator {
         updateTextDocument(this._document, [{ text }]);
         await this._updatePrep();
     }
+    /**
+     * Get the calculated ranges of text that should be included in the spell checking.
+     * @returns MatchRanges of text to include.
+     */
+    getCheckedTextRanges() {
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        return this._preparations.includeRanges;
+    }
+    traceWord(word) {
+        assert(this._preparations, ERROR_NOT_PREPARED);
+        const dictCollection = this._preparations.dictionary;
+        const config = this._preparations.config;
+        const opts = {
+            ignoreCase: true,
+            allowCompoundWords: config.allowCompoundWords || false,
+        };
+        const trace = dictCollection.dictionaries
+            .map((dict) => ({ dict, findResult: dict.find(word, opts) }))
+            .map(({ dict, findResult }) => ({
+            word,
+            found: !!findResult?.found,
+            foundWord: findResult?.found || undefined,
+            forbidden: findResult?.forbidden || false,
+            noSuggest: findResult?.noSuggest || false,
+            dictName: dict.name,
+            dictSource: toFilePathOrHref(dict.source),
+            errors: normalizeErrors(dict.getErrors?.()),
+        }));
+        return trace;
+    }
     defaultParser() {
         return pipeSync(this.document.getLines(), opMap((line) => {
             const { text, offset } = line;
@@ -378,4 +409,7 @@ function recordPerfTime(timings, name) {
 function timePromise(timings, name, p) {
     return p.finally(recordPerfTime(timings, name));
 }
+function normalizeErrors(errors) {
+    return errors?.length ? errors : undefined;
+}
 //# sourceMappingURL=docValidator.js.map

package/dist/esm/trace.js

@@ -1,9 +1,9 @@
-import { fileURLToPath } from 'node:url';
 import { genSequence } from 'gensequence';
 import { toInternalSettings } from './Settings/CSpellSettingsServer.js';
 import { finalizeSettings, mergeSettings } from './Settings/index.js';
 import { calcSettingsForLanguageId } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';
+import { toFilePathOrHref } from './util/url.js';
 import * as util from './util/util.js';
 export async function traceWords(words, settings, options) {
     const results = await util.asyncIterableToArray(traceWordsAsync(words, settings, options));
@@ -64,9 +64,6 @@ export async function* traceWordsAsync(words, settings, options) {
     }
 }
 function dictSourceToFilename(source) {
-    if (source.startsWith('file:')) {
-        return fileURLToPath(source);
-    }
-    return source;
+    return toFilePathOrHref(source);
 }
 //# sourceMappingURL=trace.js.map

package/dist/esm/util/AutoResolve.d.ts

@@ -46,5 +46,20 @@ export declare class AutoResolveWeakCache<K extends object, V> implements IWeakM
     stats(): AutoResolveCacheStats;
 }
 export declare function createAutoResolveWeakCache<K extends object, V>(): AutoResolveWeakCache<K, V>;
+export declare class AutoResolveWeakWeakCache<K extends object, V extends object> implements IWeakMap<K, V> {
+    private _map;
+    private _stats;
+    get(k: K): V | undefined;
+    get(k: K, resolve: (k: K) => V): V;
+    get(k: K, resolve?: (k: K) => V): V | undefined;
+    get map(): WeakMap<K, WeakRef<V>>;
+    has(k: K): boolean;
+    set(k: K, v: V): this;
+    clear(): void;
+    delete(k: K): boolean;
+    dispose(): void;
+    stats(): AutoResolveCacheStats;
+}
+export declare function createAutoResolveWeakWeakCache<K extends object, V extends object>(): AutoResolveWeakWeakCache<K, V>;
 export {};
 //# sourceMappingURL=AutoResolve.d.ts.map

package/dist/esm/util/AutoResolve.js

@@ -116,4 +116,57 @@ export class AutoResolveWeakCache {
 export function createAutoResolveWeakCache() {
     return new AutoResolveWeakCache();
 }
+export class AutoResolveWeakWeakCache {
+    _map = new WeakMap();
+    _stats = new CacheStatsTracker();
+    get(k, resolve) {
+        const map = this._map;
+        const found = map.get(k);
+        const foundValue = found?.deref();
+        if (found !== undefined && foundValue) {
+            ++this._stats.hits;
+            return foundValue;
+        }
+        ++this._stats.misses;
+        if (!resolve) {
+            if (found) {
+                map.delete(k);
+            }
+            return undefined;
+        }
+        ++this._stats.resolved;
+        const value = resolve(k);
+        map.set(k, new WeakRef(value));
+        return value;
+    }
+    get map() {
+        return this._map;
+    }
+    has(k) {
+        return !!this._map.get(k)?.deref();
+    }
+    set(k, v) {
+        ++this._stats.sets;
+        this._map.set(k, new WeakRef(v));
+        return this;
+    }
+    clear() {
+        this._stats.clear();
+        this._map = new WeakMap();
+    }
+    delete(k) {
+        ++this._stats.deletes;
+        return this._map.delete(k);
+    }
+    dispose() {
+        ++this._stats.disposals;
+        this.clear();
+    }
+    stats() {
+        return this._stats.stats();
+    }
+}
+export function createAutoResolveWeakWeakCache() {
+    return new AutoResolveWeakWeakCache();
+}
 //# sourceMappingURL=AutoResolve.js.map

package/dist/esm/util/TextRange.d.ts

@@ -1,3 +1,7 @@
+/**
+ * A range of text in a document.
+ * The range is inclusive of the startPos and exclusive of the endPos.
+ */
 export interface MatchRange {
     startPos: number;
     endPos: number;

package/dist/esm/util/Uri.js

@@ -77,7 +77,7 @@ class UriImpl extends URI {
     }
     toString() {
         // if (this.scheme !== 'stdin') return super.toString(true);
-        const path = (this.path || '').split('/').map(encodeURIComponent).join('/').replace(/%3A/g, ':');
+        const path = encodeURI(this.path || '').replace(/[#?]/g, (c) => `%${c.charCodeAt(0).toString(16)}`);
         const base = `${this.scheme}://${this.authority || ''}${path}`;
         const query = (this.query && `?${this.query}`) || '';
         const fragment = (this.fragment && `#${this.fragment}`) || '';

package/dist/esm/util/fileReader.d.ts

@@ -1,4 +1,3 @@
-import type { TextEncoding } from 'cspell-io';
-export declare function readLines(filename: string, encoding?: TextEncoding): Promise<IterableIterator<string>>;
-export declare function readLinesSync(filename: string, encoding?: TextEncoding): string[];
+import { type TextEncoding } from 'cspell-io';
+export declare function readLines(url: URL | string, encoding?: TextEncoding): Promise<IterableIterator<string>>;
 //# sourceMappingURL=fileReader.d.ts.map

package/dist/esm/util/fileReader.js

@@ -1,16 +1,14 @@
-import { readFileText, readFileTextSync } from 'cspell-io';
+import { toFileURL } from 'cspell-io';
+import { readTextFile } from '../fileSystem.js';
 import { toIterableIterator } from './iterableIteratorLib.js';
-export async function readLines(filename, encoding = 'utf8') {
+export async function readLines(url, encoding = 'utf8') {
     try {
-        const content = await readFileText(filename, encoding);
+        url = toFileURL(url);
+        const content = await readTextFile(url, encoding);
         return toIterableIterator(content.split(/\r?\n/g));
     }
     catch (e) {
         return Promise.reject(e);
     }
 }
-export function readLinesSync(filename, encoding = 'utf8') {
-    const content = readFileTextSync(filename, encoding);
-    return content.split(/\r?\n/g);
-}
 //# sourceMappingURL=fileReader.js.map

package/dist/esm/util/resolveFile.d.ts

@@ -30,6 +30,14 @@ export declare class FileResolver {
     resolveFile(filename: string | URL, relativeTo: string | URL): Promise<ResolveFileResult>;
     _resolveFile(filename: string, relativeTo: string | URL): Promise<ResolveFileResult>;
     private doesExist;
+    /**
+     * Check to see if it is a URL.
+     * Note: URLs are absolute!
+     * If relativeTo is a non-file URL, then it will try to resolve the filename relative to it.
+     * @param filename - url string
+     * @returns ResolveFileResult
+     */
+    tryUrlRel: (filename: string, relativeToURL: string | URL) => Promise<ResolveFileResult | undefined>;
     /**
      * Check to see if it is a URL.
      * Note: URLs are absolute!

package/dist/esm/util/resolveFile.js

@@ -45,7 +45,7 @@ export class FileResolver {
     async _resolveFile(filename, relativeTo) {
         filename = patchFilename(filename, this.templateReplacements);
         const steps = [
-            { filename, fn: this.tryUrl },
+            { filename, fn: this.tryUrlRel },
             { filename, fn: this.tryCreateRequire },
             { filename, fn: this.tryNodeRequireResolve },
             { filename, fn: this.tryImportResolve },
@@ -84,7 +84,7 @@ export class FileResolver {
      * @param filename - url string
      * @returns ResolveFileResult
      */
-    tryUrl = async (filename, relativeToURL) => {
+    tryUrlRel = async (filename, relativeToURL) => {
         if (isURLLike(filename)) {
             const fileURL = toURL(filename);
             return {
@@ -94,6 +94,26 @@ export class FileResolver {
                 method: 'tryUrl',
             };
         }
+        if (isRelative(filename) && isURLLike(relativeToURL) && !isDataURL(relativeToURL)) {
+            const relToURL = toURL(relativeToURL);
+            const url = resolveFileWithURL(filename, relToURL);
+            return {
+                filename: toFilePathOrHref(url),
+                relativeTo: toFilePathOrHref(relToURL),
+                found: await this.doesExist(url),
+                method: 'tryUrl',
+            };
+        }
+        return undefined;
+    };
+    /**
+     * Check to see if it is a URL.
+     * Note: URLs are absolute!
+     * If relativeTo is a non-file URL, then it will try to resolve the filename relative to it.
+     * @param filename - url string
+     * @returns ResolveFileResult
+     */
+    tryUrl = async (filename, relativeToURL) => {
         if (isURLLike(relativeToURL) && !isDataURL(relativeToURL)) {
             const relToURL = toURL(relativeToURL);
             const url = resolveFileWithURL(filename, relToURL);

package/dist/esm/util/simpleCache.d.ts

@@ -34,6 +34,7 @@ export declare class SimpleCache<K, T> {
     has(key: K): boolean;
     get(key: K): T | undefined;
     set(key: K, value: T): void;
+    delete(key: K): boolean;
     private _set;
     private caches;
     private rotate;

package/dist/esm/util/simpleCache.js

@@ -103,6 +103,13 @@ export class SimpleCache {
     set(key, value) {
         this._set(key, { v: value });
     }
+    delete(key) {
+        let deleted = false;
+        for (const c of this.caches()) {
+            deleted = c.delete(key) || deleted;
+        }
+        return deleted;
+    }
     _set(key, entry) {
         if (this.L0.has(key)) {
             this.L0.set(key, entry);
@@ -117,9 +124,11 @@ export class SimpleCache {
         return [this.L0, this.L1, this.L2];
     }
     rotate() {
+        const L2 = this.L2;
         this.L2 = this.L1;
         this.L1 = this.L0;
-        this.L0 = new Map();
+        this.L0 = L2;
+        this.L0.clear();
     }
 }
 export class AutoCache extends SimpleCache {

package/dist/esm/wordListHelper.js

@@ -3,13 +3,15 @@ import { readLines } from './util/fileReader.js';
 import { concatIterables, toIterableIterator } from './util/iterableIteratorLib.js';
 import { logError } from './util/logger.js';
 import * as Text from './util/text.js';
+import { toFileUrl } from './util/url.js';
 const regExpWordsWithSpaces = /^\s*\p{L}+(?:\s+\p{L}+){0,3}$/u;
 /**
  * Reads words from a file. It will not throw and error.
  * @param filename the file to read
  */
 export function loadWordsNoError(filename) {
-    return readLines(filename).catch((e) => (logError(e), toIterableIterator([])));
+    const url = toFileUrl(filename);
+    return readLines(url).catch((e) => (logError(e), toIterableIterator([])));
 }
 export function splitLine(line) {
     return [...Text.extractWordsFromText(line)].map(({ text }) => text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.2.1",
+  "version": "8.2.4",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -57,21 +57,21 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.2.1",
-    "@cspell/cspell-pipe": "8.2.1",
-    "@cspell/cspell-resolver": "8.2.1",
-    "@cspell/cspell-types": "8.2.1",
-    "@cspell/dynamic-import": "8.2.1",
-    "@cspell/strong-weak-map": "8.2.1",
+    "@cspell/cspell-bundled-dicts": "8.2.4",
+    "@cspell/cspell-pipe": "8.2.4",
+    "@cspell/cspell-resolver": "8.2.4",
+    "@cspell/cspell-types": "8.2.4",
+    "@cspell/dynamic-import": "8.2.4",
+    "@cspell/strong-weak-map": "8.2.4",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^6.0.0",
-    "cspell-config-lib": "8.2.1",
-    "cspell-dictionary": "8.2.1",
-    "cspell-glob": "8.2.1",
-    "cspell-grammar": "8.2.1",
-    "cspell-io": "8.2.1",
-    "cspell-trie-lib": "8.2.1",
+    "cspell-config-lib": "8.2.4",
+    "cspell-dictionary": "8.2.4",
+    "cspell-glob": "8.2.4",
+    "cspell-grammar": "8.2.4",
+    "cspell-io": "8.2.4",
+    "cspell-trie-lib": "8.2.4",
     "fast-equals": "^5.0.1",
     "gensequence": "^6.0.0",
     "import-fresh": "^3.3.0",
@@ -90,10 +90,10 @@
     "@cspell/dict-fr-fr": "^2.2.2",
     "@cspell/dict-html": "^4.0.5",
     "@cspell/dict-nl-nl": "^2.3.0",
-    "@cspell/dict-python": "^4.1.10",
+    "@cspell/dict-python": "^4.1.11",
     "@types/configstore": "^6.0.2",
     "cspell-dict-nl-nl": "^1.1.2",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "b0c889ee4068aa8a2447106c5c7f449debc85bdd"
+  "gitHead": "d3c5ff685b3aa2bf984f557d81380f2c994547e0"
 }

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

@@ -1,9 +0,0 @@
-import type { 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/esm/Settings/Controller/SettingsController.js

@@ -1,10 +0,0 @@
-/**
- * The settings controller manages requests to resolve configuration settings and files.
- */
-export class SettingsController {
-    cspellIO;
-    constructor(cspellIO) {
-        this.cspellIO = cspellIO;
-    }
-}
-//# sourceMappingURL=SettingsController.js.map