cspell-dictionary 6.28.0 → 6.29.1

package/dist/esm/SpellingDictionary/SuggestDictionary.mjs

@@ -0,0 +1,97 @@
+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';
+class SuggestDictionaryImpl {
+    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));
+    }
+    /**
+     * 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;
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(_word, _options) {
+        return undefined;
+    }
+    isForbidden(_word, _ignoreCaseAndAccents) {
+        return false;
+    }
+    isNoSuggestWord(_word, _options) {
+        return false;
+    }
+    /**
+     * Determine if the word can appear in a list of suggestions.
+     * @param word - word
+     * @param ignoreCaseAndAccents - ignore case.
+     * @returns true if a word is suggested, otherwise false.
+     */
+    isSuggestedWord(word, ignoreCaseAndAccents = defaults.isForbiddenIgnoreCaseAndAccents) {
+        if (this.suggestions.has(word))
+            return true;
+        const lcWord = word.toLowerCase();
+        return ignoreCaseAndAccents && (this.suggestions.has(lcWord) || this.suggestionsLower.has(lcWord));
+    }
+    suggest(word) {
+        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+    }
+    _suggest(word) {
+        if (!(word in this.typosDef))
+            return undefined;
+        const sug = this.typosDef[word];
+        const isPreferred = true;
+        if (!sug)
+            return [];
+        if (typeof sug === 'string') {
+            return [
+                {
+                    word: sug,
+                    cost: 1,
+                    isPreferred,
+                },
+            ];
+        }
+        return sug.map((word, index) => ({ word, cost: index + 1, isPreferred }));
+    }
+    genSuggestions(collector) {
+        const sugs = this.suggest(collector.word);
+        sugs.forEach((result) => collector.add(result));
+    }
+    mapWord(word) {
+        return word;
+    }
+    getErrors() {
+        return [];
+    }
+}
+const createCache = createAutoResolveWeakCache();
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param entries - list of Typos Entries
+ * @param name - name of dictionary
+ * @param source - source
+ * @returns
+ */
+export function createSuggestDictionary(entries, name, source) {
+    return createCache.get(entries, () => {
+        const def = processEntriesToTyposDef(entries);
+        return new SuggestDictionaryImpl(name, source, def);
+    });
+}

package/dist/esm/SpellingDictionary/Terms/index.d.mts

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

package/dist/esm/SpellingDictionary/Terms/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/SpellingDictionary/Terms/terms.d.mts

@@ -0,0 +1,12 @@
+export type TermValueTypoNoSuggestions = false;
+type TermValueTypoSingleSuggestion = string;
+type TermValueTypoMultipleSuggestions = string[];
+export type TermValueTypoWithSuggestions = TermValueTypoSingleSuggestion | TermValueTypoMultipleSuggestions;
+export type TermValueTypo = TermValueTypoWithSuggestions | TermValueTypoNoSuggestions;
+export type TermValueIgnoreWord = null;
+export type TermValueOk = true;
+export type TermsDefValue = TermValueTypo | TermValueIgnoreWord | TermValueOk;
+export type TermsDefKey = string;
+export type TermsDef = Record<TermsDefKey, TermsDefValue>;
+export {};
+//# sourceMappingURL=terms.d.mts.map

package/dist/esm/SpellingDictionary/Terms/terms.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/SpellingDictionary/Typos/index.d.mts

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

package/dist/esm/SpellingDictionary/Typos/index.mjs

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

package/dist/esm/SpellingDictionary/Typos/typos.d.mts

@@ -0,0 +1,18 @@
+import type { TermsDefKey, TermValueTypo, TermValueTypoNoSuggestions, TermValueTypoWithSuggestions } from '../Terms/index.mjs';
+export type TypoValueNoSuggestions = TermValueTypoNoSuggestions;
+export type TypoValueWithSuggestions = TermValueTypoWithSuggestions;
+export type TyposDefValue = TermValueTypo;
+export type TyposDefKey = TermsDefKey;
+/**
+ * Typos Definition
+ *   key - the incorrect word
+ *   value - the suggestions.
+ */
+export type TyposDef = Record<TyposDefKey, TyposDefValue>;
+type TypoWithNoSuggestions = string;
+type TypoWithSuggestionsArray = [forbidWord: string, ...suggestions: string[]];
+type TypoWithSuggestionsObj = TyposDef;
+type TypoWithSuggestions = TypoWithSuggestionsArray | TypoWithSuggestionsObj;
+export type TypoEntry = TypoWithNoSuggestions | TypoWithSuggestions;
+export {};
+//# sourceMappingURL=typos.d.mts.map

package/dist/esm/SpellingDictionary/Typos/typos.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/SpellingDictionary/Typos/typosParser.d.mts

@@ -0,0 +1,34 @@
+import type { TypoEntry, TyposDef } from './typos.mjs';
+export declare function createTyposDefFromEntries(entries: Iterable<TypoEntry>): TyposDef;
+export declare function sanitizeIntoTypoDef(dirtyDef: TyposDef | Record<string, unknown> | unknown): TyposDef | undefined;
+/**
+ * Parse Typos Entries
+ *
+ * Format:
+ * - `word:suggestion`
+ * - `word->suggestion`
+ * - `word: first, second, third suggestions`
+ *
+ * Note:
+ * ```plaintext
+ * yellow:blue, green
+ * ```
+ * Is the same as multiple entries with the same key and different suggestions.
+ * ```plaintext
+ * yellow:blue
+ * yellow:green
+ * ```
+ *
+ * Used to process entries found in a `cspell.json` file.
+ * @param entries - entries to process
+ * @returns a TyposDef
+ */
+export declare function processEntriesToTyposDef(entries: Iterable<TypoEntry> | TyposDef | Record<string, unknown>): TyposDef;
+/**
+ * Tries to parse an entry.
+ * @param line - any valid TypoEntry.
+ * @returns a valid TypoEntry
+ */
+export declare function parseTyposLine(line: TypoEntry): TypoEntry | undefined;
+export declare function parseTyposFile(content: string): TyposDef;
+//# sourceMappingURL=typosParser.d.mts.map

package/dist/esm/SpellingDictionary/Typos/typosParser.mjs

@@ -0,0 +1,131 @@
+import assert from 'assert';
+import { appendToDef, createTyposDef } from './util.mjs';
+function assertString(v) {
+    assert(typeof v === 'string', 'A string was expected.');
+    return true;
+}
+const suggestionsSeparator = /[,]/;
+const typoSuggestionsSeparator = /:|->/;
+const typoEntrySeparator = /[\n;]/;
+const inlineComment = /#.*/gm;
+export function createTyposDefFromEntries(entries) {
+    const def = Object.create(null);
+    for (const entry of entries) {
+        appendToDef(def, entry);
+    }
+    return def;
+}
+function normalize(s) {
+    return s.normalize();
+}
+function trimAndFilter(lines) {
+    return lines
+        .map((s) => s.trim())
+        .filter((s) => !!s)
+        .map(normalize);
+}
+function cleanSugs(rawSugs) {
+    const sugs = trimAndFilter(rawSugs);
+    return sugs.length === 1 ? sugs[0] : sugs.length ? sugs : false;
+}
+function splitSuggestionsValue(value) {
+    return cleanSugs(value.split(suggestionsSeparator));
+}
+export function sanitizeIntoTypoDef(dirtyDef) {
+    if (!dirtyDef || typeof dirtyDef !== 'object')
+        return undefined;
+    const def = createTyposDef();
+    for (const [rawKey, value] of Object.entries(dirtyDef)) {
+        const key = normalize(rawKey.trim());
+        if (!key)
+            continue;
+        if (typeof value === 'string') {
+            def[key] = splitSuggestionsValue(value);
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const sugs = cleanSugs(value.filter(assertString));
+            def[key] = sugs;
+            continue;
+        }
+        assert(value === false, 'Unexpected suggestion type.');
+        def[key] = false;
+    }
+    return def;
+}
+/**
+ * Parse Typos Entries
+ *
+ * Format:
+ * - `word:suggestion`
+ * - `word->suggestion`
+ * - `word: first, second, third suggestions`
+ *
+ * Note:
+ * ```plaintext
+ * yellow:blue, green
+ * ```
+ * Is the same as multiple entries with the same key and different suggestions.
+ * ```plaintext
+ * yellow:blue
+ * yellow:green
+ * ```
+ *
+ * Used to process entries found in a `cspell.json` file.
+ * @param entries - entries to process
+ * @returns a TyposDef
+ */
+export function processEntriesToTyposDef(entries) {
+    const def = isIterable(entries) ? reduceToTyposDef(entries) : entries;
+    const result = sanitizeIntoTypoDef(def);
+    assert(result);
+    return result;
+}
+function reduceToTyposDef(entries) {
+    const def = createTyposDef();
+    for (const entry of entries) {
+        appendToDef(def, parseTyposLine(entry));
+    }
+    return def;
+}
+/**
+ * Tries to parse an entry.
+ * @param line - any valid TypoEntry.
+ * @returns a valid TypoEntry
+ */
+export function parseTyposLine(line) {
+    if (!line)
+        return undefined;
+    if (typeof line === 'string') {
+        const def = createTyposDef();
+        for (const subEntry of splitIntoLines(line)) {
+            const [left, right] = splitEntry(subEntry);
+            const typo = left.trim();
+            if (!right)
+                return typo;
+            const sugs = splitSuggestionsValue(right);
+            def[typo] = sugs;
+        }
+        return def;
+    }
+    if (Array.isArray(line)) {
+        const [key, ...sugs] = line.filter(assertString).map((s) => s.trim());
+        if (!key)
+            return undefined;
+        return [key, ...sugs];
+    }
+    return sanitizeIntoTypoDef(line);
+}
+function splitIntoLines(content) {
+    return trimAndFilter(normalize(content).split(typoEntrySeparator));
+}
+function splitEntry(line) {
+    return line.split(typoSuggestionsSeparator, 2);
+}
+export function parseTyposFile(content) {
+    const lines = splitIntoLines(content.replace(inlineComment, ''));
+    return reduceToTyposDef(lines);
+}
+function isIterable(v) {
+    return Symbol.iterator in v;
+}

package/dist/esm/SpellingDictionary/Typos/util.d.mts

@@ -0,0 +1,31 @@
+import type { TypoEntry, TyposDef, TyposDefKey, TyposDefValue } from './typos.mjs';
+export declare function mergeDefEntry(targetDef: TyposDef, key: string, value: TyposDefValue): TyposDef;
+/**
+ * Merge in place the entries `fromDef` into `targetDef`
+ * @param targetDef - the target
+ * @param fromDef - the source
+ * @returns the target
+ */
+export declare function mergeDef(targetDef: TyposDef, fromDef: TyposDef): TyposDef;
+/**
+ * Append an entry to a TyposDef.
+ * @param def - modified in place
+ * @param entry- entry to add.
+ * @returns def
+ */
+export declare function appendToDef(def: TyposDef, entry: TypoEntry | undefined): TyposDef;
+export declare function createTyposDef(entries?: Iterable<[TyposDefKey, TyposDefValue]>): TyposDef;
+/**
+ * Extract all suggestions.
+ * @param typosDef - the def
+ * @returns the set of suggestions.
+ */
+export declare function extractAllSuggestions(typosDef: TyposDef): Set<string>;
+/**
+ * Extract all words that have been explicitly ignore because they contains the `ignorePrefix`.
+ * @param typosDef - the def
+ * @param ignorePrefix - prefix
+ * @returns set of ignored words with the prefix removed.
+ */
+export declare function extractIgnoreValues(typosDef: TyposDef, ignorePrefix: string): Set<string>;
+//# sourceMappingURL=util.d.mts.map

package/dist/esm/SpellingDictionary/Typos/util.mjs

@@ -0,0 +1,105 @@
+import { opConcatMap, opFilter, pipe } from '@cspell/cspell-pipe/sync';
+function normalizeTyposDefValue(value) {
+    if (!value)
+        return false;
+    if (typeof value === 'string')
+        return value;
+    const unique = [...new Set(value)];
+    return unique.length > 1 ? unique : unique.length === 1 ? unique[0] : false;
+}
+export function mergeDefEntry(targetDef, key, value) {
+    const curValue = targetDef[key];
+    if (!curValue) {
+        targetDef[key] = normalizeTyposDefValue(value);
+        return targetDef;
+    }
+    if (!value)
+        return targetDef;
+    const newValue = Array.isArray(curValue) ? curValue : [curValue];
+    if (Array.isArray(value)) {
+        newValue.push(...value);
+    }
+    else {
+        newValue.push(value);
+    }
+    targetDef[key] = normalizeTyposDefValue(newValue);
+    return targetDef;
+}
+/**
+ * Merge in place the entries `fromDef` into `targetDef`
+ * @param targetDef - the target
+ * @param fromDef - the source
+ * @returns the target
+ */
+export function mergeDef(targetDef, fromDef) {
+    for (const key of Object.keys(fromDef)) {
+        mergeDefEntry(targetDef, key, fromDef[key]);
+    }
+    return targetDef;
+}
+/**
+ * Append an entry to a TyposDef.
+ * @param def - modified in place
+ * @param entry- entry to add.
+ * @returns def
+ */
+export function appendToDef(def, entry) {
+    if (!entry)
+        return def;
+    if (typeof entry === 'string') {
+        if (!def[entry]) {
+            def[entry] = false;
+        }
+        return def;
+    }
+    if (Array.isArray(entry)) {
+        const [key, ...sugs] = entry.map((s) => s.trim());
+        if (!key)
+            return def;
+        const s = sugs.map((s) => s.trim()).filter((s) => !!s);
+        return mergeDefEntry(def, key, s);
+    }
+    return mergeDef(def, entry);
+}
+export function createTyposDef(entries) {
+    const def = Object.create(null);
+    if (!entries)
+        return def;
+    for (const [key, value] of entries) {
+        def[key] = isDefined(value) ? value : false;
+    }
+    return def;
+}
+/**
+ * Extract all suggestions.
+ * @param typosDef - the def
+ * @returns the set of suggestions.
+ */
+export function extractAllSuggestions(typosDef) {
+    const allSugs = pipe(Object.values(typosDef), opFilter(hasSuggestions), opConcatMap((v) => (Array.isArray(v) ? v : [v])));
+    return new Set(allSugs);
+}
+/**
+ * Extract all words that have been explicitly ignore because they contains the `ignorePrefix`.
+ * @param typosDef - the def
+ * @param ignorePrefix - prefix
+ * @returns set of ignored words with the prefix removed.
+ */
+export function extractIgnoreValues(typosDef, ignorePrefix) {
+    const pfxLen = ignorePrefix.length;
+    return new Set(Object.keys(typosDef)
+        .filter((k) => k.startsWith(ignorePrefix))
+        .map((k) => k.slice(pfxLen)));
+}
+function isDefined(v) {
+    return v !== undefined && v !== null;
+}
+function isString(v) {
+    return typeof v === 'string';
+}
+function isArray(v) {
+    return Array.isArray(v);
+}
+function hasSuggestions(v) {
+    return isString(v) || isArray(v);
+}

package/dist/esm/SpellingDictionary/TyposDictionary.d.mts

@@ -0,0 +1,21 @@
+import type { IgnoreCaseOption, SpellingDictionary } from './SpellingDictionary.mjs';
+import { type TypoEntry, type TyposDef } from './Typos/index.mjs';
+export interface TyposDictionary extends SpellingDictionary {
+    isForbidden(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
+    /**
+     * Determine if the word can appear in a list of suggestions.
+     * @param word - word
+     * @param ignoreCaseAndAccents - ignore case.
+     * @returns true if a word is suggested, otherwise false.
+     */
+    isSuggestedWord(word: string, ignoreCaseAndAccents?: IgnoreCaseOption): boolean;
+}
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param entries - list of Typos Entries
+ * @param name - name of dictionary
+ * @param source - source
+ * @returns
+ */
+export declare function createTyposDictionary(entries: readonly string[] | TyposDef | Iterable<TypoEntry>, name: string, source: string): TyposDictionary;
+//# sourceMappingURL=TyposDictionary.d.mts.map

package/dist/esm/SpellingDictionary/TyposDictionary.mjs

@@ -0,0 +1,129 @@
+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';
+class TyposDictionaryImpl {
+    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);
+        this.ignoreWords = new Set(pipe(this.explicitIgnoreWords, opAppend(ignoreList || [])));
+        this.suggestionsLower = new Set(pipe(this.suggestions, mapperRemoveCaseAndAccents));
+        this.containsNoSuggestWords = this.ignoreWords.size > 0;
+    }
+    /**
+     * 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;
+    }
+    /** A more detailed search for a word, might take longer than `has` */
+    find(word, options) {
+        const result = this._findForms(word, options?.ignoreCase ?? defaults.ignoreCase);
+        if (result === false)
+            return undefined;
+        const { found, ignore } = result;
+        return { found, forbidden: !ignore, noSuggest: ignore };
+    }
+    _findForms(word, ignoreCaseAndAccents) {
+        const lcWord = word.toLowerCase();
+        if (this.ignoreWords.has(word)) {
+            return { found: word, ignore: true };
+        }
+        if (this.suggestions.has(word)) {
+            return false;
+        }
+        if (ignoreCaseAndAccents) {
+            if (this.suggestionsLower.has(lcWord)) {
+                return false;
+            }
+            if (this.ignoreWords.has(lcWord)) {
+                return { found: lcWord, ignore: true };
+            }
+        }
+        if (word in this.typosDef)
+            return { found: word, ignore: false };
+        if (lcWord in this.typosDef)
+            return { found: lcWord, ignore: false };
+        return false;
+    }
+    isForbidden(word, ignoreCaseAndAccents = defaults.isForbiddenIgnoreCaseAndAccents) {
+        const found = this._findForms(word, ignoreCaseAndAccents);
+        return found !== false && !found.ignore;
+    }
+    isNoSuggestWord(word, options) {
+        const result = this.find(word, options);
+        return result?.noSuggest ?? false;
+    }
+    /**
+     * Determine if the word can appear in a list of suggestions.
+     * @param word - word
+     * @param ignoreCaseAndAccents - ignore case.
+     * @returns true if a word is suggested, otherwise false.
+     */
+    isSuggestedWord(word, ignoreCaseAndAccents = defaults.isForbiddenIgnoreCaseAndAccents) {
+        if (this.suggestions.has(word))
+            return true;
+        const lcWord = word.toLowerCase();
+        return ignoreCaseAndAccents && (this.suggestions.has(lcWord) || this.suggestionsLower.has(lcWord));
+    }
+    suggest(word) {
+        return this._suggest(word) || this._suggest(word.toLowerCase()) || [];
+    }
+    _suggest(word) {
+        if (this.ignoreWords.has(word))
+            return [];
+        if (!(word in this.typosDef))
+            return undefined;
+        const sug = this.typosDef[word];
+        const isPreferred = true;
+        if (!sug)
+            return [];
+        if (typeof sug === 'string') {
+            return [
+                {
+                    word: sug,
+                    cost: 1,
+                    isPreferred,
+                },
+            ];
+        }
+        return sug.map((word, index) => ({ word, cost: index + 1, isPreferred }));
+    }
+    genSuggestions(collector) {
+        const sugs = this.suggest(collector.word);
+        sugs.forEach((result) => collector.add(result));
+    }
+    mapWord(word) {
+        return word;
+    }
+    getErrors() {
+        return [];
+    }
+}
+const createCache = createAutoResolveWeakCache();
+/**
+ * Create a dictionary where all words are to be forbidden.
+ * @param entries - list of Typos Entries
+ * @param name - name of dictionary
+ * @param source - source
+ * @returns
+ */
+export function createTyposDictionary(entries, name, source) {
+    return createCache.get(entries, () => {
+        const def = processEntriesToTyposDef(entries);
+        return new TyposDictionaryImpl(name, source, def);
+    });
+}

package/dist/esm/SpellingDictionary/createInlineSpellingDictionary.d.mts

@@ -0,0 +1,3 @@
+import type { DictionaryDefinitionInline, SpellingDictionary } from './SpellingDictionary.mjs';
+export declare function createInlineSpellingDictionary(inlineDict: DictionaryDefinitionInline, source: string): SpellingDictionary;
+//# sourceMappingURL=createInlineSpellingDictionary.d.mts.map

package/dist/esm/SpellingDictionary/createInlineSpellingDictionary.mjs

@@ -0,0 +1,20 @@
+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';
+const cache = createAutoResolveWeakCache();
+export function createInlineSpellingDictionary(inlineDict, source) {
+    return cache.get(inlineDict, () => {
+        const { words, flagWords, ignoreWords, suggestWords, name } = inlineDict;
+        const dictSources = [
+            words && createSpellingDictionary(words, name + '-words', source, inlineDict),
+            flagWords && createFlagWordsDictionary(flagWords, name + '-flag-words', source),
+            ignoreWords && createIgnoreWordsDictionary(ignoreWords, name + '-ignore-words', source),
+            suggestWords && createSuggestDictionary(suggestWords, name + '-suggest', source),
+        ].filter(isDefined);
+        return createCollection(dictSources, name, source);
+    });
+}

package/dist/esm/SpellingDictionary/createSpellingDictionary.d.mts

@@ -0,0 +1,23 @@
+import type { IterableLike } from '../util/IterableLike.mjs';
+import type { DictionaryInfo, SpellingDictionary, SpellingDictionaryOptions } from './SpellingDictionary.mjs';
+/**
+ * Create a SpellingDictionary
+ * @param wordList - list of words
+ * @param name - name of dictionary
+ * @param source - filename or uri
+ * @param options - dictionary options
+ * @returns a Spelling Dictionary
+ */
+export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options?: SpellingDictionaryOptions | undefined): SpellingDictionary;
+export interface SpellingDictionaryLoadError extends Error {
+    /** The Error Name */
+    readonly name: string;
+    /** Possible Cause */
+    readonly cause?: Error | undefined;
+    /** Message to Display */
+    readonly message: string;
+    /** Dictionary Information */
+    readonly info: DictionaryInfo;
+}
+export declare function createFailedToLoadDictionary(name: string, source: string, error: Error, options?: SpellingDictionaryOptions | undefined): SpellingDictionary;
+//# sourceMappingURL=createSpellingDictionary.d.mts.map