cspell-lib 8.14.1 → 8.14.3

package/dist/lib/Models/CSpellSettingsInternalDef.js

@@ -1,15 +1,12 @@
 import { clean } from '../util/util.js';
 export const SymbolCSpellSettingsInternal = Symbol('CSpellSettingsInternal');
-export function cleanCSpellSettingsInternal(parts = {}) {
-    const csi = clean(parts);
-    Object.assign(csi, { [SymbolCSpellSettingsInternal]: true });
-    return csi;
+export function cleanCSpellSettingsInternal(parts) {
+    return parts
+        ? Object.assign(clean(parts), { [SymbolCSpellSettingsInternal]: true })
+        : { [SymbolCSpellSettingsInternal]: true };
 }
-export function createCSpellSettingsInternal(parts = {}) {
-    return clean({
-        ...parts,
-        [SymbolCSpellSettingsInternal]: true,
-    });
+export function createCSpellSettingsInternal(parts) {
+    return cleanCSpellSettingsInternal({ ...parts });
 }
 export function isCSpellSettingsInternal(cs) {
     return !!cs[SymbolCSpellSettingsInternal];

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

@@ -10,7 +10,7 @@ declare function mergeObjects<T>(left: T, right: undefined): T;
 declare function mergeObjects<T>(left: T, right: T): T;
 declare function mergeObjects<T>(left: undefined, right: T): T;
 export declare function mergeSettings(left: CSpellSettingsWSTO | CSpellSettingsI, ...settings: (CSpellSettingsWSTO | CSpellSettingsI | undefined)[]): CSpellSettingsI;
-export declare function mergeInDocSettings(left: CSpellSettingsWSTO, right: CSpellSettingsWSTO): CSpellSettingsWST;
+export declare function mergeInDocSettings(left: CSpellSettingsWSTO, ...rest: CSpellSettingsWSTO[]): CSpellSettingsWST;
 /**
  *
  * @param settings - settings to finalize

package/dist/lib/Settings/CSpellSettingsServer.js

@@ -1,5 +1,4 @@
 import assert from 'node:assert';
-import { pathToFileURL } from 'node:url';
 import { onClearCache } from '../events/index.js';
 import { cleanCSpellSettingsInternal as csi, isCSpellSettingsInternal } from '../Models/CSpellSettingsInternalDef.js';
 import { autoResolveWeak, AutoResolveWeakCache } from '../util/AutoResolve.js';
@@ -9,6 +8,7 @@ import { configSettingsFileVersion0_1, ENV_CSPELL_GLOB_ROOT } from './constants.
 import { calcDictionaryDefsToLoad, mapDictDefsToInternal } from './DictionarySettings.js';
 import { mergeList, mergeListUnique } from './mergeList.js';
 import { resolvePatterns } from './patterns.js';
+import { CwdUrlResolver } from './resolveCwd.js';
 export { stats as getMergeStats } from './mergeList.js';
 const emptyWords = [];
 Object.freeze(emptyWords);
@@ -17,12 +17,16 @@ const mergeCache = new AutoResolveWeakCache();
 const cacheInternalSettings = new AutoResolveWeakCache();
 const parserCache = new AutoResolveWeakCache();
 const emptyParserMap = new Map();
+const cwdResolver = new CwdUrlResolver();
+let envCSpellGlobRoot = process.env[ENV_CSPELL_GLOB_ROOT];
 onClearCache(() => {
     parserCache.clear();
     emptyParserMap.clear();
     cachedMerges.clear();
     mergeCache.clear();
     cacheInternalSettings.clear();
+    cwdResolver.reset();
+    envCSpellGlobRoot = process.env[ENV_CSPELL_GLOB_ROOT];
 });
 function _mergeWordsCached(left, right) {
     const map = autoResolveWeak(cachedMerges, left, () => new WeakMap());
@@ -154,11 +158,8 @@ function hasAncestor(s, ancestor, side) {
     const src = sources[i];
     return src === ancestor || (src && hasAncestor(src, ancestor, side)) || false;
 }
-export function mergeInDocSettings(left, right) {
-    const merged = {
-        ...mergeSettings(left, right),
-        includeRegExpList: mergeListUnique(left.includeRegExpList, right.includeRegExpList),
-    };
+export function mergeInDocSettings(left, ...rest) {
+    const merged = mergeSettings(left, ...rest);
     return util.clean(merged);
 }
 function takeRightOtherwiseLeft(left, right) {
@@ -197,7 +198,8 @@ export function toInternalSettings(settings) {
 }
 function _toInternalSettings(settings) {
     const { dictionaryDefinitions: defs, ...rest } = settings;
-    const dictionaryDefinitions = mapDictDefsToInternal(defs, (settings.source?.filename && toFileUrl(settings.source?.filename)) || resolveCwd());
+    const dictionaryDefinitions = defs &&
+        mapDictDefsToInternal(defs, (settings.source?.filename && toFileUrl(settings.source?.filename)) || resolveCwd());
     const setting = dictionaryDefinitions ? { ...rest, dictionaryDefinitions } : rest;
     return csi(setting);
 }
@@ -260,9 +262,7 @@ export function extractDependencies(settings) {
     };
 }
 function resolveCwd() {
-    const envGlobRoot = process.env[ENV_CSPELL_GLOB_ROOT];
-    const cwd = envGlobRoot || process.cwd();
-    return pathToFileURL(cwd);
+    return cwdResolver.resolveUrl(envCSpellGlobRoot);
 }
 function resolveParser(settings) {
     if (!settings.parser)

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

@@ -1,5 +1,4 @@
 import type { CSpellUserSettings, DictionaryDefinitionInline } from '@cspell/cspell-types';
-import type { Sequence } from 'gensequence';
 import type { ExtendedSuggestion } from '../Models/Suggestion.js';
 export type CSpellUserSettingsKeys = keyof CSpellUserSettings;
 export interface DirectiveIssue {
@@ -15,16 +14,31 @@ export interface DirectiveIssue {
     suggestions: string[];
     suggestionsEx: ExtendedSuggestion[];
 }
+declare function collectInDocumentDirectives(text: string): DirectiveMatchWithParser[];
 export declare function getInDocumentSettings(text: string): CSpellUserSettings;
 export declare function validateInDocumentSettings(docText: string, _settings: CSpellUserSettings): Iterable<DirectiveIssue>;
+interface PossibleMatch {
+    /** The full directive text till the end of the line */
+    fullDirective: string;
+    /** Offset of the directive */
+    offset: number;
+    /** the partial directive, missing the CSpell prefix. */
+    match: string;
+}
+type Directive = 'CompoundWords' | 'CaseSensitive' | 'Enable' | 'Disable' | 'Words' | 'Ignore' | 'Flag' | 'IgnoreRegExp' | 'IncludeRegExp' | 'Locale' | 'Dictionaries';
+type ReducerFn = (acc: CSpellUserSettings, match: string) => CSpellUserSettings;
+interface DirectiveMatchWithParser extends PossibleMatch {
+    directive: Directive;
+    fn: ReducerFn;
+}
 export declare const regExSpellingGuardBlock: RegExp;
 export declare const regExSpellingGuardNext: RegExp;
 export declare const regExSpellingGuardLine: RegExp;
-declare function parseCompoundWords(match: string): CSpellUserSettings;
-declare function parseWords(match: string): CSpellUserSettings;
-declare function parseIgnoreWords(match: string): CSpellUserSettings;
-declare function parseIgnoreRegExp(match: string): CSpellUserSettings;
-declare function getPossibleInDocSettings(text: string): Sequence<RegExpExecArray>;
+declare function parseCompoundWords(acc: CSpellUserSettings, match: string): CSpellUserSettings;
+declare function parseWords(acc: CSpellUserSettings, match: string): CSpellUserSettings;
+declare function parseIgnoreWords(acc: CSpellUserSettings, match: string): CSpellUserSettings;
+declare function parseIgnoreRegExp(acc: CSpellUserSettings, match: string): CSpellUserSettings;
+declare function getPossibleInDocSettings(text: string): Iterable<PossibleMatch>;
 declare function getWordsFromDocument(text: string): string[];
 export declare function extractInDocDictionary(settings: CSpellUserSettings): DictionaryDefinitionInline | undefined;
 export declare function getIgnoreWordsFromDocument(text: string): string[];
@@ -32,7 +46,8 @@ export declare function getIgnoreRegExpFromDocument(text: string): (string | Reg
 /**
  * These internal functions are used exposed for unit testing.
  */
-export declare const internal: {
+export declare const __internal: {
+    collectInDocumentSettings: typeof collectInDocumentDirectives;
     getPossibleInDocSettings: typeof getPossibleInDocSettings;
     getWordsFromDocument: typeof getWordsFromDocument;
     parseWords: typeof parseWords;

package/dist/lib/Settings/InDocSettings.js

@@ -1,9 +1,7 @@
-import { opAppend, opFilter, opMap, pipeSync } from '@cspell/cspell-pipe/sync';
-import { genSequence } from 'gensequence';
+import { opAppend, opFilter, opFlatten, opMap, pipeSync } from '@cspell/cspell-pipe/sync';
 import { createSpellingDictionary } from '../SpellingDictionary/index.js';
 import * as Text from '../util/text.js';
 import { clean, isDefined } from '../util/util.js';
-import { mergeInDocSettings } from './CSpellSettingsServer.js';
 // cspell:ignore gimuy
 const regExMatchRegEx = /\/.*\/[gimuy]*/;
 const regExCSpellInDocDirective = /\b(?:spell-?checker|c?spell)::?(.*)/gi;
@@ -67,12 +65,17 @@ const dictInDocSettings = createSpellingDictionary(allDirectives, 'Directives',
 const EmptyWords = [];
 Object.freeze(EmptyWords);
 const staticInDocumentDictionaryName = `[in-document-dict]`;
+function collectInDocumentDirectives(text) {
+    const dirs = [...getPossibleInDocSettings(text)].flatMap((a) => associateDirectivesWithParsers(a));
+    return dirs;
+}
+const baseInDocSettings = { id: 'in-doc-settings' };
+Object.freeze(baseInDocSettings);
 export function getInDocumentSettings(text) {
-    const collectedSettings = getPossibleInDocSettings(text)
-        .concatMap((a) => parseSettingMatch(a))
-        .reduce((s, setting) => {
-        return mergeInDocSettings(s, setting);
-    }, { id: 'in-doc-settings' });
+    const found = collectInDocumentDirectives(text);
+    if (!found.length)
+        return { ...baseInDocSettings };
+    const collectedSettings = reducePossibleMatchesToSettings(found, { ...baseInDocSettings });
     const { words, flagWords, ignoreWords, suggestWords, dictionaries = [], dictionaryDefinitions = [], ...rest } = collectedSettings;
     const dict = (words || flagWords || ignoreWords || suggestWords) &&
         clean({
@@ -95,44 +98,42 @@ export function getInDocumentSettings(text) {
         ...rest,
         ...dictSettings,
     };
-    // console.log('InDocSettings: %o', settings);
     return settings;
 }
 export function validateInDocumentSettings(docText, _settings) {
     return pipeSync(getPossibleInDocSettings(docText), opMap(parseSettingMatchValidation), opFilter(isDefined));
 }
 const settingParsers = [
-    [/^(?:enable|disable)(?:allow)?CompoundWords\b(?!-)/i, parseCompoundWords],
-    [/^(?:enable|disable)CaseSensitive\b(?!-)/i, parseCaseSensitive],
-    [/^enable\b(?!-)/i, parseEnable],
-    [/^disable(-line|-next(-line)?)?\b(?!-)/i, parseDisable],
-    [/^words?\b(?!-)/i, parseWords],
-    [/^ignore(?:-?words?)?\b(?!-)/i, parseIgnoreWords],
-    [/^(?:flag|forbid)(?:-?words?)?\b(?!-)/i, parseFlagWords],
-    [/^ignore_?Reg_?Exp\s+.+$/i, parseIgnoreRegExp],
-    [/^include_?Reg_?Exp\s+.+$/i, parseIncludeRegExp],
-    [/^locale?\b(?!-)/i, parseLocale],
-    [/^language\s\b(?!-)/i, parseLocale],
-    [/^dictionar(?:y|ies)\b(?!-)/i, parseDictionaries], // cspell:disable-line
-    [/^LocalWords:/, (w) => parseWords(w.replaceAll(/^LocalWords:?/gi, ' '))],
+    [/^(?:enable|disable)(?:allow)?CompoundWords\b(?!-)/i, parseCompoundWords, 'CompoundWords'],
+    [/^(?:enable|disable)CaseSensitive\b(?!-)/i, parseCaseSensitive, 'CaseSensitive'],
+    [/^enable\b(?!-)/i, parseEnable, 'Enable'],
+    [/^disable(-line|-next(-line)?)?\b(?!-)/i, parseDisable, 'Disable'],
+    [/^words?\b(?!-)/i, parseWords, 'Words'],
+    [/^ignore(?:-?words?)?\b(?!-)/i, parseIgnoreWords, 'Ignore'],
+    [/^(?:flag|forbid)(?:-?words?)?\b(?!-)/i, parseFlagWords, 'Flag'],
+    [/^ignore_?Reg_?Exp\s+.+$/i, parseIgnoreRegExp, 'IgnoreRegExp'],
+    [/^include_?Reg_?Exp\s+.+$/i, parseIncludeRegExp, 'IncludeRegExp'],
+    [/^locale?\b(?!-)/i, parseLocale, 'Locale'],
+    [/^language\s\b(?!-)/i, parseLocale, 'Locale'],
+    [/^dictionar(?:y|ies)\b(?!-)/i, parseDictionaries, 'Dictionaries'], // cspell:disable-line
+    [/^LocalWords:/, (acc, m) => reduceWordList(acc, m.replaceAll(/^LocalWords:?/gi, ' '), 'words'), 'Words'],
 ];
 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;
-const emptySettings = Object.freeze({});
 const issueMessages = {
     unknownDirective: 'Unknown CSpell directive',
 };
-function parseSettingMatchValidation(matchArray) {
-    const [fullMatch = ''] = matchArray;
-    const directiveMatch = fullMatch.match(regExCSpellDirectiveKey);
+function parseSettingMatchValidation(possibleMatch) {
+    const { fullDirective, offset } = possibleMatch;
+    const directiveMatch = fullDirective.match(regExCSpellDirectiveKey);
     if (!directiveMatch)
         return undefined;
     const match = directiveMatch[1];
     const possibleSetting = match.trim();
     if (!possibleSetting)
         return undefined;
-    const start = (matchArray.index || 0) + (directiveMatch.index || 0) + (match.length - match.trimStart().length);
+    const start = offset + (directiveMatch.index || 0) + (match.length - match.trimStart().length);
     const text = possibleSetting.replace(/^([-\w]+)?.*/, '$1');
     const end = start + text.length;
     if (!text)
@@ -167,44 +168,66 @@ function* filterUniqueSuggestions(sugs) {
         yield sug;
     }
 }
-function parseSettingMatch(matchArray) {
-    const [, match = ''] = matchArray;
+function associateDirectivesWithParsers(possibleMatch) {
+    const { match } = possibleMatch;
     const possibleSetting = match.trim();
     return settingParsers
         .filter(([regex]) => regex.test(possibleSetting))
-        .map(([, fn]) => fn)
-        .map((fn) => fn(possibleSetting));
+        .map(([, fn, directive]) => ({ ...possibleMatch, directive, fn }));
+}
+function mergeDirectiveIntoSettings(settings, directive) {
+    return directive.fn(settings, directive.match);
 }
-function parseCompoundWords(match) {
-    const allowCompoundWords = /enable/i.test(match);
-    return { allowCompoundWords };
+function reducePossibleMatchesToSettings(directives, settings) {
+    for (const directive of directives) {
+        settings = mergeDirectiveIntoSettings(settings, directive);
+    }
+    return settings;
 }
-function parseCaseSensitive(match) {
-    const caseSensitive = /enable/i.test(match);
-    return { caseSensitive };
+function parseCompoundWords(acc, match) {
+    acc.allowCompoundWords = /enable/i.test(match);
+    return acc;
 }
-function parseWords(match) {
-    const words = match
-        // .replace(/[@#$%^&={}/"]/g, ' ')
+function parseCaseSensitive(acc, match) {
+    acc.caseSensitive = /enable/i.test(match);
+    return acc;
+}
+function splitWords(match) {
+    return match
         .split(/[,\s;]+/g)
         .slice(1)
         .filter((a) => !!a);
-    return { words };
 }
-function parseLocale(match) {
+function mergeList(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    return [...a, ...b];
+}
+function reduceWordList(acc, match, key) {
+    const words = splitWords(match);
+    if (words.length) {
+        acc[key] = mergeList(acc[key], words);
+    }
+    return acc;
+}
+function parseWords(acc, match) {
+    return reduceWordList(acc, match, 'words');
+}
+function parseLocale(acc, match) {
     const parts = match.trim().split(/[\s,]+/);
     const language = parts.slice(1).join(',');
-    return language ? { language } : emptySettings;
+    if (language) {
+        acc.language = language;
+    }
+    return acc;
 }
-function parseIgnoreWords(match) {
-    const wordsSetting = parseWords(match);
-    const ignoreWords = wordsSetting.words;
-    return ignoreWords && ignoreWords.length ? { ignoreWords } : emptySettings;
+function parseIgnoreWords(acc, match) {
+    return reduceWordList(acc, match, 'ignoreWords');
 }
-function parseFlagWords(match) {
-    const wordsSetting = parseWords(match);
-    const flagWords = wordsSetting.words;
-    return flagWords && flagWords.length ? { flagWords } : emptySettings;
+function parseFlagWords(acc, match) {
+    return reduceWordList(acc, match, 'flagWords');
 }
 function parseRegEx(match) {
     const patterns = [match.replace(/^[^\s]+\s+/, '')].map((a) => {
@@ -216,32 +239,41 @@ function parseRegEx(match) {
     });
     return patterns;
 }
-function parseIgnoreRegExp(match) {
+function parseIgnoreRegExp(acc, match) {
     const ignoreRegExpList = parseRegEx(match);
-    return { ignoreRegExpList };
+    if (ignoreRegExpList.length) {
+        acc.ignoreRegExpList = mergeList(acc.ignoreRegExpList, ignoreRegExpList);
+    }
+    return acc;
 }
-function parseIncludeRegExp(match) {
+function parseIncludeRegExp(acc, match) {
     const includeRegExpList = parseRegEx(match);
-    return { includeRegExpList };
+    if (includeRegExpList.length) {
+        acc.includeRegExpList = mergeList(acc.includeRegExpList, includeRegExpList);
+    }
+    return acc;
 }
-function parseDictionaries(match) {
+function parseDictionaries(acc, match) {
     const dictionaries = match.split(/[,\s]+/g).slice(1);
-    return { dictionaries };
+    if (dictionaries.length) {
+        acc.dictionaries = mergeList(acc.dictionaries, dictionaries);
+    }
+    return acc;
 }
 function getPossibleInDocSettings(text) {
-    return genSequence(regExInFileSettings).concatMap((regexp) => Text.match(regexp, text));
+    return pipeSync(regExInFileSettings, opMap((regexp) => Text.match(regexp, text)), opFlatten(), opMap((match) => ({ fullDirective: match[0], offset: match.index, match: match[1].trim() })));
 }
 function getWordsFromDocument(text) {
     const dict = extractInDocDictionary(getInDocumentSettings(text));
     return dict?.words || EmptyWords;
 }
-function parseEnable(_match) {
+function parseEnable(acc, _match) {
     // Do nothing. Enable / Disable is handled in a different way.
-    return {};
+    return acc;
 }
-function parseDisable(_match) {
+function parseDisable(acc, _match) {
     // Do nothing. Enable / Disable is handled in a different way.
-    return {};
+    return acc;
 }
 export function extractInDocDictionary(settings) {
     const inDocDicts = settings.dictionaryDefinitions?.filter((def) => def.name === staticInDocumentDictionaryName);
@@ -259,7 +291,8 @@ export function getIgnoreRegExpFromDocument(text) {
 /**
  * These internal functions are used exposed for unit testing.
  */
-export const internal = {
+export const __internal = {
+    collectInDocumentSettings: collectInDocumentDirectives,
     getPossibleInDocSettings,
     getWordsFromDocument,
     parseWords,

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=InDocSettings.perf.d.ts.map

package/dist/lib/Settings/InDocSettings.perf.js

@@ -0,0 +1,73 @@
+import { suite } from 'perf-insight';
+import { __internal, getInDocumentSettings } from './InDocSettings.js';
+suite('Get InDocSettings', async (test) => {
+    const doc = sampleDoc();
+    const iterations = 10;
+    test('getInDocumentSettings', () => {
+        let settings = undefined;
+        for (let i = iterations; i > 0; --i) {
+            settings = getInDocumentSettings(doc);
+        }
+        return settings;
+    });
+});
+suite('Collect InDocSettings', async (test) => {
+    const doc = sampleDoc();
+    const iterations = 10;
+    test('collectInDocumentSettings', () => {
+        let settings = undefined;
+        for (let i = iterations; i > 0; --i) {
+            settings = __internal.collectInDocumentSettings(doc);
+        }
+        return settings;
+    });
+});
+function sampleDoc() {
+    return `
+    // cSpell\u003AenableCompoundWords
+    // cSpell\u003AdisableCompoundWords
+    // cSpell\u003A enableCOMPOUNDWords
+    // cSpell:words whiteberry, redberry, lightbrown
+    // cSpell\u003A ignoreRegExp /\\/\\/\\/.*/
+    // cSpell\u003AignoreRegexp w\\w+berry
+    // cSpell\u003A:ignoreRegExp  /
+    /* cSpell\u003AignoreRegExp \\w+s{4}\\w+ */
+    /* cSpell\u003AignoreRegExp /faullts[/]?/ */
+    const berries = ['whiteberry', 'redberry', 'blueberry'];
+
+    /* cSpell\u003Aignore tripe, comment */
+    // cSpell\u003A: ignoreWords tooo faullts
+    /// ignore triple comment, with misssspellings and faullts
+    /// mooree prooobleems onn thisss line tooo with wordberry
+    // misssspellings faullts
+
+    // weirdberry can be straange.
+    // cSpell\u003Alanguage en-US
+    // cspell\u003Alocal
+    // cspell\u003Alocale es-ES
+    // cspell\u003Alocal en, nl
+
+    // cspell\u003Adictionaries lorem-ipsum
+    // LocalWords: one two three
+    // LocalWords:four five six
+    // localwords: seven eight nine
+
+    // cspell:ignore againxx
+# cSpell\u003AdisableCompoundWords
+# cSpell\u003AenableCOMPOUNDWords
+# happydays arehere againxx
+
+// cspell:ignore popoutlist
+
+// spell\u003Adictionaries php
+// spell\u003Awords const
+// cspell\u003A
+// cspell\u003Aignore popoutlist
+const x = imp.popoutlist;
+// cspell\u003Aignore again
+
+    // cspell:ignore happydays arehere againxx localwords weirdberry straange misssspellings
+    // cspell:ignore faullts mooree prooobleems onn thisss line tooo wordberry
+`;
+}
+//# sourceMappingURL=InDocSettings.perf.js.map

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

@@ -21,10 +21,14 @@ export declare const regExBase64: RegExp;
  *
  * It must be:
  * - at least 40 characters
- * - contain at least 1 of [0-9+=]
- * - end at the end of the line or with [,"'\]
+ * - preceded by a non-Base64
+ * - contain at least 1 of [0-9+/]
+ * - contain at least 1 of [A-Z][a-z][A-Z]
+ * - contain at least 1 of [A-Z][0-9][A-Z] | [a-z][0-9][a-z] | [A-Z][0-9][a-z] | [0-9][A-Za-z][0-9]
+ * - contain at least 1 of [a-z]{3} | [A-Z]{3}
  */
 export declare const regExBase64SingleLine: RegExp;
+export declare const regExBase64SingleLineLegacy: RegExp;
 export declare const regExBase64MultiLine: RegExp;
 export declare const regExPhpHereDoc: RegExp;
 export declare const regExString: RegExp;

package/dist/lib/Settings/RegExpPatterns.js

@@ -23,10 +23,14 @@ export const regExBase64 = /(?<![A-Za-z0-9/+])(?:[A-Za-z0-9/+]{40,})(?:\s^\s*[A-
  *
  * It must be:
  * - at least 40 characters
- * - contain at least 1 of [0-9+=]
- * - end at the end of the line or with [,"'\]
+ * - preceded by a non-Base64
+ * - contain at least 1 of [0-9+/]
+ * - contain at least 1 of [A-Z][a-z][A-Z]
+ * - contain at least 1 of [A-Z][0-9][A-Z] | [a-z][0-9][a-z] | [A-Z][0-9][a-z] | [0-9][A-Za-z][0-9]
+ * - contain at least 1 of [a-z]{3} | [A-Z]{3}
  */
-export const regExBase64SingleLine = /(?<![A-Za-z0-9/+])(?=[^/]|[/][A-Za-z0-9/+]+?[=+])(?![A-Za-z/]+(?![A-Za-z0-9/+=]))(?=[A-Za-z0-9/+=]*?(?:[A-Z]{2}|[0-9]{2}))(?:[A-Za-z0-9/+]{4}){10,}(?:[A-Za-z0-9/+]{3}={1}|[A-Za-z0-9/+]{2}={2}|[A-Za-z0-9/+]{1}={3})?(?![A-Za-z0-9/+=])(?=$|[:.,"'\\)])/gm;
+export const regExBase64SingleLine = /(?<=[^A-Za-z0-9/+_]|^)(?=[A-Za-z]{0,80}[0-9+/])(?=[A-Za-z0-9/+]{0,80}?[A-Z][a-z][A-Z])(?=[A-Za-z0-9/+]{0,80}?(?:[A-Z][0-9][A-Z]|[a-z][0-9][a-z]|[A-Z][0-9][a-z]|[a-z][0-9][A-Z]|[0-9][A-Za-z][0-9]))(?=[A-Za-z0-9/+]{0,80}?(?:[a-z]{3}|[A-Z]{3}))(?:[A-Za-z0-9/+]{40,})=*/gm;
+export const regExBase64SingleLineLegacy = /((?<![A-Za-z0-9/+]))(?=[A-Za-z]{0,80}[0-9])(?:[A-Za-z0-9/+]{4}){10,}(?:[A-Za-z0-9/+]{3}={1}|[A-Za-z0-9/+]{2}={2}|[A-Za-z0-9/+]{1}={3})?(?![A-Za-z0-9/+=])(?=\1)/gm;
 export const regExBase64MultiLine = /(?<![A-Za-z0-9/+])["']?(?:[A-Za-z0-9/+]{40,})["']?(?:\s^\s*["']?[A-Za-z0-9/+]{40,}["']?)+(?:\s^\s*["']?[A-Za-z0-9/+]+={0,3}["']?)?(?![A-Za-z0-9/+=])/gm;
 // cspell:ignore aeiou
 // The following is an attempt at detecting random strings.

package/dist/lib/Settings/TextDocumentSettings.js

@@ -9,7 +9,8 @@ export function combineTextAndLanguageSettings(settings, text, languageId) {
     const settingsForText = mergeSettings(settings, docSettings);
     const langSettings = calcSettingsForLanguageId(settingsForText, languageId);
     // Merge again, to force In-Doc settings.
-    return mergeSettings(langSettings, docSettings);
+    const final = mergeSettings(langSettings, docSettings);
+    return final;
 }
 export function extractSettingsFromText(text) {
     return getInDocumentSettings(text);

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

@@ -0,0 +1,7 @@
+export declare class CwdUrlResolver {
+    #private;
+    constructor();
+    resolveUrl(path?: string): URL;
+    reset(cwd?: string): void;
+}
+//# sourceMappingURL=resolveCwd.d.ts.map

package/dist/lib/Settings/resolveCwd.js

@@ -0,0 +1,28 @@
+import { pathToFileURL } from 'node:url';
+export class CwdUrlResolver {
+    #lastPath;
+    #lastUrl;
+    #cwd;
+    #cwdUrl;
+    constructor() {
+        this.#cwd = process.cwd();
+        this.#cwdUrl = pathToFileURL(this.#cwd);
+        this.#lastPath = this.#cwd;
+        this.#lastUrl = this.#cwdUrl;
+    }
+    resolveUrl(path) {
+        path = path || this.#cwd;
+        if (path === this.#lastPath)
+            return this.#lastUrl;
+        if (path === this.#cwd)
+            return this.#cwdUrl;
+        this.#lastPath = path;
+        this.#lastUrl = pathToFileURL(path);
+        return this.#lastUrl;
+    }
+    reset(cwd = process.cwd()) {
+        this.#cwd = cwd;
+        this.#cwdUrl = pathToFileURL(this.#cwd);
+    }
+}
+//# sourceMappingURL=resolveCwd.js.map

package/dist/lib/textValidation/determineTextDocumentSettings.js

@@ -1,6 +1,6 @@
 import * as path from 'node:path';
 import { getLanguagesForBasename } from '../fileTypes.js';
-import { calcOverrideSettings, getDefaultSettings, getGlobalSettings, mergeSettings } from '../Settings/index.js';
+import { calcOverrideSettings, getDefaultSettings, getGlobalSettingsAsync, mergeSettings } from '../Settings/index.js';
 import { combineTextAndLanguageSettings } from '../Settings/TextDocumentSettings.js';
 import { uriToFilePath } from '../util/Uri.js';
 /**
@@ -17,7 +17,7 @@ import { uriToFilePath } from '../util/Uri.js';
  */
 export async function determineTextDocumentSettings(doc, settings) {
     const filename = uriToFilePath(doc.uri);
-    const settingsWithDefaults = mergeSettings(await getDefaultSettings(settings.loadDefaultConfiguration ?? true), getGlobalSettings(), settings);
+    const settingsWithDefaults = mergeSettings(await getDefaultSettings(settings.loadDefaultConfiguration ?? true), await getGlobalSettingsAsync(), settings);
     const fileSettings = calcOverrideSettings(settingsWithDefaults, filename);
     const languageIds = fileSettings?.languageId?.length
         ? fileSettings.languageId

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.14.1",
+  "version": "8.14.3",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -33,7 +33,8 @@
     "#test": "vitest run --reporter=hanging-process --reporter=default",
     "test": "vitest run --pool=forks",
     "test:update-snapshot": "vitest run -u",
-    "test:perf": "NODE_ENV=production insight --register ts-node/esm --file \"**/*.perf.{mts,ts}\""
+    "test:perf": "NODE_ENV=production insight --file \"**/*.perf.{mts,ts}\" --register ts-node/esm",
+    "test:perf:prof": "NODE_ENV=production node --cpu-prof ../../node_modules/perf-insight/bin.mjs --file \"dist/**/*.perf.{mjs,js}\" -t 1000"
   },
   "repository": {
     "type": "git",
@@ -56,24 +57,24 @@
   "bugs": {
     "url": "https://github.com/streetsidesoftware/cspell/labels/cspell-lib"
   },
-  "homepage": "https://github.com/streetsidesoftware/cspell#readme",
+  "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-lib#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.14.1",
-    "@cspell/cspell-pipe": "8.14.1",
-    "@cspell/cspell-resolver": "8.14.1",
-    "@cspell/cspell-types": "8.14.1",
-    "@cspell/dynamic-import": "8.14.1",
-    "@cspell/filetypes": "8.14.1",
-    "@cspell/strong-weak-map": "8.14.1",
-    "@cspell/url": "8.14.1",
+    "@cspell/cspell-bundled-dicts": "8.14.3",
+    "@cspell/cspell-pipe": "8.14.3",
+    "@cspell/cspell-resolver": "8.14.3",
+    "@cspell/cspell-types": "8.14.3",
+    "@cspell/dynamic-import": "8.14.3",
+    "@cspell/filetypes": "8.14.3",
+    "@cspell/strong-weak-map": "8.14.3",
+    "@cspell/url": "8.14.3",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.5",
-    "cspell-config-lib": "8.14.1",
-    "cspell-dictionary": "8.14.1",
-    "cspell-glob": "8.14.1",
-    "cspell-grammar": "8.14.1",
-    "cspell-io": "8.14.1",
-    "cspell-trie-lib": "8.14.1",
+    "cspell-config-lib": "8.14.3",
+    "cspell-dictionary": "8.14.3",
+    "cspell-glob": "8.14.3",
+    "cspell-grammar": "8.14.3",
+    "cspell-io": "8.14.3",
+    "cspell-trie-lib": "8.14.3",
     "env-paths": "^3.0.0",
     "fast-equals": "^5.0.1",
     "gensequence": "^7.0.0",
@@ -87,14 +88,14 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@cspell/dict-cpp": "^5.1.12",
+    "@cspell/dict-cpp": "^5.1.16",
     "@cspell/dict-csharp": "^4.0.2",
     "@cspell/dict-css": "^4.0.13",
     "@cspell/dict-fa-ir": "^4.0.0",
     "@cspell/dict-fr-fr": "^2.2.2",
     "@cspell/dict-html": "^4.0.5",
     "@cspell/dict-nl-nl": "^2.3.0",
-    "@cspell/dict-python": "^4.2.4",
+    "@cspell/dict-python": "^4.2.6",
     "@types/configstore": "^6.0.2",
     "configstore": "^7.0.0",
     "cspell-dict-nl-nl": "^1.1.2",
@@ -102,5 +103,5 @@
     "lorem-ipsum": "^2.0.8",
     "perf-insight": "^1.2.0"
   },
-  "gitHead": "5552bdba15adc8c073dd33791f30329147c5c64b"
+  "gitHead": "ce996377857f5d7c3e70f27fc512afbe605562f8"
 }