cspell-lib 8.7.0 → 8.8.0

package/dist/esm/Document/resolveDocument.js

@@ -1,4 +1,4 @@
-import { readFile } from 'fs/promises';
+import { readFile } from 'node:fs/promises';
 import { createTextDocument } from '../Models/TextDocument.js';
 import * as Uri from '../util/Uri.js';
 import { clean } from '../util/util.js';

package/dist/esm/LanguageIds.js

@@ -240,7 +240,7 @@ export const languageExtensionDefinitions = [
     { id: 'trie', extensions: ['.trie'], format: 'Binary', description: 'CSpell dictionary file.' },
 ];
 const binaryFormatIds = languageExtensionDefinitions.filter((d) => d.format === 'Binary').map((d) => d.id);
-export const binaryLanguages = new Set(['binary', 'image', 'video', 'fonts'].concat(binaryFormatIds));
+export const binaryLanguages = new Set(['binary', 'image', 'video', 'fonts', ...binaryFormatIds]);
 export const generatedFiles = new Set([...binaryLanguages, 'map', 'lock', 'pdf', 'cache_files', 'rsa', 'pem', 'trie']);
 export const languageIds = languageExtensionDefinitions.map(({ id }) => id);
 const mapExtensionToSetOfLanguageIds = buildLanguageExtensionMapSet(languageExtensionDefinitions);

package/dist/esm/Models/TextDocument.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { TextDocument as VsTextDocument } from 'vscode-languageserver-textdocument';
 import { getFileSystem } from '../fileSystem.js';
 import { getLanguagesForBasename } from '../LanguageIds.js';

package/dist/esm/Settings/CSpellSettingsServer.js

@@ -1,5 +1,5 @@
-import assert from 'assert';
-import { pathToFileURL } from 'url';
+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';
@@ -26,7 +26,7 @@ onClearCache(() => {
 });
 function _mergeWordsCached(left, right) {
     const map = autoResolveWeak(cachedMerges, left, () => new WeakMap());
-    return autoResolveWeak(map, right, () => left.concat(right));
+    return autoResolveWeak(map, right, () => [...left, ...right]);
 }
 function mergeWordsCached(left, right) {
     if (!Array.isArray(left) || !left.length) {

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

@@ -1,8 +1,8 @@
-import assert from 'assert';
+import assert from 'node:assert';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createReaderWriter, CSpellConfigFileInMemory } from 'cspell-config-lib';
 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';
@@ -99,11 +99,11 @@ export class ConfigLoader {
     }
     async searchForConfigFileLocation(searchFrom) {
         const url = toFileURL(searchFrom || cwdURL(), cwdURL());
-        if (typeof searchFrom === 'string' && !isUrlLike(searchFrom) && url.protocol === 'file:') {
-            // check to see if it is a directory
-            if (await isDirectory(this.fs, url)) {
-                return this.configSearch.searchForConfig(addTrailingSlash(url));
-            }
+        if (typeof searchFrom === 'string' &&
+            !isUrlLike(searchFrom) &&
+            url.protocol === 'file:' && // check to see if it is a directory
+            (await isDirectory(this.fs, url))) {
+            return this.configSearch.searchForConfig(addTrailingSlash(url));
         }
         return this.configSearch.searchForConfig(url);
     }
@@ -450,7 +450,7 @@ async function isDirectory(fs, path) {
     try {
         return (await fs.stat(path)).isDirectory();
     }
-    catch (e) {
+    catch {
         return false;
     }
 }
@@ -494,11 +494,7 @@ function relativeToCwd(file) {
     const segments = cwdPath.length - i;
     if (segments > 3)
         return toFilePathOrHref(file);
-    const prefix = '.'
-        .repeat(segments)
-        .split('')
-        .map(() => '..')
-        .join('/');
+    const prefix = [...'.'.repeat(segments)].map(() => '..').join('/');
     return [prefix || '.', ...urlPath.slice(i)].join('/');
 }
 export const __testing__ = {

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

@@ -50,7 +50,7 @@ const setOfLocations = new Set([
     '.config/cspell.yml',
 ]);
 export const searchPlaces = Object.freeze([...setOfLocations]);
-export const defaultConfigFilenames = Object.freeze(searchPlaces.concat());
+export const defaultConfigFilenames = Object.freeze([...searchPlaces]);
 function genCfgLoc(filename, extensions) {
     return extensions.map((ext) => filename + ext);
 }

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

@@ -43,7 +43,7 @@ export class ConfigSearch {
                 const result = searchCache.get(searchHref) || pFoundUrl;
                 searchCache.set(searchHref, result);
             }
-            catch (e) {
+            catch {
                 // ignore
             }
         };
@@ -100,7 +100,7 @@ export class ConfigSearch {
             const dirInfo = await this.fs.readDirectory(dir);
             return new Map(dirInfo.map((ent) => [ent.name, ent]));
         }
-        catch (e) {
+        catch {
             return new Map();
         }
     }
@@ -141,7 +141,7 @@ async function checkPackageJson(fs, filename) {
         const pkg = JSON.parse(file.getText());
         return typeof pkg.cspell === 'object';
     }
-    catch (e) {
+    catch {
         return false;
     }
 }

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

@@ -1,5 +1,5 @@
 import { homedir } from 'node:os';
-import { fileURLToPath } from 'url';
+import { fileURLToPath } from 'node:url';
 import { resolveFile } from '../../../util/resolveFile.js';
 import { resolveFileWithURL, toFilePathOrHref } from '../../../util/url.js';
 import * as util from '../../../util/util.js';

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

@@ -1,9 +1,9 @@
 /**
  * Handles loading of `.pnp.js` and `.pnp.js` files.
  */
+import { fileURLToPath } from 'node:url';
 import clearModule from 'clear-module';
 import importFresh from 'import-fresh';
-import { fileURLToPath } from 'url';
 import { findUp } from '../../util/findUp.js';
 import { toFileUrl } from '../../util/url.js';
 import { UnsupportedPnpFile } from './ImportError.js';
@@ -18,7 +18,7 @@ export class PnpLoader {
     cacheKeySuffix;
     constructor(pnpFiles = defaultPnpFiles) {
         this.pnpFiles = pnpFiles;
-        this.cacheKeySuffix = ':' + pnpFiles.join();
+        this.cacheKeySuffix = ':' + pnpFiles.join(',');
     }
     /**
      * Request that the nearest .pnp file gets loaded

package/dist/esm/Settings/DictionarySettings.js

@@ -1,5 +1,5 @@
+import * as path from 'node:path';
 import { mapDictionaryInformationToWeightMap } from 'cspell-trie-lib';
-import * as path from 'path';
 import { isDictionaryDefinitionInlineInternal } from '../Models/CSpellSettingsInternalDef.js';
 import { createAutoResolveWeakWeakCache } from '../util/AutoResolve.js';
 import { resolveRelativeTo } from '../util/resolveFile.js';
@@ -60,7 +60,7 @@ function determineName(filename, options) {
 export function calcDictionaryDefsToLoad(settings) {
     const { dictionaries = [], dictionaryDefinitions = [], noSuggestDictionaries = [] } = settings;
     const colNoSug = createDictionaryReferenceCollection(noSuggestDictionaries);
-    const colDicts = createDictionaryReferenceCollection(dictionaries.concat(colNoSug.enabled()));
+    const colDicts = createDictionaryReferenceCollection([...dictionaries, ...colNoSug.enabled()]);
     const modDefs = dictionaryDefinitions.map((def) => {
         const enabled = colNoSug.isEnabled(def.name);
         if (enabled === undefined)

package/dist/esm/Settings/GlobalSettings.js

@@ -1,5 +1,5 @@
+import { pathToFileURL } from 'node:url';
 import { CSpellConfigFileInMemory, CSpellConfigFileJson } from 'cspell-config-lib';
-import { pathToFileURL } from 'url';
 import { isErrnoException } from '../util/errors.js';
 import { logError } from '../util/logger.js';
 import { getSourceDirectoryUrl, toFilePathOrHref } from '../util/url.js';
@@ -55,7 +55,7 @@ export function getGlobalConfigPath() {
         const cfgStore = new ConfigStore(packageName);
         return cfgStore.path;
     }
-    catch (e) {
+    catch {
         return undefined;
     }
 }

package/dist/esm/Settings/InDocSettings.js

@@ -57,7 +57,7 @@ const preferredDirectives = [
     'enableCaseSensitive',
     'disableCaseSensitive',
 ];
-const allDirectives = new Set(preferredDirectives.concat(officialDirectives));
+const allDirectives = new Set([...preferredDirectives, ...officialDirectives]);
 const allDirectiveSuggestions = [
     ...pipeSync(allDirectives, opMap((word) => ({ word }))),
 ];
@@ -84,8 +84,8 @@ export function getInDocumentSettings(text) {
         });
     const dictSettings = dict
         ? {
-            dictionaries: dictionaries.concat(staticInDocumentDictionaryName),
-            dictionaryDefinitions: dictionaryDefinitions.concat(dict),
+            dictionaries: [...dictionaries, staticInDocumentDictionaryName],
+            dictionaryDefinitions: [...dictionaryDefinitions, dict],
         }
         : clean({
             dictionaries: dictionaries.length ? dictionaries : undefined,
@@ -114,7 +114,7 @@ const settingParsers = [
     [/^locale?\b(?!-)/i, parseLocale],
     [/^language\s\b(?!-)/i, parseLocale],
     [/^dictionar(?:y|ies)\b(?!-)/i, parseDictionaries], // cspell:disable-line
-    [/^LocalWords:/, (w) => parseWords(w.replace(/^LocalWords:?/gi, ' '))],
+    [/^LocalWords:/, (w) => parseWords(w.replaceAll(/^LocalWords:?/gi, ' '))],
 ];
 export const regExSpellingGuardBlock = /(\bc?spell(?:-?checker)?::?)\s*disable(?!-line|-next)\b[\s\S]*?((?:\1\s*enable\b)|$)/gi;
 export const regExSpellingGuardNext = /\bc?spell(?:-?checker)?::?\s*disable-next\b.*\s\s?.*/gi;
@@ -161,10 +161,8 @@ function* filterUniqueSuggestions(sugs) {
     const map = new Map();
     for (const sug of sugs) {
         const existing = map.get(sug.word);
-        if (existing) {
-            if (sug.isPreferred) {
-                existing.isPreferred = true;
-            }
+        if (existing && sug.isPreferred) {
+            existing.isPreferred = true;
         }
         yield sug;
     }

package/dist/esm/Settings/LanguageSettings.js

@@ -7,11 +7,11 @@ export function getDefaultLanguageSettings() {
     return defaultLanguageSettings;
 }
 function localesToList(locales) {
-    return stringToList(locales.replace(/\s+/g, ','));
+    return stringToList(locales.replaceAll(/\s+/g, ','));
 }
 function stringToList(sList) {
     return sList
-        .replace(/[|;]/g, ',')
+        .replaceAll(/[|;]/g, ',')
         .split(',')
         .map((s) => s.trim())
         .filter((s) => !!s);
@@ -31,7 +31,7 @@ export function normalizeLanguageId(langId) {
 const _normalizeLocale = memorizer(__normalizeLocale);
 function __normalizeLocale(locale) {
     const locales = localesToList(locale);
-    return new Set(locales.map((locale) => locale.toLowerCase().replace(/[^a-z]/g, '')));
+    return new Set(locales.map((locale) => locale.toLowerCase().replaceAll(/[^a-z]/g, '')));
 }
 export function normalizeLocale(locale) {
     locale = typeof locale === 'string' ? locale : locale.join(',');

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

@@ -1,4 +1,3 @@
-import { checkFilenameMatchesExcludeGlob } from '../globs/checkFilenameMatchesGlob.js';
 /**
  * @param filename - filename
  * @param globs - globs
@@ -6,5 +5,5 @@ import { checkFilenameMatchesExcludeGlob } from '../globs/checkFilenameMatchesGl
  * @deprecated true
  * @deprecationMessage No longer actively supported. Use package: `cspell-glob`.
  */
-export declare const checkFilenameMatchesGlob: typeof checkFilenameMatchesExcludeGlob;
+export { checkFilenameMatchesExcludeGlob as checkFilenameMatchesGlob } from '../globs/checkFilenameMatchesGlob.js';
 //# sourceMappingURL=checkFilenameMatchesGlob.d.ts.map

package/dist/esm/Settings/checkFilenameMatchesGlob.js

@@ -1,4 +1,3 @@
-import { checkFilenameMatchesExcludeGlob } from '../globs/checkFilenameMatchesGlob.js';
 /**
  * @param filename - filename
  * @param globs - globs
@@ -6,5 +5,5 @@ import { checkFilenameMatchesExcludeGlob } from '../globs/checkFilenameMatchesGl
  * @deprecated true
  * @deprecationMessage No longer actively supported. Use package: `cspell-glob`.
  */
-export const checkFilenameMatchesGlob = checkFilenameMatchesExcludeGlob;
+export { checkFilenameMatchesExcludeGlob as checkFilenameMatchesGlob } from '../globs/checkFilenameMatchesGlob.js';
 //# sourceMappingURL=checkFilenameMatchesGlob.js.map

package/dist/esm/Settings/link.js

@@ -1,5 +1,5 @@
-import * as fs from 'fs';
-import * as Path from 'path';
+import * as fs from 'node:fs';
+import * as Path from 'node:path';
 import { toError } from '../util/errors.js';
 import { clean } from '../util/util.js';
 import { readRawSettings } from './Controller/configLoader/index.js';
@@ -25,7 +25,7 @@ function isString(s) {
 }
 export async function addPathsToGlobalImports(paths) {
     const resolvedSettings = await Promise.all(paths.map(resolveSettings));
-    const hasError = resolvedSettings.filter((r) => !!r.error).length > 0;
+    const hasError = resolvedSettings.some((r) => !!r.error);
     if (hasError) {
         return {
             success: false,
@@ -134,7 +134,7 @@ function findPackageForCSpellConfig(pathToConfig) {
             name: pkg['name'],
         };
     }
-    catch (e) {
+    catch {
         return undefined;
     }
 }

package/dist/esm/Settings/mergeList.js

@@ -25,7 +25,7 @@ export function mergeList(left, right) {
         return right;
     if (!right.length)
         return left;
-    const result = cacheMergeLists.get(left, right, (left, right) => left.concat(right));
+    const result = cacheMergeLists.get(left, right, (left, right) => [...left, ...right]);
     Object.freeze(left);
     Object.freeze(right);
     Object.freeze(result);

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

@@ -7,7 +7,7 @@ import { AutoResolveWeakCache, AutoResolveWeakWeakCache } from '../../util/AutoR
 import { toError } from '../../util/errors.js';
 import { SimpleCache } from '../../util/simpleCache.js';
 import { SpellingDictionaryLoadError } from '../SpellingDictionaryError.js';
-const MAX_AGE = 10000;
+const MAX_AGE = 10_000;
 const loaders = {
     S: loadSimpleWordList,
     C: legacyWordList,
@@ -109,13 +109,14 @@ export class DictionaryLoader {
             loadingState: LoadingState.Loading,
             sig,
         };
-        // eslint-disable-next-line promise/catch-or-return
-        pending.then(([dictionary, stat]) => {
+        pending
+            .then(([dictionary, stat]) => {
             entry.stat = stat;
             entry.dictionary = dictionary;
             entry.loadingState = LoadingState.Loaded;
             return;
-        });
+        })
+            .catch(() => undefined);
         return entry;
     }
     getStat(uri) {
@@ -141,7 +142,7 @@ export class DictionaryLoader {
         const path = def.path;
         const loaderType = determineType(toFileURL(path), def);
         const optValues = importantOptionKeys.map((k) => def[k]?.toString() || '');
-        const parts = [path, loaderType].concat(optValues);
+        const parts = [path, loaderType, ...optValues];
         return parts.join('|');
     }
 }
@@ -178,7 +179,7 @@ async function legacyWordList(reader, filename, options) {
 function _legacyWordListSync(lines, filename, options) {
     const words = pipe(lines, 
     // Remove comments
-    opMap((line) => line.replace(/#.*/g, '')), 
+    opMap((line) => line.replaceAll(/#.*/g, '')), 
     // Split on everything else
     opConcatMap((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), opFilter((word) => !!word));
     return createSpellingDictionary(words, options.name, filename.toString(), options);
@@ -190,7 +191,7 @@ async function wordsPerLineWordList(reader, filename, options) {
 function _wordsPerLineWordList(lines, filename, options) {
     const words = pipe(lines, 
     // Remove comments
-    opMap((line) => line.replace(/#.*/g, '')), 
+    opMap((line) => line.replaceAll(/#.*/g, '')), 
     // Split on everything else
     opConcatMap((line) => line.split(/\s+/gu)), opFilter((word) => !!word));
     return createSpellingDictionary(words, options.name, filename, options);

package/dist/esm/SpellingDictionary/SuggestExperimental/SuggestionCollector.js

@@ -8,7 +8,7 @@ export class SuggestionCollector {
         this.minScore = minScore;
     }
     get collection() {
-        return this.results.concat();
+        return [...this.results];
     }
     get sortedCollection() {
         return this.collection.sort(compareResults);

package/dist/esm/SpellingDictionary/SuggestExperimental/helpers.js

@@ -16,16 +16,16 @@ export function mergeFeatures(map, features) {
     map.append(features);
 }
 export function wordToSingleLetterFeatures(word) {
-    return word.split('').map((a) => [a, 1]);
+    return [...word].map((a) => [a, 1]);
 }
 export function wordToTwoLetterFeatures(word) {
     return segmentString(word, 2).map((s) => [s, 1]);
 }
 export function segmentString(s, segLen) {
     const count = Math.max(0, s.length - segLen + 1);
-    const result = new Array(count);
+    const result = [];
     for (let i = 0; i < count; ++i) {
-        result[i] = s.substr(i, segLen);
+        result[i] = s.slice(i, i + segLen);
     }
     return result;
 }

package/dist/esm/clearCachedFiles.js

@@ -18,7 +18,7 @@ export function clearCachedFiles() {
 function _clearCachedFiles() {
     // We want to dispatch immediately.
     dispatchClearCache();
-    return Promise.all([refreshDictionaryCache(0)]).then(() => undefined);
+    return refreshDictionaryCache(0).then(() => undefined);
 }
 /**
  * Sends and event to clear the caches.

package/dist/esm/events/events.d.ts

@@ -1,17 +1,45 @@
-/**
- * Event indicating that the cache should be cleared.
- */
-export declare class ClearCacheEvent extends Event {
-    constructor();
-    static eventName: "clear-cache";
-}
-export type EventNames = typeof ClearCacheEvent.eventName;
-export type EventTypes = ClearCacheEvent;
-export interface DisposableListener {
+export interface Disposable {
     dispose(): void;
 }
-export declare function addEventListener(event: EventNames, listener: (event: ClearCacheEvent) => void): DisposableListener;
-export declare function dispatchEvent(event: EventTypes): void;
+type EventListener<T, U = unknown> = (e: T) => U;
+export interface EventFn<T, U = unknown> {
+    /**
+     * A function that represents an event to which you subscribe by calling it with
+     * a listener function as argument.
+     *
+     * @param listener The listener function will be called when the event happens.
+     * @returns A disposable which unsubscribes the event listener.
+     */
+    (listener: (e: T) => U): Disposable;
+}
+export type DisposableListener = Disposable;
+export interface IEventEmitter<T> extends Disposable {
+    readonly name: string;
+    readonly on: EventFn<T>;
+    fire(event: T): Error[] | undefined | void;
+}
+export declare function createEmitter<T>(name: string): IEventEmitter<T>;
+export declare class EventEmitter<T> implements IEventEmitter<T> {
+    #private;
+    readonly name: string;
+    constructor(name: string);
+    /**
+     * The event listeners can subscribe to.
+     */
+    readonly on: (listener: EventListener<T>) => Disposable;
+    /**
+     * Notify all subscribers of the {@link EventEmitter.on event}. Failure
+     * of one or more listener will not fail this function call.
+     *
+     * @param data The event object.
+     */
+    fire(event: T): undefined | Error[];
+    /**
+     * Dispose this object and free resources.
+     */
+    readonly dispose: () => void;
+}
 export declare function onClearCache(listener: () => void): DisposableListener;
 export declare function dispatchClearCache(): void;
+export {};
 //# sourceMappingURL=events.d.ts.map

package/dist/esm/events/events.js

@@ -1,28 +1,64 @@
+import { toError } from '../util/errors.js';
+export function createEmitter(name) {
+    return new EventEmitter(name);
+}
+export class EventEmitter {
+    name;
+    #listeners = new Set();
+    constructor(name) {
+        this.name = name;
+    }
+    /**
+     * The event listeners can subscribe to.
+     */
+    on = (listener) => {
+        this.#listeners.add(listener);
+        return {
+            dispose: () => {
+                this.#listeners.delete(listener);
+            },
+        };
+    };
+    /**
+     * Notify all subscribers of the {@link EventEmitter.on event}. Failure
+     * of one or more listener will not fail this function call.
+     *
+     * @param data The event object.
+     */
+    fire(event) {
+        let errors;
+        for (const listener of this.#listeners) {
+            try {
+                listener(event);
+            }
+            catch (e) {
+                errors = errors ?? [];
+                errors.push(toError(e));
+            }
+        }
+        return errors;
+    }
+    /**
+     * Dispose this object and free resources.
+     */
+    dispose = () => {
+        this.#listeners.clear();
+    };
+}
 /**
  * Event indicating that the cache should be cleared.
  */
-export class ClearCacheEvent extends Event {
+class ClearCacheEvent extends EventEmitter {
     constructor() {
         super(ClearCacheEvent.eventName);
     }
     static eventName = 'clear-cache';
 }
-const eventEmitter = new EventTarget();
-export function addEventListener(event, listener) {
-    eventEmitter.addEventListener(event, listener);
-    return {
-        dispose() {
-            eventEmitter.removeEventListener(event, listener);
-        },
-    };
-}
-export function dispatchEvent(event) {
-    eventEmitter.dispatchEvent(event);
-}
+const clearCacheEvent = new ClearCacheEvent();
 export function onClearCache(listener) {
-    return addEventListener(ClearCacheEvent.eventName, listener);
+    return clearCacheEvent.on(listener);
 }
 export function dispatchClearCache() {
-    dispatchEvent(new ClearCacheEvent());
+    clearCacheEvent.fire(undefined);
 }
 //# sourceMappingURL=events.js.map

package/dist/esm/events/index.d.ts

@@ -1,3 +1,3 @@
-export type { DisposableListener, EventNames, EventTypes } from './events.js';
-export { addEventListener, ClearCacheEvent, dispatchClearCache, dispatchEvent, onClearCache } from './events.js';
+export type { DisposableListener } from './events.js';
+export { dispatchClearCache, onClearCache } from './events.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/events/index.js

@@ -1,2 +1,2 @@
-export { addEventListener, ClearCacheEvent, dispatchClearCache, dispatchEvent, onClearCache } from './events.js';
+export { dispatchClearCache, onClearCache } from './events.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.d.ts

@@ -1,17 +1,22 @@
-import * as ExclusionHelper from './exclusionHelper.js';
-import * as Link from './Settings/index.link.js';
-import * as Text from './util/text.js';
+export { clearCachedFiles, clearCaches } from './clearCachedFiles.js';
 export type { Document } from './Document/index.js';
 export { fileToDocument, fileToTextDocument, isBinaryFile } from './Document/index.js';
 export { ExcludeFilesGlobMap, ExclusionFunction } from './exclusionHelper.js';
+export * as ExclusionHelper from './exclusionHelper.js';
 export { FeatureFlag, FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags/index.js';
+export type { VFileSystemProvider, VirtualFS } from './fileSystem.js';
+export { FSCapabilityFlags, getVirtualFS } from './fileSystem.js';
+export { getDictionary } from './getDictionary.js';
 export { getLanguagesForBasename as getLanguageIdsForBaseFilename, getLanguagesForExt } from './LanguageIds.js';
 export type { CreateTextDocumentParams, TextDocument, TextDocumentLine, TextDocumentRef, } from './Models/TextDocument.js';
 export { createTextDocument, updateTextDocument } from './Models/TextDocument.js';
+export type { PerfTimer } from './perf/index.js';
+export { createPerfTimer } from './perf/index.js';
 export { calcOverrideSettings, checkFilenameMatchesGlob, type ConfigurationDependencies, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, type ImportFileRefWithError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './Settings/index.js';
 export { defaultFileName as defaultSettingsFilename } from './Settings/index.js';
+export * as Link from './Settings/index.link.js';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings.js';
-export { determineFinalDocumentSettings, DetermineFinalDocumentSettingsResult, spellCheckDocument, spellCheckFile, SpellCheckFileOptions, SpellCheckFileResult, } from './spellCheckFile.js';
+export { determineFinalDocumentSettings, DetermineFinalDocumentSettingsResult, spellCheckDocument, spellCheckFile, SpellCheckFileOptions, SpellCheckFilePerf, SpellCheckFileResult, } from './spellCheckFile.js';
 export { CompoundWordsMethod, createSpellingDictionary, createCollection as createSpellingDictionaryCollection, isSpellingDictionaryLoadError, refreshDictionaryCache, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryLoadError, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary/index.js';
 export type { SuggestedWord, SuggestionOptions, SuggestionsForWordResult } from './suggestions.js';
 export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions.js';
@@ -20,15 +25,8 @@ 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';
+export * as Text from './util/text.js';
 export { checkText, checkTextDocument, CheckTextInfo, IncludeExcludeFlag, IncludeExcludeOptions, TextInfoItem, validateText, ValidationIssue, } from './validator.js';
 export * from '@cspell/cspell-types';
 export { asyncIterableToArray, readFileText as readFile, readFileTextSync as readFileSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from 'cspell-io';
-export { Link, Text };
-export { ExclusionHelper };
-export { clearCachedFiles, clearCaches } from './clearCachedFiles.js';
-export type { VFileSystemProvider, VirtualFS } from './fileSystem.js';
-export { FSCapabilityFlags, getVirtualFS } from './fileSystem.js';
-export { getDictionary } from './getDictionary.js';
-export type { PerfTimer } from './perf/index.js';
-export { createPerfTimer } from './perf/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -1,12 +1,15 @@
-import * as ExclusionHelper from './exclusionHelper.js';
-import * as Link from './Settings/index.link.js';
-import * as Text from './util/text.js';
+export { clearCachedFiles, clearCaches } from './clearCachedFiles.js';
 export { fileToDocument, fileToTextDocument, isBinaryFile } from './Document/index.js';
+export * as ExclusionHelper from './exclusionHelper.js';
 export { FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags/index.js';
+export { FSCapabilityFlags, getVirtualFS } from './fileSystem.js';
+export { getDictionary } from './getDictionary.js';
 export { getLanguagesForBasename as getLanguageIdsForBaseFilename, getLanguagesForExt } from './LanguageIds.js';
 export { createTextDocument, updateTextDocument } from './Models/TextDocument.js';
+export { createPerfTimer } from './perf/index.js';
 export { calcOverrideSettings, checkFilenameMatchesGlob, createConfigLoader, currentSettingsFileVersion, defaultConfigFilenames, defaultFileName, ENV_CSPELL_GLOB_ROOT, extractDependencies, extractImportErrors, finalizeSettings, getCachedFileSize, getDefaultBundledSettingsAsync, getDefaultConfigLoader, getDefaultSettings, getGlobalSettings, getGlobalSettingsAsync, getSources, ImportError, loadConfig, loadPnP, mergeInDocSettings, mergeSettings, readRawSettings, readSettings, readSettingsFiles, searchForConfig, sectionCSpell, } from './Settings/index.js';
 export { defaultFileName as defaultSettingsFilename } from './Settings/index.js';
+export * as Link from './Settings/index.link.js';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings.js';
 export { determineFinalDocumentSettings, spellCheckDocument, spellCheckFile, } from './spellCheckFile.js';
 export { CompoundWordsMethod, createSpellingDictionary, createCollection as createSpellingDictionaryCollection, isSpellingDictionaryLoadError, refreshDictionaryCache, SpellingDictionaryLoadError, } from './SpellingDictionary/index.js';
@@ -15,13 +18,8 @@ export { DocumentValidator, shouldCheckDocument } from './textValidation/index.j
 export { traceWords, traceWordsAsync } from './trace.js';
 export { getLogger, setLogger } from './util/logger.js';
 export { resolveFile } from './util/resolveFile.js';
+export * as Text from './util/text.js';
 export { checkText, checkTextDocument, IncludeExcludeFlag, validateText, } from './validator.js';
 export * from '@cspell/cspell-types';
 export { asyncIterableToArray, readFileText as readFile, readFileTextSync as readFileSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from 'cspell-io';
-export { Link, Text };
-export { ExclusionHelper };
-export { clearCachedFiles, clearCaches } from './clearCachedFiles.js';
-export { FSCapabilityFlags, getVirtualFS } from './fileSystem.js';
-export { getDictionary } from './getDictionary.js';
-export { createPerfTimer } from './perf/index.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/suggestions.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { finalizeSettings, getDefaultSettings, getGlobalSettingsAsync, mergeSettings } from './Settings/index.js';
 import { calcSettingsForLanguageId, isValidLocaleIntlFormat, normalizeLocaleIntl, } from './Settings/LanguageSettings.js';
 import { getDictionaryInternal, refreshDictionaryCache } from './SpellingDictionary/index.js';

package/dist/esm/textValidation/checkText.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { resolveDocumentToTextDocument } from '../Document/resolveDocument.js';
 import { isTextDocument } from '../Models/TextDocument.js';
 import * as Settings from '../Settings/index.js';
@@ -69,8 +69,7 @@ function genResult(text, issues, includeRanges) {
             startPos: lastPos,
             endPos: startPos,
             flagIE: IncludeExcludeFlag.EXCLUDE,
-        });
-        result.push({
+        }, {
             text: text.slice(startPos, endPos),
             startPos,
             endPos,

package/dist/esm/textValidation/determineTextDocumentSettings.js

@@ -1,4 +1,4 @@
-import * as path from 'path';
+import * as path from 'node:path';
 import { getLanguagesForBasename } from '../LanguageIds.js';
 import { calcOverrideSettings, getDefaultSettings, getGlobalSettings, mergeSettings } from '../Settings/index.js';
 import { combineTextAndLanguageSettings } from '../Settings/TextDocumentSettings.js';

package/dist/esm/textValidation/docValidator.js

@@ -1,6 +1,6 @@
+import assert from 'node:assert';
 import { opConcatMap, opMap, pipeSync } from '@cspell/cspell-pipe/sync';
 import { IssueType } from '@cspell/cspell-types';
-import assert from 'assert';
 import { getGlobMatcherForExcluding } from '../globs/getGlobMatcher.js';
 import { updateTextDocument } from '../Models/TextDocument.js';
 import { createPerfTimer } from '../perf/index.js';
@@ -78,6 +78,7 @@ export class DocumentValidator {
         const uri = this._document.uri;
         recGlobMatcherTime();
         const recShouldCheckTime = recordPerfTime(this.perfTiming, '_shouldCheck');
+        // eslint-disable-next-line unicorn/prefer-regexp-test
         const shouldCheck = !matcher.match(uriToFilePath(uri)) && (docSettings.enabled ?? true);
         recShouldCheckTime();
         const recFinalizeTime = recordPerfTime(this.perfTiming, '_finalizeSettings');
@@ -206,7 +207,7 @@ export class DocumentValidator {
             const spellingIssues = forceCheck || this.shouldCheckDocument() ? [...this._checkParsedText(this._parse())] : [];
             const directiveIssues = this.checkDocumentDirectives();
             // console.log('Stats: %o', this._preparations.textValidator.lineValidator.dict.stats());
-            const allIssues = spellingIssues.concat(directiveIssues).sort((a, b) => a.offset - b.offset);
+            const allIssues = [...spellingIssues, ...directiveIssues].sort((a, b) => a.offset - b.offset);
             return allIssues;
         }
         finally {
@@ -350,7 +351,7 @@ function sanitizeSuggestion(sug) {
 async function searchForDocumentConfig(document, defaultConfig, pnpSettings) {
     const { uri } = document;
     if (uri.scheme !== 'file')
-        return Promise.resolve(defaultConfig);
+        return defaultConfig;
     return searchForConfig(uri.toString(), pnpSettings).then((s) => s || defaultConfig);
 }
 function mapSug(sug) {
@@ -377,6 +378,7 @@ export async function shouldCheckDocument(doc, options, settings) {
         const matcher = getGlobMatcherForExcluding(localConfig?.ignorePaths);
         const docSettings = await determineTextDocumentSettings(doc, config);
         const uri = doc.uri;
+        // eslint-disable-next-line unicorn/prefer-regexp-test
         return !matcher.match(uriToFilePath(uri)) && (docSettings.enabled ?? true);
     }
     return { errors, shouldCheck: await shouldCheck() };

package/dist/esm/textValidation/isWordValid.js

@@ -1,5 +1,5 @@
 function hasWordCheck(dict, word) {
-    word = word.includes('\\') ? word.replace(/\\/g, '') : word;
+    word = word.includes('\\') ? word.replaceAll('\\', '') : word;
     return dict.has(word);
 }
 export function isWordValidWithEscapeRetry(dict, wo, line) {

package/dist/esm/textValidation/traceWord.js

@@ -12,7 +12,7 @@ export function traceWord(word, dictCollection, config) {
     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 wordSplits = wfSplits.some((s) => s.word === word) ? wfSplits : [wsFound, ...wfSplits];
     const traces = wordSplits
         .filter(unique)
         .map((s) => s.word)

package/dist/esm/textValidation/validator.js

@@ -17,7 +17,7 @@ export async function validateText(text, settings, options = {}) {
     const validationIssues = options.validateDirectives || finalSettings.validateDirectives
         ? validateInDocumentSettings(text, settings)
         : [];
-    const issues = spellingIssues.concat(mapValidationIssues(text, validationIssues));
+    const issues = [...spellingIssues, ...mapValidationIssues(text, validationIssues)];
     if (!options.generateSuggestions) {
         return issues;
     }

package/dist/esm/trace.js

@@ -22,9 +22,10 @@ export async function* traceWordsAsync(words, settings, options) {
         }));
         const withLanguageId = calcSettingsForLanguageId(withLocale, languageId ?? withLocale.languageId ?? 'plaintext');
         const settings = finalizeSettings(withLanguageId);
-        const dictionaries = (settings.dictionaries || [])
-            .concat((settings.dictionaryDefinitions || []).map((d) => d.name))
-            .filter(util.uniqueFn);
+        const dictionaries = [
+            ...(settings.dictionaries || []),
+            ...(settings.dictionaryDefinitions || []).map((d) => d.name),
+        ].filter(util.uniqueFn);
         const dictSettings = toInternalSettings({ ...settings, dictionaries });
         const dictBase = await getDictionaryInternal(settings);
         const dicts = await getDictionaryInternal(dictSettings);

package/dist/esm/util/AutoResolveLRUCache.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { isArrayEqual } from './util.js';
 export class AutoResolveLRUCache {
     maxSize;

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

@@ -10,7 +10,7 @@ export declare class MinHeapQueue<T> implements IterableIterator<T> {
     add(t: T): MinHeapQueue<T>;
     get length(): number;
     dequeue(): T | undefined;
-    concat(i: Iterable<T>): MinHeapQueue<T>;
+    append(i: Iterable<T>): MinHeapQueue<T>;
     next(): IteratorResult<T>;
     [Symbol.iterator](): IterableIterator<T>;
     clone(): MinHeapQueue<T>;

package/dist/esm/util/MinHeapQueue.js

@@ -35,10 +35,8 @@ function takeFromHeap(t, compare) {
         i = k;
         j = i * 2 + 1;
     }
-    if (j === m) {
-        if (compare(t[i], t[j]) > 0) {
-            swap(t, i, j);
-        }
+    if (j === m && compare(t[i], t[j]) > 0) {
+        swap(t, i, j);
     }
     return result;
 }
@@ -61,7 +59,7 @@ export class MinHeapQueue {
     dequeue() {
         return takeFromHeap(this.values, this.compare);
     }
-    concat(i) {
+    append(i) {
         for (const v of i) {
             this.add(v);
         }
@@ -83,7 +81,7 @@ export class MinHeapQueue {
     }
     clone() {
         const clone = new MinHeapQueue(this.compare);
-        clone.values = this.values.concat();
+        clone.values = [...this.values];
         return clone;
     }
 }

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

@@ -14,7 +14,7 @@ export declare class PairingHeap<T> implements IterableIterator<T> {
     constructor(compare: CompareFn<T>);
     add(v: T): this;
     dequeue(): T | undefined;
-    concat(i: Iterable<T>): this;
+    append(i: Iterable<T>): this;
     next(): IteratorResult<T>;
     peek(): T | undefined;
     [Symbol.iterator](): IterableIterator<T>;

package/dist/esm/util/PairingHeap.js

@@ -16,7 +16,7 @@ export class PairingHeap {
             return undefined;
         return n.value;
     }
-    concat(i) {
+    append(i) {
         for (const v of i) {
             this.add(v);
         }

package/dist/esm/util/TextMap.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 /**
  * Extract a substring from a TextMap.
  * @param textMap - A text range with an optional map
@@ -24,7 +24,7 @@ export function extractTextMapRangeOrigin(textMap, extractRange) {
     const endDiff = srcTxt.length - mapEndDst;
     const head = !srcMap[0] && !srcMap[1] ? [] : [0, 0];
     const tail = [mapEndSrc + endDiff, mapEndDst + endDiff];
-    const sMap = head.concat(srcMap).concat(tail);
+    const sMap = [...head, ...srcMap, ...tail];
     let idx = 0;
     for (; idx < sMap.length && a >= sMap[idx]; idx += 2) {
         // empty

package/dist/esm/util/Uri.js

@@ -1,4 +1,4 @@
-import assert from 'assert';
+import assert from 'node:assert';
 import { URI, Utils } from 'vscode-uri';
 const isFile = /^(?:[a-zA-Z]:|[/\\])/;
 const isPossibleUri = /\w:\/\//;
@@ -77,7 +77,7 @@ class UriImpl extends URI {
     }
     toString() {
         // if (this.scheme !== 'stdin') return super.toString(true);
-        const path = encodeURI(this.path || '').replace(/[#?]/g, (c) => `%${c.charCodeAt(0).toString(16)}`);
+        const path = encodeURI(this.path || '').replaceAll(/[#?]/g, (c) => `%${(c.codePointAt(0) || 0).toString(16)}`);
         const base = `${this.scheme}://${this.authority || ''}${path}`;
         const query = (this.query && `?${this.query}`) || '';
         const fragment = (this.fragment && `#${this.fragment}`) || '';
@@ -123,7 +123,7 @@ class UriImpl extends URI {
     }
 }
 function normalizeFilePath(path) {
-    return normalizeDriveLetter(path.replace(/\\/g, '/'));
+    return normalizeDriveLetter(path.replaceAll('\\', '/'));
 }
 function parseStdinUri(uri) {
     assert(uri.startsWith(STDIN_PROTOCOL));

package/dist/esm/util/errors.js

@@ -1,4 +1,4 @@
-import { format } from 'util';
+import { format } from 'node:util';
 function getTypeOf(t) {
     return typeof t;
 }

package/dist/esm/util/fileReader.js

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

package/dist/esm/util/findUp.js

@@ -1,6 +1,6 @@
 import { stat } from 'node:fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 export async function findUp(name, options = {}) {
     const { cwd = process.cwd(), type: entryType = 'file', stopAt } = options;
     let dir = path.resolve(toDirPath(cwd));

package/dist/esm/util/regexHelper.js

@@ -4,6 +4,6 @@
  * @returns - the escaped string.
  */
 export function escapeRegEx(s) {
-    return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+    return s.replaceAll(/[|\\{}()[\]^$+*?.]/g, '\\$&').replaceAll('-', '\\x2d');
 }
 //# sourceMappingURL=regexHelper.js.map

package/dist/esm/util/repMap.js

@@ -10,11 +10,11 @@ export function createMapper(repMap) {
         .map((s) => {
         try {
             // fix up any nested ()
-            const r = s.match(/\(/) ? s.replace(/\((?=.*\))/g, '(?:').replace(/\(\?:\?/g, '(?') : s;
+            const r = /\(/.test(s) ? s.replaceAll(/\((?=.*\))/g, '(?:').replaceAll('(?:?', '(?') : s;
             new RegExp(r);
             s = r;
         }
-        catch (err) {
+        catch {
             return escapeRegEx(s);
         }
         return s;

package/dist/esm/util/resolveFile.js

@@ -1,11 +1,11 @@
 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';
-import * as os from 'os';
-import * as path from 'path';
 import resolveFrom from 'resolve-from';
-import { fileURLToPath } from 'url';
 import { srcDirectory } from '../../lib-cjs/pkg-info.cjs';
 import { getFileSystem } from '../fileSystem.js';
 import { envToTemplateVars, replaceTemplate } from './templates.js';
@@ -73,7 +73,7 @@ export class FileResolver {
             const s = await this.fs.stat(file);
             return s.isFile() || s.isUnknown();
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -135,16 +135,17 @@ export class FileResolver {
             const r = require.resolve(filename);
             return { filename: r, relativeTo: rel.toString(), found: true, method: 'tryCreateRequire' };
         }
-        catch (_) {
+        catch {
             return undefined;
         }
     };
     tryNodeResolveDefaultPaths = (filename) => {
         try {
+            // eslint-disable-next-line unicorn/prefer-module
             const r = require.resolve(filename);
             return { filename: r, relativeTo: undefined, found: true, method: 'tryNodeResolveDefaultPaths' };
         }
-        catch (_) {
+        catch {
             return undefined;
         }
     };
@@ -167,10 +168,11 @@ export class FileResolver {
         }
         const paths = calcPaths(path.resolve(relativeToPath));
         try {
+            // eslint-disable-next-line unicorn/prefer-module
             const r = require.resolve(filename, { paths });
             return { filename: r, relativeTo: relativeToPath, found: true, method: 'tryNodeRequireResolve' };
         }
-        catch (_) {
+        catch {
             return undefined;
         }
     };
@@ -180,7 +182,7 @@ export class FileResolver {
             const resolved = fileURLToPath(importResolveModuleName(filename, paths));
             return { filename: resolved, relativeTo: relativeTo.toString(), found: true, method: 'tryImportResolve' };
         }
-        catch (_) {
+        catch {
             return undefined;
         }
     };
@@ -218,7 +220,7 @@ export class FileResolver {
                 method: 'tryResolveFrom',
             };
         }
-        catch (error) {
+        catch {
             // Failed to resolve a relative module request
             return undefined;
         }

package/dist/esm/util/text.js

@@ -83,10 +83,10 @@ export function extractWordsFromCodeTextOffset(textOffset) {
     return pipe(extractWordsFromTextOffset(textOffset), opConcatMap(splitCamelCaseWordWithOffset));
 }
 export function isUpperCase(word) {
-    return !!word.match(regExAllUpper);
+    return regExAllUpper.test(word);
 }
 export function isLowerCase(word) {
-    return !!word.match(regExAllLower);
+    return regExAllLower.test(word);
 }
 export function isFirstCharacterUpper(word) {
     return isUpperCase(word.slice(0, 1));
@@ -107,13 +107,13 @@ export function camelToSnake(word) {
     return splitCamelCaseWord(word).join('_').toLowerCase();
 }
 export function matchCase(example, word) {
-    if (example.match(regExFirstUpper)) {
+    if (regExFirstUpper.test(example)) {
         return word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase();
     }
-    if (example.match(regExAllLower)) {
+    if (regExAllLower.test(example)) {
         return word.toLowerCase();
     }
-    if (example.match(regExAllUpper)) {
+    if (regExAllUpper.test(example)) {
         return word.toUpperCase();
     }
     if (isFirstCharacterUpper(example)) {

package/dist/esm/util/textRegex.js

@@ -30,12 +30,12 @@ export function stringToRegExp(pattern, defaultFlags = 'gimu', forceFlags = 'g')
         if (pat) {
             const regPattern = flag.includes('x') ? removeVerboseFromRegExp(pat) : pat;
             // Make sure the flags are unique.
-            const flags = [...new Set(forceFlags + flag)].join('').replace(/[^gimuy]/g, '');
+            const flags = [...new Set(forceFlags + flag)].join('').replaceAll(/[^gimuy]/g, '');
             const regex = new RegExp(regPattern, flags);
             return regex;
         }
     }
-    catch (e) {
+    catch {
         /* empty */
     }
     return undefined;

package/dist/esm/util/url.js

@@ -1,5 +1,5 @@
-import path from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { srcDirectory } from '../../lib-cjs/pkg-info.cjs';
 const isUrlRegExp = /^(?:[\w][\w-]+:\/|data:|untitled:)/i;
 /**

package/dist/esm/util/wordSplitter.js

@@ -268,7 +268,7 @@ function splitIntoWords(lineSeg, breaks, has) {
     let maxCost = lineSeg.relEnd - lineSeg.relStart;
     const candidates = new PairingHeap(compare);
     const text = lineSeg.line.text;
-    candidates.concat(makeCandidates(undefined, lineSeg.relStart, 0, 0));
+    candidates.append(makeCandidates(undefined, lineSeg.relStart, 0, 0));
     let attempts = 0;
     let bestPath;
     while (maxCost && candidates.length && attempts++ < maxAttempts) {
@@ -296,13 +296,13 @@ function splitIntoWords(lineSeg, breaks, has) {
             }
             else if (best.c < maxCost) {
                 const c = makeCandidates(t ? best : best.p, j, best.bi + 1, best.c);
-                candidates.concat(c);
+                candidates.append(c);
             }
         }
         else {
             // It is a pass through
             const c = makeCandidates(best.p, best.i, best.bi + 1, best.c);
-            candidates.concat(c);
+            candidates.append(c);
             if (!c.length) {
                 const t = maxIndex > best.i ? toTextOffset(text.slice(best.i, maxIndex), best.i) : undefined;
                 const cost = !t || t.isFound ? 0 : t.text.length;
@@ -322,7 +322,7 @@ function splitIntoWords(lineSeg, breaks, has) {
     return pathToWords(bestPath);
 }
 function mergeSortedBreaks(...maps) {
-    return [].concat(...maps).sort((a, b) => a.offset - b.offset);
+    return maps.flat().sort((a, b) => a.offset - b.offset);
 }
 export const __testing__ = {
     generateWordBreaks,

package/dist/esm/wordListHelper.js

@@ -17,7 +17,7 @@ export function splitLine(line) {
     return [...Text.extractWordsFromText(line)].map(({ text }) => text);
 }
 export function splitCodeWords(words) {
-    return words.map(Text.splitCamelCaseWord).flatMap((a) => a);
+    return words.flatMap(Text.splitCamelCaseWord);
 }
 export function splitLineIntoCodeWords(line) {
     const asMultiWord = regExpWordsWithSpaces.test(line) ? [line] : [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "8.7.0",
+  "version": "8.8.0",
   "description": "A library of useful functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -59,21 +59,21 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "8.7.0",
-    "@cspell/cspell-pipe": "8.7.0",
-    "@cspell/cspell-resolver": "8.7.0",
-    "@cspell/cspell-types": "8.7.0",
-    "@cspell/dynamic-import": "8.7.0",
-    "@cspell/strong-weak-map": "8.7.0",
+    "@cspell/cspell-bundled-dicts": "8.8.0",
+    "@cspell/cspell-pipe": "8.8.0",
+    "@cspell/cspell-resolver": "8.8.0",
+    "@cspell/cspell-types": "8.8.0",
+    "@cspell/dynamic-import": "8.8.0",
+    "@cspell/strong-weak-map": "8.8.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^6.0.0",
-    "cspell-config-lib": "8.7.0",
-    "cspell-dictionary": "8.7.0",
-    "cspell-glob": "8.7.0",
-    "cspell-grammar": "8.7.0",
-    "cspell-io": "8.7.0",
-    "cspell-trie-lib": "8.7.0",
+    "cspell-config-lib": "8.8.0",
+    "cspell-dictionary": "8.8.0",
+    "cspell-glob": "8.8.0",
+    "cspell-grammar": "8.8.0",
+    "cspell-io": "8.8.0",
+    "cspell-trie-lib": "8.8.0",
     "fast-equals": "^5.0.1",
     "gensequence": "^7.0.0",
     "import-fresh": "^3.3.0",
@@ -98,5 +98,5 @@
     "leaked-handles": "^5.2.0",
     "lorem-ipsum": "^2.0.8"
   },
-  "gitHead": "5318079ed11fe77e981287ecf1c40d6f28dd91ed"
+  "gitHead": "a42bce675c00cb2d51809b3ae3894119ea4f5ce7"
 }