cspell-lib 6.14.2 → 6.14.3

package/dist/Cache/cspell.cache.d.ts

@@ -7,12 +7,12 @@ export interface CSpellCache {
     signature: Hash;
     files: CachedFile[];
 }
-export declare type Version = '0.1';
+export type Version = '0.1';
 /**
  * Hash used. Starts with hash id. i.e. `sha1-` or `sha512-`.
  */
-export declare type Hash = string;
-export declare type UriRelPath = string;
+export type Hash = string;
+export type UriRelPath = string;
 export declare enum IssueCode {
     UnknownWord = 1,
     ForbiddenWord = 2,
@@ -24,7 +24,7 @@ export interface CachedFile {
     path: UriRelPath;
     issues: Issue[];
 }
-export declare type Issue = IssueEntry | IssueLine;
+export type Issue = IssueEntry | IssueLine;
 export interface IssueEntry {
     line: number;
     character: number;
@@ -32,7 +32,7 @@ export interface IssueEntry {
     text: string;
     len: number;
 }
-export declare type IssueLine = [
+export type IssueLine = [
     line: IssueEntry['line'],
     character: IssueEntry['character'],
     code: IssueEntry['code'],

package/dist/FeatureFlags/FeatureFlags.d.ts

@@ -2,7 +2,7 @@ export interface FeatureFlag {
     name: string;
     description: string;
 }
-declare type FlagTypes = string | boolean;
+type FlagTypes = string | boolean;
 /**
  * Feature Flags are used to turn on/off features.
  * These are primarily used before a feature has been fully released.

package/dist/LanguageIds.d.ts

@@ -12,12 +12,12 @@ export interface LanguageExtensionDefinition {
     /** Filenames that do not have an extension or have a different type than their implied extension */
     filenames?: string[];
 }
-export declare type LanguageDefinition = LanguageExtensionDefinition;
-export declare type LanguageDefinitions = LanguageDefinition[];
-export declare type ExtensionToLanguageIdMapSet = Map<string, Set<string>>;
-export declare type ExtensionToLanguageIdMap = Map<string, string[]>;
+export type LanguageDefinition = LanguageExtensionDefinition;
+export type LanguageDefinitions = LanguageDefinition[];
+export type ExtensionToLanguageIdMapSet = Map<string, Set<string>>;
+export type ExtensionToLanguageIdMap = Map<string, string[]>;
 export declare const languageExtensionDefinitions: LanguageDefinitions;
-export declare type LanguageId = string;
+export type LanguageId = string;
 export declare const binaryLanguages: Set<string>;
 export declare const generatedFiles: Set<string>;
 export declare const languageIds: LanguageId[];

package/dist/Models/CSpellSettingsInternalDef.d.ts

@@ -12,7 +12,7 @@ export interface CSpellSettingsInternalFinalized extends CSpellSettingsInternal
     ignoreRegExpList: RegExp[];
     includeRegExpList: RegExp[];
 }
-declare type DictionaryDefinitionCustomUniqueFields = Omit<DictionaryDefinitionCustom, keyof DictionaryDefinitionPreferred>;
+type DictionaryDefinitionCustomUniqueFields = Omit<DictionaryDefinitionCustom, keyof DictionaryDefinitionPreferred>;
 export interface DictionaryDefinitionInternal extends Readonly<DictionaryDefinitionPreferred>, Readonly<Partial<DictionaryDefinitionCustomUniqueFields>>, Readonly<DictionaryDefinitionAugmented> {
     /**
      * Optional weight map used to improve suggestions.

package/dist/Models/TextDocument.d.ts

@@ -1,5 +1,5 @@
 import * as Uri from './Uri';
-export declare type DocumentUri = Uri.Uri;
+export type DocumentUri = Uri.Uri;
 export interface Position {
     line: number;
     character: number;
@@ -7,7 +7,7 @@ export interface Position {
 /**
  * Range offset tuple.
  */
-export declare type SimpleRange = [start: number, end: number];
+export type SimpleRange = [start: number, end: number];
 export interface TextDocumentLine {
     readonly text: string;
     readonly offset: number;

package/dist/Settings/CSpellSettingsServer.d.ts

@@ -1,9 +1,9 @@
 import type { AdvancedCSpellSettingsWithSourceTrace, Glob, ImportFileRef } from '@cspell/cspell-types';
 import { CSpellSettingsInternal, CSpellSettingsInternalFinalized } from '../Models/CSpellSettingsInternalDef';
 import { OptionalOrUndefined } from '../util/types';
-declare type CSpellSettingsWST = AdvancedCSpellSettingsWithSourceTrace;
-declare type CSpellSettingsWSTO = OptionalOrUndefined<AdvancedCSpellSettingsWithSourceTrace>;
-declare type CSpellSettingsI = CSpellSettingsInternal;
+type CSpellSettingsWST = AdvancedCSpellSettingsWithSourceTrace;
+type CSpellSettingsWSTO = OptionalOrUndefined<AdvancedCSpellSettingsWithSourceTrace>;
+type CSpellSettingsI = CSpellSettingsInternal;
 declare function mergeObjects(left: undefined, right: undefined): undefined;
 declare function mergeObjects<T>(left: T, right: undefined): T;
 declare function mergeObjects<T>(left: T, right: T): T;

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

@@ -5,9 +5,9 @@ import { CSpellSettingsInternal } from '../../../Models/CSpellSettingsInternalDe
 import { OptionalOrUndefined } from '../../../util/types';
 import { LoaderResult } from '../pnpLoader';
 import { normalizeCacheSettings } from './normalizeRawSettings';
-export declare type CSpellSettingsWST = CSpellSettingsWithSourceTrace;
-export declare type CSpellSettingsI = CSpellSettingsInternal;
-declare type PnPSettings = OptionalOrUndefined<PnPSettingsStrict>;
+export type CSpellSettingsWST = CSpellSettingsWithSourceTrace;
+export type CSpellSettingsI = CSpellSettingsInternal;
+type PnPSettings = OptionalOrUndefined<PnPSettingsStrict>;
 export declare const sectionCSpell = "cSpell";
 export declare const defaultFileName = "cspell.json";
 export declare const defaultConfigFilenames: readonly string[];

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

@@ -4,7 +4,7 @@ interface NormalizableFields {
     version?: string | number;
 }
 export declare function normalizeRawConfig(config: CSpellUserSettings | NormalizableFields): void;
-declare type NormalizeDictionaryDefsParams = OptionalOrUndefined<Pick<CSpellUserSettings, 'dictionaryDefinitions' | 'languageSettings'>>;
+type NormalizeDictionaryDefsParams = OptionalOrUndefined<Pick<CSpellUserSettings, 'dictionaryDefinitions' | 'languageSettings'>>;
 export declare function normalizeDictionaryDefs(settings: NormalizeDictionaryDefsParams, pathToSettingsFile: string): import("../../../util/types").RemoveUndefined<{
     dictionaryDefinitions: import("../../../Models/CSpellSettingsInternalDef").DictionaryDefinitionInternalWithSource[] | undefined;
     languageSettings: import("../../../util/types").RemoveUndefined<{
@@ -29,13 +29,13 @@ export declare function normalizeDictionaryDefs(settings: NormalizeDictionaryDef
         parser?: string;
     }>[] | undefined;
 }>;
-declare type NormalizeOverrides = Pick<CSpellUserSettings, 'globRoot' | 'overrides'>;
-declare type NormalizeOverridesResult = Pick<CSpellUserSettings, 'overrides'>;
+type NormalizeOverrides = Pick<CSpellUserSettings, 'globRoot' | 'overrides'>;
+type NormalizeOverridesResult = Pick<CSpellUserSettings, 'overrides'>;
 export declare function normalizeOverrides(settings: NormalizeOverrides, pathToSettingsFile: string): NormalizeOverridesResult;
-declare type NormalizeReporters = Pick<CSpellUserSettings, 'reporters'>;
+type NormalizeReporters = Pick<CSpellUserSettings, 'reporters'>;
 export declare function normalizeReporters(settings: NormalizeReporters, pathToSettingsFile: string): NormalizeReporters;
 export declare function normalizeLanguageSettings(languageSettings: LanguageSetting[] | undefined): LanguageSetting[] | undefined;
-declare type NormalizeGitignoreRoot = Pick<CSpellUserSettings, 'gitignoreRoot'>;
+type NormalizeGitignoreRoot = Pick<CSpellUserSettings, 'gitignoreRoot'>;
 export declare function normalizeGitignoreRoot(settings: NormalizeGitignoreRoot, pathToSettingsFile: string): NormalizeGitignoreRoot;
 interface NormalizeSettingsGlobs {
     globRoot?: CSpellUserSettings['globRoot'];

package/dist/Settings/Controller/pnpLoader.d.ts

@@ -2,7 +2,7 @@
  * Handles loading of `.pnp.js` and `.pnp.js` files.
  */
 import { URI } from 'vscode-uri';
-export declare type LoaderResult = URI | undefined;
+export type LoaderResult = URI | undefined;
 export declare class PnpLoader {
     readonly pnpFiles: string[];
     private cacheKeySuffix;

package/dist/Settings/DictionarySettings.d.ts

@@ -1,7 +1,7 @@
 import type { DictionaryDefinition } from '@cspell/cspell-types';
 import { CSpellSettingsInternal, DictionaryDefinitionInternal, DictionaryDefinitionInternalWithSource } from '../Models/CSpellSettingsInternalDef';
 import { DictionaryReferenceCollection } from './DictionaryReferenceCollection';
-export declare type DefMapArrayItem = [string, DictionaryDefinitionInternal];
+export type DefMapArrayItem = [string, DictionaryDefinitionInternal];
 /**
  * Combines the list of desired dictionaries with the list of dictionary
  * definitions. Order does not matter, but the number of leading `!` does.

package/dist/Settings/InDocSettings.d.ts

@@ -1,6 +1,6 @@
 import type { CSpellUserSettings } from '@cspell/cspell-types';
 import { Sequence } from 'gensequence';
-export declare type CSpellUserSettingsKeys = keyof CSpellUserSettings;
+export type CSpellUserSettingsKeys = keyof CSpellUserSettings;
 export interface DirectiveIssue {
     /**
      * the start and end offsets within the document of the issue.

package/dist/Settings/LanguageSettings.d.ts

@@ -1,5 +1,5 @@
 import type { BaseSetting, CSpellUserSettings, LanguageId, LanguageSetting, LocaleId } from '@cspell/cspell-types';
-export declare type LanguageSettings = LanguageSetting[];
+export type LanguageSettings = LanguageSetting[];
 export declare function getDefaultLanguageSettings(): LanguageSettings;
 export declare function normalizeLanguageId(langId: LanguageId | LanguageId[]): Set<LanguageId>;
 export declare function normalizeLocale(locale: LocaleId | LocaleId[]): Set<LocaleId>;

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

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

package/dist/SpellingDictionary/SpellingDictionary.d.ts

@@ -7,7 +7,7 @@ declare const SpellingDictionaryModule: {
     readonly createIgnoreWordsDictionary: typeof cspellDictModule.createIgnoreWordsDictionary;
     readonly createSpellingDictionaryFromTrieFile: typeof cspellDictModule.createSpellingDictionaryFromTrieFile;
 };
-declare type SpellDictInterface = typeof SpellingDictionaryModule;
+type SpellDictInterface = typeof SpellingDictionaryModule;
 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 cspellDictModule.createSpellingDictionary;

package/dist/SpellingDictionary/SuggestExperimental/entities.d.ts

@@ -1,4 +1,4 @@
-export declare type Feature = [string, number];
+export type Feature = [string, number];
 export interface SuggestionResult {
     word: string;
     score: number;

package/dist/SpellingDictionary/SuggestExperimental/suggest.d.ts

@@ -1,6 +1,6 @@
 import { Trie, WalkerIterator } from 'cspell-trie-lib';
 import { SuggestionResult } from './entities';
-export declare type SuggestionIterator = Generator<SuggestionResult, void, number | undefined>;
+export type SuggestionIterator = Generator<SuggestionResult, void, number | undefined>;
 export declare function suggest(trie: Trie, word: string, minScore?: number): SuggestionIterator;
 export declare function suggestIteration(i: WalkerIterator, word: string, minScore?: number): SuggestionIterator;
 //# sourceMappingURL=suggest.d.ts.map

package/dist/exclusionHelper.d.ts

@@ -1,6 +1,6 @@
 import type { Glob } from '@cspell/cspell-types';
-export declare type ExclusionFunction = (fileUri: string) => boolean;
-export declare type FileExclusionFunction = (file: string) => boolean;
+export type ExclusionFunction = (fileUri: string) => boolean;
+export type FileExclusionFunction = (file: string) => boolean;
 /** The structure of the VS Code search.exclude settings */
 export interface ExcludeFilesGlobMap {
     [glob: string]: boolean;

package/dist/spellCheckFile.d.ts

@@ -33,7 +33,7 @@ export interface SpellCheckFileResult {
     checked: boolean;
     errors: Error[] | undefined;
 }
-export declare type UriString = string;
+export type UriString = string;
 export interface DocumentWithText extends Document {
     text: string;
 }

package/dist/textValidation/ValidationTypes.d.ts

@@ -1,5 +1,5 @@
 import { MappedText, TextOffset as TextOffsetRW, Issue } from '@cspell/cspell-types';
-export declare type TextOffsetRO = Readonly<TextOffsetRW>;
+export type TextOffsetRO = Readonly<TextOffsetRW>;
 export interface ValidationOptions extends IncludeExcludeOptions {
     maxNumberOfProblems?: number;
     maxDuplicateProblems?: number;
@@ -27,8 +27,8 @@ export interface ValidationResult extends TextOffsetRW, Pick<Issue, 'message' |
     isFlagged?: boolean | undefined;
     isFound?: boolean | undefined;
 }
-export declare type ValidationResultRO = Readonly<ValidationResult>;
-export declare type LineValidatorFn = (line: LineSegment) => Iterable<ValidationResult>;
+export type ValidationResultRO = Readonly<ValidationResult>;
+export 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 TextValidatorFn = (text: MappedText) => Iterable<MappedTextValidationResult>;
+export type TextValidatorFn = (text: MappedText) => Iterable<MappedTextValidationResult>;
 //# sourceMappingURL=ValidationTypes.d.ts.map

package/dist/textValidation/parsedText.d.ts

@@ -1,8 +1,8 @@
 import { MappedText } from '@cspell/cspell-types';
 import { ValidationIssue } from './validator';
 import * as TextRange from '../util/TextRange';
-export declare type Offset = number;
-export declare type SimpleRange = readonly [Offset, Offset];
+export type Offset = number;
+export type SimpleRange = readonly [Offset, Offset];
 export declare function mapIssueBackToOriginalPos(mappedText: MappedText, issue: ValidationIssue): ValidationIssue;
 export declare function mapRangeBackToOriginalPos(offRange: SimpleRange, map: number[] | undefined): SimpleRange;
 export declare function mapRangeToLocal(rangeOrig: SimpleRange, map: number[] | undefined): SimpleRange;

package/dist/util/Comparable.d.ts

@@ -1,11 +1,11 @@
-export declare type Comparable = number | string | boolean | undefined | null | Date;
-export declare type ComparableFilter<T> = T extends Comparable ? T : never;
-export declare type ComparablePropertyNames<T> = {
+export type Comparable = number | string | boolean | undefined | null | Date;
+export type ComparableFilter<T> = T extends Comparable ? T : never;
+export type ComparablePropertyNames<T> = {
     [K in keyof T]: T[K] extends Comparable ? K : never;
 }[keyof T];
-export declare type ComparableProperties<T> = Pick<T, ComparablePropertyNames<T>>;
-export declare type CompareArg<T> = ComparablePropertyNames<T> | ((t: T) => Comparable);
-export declare type CompareFn<T> = (a: T, b: T) => number;
+export type ComparableProperties<T> = Pick<T, ComparablePropertyNames<T>>;
+export type CompareArg<T> = ComparablePropertyNames<T> | ((t: T) => Comparable);
+export type CompareFn<T> = (a: T, b: T) => number;
 export declare function compareBy<T>(extract: CompareArg<T>, ...extractors: CompareArg<T>[]): CompareFn<T>;
 export declare function compareBy<T>(extract: CompareArg<T>): CompareFn<T>;
 export declare function compareBy<T>(extract1: CompareArg<T>, extract2: CompareArg<T>): CompareFn<T>;

package/dist/util/Memorizer.d.ts

@@ -1,6 +1,6 @@
 /** Only types that can be easily turned into strings */
-declare type P0 = string | number | boolean | RegExp | undefined;
-declare type Primitive = P0 | P0[];
+type P0 = string | number | boolean | RegExp | undefined;
+type Primitive = P0 | P0[];
 /**
  * Memorize the result of a function call to be returned on later calls with the same parameters.
  *

package/dist/util/PairingHeap.d.ts

@@ -6,7 +6,7 @@ export interface PairHeapNode<T> {
     /** Children */
     c: PairHeapNode<T> | undefined;
 }
-export declare type CompareFn<T> = (a: T, b: T) => number;
+export type CompareFn<T> = (a: T, b: T) => number;
 export declare class PairingHeap<T> implements IterableIterator<T> {
     readonly compare: CompareFn<T>;
     private _heap;

package/dist/util/logger.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-declare type Console = typeof console;
+type Console = typeof console;
 export interface Logger {
     log: Console['log'];
     warn: Console['warn'];

package/dist/util/repMap.d.ts

@@ -1,4 +1,4 @@
 import type { ReplaceMap } from '@cspell/cspell-types';
-export declare type ReplaceMapper = (src: string) => string;
+export type ReplaceMapper = (src: string) => string;
 export declare function createMapper(repMap: ReplaceMap): ReplaceMapper;
 //# sourceMappingURL=repMap.d.ts.map

package/dist/util/timer.d.ts

@@ -13,8 +13,8 @@ export interface Timer {
     lap(): number;
 }
 export declare function createTimer(hrTimeFn?: HRTimeFn): Timer;
-export declare type HRTimeFn = (time?: HRTime) => HRTime;
-export declare type HRTime = [number, number];
+export type HRTimeFn = (time?: HRTime) => HRTime;
+export type HRTime = [number, number];
 export declare function toMilliseconds(t: HRTime): number;
 export declare function polyHrTime(time?: HRTime): HRTime;
 export interface LapRecorder {

package/dist/util/types.d.ts

@@ -1,62 +1,62 @@
 /**
  * Make all optional fields required.
  */
-export declare type RequireOptional<T> = {
+export type RequireOptional<T> = {
     [K in keyof Required<T>]: T[K];
 };
 /**
  * Make all properties in T optional and Possibly undefined
  */
-export declare type PartialWithUndefined<T> = {
+export type PartialWithUndefined<T> = {
     [P in keyof T]?: T[P] | undefined;
 };
 /**
  * Make all fields mandatory
  */
-export declare type Mandatory<T> = {
+export type Mandatory<T> = {
     [P in keyof T]-?: Exclude<T[P], undefined>;
 };
 /**
  * Union the fields
  */
-export declare type UnionFields<T, U> = {
+export type UnionFields<T, U> = {
     [K in keyof T | keyof U]: (K extends keyof T ? T[K] : undefined) | (K extends keyof U ? U[K] : undefined);
 };
 /**
  * The keys of an object where the values cannot be undefined.
  */
-export declare type RequiredKeys<T> = Exclude<{
+export type RequiredKeys<T> = Exclude<{
     [P in keyof T]: T[P] extends Exclude<T[P], undefined> ? P : never;
 }[keyof T], undefined>;
 /**
  * The keys of an object where the values cannot be undefined.
  */
-export declare type OptionalKeys<T> = Exclude<{
+export type OptionalKeys<T> = Exclude<{
     [P in keyof T]: T[P] extends Exclude<T[P], undefined> ? never : P;
 }[keyof T], undefined>;
 /**
  * Extract the fields that cannot be `undefined`
  */
-export declare type OnlyRequired<T> = {
+export type OnlyRequired<T> = {
     [P in RequiredKeys<T>]: T[P];
 };
 /**
  * Extract the fields that can be `undefined`
  */
-export declare type OnlyOptional<T> = {
+export type OnlyOptional<T> = {
     [P in keyof T as P extends OptionalKeys<T> ? P : never]: T[P];
 };
-export declare type MakeOptional<T> = OnlyRequired<T> & Partial<OnlyOptional<T>>;
+export type MakeOptional<T> = OnlyRequired<T> & Partial<OnlyOptional<T>>;
 /**
  * Like Required, but keeps the Optional.
  */
-export declare type RemoveUndefined<T> = {
+export type RemoveUndefined<T> = {
     [P in keyof T]: Exclude<T[P], undefined>;
 };
 /**
  * Allow undefined in optional fields
  */
-export declare type OptionalOrUndefined<T> = {
+export type OptionalOrUndefined<T> = {
     [P in keyof T]: P extends OptionalKeys<T> ? T[P] | undefined : T[P];
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/util/wordSplitter.d.ts

@@ -1,5 +1,5 @@
 import type { TextOffset } from '@cspell/cspell-types';
-export declare type IsValidWordFn = (word: TextOffset) => boolean;
+export type IsValidWordFn = (word: TextOffset) => boolean;
 export interface SplitResult {
     /** Original line passed to the split function */
     line: TextOffset;
@@ -23,7 +23,7 @@ export interface TextOffsetWithValid extends TextOffset {
 export interface SplitOptions extends WordBreakOptions {
 }
 export declare function split(line: TextOffset, offset: number, isValidWord: IsValidWordFn, options?: SplitOptions): SplitResult;
-declare type BreakPairs = readonly number[];
+type BreakPairs = readonly number[];
 interface PossibleWordBreak {
     /** offset from the start of the string */
     offset: number;
@@ -34,7 +34,7 @@ interface PossibleWordBreak {
      */
     breaks: BreakPairs[];
 }
-export declare type SortedBreaks = PossibleWordBreak[];
+export type SortedBreaks = PossibleWordBreak[];
 interface WordBreakOptions {
     optionalWordBreakCharacters?: string;
 }

package/dist/wordListHelper.d.ts

@@ -1,7 +1,7 @@
 export interface WordDictionary {
     [index: string]: boolean;
 }
-export declare type WordSet = Set<string>;
+export type WordSet = Set<string>;
 /**
  * Reads words from a file. It will not throw and error.
  * @param filename the file to read

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-lib",
-  "version": "6.14.2",
+  "version": "6.14.3",
   "description": "A library of useful functions used across various cspell tools.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,19 +48,19 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "dependencies": {
-    "@cspell/cspell-bundled-dicts": "6.14.2",
-    "@cspell/cspell-pipe": "6.14.2",
-    "@cspell/cspell-types": "6.14.2",
-    "@cspell/strong-weak-map": "6.14.2",
+    "@cspell/cspell-bundled-dicts": "6.14.3",
+    "@cspell/cspell-pipe": "6.14.3",
+    "@cspell/cspell-types": "6.14.3",
+    "@cspell/strong-weak-map": "6.14.3",
     "clear-module": "^4.1.2",
     "comment-json": "^4.2.3",
     "configstore": "^5.0.1",
-    "cosmiconfig": "^7.0.1",
-    "cspell-dictionary": "6.14.2",
-    "cspell-glob": "6.14.2",
-    "cspell-grammar": "6.14.2",
-    "cspell-io": "6.14.2",
-    "cspell-trie-lib": "6.14.2",
+    "cosmiconfig": "^7.1.0",
+    "cspell-dictionary": "6.14.3",
+    "cspell-glob": "6.14.3",
+    "cspell-grammar": "6.14.3",
+    "cspell-io": "6.14.3",
+    "cspell-trie-lib": "6.14.3",
     "fast-equals": "^4.0.3",
     "find-up": "^5.0.0",
     "fs-extra": "^10.1.0",
@@ -85,15 +85,15 @@
     "@cspell/dict-python": "^4.0.0",
     "@types/configstore": "^5.0.1",
     "@types/fs-extra": "^9.0.13",
-    "@types/jest": "^29.2.2",
+    "@types/jest": "^29.2.3",
     "@types/node": "^18.11.9",
     "cspell-dict-nl-nl": "^1.1.2",
     "jest": "^29.3.1",
     "lorem-ipsum": "^2.0.8",
     "rimraf": "^3.0.2",
-    "rollup": "^3.2.5",
+    "rollup": "^3.3.0",
     "rollup-plugin-dts": "^5.0.0",
     "ts-jest": "^29.0.3"
   },
-  "gitHead": "ea9692380357e9e890c20f15b1200cc1c6c3a2df"
+  "gitHead": "df0efdbb0dc7b084579130ba5fe97441c0ab67ca"
 }