cspell-lib 8.2.4 → 8.3.1

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

@@ -49,6 +49,7 @@ export interface IConfigLoader {
      * @returns the resulting settings
      */
     searchForConfig(searchFrom: URL | string | undefined, pnpSettings?: PnPSettingsOptional): Promise<CSpellSettingsI | undefined>;
+    resolveConfigFileLocation(filenameOrURL: string | URL, relativeTo?: string | URL): Promise<URL | undefined>;
     getGlobalSettingsAsync(): Promise<CSpellSettingsI>;
     /**
      * The loader caches configuration files for performance. This method clears the cache.
@@ -71,12 +72,15 @@ export interface IConfigLoader {
      */
     dispose(): void;
     getStats(): Readonly<Record<string, Readonly<Record<string, number>>>>;
+    readonly isTrusted: boolean;
+    setIsTrusted(isTrusted: boolean): void;
 }
 export declare class ConfigLoader implements IConfigLoader {
     readonly fs: VFileSystem;
     readonly templateVariables: Record<string, string>;
     onReady: Promise<void>;
     readonly fileResolver: FileResolver;
+    private _isTrusted;
     /**
      * Use `createConfigLoader`
      * @param virtualFs - virtual file system to use.
@@ -107,7 +111,9 @@ export declare class ConfigLoader implements IConfigLoader {
     getGlobalSettings(): CSpellSettingsI;
     getGlobalSettingsAsync(): Promise<CSpellSettingsI>;
     clearCachedSettingsFiles(): void;
+    protected init(): Promise<void>;
     protected prefetchGlobalSettingsAsync(): Promise<void>;
+    protected resolveDefaultConfig(): Promise<URL>;
     protected importSettings(fileRef: ImportFileRef, pnpSettings: PnPSettingsOptional | undefined, backReferences: string[]): ImportedConfigEntry;
     private setupPnp;
     mergeConfigFileWithImports(cfgFile: CSpellConfigFile, pnpSettings: PnPSettingsOptional | undefined, referencedBy?: string[] | undefined): Promise<CSpellSettingsI>;
@@ -124,7 +130,10 @@ export declare class ConfigLoader implements IConfigLoader {
         cacheMergeListUnique: Readonly<import("../../../util/AutoResolve.js").CacheStats>;
         cacheMergeLists: Readonly<import("../../../util/AutoResolve.js").CacheStats>;
     };
+    resolveConfigFileLocation(filenameOrURL: string | URL, relativeTo: string | URL): Promise<URL | undefined>;
     private resolveFilename;
+    get isTrusted(): boolean;
+    setIsTrusted(isTrusted: boolean): void;
 }
 declare class ConfigLoaderInternal extends ConfigLoader {
     constructor(vfs: VFileSystem);

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

@@ -4,6 +4,7 @@ import { isUrlLike, toFileURL } from 'cspell-io';
 import path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { URI, Utils as UriUtils } from 'vscode-uri';
+import { srcDirectory } from '../../../../lib-cjs/index.cjs';
 import { onClearCache } from '../../../events/index.js';
 import { getVirtualFS } from '../../../fileSystem.js';
 import { createCSpellSettingsInternal as csi } from '../../../Models/CSpellSettingsInternalDef.js';
@@ -12,7 +13,7 @@ import { logError, logWarning } from '../../../util/logger.js';
 import { FileResolver } from '../../../util/resolveFile.js';
 import { envToTemplateVars } from '../../../util/templates.js';
 import { addTrailingSlash, cwdURL, resolveFileWithURL, toFilePathOrHref, windowsDriveLetterToUpper, } from '../../../util/url.js';
-import { configSettingsFileVersion0_1, configSettingsFileVersion0_2, currentSettingsFileVersion, ENV_CSPELL_GLOB_ROOT, } from '../../constants.js';
+import { configSettingsFileVersion0_1, configSettingsFileVersion0_2, currentSettingsFileVersion, defaultConfigFileModuleRef, ENV_CSPELL_GLOB_ROOT, } from '../../constants.js';
 import { getMergeStats, mergeSettings } from '../../CSpellSettingsServer.js';
 import { getGlobalConfig } from '../../GlobalSettings.js';
 import { ImportError } from '../ImportError.js';
@@ -28,11 +29,19 @@ const setOfSupportedConfigVersions = Object.freeze(new Set(supportedCSpellConfig
 export const sectionCSpell = 'cSpell';
 export const defaultFileName = 'cspell.json';
 let defaultConfigLoader = undefined;
+const defaultExtensions = ['.json', '.yaml', '.yml', '.jsonc'];
+const defaultJsExtensions = ['.js', '.cjs', '.mjs'];
+const trustedSearch = new Map([
+    ['*', defaultExtensions],
+    ['file:', [...defaultExtensions, ...defaultJsExtensions]],
+]);
+const unTrustedSearch = new Map([['*', defaultExtensions]]);
 export class ConfigLoader {
     fs;
     templateVariables;
     onReady;
     fileResolver;
+    _isTrusted = true;
     /**
      * Use `createConfigLoader`
      * @param virtualFs - virtual file system to use.
@@ -40,10 +49,10 @@ export class ConfigLoader {
     constructor(fs, templateVariables = envToTemplateVars(process.env)) {
         this.fs = fs;
         this.templateVariables = templateVariables;
-        this.configSearch = new ConfigSearch(searchPlaces, fs);
+        this.configSearch = new ConfigSearch(searchPlaces, trustedSearch, fs);
         this.cspellConfigFileReaderWriter = createReaderWriter(undefined, undefined, createIO(fs));
         this.fileResolver = new FileResolver(fs, this.templateVariables);
-        this.onReady = this.prefetchGlobalSettingsAsync();
+        this.onReady = this.init();
         this.subscribeToEvents();
     }
     subscribeToEvents() {
@@ -140,10 +149,19 @@ export class ConfigLoader {
         this.cachedMergedConfig = new WeakMap();
         this.prefetchGlobalSettingsAsync();
     }
-    prefetchGlobalSettingsAsync() {
-        this.onReady = this.getGlobalSettingsAsync().then(() => undefined, (e) => logError(e));
+    init() {
+        this.onReady = Promise.all([this.prefetchGlobalSettingsAsync(), this.resolveDefaultConfig()]).then(() => undefined);
         return this.onReady;
     }
+    async prefetchGlobalSettingsAsync() {
+        await this.getGlobalSettingsAsync().catch((e) => logError(e));
+    }
+    async resolveDefaultConfig() {
+        const r = await this.fileResolver.resolveFile(defaultConfigFileModuleRef, srcDirectory);
+        const url = toFileURL(r.filename);
+        this.cspellConfigFileReaderWriter.setTrustedUrls([new URL('../..', url)]);
+        return url;
+    }
     importSettings(fileRef, pnpSettings, backReferences) {
         const url = toFileURL(fileRef.filename);
         const cacheKey = url.href;
@@ -318,6 +336,10 @@ export class ConfigLoader {
     getStats() {
         return { ...getMergeStats() };
     }
+    async resolveConfigFileLocation(filenameOrURL, relativeTo) {
+        const r = await this.fileResolver.resolveFile(filenameOrURL, relativeTo);
+        return r.found ? toFileURL(r.filename) : undefined;
+    }
     async resolveFilename(filename, relativeTo) {
         if (filename instanceof URL)
             return { filename: toFilePathOrHref(filename) };
@@ -332,6 +354,15 @@ export class ConfigLoader {
             error: r.found ? undefined : new Error(`Failed to resolve file: "${filename}"`),
         };
     }
+    get isTrusted() {
+        return this._isTrusted;
+    }
+    setIsTrusted(isTrusted) {
+        this._isTrusted = isTrusted;
+        this.clearCachedSettingsFiles();
+        this.configSearch = new ConfigSearch(searchPlaces, isTrusted ? trustedSearch : unTrustedSearch, this.fs);
+        this.cspellConfigFileReaderWriter.setUntrustedExtensions(isTrusted ? [] : defaultJsExtensions);
+    }
 }
 class ConfigLoaderInternal extends ConfigLoader {
     constructor(vfs) {

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

@@ -1,10 +1,17 @@
 import type { VFileSystem } from '../../../fileSystem.js';
 export declare class ConfigSearch {
     readonly searchPlaces: readonly string[];
+    readonly allowedExtensionsByProtocol: Map<string, readonly string[]>;
     private fs;
     private searchCache;
     private searchDirCache;
-    constructor(searchPlaces: readonly string[], fs: VFileSystem);
+    private searchPlacesByProtocol;
+    /**
+     * @param searchPlaces - The list of file names to search for.
+     * @param allowedExtensionsByProtocol - Map of allowed extensions by protocol, '*' is used to match all protocols.
+     * @param fs - The file system to use.
+     */
+    constructor(searchPlaces: readonly string[], allowedExtensionsByProtocol: Map<string, readonly string[]>, fs: VFileSystem);
     searchForConfig(searchFromURL: URL): Promise<URL | undefined>;
     clearCache(): void;
     private findUpConfigPath;

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

@@ -1,15 +1,25 @@
+import { extname } from 'node:path/posix';
 import { urlBasename } from 'cspell-io';
 import { createAutoResolveCache } from '../../../util/AutoResolve.js';
 import { findUpFromUrl } from '../../../util/findUpFromUrl.js';
 export class ConfigSearch {
     searchPlaces;
+    allowedExtensionsByProtocol;
     fs;
     searchCache = new Map();
     searchDirCache = new Map();
-    constructor(searchPlaces, fs) {
+    searchPlacesByProtocol;
+    /**
+     * @param searchPlaces - The list of file names to search for.
+     * @param allowedExtensionsByProtocol - Map of allowed extensions by protocol, '*' is used to match all protocols.
+     * @param fs - The file system to use.
+     */
+    constructor(searchPlaces, allowedExtensionsByProtocol, fs) {
         this.searchPlaces = searchPlaces;
+        this.allowedExtensionsByProtocol = allowedExtensionsByProtocol;
         this.fs = fs;
-        this.searchPlaces = searchPlaces;
+        this.searchPlacesByProtocol = setupSearchPlacesByProtocol(searchPlaces, allowedExtensionsByProtocol);
+        this.searchPlaces = this.searchPlacesByProtocol.get('*') || searchPlaces;
     }
     searchForConfig(searchFromURL) {
         const dirUrl = new URL('.', searchFromURL);
@@ -105,7 +115,8 @@ export class ConfigSearch {
         const hasFile = this.fs.getCapabilities(dir).readDirectory
             ? this.createHasFileDirSearch()
             : this.createHasFileStatCheck();
-        for (const searchPlace of this.searchPlaces) {
+        const searchPlaces = this.searchPlacesByProtocol.get(dir.protocol) || this.searchPlaces;
+        for (const searchPlace of searchPlaces) {
             const file = new URL(searchPlace, dir);
             const found = await hasFile(file);
             if (found) {
@@ -118,6 +129,12 @@ export class ConfigSearch {
         return undefined;
     }
 }
+function setupSearchPlacesByProtocol(searchPlaces, allowedExtensionsByProtocol) {
+    const map = new Map([...allowedExtensionsByProtocol.entries()]
+        .map(([k, v]) => [k, new Set(v)])
+        .map(([protocol, exts]) => [protocol, searchPlaces.filter((url) => exts.has(extname(url)))]));
+    return map;
+}
 async function checkPackageJson(fs, filename) {
     try {
         const file = await fs.readFile(filename);

package/dist/esm/Settings/DefaultSettings.js

@@ -3,11 +3,11 @@ import { srcDirectory } from '../../lib-cjs/index.cjs';
 import { createCSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef.js';
 import { PatternRegExp } from '../Models/PatternRegExp.js';
 import { resolveFile } from '../util/resolveFile.js';
+import { defaultConfigFileModuleRef } from './constants.js';
 import { readSettings } from './Controller/configLoader/index.js';
 import { mergeSettings } from './CSpellSettingsServer.js';
 import * as LanguageSettings from './LanguageSettings.js';
 import * as RegPat from './RegExpPatterns.js';
-const defaultConfigFileModuleRef = '@cspell/cspell-bundled-dicts/cspell-default.json';
 // Do not use require.resolve because webpack will mess it up.
 const defaultConfigFile = () => resolveConfigModule(defaultConfigFileModuleRef);
 const regExpSpellCheckerDisable = [

package/dist/esm/Settings/constants.d.ts

@@ -2,4 +2,5 @@ export declare const configSettingsFileVersion0_1 = "0.1";
 export declare const configSettingsFileVersion0_2 = "0.2";
 export declare const currentSettingsFileVersion = "0.2";
 export declare const ENV_CSPELL_GLOB_ROOT = "CSPELL_GLOB_ROOT";
+export declare const defaultConfigFileModuleRef = "@cspell/cspell-bundled-dicts/cspell-default.json";
 //# sourceMappingURL=constants.d.ts.map

package/dist/esm/Settings/constants.js

@@ -2,4 +2,5 @@ export const configSettingsFileVersion0_1 = '0.1';
 export const configSettingsFileVersion0_2 = '0.2';
 export const currentSettingsFileVersion = configSettingsFileVersion0_2;
 export const ENV_CSPELL_GLOB_ROOT = 'CSPELL_GLOB_ROOT';
+export const defaultConfigFileModuleRef = '@cspell/cspell-bundled-dicts/cspell-default.json';
 //# sourceMappingURL=constants.js.map

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

@@ -1,6 +1,17 @@
+import type { CSpellSettings } from '@cspell/cspell-types';
 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 refreshDictionaryCache(maxAge?: number): Promise<void>;
 export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
+export declare const specialDictionaryNames: {
+    readonly words: "[words]";
+    readonly userWords: "[userWords]";
+    readonly flagWords: "[flagWords]";
+    readonly ignoreWords: "[ignoreWords]";
+    readonly suggestWords: "[suggestWords]";
+};
+export type DictionaryNameFields = keyof typeof specialDictionaryNames;
+export declare const mapSpecialDictionaryNamesToSettings: Map<string, DictionaryNameFields>;
+export declare function getInlineConfigDictionaries(settings: CSpellSettings): SpellingDictionary[];
 //# sourceMappingURL=Dictionaries.d.ts.map

package/dist/esm/SpellingDictionary/Dictionaries.js

@@ -13,29 +13,40 @@ export async function getDictionaryInternal(settings) {
     const spellDictionaries = await Promise.all(loadDictionaryDefs(calcDictionaryDefsToLoad(settings)));
     return _getDictionaryInternal(settings, spellDictionaries);
 }
-function _getDictionaryInternal(settings, spellDictionaries) {
+export const specialDictionaryNames = {
+    words: '[words]',
+    userWords: '[userWords]',
+    flagWords: '[flagWords]',
+    ignoreWords: '[ignoreWords]',
+    suggestWords: '[suggestWords]',
+};
+export const mapSpecialDictionaryNamesToSettings = new Map(Object.entries(specialDictionaryNames).map(([k, v]) => [v, k]));
+export function getInlineConfigDictionaries(settings) {
     const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords, suggestWords = emptyWords, } = settings;
-    const settingsWordsDictionary = createSpellingDictionary(words, '[words]', 'From Settings `words`', {
+    const settingsWordsDictionary = createSpellingDictionary(words, specialDictionaryNames.words, 'From Settings `words`', {
         caseSensitive: true,
         weightMap: undefined,
     });
     const settingsUserWordsDictionary = userWords.length
-        ? createSpellingDictionary(userWords, '[userWords]', 'From Settings `userWords`', {
+        ? createSpellingDictionary(userWords, specialDictionaryNames.userWords, 'From Settings `userWords`', {
             caseSensitive: true,
             weightMap: undefined,
         })
         : undefined;
-    const ignoreWordsDictionary = createIgnoreWordsDictionary(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`');
-    const flagWordsDictionary = createForbiddenWordsDictionary(flagWords, '[flagWords]', 'From Settings `flagWords`');
+    const ignoreWordsDictionary = createIgnoreWordsDictionary(ignoreWords, specialDictionaryNames.ignoreWords, 'From Settings `ignoreWords`');
+    const flagWordsDictionary = createForbiddenWordsDictionary(flagWords, specialDictionaryNames.flagWords, 'From Settings `flagWords`');
     const suggestWordsDictionary = createSuggestDictionary(suggestWords, '[suggestWords]', 'From Settings `suggestWords`');
     const dictionaries = [
-        ...spellDictionaries,
         settingsWordsDictionary,
         settingsUserWordsDictionary,
         ignoreWordsDictionary,
         flagWordsDictionary,
         suggestWordsDictionary,
     ].filter(isDefined);
+    return dictionaries;
+}
+function _getDictionaryInternal(settings, spellDictionaries) {
+    const dictionaries = [...spellDictionaries, ...getInlineConfigDictionaries(settings)];
     return createCollection(dictionaries, 'dictionary collection');
 }
 //# sourceMappingURL=Dictionaries.js.map

package/dist/esm/index.d.ts

@@ -16,7 +16,7 @@ export { CompoundWordsMethod, createSpellingDictionary, createCollection as crea
 export type { SuggestedWord, SuggestionOptions, SuggestionsForWordResult } from './suggestions.js';
 export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions.js';
 export { DocumentValidator, DocumentValidatorOptions, shouldCheckDocument } from './textValidation/index.js';
-export type { TraceOptions, TraceResult } from './trace.js';
+export type { TraceOptions, TraceResult, TraceWordResult } from './trace.js';
 export { traceWords, traceWordsAsync } from './trace.js';
 export { getLogger, Logger, setLogger } from './util/logger.js';
 export { resolveFile } from './util/resolveFile.js';

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

@@ -1,6 +1,7 @@
 import type { MappedText, TextOffset as TextOffsetRW } from '@cspell/cspell-types';
 import type { ExtendedSuggestion } from '../Models/Suggestion.js';
 import type { ValidationIssue } from '../Models/ValidationIssue.js';
+export type { TextOffset as TextOffsetRW } from '@cspell/cspell-types';
 export type TextOffsetRO = Readonly<TextOffsetRW>;
 export interface ValidationOptions extends IncludeExcludeOptions {
     maxNumberOfProblems?: number;

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

@@ -77,16 +77,7 @@ export declare class DocumentValidator {
      * @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;
-    }[];
+    traceWord(word: string): import("./traceWord.js").TraceResult;
     private defaultParser;
     private _checkParsedText;
     private addPossibleError;

package/dist/esm/textValidation/docValidator.js

@@ -11,13 +11,13 @@ 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';
 import { createMappedTextSegmenter } from './parsedText.js';
 import { settingsToValidateOptions } from './settingsToValidateOptions.js';
 import { calcTextInclusionRanges } from './textValidator.js';
+import { traceWord } from './traceWord.js';
 const ERROR_NOT_PREPARED = 'Validator Must be prepared before calling this function.';
 export class DocumentValidator {
     settings;
@@ -248,25 +248,7 @@ export class DocumentValidator {
     }
     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;
+        return traceWord(word, this._preparations.dictionary, this._preparations.config);
     }
     defaultParser() {
         return pipeSync(this.document.getLines(), opMap((line) => {
@@ -409,7 +391,4 @@ 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/textValidation/lineValidatorFactory.js

@@ -88,7 +88,7 @@ export function lineValidatorFactory(sDict, options) {
                 };
                 return [vr];
             }
-            const mismatches = toArray(pipe(Text.extractWordsFromTextOffset(possibleWord), opFilter(filterAlreadyChecked), opMap((wo) => ({ ...wo, line: lineSegment.line })), opMap(annotateIsFlagged), opFilter(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), opConcatMap(checkFullWord)));
+            const mismatches = toArray(pipe(Text.extractWordsFromTextOffset(possibleWord), opFilter((wo) => filterAlreadyChecked(wo)), opMap((wo) => ((wo.line = lineSegment.line), wo)), opMap(annotateIsFlagged), opFilter(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), opConcatMap(checkFullWord)));
             if (mismatches.length) {
                 // Try the more expensive word splitter
                 const splitResult = split(lineSegment.segment, possibleWord.offset, splitterIsValid);

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

@@ -0,0 +1,27 @@
+import type { CSpellSettingsWithSourceTrace } from '@cspell/cspell-types';
+import type { SpellingDictionaryCollection } from '../SpellingDictionary/index.js';
+type Href = string;
+export interface DictionaryTraceResult {
+    word: string;
+    found: boolean;
+    foundWord: string | undefined;
+    forbidden: boolean;
+    noSuggest: boolean;
+    dictName: string;
+    dictSource: string;
+    configSource: Href | undefined;
+    errors: Error[] | undefined;
+}
+export interface WordSplits {
+    word: string;
+    found: boolean;
+}
+export interface TraceResult extends Array<DictionaryTraceResult> {
+    splits?: readonly WordSplits[];
+}
+export interface TraceOptions extends Pick<CSpellSettingsWithSourceTrace, 'source' | 'allowCompoundWords'> {
+    ignoreCase?: boolean;
+}
+export declare function traceWord(word: string, dictCollection: SpellingDictionaryCollection, config: TraceOptions): TraceResult;
+export {};
+//# sourceMappingURL=traceWord.d.ts.map

package/dist/esm/textValidation/traceWord.js

@@ -0,0 +1,106 @@
+import { getSources } from '../Settings/index.js';
+import { createCollection, getInlineConfigDictionaries, mapSpecialDictionaryNamesToSettings, } from '../SpellingDictionary/index.js';
+import { toFileUrl } from '../util/url.js';
+import { uniqueFn } from '../util/util.js';
+import { split } from '../util/wordSplitter.js';
+export function traceWord(word, dictCollection, config) {
+    const opts = {
+        ignoreCase: true,
+        useCompounds: config.allowCompoundWords || false,
+    };
+    const splits = split({ text: word, offset: 0 }, 0, checkWord);
+    const wfSplits = splits.words.map((s) => ({ word: s.text, found: s.isFound }));
+    const unique = uniqueFn((w) => w.word + '|' + w.found);
+    const wsFound = { word, found: dictCollection.has(word, opts) };
+    const wordSplits = wfSplits.find((s) => s.word === word) ? wfSplits : [wsFound, ...wfSplits];
+    const traces = wordSplits
+        .filter(unique)
+        .map((s) => s.word)
+        .flatMap((word) => dictCollection.dictionaries.map((dict) => ({ dict, word })))
+        .map(({ dict, word }) => ({ dict, findResult: dict.find(word, opts), word }))
+        .flatMap((r) => unpackDictionaryFindResult(r, config));
+    const r = new CTraceResult(...traces);
+    r.splits = wordSplits;
+    return r;
+    function checkWord(wo) {
+        return dictCollection.has(wo.text, opts);
+    }
+}
+/**
+ * Map FindInDictResult to DictionaryTraceResult
+ * If the word was found in a dictionary based upon a config field setting, then find the source config.
+ * @param found - a word found in a dictionary
+ * @param config - the trace config
+ * @returns DictionaryTraceResult[]
+ */
+function unpackDictionaryFindResult(found, config) {
+    const { word, dict, findResult } = found;
+    const baseResult = {
+        word,
+        found: !!findResult?.found,
+        foundWord: findResult?.found || undefined,
+        forbidden: findResult?.forbidden || false,
+        noSuggest: findResult?.noSuggest || false,
+        dictName: dict.name,
+        dictSource: dict.source,
+        configSource: undefined,
+        errors: normalizeErrors(dict.getErrors?.()),
+    };
+    const configFieldName = mapSpecialDictionaryNamesToSettings.get(dict.name);
+    if (!findResult?.found || !configFieldName || !config.source) {
+        return [baseResult];
+    }
+    const opts = {
+        ignoreCase: true,
+        useCompounds: config.allowCompoundWords || false,
+    };
+    const sources = getSources(config);
+    const results = [];
+    for (const src of sources) {
+        if (!src[configFieldName] ||
+            !Array.isArray(src[configFieldName]) ||
+            !src[configFieldName]?.length ||
+            !src.source?.filename) {
+            continue;
+        }
+        // We found a possible config, build a dictionary result for it.
+        const configSource = toFileUrl(src.source.filename).href;
+        const cfg = { [configFieldName]: src[configFieldName] };
+        const cfgDict = createCollection(getInlineConfigDictionaries(cfg), dict.name, configSource);
+        const findResult = cfgDict.find(word, opts);
+        if (!findResult?.found)
+            continue;
+        const result = {
+            word,
+            found: !!findResult?.found,
+            foundWord: findResult?.found || undefined,
+            forbidden: findResult?.forbidden || false,
+            noSuggest: findResult?.noSuggest || false,
+            dictName: dict.name,
+            dictSource: configSource,
+            configSource,
+            errors: normalizeErrors(dict.getErrors?.()),
+        };
+        results.push(result);
+        // console.log('unpackDictFindResult %o', {
+        //     id: src.id,
+        //     name: src.name,
+        //     filename: src.source?.filename,
+        //     configFieldName,
+        //     findResult,
+        //     cfg,
+        //     result,
+        // });
+    }
+    return results.length ? results : [baseResult];
+}
+function normalizeErrors(errors) {
+    return errors?.length ? errors : undefined;
+}
+class CTraceResult extends Array {
+    splits = [];
+    constructor(...items) {
+        super(...items);
+    }
+}
+//# sourceMappingURL=traceWord.js.map

package/dist/esm/trace.d.ts

@@ -1,5 +1,6 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
 import type { LanguageId } from './LanguageIds.js';
+import type { WordSplits } from './textValidation/traceWord.js';
 export interface TraceResult {
     word: string;
     found: boolean;
@@ -18,6 +19,9 @@ export interface TraceOptions {
     ignoreCase?: boolean;
     allowCompoundWords?: boolean;
 }
+export interface TraceWordResult extends Array<TraceResult> {
+    splits: readonly WordSplits[];
+}
 export declare function traceWords(words: string[], settings: CSpellSettings, options: TraceOptions | undefined): Promise<TraceResult[]>;
-export declare function traceWordsAsync(words: Iterable<string> | AsyncIterable<string>, settings: CSpellSettings, options: TraceOptions | undefined): AsyncIterableIterator<TraceResult[]>;
+export declare function traceWordsAsync(words: Iterable<string> | AsyncIterable<string>, settings: CSpellSettings, options: TraceOptions | undefined): AsyncIterableIterator<TraceWordResult>;
 //# sourceMappingURL=trace.d.ts.map

package/dist/esm/trace.js

@@ -3,6 +3,7 @@ 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 { traceWord } from './textValidation/traceWord.js';
 import { toFilePathOrHref } from './util/url.js';
 import * as util from './util/util.js';
 export async function traceWords(words, settings, options) {
@@ -37,33 +38,27 @@ export async function* traceWordsAsync(words, settings, options) {
     await refreshDictionaryCache();
     const { config, dicts, activeDictionaries } = await finalize(settings);
     const setOfActiveDicts = new Set(activeDictionaries);
-    const opts = util.clean({ ignoreCase, useCompounds: config.allowCompoundWords });
-    function normalizeErrors(errors) {
-        if (!errors?.length)
-            return undefined;
-        return errors;
-    }
     function processWord(word) {
-        return dicts.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: dictSourceToFilename(dict.source),
-            dictActive: setOfActiveDicts.has(dict.name),
-            configSource: config.name || '',
-            errors: normalizeErrors(dict.getErrors?.()),
+        const results = traceWord(word, dicts, { ...config, ignoreCase });
+        const r = results.map((r) => ({
+            ...r,
+            dictActive: setOfActiveDicts.has(r.dictName),
+            dictSource: toFilePathOrHref(r.dictSource),
+            configSource: r.configSource || config.name || '',
+            splits: results.splits,
         }));
+        const tr = new CTraceResult(...r);
+        results.splits && tr.splits.push(...results.splits);
+        return tr;
     }
     for await (const word of words) {
         yield processWord(word);
     }
 }
-function dictSourceToFilename(source) {
-    return toFilePathOrHref(source);
+class CTraceResult extends Array {
+    splits = [];
+    constructor(...items) {
+        super(...items);
+    }
 }
 //# sourceMappingURL=trace.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.2.4",
+  "version": "8.3.1",
   "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.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",
+    "@cspell/cspell-bundled-dicts": "8.3.1",
+    "@cspell/cspell-pipe": "8.3.1",
+    "@cspell/cspell-resolver": "8.3.1",
+    "@cspell/cspell-types": "8.3.1",
+    "@cspell/dynamic-import": "8.3.1",
+    "@cspell/strong-weak-map": "8.3.1",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^6.0.0",
-    "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",
+    "cspell-config-lib": "8.3.1",
+    "cspell-dictionary": "8.3.1",
+    "cspell-glob": "8.3.1",
+    "cspell-grammar": "8.3.1",
+    "cspell-io": "8.3.1",
+    "cspell-trie-lib": "8.3.1",
     "fast-equals": "^5.0.1",
     "gensequence": "^6.0.0",
     "import-fresh": "^3.3.0",
@@ -95,5 +95,5 @@
     "cspell-dict-nl-nl": "^1.1.2",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "d3c5ff685b3aa2bf984f557d81380f2c994547e0"
+  "gitHead": "7136c39fd5f47c2acd44bec0bede924e55e1a107"
 }