cspell-lib 6.10.1 → 6.11.0

package/dist/FeatureFlags/FeatureFlags.d.ts

@@ -0,0 +1,30 @@
+export interface FeatureFlag {
+    name: string;
+    description: string;
+}
+declare type FlagTypes = string | boolean;
+/**
+ * Feature Flags are used to turn on/off features.
+ * These are primarily used before a feature has been fully released.
+ */
+export declare class FeatureFlags {
+    private flags;
+    private flagValues;
+    constructor(flags?: FeatureFlag[]);
+    register(flag: FeatureFlag): this;
+    register(name: string, description: string): this;
+    getFlag(flag: string): FlagTypes | undefined;
+    getFlagBool(flag: string): boolean | undefined;
+    setFlag(flag: string, value?: FlagTypes): this;
+    getFlagInfo(flag: string): FeatureFlag | undefined;
+    getFlags(): FeatureFlag[];
+    getFlagValues(): Map<string, FlagTypes>;
+    reset(): this;
+}
+export declare class UnknownFeatureFlagError extends Error {
+    readonly flag: string;
+    constructor(flag: string);
+}
+export declare function getSystemFeatureFlags(): FeatureFlags;
+export {};
+//# sourceMappingURL=FeatureFlags.d.ts.map

package/dist/FeatureFlags/FeatureFlags.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSystemFeatureFlags = exports.UnknownFeatureFlagError = exports.FeatureFlags = void 0;
+let systemFeatureFlags;
+/**
+ * Feature Flags are used to turn on/off features.
+ * These are primarily used before a feature has been fully released.
+ */
+class FeatureFlags {
+    constructor(flags = []) {
+        this.flagValues = new Map();
+        this.flags = new Map(flags.map((f) => [f.name, f]));
+    }
+    register(flagOrName, description) {
+        if (typeof flagOrName === 'string') {
+            return this.register({ name: flagOrName, description: description || '' });
+        }
+        this.flags.set(flagOrName.name, flagOrName);
+        return this;
+    }
+    getFlag(flag) {
+        return this.flagValues.get(flag);
+    }
+    getFlagBool(flag) {
+        return toBool(this.getFlag(flag));
+    }
+    setFlag(flag, value = true) {
+        if (!this.flags.has(flag)) {
+            throw new UnknownFeatureFlagError(flag);
+        }
+        this.flagValues.set(flag, value);
+        return this;
+    }
+    getFlagInfo(flag) {
+        return this.flags.get(flag);
+    }
+    getFlags() {
+        return [...this.flags.values()];
+    }
+    getFlagValues() {
+        return new Map(this.flagValues);
+    }
+    reset() {
+        this.flagValues.clear();
+        return this;
+    }
+}
+exports.FeatureFlags = FeatureFlags;
+class UnknownFeatureFlagError extends Error {
+    constructor(flag) {
+        super(`Unknown feature flag: ${flag}`);
+        this.flag = flag;
+    }
+}
+exports.UnknownFeatureFlagError = UnknownFeatureFlagError;
+function getSystemFeatureFlags() {
+    return systemFeatureFlags || (systemFeatureFlags = new FeatureFlags());
+}
+exports.getSystemFeatureFlags = getSystemFeatureFlags;
+const boolValues = {
+    0: false,
+    1: true,
+    f: false,
+    false: false,
+    n: false,
+    no: false,
+    t: true,
+    true: true,
+    y: true,
+    yes: true,
+};
+function toBool(value) {
+    if (typeof value !== 'string')
+        return value;
+    return boolValues[value.toLowerCase()];
+}
+//# sourceMappingURL=FeatureFlags.js.map

package/dist/FeatureFlags/index.d.ts

@@ -0,0 +1,2 @@
+export { FeatureFlag, FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags';
+//# sourceMappingURL=index.d.ts.map

package/dist/FeatureFlags/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownFeatureFlagError = exports.getSystemFeatureFlags = exports.FeatureFlags = void 0;
+var FeatureFlags_1 = require("./FeatureFlags");
+Object.defineProperty(exports, "FeatureFlags", { enumerable: true, get: function () { return FeatureFlags_1.FeatureFlags; } });
+Object.defineProperty(exports, "getSystemFeatureFlags", { enumerable: true, get: function () { return FeatureFlags_1.getSystemFeatureFlags; } });
+Object.defineProperty(exports, "UnknownFeatureFlagError", { enumerable: true, get: function () { return FeatureFlags_1.UnknownFeatureFlagError; } });
+//# sourceMappingURL=index.js.map

package/dist/Settings/InDocSettings.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.internal = exports.getIgnoreRegExpFromDocument = exports.getIgnoreWordsFromDocument = exports.regExSpellingGuardLine = exports.regExSpellingGuardNext = exports.regExSpellingGuardBlock = exports.validateInDocumentSettings = exports.getInDocumentSettings = void 0;
-const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const sync_1 = require("@cspell/cspell-pipe/sync");
 const gensequence_1 = require("gensequence");
 const SpellingDictionary_1 = require("../SpellingDictionary");
 const Text = __importStar(require("../util/text"));
@@ -32,9 +32,9 @@ const util_1 = require("../util/util");
 const CSpellSettingsServer_1 = require("./CSpellSettingsServer");
 // cspell:ignore gimuy
 const regExMatchRegEx = /\/.*\/[gimuy]*/;
-const regExCSpellInDocDirective = /(?:spell-?checker|c?spell)::?(.*)/gi;
-const regExCSpellDirectiveKey = /(?<=(?:spell-?checker|c?spell)::?)(?!:)(.*)/i;
-const regExInFileSettings = [regExCSpellInDocDirective, /(LocalWords:?.*)/g];
+const regExCSpellInDocDirective = /\b(?:spell-?checker|c?spell)::?(.*)/gi;
+const regExCSpellDirectiveKey = /(?<=\b(?:spell-?checker|c?spell)::?)(?!:)(.*)/i;
+const regExInFileSettings = [regExCSpellInDocDirective, /\b(LocalWords:?.*)/g];
 const officialDirectives = [
     'enable',
     'disable',
@@ -84,7 +84,7 @@ const preferredDirectives = [
     'disableCaseSensitive',
 ];
 const allDirectives = new Set(preferredDirectives.concat(officialDirectives));
-const dictInDocSettings = (0, SpellingDictionary_1.createSpellingDictionary)(allDirectives, 'Directives', 'Directive List', {
+const dictInDocSettings = (0, SpellingDictionary_1.getSpellDictInterface)().createSpellingDictionary(allDirectives, 'Directives', 'Directive List', {
     supportNonStrictSearches: false,
 });
 const EmptyWords = [];
@@ -100,7 +100,7 @@ function getInDocumentSettings(text) {
 }
 exports.getInDocumentSettings = getInDocumentSettings;
 function validateInDocumentSettings(docText, _settings) {
-    return (0, cspell_pipe_1.pipeSync)(getPossibleInDocSettings(docText), (0, cspell_pipe_1.opMap)(parseSettingMatchValidation), (0, cspell_pipe_1.opFilter)(util_1.isDefined));
+    return (0, sync_1.pipeSync)(getPossibleInDocSettings(docText), (0, sync_1.opMap)(parseSettingMatchValidation), (0, sync_1.opFilter)(util_1.isDefined));
 }
 exports.validateInDocumentSettings = validateInDocumentSettings;
 const settingParsers = [
@@ -146,7 +146,7 @@ function parseSettingMatchValidation(matchArray) {
         .suggest(text, { ignoreCase: false })
         .map((sug) => sug.word)
         .filter((a) => !noSuggestDirectives.has(a));
-    const sugs = new Set((0, cspell_pipe_1.pipeSync)(dictSugs, (0, cspell_pipe_1.opAppend)(allDirectives)));
+    const sugs = new Set((0, sync_1.pipeSync)(dictSugs, (0, sync_1.opAppend)(allDirectives)));
     const suggestions = [...sugs].slice(0, 8);
     const issue = {
         range: [start, end],

package/dist/SpellingDictionary/Dictionaries.d.ts

@@ -1,6 +1,5 @@
 import { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
-import { SpellingDictionary } from './SpellingDictionary';
-import { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
+import { SpellingDictionary, SpellingDictionaryCollection } from './SpellingDictionary';
 export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
 export declare function loadDictionaryDefsSync(defsToLoad: DictionaryDefinitionInternal[]): SpellingDictionary[];
 export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;

package/dist/SpellingDictionary/Dictionaries.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDictionaryInternalSync = exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefsSync = exports.loadDictionaryDefs = void 0;
 const DictionarySettings_1 = require("../Settings/DictionarySettings");
 const util_1 = require("../util/util");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
 const DictionaryLoader_1 = require("./DictionaryLoader");
-const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
+const SpellingDictionary_1 = require("./SpellingDictionary");
 function loadDictionaryDefs(defsToLoad) {
     return defsToLoad.map(DictionaryLoader_1.loadDictionary);
 }
@@ -31,22 +30,19 @@ function getDictionaryInternalSync(settings) {
 exports.getDictionaryInternalSync = getDictionaryInternalSync;
 function _getDictionaryInternal(settings, spellDictionaries) {
     const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords } = settings;
-    const settingsWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(words, '[words]', 'From Settings `words`', {
+    const { createSpellingDictionary, createIgnoreWordsDictionary, createCollection, createForbiddenWordsDictionary } = (0, SpellingDictionary_1.getSpellDictInterface)();
+    const settingsWordsDictionary = createSpellingDictionary(words, '[words]', 'From Settings `words`', {
         caseSensitive: true,
         weightMap: undefined,
     });
     const settingsUserWordsDictionary = userWords.length
-        ? (0, createSpellingDictionary_1.createSpellingDictionary)(userWords, '[userWords]', 'From Settings `userWords`', {
+        ? createSpellingDictionary(userWords, '[userWords]', 'From Settings `userWords`', {
             caseSensitive: true,
             weightMap: undefined,
         })
         : undefined;
-    const ignoreWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`', {
-        caseSensitive: true,
-        noSuggest: true,
-        weightMap: undefined,
-    });
-    const flagWordsDictionary = (0, createSpellingDictionary_1.createForbiddenWordsDictionary)(flagWords, '[flagWords]', 'From Settings `flagWords`', {
+    const ignoreWordsDictionary = createIgnoreWordsDictionary(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`');
+    const flagWordsDictionary = createForbiddenWordsDictionary(flagWords, '[flagWords]', 'From Settings `flagWords`', {
         weightMap: undefined,
     });
     const dictionaries = [
@@ -56,6 +52,6 @@ function _getDictionaryInternal(settings, spellDictionaries) {
         ignoreWordsDictionary,
         flagWordsDictionary,
     ].filter(util_1.isDefined);
-    return (0, SpellingDictionaryCollection_1.createCollection)(dictionaries, 'dictionary collection');
+    return createCollection(dictionaries, 'dictionary collection');
 }
 //# sourceMappingURL=Dictionaries.js.map

package/dist/SpellingDictionary/DictionaryController/DictionaryLoader.d.ts

@@ -1,6 +1,6 @@
 import { CSpellIO } from 'cspell-io';
 import { DictionaryDefinitionInternal } from '../../Models/CSpellSettingsInternalDef';
-import { SpellingDictionary } from '../SpellingDictionary';
+import { SpellingDictionary } from '../SpellingDictionaryLibOld/SpellingDictionary';
 export declare type LoadOptions = DictionaryDefinitionInternal;
 export declare class DictionaryLoader {
     private cspellIO;

package/dist/SpellingDictionary/DictionaryController/DictionaryLoader.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DictionaryLoader = void 0;
-const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const sync_1 = require("@cspell/cspell-pipe/sync");
 const errors_1 = require("../../util/errors");
-const createSpellingDictionary_1 = require("../createSpellingDictionary");
+const createSpellingDictionary_1 = require("../SpellingDictionaryLibOld/createSpellingDictionary");
 const SpellingDictionaryError_1 = require("../SpellingDictionaryError");
-const SpellingDictionaryFromTrie_1 = require("../SpellingDictionaryFromTrie");
+const SpellingDictionaryFromTrie_1 = require("../SpellingDictionaryLibOld/SpellingDictionaryFromTrie");
 const MAX_AGE = 10000;
 const loaders = {
     S: loadSimpleWordList,
@@ -231,11 +231,11 @@ function legacyWordListSync(readLinesSync, filename, options) {
     return _legacyWordListSync(lines, filename, options);
 }
 function _legacyWordListSync(lines, filename, options) {
-    const words = (0, cspell_pipe_1.pipeSync)(lines, 
+    const words = (0, sync_1.pipe)(lines, 
     // Remove comments
-    (0, cspell_pipe_1.opMap)((line) => line.replace(/#.*/g, '')), 
+    (0, sync_1.opMap)((line) => line.replace(/#.*/g, '')), 
     // Split on everything else
-    (0, cspell_pipe_1.opConcatMap)((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), (0, cspell_pipe_1.opFilter)((word) => !!word));
+    (0, sync_1.opConcatMap)((line) => line.split(/[^\w\p{L}\p{M}'’]+/gu)), (0, sync_1.opFilter)((word) => !!word));
     return (0, createSpellingDictionary_1.createSpellingDictionary)(words, options.name, filename, options);
 }
 async function wordsPerLineWordList(readLines, filename, options) {
@@ -247,11 +247,11 @@ function wordsPerLineWordListSync(readLinesSync, filename, options) {
     return _wordsPerLineWordList(lines, filename, options);
 }
 function _wordsPerLineWordList(lines, filename, options) {
-    const words = (0, cspell_pipe_1.pipeSync)(lines, 
+    const words = (0, sync_1.pipe)(lines, 
     // Remove comments
-    (0, cspell_pipe_1.opMap)((line) => line.replace(/#.*/g, '')), 
+    (0, sync_1.opMap)((line) => line.replace(/#.*/g, '')), 
     // Split on everything else
-    (0, cspell_pipe_1.opConcatMap)((line) => line.split(/\s+/gu)), (0, cspell_pipe_1.opFilter)((word) => !!word));
+    (0, sync_1.opConcatMap)((line) => line.split(/\s+/gu)), (0, sync_1.opFilter)((word) => !!word));
     return (0, createSpellingDictionary_1.createSpellingDictionary)(words, options.name, filename, options);
 }
 async function loadSimpleWordList(reader, filename, options) {

package/dist/SpellingDictionary/DictionaryLoader.d.ts

@@ -1,7 +1,7 @@
 import { CSpellIO } from 'cspell-io';
 import { DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
 import { DictionaryLoader } from './DictionaryController';
-import { SpellingDictionary } from './SpellingDictionary';
+import { SpellingDictionary } from './SpellingDictionaryLibOld/SpellingDictionary';
 export type { LoadOptions } from './DictionaryController';
 export declare function getDictionaryLoader(cspellIO?: CSpellIO): DictionaryLoader;
 export declare function loadDictionary(def: DictionaryDefinitionInternal): Promise<SpellingDictionary>;

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -1,88 +1,15 @@
-import type { ReplaceMap, DictionaryInformation } from '@cspell/cspell-types';
-import { CompoundWordsMethod, SuggestionCollector, SuggestionResult, WeightMap } from 'cspell-trie-lib';
-export { CompoundWordsMethod, SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
-export interface SearchOptions {
-    useCompounds?: boolean | number | undefined;
-    ignoreCase?: boolean | undefined;
-}
-export interface SuggestOptions {
-    /**
-     * Compounding Mode.
-     * `NONE` is the best option.
-     */
-    compoundMethod?: CompoundWordsMethod;
-    /**
-     * The limit on the number of suggestions to generate. If `allowTies` is true, it is possible
-     * for more suggestions to be generated.
-     */
-    numSuggestions?: number;
-    /**
-     * Max number of changes / edits to the word to get to a suggestion matching suggestion.
-     */
-    numChanges?: number;
-    /**
-     * Allow for case-ingestive checking.
-     */
-    ignoreCase?: boolean;
-    /**
-     * If multiple suggestions have the same edit / change "cost", then included them even if
-     * it causes more than `numSuggestions` to be returned.
-     * @default false
-     */
-    includeTies?: boolean;
-    /**
-     * Maximum amount of time to allow for generating suggestions.
-     */
-    timeout?: number;
-}
-export declare type FindOptions = SearchOptions;
-export interface FindResult {
-    /** the text found, otherwise `false` */
-    found: string | false;
-    /** `true` if it is considered a forbidden word. */
-    forbidden: boolean;
-    /** `true` if it is a no-suggest word. */
-    noSuggest: boolean;
-}
-export declare type HasOptions = SearchOptions;
-export interface SpellingDictionaryOptions {
-    repMap?: ReplaceMap;
-    useCompounds?: boolean;
-    /**
-     * The dictionary is case aware.
-     */
-    caseSensitive?: boolean;
-    noSuggest?: boolean;
-    weightMap?: WeightMap | undefined;
-    dictionaryInformation?: DictionaryInformation;
-    /**
-     * Strip Case and Accents to allow for case insensitive searches and
-     * words without accents.
-     *
-     * Note: this setting only applies to word lists. It has no-impact on trie
-     * dictionaries.
-     *
-     * @default true
-     */
-    supportNonStrictSearches?: boolean;
-}
-export interface SpellingDictionary {
-    readonly name: string;
-    readonly type: string;
-    readonly source: string;
-    readonly containsNoSuggestWords: boolean;
-    has(word: string, options?: HasOptions): boolean;
-    /** A more detailed search for a word, might take longer than `has` */
-    find(word: string, options?: SearchOptions): FindResult | undefined;
-    isForbidden(word: string): boolean;
-    isNoSuggestWord(word: string, options: HasOptions): boolean;
-    suggest(word: string, numSuggestions?: number, compoundMethod?: CompoundWordsMethod, numChanges?: number, ignoreCase?: boolean): SuggestionResult[];
-    suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
-    genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
-    mapWord(word: string): string;
-    readonly size: number;
-    readonly options: SpellingDictionaryOptions;
-    readonly isDictionaryCaseSensitive: boolean;
-    getErrors?(): Error[];
-}
+import * as cspellDictModule from 'cspell-dictionary';
+import { SpellingDictionaryLibOld } from './SpellingDictionaryLibOld';
+export { CompoundWordsMethod } from 'cspell-trie-lib';
+declare const SpellingDictionaryModule: {
+    readonly createCollection: typeof cspellDictModule.createCollection;
+    readonly createForbiddenWordsDictionary: typeof cspellDictModule.createForbiddenWordsDictionary;
+    readonly createSpellingDictionary: typeof cspellDictModule.createSpellingDictionary;
+    readonly createIgnoreWordsDictionary: typeof cspellDictModule.createIgnoreWordsDictionary;
+};
+declare type SpellDictInterface = typeof SpellingDictionaryModule | typeof SpellingDictionaryLibOld;
+export type { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from 'cspell-dictionary';
+export declare function getSpellDictInterface(): SpellDictInterface;
+export declare const createSpellingDictionary: typeof import("./SpellingDictionaryLibOld/createSpellingDictionary").createSpellingDictionary | typeof cspellDictModule.createSpellingDictionary;
+export declare const createCollection: typeof import("./SpellingDictionaryLibOld/SpellingDictionaryCollection").createCollection | typeof cspellDictModule.createCollection;
 //# sourceMappingURL=SpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionary.js

@@ -1,6 +1,47 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompoundWordsMethod = void 0;
+exports.createCollection = exports.createSpellingDictionary = exports.getSpellDictInterface = exports.CompoundWordsMethod = void 0;
+const cspellDictModule = __importStar(require("cspell-dictionary"));
+const FeatureFlags_1 = require("../FeatureFlags");
+const SpellingDictionaryLibOld_1 = require("./SpellingDictionaryLibOld");
 var cspell_trie_lib_1 = require("cspell-trie-lib");
 Object.defineProperty(exports, "CompoundWordsMethod", { enumerable: true, get: function () { return cspell_trie_lib_1.CompoundWordsMethod; } });
+const SpellingDictionaryModule = {
+    createCollection: cspellDictModule.createCollection,
+    createForbiddenWordsDictionary: cspellDictModule.createForbiddenWordsDictionary,
+    createSpellingDictionary: cspellDictModule.createSpellingDictionary,
+    createIgnoreWordsDictionary: cspellDictModule.createIgnoreWordsDictionary,
+};
+const flagUseCSpellDictionary = 'use-cspell-dictionary';
+(0, FeatureFlags_1.getSystemFeatureFlags)().register(flagUseCSpellDictionary, 'Use the CSpell Dictionary module.');
+function getSpellDictInterface() {
+    const useModule = (0, FeatureFlags_1.getSystemFeatureFlags)().getFlagBool(flagUseCSpellDictionary) ?? true;
+    return useModule ? SpellingDictionaryModule : SpellingDictionaryLibOld_1.SpellingDictionaryLibOld;
+}
+exports.getSpellDictInterface = getSpellDictInterface;
+exports.createSpellingDictionary = getSpellDictInterface().createSpellingDictionary;
+exports.createCollection = getSpellDictInterface().createCollection;
 //# sourceMappingURL=SpellingDictionary.js.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionary.d.ts

@@ -0,0 +1,4 @@
+export { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestOptions, } from 'cspell-dictionary';
+export { CompoundWordsMethod } from 'cspell-trie-lib';
+export type { SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
+//# sourceMappingURL=SpellingDictionary.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionary.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompoundWordsMethod = void 0;
+var cspell_trie_lib_1 = require("cspell-trie-lib");
+Object.defineProperty(exports, "CompoundWordsMethod", { enumerable: true, get: function () { return cspell_trie_lib_1.CompoundWordsMethod; } });
+//# sourceMappingURL=SpellingDictionary.js.map

package/dist/SpellingDictionary/{SpellingDictionaryCollection.d.ts → SpellingDictionaryLibOld/SpellingDictionaryCollection.d.ts}

@@ -1,6 +1,6 @@
 import { CompoundWordsMethod, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions } from './SpellingDictionary';
 declare function identityString(w: string): string;
-export declare class SpellingDictionaryCollection implements SpellingDictionary {
+declare class SpellingDictionaryCollection implements SpellingDictionary {
     readonly dictionaries: SpellingDictionary[];
     readonly name: string;
     readonly options: SpellingDictionaryOptions;
@@ -23,6 +23,7 @@ export declare class SpellingDictionaryCollection implements SpellingDictionary
     private _isForbiddenInDict;
     private _isNoSuggestWord;
 }
+export declare const SpellingDictionaryCollectionLegacy: typeof SpellingDictionaryCollection;
 export declare function createCollection(dictionaries: SpellingDictionary[], name: string): SpellingDictionaryCollection;
 declare function isWordInAnyDictionary(dicts: SpellingDictionary[], word: string, options: SearchOptions): SpellingDictionary | undefined;
 declare function isWordForbiddenInAnyDictionary(dicts: SpellingDictionary[], word: string): SpellingDictionary | undefined;

package/dist/SpellingDictionary/{SpellingDictionaryCollection.js → SpellingDictionaryLibOld/SpellingDictionaryCollection.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.createCollection = exports.SpellingDictionaryCollection = void 0;
+exports.__testing__ = exports.createCollection = exports.SpellingDictionaryCollectionLegacy = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const gensequence_1 = require("gensequence");
-const Settings_1 = require("../Settings");
-const Memorizer_1 = require("../util/Memorizer");
-const util_1 = require("../util/util");
+const Settings_1 = require("../../Settings");
+const Memorizer_1 = require("../../util/Memorizer");
+const util_1 = require("../../util/util");
 const SpellingDictionary_1 = require("./SpellingDictionary");
 const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
 const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
@@ -85,7 +85,7 @@ class SpellingDictionaryCollection {
         return this.dictionaries.reduce((errors, dict) => errors.concat(dict.getErrors?.() || []), []);
     }
 }
-exports.SpellingDictionaryCollection = SpellingDictionaryCollection;
+exports.SpellingDictionaryCollectionLegacy = SpellingDictionaryCollection;
 function createCollection(dictionaries, name) {
     return new SpellingDictionaryCollection(dictionaries, name);
 }

package/dist/SpellingDictionary/{SpellingDictionaryFromTrie.js → SpellingDictionaryLibOld/SpellingDictionaryFromTrie.js}

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSpellingDictionaryTrie = exports.SpellingDictionaryFromTrie = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
-const Settings_1 = require("../Settings");
-const Memorizer_1 = require("../util/Memorizer");
-const repMap_1 = require("../util/repMap");
-const util_1 = require("../util/util");
+const Settings_1 = require("../../Settings");
+const Memorizer_1 = require("../../util/Memorizer");
+const repMap_1 = require("../../util/repMap");
+const util_1 = require("../../util/util");
 const charset_1 = require("./charset");
 const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
 class SpellingDictionaryFromTrie {

package/dist/SpellingDictionary/{SpellingDictionaryMethods.js → SpellingDictionaryLibOld/SpellingDictionaryMethods.js}

@@ -4,7 +4,7 @@ exports.__testMethods__ = exports.createWeightMapFromDictionaryInformation = exp
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const trie_util_1 = require("cspell-trie-lib/dist/lib/trie-util");
 const gensequence_1 = require("gensequence");
-const text_1 = require("../util/text");
+const text_1 = require("../../util/text");
 var cspell_trie_lib_2 = require("cspell-trie-lib");
 Object.defineProperty(exports, "impersonateCollector", { enumerable: true, get: function () { return cspell_trie_lib_2.impersonateCollector; } });
 Object.defineProperty(exports, "suggestionCollector", { enumerable: true, get: function () { return cspell_trie_lib_2.suggestionCollector; } });

package/dist/SpellingDictionary/{createSpellingDictionary.d.ts → SpellingDictionaryLibOld/createSpellingDictionary.d.ts}

@@ -1,7 +1,8 @@
-import { IterableLike } from '../util/IterableLike';
+import { IterableLike } from '../../util/IterableLike';
 import { SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary';
-import { SpellingDictionaryLoadError } from './SpellingDictionaryError';
+import { SpellingDictionaryLoadError } from '../SpellingDictionaryError';
 export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options: SpellingDictionaryOptions | undefined): SpellingDictionary;
 export declare function createForbiddenWordsDictionary(wordList: readonly string[], name: string, source: string, options: SpellingDictionaryOptions | undefined): SpellingDictionary;
 export declare function createFailedToLoadDictionary(error: SpellingDictionaryLoadError): SpellingDictionary;
+export declare function createIgnoreWordsDictionary(wordList: readonly string[], name: string, source: string): SpellingDictionary;
 //# sourceMappingURL=createSpellingDictionary.d.ts.map

package/dist/SpellingDictionary/{createSpellingDictionary.js → SpellingDictionaryLibOld/createSpellingDictionary.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFailedToLoadDictionary = exports.createForbiddenWordsDictionary = exports.createSpellingDictionary = void 0;
+exports.createIgnoreWordsDictionary = exports.createFailedToLoadDictionary = exports.createForbiddenWordsDictionary = exports.createSpellingDictionary = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const fast_equals_1 = require("fast-equals");
 const gensequence_1 = require("gensequence");
-const simpleCache_1 = require("../util/simpleCache");
+const simpleCache_1 = require("../../util/simpleCache");
 const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
 const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
 const defaultOptions = Object.freeze({
@@ -44,7 +44,7 @@ function _createSpellingDictionary(params) {
     return new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, opts, source);
 }
 function createForbiddenWordsDictionary(wordList, name, source, options) {
-    // console.log(`createSpellingDictionary ${name} ${source}`);
+    // console.log(`createForbiddenWordsDictionary ${name} ${source}`);
     const words = (0, cspell_trie_lib_1.parseDictionaryLines)(wordList.concat(wordList.map((a) => a.toLowerCase())), {
         stripCaseAndAccents: !options?.noSuggest,
     });
@@ -77,4 +77,14 @@ function createFailedToLoadDictionary(error) {
     };
 }
 exports.createFailedToLoadDictionary = createFailedToLoadDictionary;
+function createIgnoreWordsDictionary(wordList, name, source) {
+    // console.log('createIgnoreWordsDictionary %o', wordList);
+    return createSpellingDictionary(wordList, name, source, {
+        caseSensitive: true,
+        noSuggest: true,
+        weightMap: undefined,
+        supportNonStrictSearches: true,
+    });
+}
+exports.createIgnoreWordsDictionary = createIgnoreWordsDictionary;
 //# sourceMappingURL=createSpellingDictionary.js.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/index.d.ts

@@ -0,0 +1,11 @@
+export * from './SpellingDictionary';
+import { createCollection } from './SpellingDictionaryCollection';
+import { createFailedToLoadDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createSpellingDictionary } from './createSpellingDictionary';
+export declare const SpellingDictionaryLibOld: {
+    readonly createCollection: typeof createCollection;
+    readonly createFailedToLoadDictionary: typeof createFailedToLoadDictionary;
+    readonly createForbiddenWordsDictionary: typeof createForbiddenWordsDictionary;
+    readonly createIgnoreWordsDictionary: typeof createIgnoreWordsDictionary;
+    readonly createSpellingDictionary: typeof createSpellingDictionary;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryLibOld/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpellingDictionaryLibOld = void 0;
+__exportStar(require("./SpellingDictionary"), exports);
+const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
+const createSpellingDictionary_1 = require("./createSpellingDictionary");
+exports.SpellingDictionaryLibOld = {
+    createCollection: SpellingDictionaryCollection_1.createCollection,
+    createFailedToLoadDictionary: createSpellingDictionary_1.createFailedToLoadDictionary,
+    createForbiddenWordsDictionary: createSpellingDictionary_1.createForbiddenWordsDictionary,
+    createIgnoreWordsDictionary: createSpellingDictionary_1.createIgnoreWordsDictionary,
+    createSpellingDictionary: createSpellingDictionary_1.createSpellingDictionary,
+};
+//# sourceMappingURL=index.js.map

package/dist/SpellingDictionary/index.d.ts

@@ -1,6 +1,4 @@
 export * from './SpellingDictionary';
-export * from './SpellingDictionaryCollection';
 export * from './Dictionaries';
-export * from './createSpellingDictionary';
 export * from './SpellingDictionaryError';
 //# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/index.js

@@ -15,8 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./SpellingDictionary"), exports);
-__exportStar(require("./SpellingDictionaryCollection"), exports);
 __exportStar(require("./Dictionaries"), exports);
-__exportStar(require("./createSpellingDictionary"), exports);
 __exportStar(require("./SpellingDictionaryError"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -6,14 +6,16 @@ import * as Text from './util/text';
 export * from '@cspell/cspell-types';
 export { asyncIterableToArray, readFile, readFileSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from 'cspell-io';
 export { ExcludeFilesGlobMap, ExclusionFunction } from './exclusionHelper';
-export { getLanguagesForExt, getLanguagesForBasename as getLanguageIdsForBaseFilename } from './LanguageIds';
+export { FeatureFlag, FeatureFlags, getSystemFeatureFlags, UnknownFeatureFlagError } from './FeatureFlags';
+export { getLanguagesForBasename as getLanguageIdsForBaseFilename, getLanguagesForExt } from './LanguageIds';
 export { createTextDocument, updateTextDocument } from './Models/TextDocument';
 export type { CreateTextDocumentParams, TextDocument, TextDocumentLine } from './Models/TextDocument';
 export * from './Settings';
 export { defaultFileName as defaultSettingsFilename } from './Settings';
 export { combineTextAndLanguageSettings, combineTextAndLanguageSettings as constructSettingsForText, } from './Settings/TextDocumentSettings';
 export { determineFinalDocumentSettings, DetermineFinalDocumentSettingsResult, Document, fileToDocument, fileToTextDocument, isBinaryFile, spellCheckDocument, spellCheckFile, SpellCheckFileOptions, SpellCheckFileResult, } from './spellCheckFile';
-export { CompoundWordsMethod, createSpellingDictionary, isSpellingDictionaryLoadError, refreshDictionaryCache, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryLoadError, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
+export { CompoundWordsMethod, createSpellingDictionary, isSpellingDictionaryLoadError, refreshDictionaryCache, SpellingDictionary, SpellingDictionaryLoadError, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
+export { SpellingDictionaryCollectionLegacy as SpellingDictionaryCollection } from './SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionaryCollection';
 export { SuggestionError, suggestionsForWord, suggestionsForWords } from './suggestions';
 export type { SuggestedWord, SuggestionOptions, SuggestionsForWordResult } from './suggestions';
 export { DocumentValidator, DocumentValidatorOptions } from './textValidation';

package/dist/index.js

@@ -26,7 +26,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDictionary = exports.clearCachedFiles = exports.ExclusionHelper = exports.Link = exports.Text = exports.validateText = exports.IncludeExcludeFlag = exports.checkTextDocument = exports.checkText = exports.resolveFile = exports.setLogger = exports.getLogger = exports.traceWordsAsync = exports.traceWords = exports.DocumentValidator = exports.suggestionsForWords = exports.suggestionsForWord = exports.SuggestionError = exports.SpellingDictionaryLoadError = exports.SpellingDictionaryCollection = exports.refreshDictionaryCache = exports.isSpellingDictionaryLoadError = exports.createSpellingDictionary = exports.CompoundWordsMethod = exports.spellCheckFile = exports.spellCheckDocument = exports.isBinaryFile = exports.fileToTextDocument = exports.fileToDocument = exports.determineFinalDocumentSettings = exports.constructSettingsForText = exports.combineTextAndLanguageSettings = exports.defaultSettingsFilename = exports.updateTextDocument = exports.createTextDocument = exports.getLanguageIdsForBaseFilename = exports.getLanguagesForExt = exports.writeToFileIterableP = exports.writeToFileIterable = exports.writeToFile = exports.readFileSync = exports.readFile = exports.asyncIterableToArray = void 0;
+exports.getDictionary = exports.clearCachedFiles = exports.ExclusionHelper = exports.Link = exports.Text = exports.validateText = exports.IncludeExcludeFlag = exports.checkTextDocument = exports.checkText = exports.resolveFile = exports.setLogger = exports.getLogger = exports.traceWordsAsync = exports.traceWords = exports.DocumentValidator = exports.suggestionsForWords = exports.suggestionsForWord = exports.SuggestionError = exports.SpellingDictionaryCollection = exports.SpellingDictionaryLoadError = exports.refreshDictionaryCache = exports.isSpellingDictionaryLoadError = exports.createSpellingDictionary = exports.CompoundWordsMethod = exports.spellCheckFile = exports.spellCheckDocument = exports.isBinaryFile = exports.fileToTextDocument = exports.fileToDocument = exports.determineFinalDocumentSettings = exports.constructSettingsForText = exports.combineTextAndLanguageSettings = exports.defaultSettingsFilename = exports.updateTextDocument = exports.createTextDocument = exports.getLanguagesForExt = exports.getLanguageIdsForBaseFilename = exports.UnknownFeatureFlagError = exports.getSystemFeatureFlags = exports.FeatureFlags = exports.writeToFileIterableP = exports.writeToFileIterable = exports.writeToFile = exports.readFileSync = exports.readFile = exports.asyncIterableToArray = void 0;
 const ExclusionHelper = __importStar(require("./exclusionHelper"));
 exports.ExclusionHelper = ExclusionHelper;
 const Settings_1 = require("./Settings");
@@ -44,9 +44,13 @@ Object.defineProperty(exports, "readFileSync", { enumerable: true, get: function
 Object.defineProperty(exports, "writeToFile", { enumerable: true, get: function () { return cspell_io_1.writeToFile; } });
 Object.defineProperty(exports, "writeToFileIterable", { enumerable: true, get: function () { return cspell_io_1.writeToFileIterable; } });
 Object.defineProperty(exports, "writeToFileIterableP", { enumerable: true, get: function () { return cspell_io_1.writeToFileIterableP; } });
+var FeatureFlags_1 = require("./FeatureFlags");
+Object.defineProperty(exports, "FeatureFlags", { enumerable: true, get: function () { return FeatureFlags_1.FeatureFlags; } });
+Object.defineProperty(exports, "getSystemFeatureFlags", { enumerable: true, get: function () { return FeatureFlags_1.getSystemFeatureFlags; } });
+Object.defineProperty(exports, "UnknownFeatureFlagError", { enumerable: true, get: function () { return FeatureFlags_1.UnknownFeatureFlagError; } });
 var LanguageIds_1 = require("./LanguageIds");
-Object.defineProperty(exports, "getLanguagesForExt", { enumerable: true, get: function () { return LanguageIds_1.getLanguagesForExt; } });
 Object.defineProperty(exports, "getLanguageIdsForBaseFilename", { enumerable: true, get: function () { return LanguageIds_1.getLanguagesForBasename; } });
+Object.defineProperty(exports, "getLanguagesForExt", { enumerable: true, get: function () { return LanguageIds_1.getLanguagesForExt; } });
 var TextDocument_1 = require("./Models/TextDocument");
 Object.defineProperty(exports, "createTextDocument", { enumerable: true, get: function () { return TextDocument_1.createTextDocument; } });
 Object.defineProperty(exports, "updateTextDocument", { enumerable: true, get: function () { return TextDocument_1.updateTextDocument; } });
@@ -68,8 +72,10 @@ Object.defineProperty(exports, "CompoundWordsMethod", { enumerable: true, get: f
 Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return SpellingDictionary_2.createSpellingDictionary; } });
 Object.defineProperty(exports, "isSpellingDictionaryLoadError", { enumerable: true, get: function () { return SpellingDictionary_2.isSpellingDictionaryLoadError; } });
 Object.defineProperty(exports, "refreshDictionaryCache", { enumerable: true, get: function () { return SpellingDictionary_2.refreshDictionaryCache; } });
-Object.defineProperty(exports, "SpellingDictionaryCollection", { enumerable: true, get: function () { return SpellingDictionary_2.SpellingDictionaryCollection; } });
+// SpellingDictionaryCollection,
 Object.defineProperty(exports, "SpellingDictionaryLoadError", { enumerable: true, get: function () { return SpellingDictionary_2.SpellingDictionaryLoadError; } });
+var SpellingDictionaryCollection_1 = require("./SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionaryCollection");
+Object.defineProperty(exports, "SpellingDictionaryCollection", { enumerable: true, get: function () { return SpellingDictionaryCollection_1.SpellingDictionaryCollectionLegacy; } });
 var suggestions_1 = require("./suggestions");
 Object.defineProperty(exports, "SuggestionError", { enumerable: true, get: function () { return suggestions_1.SuggestionError; } });
 Object.defineProperty(exports, "suggestionsForWord", { enumerable: true, get: function () { return suggestions_1.suggestionsForWord; } });

package/dist/textValidation/ValidationTypes.d.ts

@@ -28,7 +28,7 @@ export interface ValidationResult extends TextOffsetRW, Pick<Issue, 'message' |
     isFound?: boolean | undefined;
 }
 export declare type ValidationResultRO = Readonly<ValidationResult>;
-export declare type LineValidator = (line: LineSegment) => Iterable<ValidationResult>;
+export declare type LineValidatorFn = (line: LineSegment) => Iterable<ValidationResult>;
 export interface LineSegment {
     line: TextOffsetRO;
     segment: TextOffsetRO;
@@ -37,5 +37,5 @@ export interface MappedTextValidationResult extends MappedText {
     isFlagged?: boolean | undefined;
     isFound?: boolean | undefined;
 }
-export declare type TextValidator = (text: MappedText) => Iterable<MappedTextValidationResult>;
+export declare type TextValidatorFn = (text: MappedText) => Iterable<MappedTextValidationResult>;
 //# sourceMappingURL=ValidationTypes.d.ts.map

package/dist/textValidation/docValidator.d.ts

@@ -3,8 +3,8 @@ import { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Mode
 import { TextDocument } from '../Models/TextDocument';
 import { SpellingDictionaryCollection } from '../SpellingDictionary';
 import { MatchRange } from '../util/TextRange';
+import { TextValidator } from './lineValidatorFactory';
 import { SimpleRange } from './parsedText';
-import type { TextValidator } from './ValidationTypes';
 import { ValidationOptions } from './ValidationTypes';
 import { ValidateTextOptions, ValidationIssue } from './validator';
 export interface DocumentValidatorOptions extends ValidateTextOptions {

package/dist/textValidation/docValidator.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentValidator = void 0;
-const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const sync_1 = require("@cspell/cspell-pipe/sync");
 const cspell_types_1 = require("@cspell/cspell-types");
 const assert_1 = __importDefault(require("assert"));
 const cspell_glob_1 = require("cspell-glob");
@@ -190,7 +190,7 @@ class DocumentValidator {
             }
             return { text, offset, line, length, isFlagged, isFound };
         }
-        const issues = [...(0, cspell_pipe_1.pipeSync)(segmenter(parsedText), (0, cspell_pipe_1.opConcatMap)(textValidator), (0, cspell_pipe_1.opMap)(mapToIssue))];
+        const issues = [...(0, sync_1.pipeSync)(segmenter(parsedText), (0, sync_1.opConcatMap)(textValidator.validate), (0, sync_1.opMap)(mapToIssue))];
         if (!this.options.generateSuggestions) {
             return issues;
         }
@@ -223,6 +223,7 @@ class DocumentValidator {
         (0, assert_1.default)(this._preparations, ERROR_NOT_PREPARED);
         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);
         return allIssues;
     }
@@ -252,7 +253,7 @@ class DocumentValidator {
         this._updatePrep();
     }
     defaultParser() {
-        return (0, cspell_pipe_1.pipeSync)(this.document.getLines(), (0, cspell_pipe_1.opMap)((line) => {
+        return (0, sync_1.pipeSync)(this.document.getLines(), (0, sync_1.opMap)((line) => {
             const { text, offset } = line;
             const range = [offset, offset + text.length];
             return { text, range };

package/dist/textValidation/isWordValid.d.ts

@@ -1,11 +1,7 @@
-import { SpellingDictionary } from '../SpellingDictionary/SpellingDictionary';
+import { CachingDictionary } from 'cspell-dictionary';
 import { TextOffsetRO } from './ValidationTypes';
-export interface IsWordValidOptions {
-    ignoreCase: boolean;
-    useCompounds: boolean | undefined;
-}
-export declare function hasWordCheck(dict: SpellingDictionary, word: string, options: IsWordValidOptions): boolean;
-export declare function isWordValidWithEscapeRetry(dict: SpellingDictionary, wo: TextOffsetRO, line: TextOffsetRO, options: IsWordValidOptions): boolean;
+export declare function hasWordCheck(dict: CachingDictionary, word: string): boolean;
+export declare function isWordValidWithEscapeRetry(dict: CachingDictionary, wo: TextOffsetRO, line: TextOffsetRO): boolean;
 export declare const __testing__: {
     hasWordCheck: typeof hasWordCheck;
 };

package/dist/textValidation/isWordValid.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.isWordValidWithEscapeRetry = exports.hasWordCheck = void 0;
-function hasWordCheck(dict, word, options) {
+function hasWordCheck(dict, word) {
     word = word.replace(/\\/g, '');
-    return dict.has(word, options);
+    return dict.has(word);
 }
 exports.hasWordCheck = hasWordCheck;
-function isWordValidWithEscapeRetry(dict, wo, line, options) {
-    const firstTry = hasWordCheck(dict, wo.text, options);
+function isWordValidWithEscapeRetry(dict, wo, line) {
+    const firstTry = hasWordCheck(dict, wo.text);
     return (firstTry ||
         // Drop the first letter if it is preceded by a '\'.
-        (line.text[wo.offset - line.offset - 1] === '\\' && hasWordCheck(dict, wo.text.slice(1), options)));
+        (line.text[wo.offset - line.offset - 1] === '\\' && hasWordCheck(dict, wo.text.slice(1))));
 }
 exports.isWordValidWithEscapeRetry = isWordValidWithEscapeRetry;
 exports.__testing__ = {

package/dist/textValidation/lineValidatorFactory.d.ts

@@ -1,5 +1,14 @@
-import { SpellingDictionary } from '../SpellingDictionary/SpellingDictionary';
-import type { LineValidator, TextValidator, ValidationOptions } from './ValidationTypes';
-export declare function lineValidatorFactory(dict: SpellingDictionary, options: ValidationOptions): LineValidator;
+import { CachingDictionary, SpellingDictionary } from 'cspell-dictionary';
+import type { LineValidatorFn, TextValidatorFn, ValidationOptions } from './ValidationTypes';
+interface LineValidator {
+    fn: LineValidatorFn;
+    dict: CachingDictionary;
+}
+export declare function lineValidatorFactory(sDict: SpellingDictionary, options: ValidationOptions): LineValidator;
+export interface TextValidator {
+    validate: TextValidatorFn;
+    lineValidator: LineValidator;
+}
 export declare function textValidatorFactory(dict: SpellingDictionary, options: ValidationOptions): TextValidator;
+export {};
 //# sourceMappingURL=lineValidatorFactory.d.ts.map

package/dist/textValidation/lineValidatorFactory.js

@@ -24,22 +24,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.textValidatorFactory = exports.lineValidatorFactory = void 0;
-const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const sync_1 = require("@cspell/cspell-pipe/sync");
+const cspell_dictionary_1 = require("cspell-dictionary");
 const gensequence_1 = require("gensequence");
 const RxPat = __importStar(require("../Settings/RegExpPatterns"));
 const Text = __importStar(require("../util/text"));
 const util_1 = require("../util/util");
 const wordSplitter_1 = require("../util/wordSplitter");
-const textValidator_1 = require("./textValidator");
 const isWordValid_1 = require("./isWordValid");
 const parsedText_1 = require("./parsedText");
-function lineValidatorFactory(dict, options) {
+const textValidator_1 = require("./textValidator");
+function lineValidatorFactory(sDict, options) {
     const { minWordLength = textValidator_1.defaultMinWordLength, flagWords = [], allowCompoundWords = false, ignoreCase = true, } = options;
     const hasWordOptions = {
         ignoreCase,
         useCompounds: allowCompoundWords || undefined, // let the dictionaries decide on useCompounds if allow is false
     };
-    const dictCol = dict;
+    const dictCol = (0, cspell_dictionary_1.createCachingDictionary)(sDict, hasWordOptions);
     const setOfFlagWords = new Set(flagWords);
     const setOfKnownSuccessfulWords = new Set();
     const rememberFilter = (fn) => (v) => {
@@ -57,7 +58,7 @@ function lineValidatorFactory(dict, options) {
         return setOfFlagWords.has(text) || setOfFlagWords.has(text.toLowerCase()) || dictCol.isForbidden(text);
     }
     function isWordIgnored(word) {
-        return dict.isNoSuggestWord(word, options);
+        return dictCol.isNoSuggestWord(word);
     }
     function isWordFlagged(word) {
         const isIgnored = isWordIgnored(word.text);
@@ -68,31 +69,28 @@ function lineValidatorFactory(dict, options) {
         word.isFlagged = isWordFlagged(word);
         return word;
     }
-    function checkWord(word, options) {
+    function checkWord(word) {
         const isIgnored = isWordIgnored(word.text);
         const { isFlagged = !isIgnored && testForFlaggedWord(word) } = word;
-        const isFound = isFlagged
-            ? undefined
-            : isIgnored || (0, isWordValid_1.isWordValidWithEscapeRetry)(dictCol, word, word.line, options);
+        const isFound = isFlagged ? undefined : isIgnored || (0, isWordValid_1.isWordValidWithEscapeRetry)(dictCol, word, word.line);
         return (0, util_1.clean)({ ...word, isFlagged, isFound });
     }
     const fn = (lineSegment) => {
         function splitterIsValid(word) {
             return (setOfKnownSuccessfulWords.has(word.text) ||
-                (!testForFlaggedWord(word) &&
-                    (0, isWordValid_1.isWordValidWithEscapeRetry)(dictCol, word, lineSegment.line, hasWordOptions)));
+                (!testForFlaggedWord(word) && (0, isWordValid_1.isWordValidWithEscapeRetry)(dictCol, word, lineSegment.line)));
         }
         function checkFullWord(vr) {
             if (vr.isFlagged) {
                 return [vr];
             }
-            const codeWordResults = (0, cspell_pipe_1.toArray)((0, cspell_pipe_1.pipeSync)(Text.extractWordsFromCodeTextOffset(vr), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opMap)((t) => ({ ...t, line: vr.line })), (0, cspell_pipe_1.opMap)(checkFlagWords), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, cspell_pipe_1.opMap)((wo) => (wo.isFlagged ? wo : checkWord(wo, hasWordOptions))), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.isFlagged || !wo.isFound)), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => !RxPat.regExRepeatedChar.test(wo.text))), 
+            const codeWordResults = (0, sync_1.toArray)((0, sync_1.pipe)(Text.extractWordsFromCodeTextOffset(vr), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opMap)((t) => ({ ...t, line: vr.line })), (0, sync_1.opMap)(checkFlagWords), (0, sync_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, sync_1.opMap)((wo) => (wo.isFlagged ? wo : checkWord(wo))), (0, sync_1.opFilter)(rememberFilter((wo) => wo.isFlagged || !wo.isFound)), (0, sync_1.opFilter)(rememberFilter((wo) => !RxPat.regExRepeatedChar.test(wo.text))), 
             // get back the original text.
-            (0, cspell_pipe_1.opMap)((wo) => ({
+            (0, sync_1.opMap)((wo) => ({
                 ...wo,
                 text: Text.extractText(lineSegment.segment, wo.offset, wo.offset + wo.text.length),
             }))));
-            if (!codeWordResults.length || isWordIgnored(vr.text) || checkWord(vr, hasWordOptions).isFound) {
+            if (!codeWordResults.length || isWordIgnored(vr.text) || checkWord(vr).isFound) {
                 rememberFilter((_) => false)(vr);
                 return [];
             }
@@ -107,7 +105,7 @@ function lineValidatorFactory(dict, options) {
                 };
                 return [vr];
             }
-            const mismatches = (0, cspell_pipe_1.toArray)((0, cspell_pipe_1.pipeSync)(Text.extractWordsFromTextOffset(possibleWord), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opMap)((wo) => ({ ...wo, line: lineSegment.line })), (0, cspell_pipe_1.opMap)(checkFlagWords), (0, cspell_pipe_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, cspell_pipe_1.opConcatMap)(checkFullWord)));
+            const mismatches = (0, sync_1.toArray)((0, sync_1.pipe)(Text.extractWordsFromTextOffset(possibleWord), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opMap)((wo) => ({ ...wo, line: lineSegment.line })), (0, sync_1.opMap)(checkFlagWords), (0, sync_1.opFilter)(rememberFilter((wo) => wo.text.length >= minWordLength || !!wo.isFlagged)), (0, sync_1.opConcatMap)(checkFullWord)));
             if (mismatches.length) {
                 // Try the more expensive word splitter
                 const splitResult = (0, wordSplitter_1.split)(lineSegment.segment, possibleWord.offset, splitterIsValid);
@@ -118,15 +116,16 @@ function lineValidatorFactory(dict, options) {
             }
             return mismatches;
         }
-        const checkedPossibleWords = (0, gensequence_1.genSequence)((0, cspell_pipe_1.pipeSync)(Text.extractPossibleWordsFromTextOffset(lineSegment.segment), (0, cspell_pipe_1.opFilter)(filterAlreadyChecked), (0, cspell_pipe_1.opConcatMap)(checkPossibleWords)));
+        const checkedPossibleWords = (0, gensequence_1.genSequence)((0, sync_1.pipe)(Text.extractPossibleWordsFromTextOffset(lineSegment.segment), (0, sync_1.opFilter)(filterAlreadyChecked), (0, sync_1.opConcatMap)(checkPossibleWords)));
         return checkedPossibleWords;
     };
-    return fn;
+    return { fn, dict: dictCol };
 }
 exports.lineValidatorFactory = lineValidatorFactory;
 function textValidatorFactory(dict, options) {
     const lineValidator = lineValidatorFactory(dict, options);
-    function validator(pText) {
+    const lineValidatorFn = lineValidator.fn;
+    function validate(pText) {
         const { text, range: srcRange, map } = pText;
         const srcOffset = srcRange[0];
         const segment = { text, offset: 0 };
@@ -137,9 +136,12 @@ function textValidatorFactory(dict, options) {
             const range = [r[0] + srcOffset, r[1] + srcOffset];
             return { text, range, isFlagged, isFound };
         }
-        return [...lineValidator(lineSegment)].map(mapBackToOriginSimple);
+        return [...lineValidatorFn(lineSegment)].map(mapBackToOriginSimple);
     }
-    return validator;
+    return {
+        validate,
+        lineValidator,
+    };
 }
 exports.textValidatorFactory = textValidatorFactory;
 //# sourceMappingURL=lineValidatorFactory.js.map

package/dist/textValidation/textValidator.d.ts

@@ -1,5 +1,5 @@
 import { Sequence } from 'gensequence';
-import { SpellingDictionary } from '../SpellingDictionary/SpellingDictionary';
+import { SpellingDictionary } from '../SpellingDictionary/SpellingDictionaryLibOld/SpellingDictionary';
 import * as TextRange from '../util/TextRange';
 import { IncludeExcludeOptions, LineSegment, ValidationOptions, ValidationResult } from './ValidationTypes';
 export declare const defaultMaxNumberOfProblems = 200;

package/dist/textValidation/textValidator.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports._testMethods = exports.mapLineSegmentAgainstRangesFactory = exports.calcTextInclusionRanges = exports.validateText = exports.minWordSplitLen = exports.defaultMinWordLength = exports.defaultMaxDuplicateProblems = exports.defaultMaxNumberOfProblems = void 0;
-const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const sync_1 = require("@cspell/cspell-pipe/sync");
 const gensequence_1 = require("gensequence");
 const Text = __importStar(require("../util/text"));
 const TextRange = __importStar(require("../util/TextRange"));
@@ -41,15 +41,16 @@ function validateText(text, dict, options) {
     const { maxNumberOfProblems = exports.defaultMaxNumberOfProblems, maxDuplicateProblems = exports.defaultMaxDuplicateProblems } = options;
     const mapOfProblems = new Map();
     const includeRanges = calcTextInclusionRanges(text, options);
-    const validator = (0, lineValidatorFactory_1.lineValidatorFactory)(dict, options);
-    const iter = (0, cspell_pipe_1.pipeSync)(Text.extractLinesOfText(text), (0, cspell_pipe_1.opConcatMap)(mapLineToLineSegments(includeRanges)), (0, cspell_pipe_1.opConcatMap)(validator), (0, cspell_pipe_1.opFilter)((wo) => {
+    const lineValidator = (0, lineValidatorFactory_1.lineValidatorFactory)(dict, options);
+    const validator = lineValidator.fn;
+    const iter = (0, sync_1.pipe)(Text.extractLinesOfText(text), (0, sync_1.opConcatMap)(mapLineToLineSegments(includeRanges)), (0, sync_1.opConcatMap)(validator), (0, sync_1.opFilter)((wo) => {
         const word = wo.text;
         // Keep track of the number of times we have seen the same problem
         const n = (mapOfProblems.get(word) || 0) + 1;
         mapOfProblems.set(word, n);
         // Filter out if there is too many
         return n <= maxDuplicateProblems;
-    }), (0, cspell_pipe_1.opTake)(maxNumberOfProblems));
+    }), (0, sync_1.opTake)(maxNumberOfProblems));
     return (0, gensequence_1.genSequence)(iter);
 }
 exports.validateText = validateText;

package/dist/util/Memorizer.d.ts

@@ -35,18 +35,6 @@ export declare function memorizer<F extends (...args: Primitive[]) => any, Args
  * @returns A function
  */
 export declare function memorizerKeyBy<F extends (...args: any[]) => any, Args extends Parameters<F> = Parameters<F>, R extends ReturnType<F> = ReturnType<F>>(fn: F, keyFn: (...args: Args) => string, size?: number): (...args: Args) => R;
-/**
- * Create a function that memorizes the last call. If the next call is called with the same arguments, the
- * the last value is returned.
- * @param fn - function to memorize
- * @returns a new function.
- */
-export declare function memorizeLastCall<T>(fn: (...p: []) => T): (...p: []) => T;
-export declare function memorizeLastCall<T, K0>(fn: (...p: [K0]) => T): (...p: [K0]) => T;
-export declare function memorizeLastCall<T, K0, K1>(fn: (...p: [K0, K1]) => T): (...p: [K0, K1]) => T;
-export declare function memorizeLastCall<T, K0, K1, K2>(fn: (...p: [K0, K1, K2]) => T): (...p: [K0, K1, K2]) => T;
-export declare function memorizeLastCall<T, K0, K1, K2, K3>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
-export declare function memorizeLastCall<T, K>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
 /**
  * Creates a function that will call `fn` exactly once when invoked and remember the value returned.
  * All subsequent calls will return exactly same value.

package/dist/util/Memorizer.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.memorizerAll = exports.callOnce = exports.memorizeLastCall = exports.memorizerKeyBy = exports.memorizer = void 0;
-const util_1 = require("./util");
+exports.memorizerAll = exports.callOnce = exports.memorizerKeyBy = exports.memorizer = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const defaultSize = 50000;
 /**
@@ -60,19 +59,6 @@ function memorizerKeyBy(fn, keyFn, size = defaultSize) {
     };
 }
 exports.memorizerKeyBy = memorizerKeyBy;
-function memorizeLastCall(fn) {
-    let last;
-    return (...p) => {
-        if (last && (0, util_1.isArrayEqual)(last.args, p)) {
-            return last.value;
-        }
-        const args = p;
-        const value = fn(...args);
-        last = { args, value };
-        return value;
-    };
-}
-exports.memorizeLastCall = memorizeLastCall;
 /**
  * Creates a function that will call `fn` exactly once when invoked and remember the value returned.
  * All subsequent calls will return exactly same value.

package/dist/util/memorizeLastCall.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Create a function that memorizes the last call. If the next call is called with the same arguments, the
+ * the last value is returned.
+ * @param fn - function to memorize
+ * @returns a new function.
+ */
+export declare function memorizeLastCall<T>(fn: (...p: []) => T): (...p: []) => T;
+export declare function memorizeLastCall<T, K0>(fn: (...p: [K0]) => T): (...p: [K0]) => T;
+export declare function memorizeLastCall<T, K0, K1>(fn: (...p: [K0, K1]) => T): (...p: [K0, K1]) => T;
+export declare function memorizeLastCall<T, K0, K1, K2>(fn: (...p: [K0, K1, K2]) => T): (...p: [K0, K1, K2]) => T;
+export declare function memorizeLastCall<T, K0, K1, K2, K3>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
+export declare function memorizeLastCall<T, K>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
+//# sourceMappingURL=memorizeLastCall.d.ts.map

package/dist/util/memorizeLastCall.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memorizeLastCall = void 0;
+const util_1 = require("./util");
+function memorizeLastCall(fn) {
+    let last;
+    return (...p) => {
+        if (last && (0, util_1.isArrayEqual)(last.args, p)) {
+            return last.value;
+        }
+        const args = p;
+        const value = fn(...args);
+        last = { args, value };
+        return value;
+    };
+}
+exports.memorizeLastCall = memorizeLastCall;
+//# sourceMappingURL=memorizeLastCall.js.map

package/dist/util/text.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.removeAccents = exports.calculateTextDocumentOffsets = exports.extractText = exports.textOffset = exports.matchCase = exports.camelToSnake = exports.snakeToCamel = exports.lcFirst = exports.ucFirst = exports.isFirstCharacterLower = exports.isFirstCharacterUpper = exports.isLowerCase = exports.isUpperCase = exports.extractWordsFromCodeTextOffset = exports.extractWordsFromCode = exports.extractPossibleWordsFromTextOffset = exports.cleanTextOffset = exports.cleanText = exports.extractWordsFromTextOffset = exports.extractWordsFromText = exports.extractLinesOfText = exports.matchToTextOffset = exports.matchStringToTextOffset = exports.match = exports.splitCamelCaseWord = exports.splitCamelCaseWordWithOffset = exports.stringToRegExp = void 0;
-const cspell_pipe_1 = require("@cspell/cspell-pipe");
+const sync_1 = require("@cspell/cspell-pipe/sync");
 const gensequence_1 = require("gensequence");
 const search_1 = require("./search");
 const textRegex_1 = require("./textRegex");
@@ -42,7 +42,7 @@ function matchToTextOffset(reg, text) {
     const textOffset = text;
     const fnOffsetMap = offsetMap(textOffset.offset);
     textOffset.text.matchAll(reg);
-    return (0, cspell_pipe_1.pipeSync)(match(reg, textOffset.text), (0, cspell_pipe_1.opMap)((m) => fnOffsetMap({ text: m[0], offset: m.index || 0 })));
+    return (0, sync_1.pipe)(match(reg, textOffset.text), (0, sync_1.opMap)((m) => fnOffsetMap({ text: m[0], offset: m.index || 0 })));
 }
 exports.matchToTextOffset = matchToTextOffset;
 function extractLinesOfText(text) {
@@ -89,7 +89,7 @@ function extractWordsFromCode(text) {
 }
 exports.extractWordsFromCode = extractWordsFromCode;
 function extractWordsFromCodeTextOffset(textOffset) {
-    return (0, cspell_pipe_1.pipeSync)(extractWordsFromTextOffset(textOffset), (0, cspell_pipe_1.opConcatMap)(splitCamelCaseWordWithOffset));
+    return (0, sync_1.pipe)(extractWordsFromTextOffset(textOffset), (0, sync_1.opConcatMap)(splitCamelCaseWordWithOffset));
 }
 exports.extractWordsFromCodeTextOffset = extractWordsFromCodeTextOffset;
 function isUpperCase(word) {
@@ -160,7 +160,7 @@ function offsetMap(offset) {
 function calculateTextDocumentOffsets(uri, doc, wordOffsets) {
     const lines = [
         -1,
-        ...(0, cspell_pipe_1.pipeSync)(match(/\n/g, doc), (0, cspell_pipe_1.opMap)((a) => a.index)),
+        ...(0, sync_1.pipe)(match(/\n/g, doc), (0, sync_1.opMap)((a) => a.index)),
         doc.length,
     ];
     let lastRow = -1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.10.1",
+  "version": "6.11.0",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,17 +48,18 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "^6.10.1",
-    "@cspell/cspell-pipe": "^6.10.1",
-    "@cspell/cspell-types": "^6.10.1",
+    "@cspell/cspell-bundled-dicts": "^6.11.0",
+    "@cspell/cspell-pipe": "^6.11.0",
+    "@cspell/cspell-types": "^6.11.0",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^5.0.1",
     "cosmiconfig": "^7.0.1",
-    "cspell-glob": "^6.10.1",
-    "cspell-grammar": "^6.10.1",
-    "cspell-io": "^6.10.1",
-    "cspell-trie-lib": "^6.10.1",
+    "cspell-dictionary": "^6.11.0",
+    "cspell-glob": "^6.11.0",
+    "cspell-grammar": "^6.11.0",
+    "cspell-io": "^6.11.0",
+    "cspell-trie-lib": "^6.11.0",
     "fast-equals": "^4.0.3",
     "find-up": "^5.0.0",
     "fs-extra": "^10.1.0",
@@ -83,15 +84,15 @@
     "@cspell/dict-python": "^2.0.6",
     "@types/configstore": "^5.0.1",
     "@types/fs-extra": "^9.0.13",
-    "@types/jest": "^29.0.3",
-    "@types/node": "^18.7.18",
+    "@types/jest": "^29.1.0",
+    "@types/node": "^18.7.23",
     "cspell-dict-nl-nl": "^1.1.2",
-    "jest": "^29.0.3",
+    "jest": "^29.1.1",
     "lorem-ipsum": "^2.0.8",
     "rimraf": "^3.0.2",
-    "rollup": "^2.79.0",
+    "rollup": "^2.79.1",
     "rollup-plugin-dts": "^4.2.2",
-    "ts-jest": "^29.0.1"
+    "ts-jest": "^29.0.3"
   },
-  "gitHead": "03625a3f7ca4ef85f3549ccae73d90d2cd3ac0f0"
+  "gitHead": "664676692898c3b6aa150fb2c6656b56f49a54b8"
 }