cspell-lib 9.3.2 → 9.6.0

package/README.md

@@ -6,13 +6,13 @@
 
 <!--- @@inject: ../../static/sponsor.md --->
 
-- [![GitHub Sponsors](https://img.shields.io/badge/-black?style=social&logo=githubsponsors&label=GitHub%20Sponsor%3A%20Street%20Side%20Software)](https://github.com/sponsors/streetsidesoftware)
-- [![PayPal](https://img.shields.io/badge/-black?style=social&logo=paypal&label=PayPal%20Donate%3A%20Street%20Side%20Software)](https://www.paypal.com/donate/?hosted_button_id=26LNBP2Q6MKCY)
-- [![Open Collective](https://img.shields.io/badge/-black?style=social&logo=opencollective&label=Open%20Collective%3A%20CSpell)](https://opencollective.com/cspell)
+[![GitHub Sponsors](https://img.shields.io/badge/-Street_Side_Software-black?style=for-the-badge&logo=githubsponsors&label=GitHub%20Sponsor%3A)](https://github.com/sponsors/streetsidesoftware)
 
-<!---
-- [![Patreon](https://img.shields.io/badge/-black?style=social&logo=patreon&label=Patreon%3A%20Street%20Side%20Software)](https://patreon.com/streetsidesoftware)
-  --->
+[![Open Collective](https://img.shields.io/badge/-CSpell-black?style=for-the-badge&logo=opencollective&label=Open%20Collective%3A)](https://opencollective.com/cspell)
+
+[![Street Side Software](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fstreetsidesoftware%2Fcspell%2Frefs%2Fheads%2Fmain%2Fstatic%2Fcspell-badge.json)](https://streetsidesoftware.com/sponsor/)
+
+[![PayPal](https://img.shields.io/badge/-Street_Side_Software-black?style=for-the-badge&logo=paypal&label=PayPal%20Donate%3A)](https://www.paypal.com/donate/?hosted_button_id=26LNBP2Q6MKCY)
 
 <!--- @@inject-end: ../../static/sponsor.md --->
 

package/dist/lib/Settings/Controller/ImportError.js

@@ -2,6 +2,9 @@ import { isError } from '../../util/errors.js';
 export class ImportError extends Error {
     cause;
     constructor(msg, cause) {
+        if (isError(cause)) {
+            msg += `\n  ${cause.message}`;
+        }
         super(msg);
         this.cause = isError(cause) ? cause : undefined;
     }

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

@@ -1,11 +1,13 @@
 import type { CSpellSettings, CSpellUserSettings, ImportFileRef } from '@cspell/cspell-types';
-import { CSpellConfigFile, CSpellConfigFileReaderWriter, ICSpellConfigFile } from 'cspell-config-lib';
+import type { CSpellConfigFileReaderWriter, ICSpellConfigFile } from 'cspell-config-lib';
+import { CSpellConfigFile, CSpellConfigFileWithErrors } from 'cspell-config-lib';
 import type { VFileSystem } from '../../../fileSystem.js';
-import { AutoResolveCache, CacheStats } from '../../../util/AutoResolve.js';
+import type { CacheStats } from '../../../util/AutoResolve.js';
+import { AutoResolveCache } from '../../../util/AutoResolve.js';
 import { FileResolver } from '../../../util/resolveFile.js';
 import type { LoaderResult } from '../pnpLoader.js';
 import { ConfigSearch } from './configSearch.js';
-import { StopSearchAt } from './defaultConfigLoader.js';
+import type { StopSearchAt } from './defaultConfigLoader.js';
 import { normalizeCacheSettings } from './normalizeRawSettings.js';
 import type { PnPSettingsOptional } from './PnPSettings.js';
 import type { CSpellSettingsI, CSpellSettingsWST } from './types.js';
@@ -123,7 +125,7 @@ export declare class ConfigLoader implements IConfigLoader {
     readSettingsAsync(filename: string | URL, relativeTo?: string | URL, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI>;
     readConfigFile(filenameOrURL: string | URL, relativeTo?: string | URL): Promise<CSpellConfigFile | Error>;
     searchForConfigFileLocation(searchFrom: URL | string | undefined, stopSearchAt?: URL[] | undefined): Promise<URL | undefined>;
-    searchForConfigFile(searchFrom: URL | string | undefined, stopSearchAt?: URL[]): Promise<CSpellConfigFile | undefined>;
+    searchForConfigFile(searchFrom: URL | string | undefined, stopSearchAt?: URL[]): Promise<CSpellConfigFile | CSpellConfigFileWithErrors | undefined>;
     /**
      *
      * @param searchFrom the directory / file URL to start searching from.

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

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { CSpellConfigFile } from 'cspell-config-lib';
+import { CSpellConfigFile, CSpellConfigFileWithErrors } from 'cspell-config-lib';
 import { createReaderWriter } from 'cspell-config-lib';
 import { isUrlLike, toFileURL } from 'cspell-io';
 import { URI, Utils as UriUtils } from 'vscode-uri';
@@ -15,13 +15,13 @@ import { FileResolver } from '../../../util/resolveFile.js';
 import { envToTemplateVars } from '../../../util/templates.js';
 import { addTrailingSlash, cwdURL, resolveFileWithURL, toFileDirURL, toFilePathOrHref, toFileUrl, windowsDriveLetterToUpper, } from '../../../util/url.js';
 import { configSettingsFileVersion0_1, configSettingsFileVersion0_2, currentSettingsFileVersion, defaultConfigFileModuleRef, ENV_CSPELL_GLOB_ROOT, } from '../../constants.js';
-import { getMergeStats, mergeSettings } from '../../CSpellSettingsServer.js';
+import { getMergeStats, mergeSettings, toInternalSettings } from '../../CSpellSettingsServer.js';
 import { getGlobalConfig } from '../../GlobalSettings.js';
 import { ImportError } from '../ImportError.js';
 import { pnpLoader } from '../pnpLoader.js';
 import { searchPlaces } from './configLocations.js';
 import { ConfigSearch } from './configSearch.js';
-import { configToRawSettings } from './configToRawSettings.js';
+import { configErrorToRawSettings, configToRawSettings } from './configToRawSettings.js';
 import { defaultSettings } from './defaultSettings.js';
 import { normalizeCacheSettings, normalizeDictionaryDefs, normalizeGitignoreRoot, normalizeImport, normalizeLanguageSettings, normalizeOverrides, normalizeReporters, normalizeSettingsGlobs, } from './normalizeRawSettings.js';
 import { defaultPnPSettings, normalizePnPSettings } from './PnPSettings.js';
@@ -31,7 +31,7 @@ export const sectionCSpell = 'cSpell';
 export const defaultFileName = 'cspell.json';
 let defaultConfigLoader = undefined;
 const defaultExtensions = ['.json', '.yaml', '.yml', '.jsonc', '.toml'];
-const defaultJsExtensions = ['.js', '.cjs', '.mjs', '.ts', '.mts'];
+const defaultJsExtensions = ['.js', '.cjs', '.mjs', '.ts', '.mts', '.cts'];
 export const defaultExtensionsAll = [...defaultExtensions, ...defaultJsExtensions];
 const trustedSearch = new Map([
     ['*', defaultExtensions],
@@ -110,7 +110,10 @@ export class ConfigLoader {
         if (!location)
             return undefined;
         const file = await this.readConfigFile(location);
-        return file instanceof Error ? undefined : file;
+        if (file instanceof Error) {
+            return new CSpellConfigFileWithErrors(location, configErrorToRawSettings(file, location), file);
+        }
+        return file;
     }
     /**
      *
@@ -123,6 +126,9 @@ export class ConfigLoader {
         const configFile = await this.searchForConfigFile(searchFrom, stopAt);
         if (!configFile)
             return undefined;
+        if (configFile instanceof CSpellConfigFileWithErrors) {
+            return toInternalSettings(configFile.settings);
+        }
         return this.mergeConfigFileWithImports(configFile, options);
     }
     getGlobalSettings() {

package/dist/lib/Settings/Controller/configLoader/configLocations.js

@@ -9,6 +9,7 @@ export const supportedExtensions = [
     '.toml',
     '.mts',
     '.ts',
+    '.cts',
 ];
 /**
  * Logic of the locations:

package/dist/lib/Settings/DictionarySettings.js

@@ -27,10 +27,12 @@ function fixPath(def) {
         return def;
     }
     const newPath = fixDicPath(def.path, def.file);
+    const newBTriePath = def.btrie ? fixDicPath(def.btrie, def.file) : undefined;
     return {
         ...def,
         file: undefined,
         path: newPath,
+        btrie: newBTriePath,
     };
 }
 function fixDicPath(defPath, defFile) {
@@ -103,15 +105,18 @@ class _DictionaryDefinitionInternalWithSource {
         this.__source = sourceURL.href;
         // this bit of assignment is to have the compiler help use if any new fields are added.
         const defAll = def;
-        const { path: relPath = '', file = '', addWords, description, dictionaryInformation, type, repMap, noSuggest, ignoreForbiddenWords, scope, supportNonStrictSearches, useCompounds, } = defAll;
+        const { path: relPath = '', file = '', btrie, addWords, description, dictionaryInformation, type, repMap, noSuggest, ignoreForbiddenWords, scope, supportNonStrictSearches, useCompounds, } = defAll;
         const defaultPath = sourceURL;
         const filePath = fixDicPath(relPath, file);
         const name = determineName(filePath, def);
         const resolvedPath = toFilePathOrHref(resolveRelativeTo(filePath, defaultPath));
+        let bTriePath = btrie ? fixDicPath(btrie, file) : undefined;
+        bTriePath = bTriePath ? toFilePathOrHref(resolveRelativeTo(bTriePath, defaultPath)) : undefined;
         const ddi = {
             name,
             file: undefined,
             path: resolvedPath,
+            btrie: bTriePath,
             addWords,
             description,
             dictionaryInformation,

package/dist/lib/Settings/RegExpPatterns.js

@@ -5,14 +5,14 @@ export const regExHRef = /\bhref\s*=\s*".*?"/gi;
 export const regExMatchCommonHexFormats = /(?:#[0-9a-f]{3,8})|(?:0x[0-9a-f]+)|(?:\\u[0-9a-f]{4})|(?:\\x\{[0-9a-f]{4}\})/gi;
 export const regExCommitHash = /\b(?![a-f]+\b)(?:0x)?[0-9a-f]{7,}\b/gi; // Match Commit Hashes that contain at least one digit.
 export const regExCommitHashLink = /\[[0-9a-f]{7,}\]/gi; // Match Commit Hash Markdown link: [abcdef0].
-export const regExCStyleHexValue = /\b0x[0-9a-f_]+\b/gi;
+export const regExCStyleHexValue = /\b0x[0-9a-f_]+n?\b/gi;
 export const regExCSSHexValue = /#[0-9a-f]{3,8}\b/gi;
 export const 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
 export const regExUnicodeRef = /\bU\+[0-9a-f]{4,5}(?:-[0-9a-f]{4,5})?/gi;
 export const regExSpellingGuardBlock = /(\bc?spell(?:-?checker)?::?)\s*disable(?!-line|-next)\b(?!-)[\s\S]*?((?:\1\s*enable\b)|$)/gi;
 export const regExSpellingGuardNext = /\bc?spell(?:-?checker)?::?\s*disable-next\b.*\s\s?.*/gi;
 export const regExSpellingGuardLine = /^.*\bc?spell(?:-?checker)?::?\s*disable-line\b.*/gim;
-export const regExIgnoreSpellingDirectives = /\bc?spell(?:-?checker)?::?\s*ignoreRegExp.*/gim;
+export const regExIgnoreSpellingDirectives = /\bc?spell(?:-?checker)?::?\s*(ignoreRegExp|word|ignore).*/gim;
 export const regExPublicKey = /-{5}BEGIN\s+((?:RSA\s+)?PUBLIC\s+KEY)[\w=+\-/=\\\s]+?END\s+\1-{5}/g;
 export const regExCert = /-{5}BEGIN\s+(CERTIFICATE|(?:RSA\s+)?(?:PRIVATE|PUBLIC)\s+KEY)[\w=+\-/=\\\s]+?END\s+\1-{5}/g;
 export const regExSshRSA = /ssh-rsa\s+[a-z0-9/+]{28,}={0,3}(?![a-z0-9/+=])/gi;

package/dist/lib/Settings/cfgStore.d.ts

@@ -1,4 +1,4 @@
-import { CSpellSettings } from '@cspell/cspell-types';
+import type { CSpellSettings } from '@cspell/cspell-types';
 export declare const legacyLocationDir: string | undefined;
 export declare const cspellGlobalLocationDir: string;
 export declare const defaultConfigFileName = "cspell.json";

package/dist/lib/Settings/link.js

@@ -78,7 +78,7 @@ export async function removePathsFromGlobalImports(paths) {
         return c === Path.sep || c === Path.posix.sep;
     }
     function matchFilename(pathToRemove) {
-        return Path.dirname(pathToRemove) != '.'
+        return Path.dirname(pathToRemove) !== '.'
             ? ({ filename }) => compareFilenames(filename, pathToRemove)
             : () => false;
     }

package/dist/lib/Settings/mergeCache.d.ts

@@ -1,4 +1,4 @@
-import { CacheStats } from '../util/AutoResolve.js';
+import type { CacheStats } from '../util/AutoResolve.js';
 interface IDisposable {
     dispose(): void;
 }

package/dist/lib/Settings/mergeList.d.ts

@@ -1,4 +1,4 @@
-import { CacheStats } from '../util/AutoResolve.js';
+import type { CacheStats } from '../util/AutoResolve.js';
 /**
  * Merges two lists and removes duplicates.  Order is NOT preserved.
  */

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

@@ -3,6 +3,7 @@ import { StrongWeakMap } from '@cspell/strong-weak-map';
 import { createFailedToLoadDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, } from 'cspell-dictionary';
 import { compareStats, toFileURL, urlBasename } from 'cspell-io';
 import { isDictionaryDefinitionInlineInternal, isDictionaryFileDefinitionInternal, } from '../../Models/CSpellSettingsInternalDef.js';
+import { measurePerfFn } from '../../perf/index.js';
 import { AutoResolveWeakCache, AutoResolveWeakWeakCache } from '../../util/AutoResolve.js';
 import { toError } from '../../util/errors.js';
 import { SimpleCache } from '../../util/simpleCache.js';
@@ -42,7 +43,7 @@ export class DictionaryLoader {
             if (entry) {
                 return entry.pending.then(([dictionary]) => dictionary);
             }
-            const loadedEntry = this.loadEntry(def.path, def);
+            const loadedEntry = this.loadEntry(def.btrie || def.path, def);
             this.setCacheEntry(key, loadedEntry, def);
             this.keepAliveCache.set(def, loadedEntry);
             return loadedEntry.pending.then(([dictionary]) => dictionary);
@@ -98,8 +99,8 @@ export class DictionaryLoader {
     loadEntry(fileOrUri, options, now = Date.now()) {
         const url = toFileURL(fileOrUri);
         options = this.normalizeOptions(url, 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 pDictionary = load(this.reader, url, options).catch((e) => createFailedToLoadDictionary(options.name, fileOrUri, new SpellingDictionaryLoadError(url.href, options, e, 'failed to load'), options));
+        const pStat = this.getStat(url);
         const pending = Promise.all([pDictionary, pStat]);
         const sig = now + Math.random();
         const entry = {
@@ -153,12 +154,19 @@ export class DictionaryLoader {
     }
 }
 function toReader(fs) {
-    async function readFile(url) {
-        return (await fs.readFile(url)).getText();
+    function readResource(url) {
+        return fs.readFile(url);
+    }
+    async function readText(url) {
+        return (await readResource(url)).getText();
+    }
+    async function read(url) {
+        return (await readResource(url)).getBytes();
     }
     return {
-        read: readFile,
-        readLines: async (filename) => toLines(await readFile(filename)),
+        read,
+        readText,
+        readLines: async (filename) => toLines(await readText(filename)),
     };
 }
 const importantOptionKeys = ['name', 'noSuggest', 'useCompounds', 'type'];
@@ -170,17 +178,17 @@ function determineType(uri, opts) {
     const t = (opts.type && opts.type in loaders && opts.type) || 'S';
     const defLoaderType = t;
     const defType = uri.pathname.endsWith('.trie.gz') ? 'T' : defLoaderType;
-    const regTrieTest = /\.trie\b/i;
+    const regTrieTest = /\.b?trie\b/i;
     return regTrieTest.test(uri.pathname) ? 'T' : defType;
 }
-function load(reader, uri, options) {
+async function load(reader, uri, options) {
     const type = determineType(uri, options);
     const loader = loaders[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);
+    return measurePerfFn('legacyWords', () => _legacyWordListSync(lines, filename, options));
 }
 function _legacyWordListSync(lines, filename, options) {
     const words = pipe(lines, 
@@ -188,11 +196,11 @@ function _legacyWordListSync(lines, filename, options) {
     opMap((line) => line.replaceAll(/#.*/g, '')), 
     // Split on everything else
     opConcatMap((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), opFilter((word) => !!word));
-    return createSpellingDictionary(words, options.name, filename.toString(), options);
+    return createSpellingDictionary(words, options.name, filename.toString(), options, true);
 }
 async function wordsPerLineWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
-    return _wordsPerLineWordList(lines, filename.toString(), options);
+    return measurePerfFn('wordsPerLineWordList', () => _wordsPerLineWordList(lines, filename.toString(), options));
 }
 function _wordsPerLineWordList(lines, filename, options) {
     const words = pipe(lines, 
@@ -200,15 +208,15 @@ function _wordsPerLineWordList(lines, filename, options) {
     opMap((line) => line.replaceAll(/#.*/g, '')), 
     // Split on everything else
     opConcatMap((line) => line.split(/\s+/gu)), opFilter((word) => !!word));
-    return createSpellingDictionary(words, options.name, filename, options);
+    return createSpellingDictionary(words, options.name, filename, options, true);
 }
 async function loadSimpleWordList(reader, filename, options) {
     const lines = await reader.readLines(filename);
-    return createSpellingDictionary(lines, options.name, filename.href, options);
+    return measurePerfFn('loadSimpleWordList', () => 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);
+    return measurePerfFn('loadTrie', () => createSpellingDictionaryFromTrieFile(content, options.name, filename.href, options));
 }
 function toLines(content) {
     return content.split(/\n|\r\n|\r/);

package/dist/lib/perf/index.d.ts

@@ -1,3 +1,4 @@
+export { measurePerf, measurePerfEnd, measurePerfFn, measurePerfStart } from './performance.js';
 export type { PerfTimer } from './timer.js';
 export { createPerfTimer } from './timer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/perf/index.js

@@ -1,2 +1,3 @@
+export { measurePerf, measurePerfEnd, measurePerfFn, measurePerfStart } from './performance.js';
 export { createPerfTimer } from './timer.js';
 //# sourceMappingURL=index.js.map

package/dist/lib/perf/performance.d.ts

@@ -0,0 +1,16 @@
+export declare function measurePerfStart(name: string): void;
+export declare function measurePerfEnd(name: string): void;
+/**
+ * Creates performance marks and measures the time taken between them.
+ * @param name - name of the performance entry
+ * @returns a function to stop the timer.
+ */
+export declare function measurePerf(name: string): () => void;
+/**
+ * Measure the performance of a function.
+ * @param name - name of the performance entry
+ * @param fn - function to measure
+ * @returns the result of the function
+ */
+export declare function measurePerfFn<R>(name: string, fn: () => R): R;
+//# sourceMappingURL=performance.d.ts.map

package/dist/lib/perf/performance.js

@@ -0,0 +1,34 @@
+export function measurePerfStart(name) {
+    performance.mark(name + '-start');
+}
+export function measurePerfEnd(name) {
+    performance.mark(name + '-end');
+    performance.measure(name, name + '-start', name + '-end');
+}
+/**
+ * Creates performance marks and measures the time taken between them.
+ * @param name - name of the performance entry
+ * @returns a function to stop the timer.
+ */
+export function measurePerf(name) {
+    measurePerfStart(name);
+    return () => {
+        measurePerfEnd(name);
+    };
+}
+/**
+ * Measure the performance of a function.
+ * @param name - name of the performance entry
+ * @param fn - function to measure
+ * @returns the result of the function
+ */
+export function measurePerfFn(name, fn) {
+    const perfEnd = measurePerf(name);
+    try {
+        return fn();
+    }
+    finally {
+        perfEnd();
+    }
+}
+//# sourceMappingURL=performance.js.map

package/dist/lib/spellCheckFile.d.ts

@@ -1,5 +1,5 @@
 import type { CSpellSettingsWithSourceTrace, CSpellUserSettings } from '@cspell/cspell-types';
-import { ICSpellConfigFile } from 'cspell-config-lib';
+import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { Document, DocumentWithText } from './Document/index.js';
 import type { Uri } from './util/IUri.js';
 import type { ValidateTextOptions, ValidationIssue } from './validator.js';

package/dist/lib/suggestions.d.ts

@@ -1,5 +1,5 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
-import { ICSpellConfigFile } from 'cspell-config-lib';
+import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { LanguageId } from './fileTypes.js';
 import type { SpellingDictionaryCollection, SuggestionResult, SuggestOptions } from './SpellingDictionary/index.js';
 export interface WordSuggestion extends SuggestionResult {

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

@@ -1,5 +1,5 @@
 import type { CSpellUserSettings, MappedText, ParsedText } from '@cspell/cspell-types';
-import { ICSpellConfigFile } from 'cspell-config-lib';
+import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef.js';
 import type { ExtendedSuggestion } from '../Models/Suggestion.js';
 import type { TextDocument, TextDocumentRef } from '../Models/TextDocument.js';
@@ -9,7 +9,7 @@ import type { WordSuggestion } from '../suggestions.js';
 import type { MatchRange } from '../util/TextRange.js';
 import type { TextValidator } from './lineValidatorFactory.js';
 import type { SimpleRange } from './parsedText.js';
-import { TraceResult } from './traceWord.js';
+import type { TraceResult } from './traceWord.js';
 import type { ValidateTextOptions } from './ValidateTextOptions.js';
 import type { ValidationOptions } from './ValidationTypes.js';
 export interface DocumentValidatorOptions extends ValidateTextOptions {
@@ -131,9 +131,31 @@ interface Preparations {
     localConfigFilepath: string | undefined;
 }
 interface ShouldCheckDocumentResult {
+    /** possible errors found while loading configuration. */
     errors: Error[];
+    /**
+     * The calculated result:
+     * - `false` if the document should not be checked. Based upon the settings.
+     * - `true` if the document should be checked.
+     */
     shouldCheck: boolean;
+    /** final settings used to determine the result. */
+    settings: CSpellUserSettings;
+    /**
+     * The reason the document should not be checked.
+     */
+    reason?: string | undefined;
 }
+/**
+ * Check if a document should be checked based upon the ignorePaths and override settings.
+ *
+ * This function will search and fetch settings based upon the location of the document if `noConfigSearch` is not true.
+ *
+ * @param doc - document to check
+ * @param options - options to override some of the settings.
+ * @param settings - current settings
+ * @returns ShouldCheckDocumentResult
+ */
 export declare function shouldCheckDocument(doc: TextDocumentRef, options: DocumentValidatorOptions, settings: CSpellUserSettings): Promise<ShouldCheckDocumentResult>;
 export declare const __testing__: {
     sanitizeSuggestion: typeof sanitizeSuggestion;

package/dist/lib/textValidation/docValidator.js

@@ -5,8 +5,8 @@ import { toFilePathOrHref, toFileURL } from '@cspell/url';
 import { satisfiesCSpellConfigFile } from 'cspell-config-lib';
 import { getGlobMatcherForExcluding } from '../globs/getGlobMatcher.js';
 import { documentUriToURL, updateTextDocument } from '../Models/TextDocument.js';
-import { createPerfTimer } from '../perf/index.js';
-import { finalizeSettings, loadConfig, mergeSettings, resolveConfigFileImports, resolveSettingsImports, searchForConfig, } from '../Settings/index.js';
+import { createPerfTimer, measurePerf } from '../perf/index.js';
+import { extractImportErrors, finalizeSettings, loadConfig, mergeSettings, resolveConfigFileImports, resolveSettingsImports, searchForConfig, } from '../Settings/index.js';
 import { validateInDocumentSettings } from '../Settings/InDocSettings.js';
 import { getDictionaryInternal } from '../SpellingDictionary/index.js';
 import { calcSuggestionAdjustedToToMatchCase } from '../suggestions.js';
@@ -81,12 +81,15 @@ export class DocumentValidator {
             : useSearchForConfig
                 ? timePromise(this.perfTiming, '__searchForDocumentConfig', searchForDocumentConfig(this._document, settings, settings))
                 : undefined;
-        pLocalConfig && timePromise(this.perfTiming, '_loadConfig', pLocalConfig);
+        if (pLocalConfig) {
+            timePromise(this.perfTiming, '_loadConfig', pLocalConfig).catch(() => undefined);
+        }
         const localConfig = (await catchPromiseError(pLocalConfig, (e) => this.addPossibleError(e))) || {};
-        this.addPossibleError(localConfig?.__importRef?.error);
+        extractImportErrors(localConfig).forEach((e) => this.addPossibleError(e.error));
         const config = mergeSettings(settings, localConfig);
         const docSettings = await timePromise(this.perfTiming, '_determineTextDocumentSettings', determineTextDocumentSettings(this._document, config));
         const dict = await timePromise(this.perfTiming, '_getDictionaryInternal', getDictionaryInternal(docSettings));
+        const stopMeasure = measurePerf('DocumentValidator._prepareAsync');
         const recGlobMatcherTime = recordPerfTime(this.perfTiming, '_GlobMatcher');
         const matcher = getGlobMatcherForExcluding(localConfig?.ignorePaths);
         const uri = this._document.uri;
@@ -118,6 +121,7 @@ export class DocumentValidator {
         this._ready = true;
         this._preparationTime = timer.elapsed;
         this.perfTiming.prepTime = this._preparationTime;
+        stopMeasure();
     }
     async _updatePrep() {
         assert(this._preparations, ERROR_NOT_PREPARED);
@@ -125,6 +129,7 @@ export class DocumentValidator {
         const prep = this._preparations;
         const docSettings = await determineTextDocumentSettings(this._document, prep.config);
         const dict = await getDictionaryInternal(docSettings);
+        const stopMeasure = measurePerf('DocumentValidator._updatePrep');
         const shouldCheck = docSettings.enabled ?? true;
         const finalSettings = finalizeSettings(docSettings);
         const validateOptions = settingsToValidateOptions(finalSettings);
@@ -142,6 +147,7 @@ export class DocumentValidator {
             textValidator,
         };
         this._preparationTime = timer.elapsed;
+        stopMeasure();
     }
     /**
      * The amount of time in ms to prepare for validation.
@@ -295,6 +301,7 @@ export class DocumentValidator {
         const { maxNumberOfProblems = defaultMaxNumberOfProblems, maxDuplicateProblems = defaultMaxDuplicateProblems } = this._preparations.validateOptions;
         let numProblems = 0;
         const mapOfProblems = new Map();
+        const stopMeasure = measurePerf('DocumentValidator._checkParsedText');
         for (const pText of parsedTexts) {
             for (const issue of this.check(pText)) {
                 const { text } = issue;
@@ -307,6 +314,7 @@ export class DocumentValidator {
                     return;
             }
         }
+        stopMeasure();
     }
     addPossibleError(error) {
         if (!error)
@@ -394,6 +402,16 @@ async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {
 function mapSug(sug) {
     return { cost: 999, ...sug };
 }
+/**
+ * Check if a document should be checked based upon the ignorePaths and override settings.
+ *
+ * This function will search and fetch settings based upon the location of the document if `noConfigSearch` is not true.
+ *
+ * @param doc - document to check
+ * @param options - options to override some of the settings.
+ * @param settings - current settings
+ * @returns ShouldCheckDocumentResult
+ */
 export async function shouldCheckDocument(doc, options, settings) {
     const errors = [];
     function addPossibleError(error) {
@@ -410,14 +428,19 @@ export async function shouldCheckDocument(doc, options, settings) {
                 ? searchForDocumentConfig(doc, settings, settings)
                 : undefined;
         const localConfig = (await catchPromiseError(pLocalConfig, addPossibleError)) || {};
-        addPossibleError(localConfig?.__importRef?.error);
+        extractImportErrors(localConfig).forEach((e) => addPossibleError(e.error));
         const config = mergeSettings(settings, localConfig);
         const matcher = getGlobMatcherForExcluding(localConfig?.ignorePaths);
-        const docSettings = await determineTextDocumentSettings(doc, config);
         // eslint-disable-next-line unicorn/prefer-regexp-test
-        return !matcher.match(uriToFilePath(doc.uri)) && (docSettings.enabled ?? true);
+        if (matcher.match(uriToFilePath(doc.uri))) {
+            return { errors, shouldCheck: false, settings: localConfig, reason: 'Excluded by ignorePaths.' };
+        }
+        const docSettings = await determineTextDocumentSettings(doc, config);
+        const shouldCheck = docSettings.enabled ?? true;
+        const reason = shouldCheck ? undefined : 'Excluded by overrides or languageSettings.';
+        return { errors, shouldCheck, settings: docSettings, reason };
     }
-    return { errors, shouldCheck: await shouldCheck() };
+    return await shouldCheck();
 }
 export const __testing__ = {
     sanitizeSuggestion,

package/dist/lib/textValidation/isRandomString.d.ts

@@ -1,4 +1,4 @@
-import { TextOffset } from '@cspell/cspell-types';
+import type { TextOffset } from '@cspell/cspell-types';
 /**
  * Try to detect if a string is a random string of characters or is it camel case / snake case words.
  * @param s - string to check

package/dist/lib/textValidation/lineValidatorFactory.js

@@ -13,7 +13,7 @@ import { isWordValidWithEscapeRetry } from './isWordValid.js';
 import { mapRangeBackToOriginalPos } from './parsedText.js';
 const MIN_HEX_SEQUENCE_LENGTH = 8;
 export function lineValidatorFactory(sDict, options) {
-    const { minWordLength = defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, ignoreRandomStrings = defaultCSpellSettings.ignoreRandomStrings, minRandomLength = defaultCSpellSettings.minRandomLength, unknownWords = unknownWordsChoices.ReportAll, } = options;
+    const { minWordLength = defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, ignoreRandomStrings = defaultCSpellSettings.ignoreRandomStrings, minRandomLength = defaultCSpellSettings.minRandomLength, unknownWords = unknownWordsChoices.ReportAll, numSuggestions, } = options;
     const hasWordOptions = {
         ignoreCase,
         useCompounds: allowCompoundWords || undefined, // let the dictionaries decide on useCompounds if allow is false
@@ -67,17 +67,21 @@ export function lineValidatorFactory(sDict, options) {
         return autoResolve(cacheGetPreferredSuggestions, word, () => dictCol.getPreferredSuggestions(word));
     }
     const cacheHasSimpleSuggestions = new Map();
-    function hasSimpleSuggestions(word) {
+    function getSimpleSuggestions(word) {
+        const numSug = numSuggestions ?? 5;
         return autoResolve(cacheHasSimpleSuggestions, word, () => {
             const sugs = dictCol.suggest(word, {
                 numSuggestions: 1,
                 compoundMethod: 0,
-                includeTies: false,
+                includeTies: true, // We want the top suggestions even if there are ties
                 ignoreCase,
                 timeout: 100,
                 numChanges: 1.8, // Only consider very simple changes (1 edit distance plus case changes)
             });
-            return !!sugs.length;
+            if (sugs.length > numSug) {
+                sugs.length = numSug;
+            }
+            return sugs;
         });
     }
     function isWordFlagged(wo) {
@@ -92,7 +96,11 @@ export function lineValidatorFactory(sDict, options) {
         if (!sugs?.length) {
             issue.hasPreferredSuggestions = sugs !== undefined ? false : undefined;
             if (unknownWords === unknownWordsChoices.ReportSimple) {
-                issue.hasSimpleSuggestions = hasSimpleSuggestions(issue.text);
+                const sug = getSimpleSuggestions(issue.text);
+                issue.hasSimpleSuggestions = !!sug.length;
+                if (sug.length) {
+                    issue.suggestionsEx = sug.map((s) => ({ ...s, isPreferred: !!s.isPreferred }));
+                }
             }
             return issue;
         }

package/dist/lib/textValidation/traceWord.d.ts

@@ -31,6 +31,7 @@ export interface TraceResult extends Array<DictionaryTraceResult> {
 }
 export interface TraceOptions extends Pick<CSpellSettingsWithSourceTrace, 'source' | 'allowCompoundWords'> {
     ignoreCase?: boolean;
+    compoundSeparator?: string | undefined;
 }
 export declare function traceWord(word: string, dictCollection: SpellingDictionaryCollection, config: TraceOptions): TraceResult;
 export {};

package/dist/lib/textValidation/traceWord.js

@@ -7,6 +7,7 @@ export function traceWord(word, dictCollection, config) {
     const opts = {
         ignoreCase: config.ignoreCase ?? true,
         useCompounds: config.allowCompoundWords || false,
+        compoundSeparator: '•',
     };
     const splits = split({ text: word, offset: 0 }, 0, checkWord);
     const wfSplits = splits.words.map((s) => ({ word: s.text, found: s.isFound }));

package/dist/lib/trace.d.ts

@@ -1,5 +1,5 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
-import { ICSpellConfigFile } from 'cspell-config-lib';
+import type { ICSpellConfigFile } from 'cspell-config-lib';
 import type { LanguageId } from './fileTypes.js';
 import type { DictionaryTraceResult, WordSplits } from './textValidation/traceWord.js';
 export interface TraceResult extends DictionaryTraceResult {
@@ -11,6 +11,7 @@ export interface TraceOptions {
     locale?: LocaleId;
     ignoreCase?: boolean;
     allowCompoundWords?: boolean;
+    compoundSeparator?: string | undefined;
 }
 export interface TraceWordResult extends Array<TraceResult> {
     splits: readonly WordSplits[];

package/dist/lib/trace.js

@@ -15,7 +15,7 @@ export async function traceWords(words, settings, options) {
     return s;
 }
 export async function* traceWordsAsync(words, settingsOrConfig, options) {
-    const { languageId, locale: language, ignoreCase = true, allowCompoundWords } = options || {};
+    const { languageId, locale: language, ignoreCase = true, allowCompoundWords, compoundSeparator } = options || {};
     const settings = satisfiesCSpellConfigFile(settingsOrConfig)
         ? await resolveConfigFileImports(settingsOrConfig)
         : settingsOrConfig;
@@ -44,7 +44,7 @@ export async function* traceWordsAsync(words, settingsOrConfig, options) {
     const { config, dicts, activeDictionaries } = await finalize(settings);
     const setOfActiveDicts = new Set(activeDictionaries);
     function processWord(word) {
-        const results = traceWord(word, dicts, { ...config, ignoreCase });
+        const results = traceWord(word, dicts, { ...config, ignoreCase, compoundSeparator });
         const r = results.map((r) => ({
             ...r,
             dictActive: setOfActiveDicts.has(r.dictName),

package/dist/lib/util/errors.js

@@ -26,7 +26,7 @@ export function isError(e) {
     if (!e || typeof e !== 'object')
         return false;
     const ex = e;
-    return typeof ex.name == 'string' && typeof ex.message == 'string' && (typeof ex.stack) in allowStringOrUndefined;
+    return typeof ex.name === 'string' && typeof ex.message === 'string' && (typeof ex.stack) in allowStringOrUndefined;
 }
 export function toError(e, errorFactory = UnknownError) {
     if (isError(e))

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "9.3.2",
+  "version": "9.6.0",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -64,21 +64,21 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "9.3.2",
-    "@cspell/cspell-pipe": "9.3.2",
-    "@cspell/cspell-resolver": "9.3.2",
-    "@cspell/cspell-types": "9.3.2",
-    "@cspell/dynamic-import": "9.3.2",
-    "@cspell/filetypes": "9.3.2",
-    "@cspell/strong-weak-map": "9.3.2",
-    "@cspell/url": "9.3.2",
+    "@cspell/cspell-bundled-dicts": "9.6.0",
+    "@cspell/cspell-pipe": "9.6.0",
+    "@cspell/cspell-resolver": "9.6.0",
+    "@cspell/cspell-types": "9.6.0",
+    "@cspell/dynamic-import": "9.6.0",
+    "@cspell/filetypes": "9.6.0",
+    "@cspell/strong-weak-map": "9.6.0",
+    "@cspell/url": "9.6.0",
     "clear-module": "^4.1.2",
-    "cspell-config-lib": "9.3.2",
-    "cspell-dictionary": "9.3.2",
-    "cspell-glob": "9.3.2",
-    "cspell-grammar": "9.3.2",
-    "cspell-io": "9.3.2",
-    "cspell-trie-lib": "9.3.2",
+    "cspell-config-lib": "9.6.0",
+    "cspell-dictionary": "9.6.0",
+    "cspell-glob": "9.6.0",
+    "cspell-grammar": "9.6.0",
+    "cspell-io": "9.6.0",
+    "cspell-trie-lib": "9.6.0",
     "env-paths": "^3.0.0",
     "gensequence": "^8.0.8",
     "import-fresh": "^3.3.1",
@@ -91,21 +91,23 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "@cspell/dict-cpp": "^6.0.14",
-    "@cspell/dict-csharp": "^4.0.7",
-    "@cspell/dict-css": "^4.0.18",
+    "@cspell/cspell-tools": "9.6.0",
+    "@cspell/dict-cpp": "^7.0.2",
+    "@cspell/dict-csharp": "^4.0.8",
+    "@cspell/dict-css": "^4.0.19",
+    "@cspell/dict-en_us": "^4.4.27",
     "@cspell/dict-fa-ir": "^4.0.5",
     "@cspell/dict-fr-fr": "^2.3.2",
-    "@cspell/dict-html": "^4.0.12",
+    "@cspell/dict-html": "^4.0.14",
     "@cspell/dict-nl-nl": "^2.4.2",
-    "@cspell/dict-python": "^4.2.21",
+    "@cspell/dict-python": "^4.2.25",
     "@types/configstore": "^6.0.2",
-    "comment-json": "^4.4.1",
+    "comment-json": "^4.5.1",
     "configstore": "^7.1.0",
     "cspell-dict-nl-nl": "^1.1.2",
     "leaked-handles": "^5.2.0",
     "lorem-ipsum": "^2.0.8",
     "perf-insight": "^2.0.1"
   },
-  "gitHead": "595bde79b4a5abf3256b71129995ec3601454b02"
+  "gitHead": "163793ddf2a0ad90bc7c90351698a106003297af"
 }

package/dist/lib/perf/perf.d.ts

@@ -1,20 +0,0 @@
-interface PerfEntry {
-    readonly entryType: string;
-    readonly name: string;
-    readonly startTime: number;
-    readonly duration?: number | undefined;
-}
-interface PerfMark extends PerfEntry {
-    readonly entryType: 'mark';
-}
-export declare class PerfMonitor {
-    private _performance;
-    private _enabled;
-    constructor(_performance?: Performance);
-    mark(name: string): PerfMark;
-    get enabled(): boolean;
-    set enabled(value: boolean);
-}
-export declare const perf: PerfMonitor;
-export {};
-//# sourceMappingURL=perf.d.ts.map

package/dist/lib/perf/perf.js

@@ -1,32 +0,0 @@
-export class PerfMonitor {
-    _performance;
-    _enabled = false;
-    constructor(_performance = performance) {
-        this._performance = _performance;
-    }
-    mark(name) {
-        const mark = ((this._enabled && this._performance.mark(name)) || {
-            entryType: 'mark',
-            name,
-            startTime: performance.now(),
-        });
-        return mark;
-    }
-    // measure(name: string, startMark: string, endMark: string) {
-    //     return this._enabled && this._performance.measure(name, startMark, endMark);
-    // }
-    // clearMarks(name?: string) {
-    //     this._enabled && this._performance.clearMarks(name);
-    // }
-    // clearMeasures(name?: string) {
-    //     this._enabled && this._performance.clearMeasures(name);
-    // }
-    get enabled() {
-        return this._enabled;
-    }
-    set enabled(value) {
-        this._enabled = value;
-    }
-}
-export const perf = new PerfMonitor();
-//# sourceMappingURL=perf.js.map