cspell-lib 8.16.0 → 8.17.0

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

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import { CSpellConfigFile } from 'cspell-config-lib';
 import { createReaderWriter } from 'cspell-config-lib';
 import { isUrlLike, toFileURL } from 'cspell-io';
@@ -13,7 +13,7 @@ import { autoResolve, AutoResolveCache, autoResolveWeak } from '../../../util/Au
 import { logError, logWarning } from '../../../util/logger.js';
 import { FileResolver } from '../../../util/resolveFile.js';
 import { envToTemplateVars } from '../../../util/templates.js';
-import { addTrailingSlash, cwdURL, resolveFileWithURL, toFilePathOrHref, toFileUrl, windowsDriveLetterToUpper, } from '../../../util/url.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 { getGlobalConfig } from '../../GlobalSettings.js';
@@ -70,12 +70,12 @@ export class ConfigLoader {
     toDispose = [];
     async readSettingsAsync(filename, relativeTo, pnpSettings) {
         await this.onReady;
-        const ref = await this.resolveFilename(filename, relativeTo || pathToFileURL('./'));
+        const ref = await this.resolveFilename(filename, relativeTo || toFileDirURL('./'));
         const entry = this.importSettings(ref, pnpSettings || defaultPnPSettings, []);
         return entry.onReady;
     }
     async readConfigFile(filenameOrURL, relativeTo) {
-        const ref = await this.resolveFilename(filenameOrURL.toString(), relativeTo || pathToFileURL('./'));
+        const ref = await this.resolveFilename(filenameOrURL.toString(), relativeTo || toFileDirURL('./'));
         const url = toFileURL(ref.filename);
         const href = url.href;
         if (ref.error)

package/dist/lib/Settings/GlobalSettings.js

@@ -1,5 +1,5 @@
-import { pathToFileURL } from 'node:url';
 import { CSpellConfigFileInMemory, CSpellConfigFileJson } from 'cspell-config-lib';
+import { toFileURL } from 'cspell-io';
 import { getSourceDirectoryUrl, toFilePathOrHref } from '../util/url.js';
 import { GlobalConfigStore } from './cfgStore.js';
 import { configToRawSettings } from './Controller/configLoader/configToRawSettings.js';
@@ -10,7 +10,7 @@ export async function getRawGlobalSettings() {
 export async function getGlobalConfig() {
     const name = 'CSpell Configstore';
     const configPath = getGlobalConfigPath();
-    let urlGlobal = configPath ? pathToFileURL(configPath) : new URL('global-config.json', getSourceDirectoryUrl());
+    let urlGlobal = configPath ? toFileURL(configPath) : new URL('global-config.json', getSourceDirectoryUrl());
     const source = {
         name,
         filename: toFilePathOrHref(urlGlobal),
@@ -20,7 +20,7 @@ export async function getGlobalConfig() {
     const found = await globalConfig.readConfigFile();
     if (found && found.config && found.filename) {
         const cfg = found.config;
-        urlGlobal = pathToFileURL(found.filename);
+        urlGlobal = toFileURL(found.filename);
         // Only populate globalConf is there are values.
         if (cfg && Object.keys(cfg).length) {
             Object.assign(globalConf, cfg);

package/dist/lib/Settings/resolveCwd.js

@@ -1,4 +1,4 @@
-import { pathToFileURL } from 'node:url';
+import { toFileDirURL, toFileURL } from '@cspell/url';
 export class CwdUrlResolver {
     #lastPath;
     #lastUrl;
@@ -6,7 +6,7 @@ export class CwdUrlResolver {
     #cwdUrl;
     constructor() {
         this.#cwd = process.cwd();
-        this.#cwdUrl = pathToFileURL(this.#cwd);
+        this.#cwdUrl = toFileDirURL(this.#cwd);
         this.#lastPath = this.#cwd;
         this.#lastUrl = this.#cwdUrl;
     }
@@ -17,12 +17,12 @@ export class CwdUrlResolver {
         if (path === this.#cwd)
             return this.#cwdUrl;
         this.#lastPath = path;
-        this.#lastUrl = pathToFileURL(path);
+        this.#lastUrl = toFileURL(path);
         return this.#lastUrl;
     }
     reset(cwd = process.cwd()) {
         this.#cwd = cwd;
-        this.#cwdUrl = pathToFileURL(this.#cwd);
+        this.#cwdUrl = toFileDirURL(this.#cwd);
     }
 }
 //# sourceMappingURL=resolveCwd.js.map

package/dist/lib/spellCheckFile.d.ts

@@ -1,4 +1,5 @@
 import type { CSpellSettingsWithSourceTrace, CSpellUserSettings } from '@cspell/cspell-types';
+import { 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';
@@ -45,14 +46,14 @@ export interface SpellCheckFileResult {
  * @param options - options to control checking
  * @param settings - default settings to use.
  */
-export declare function spellCheckFile(file: string | Uri | URL, options: SpellCheckFileOptions, settings: CSpellUserSettings): Promise<SpellCheckFileResult>;
+export declare function spellCheckFile(file: string | Uri | URL, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
 /**
  * Spell Check a Document.
  * @param document - document to be checked. If `document.text` is `undefined` the file will be loaded
  * @param options - options to control checking
  * @param settings - default settings to use.
  */
-export declare function spellCheckDocument(document: Document | DocumentWithText, options: SpellCheckFileOptions, settings: CSpellUserSettings): Promise<SpellCheckFileResult>;
+export declare function spellCheckDocument(document: Document | DocumentWithText, options: SpellCheckFileOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<SpellCheckFileResult>;
 export interface DetermineFinalDocumentSettingsResult {
     document: DocumentWithText;
     settings: CSpellSettingsWithSourceTrace;

package/dist/lib/spellCheckFile.js

@@ -1,3 +1,4 @@
+import { satisfiesCSpellConfigFile } from 'cspell-config-lib';
 import { isBinaryDoc } from './Document/isBinaryDoc.js';
 import { documentToTextDocument, resolveDocument } from './Document/resolveDocument.js';
 import { createTextDocument } from './Models/TextDocument.js';
@@ -12,11 +13,11 @@ import { toUri } from './util/Uri.js';
  * @param options - options to control checking
  * @param settings - default settings to use.
  */
-export function spellCheckFile(file, options, settings) {
+export function spellCheckFile(file, options, settingsOrConfigFile) {
     const doc = {
         uri: toUri(file).toString(),
     };
-    return spellCheckDocument(doc, options, settings);
+    return spellCheckDocument(doc, options, settingsOrConfigFile);
 }
 /**
  * Spell Check a Document.
@@ -24,12 +25,15 @@ export function spellCheckFile(file, options, settings) {
  * @param options - options to control checking
  * @param settings - default settings to use.
  */
-export async function spellCheckDocument(document, options, settings) {
+export async function spellCheckDocument(document, options, settingsOrConfigFile) {
+    const settingsUsed = satisfiesCSpellConfigFile(settingsOrConfigFile)
+        ? settingsOrConfigFile.settings
+        : settingsOrConfigFile;
     if (isBinaryDoc(document)) {
         return {
             document,
             options,
-            settingsUsed: settings,
+            settingsUsed,
             localConfigFilepath: undefined,
             issues: [],
             checked: false,
@@ -43,14 +47,14 @@ export async function spellCheckDocument(document, options, settings) {
             return {
                 document,
                 options,
-                settingsUsed: settings,
+                settingsUsed,
                 localConfigFilepath: undefined,
                 issues: [],
                 checked: false,
                 errors: undefined,
             };
         }
-        const result = await spellCheckFullDocument(doc, options, settings);
+        const result = await spellCheckFullDocument(doc, options, settingsOrConfigFile);
         const perf = result.perf || {};
         perf.loadTimeMs = timer.elapsed;
         result.perf = perf;
@@ -61,7 +65,7 @@ export async function spellCheckDocument(document, options, settings) {
         return {
             document,
             options,
-            settingsUsed: settings,
+            settingsUsed,
             localConfigFilepath: undefined,
             issues: [],
             checked: false,
@@ -69,7 +73,7 @@ export async function spellCheckDocument(document, options, settings) {
         };
     }
 }
-async function spellCheckFullDocument(document, options, settings) {
+async function spellCheckFullDocument(document, options, settingsOrConfigFile) {
     // if (options.skipValidation) {
     //     return {
     //         document,
@@ -87,15 +91,17 @@ async function spellCheckFullDocument(document, options, settings) {
     const timerPrepare = createPerfTimer('prepare', (elapsed) => (perf.prepareTimeMs = elapsed));
     const doc = documentToTextDocument(document);
     const docValOptions = options;
-    const docValidator = new DocumentValidator(doc, docValOptions, settings);
-    await docValidator.prepare().finally(() => timerPrepare.end());
+    const docValidator = await DocumentValidator.create(doc, docValOptions, settingsOrConfigFile).finally(() => timerPrepare.end());
     Object.assign(perf, Object.fromEntries(Object.entries(docValidator.perfTiming).map(([k, v]) => ['_' + k, v])));
     const prep = docValidator._getPreparations();
     if (docValidator.errors.length) {
         return {
             document,
             options,
-            settingsUsed: prep?.localConfig || settings,
+            settingsUsed: prep?.localConfig ||
+                (satisfiesCSpellConfigFile(settingsOrConfigFile)
+                    ? settingsOrConfigFile.settings
+                    : settingsOrConfigFile),
             localConfigFilepath: prep?.localConfigFilepath,
             issues: [],
             checked: false,

package/dist/lib/suggestions.d.ts

@@ -1,4 +1,5 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
+import { 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 {
@@ -64,7 +65,7 @@ export interface SuggestionOptions extends FromSuggestOptions {
     includeDefaultConfig?: boolean;
 }
 export declare function suggestionsForWords(words: Iterable<string> | AsyncIterable<string>, options?: SuggestionOptions, settings?: CSpellSettings): AsyncIterable<SuggestionsForWordResult>;
-export declare function suggestionsForWord(word: string, options?: SuggestionOptions, settings?: CSpellSettings): Promise<SuggestionsForWordResult>;
+export declare function suggestionsForWord(word: string, options?: SuggestionOptions, settings?: CSpellSettings | ICSpellConfigFile): Promise<SuggestionsForWordResult>;
 export declare function calcSuggestionAdjustedToToMatchCase<T extends SuggestionResult>(originalWord: string, sugs: T[], locale: string | string[] | undefined, ignoreCase: boolean, dict: SpellingDictionaryCollection): (T & WordSuggestion)[];
 export declare class SuggestionError extends Error {
     readonly code: string;

package/dist/lib/suggestions.js

@@ -1,5 +1,6 @@
 import assert from 'node:assert';
-import { finalizeSettings, getDefaultSettings, getGlobalSettingsAsync, mergeSettings } from './Settings/index.js';
+import { satisfiesCSpellConfigFile } from 'cspell-config-lib';
+import { finalizeSettings, getDefaultSettings, getGlobalSettingsAsync, mergeSettings, resolveConfigFileImports, } from './Settings/index.js';
 import { calcSettingsForLanguageId, isValidLocaleIntlFormat, normalizeLocaleIntl, } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';
 import { createAutoResolveCache } from './util/AutoResolve.js';
@@ -8,8 +9,9 @@ import * as util from './util/util.js';
 const emptySuggestionOptions = Object.freeze({});
 const emptyCSpellSettings = Object.freeze({});
 export async function* suggestionsForWords(words, options, settings) {
+    const cspellSettings = satisfiesCSpellConfigFile(settings) ? await resolveConfigFileImports(settings) : settings;
     for await (const word of words) {
-        yield await suggestionsForWord(word, options, settings);
+        yield await suggestionsForWord(word, options, cspellSettings);
     }
 }
 const memorizeSuggestions = memorizeLastCall(cacheSuggestionsForWord);
@@ -17,8 +19,9 @@ function cacheSuggestionsForWord(options, settings) {
     const cache = createAutoResolveCache();
     return (word) => cache.get(word, (word) => _suggestionsForWord(word, options, settings));
 }
-export function suggestionsForWord(word, options = emptySuggestionOptions, settings = emptyCSpellSettings) {
-    return memorizeSuggestions(options, settings)(word);
+export async function suggestionsForWord(word, options = emptySuggestionOptions, settings = emptyCSpellSettings) {
+    const cspellSettings = satisfiesCSpellConfigFile(settings) ? await resolveConfigFileImports(settings) : settings;
+    return memorizeSuggestions(options, cspellSettings)(word);
 }
 async function _suggestionsForWord(word, options, settings) {
     const { languageId, locale: language, includeDefaultConfig = true, dictionaries } = options;

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

@@ -11,6 +11,8 @@ export interface ValidationOptions extends IncludeExcludeOptions {
     allowCompoundWords?: boolean;
     /** ignore case when checking words against dictionary or ignore words list */
     ignoreCase: boolean;
+    ignoreRandomStrings?: boolean | undefined;
+    minRandomLength?: number | undefined;
 }
 export interface CheckOptions extends ValidationOptions {
     allowCompoundWords: boolean;

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

@@ -1,4 +1,5 @@
 import type { CSpellUserSettings, MappedText, ParsedText } from '@cspell/cspell-types';
+import { 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';
@@ -44,6 +45,7 @@ export declare class DocumentValidator {
     readonly options: DocumentValidatorOptions;
     readonly perfTiming: PerfTimings;
     skipValidation: boolean;
+    static create(doc: TextDocument, options: DocumentValidatorOptions, settingsOrConfigFile: CSpellUserSettings | ICSpellConfigFile): Promise<DocumentValidator>;
     /**
      * @param doc - Document to validate
      * @param config - configuration to use (not finalized).

package/dist/lib/textValidation/docValidator.js

@@ -1,12 +1,12 @@
 import assert from 'node:assert';
-import { pathToFileURL } from 'node:url';
 import { opConcatMap, opMap, pipeSync } from '@cspell/cspell-pipe/sync';
 import { IssueType } from '@cspell/cspell-types';
 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, resolveSettingsImports, searchForConfig, } from '../Settings/index.js';
+import { 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';
@@ -33,6 +33,14 @@ export class DocumentValidator {
     options;
     perfTiming = {};
     skipValidation;
+    static async create(doc, options, settingsOrConfigFile) {
+        const settings = satisfiesCSpellConfigFile(settingsOrConfigFile)
+            ? await resolveConfigFileImports(settingsOrConfigFile)
+            : settingsOrConfigFile;
+        const validator = new DocumentValidator(doc, options, settings);
+        await validator.prepare();
+        return validator;
+    }
     /**
      * @param doc - Document to validate
      * @param config - configuration to use (not finalized).
@@ -63,7 +71,7 @@ export class DocumentValidator {
         assert(!this._ready);
         const timer = createPerfTimer('_prepareAsync');
         const { options, settings: rawSettings } = this;
-        const resolveImportsRelativeTo = toFileURL(options.resolveImportsRelativeTo || pathToFileURL('./virtual.settings.json'));
+        const resolveImportsRelativeTo = toFileURL(options.resolveImportsRelativeTo || toFileURL('./virtual.settings.json'));
         const settings = rawSettings.import?.length
             ? await resolveSettingsImports(rawSettings, resolveImportsRelativeTo)
             : rawSettings;

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

@@ -0,0 +1,18 @@
+import { 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
+ * @returns true if the string is considered random;
+ */
+export declare function isRandomString(s: string, maxNoiseToLengthRatio?: number): boolean;
+/**
+ * Calculate the ratio of noise to the length of the string.
+ * @param s - string to check
+ * @returns true if the string is considered random;
+ */
+export declare function scoreRandomString(s: string): number;
+export declare function scoreLongWordRatio(s: string): number;
+export declare function categorizeString(s: string): string;
+export declare function isHexNumber(s: string): boolean;
+export declare function extractHexSequences(s: string, minLength?: number): TextOffset[];
+//# sourceMappingURL=isRandomString.d.ts.map

package/dist/lib/textValidation/isRandomString.js

@@ -0,0 +1,65 @@
+const maxRadio = 0.5;
+/**
+ * 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
+ * @returns true if the string is considered random;
+ */
+export function isRandomString(s, maxNoiseToLengthRatio = maxRadio) {
+    return scoreRandomString(s) >= maxNoiseToLengthRatio;
+}
+/**
+ * Calculate the ratio of noise to the length of the string.
+ * @param s - string to check
+ * @returns true if the string is considered random;
+ */
+export function scoreRandomString(s) {
+    if (!s.length)
+        return 0;
+    const n = categorizeString(s);
+    return n.length / s.length; // * 0.75 + (1 - scoreLongWordRatio(s)) * 0.25 + nonLetterRatio(s) * 0.25;
+}
+export function scoreLongWordRatio(s) {
+    return sumWordLengths(s) / s.length;
+}
+function sumWordLengths(s) {
+    let total = 0;
+    for (const w of s.matchAll(/\p{Lu}\p{Ll}{3,}|\p{Ll}{4,}|\p{Lu}{4,}/gu)) {
+        total += w[0].length;
+    }
+    return total;
+}
+function _nonLetterRatio(s) {
+    return s.replaceAll(/\p{L}/gu, '').length / s.length;
+}
+export function categorizeString(s) {
+    const n = s
+        .replaceAll(/\d+/g, '0')
+        .replaceAll(/\p{Ll}\p{M}+/gu, 'a')
+        .replaceAll(/\p{Lu}\p{M}+/gu, 'A')
+        .replaceAll(/\p{Lu}?\p{Ll}+/gu, '1')
+        .replaceAll(/\p{Lu}+/gu, '2')
+        .replaceAll(/\p{M}/gu, '4')
+        .replaceAll('_', '')
+        .replaceAll(/[-_.']+/g, '3');
+    return n;
+}
+const hexLowerRegex = /^[0-9a-f]+$/;
+const hexUpperRegex = /^[0-9A-F]+$/;
+export function isHexNumber(s) {
+    return hexLowerRegex.test(s) || hexUpperRegex.test(s);
+}
+const hexSequence = /(?:\b|(?<=[\W_]))[0-9a-fA-F][-0-9a-fA-F]*[0-9a-fA-F](?:\b|(?=[\W_]))/g;
+const isLetter = /\p{L}/uy;
+function isLetterAt(s, idx) {
+    isLetter.lastIndex = idx;
+    return isLetter.test(s);
+}
+const MIN_HEX_SEQUENCE_LENGTH = 4;
+export function extractHexSequences(s, minLength = MIN_HEX_SEQUENCE_LENGTH) {
+    return [...s.matchAll(hexSequence)]
+        .filter((m) => m[0].length >= minLength &&
+        (m.index === 0 || !isLetterAt(s, m.index - 1)) &&
+        !isLetterAt(s, m.index + m[0].length))
+        .map((m) => ({ text: m[0], offset: m.index }));
+}
+//# sourceMappingURL=isRandomString.js.map

package/dist/lib/textValidation/lineValidatorFactory.js

@@ -1,15 +1,18 @@
 import assert from 'node:assert';
 import { opConcatMap, opFilter, pipe } from '@cspell/cspell-pipe/sync';
+import { defaultCSpellSettings } from '@cspell/cspell-types';
 import { createCachingDictionary } from 'cspell-dictionary';
 import * as RxPat from '../Settings/RegExpPatterns.js';
 import { extractPossibleWordsFromTextOffset, extractText, extractWordsFromTextOffset, splitWordWithOffset, } from '../util/text.js';
 import { regExpCamelCaseWordBreaksWithEnglishSuffix } from '../util/textRegex.js';
 import { split } from '../util/wordSplitter.js';
 import { defaultMinWordLength } from './defaultConstants.js';
+import { extractHexSequences, isRandomString } from './isRandomString.js';
 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, } = options;
+    const { minWordLength = defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, ignoreRandomStrings = defaultCSpellSettings.ignoreRandomStrings, minRandomLength = defaultCSpellSettings.minRandomLength, } = options;
     const hasWordOptions = {
         ignoreCase,
         useCompounds: allowCompoundWords || undefined, // let the dictionaries decide on useCompounds if allow is false
@@ -101,7 +104,7 @@ export function lineValidatorFactory(sDict, options) {
     const fn = (lineSegment) => {
         const line = lineSegment.line;
         function isWordTooShort(word, ignoreSuffix = false) {
-            if (word.text.length >= minWordLength)
+            if (word.text.length >= minWordLength * 2 || [...word.text].length >= minWordLength)
                 return false;
             const offset = word.offset - line.offset;
             assert.equal(line.text.slice(offset, offset + word.text.length), word.text);
@@ -217,6 +220,28 @@ export function lineValidatorFactory(sDict, options) {
                 return issue;
             });
         }
+        function checkForFlaggedWord(possibleWord) {
+            if (isWordFlagged(possibleWord)) {
+                const vr = {
+                    ...possibleWord,
+                    line: lineSegment.line,
+                    isFlagged: true,
+                };
+                return vr;
+            }
+            if (possibleWord.text.endsWith('.')) {
+                const pw = { ...possibleWord, text: possibleWord.text.slice(0, -1) };
+                if (isWordFlagged(pw)) {
+                    const vr = {
+                        ...pw,
+                        line: lineSegment.line,
+                        isFlagged: true,
+                    };
+                    return vr;
+                }
+            }
+            return undefined;
+        }
         function checkPossibleWords(possibleWord) {
             const known = setOfKnownIssues.get(possibleWord.text);
             if (known) {
@@ -230,15 +255,10 @@ export function lineValidatorFactory(sDict, options) {
             return issues;
         }
         function _checkPossibleWords(possibleWord) {
-            if (isWordFlagged(possibleWord)) {
-                const vr = {
-                    ...possibleWord,
-                    line: lineSegment.line,
-                    isFlagged: true,
-                };
-                return [vr];
-            }
-            const mismatches = [];
+            const flagged = checkForFlaggedWord(possibleWord);
+            if (flagged)
+                return [flagged];
+            let mismatches = [];
             for (const wo of extractWordsFromTextOffset(possibleWord)) {
                 if (setOfKnownSuccessfulWords.has(wo.text))
                     continue;
@@ -251,6 +271,19 @@ export function lineValidatorFactory(sDict, options) {
                     mismatches.push(w);
                 }
             }
+            if (!mismatches.length)
+                return mismatches;
+            const hexSequences = !ignoreRandomStrings
+                ? []
+                : extractHexSequences(possibleWord.text, MIN_HEX_SEQUENCE_LENGTH)
+                    .filter(
+                // Only consider hex sequences that are all upper case or all lower case and contain a `-` or a digit.
+                (w) => (w.text === w.text.toLowerCase() || w.text === w.text.toUpperCase()) &&
+                    /[\d-]/.test(w.text))
+                    .map((w) => ((w.offset += possibleWord.offset), w));
+            if (hexSequences.length) {
+                mismatches = filterExcludedTextOffsets(mismatches, hexSequences);
+            }
             if (mismatches.length) {
                 // Try the more expensive word splitter
                 const splitResult = split(lineSegment.segment, possibleWord.offset, splitterIsValid);
@@ -263,13 +296,19 @@ export function lineValidatorFactory(sDict, options) {
                     const v = checkWord({ ...w, text: m[1], line: lineSegment.line });
                     return v.isFlagged || !v.isFound;
                 });
-                if (nonMatching.length < mismatches.length) {
-                    return nonMatching.map((w) => ({ ...w, line: lineSegment.line })).map(annotateIsFlagged);
+                const filtered = filterExcludedTextOffsets(nonMatching.map((w) => ({ ...w, line: lineSegment.line })).map(annotateIsFlagged), hexSequences);
+                if (filtered.length < mismatches.length) {
+                    return filtered;
                 }
             }
             return mismatches;
         }
-        const checkedPossibleWords = pipe(extractPossibleWordsFromTextOffset(lineSegment.segment), opFilter(filterAlreadyChecked), opConcatMap(checkPossibleWords));
+        function isNotRandom(textOff) {
+            if (textOff.text.length < minRandomLength || !ignoreRandomStrings)
+                return true;
+            return !isRandomString(textOff.text);
+        }
+        const checkedPossibleWords = pipe(extractPossibleWordsFromTextOffset(lineSegment.segment), opFilter(isNotRandom), opFilter(filterAlreadyChecked), opConcatMap(checkPossibleWords));
         return checkedPossibleWords;
     };
     function getWordInfo(word) {
@@ -303,4 +342,27 @@ export function textValidatorFactory(dict, options) {
         lineValidator,
     };
 }
+function filterExcludedTextOffsets(issues, excluded) {
+    if (!excluded.length)
+        return issues;
+    const keep = [];
+    let i = 0;
+    let j = 0;
+    for (i = 0; i < issues.length && j < excluded.length; i++) {
+        const issue = issues[i];
+        while (j < excluded.length && excluded[j].offset + excluded[j].text.length <= issue.offset) {
+            j++;
+        }
+        if (j >= excluded.length) {
+            break;
+        }
+        if (issue.isFlagged || issue.offset < excluded[j].offset) {
+            keep.push(issue);
+        }
+    }
+    if (i < issues.length) {
+        keep.push(...issues.slice(i));
+    }
+    return keep;
+}
 //# sourceMappingURL=lineValidatorFactory.js.map

package/dist/lib/textValidation/settingsToValidateOptions.js

@@ -2,6 +2,8 @@ export function settingsToValidateOptions(settings) {
     const opt = {
         ...settings,
         ignoreCase: !(settings.caseSensitive ?? false),
+        ignoreRandomStrings: settings.ignoreRandomStrings,
+        minRandomLength: settings.minRandomLength,
     };
     return opt;
 }

package/dist/lib/trace.d.ts

@@ -1,4 +1,5 @@
 import type { CSpellSettings, LocaleId } from '@cspell/cspell-types';
+import { ICSpellConfigFile } from 'cspell-config-lib';
 import type { LanguageId } from './fileTypes.js';
 import type { DictionaryTraceResult, WordSplits } from './textValidation/traceWord.js';
 export interface TraceResult extends DictionaryTraceResult {
@@ -14,6 +15,6 @@ export interface TraceOptions {
 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<TraceWordResult>;
+export declare function traceWords(words: string[], settings: CSpellSettings | ICSpellConfigFile, options: TraceOptions | undefined): Promise<TraceResult[]>;
+export declare function traceWordsAsync(words: Iterable<string> | AsyncIterable<string>, settingsOrConfig: CSpellSettings | ICSpellConfigFile, options: TraceOptions | undefined): AsyncIterableIterator<TraceWordResult>;
 //# sourceMappingURL=trace.d.ts.map

package/dist/lib/trace.js

@@ -1,6 +1,7 @@
+import { satisfiesCSpellConfigFile } from 'cspell-config-lib';
 import { genSequence } from 'gensequence';
 import { toInternalSettings } from './Settings/CSpellSettingsServer.js';
-import { finalizeSettings, mergeSettings } from './Settings/index.js';
+import { finalizeSettings, mergeSettings, resolveConfigFileImports } from './Settings/index.js';
 import { calcSettingsForLanguageId } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';
 import { traceWord } from './textValidation/traceWord.js';
@@ -13,8 +14,11 @@ export async function traceWords(words, settings, options) {
         .toArray();
     return s;
 }
-export async function* traceWordsAsync(words, settings, options) {
+export async function* traceWordsAsync(words, settingsOrConfig, options) {
     const { languageId, locale: language, ignoreCase = true, allowCompoundWords } = options || {};
+    const settings = satisfiesCSpellConfigFile(settingsOrConfig)
+        ? await resolveConfigFileImports(settingsOrConfig)
+        : settingsOrConfig;
     async function finalize(config) {
         const withLocale = mergeSettings(config, util.clean({
             language: language || config.language,

package/dist/lib/util/Uri.js

@@ -1,6 +1,5 @@
 import assert from 'node:assert';
-import { pathToFileURL } from 'node:url';
-import { toFilePathOrHref, toFileURL, toURL } from '@cspell/url';
+import { toFileDirURL, toFilePathOrHref, toFileURL, toURL } from '@cspell/url';
 import { isUrlLike } from 'cspell-io';
 import { URI, Utils } from 'vscode-uri';
 const STDIN_PROTOCOL = 'stdin:';
@@ -21,7 +20,7 @@ export function toUri(uriOrFile) {
 }
 const isWindows = process.platform === 'win32';
 const hasDriveLetter = /^[a-zA-Z]:[\\/]/;
-const rootUrl = pathToFileURL('/');
+const rootUrl = toFileDirURL('/');
 export function uriToFilePath(uri) {
     let url = documentUriToURL(uri);
     url = url.protocol === 'stdin:' ? new URL(url.pathname, rootUrl) : url;

package/dist/lib/util/resolveFile.js

@@ -1,7 +1,6 @@
 import { createRequire } from 'node:module';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { pathToFileURL } from 'node:url';
 import { fileURLToPath } from 'node:url';
 import { resolveGlobal } from '@cspell/cspell-resolver';
 import { importResolveModuleName } from '@cspell/dynamic-import';
@@ -9,8 +8,9 @@ import resolveFrom from 'resolve-from';
 import { getFileSystem } from '../fileSystem.js';
 import { srcDirectory } from '../pkg-info.mjs';
 import { envToTemplateVars, replaceTemplate } from './templates.js';
-import { fileURLOrPathToPath, isDataURL, isFileURL, isURLLike, resolveFileWithURL, toFilePathOrHref, toFileUrl, toURL, } from './url.js';
+import { fileURLOrPathToPath, isDataURL, isFileURL, isURLLike, resolveFileWithURL, toFileDirURL, toFilePathOrHref, toFileUrl, toURL, } from './url.js';
 const regExpStartsWidthNodeModules = /^node_modules[/\\]/;
+const debugMode = false;
 export class FileResolver {
     fs;
     templateReplacements;
@@ -129,13 +129,16 @@ export class FileResolver {
     tryCreateRequire = (filename, relativeTo) => {
         if (filename instanceof URL)
             return undefined;
-        const rel = !isURLLike(relativeTo) || isFileURL(relativeTo) ? relativeTo : pathToFileURL('./');
-        const require = createRequire(rel);
+        const rel = !isURLLike(relativeTo) || isFileURL(relativeTo) ? relativeTo : toFileDirURL('./');
         try {
+            const require = createRequire(rel);
             const r = require.resolve(filename);
             return { filename: r, relativeTo: rel.toString(), found: true, method: 'tryCreateRequire' };
         }
-        catch {
+        catch (error) {
+            if (debugMode) {
+                console.error('Error in tryCreateRequire: %o', { filename, rel, relativeTo, error: `${error}` });
+            }
             return undefined;
         }
     };

package/dist/lib/util/url.js

@@ -1,6 +1,4 @@
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { toFilePathOrHref, toFileURL } from '@cspell/url';
+import { toFileDirURL, toFilePathOrHref, toFileURL } from '@cspell/url';
 import { srcDirectory } from '../pkg-info.mjs';
 export { addTrailingSlash, isDataURL, isFileURL, isUrlLike as isURLLike, toFileURL as resolveFileWithURL, toFileDirURL, toFilePathOrHref, toURL, } from '@cspell/url';
 /**
@@ -8,7 +6,7 @@ export { addTrailingSlash, isDataURL, isFileURL, isUrlLike as isURLLike, toFileU
  * @returns URL for the source directory
  */
 export function getSourceDirectoryUrl() {
-    const srcDirectoryURL = pathToFileURL(path.join(srcDirectory, '/'));
+    const srcDirectoryURL = toFileDirURL(srcDirectory);
     return srcDirectoryURL;
 }
 /**
@@ -20,7 +18,7 @@ export function relativeTo(path, relativeTo) {
     return toFileURL(path, relativeTo ?? cwdURL());
 }
 export function cwdURL() {
-    return pathToFileURL('./');
+    return toFileDirURL('./');
 }
 export function toFileUrl(file) {
     return toFileURL(file, cwdURL());

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "8.16.0",
+  "version": "8.17.0",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -64,22 +64,22 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.16.0",
-    "@cspell/cspell-pipe": "8.16.0",
-    "@cspell/cspell-resolver": "8.16.0",
-    "@cspell/cspell-types": "8.16.0",
-    "@cspell/dynamic-import": "8.16.0",
-    "@cspell/filetypes": "8.16.0",
-    "@cspell/strong-weak-map": "8.16.0",
-    "@cspell/url": "8.16.0",
+    "@cspell/cspell-bundled-dicts": "8.17.0",
+    "@cspell/cspell-pipe": "8.17.0",
+    "@cspell/cspell-resolver": "8.17.0",
+    "@cspell/cspell-types": "8.17.0",
+    "@cspell/dynamic-import": "8.17.0",
+    "@cspell/filetypes": "8.17.0",
+    "@cspell/strong-weak-map": "8.17.0",
+    "@cspell/url": "8.17.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.5",
-    "cspell-config-lib": "8.16.0",
-    "cspell-dictionary": "8.16.0",
-    "cspell-glob": "8.16.0",
-    "cspell-grammar": "8.16.0",
-    "cspell-io": "8.16.0",
-    "cspell-trie-lib": "8.16.0",
+    "cspell-config-lib": "8.17.0",
+    "cspell-dictionary": "8.17.0",
+    "cspell-glob": "8.17.0",
+    "cspell-grammar": "8.17.0",
+    "cspell-io": "8.17.0",
+    "cspell-trie-lib": "8.17.0",
     "env-paths": "^3.0.0",
     "fast-equals": "^5.0.1",
     "gensequence": "^7.0.0",
@@ -93,14 +93,14 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@cspell/dict-cpp": "^6.0.1",
+    "@cspell/dict-cpp": "^6.0.2",
     "@cspell/dict-csharp": "^4.0.5",
     "@cspell/dict-css": "^4.0.16",
     "@cspell/dict-fa-ir": "^4.0.3",
     "@cspell/dict-fr-fr": "^2.2.5",
     "@cspell/dict-html": "^4.0.10",
     "@cspell/dict-nl-nl": "^2.3.3",
-    "@cspell/dict-python": "^4.2.12",
+    "@cspell/dict-python": "^4.2.13",
     "@types/configstore": "^6.0.2",
     "configstore": "^7.0.0",
     "cspell-dict-nl-nl": "^1.1.2",
@@ -108,5 +108,5 @@
     "lorem-ipsum": "^2.0.8",
     "perf-insight": "^1.2.0"
   },
-  "gitHead": "41cd50f9ba34033b6da32408855d7fc3b888c5e0"
+  "gitHead": "cac17fe7b993db5965aa441648b1c22cb5486929"
 }