cspell-dictionary 6.27.0 → 6.29.0

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/CachingDictionary.d.ts

@@ -1,6 +1,6 @@
-import type { CacheStats } from '../util/AutoCache';
-import type { SearchOptions, SpellingDictionary } from './SpellingDictionary';
-import type { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
+import type { CacheStats } from '../util/AutoCache.js';
+import type { SearchOptions, SpellingDictionary } from './SpellingDictionary.js';
+import type { SpellingDictionaryCollection } from './SpellingDictionaryCollection.js';
 interface CallStats {
     name: string;
     id: number;

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/CachingDictionary.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCachingDictionary = void 0;
-const AutoCache_1 = require("../util/AutoCache");
-const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+const AutoCache_js_1 = require("../util/AutoCache.js");
+const SpellingDictionaryMethods_js_1 = require("./SpellingDictionaryMethods.js");
 let dictionaryCounter = 0;
 class CachedDict {
     constructor(dict, options) {
         this.dict = dict;
         this.options = options;
         this.id = ++dictionaryCounter;
-        this.has = (0, AutoCache_1.autoCache)((word) => this.dict.has(word, this.options));
-        this.isNoSuggestWord = (0, AutoCache_1.autoCache)((word) => this.dict.isNoSuggestWord(word, this.options));
-        this.isForbidden = (0, AutoCache_1.autoCache)((word) => this.dict.isForbidden(word));
+        this.has = (0, AutoCache_js_1.autoCache)((word) => this.dict.has(word, this.options));
+        this.isNoSuggestWord = (0, AutoCache_js_1.autoCache)((word) => this.dict.isNoSuggestWord(word, this.options));
+        this.isForbidden = (0, AutoCache_js_1.autoCache)((word) => this.dict.isForbidden(word));
         this.name = dict.name;
         // console.log(`CachedDict for ${this.name}`);
     }
@@ -19,9 +19,9 @@ class CachedDict {
         return {
             name: this.name,
             id: this.id,
-            has: (0, AutoCache_1.extractStats)(this.has),
-            isNoSuggestWord: (0, AutoCache_1.extractStats)(this.isNoSuggestWord),
-            isForbidden: (0, AutoCache_1.extractStats)(this.isForbidden),
+            has: (0, AutoCache_js_1.extractStats)(this.has),
+            isNoSuggestWord: (0, AutoCache_js_1.extractStats)(this.isNoSuggestWord),
+            isForbidden: (0, AutoCache_js_1.extractStats)(this.isForbidden),
         };
     }
 }
@@ -33,7 +33,7 @@ const knownDicts = new Map();
  * @returns CachingDictionary
  */
 function createCachingDictionary(dict, options) {
-    options = (0, SpellingDictionaryMethods_1.canonicalSearchOptions)(options);
+    options = (0, SpellingDictionaryMethods_js_1.canonicalSearchOptions)(options);
     let knownOptions = knownDicts.get(options);
     if (!knownOptions) {
         knownOptions = new WeakMap();

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/FlagWordsDictionary.d.ts

@@ -1,4 +1,4 @@
-import type { SpellingDictionary } from './SpellingDictionary';
+import type { SpellingDictionary } from './SpellingDictionary.js';
 /**
  * Create a dictionary where all words are to be forbidden.
  * @param wordList - list of words

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/FlagWordsDictionary.js

@@ -26,15 +26,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFlagWordsDictionary = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
 const cspell_trie_lib_1 = require("cspell-trie-lib");
-const AutoResolve_1 = require("../util/AutoResolve");
-const Defaults = __importStar(require("./defaults"));
-const SpellingDictionary_1 = require("./SpellingDictionary");
-const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
-const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
-const TyposDictionary_1 = require("./TyposDictionary");
-class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie {
+const AutoResolve_js_1 = require("../util/AutoResolve.js");
+const Defaults = __importStar(require("./defaults.js"));
+const SpellingDictionary_js_1 = require("./SpellingDictionary.js");
+const SpellingDictionaryFromTrie_js_1 = require("./SpellingDictionaryFromTrie.js");
+const SpellingDictionaryMethods_js_1 = require("./SpellingDictionaryMethods.js");
+const TyposDictionary_js_1 = require("./TyposDictionary.js");
+class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie_js_1.SpellingDictionaryFromTrie {
     constructor(trie, name, source) {
-        super(trie, name, SpellingDictionary_1.defaultOptions, source);
+        super(trie, name, SpellingDictionary_js_1.defaultOptions, source);
         this.name = name;
         this.source = source;
         this.containsNoSuggestWords = false;
@@ -104,7 +104,7 @@ class FlagWordsDictionary {
     }
     suggest(...args) {
         const [word] = args;
-        const suggestOptions = (0, SpellingDictionaryMethods_1.suggestArgsToSuggestOptions)(args);
+        const suggestOptions = (0, SpellingDictionaryMethods_js_1.suggestArgsToSuggestOptions)(args);
         return this.dictTypos.suggest(word, suggestOptions);
     }
     genSuggestions() {
@@ -120,7 +120,7 @@ class FlagWordsDictionary {
         return [];
     }
 }
-const createCache = (0, AutoResolve_1.createAutoResolveWeakCache)();
+const createCache = (0, AutoResolve_js_1.createAutoResolveWeakCache)();
 /**
  * Create a dictionary where all words are to be forbidden.
  * @param wordList - list of words
@@ -134,7 +134,7 @@ function createFlagWordsDictionary(wordList, name, source) {
         const testSpecialCharacters = /[~*+]/;
         const { t: specialWords, f: typoWords } = bisect((0, cspell_trie_lib_1.parseDictionaryLines)(wordList, { stripCaseAndAccents: false }), (line) => testSpecialCharacters.test(line));
         const trieDict = specialWords.size ? buildTrieDict(specialWords, name, source) : undefined;
-        const typosDict = (0, TyposDictionary_1.createTyposDictionary)(typoWords, name, source);
+        const typosDict = (0, TyposDictionary_js_1.createTyposDictionary)(typoWords, name, source);
         if (!trieDict)
             return typosDict;
         return new FlagWordsDictionary(name, source, typosDict, trieDict);

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/IgnoreWordsDictionary.d.ts

@@ -1,4 +1,4 @@
-import type { SpellingDictionary } from './SpellingDictionary';
+import type { SpellingDictionary } from './SpellingDictionary.js';
 /**
  * Create a dictionary where all words are to be ignored.
  * Ignored words override forbidden words.

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/IgnoreWordsDictionary.js

@@ -26,9 +26,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIgnoreWordsDictionary = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
 const cspell_trie_lib_1 = require("cspell-trie-lib");
-const AutoResolve_1 = require("../util/AutoResolve");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
-const Defaults = __importStar(require("./defaults"));
+const AutoResolve_js_1 = require("../util/AutoResolve.js");
+const createSpellingDictionary_js_1 = require("./createSpellingDictionary.js");
+const Defaults = __importStar(require("./defaults.js"));
 const NormalizeForm = 'NFC';
 class IgnoreWordsDictionary {
     constructor(name, source, words) {
@@ -95,7 +95,7 @@ class IgnoreWordsDictionary {
         return [];
     }
 }
-const createCache = (0, AutoResolve_1.createAutoResolveWeakCache)();
+const createCache = (0, AutoResolve_js_1.createAutoResolveWeakCache)();
 /**
  * Create a dictionary where all words are to be ignored.
  * Ignored words override forbidden words.
@@ -110,7 +110,7 @@ function createIgnoreWordsDictionary(wordList, name, source) {
         const words = [...(0, cspell_trie_lib_1.parseDictionaryLines)(wordList, { stripCaseAndAccents: true })].map((w) => w.normalize(NormalizeForm));
         const hasSpecial = words.findIndex((word) => testSpecialCharacters.test(word)) >= 0;
         if (hasSpecial) {
-            return (0, createSpellingDictionary_1.createSpellingDictionary)(words, name, source, {
+            return (0, createSpellingDictionary_js_1.createSpellingDictionary)(words, name, source, {
                 caseSensitive: true,
                 noSuggest: true,
                 weightMap: undefined,

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/SpellingDictionary.d.ts

@@ -134,6 +134,13 @@ export interface SpellingDictionary extends DictionaryInfo {
     suggest(word: string, suggestOptions: SuggestOptions): SuggestionResult[];
     genSuggestions(collector: SuggestionCollector, suggestOptions: SuggestOptions): void;
     mapWord(word: string): string;
+    /**
+     * Generates all possible word combinations by applying `repMap`.
+     * This acts a bit like brace expansions in globs.
+     * @param word - the word to map
+     * @returns array of adjusted words.
+     */
+    remapWord?: (word: string) => string[];
     readonly size: number;
     readonly isDictionaryCaseSensitive: boolean;
     getErrors?(): Error[];

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

@@ -1,4 +1,4 @@
-import type { SearchOptions, SpellingDictionary } from './SpellingDictionary';
+import type { SearchOptions, SpellingDictionary } from './SpellingDictionary.js';
 export interface SpellingDictionaryCollection extends SpellingDictionary {
     readonly type: 'SpellingDictionaryCollection';
     readonly dictionaries: SpellingDictionary[];

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

@@ -26,10 +26,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.isSpellingDictionaryCollection = exports.createCollection = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
 const gensequence_1 = require("gensequence");
-const util_1 = require("../util/util");
-const Defaults = __importStar(require("./defaults"));
-const SpellingDictionary_1 = require("./SpellingDictionary");
-const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+const util_js_1 = require("../util/util.js");
+const Defaults = __importStar(require("./defaults.js"));
+const SpellingDictionary_js_1 = require("./SpellingDictionary.js");
+const SpellingDictionaryMethods_js_1 = require("./SpellingDictionaryMethods.js");
 function identityString(w) {
     return w;
 }
@@ -51,11 +51,11 @@ class SpellingDictionaryCollectionImpl {
         this.containsNoSuggestWords = this.dictionaries.reduce((a, b) => a || b.containsNoSuggestWords, false);
     }
     has(word, hasOptions) {
-        const options = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
+        const options = (0, SpellingDictionaryMethods_js_1.hasOptionToSearchOption)(hasOptions);
         return !!isWordInAnyDictionary(this.dictionaries, word, options) && !this.isForbidden(word);
     }
     find(word, hasOptions) {
-        const options = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
+        const options = (0, SpellingDictionaryMethods_js_1.hasOptionToSearchOption)(hasOptions);
         return findInAnyDictionary(this.dictionaries, word, options);
     }
     isNoSuggestWord(word, options) {
@@ -67,11 +67,11 @@ class SpellingDictionaryCollectionImpl {
     }
     suggest(...args) {
         const [word] = args;
-        const suggestOptions = (0, SpellingDictionaryMethods_1.suggestArgsToSuggestOptions)(args);
+        const suggestOptions = (0, SpellingDictionaryMethods_js_1.suggestArgsToSuggestOptions)(args);
         return this._suggest(word, suggestOptions);
     }
     _suggest(word, suggestOptions) {
-        const { numSuggestions = SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, ignoreCase, includeTies, timeout } = suggestOptions;
+        const { numSuggestions = SpellingDictionaryMethods_js_1.defaultNumSuggestions, numChanges, ignoreCase, includeTies, timeout } = suggestOptions;
         const prefixNoCase = cspell_trie_lib_1.CASE_INSENSITIVE_PREFIX;
         const filter = (word, _cost) => {
             return ((ignoreCase || word[0] !== prefixNoCase) &&
@@ -86,7 +86,7 @@ class SpellingDictionaryCollectionImpl {
             ignoreCase,
             timeout,
         };
-        const collector = (0, SpellingDictionaryMethods_1.suggestionCollector)(word, collectorOptions);
+        const collector = (0, SpellingDictionaryMethods_js_1.suggestionCollector)(word, collectorOptions);
         this.genSuggestions(collector, suggestOptions);
         return collector.suggestions.map((r) => ({ ...r, word: r.word }));
     }
@@ -95,8 +95,8 @@ class SpellingDictionaryCollectionImpl {
     }
     genSuggestions(collector, suggestOptions) {
         const _suggestOptions = { ...suggestOptions };
-        const { compoundMethod = SpellingDictionary_1.CompoundWordsMethod.SEPARATE_WORDS } = suggestOptions;
-        _suggestOptions.compoundMethod = this.options.useCompounds ? SpellingDictionary_1.CompoundWordsMethod.JOIN_WORDS : compoundMethod;
+        const { compoundMethod = SpellingDictionary_js_1.CompoundWordsMethod.SEPARATE_WORDS } = suggestOptions;
+        _suggestOptions.compoundMethod = this.options.useCompounds ? SpellingDictionary_js_1.CompoundWordsMethod.JOIN_WORDS : compoundMethod;
         this.dictionaries.forEach((dict) => dict.genSuggestions(collector, _suggestOptions));
     }
     getErrors() {
@@ -114,7 +114,7 @@ function isWordInAnyDictionary(dicts, word, options) {
     return (0, gensequence_1.genSequence)(dicts).first((dict) => dict.has(word, options));
 }
 function findInAnyDictionary(dicts, word, options) {
-    const found = dicts.map((dict) => dict.find(word, options)).filter(util_1.isDefined);
+    const found = dicts.map((dict) => dict.find(word, options)).filter(util_js_1.isDefined);
     if (!found.length)
         return undefined;
     return found.reduce((a, b) => ({

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/SpellingDictionaryFromTrie.d.ts

@@ -1,6 +1,6 @@
 import type { SuggestionCollector, SuggestionResult } from 'cspell-trie-lib';
 import { CompoundWordsMethod, Trie } from 'cspell-trie-lib';
-import type { FindResult, HasOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestOptions } from './SpellingDictionary';
+import type { FindResult, HasOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestOptions } from './SpellingDictionary.js';
 export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     readonly trie: Trie;
     readonly name: string;
@@ -11,6 +11,7 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
     readonly knownWords: Set<string>;
     readonly unknownWords: Set<string>;
     readonly mapWord: (word: string) => string;
+    readonly remapWord: (word: string) => string[];
     readonly type = "SpellingDictionaryFromTrie";
     readonly isDictionaryCaseSensitive: boolean;
     readonly containsNoSuggestWords: boolean;
@@ -41,7 +42,7 @@ export declare class SpellingDictionaryFromTrie implements SpellingDictionary {
  * @returns SpellingDictionary
  */
 export declare function createSpellingDictionaryFromTrieFile(data: Iterable<string> | string, name: string, source: string, options: SpellingDictionaryOptions): SpellingDictionary;
-declare function outerWordForms(word: string, mapWord: (word: string) => string): Set<string>;
+declare function outerWordForms(word: string, mapWord: (word: string) => string[]): Set<string>;
 export declare const __testing__: {
     outerWordForms: typeof outerWordForms;
 };

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

@@ -26,11 +26,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.createSpellingDictionaryFromTrieFile = exports.SpellingDictionaryFromTrie = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
 const cspell_trie_lib_1 = require("cspell-trie-lib");
-const AutoCache_1 = require("../util/AutoCache");
-const clean_1 = require("../util/clean");
-const repMap_1 = require("../util/repMap");
-const Defaults = __importStar(require("./defaults"));
-const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+const AutoCache_js_1 = require("../util/AutoCache.js");
+const clean_js_1 = require("../util/clean.js");
+const repMap_js_1 = require("../util/repMap.js");
+const Defaults = __importStar(require("./defaults.js"));
+const SpellingDictionaryMethods_js_1 = require("./SpellingDictionaryMethods.js");
 const findWordOptionsCaseSensitive = Object.freeze({ caseSensitive: true });
 const findWordOptionsNotCaseSensitive = Object.freeze({ caseSensitive: false });
 class SpellingDictionaryFromTrie {
@@ -44,14 +44,15 @@ class SpellingDictionaryFromTrie {
         this.unknownWords = new Set();
         this.type = 'SpellingDictionaryFromTrie';
         this._find = findCache((word, useCompounds, ignoreCase) => this.findAnyForm(word, useCompounds, ignoreCase));
-        this._isForbidden = (0, AutoCache_1.autoCache)((word) => {
+        this._isForbidden = (0, AutoCache_js_1.autoCache)((word) => {
             return this.trie.isForbiddenWord(word);
         });
-        this.mapWord = (0, repMap_1.createMapper)(options.repMap, options.dictionaryInformation?.ignore);
+        this.mapWord = (0, repMap_js_1.createMapper)(options.repMap, options.dictionaryInformation?.ignore);
+        this.remapWord = (0, repMap_js_1.createRepMapper)(options.repMap, options.dictionaryInformation?.ignore);
         this.isDictionaryCaseSensitive = options.caseSensitive ?? !trie.isLegacy;
         this.containsNoSuggestWords = options.noSuggest || false;
         this._size = size || 0;
-        this.weightMap = options.weightMap || (0, SpellingDictionaryMethods_1.createWeightMapFromDictionaryInformation)(options.dictionaryInformation);
+        this.weightMap = options.weightMap || (0, SpellingDictionaryMethods_js_1.createWeightMapFromDictionaryInformation)(options.dictionaryInformation);
     }
     get size() {
         if (!this._size) {
@@ -85,11 +86,11 @@ class SpellingDictionaryFromTrie {
         return { found, forbidden, noSuggest };
     }
     resolveOptions(hasOptions) {
-        const { useCompounds = this.options.useCompounds, ignoreCase = Defaults.ignoreCase } = (0, SpellingDictionaryMethods_1.hasOptionToSearchOption)(hasOptions);
+        const { useCompounds = this.options.useCompounds, ignoreCase = Defaults.ignoreCase } = (0, SpellingDictionaryMethods_js_1.hasOptionToSearchOption)(hasOptions);
         return { useCompounds, ignoreCase };
     }
     findAnyForm(word, useCompounds, ignoreCase) {
-        const outerForms = outerWordForms(word, this.mapWord);
+        const outerForms = outerWordForms(word, this.remapWord ? this.remapWord : (word) => [this.mapWord(word)]);
         for (const form of outerForms) {
             const r = this._findAnyForm(form, useCompounds, ignoreCase);
             if (r)
@@ -103,7 +104,7 @@ class SpellingDictionaryFromTrie {
         if (findResult.found !== false) {
             return findResult;
         }
-        const forms = (0, SpellingDictionaryMethods_1.wordSearchForms)(mWord, this.isDictionaryCaseSensitive, ignoreCase);
+        const forms = (0, SpellingDictionaryMethods_js_1.wordSearchForms)(mWord, this.isDictionaryCaseSensitive, ignoreCase);
         for (const w of forms) {
             const findResult = this.trie.findWord(w, opts);
             if (findResult.found !== false) {
@@ -129,15 +130,15 @@ class SpellingDictionaryFromTrie {
     }
     suggest(...args) {
         const [word] = args;
-        const suggestOptions = (0, SpellingDictionaryMethods_1.suggestArgsToSuggestOptions)(args);
+        const suggestOptions = (0, SpellingDictionaryMethods_js_1.suggestArgsToSuggestOptions)(args);
         return this._suggest(word, suggestOptions);
     }
     _suggest(word, suggestOptions) {
-        const { numSuggestions = SpellingDictionaryMethods_1.defaultNumSuggestions, numChanges, includeTies, ignoreCase, timeout } = suggestOptions;
+        const { numSuggestions = SpellingDictionaryMethods_js_1.defaultNumSuggestions, numChanges, includeTies, ignoreCase, timeout } = suggestOptions;
         function filter(_word) {
             return true;
         }
-        const collector = (0, cspell_trie_lib_1.suggestionCollector)(word, (0, clean_1.clean)({
+        const collector = (0, cspell_trie_lib_1.suggestionCollector)(word, (0, clean_js_1.clean)({
             numSuggestions,
             filter,
             changeLimit: numChanges,
@@ -154,7 +155,7 @@ class SpellingDictionaryFromTrie {
             return;
         const _compoundMethod = suggestOptions.compoundMethod ??
             (this.options.useCompounds ? cspell_trie_lib_1.CompoundWordsMethod.JOIN_WORDS : cspell_trie_lib_1.CompoundWordsMethod.NONE);
-        (0, SpellingDictionaryMethods_1.wordSuggestFormsArray)(collector.word).forEach((w) => this.trie.genSuggestions((0, SpellingDictionaryMethods_1.impersonateCollector)(collector, w), _compoundMethod));
+        (0, SpellingDictionaryMethods_js_1.wordSuggestFormsArray)(collector.word).forEach((w) => this.trie.genSuggestions((0, SpellingDictionaryMethods_js_1.impersonateCollector)(collector, w), _compoundMethod));
     }
     getErrors() {
         return [];
@@ -178,7 +179,7 @@ function createSpellingDictionaryFromTrieFile(data, name, source, options) {
 }
 exports.createSpellingDictionaryFromTrieFile = createSpellingDictionaryFromTrieFile;
 function findCache(fn, size = 2000) {
-    const cache = (0, AutoCache_1.createCache01)(size);
+    const cache = (0, AutoCache_js_1.createCache01)(size);
     function find(word, useCompounds, ignoreCase) {
         const r = cache.get(word);
         if (r !== undefined) {
@@ -193,7 +194,7 @@ function findCache(fn, size = 2000) {
     return find;
 }
 function outerWordForms(word, mapWord) {
-    const forms = (0, sync_1.pipe)([word], (0, sync_1.opConcatMap)((word) => [word, word.normalize('NFC'), word.normalize('NFD')]), (0, sync_1.opConcatMap)((word) => [word, mapWord(word)]));
+    const forms = (0, sync_1.pipe)([word], (0, sync_1.opConcatMap)((word) => [word, word.normalize('NFC'), word.normalize('NFD')]), (0, sync_1.opConcatMap)((word) => [word, ...mapWord(word)]));
     return new Set(forms);
 }
 exports.__testing__ = { outerWordForms };

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/SpellingDictionaryMethods.d.ts

@@ -1,6 +1,6 @@
 import type { DictionaryInformation } from '@cspell/cspell-types';
 import type { SuggestionResult, WeightMap } from 'cspell-trie-lib';
-import type { HasOptions, SearchOptions, SuggestArgs, SuggestOptions } from './SpellingDictionary';
+import type { HasOptions, SearchOptions, SuggestArgs, SuggestOptions } from './SpellingDictionary.js';
 export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
 export type FilterSuggestionsPredicate = (word: SuggestionResult) => boolean;
 export declare const defaultNumSuggestions = 10;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testMethods__ = exports.createWeightMapFromDictionaryInformation = exports.suggestArgsToSuggestOptions = exports.canonicalSearchOptions = exports.hasOptionToSearchOption = exports.wordSuggestForms = exports.wordSuggestFormsArray = exports.wordSearchForms = exports.defaultNumSuggestions = exports.suggestionCollector = exports.impersonateCollector = void 0;
 const cspell_trie_lib_1 = require("cspell-trie-lib");
-const text_1 = require("../util/text");
+const text_js_1 = require("../util/text.js");
 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; } });
@@ -21,7 +21,7 @@ function wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase) {
         else {
             forms.add(wordLc);
             // Legacy remove any unbound accents
-            forms.add((0, text_1.removeUnboundAccents)(wordLc));
+            forms.add((0, text_js_1.removeUnboundAccents)(wordLc));
         }
     }
     else {
@@ -29,14 +29,14 @@ function wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase) {
             forms.add(word);
             forms.add(wordLc);
             // HOUSE -> House, house
-            if ((0, text_1.isUpperCase)(word)) {
-                forms.add((0, text_1.ucFirst)(wordLc));
+            if ((0, text_js_1.isUpperCase)(word)) {
+                forms.add((0, text_js_1.ucFirst)(wordLc));
             }
         }
         else {
             forms.add(wordLc);
             // Legacy remove any unbound accents
-            forms.add((0, text_1.removeUnboundAccents)(wordLc));
+            forms.add((0, text_js_1.removeUnboundAccents)(wordLc));
         }
     }
     return forms;

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/SuggestDictionary.d.ts

@@ -1,5 +1,5 @@
-import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary';
-import { type TypoEntry, type TyposDef } from './Typos';
+import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary.js';
+import { type TypoEntry, type TyposDef } from './Typos/index.js';
 export interface SuggestDictionary extends SpellingDictionary {
     /**
      * Determine if the word can appear in a list of suggestions.

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/SuggestDictionary.js

@@ -25,11 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSuggestDictionary = void 0;
 const sync_1 = require("@cspell/cspell-pipe/sync");
-const AutoResolve_1 = require("../util/AutoResolve");
-const textMappers_1 = require("../util/textMappers");
-const defaults = __importStar(require("./defaults"));
-const Typos_1 = require("./Typos");
-const util_1 = require("./Typos/util");
+const AutoResolve_js_1 = require("../util/AutoResolve.js");
+const textMappers_js_1 = require("../util/textMappers.js");
+const defaults = __importStar(require("./defaults.js"));
+const index_js_1 = require("./Typos/index.js");
+const util_js_1 = require("./Typos/util.js");
 class SuggestDictionaryImpl {
     constructor(name, source, typosDef) {
         this.name = name;
@@ -40,8 +40,8 @@ class SuggestDictionaryImpl {
         this.type = 'suggest';
         this.isDictionaryCaseSensitive = true;
         this.size = Object.keys(typosDef).length;
-        this.suggestions = (0, util_1.extractAllSuggestions)(typosDef);
-        this.suggestionsLower = new Set((0, sync_1.pipe)(this.suggestions, textMappers_1.mapperRemoveCaseAndAccents));
+        this.suggestions = (0, util_js_1.extractAllSuggestions)(typosDef);
+        this.suggestionsLower = new Set((0, sync_1.pipe)(this.suggestions, textMappers_js_1.mapperRemoveCaseAndAccents));
     }
     /**
      * A Forbidden word list does not "have" valid words.
@@ -107,7 +107,7 @@ class SuggestDictionaryImpl {
         return [];
     }
 }
-const createCache = (0, AutoResolve_1.createAutoResolveWeakCache)();
+const createCache = (0, AutoResolve_js_1.createAutoResolveWeakCache)();
 /**
  * Create a dictionary where all words are to be forbidden.
  * @param entries - list of Typos Entries
@@ -117,7 +117,7 @@ const createCache = (0, AutoResolve_1.createAutoResolveWeakCache)();
  */
 function createSuggestDictionary(entries, name, source) {
     return createCache.get(entries, () => {
-        const def = (0, Typos_1.processEntriesToTyposDef)(entries);
+        const def = (0, index_js_1.processEntriesToTyposDef)(entries);
         return new SuggestDictionaryImpl(name, source, def);
     });
 }

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/Terms/index.d.ts

@@ -1,2 +1,2 @@
-export { TermsDef, TermsDefKey, TermsDefValue, TermValueIgnoreWord, TermValueOk, TermValueTypo, TermValueTypoNoSuggestions, TermValueTypoWithSuggestions, } from './terms';
+export { TermsDef, TermsDefKey, TermsDefValue, TermValueIgnoreWord, TermValueOk, TermValueTypo, TermValueTypoNoSuggestions, TermValueTypoWithSuggestions, } from './terms.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/SpellingDictionary/Typos/index.d.ts

@@ -0,0 +1,4 @@
+export type { TypoEntry, TyposDef } from './typos.js';
+export { parseTyposFile, parseTyposLine, processEntriesToTyposDef } from './typosParser.js';
+export { createTyposDef, extractAllSuggestions } from './util.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/Typos/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractAllSuggestions = exports.createTyposDef = exports.processEntriesToTyposDef = exports.parseTyposLine = exports.parseTyposFile = void 0;
-var typosParser_1 = require("./typosParser");
-Object.defineProperty(exports, "parseTyposFile", { enumerable: true, get: function () { return typosParser_1.parseTyposFile; } });
-Object.defineProperty(exports, "parseTyposLine", { enumerable: true, get: function () { return typosParser_1.parseTyposLine; } });
-Object.defineProperty(exports, "processEntriesToTyposDef", { enumerable: true, get: function () { return typosParser_1.processEntriesToTyposDef; } });
-var util_1 = require("./util");
-Object.defineProperty(exports, "createTyposDef", { enumerable: true, get: function () { return util_1.createTyposDef; } });
-Object.defineProperty(exports, "extractAllSuggestions", { enumerable: true, get: function () { return util_1.extractAllSuggestions; } });
+var typosParser_js_1 = require("./typosParser.js");
+Object.defineProperty(exports, "parseTyposFile", { enumerable: true, get: function () { return typosParser_js_1.parseTyposFile; } });
+Object.defineProperty(exports, "parseTyposLine", { enumerable: true, get: function () { return typosParser_js_1.parseTyposLine; } });
+Object.defineProperty(exports, "processEntriesToTyposDef", { enumerable: true, get: function () { return typosParser_js_1.processEntriesToTyposDef; } });
+var util_js_1 = require("./util.js");
+Object.defineProperty(exports, "createTyposDef", { enumerable: true, get: function () { return util_js_1.createTyposDef; } });
+Object.defineProperty(exports, "extractAllSuggestions", { enumerable: true, get: function () { return util_js_1.extractAllSuggestions; } });
 //# sourceMappingURL=index.js.map

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/Typos/typos.d.ts

@@ -1,4 +1,4 @@
-import type { TermsDefKey, TermValueTypo, TermValueTypoNoSuggestions, TermValueTypoWithSuggestions } from '../Terms';
+import type { TermsDefKey, TermValueTypo, TermValueTypoNoSuggestions, TermValueTypoWithSuggestions } from '../Terms/index.js';
 export type TypoValueNoSuggestions = TermValueTypoNoSuggestions;
 export type TypoValueWithSuggestions = TermValueTypoWithSuggestions;
 export type TyposDefValue = TermValueTypo;

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/Typos/typosParser.d.ts

@@ -1,4 +1,4 @@
-import type { TypoEntry, TyposDef } from './typos';
+import type { TypoEntry, TyposDef } from './typos.js';
 export declare function createTyposDefFromEntries(entries: Iterable<TypoEntry>): TyposDef;
 export declare function sanitizeIntoTypoDef(dirtyDef: TyposDef | Record<string, unknown> | unknown): TyposDef | undefined;
 /**

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/Typos/typosParser.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTyposFile = exports.parseTyposLine = exports.processEntriesToTyposDef = exports.sanitizeIntoTypoDef = exports.createTyposDefFromEntries = void 0;
 const assert_1 = __importDefault(require("assert"));
-const util_1 = require("./util");
+const util_js_1 = require("./util.js");
 function assertString(v) {
     (0, assert_1.default)(typeof v === 'string', 'A string was expected.');
     return true;
@@ -17,7 +17,7 @@ const inlineComment = /#.*/gm;
 function createTyposDefFromEntries(entries) {
     const def = Object.create(null);
     for (const entry of entries) {
-        (0, util_1.appendToDef)(def, entry);
+        (0, util_js_1.appendToDef)(def, entry);
     }
     return def;
 }
@@ -41,7 +41,7 @@ function splitSuggestionsValue(value) {
 function sanitizeIntoTypoDef(dirtyDef) {
     if (!dirtyDef || typeof dirtyDef !== 'object')
         return undefined;
-    const def = (0, util_1.createTyposDef)();
+    const def = (0, util_js_1.createTyposDef)();
     for (const [rawKey, value] of Object.entries(dirtyDef)) {
         const key = normalize(rawKey.trim());
         if (!key)
@@ -91,9 +91,9 @@ function processEntriesToTyposDef(entries) {
 }
 exports.processEntriesToTyposDef = processEntriesToTyposDef;
 function reduceToTyposDef(entries) {
-    const def = (0, util_1.createTyposDef)();
+    const def = (0, util_js_1.createTyposDef)();
     for (const entry of entries) {
-        (0, util_1.appendToDef)(def, parseTyposLine(entry));
+        (0, util_js_1.appendToDef)(def, parseTyposLine(entry));
     }
     return def;
 }
@@ -106,7 +106,7 @@ function parseTyposLine(line) {
     if (!line)
         return undefined;
     if (typeof line === 'string') {
-        const def = (0, util_1.createTyposDef)();
+        const def = (0, util_js_1.createTyposDef)();
         for (const subEntry of splitIntoLines(line)) {
             const [left, right] = splitEntry(subEntry);
             const typo = left.trim();

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/Typos/util.d.ts

@@ -1,4 +1,4 @@
-import type { TypoEntry, TyposDef, TyposDefKey, TyposDefValue } from './typos';
+import type { TypoEntry, TyposDef, TyposDefKey, TyposDefValue } from './typos.js';
 export declare function mergeDefEntry(targetDef: TyposDef, key: string, value: TyposDefValue): TyposDef;
 /**
  * Merge in place the entries `fromDef` into `targetDef`

package/dist/{SpellingDictionary → cjs/SpellingDictionary}/TyposDictionary.d.ts

@@ -1,5 +1,5 @@
-import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary';
-import { type TypoEntry, type TyposDef } from './Typos';
+import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary.js';
+import { type TypoEntry, type TyposDef } from './Typos/index.js';
 export interface TyposDictionary extends SpellingDictionary {
     isForbidden(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
     /**