cspell-dictionary 7.3.9 → 8.0.0

package/dist/SpellingDictionary/CachingDictionary.js

@@ -3,17 +3,20 @@ import { canonicalSearchOptions } from './SpellingDictionaryMethods.js';
 let dictionaryCounter = 0;
 const DefaultAutoCacheSize = 1000;
 class CachedDict {
+    dict;
+    options;
+    name;
+    id = ++dictionaryCounter;
     constructor(dict, options) {
         this.dict = dict;
         this.options = options;
-        this.id = ++dictionaryCounter;
-        this.has = autoCache((word) => this.dict.has(word, this.options), DefaultAutoCacheSize);
-        this.isNoSuggestWord = autoCache((word) => this.dict.isNoSuggestWord(word, this.options), DefaultAutoCacheSize);
-        this.isForbidden = autoCache((word) => this.dict.isForbidden(word), DefaultAutoCacheSize);
-        this.getPreferredSuggestions = autoCache((word) => this.dict.getPreferredSuggestions?.(word), DefaultAutoCacheSize);
         this.name = dict.name;
         // console.log(`CachedDict for ${this.name}`);
     }
+    has = autoCache((word) => this.dict.has(word, this.options), DefaultAutoCacheSize);
+    isNoSuggestWord = autoCache((word) => this.dict.isNoSuggestWord(word, this.options), DefaultAutoCacheSize);
+    isForbidden = autoCache((word) => this.dict.isForbidden(word), DefaultAutoCacheSize);
+    getPreferredSuggestions = autoCache((word) => this.dict.getPreferredSuggestions?.(word), DefaultAutoCacheSize);
     stats() {
         return {
             name: this.name,

package/dist/SpellingDictionary/FlagWordsDictionary.js

@@ -6,13 +6,14 @@ import { defaultOptions } from './SpellingDictionary.js';
 import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.js';
 import { createTyposDictionary } from './TyposDictionary.js';
 class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
+    name;
+    source;
+    containsNoSuggestWords = false;
+    options = {};
     constructor(trie, name, source) {
         super(trie, name, defaultOptions, source);
         this.name = name;
         this.source = source;
-        this.containsNoSuggestWords = false;
-        this.options = {};
-        this.isDictionaryCaseSensitive = true;
     }
     /**
      * A Forbidden word list does not "have" valid words.
@@ -36,17 +37,21 @@ class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
     genSuggestions() {
         return;
     }
+    isDictionaryCaseSensitive = true;
 }
 class FlagWordsDictionary {
+    name;
+    source;
+    dictTypos;
+    dictTrie;
+    containsNoSuggestWords = false;
+    options = {};
+    type = 'flag-words';
     constructor(name, source, dictTypos, dictTrie) {
         this.name = name;
         this.source = source;
         this.dictTypos = dictTypos;
         this.dictTrie = dictTrie;
-        this.containsNoSuggestWords = false;
-        this.options = {};
-        this.type = 'flag-words';
-        this.isDictionaryCaseSensitive = true;
     }
     /**
      * A Forbidden word list does not "have" valid words.
@@ -90,6 +95,7 @@ class FlagWordsDictionary {
     get size() {
         return this.dictTypos.size + (this.dictTrie?.size || 0);
     }
+    isDictionaryCaseSensitive = true;
     getErrors() {
         return [];
     }

package/dist/SpellingDictionary/IgnoreWordsDictionary.js

@@ -5,13 +5,16 @@ import { createSpellingDictionary } from './createSpellingDictionary.js';
 import * as Defaults from './defaults.js';
 const NormalizeForm = 'NFC';
 class IgnoreWordsDictionary {
+    name;
+    source;
+    dict;
+    dictNonStrict;
+    containsNoSuggestWords = true;
+    options = {};
+    type = 'ignore';
     constructor(name, source, words) {
         this.name = name;
         this.source = source;
-        this.containsNoSuggestWords = true;
-        this.options = {};
-        this.type = 'ignore';
-        this.isDictionaryCaseSensitive = true;
         this.dict = new Set(words);
         this.dictNonStrict = new Set(pipe(this.dict, opFilter((w) => w.startsWith('~')), opMap((w) => w.slice(1))));
     }
@@ -65,6 +68,7 @@ class IgnoreWordsDictionary {
     get size() {
         return this.dict.size;
     }
+    isDictionaryCaseSensitive = true;
     getErrors() {
         return [];
     }

package/dist/SpellingDictionary/SpellingDictionaryCollection.js

@@ -7,17 +7,17 @@ function identityString(w) {
     return w;
 }
 class SpellingDictionaryCollectionImpl {
+    dictionaries;
+    name;
+    options = { weightMap: undefined };
+    mapWord = identityString;
+    type = 'SpellingDictionaryCollection';
+    source;
+    isDictionaryCaseSensitive;
+    containsNoSuggestWords;
     constructor(dictionaries, name, source) {
         this.dictionaries = dictionaries;
         this.name = name;
-        this.options = { weightMap: undefined };
-        this.mapWord = identityString;
-        this.type = 'SpellingDictionaryCollection';
-        this._isNoSuggestWord = (word, options) => {
-            if (!this.containsNoSuggestWords)
-                return false;
-            return !!isNoSuggestWordInAnyDictionary(this.dictionaries, word, options || {});
-        };
         this.dictionaries = this.dictionaries.sort((a, b) => b.size - a.size);
         this.source = source || dictionaries.map((d) => d.name).join(', ');
         this.isDictionaryCaseSensitive = this.dictionaries.reduce((a, b) => a || b.isDictionaryCaseSensitive, false);
@@ -88,6 +88,11 @@ class SpellingDictionaryCollectionImpl {
     _isForbiddenInDict(word, ignoreCase) {
         return isWordForbiddenInAnyDictionary(this.dictionaries, word, ignoreCase);
     }
+    _isNoSuggestWord = (word, options) => {
+        if (!this.containsNoSuggestWords)
+            return false;
+        return !!isNoSuggestWordInAnyDictionary(this.dictionaries, word, options || {});
+    };
 }
 export function createCollection(dictionaries, name, source) {
     return new SpellingDictionaryCollectionImpl(dictionaries, name, source);

package/dist/SpellingDictionary/SpellingDictionaryFromTrie.js

@@ -8,19 +8,25 @@ import { createWeightMapFromDictionaryInformation, defaultNumSuggestions, hasOpt
 const findWordOptionsCaseSensitive = Object.freeze({ caseSensitive: true });
 const findWordOptionsNotCaseSensitive = Object.freeze({ caseSensitive: false });
 export class SpellingDictionaryFromTrie {
+    trie;
+    name;
+    options;
+    source;
+    static cachedWordsLimit = 50000;
+    _size = 0;
+    knownWords = new Set();
+    unknownWords = new Set();
+    mapWord;
+    remapWord;
+    type = 'SpellingDictionaryFromTrie';
+    isDictionaryCaseSensitive;
+    containsNoSuggestWords;
+    weightMap;
     constructor(trie, name, options, source = 'from trie', size) {
         this.trie = trie;
         this.name = name;
         this.options = options;
         this.source = source;
-        this._size = 0;
-        this.knownWords = new Set();
-        this.unknownWords = new Set();
-        this.type = 'SpellingDictionaryFromTrie';
-        this._find = findCache((word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase));
-        this._isForbidden = autoCache((word) => {
-            return this.trie.isForbiddenWord(word);
-        });
         this.mapWord = createMapper(options.repMap, options.dictionaryInformation?.ignore);
         this.remapWord = createRepMapper(options.repMap, options.dictionaryInformation?.ignore);
         this.isDictionaryCaseSensitive = options.caseSensitive ?? trie.isCaseAware;
@@ -63,6 +69,7 @@ export class SpellingDictionaryFromTrie {
         const { useCompounds = this.options.useCompounds, ignoreCase = Defaults.ignoreCase } = hasOptionToSearchOption(hasOptions);
         return { useCompounds, ignoreCase };
     }
+    _find = findCache((word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase));
     findAnyForm(word, useCompounds, ignoreCase) {
         const outerForms = outerWordForms(word, this.remapWord ? this.remapWord : (word) => [this.mapWord(word)]);
         for (const form of outerForms) {
@@ -102,6 +109,9 @@ export class SpellingDictionaryFromTrie {
     isForbidden(word, _ignoreCaseAndAccents) {
         return this._isForbidden(word);
     }
+    _isForbidden = autoCache((word) => {
+        return this.trie.isForbiddenWord(word);
+    });
     suggest(word, suggestOptions = {}) {
         return this._suggest(word, suggestOptions);
     }
@@ -133,7 +143,6 @@ export class SpellingDictionaryFromTrie {
         return [];
     }
 }
-SpellingDictionaryFromTrie.cachedWordsLimit = 50000;
 /**
  * Create a dictionary from a trie file.
  * @param data - contents of a trie file.

package/dist/SpellingDictionary/SuggestDictionary.js

@@ -5,14 +5,24 @@ import * as defaults from './defaults.js';
 import { processEntriesToTyposDef } from './Typos/index.js';
 import { extractAllSuggestions } from './Typos/util.js';
 class SuggestDictionaryImpl {
+    name;
+    source;
+    typosDef;
+    containsNoSuggestWords = false;
+    options = {};
+    type = 'suggest';
+    size;
+    /**
+     * Note: ignoreWordsLower is only suggestions with the case and accents removed.
+     * The logic is that if someone explicity ignored an upper case version, it does not
+     * mean that the lower case version is ok.
+     */
+    suggestions;
+    suggestionsLower;
     constructor(name, source, typosDef) {
         this.name = name;
         this.source = source;
         this.typosDef = typosDef;
-        this.containsNoSuggestWords = false;
-        this.options = {};
-        this.type = 'suggest';
-        this.isDictionaryCaseSensitive = true;
         this.size = Object.keys(typosDef).length;
         this.suggestions = extractAllSuggestions(typosDef);
         this.suggestionsLower = new Set(pipe(this.suggestions, mapperRemoveCaseAndAccents));
@@ -80,6 +90,7 @@ class SuggestDictionaryImpl {
     mapWord(word) {
         return word;
     }
+    isDictionaryCaseSensitive = true;
     getErrors() {
         return [];
     }

package/dist/SpellingDictionary/TyposDictionary.js

@@ -5,13 +5,26 @@ import * as defaults from './defaults.js';
 import { processEntriesToTyposDef } from './Typos/index.js';
 import { extractAllSuggestions, extractIgnoreValues } from './Typos/util.js';
 class TyposDictionaryImpl {
+    name;
+    source;
+    typosDef;
+    containsNoSuggestWords;
+    options = {};
+    type = 'typos';
+    size;
+    ignoreWords;
+    /**
+     * Note: ignoreWordsLower is only suggestions with the case and accents removed.
+     * The logic is that if someone explicity ignored an upper case version, it does not
+     * mean that the lower case version is ok.
+     */
+    suggestions;
+    suggestionsLower;
+    explicitIgnoreWords;
     constructor(name, source, typosDef, ignoreList) {
         this.name = name;
         this.source = source;
         this.typosDef = typosDef;
-        this.options = {};
-        this.type = 'typos';
-        this.isDictionaryCaseSensitive = true;
         this.size = Object.keys(typosDef).length;
         this.explicitIgnoreWords = extractIgnoreValues(typosDef, '!');
         this.suggestions = extractAllSuggestions(typosDef);
@@ -112,6 +125,7 @@ class TyposDictionaryImpl {
     mapWord(word) {
         return word;
     }
+    isDictionaryCaseSensitive = true;
     getErrors() {
         return [];
     }

package/dist/util/AutoCache.js

@@ -1,13 +1,14 @@
 const CACHE_SIZE = 100;
 class Cache01 {
+    maxSize;
+    count = 0;
+    cache0 = Object.create(null);
+    cache1 = Object.create(null);
+    hits = 0;
+    misses = 0;
+    swaps = 0;
     constructor(maxSize) {
         this.maxSize = maxSize;
-        this.count = 0;
-        this.cache0 = Object.create(null);
-        this.cache1 = Object.create(null);
-        this.hits = 0;
-        this.misses = 0;
-        this.swaps = 0;
     }
     get(key) {
         const cache0 = this.cache0;

package/dist/util/AutoResolve.js

@@ -7,9 +7,7 @@ export function autoResolve(map, key, resolve) {
     return value;
 }
 export class AutoResolveCache {
-    constructor() {
-        this.map = new Map();
-    }
+    map = new Map();
     get(k, resolve) {
         return resolve ? autoResolve(this.map, k, resolve) : this.map.get(k);
     }
@@ -33,9 +31,7 @@ export function autoResolveWeak(map, key, resolve) {
     return value;
 }
 export class AutoResolveWeakCache {
-    constructor() {
-        this.map = new WeakMap();
-    }
+    map = new WeakMap();
     get(k, resolve) {
         return resolve ? autoResolveWeak(this.map, k, resolve) : this.map.get(k);
     }

package/dist/util/simpleCache.js

@@ -1,10 +1,11 @@
 export class SimpleWeakCache {
+    size;
+    L0 = new WeakMap();
+    L1 = new WeakMap();
+    L2 = new WeakMap();
+    sizeL0 = 0;
     constructor(size) {
         this.size = size;
-        this.L0 = new WeakMap();
-        this.L1 = new WeakMap();
-        this.L2 = new WeakMap();
-        this.sizeL0 = 0;
     }
     has(key) {
         for (const c of this.caches()) {
@@ -50,6 +51,7 @@ export class SimpleWeakCache {
     }
 }
 export class AutoWeakCache extends SimpleWeakCache {
+    factory;
     constructor(factory, size) {
         super(size);
         this.factory = factory;
@@ -72,11 +74,12 @@ export class AutoWeakCache extends SimpleWeakCache {
  * promoted to L0.
  */
 export class SimpleCache {
+    size;
+    L0 = new Map();
+    L1 = new Map();
+    L2 = new Map();
     constructor(size) {
         this.size = size;
-        this.L0 = new Map();
-        this.L1 = new Map();
-        this.L2 = new Map();
     }
     has(key) {
         for (const c of this.caches()) {
@@ -120,6 +123,7 @@ export class SimpleCache {
     }
 }
 export class AutoCache extends SimpleCache {
+    factory;
     constructor(factory, size) {
         super(size);
         this.factory = factory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-dictionary",
-  "version": "7.3.9",
+  "version": "8.0.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "type": "module",
   "types": "dist/index.d.ts",
@@ -42,14 +42,14 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "7.3.9",
-    "@cspell/cspell-types": "7.3.9",
-    "cspell-trie-lib": "7.3.9",
+    "@cspell/cspell-pipe": "8.0.0",
+    "@cspell/cspell-types": "8.0.0",
+    "cspell-trie-lib": "8.0.0",
     "fast-equals": "^4.0.3",
     "gensequence": "^6.0.0"
   },
-  "gitHead": "77c7fb3ffd80a626ec07d704cefcaa21d62fd460"
+  "gitHead": "67c22bf98baed1c17bbc658fba8656262d17e370"
 }