cspell-dictionary 7.0.0-alpha.1 → 7.0.1-alpha.0

package/dist/{esm/SpellingDictionary/CachingDictionary.mjs → SpellingDictionary/CachingDictionary.js}

@@ -1,5 +1,5 @@
-import { autoCache, extractStats } from '../util/AutoCache.mjs';
-import { canonicalSearchOptions } from './SpellingDictionaryMethods.mjs';
+import { autoCache, extractStats } from '../util/AutoCache.js';
+import { canonicalSearchOptions } from './SpellingDictionaryMethods.js';
 let dictionaryCounter = 0;
 const DefaultAutoCacheSize = 1000;
 class CachedDict {

package/dist/{esm/SpellingDictionary/FlagWordsDictionary.mjs → SpellingDictionary/FlagWordsDictionary.js}

@@ -1,11 +1,11 @@
 import { opMap, pipe } from '@cspell/cspell-pipe/sync';
 import { buildTrieFast, parseDictionaryLines } from 'cspell-trie-lib';
-import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
-import * as Defaults from './defaults.mjs';
-import { defaultOptions } from './SpellingDictionary.mjs';
-import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.mjs';
-import { suggestArgsToSuggestOptions } from './SpellingDictionaryMethods.mjs';
-import { createTyposDictionary } from './TyposDictionary.mjs';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.js';
+import * as Defaults from './defaults.js';
+import { defaultOptions } from './SpellingDictionary.js';
+import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.js';
+import { suggestArgsToSuggestOptions } from './SpellingDictionaryMethods.js';
+import { createTyposDictionary } from './TyposDictionary.js';
 class FlagWordsDictionaryTrie extends SpellingDictionaryFromTrie {
     constructor(trie, name, source) {
         super(trie, name, defaultOptions, source);

package/dist/{esm/SpellingDictionary/IgnoreWordsDictionary.mjs → SpellingDictionary/IgnoreWordsDictionary.js}

@@ -1,8 +1,8 @@
 import { opFilter, opMap, pipe } from '@cspell/cspell-pipe/sync';
 import { parseDictionaryLines } from 'cspell-trie-lib';
-import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
-import { createSpellingDictionary } from './createSpellingDictionary.mjs';
-import * as Defaults from './defaults.mjs';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.js';
+import { createSpellingDictionary } from './createSpellingDictionary.js';
+import * as Defaults from './defaults.js';
 const NormalizeForm = 'NFC';
 class IgnoreWordsDictionary {
     constructor(name, source, words) {

package/dist/{esm/SpellingDictionary/SpellingDictionaryCollection.mjs → SpellingDictionary/SpellingDictionaryCollection.js}

@@ -1,9 +1,9 @@
 import { CASE_INSENSITIVE_PREFIX } from 'cspell-trie-lib';
 import { genSequence } from 'gensequence';
-import { isDefined } from '../util/util.mjs';
-import * as Defaults from './defaults.mjs';
-import { CompoundWordsMethod } from './SpellingDictionary.mjs';
-import { defaultNumSuggestions, hasOptionToSearchOption, suggestArgsToSuggestOptions, suggestionCollector, } from './SpellingDictionaryMethods.mjs';
+import { isDefined } from '../util/util.js';
+import * as Defaults from './defaults.js';
+import { CompoundWordsMethod } from './SpellingDictionary.js';
+import { defaultNumSuggestions, hasOptionToSearchOption, suggestArgsToSuggestOptions, suggestionCollector, } from './SpellingDictionaryMethods.js';
 function identityString(w) {
     return w;
 }

package/dist/{esm/SpellingDictionary/SpellingDictionaryFromTrie.mjs → SpellingDictionary/SpellingDictionaryFromTrie.js}

@@ -1,13 +1,13 @@
 import { opConcatMap, pipe } from '@cspell/cspell-pipe/sync';
 import { CompoundWordsMethod, importTrie, suggestionCollector, Trie } from 'cspell-trie-lib';
-import { autoCache, createCache01 } from '../util/AutoCache.mjs';
-import { clean } from '../util/clean.mjs';
-import { createMapper, createRepMapper } from '../util/repMap.mjs';
-import * as Defaults from './defaults.mjs';
-import { createWeightMapFromDictionaryInformation, defaultNumSuggestions, hasOptionToSearchOption, impersonateCollector, suggestArgsToSuggestOptions, wordSearchForms, wordSuggestFormsArray, } from './SpellingDictionaryMethods.mjs';
+import { autoCache, createCache01 } from '../util/AutoCache.js';
+import { clean } from '../util/clean.js';
+import { createMapper, createRepMapper } from '../util/repMap.js';
+import * as Defaults from './defaults.js';
+import { createWeightMapFromDictionaryInformation, defaultNumSuggestions, hasOptionToSearchOption, impersonateCollector, suggestArgsToSuggestOptions, wordSearchForms, wordSuggestFormsArray, } from './SpellingDictionaryMethods.js';
 const findWordOptionsCaseSensitive = Object.freeze({ caseSensitive: true });
 const findWordOptionsNotCaseSensitive = Object.freeze({ caseSensitive: false });
-class SpellingDictionaryFromTrie {
+export class SpellingDictionaryFromTrie {
     constructor(trie, name, options, source = 'from trie', size) {
         this.trie = trie;
         this.name = name;
@@ -136,7 +136,6 @@ class SpellingDictionaryFromTrie {
     }
 }
 SpellingDictionaryFromTrie.cachedWordsLimit = 50000;
-export { SpellingDictionaryFromTrie };
 /**
  * Create a dictionary from a trie file.
  * @param data - contents of a trie file.

package/dist/{esm/SpellingDictionary/SpellingDictionaryMethods.mjs → SpellingDictionary/SpellingDictionaryMethods.js}

@@ -1,5 +1,5 @@
 import { mapDictionaryInformationToWeightMap } from 'cspell-trie-lib';
-import { isUpperCase, removeUnboundAccents, ucFirst } from '../util/text.mjs';
+import { isUpperCase, removeUnboundAccents, ucFirst } from '../util/text.js';
 export { impersonateCollector, suggestionCollector } from 'cspell-trie-lib';
 export const defaultNumSuggestions = 10;
 function wordSearchFormsArray(word, isDictionaryCaseSensitive, ignoreCase) {

package/dist/{esm/SpellingDictionary/SuggestDictionary.mjs → SpellingDictionary/SuggestDictionary.js}

@@ -1,9 +1,9 @@
 import { pipe } from '@cspell/cspell-pipe/sync';
-import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
-import { mapperRemoveCaseAndAccents } from '../util/textMappers.mjs';
-import * as defaults from './defaults.mjs';
-import { processEntriesToTyposDef } from './Typos/index.mjs';
-import { extractAllSuggestions } from './Typos/util.mjs';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.js';
+import { mapperRemoveCaseAndAccents } from '../util/textMappers.js';
+import * as defaults from './defaults.js';
+import { processEntriesToTyposDef } from './Typos/index.js';
+import { extractAllSuggestions } from './Typos/util.js';
 class SuggestDictionaryImpl {
     constructor(name, source, typosDef) {
         this.name = name;

package/dist/SpellingDictionary/Typos/index.js

@@ -0,0 +1,2 @@
+export { parseTyposFile, parseTyposLine, processEntriesToTyposDef } from './typosParser.js';
+export { createTyposDef, extractAllSuggestions } from './util.js';

package/dist/{esm/SpellingDictionary/Typos/typosParser.mjs → SpellingDictionary/Typos/typosParser.js}

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import { appendToDef, createTyposDef } from './util.mjs';
+import { appendToDef, createTyposDef } from './util.js';
 function assertString(v) {
     assert(typeof v === 'string', 'A string was expected.');
     return true;

package/dist/{esm/SpellingDictionary/TyposDictionary.mjs → SpellingDictionary/TyposDictionary.js}

@@ -1,9 +1,9 @@
 import { opAppend, pipe } from '@cspell/cspell-pipe/sync';
-import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
-import { mapperRemoveCaseAndAccents } from '../util/textMappers.mjs';
-import * as defaults from './defaults.mjs';
-import { processEntriesToTyposDef } from './Typos/index.mjs';
-import { extractAllSuggestions, extractIgnoreValues } from './Typos/util.mjs';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.js';
+import { mapperRemoveCaseAndAccents } from '../util/textMappers.js';
+import * as defaults from './defaults.js';
+import { processEntriesToTyposDef } from './Typos/index.js';
+import { extractAllSuggestions, extractIgnoreValues } from './Typos/util.js';
 class TyposDictionaryImpl {
     constructor(name, source, typosDef, ignoreList) {
         this.name = name;

package/dist/{esm/SpellingDictionary/createInlineSpellingDictionary.mjs → SpellingDictionary/createInlineSpellingDictionary.js}

@@ -1,10 +1,10 @@
-import { createAutoResolveWeakCache } from '../util/AutoResolve.mjs';
-import { isDefined } from '../util/util.mjs';
-import { createSpellingDictionary } from './createSpellingDictionary.mjs';
-import { createFlagWordsDictionary } from './FlagWordsDictionary.mjs';
-import { createIgnoreWordsDictionary } from './IgnoreWordsDictionary.mjs';
-import { createCollection } from './SpellingDictionaryCollection.mjs';
-import { createSuggestDictionary } from './SuggestDictionary.mjs';
+import { createAutoResolveWeakCache } from '../util/AutoResolve.js';
+import { isDefined } from '../util/util.js';
+import { createSpellingDictionary } from './createSpellingDictionary.js';
+import { createFlagWordsDictionary } from './FlagWordsDictionary.js';
+import { createIgnoreWordsDictionary } from './IgnoreWordsDictionary.js';
+import { createCollection } from './SpellingDictionaryCollection.js';
+import { createSuggestDictionary } from './SuggestDictionary.js';
 const cache = createAutoResolveWeakCache();
 export function createInlineSpellingDictionary(inlineDict, source) {
     return cache.get(inlineDict, () => {

package/dist/{esm/SpellingDictionary/createSpellingDictionary.mjs → SpellingDictionary/createSpellingDictionary.js}

@@ -1,9 +1,9 @@
 import { buildTrieFast, parseDictionaryLines } from 'cspell-trie-lib';
 import { deepEqual } from 'fast-equals';
-import { AutoWeakCache, SimpleCache } from '../util/simpleCache.mjs';
-import { defaultOptions } from './SpellingDictionary.mjs';
-import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.mjs';
-import { createWeightMapFromDictionaryInformation } from './SpellingDictionaryMethods.mjs';
+import { AutoWeakCache, SimpleCache } from '../util/simpleCache.js';
+import { defaultOptions } from './SpellingDictionary.js';
+import { SpellingDictionaryFromTrie } from './SpellingDictionaryFromTrie.js';
+import { createWeightMapFromDictionaryInformation } from './SpellingDictionaryMethods.js';
 const cachedDictionaries = new AutoWeakCache(_createSpellingDictionary, 64);
 const maxSetSize = 3;
 const cachedParamsByWordList = new SimpleCache(64);

package/dist/{esm/SpellingDictionary/index.mjs → SpellingDictionary/index.js}

@@ -1,9 +1,9 @@
-export { createCachingDictionary } from './CachingDictionary.mjs';
-export { createInlineSpellingDictionary } from './createInlineSpellingDictionary.mjs';
-export { createFailedToLoadDictionary, createSpellingDictionary } from './createSpellingDictionary.mjs';
-export { createFlagWordsDictionary, createFlagWordsDictionary as createForbiddenWordsDictionary, } from './FlagWordsDictionary.mjs';
-export { createIgnoreWordsDictionary } from './IgnoreWordsDictionary.mjs';
-export { createCollection } from './SpellingDictionaryCollection.mjs';
-export { createSpellingDictionaryFromTrieFile } from './SpellingDictionaryFromTrie.mjs';
-export { createSuggestDictionary } from './SuggestDictionary.mjs';
-export { createTyposDictionary } from './TyposDictionary.mjs';
+export { createCachingDictionary } from './CachingDictionary.js';
+export { createInlineSpellingDictionary } from './createInlineSpellingDictionary.js';
+export { createFailedToLoadDictionary, createSpellingDictionary } from './createSpellingDictionary.js';
+export { createFlagWordsDictionary, createFlagWordsDictionary as createForbiddenWordsDictionary, } from './FlagWordsDictionary.js';
+export { createIgnoreWordsDictionary } from './IgnoreWordsDictionary.js';
+export { createCollection } from './SpellingDictionaryCollection.js';
+export { createSpellingDictionaryFromTrieFile } from './SpellingDictionaryFromTrie.js';
+export { createSuggestDictionary } from './SuggestDictionary.js';
+export { createTyposDictionary } from './TyposDictionary.js';

package/dist/{esm/index.mjs → index.js}

@@ -1 +1 @@
-export { createCachingDictionary, createCollection, createFailedToLoadDictionary, createFlagWordsDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, createSuggestDictionary, } from './SpellingDictionary/index.mjs';
+export { createCachingDictionary, createCollection, createFailedToLoadDictionary, createFlagWordsDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, createSuggestDictionary, } from './SpellingDictionary/index.js';

package/dist/{esm/util/repMap.mjs → util/repMap.js}

@@ -1,6 +1,6 @@
 import { expandCharacterSet } from 'cspell-trie-lib';
-import { escapeRegEx } from './regexHelper.mjs';
-import { isDefined } from './util.mjs';
+import { escapeRegEx } from './regexHelper.js';
+import { isDefined } from './util.js';
 export function createMapper(repMap, ignoreCharset) {
     if (!repMap && !ignoreCharset)
         return (a) => a;

package/dist/{esm/util/textMappers.mjs → util/textMappers.js}

@@ -1,4 +1,4 @@
-import { removeAccents } from './text.mjs';
+import { removeAccents } from './text.js';
 export function* mapperNormalizeNFC(words) {
     for (const word of words) {
         yield word.normalize('NFC');

package/package.json

@@ -1,21 +1,17 @@
 {
   "name": "cspell-dictionary",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.1-alpha.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
-  "type": "commonjs",
-  "main": "dist/cjs/index.js",
-  "types": "dist/cjs/index.d.ts",
-  "module": "dist/esm/index.mjs",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
   "exports": {
     ".": {
-      "import": "./dist/esm/index.mjs",
-      "require": "./dist/cjs/index.js"
+      "import": "./dist/index.js"
     }
   },
   "files": [
     "dist",
-    "!dist/esm/**/*.js",
-    "!dist/esm/**/*.ts",
     "!**/*.tsbuildInfo",
     "!**/__mocks__",
     "!**/test/**",
@@ -24,9 +20,8 @@
     "!**/*.map"
   ],
   "scripts": {
-    "clean": "shx rm -rf dist coverage .tsbuildinfo",
-    "build": "tsc -b . && ts2mjs dist/esm",
-    "build:esm": "tsc -p tsconfig.esm.json",
+    "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
+    "build": "tsc -b .",
     "clean-build": "pnpm run clean && pnpm run build",
     "coverage": "pnpm coverage:vitest && pnpm coverage:fix",
     "coverage:vitest": "vitest run --coverage",
@@ -52,11 +47,11 @@
     "node": ">=16"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "7.0.0-alpha.1",
-    "@cspell/cspell-types": "7.0.0-alpha.1",
-    "cspell-trie-lib": "7.0.0-alpha.1",
+    "@cspell/cspell-pipe": "7.0.1-alpha.0",
+    "@cspell/cspell-types": "7.0.1-alpha.0",
+    "cspell-trie-lib": "7.0.1-alpha.0",
     "fast-equals": "^4.0.3",
     "gensequence": "^5.0.2"
   },
-  "gitHead": "626d1a01b413c1b6de0b386a5a264b78a10ba146"
+  "gitHead": "9ac874fd367a2858df9aab07fafad183347f2033"
 }

package/dist/cjs/SpellingDictionary/CachingDictionary.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCachingDictionary = void 0;
-const AutoCache_js_1 = require("../util/AutoCache.js");
-const SpellingDictionaryMethods_js_1 = require("./SpellingDictionaryMethods.js");
-let dictionaryCounter = 0;
-const DefaultAutoCacheSize = 1000;
-class CachedDict {
-    constructor(dict, options) {
-        this.dict = dict;
-        this.options = options;
-        this.id = ++dictionaryCounter;
-        this.has = (0, AutoCache_js_1.autoCache)((word) => this.dict.has(word, this.options), DefaultAutoCacheSize);
-        this.isNoSuggestWord = (0, AutoCache_js_1.autoCache)((word) => this.dict.isNoSuggestWord(word, this.options), DefaultAutoCacheSize);
-        this.isForbidden = (0, AutoCache_js_1.autoCache)((word) => this.dict.isForbidden(word), DefaultAutoCacheSize);
-        this.getPreferredSuggestions = (0, AutoCache_js_1.autoCache)((word) => this.dict.getPreferredSuggestions?.(word), DefaultAutoCacheSize);
-        this.name = dict.name;
-        // console.log(`CachedDict for ${this.name}`);
-    }
-    stats() {
-        return {
-            name: this.name,
-            id: this.id,
-            has: (0, AutoCache_js_1.extractStats)(this.has),
-            isNoSuggestWord: (0, AutoCache_js_1.extractStats)(this.isNoSuggestWord),
-            isForbidden: (0, AutoCache_js_1.extractStats)(this.isForbidden),
-            getPreferredSuggestions: (0, AutoCache_js_1.extractStats)(this.getPreferredSuggestions),
-        };
-    }
-}
-const knownDicts = new Map();
-/**
- * create a caching dictionary
- * @param dict - Dictionary to cache the search results.
- * @param options - Search options to use.
- * @returns CachingDictionary
- */
-function createCachingDictionary(dict, options) {
-    options = (0, SpellingDictionaryMethods_js_1.canonicalSearchOptions)(options);
-    let knownOptions = knownDicts.get(options);
-    if (!knownOptions) {
-        knownOptions = new WeakMap();
-        knownDicts.set(options, knownOptions);
-    }
-    const known = knownOptions.get(dict);
-    if (known)
-        return known;
-    const cached = new CachedDict(dict, options);
-    knownOptions.set(dict, cached);
-    return cached;
-}
-exports.createCachingDictionary = createCachingDictionary;
-//# sourceMappingURL=CachingDictionary.js.map

package/dist/cjs/SpellingDictionary/FlagWordsDictionary.js

@@ -1,165 +0,0 @@
-"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.createFlagWordsDictionary = void 0;
-const sync_1 = require("@cspell/cspell-pipe/sync");
-const cspell_trie_lib_1 = require("cspell-trie-lib");
-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_js_1.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.
-     * Therefore it always returns false.
-     * @param _word - the word
-     * @param _options - options
-     * @returns always false
-     */
-    has(_word, _options) {
-        return false;
-    }
-    find(word, hasOptions) {
-        const f = super.find(word, hasOptions);
-        if (!f || !f.forbidden)
-            return undefined;
-        return f;
-    }
-    suggest() {
-        return [];
-    }
-    genSuggestions() {
-        return;
-    }
-}
-class FlagWordsDictionary {
-    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.
-     * Therefore it always returns false.
-     * @param word - the word
-     * @param options - options
-     * @returns always false
-     */
-    has(word, options) {
-        return this.dictTypos.has(word, options) || this.dictTrie?.has(word, options) || false;
-    }
-    /** A more detailed search for a word, might take longer than `has` */
-    find(word, options) {
-        const findTypos = this.dictTypos.find(word, options);
-        if (findTypos)
-            return findTypos;
-        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
-        if (this.dictTypos.isSuggestedWord(word, ignoreCase))
-            return undefined;
-        return this.dictTrie?.find(word, options);
-    }
-    isForbidden(word, ignoreCaseAndAccents = Defaults.isForbiddenIgnoreCaseAndAccents) {
-        const findResult = this.find(word, { ignoreCase: ignoreCaseAndAccents });
-        return findResult?.forbidden || false;
-    }
-    isNoSuggestWord(word, options) {
-        return this.dictTrie?.isNoSuggestWord(word, options) || this.dictTypos.isNoSuggestWord(word, options);
-    }
-    suggest(...args) {
-        const [word] = args;
-        const suggestOptions = (0, SpellingDictionaryMethods_js_1.suggestArgsToSuggestOptions)(args);
-        return this.dictTypos.suggest(word, suggestOptions);
-    }
-    getPreferredSuggestions(word) {
-        return this.dictTypos.getPreferredSuggestions(word);
-    }
-    genSuggestions() {
-        return;
-    }
-    mapWord(word) {
-        return word;
-    }
-    get size() {
-        return this.dictTypos.size + (this.dictTrie?.size || 0);
-    }
-    getErrors() {
-        return [];
-    }
-}
-const createCache = (0, AutoResolve_js_1.createAutoResolveWeakCache)();
-/**
- * Create a dictionary where all words are to be forbidden.
- * @param wordList - list of words
- * @param name
- * @param source
- * @param options
- * @returns SpellingDictionary
- */
-function createFlagWordsDictionary(wordList, name, source) {
-    return createCache.get(wordList, () => {
-        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_js_1.createTyposDictionary)(typoWords, name, source);
-        if (!trieDict)
-            return typosDict;
-        return new FlagWordsDictionary(name, source, typosDict, trieDict);
-    });
-}
-exports.createFlagWordsDictionary = createFlagWordsDictionary;
-const regExpCleanIgnore = /^(!!)+/;
-function buildTrieDict(words, name, source) {
-    const trie = (0, cspell_trie_lib_1.buildTrieFast)((0, sync_1.pipe)(words, (0, sync_1.opMap)((w) => '!' + w), (0, sync_1.opMap)((w) => w.replace(regExpCleanIgnore, ''))));
-    return new FlagWordsDictionaryTrie(trie, name, source);
-}
-function bisect(values, predicate) {
-    const t = new Set();
-    const f = new Set();
-    for (const v of values) {
-        if (predicate(v)) {
-            t.add(v);
-        }
-        else {
-            f.add(v);
-        }
-    }
-    return { t, f };
-}
-//# sourceMappingURL=FlagWordsDictionary.js.map

package/dist/cjs/SpellingDictionary/IgnoreWordsDictionary.js

@@ -1,124 +0,0 @@
-"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.createIgnoreWordsDictionary = void 0;
-const sync_1 = require("@cspell/cspell-pipe/sync");
-const cspell_trie_lib_1 = require("cspell-trie-lib");
-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) {
-        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((0, sync_1.pipe)(this.dict, (0, sync_1.opFilter)((w) => w.startsWith('~')), (0, sync_1.opMap)((w) => w.slice(1))));
-    }
-    /**
-     * A Forbidden word list does not "have" valid words.
-     * Therefore it always returns false.
-     * @param _word - the word
-     * @param _options - options
-     * @returns always false
-     */
-    has(word, options) {
-        const nWord = word.normalize(NormalizeForm);
-        if (this.dict.has(nWord))
-            return true;
-        const lcWord = nWord.toLowerCase();
-        if (this.dict.has(lcWord))
-            return true;
-        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
-        return ignoreCase && (this.dictNonStrict.has(nWord) || this.dictNonStrict.has(lcWord));
-    }
-    /** A more detailed search for a word, might take longer than `has` */
-    find(word, options) {
-        const nWord = word.normalize(NormalizeForm);
-        if (this.dict.has(nWord))
-            return { found: nWord, forbidden: false, noSuggest: true };
-        const lcWord = nWord.toLowerCase();
-        if (this.dict.has(lcWord))
-            return { found: lcWord, forbidden: false, noSuggest: true };
-        const ignoreCase = options?.ignoreCase ?? Defaults.ignoreCase;
-        if (!ignoreCase)
-            return undefined;
-        if (this.dictNonStrict.has(nWord))
-            return { found: nWord, forbidden: false, noSuggest: true };
-        return (this.dictNonStrict.has(lcWord) && { found: lcWord, forbidden: false, noSuggest: true }) || undefined;
-    }
-    isForbidden(_word, _ignoreCase) {
-        return false;
-    }
-    isNoSuggestWord(word, options) {
-        return this.has(word, options);
-    }
-    suggest() {
-        return [];
-    }
-    genSuggestions() {
-        return;
-    }
-    mapWord(word) {
-        return word;
-    }
-    get size() {
-        return this.dict.size;
-    }
-    getErrors() {
-        return [];
-    }
-}
-const createCache = (0, AutoResolve_js_1.createAutoResolveWeakCache)();
-/**
- * Create a dictionary where all words are to be ignored.
- * Ignored words override forbidden words.
- * @param wordList - list of words
- * @param name - name of dictionary
- * @param source - dictionary source
- * @returns
- */
-function createIgnoreWordsDictionary(wordList, name, source) {
-    return createCache.get(wordList, () => {
-        const testSpecialCharacters = /[*+]/;
-        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_js_1.createSpellingDictionary)(words, name, source, {
-                caseSensitive: true,
-                noSuggest: true,
-                weightMap: undefined,
-                supportNonStrictSearches: true,
-            });
-        }
-        return new IgnoreWordsDictionary(name, source, words);
-    });
-}
-exports.createIgnoreWordsDictionary = createIgnoreWordsDictionary;
-//# sourceMappingURL=IgnoreWordsDictionary.js.map

package/dist/cjs/SpellingDictionary/SpellingDictionary.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultOptions = 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; } });
-exports.defaultOptions = Object.freeze({
-    weightMap: undefined,
-});
-//# sourceMappingURL=SpellingDictionary.js.map