cspell-dictionary 6.27.0 → 6.29.0

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

package/dist/esm/SpellingDictionary/createSpellingDictionary.mjs

@@ -0,0 +1,68 @@
+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';
+const cachedDictionaries = new AutoWeakCache(_createSpellingDictionary, 64);
+const maxSetSize = 3;
+const cachedParamsByWordList = new SimpleCache(64);
+/**
+ * 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 function createSpellingDictionary(wordList, name, source, options) {
+    const params = [wordList, name, source, options];
+    if (!Array.isArray(wordList)) {
+        return _createSpellingDictionary(params);
+    }
+    const cached = cachedParamsByWordList.get(name) || new Set();
+    for (const cachedParams of cached) {
+        if (deepEqual(params, cachedParams)) {
+            return cachedDictionaries.get(cachedParams);
+        }
+    }
+    if (cached.size > maxSetSize)
+        cached.clear();
+    cached.add(params);
+    cachedParamsByWordList.set(name, cached);
+    return cachedDictionaries.get(params);
+}
+function _createSpellingDictionary(params) {
+    const [wordList, name, source, options] = params;
+    // console.log(`createSpellingDictionary ${name} ${source}`);
+    const parseOptions = { stripCaseAndAccents: options?.supportNonStrictSearches ?? true };
+    const words = parseDictionaryLines(wordList, parseOptions);
+    const trie = buildTrieFast(words);
+    const opts = { ...(options || defaultOptions) };
+    if (opts.weightMap === undefined && opts.dictionaryInformation) {
+        opts.weightMap = createWeightMapFromDictionaryInformation(opts.dictionaryInformation);
+    }
+    return new SpellingDictionaryFromTrie(trie, name, opts, source);
+}
+export function createFailedToLoadDictionary(name, source, error, options) {
+    options = options || {};
+    return {
+        name,
+        source,
+        type: 'error',
+        containsNoSuggestWords: false,
+        has: () => false,
+        find: () => undefined,
+        isNoSuggestWord: () => false,
+        isForbidden: () => false,
+        suggest: () => [],
+        mapWord: (a) => a,
+        genSuggestions: () => {
+            return;
+        },
+        size: 0,
+        options,
+        isDictionaryCaseSensitive: false,
+        getErrors: () => [error],
+    };
+}

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

@@ -0,0 +1,3 @@
+export declare const ignoreCase: true;
+export declare const isForbiddenIgnoreCaseAndAccents: false;
+//# sourceMappingURL=defaults.d.mts.map

package/dist/esm/SpellingDictionary/defaults.mjs

@@ -0,0 +1,2 @@
+export const ignoreCase = true;
+export const isForbiddenIgnoreCaseAndAccents = false;

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

@@ -0,0 +1,11 @@
+export { CachingDictionary, 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 type { DictionaryDefinitionInline, FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary.mjs';
+export { createCollection, SpellingDictionaryCollection } from './SpellingDictionaryCollection.mjs';
+export { createSpellingDictionaryFromTrieFile } from './SpellingDictionaryFromTrie.mjs';
+export { createSuggestDictionary } from './SuggestDictionary.mjs';
+export { createTyposDictionary } from './TyposDictionary.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/esm/SpellingDictionary/index.mjs

@@ -0,0 +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';

package/dist/esm/index.d.mts

@@ -0,0 +1,3 @@
+export type { CachingDictionary, FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryCollection, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary/index.mjs';
+export { createCachingDictionary, createCollection, createFailedToLoadDictionary, createFlagWordsDictionary, createForbiddenWordsDictionary, createIgnoreWordsDictionary, createInlineSpellingDictionary, createSpellingDictionary, createSpellingDictionaryFromTrieFile, createSuggestDictionary, } from './SpellingDictionary/index.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/esm/index.mjs

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

package/dist/esm/util/AutoCache.d.mts

@@ -0,0 +1,25 @@
+interface AutoCache<R> extends CacheStats {
+    (word: string): R;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    swaps: number;
+}
+declare class Cache01<R> implements CacheStats {
+    readonly maxSize: number;
+    private count;
+    private cache0;
+    private cache1;
+    hits: number;
+    misses: number;
+    swaps: number;
+    constructor(maxSize: number);
+    get(key: string): R | undefined;
+    set(key: string, value: R): this;
+}
+export declare function createCache01<R>(size: number): Cache01<R>;
+export declare function autoCache<R>(fn: (p: string) => R, size?: number): AutoCache<R>;
+export declare function extractStats(ac: AutoCache<unknown> | CacheStats): CacheStats;
+export {};
+//# sourceMappingURL=AutoCache.d.mts.map

package/dist/esm/util/AutoCache.mjs

@@ -0,0 +1,67 @@
+const CACHE_SIZE = 100;
+class Cache01 {
+    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;
+        const cache1 = this.cache1;
+        if (key in cache0) {
+            ++this.hits;
+            return cache0[key];
+        }
+        if (key in cache1) {
+            ++this.hits;
+            ++this.count;
+            const r = cache1[key];
+            cache0[key] = r;
+            return r;
+        }
+        ++this.misses;
+        return undefined;
+    }
+    set(key, value) {
+        if (this.count >= this.maxSize) {
+            this.cache1 = this.cache0;
+            this.cache0 = Object.create(null);
+            this.swaps++;
+            this.count = 0;
+        }
+        ++this.count;
+        this.cache0[key] = value;
+        return this;
+    }
+}
+export function createCache01(size) {
+    return new Cache01(size);
+}
+export function autoCache(fn, size = CACHE_SIZE) {
+    const cache = createCache01(size);
+    const ac = get;
+    ac.hits = 0;
+    ac.misses = 0;
+    ac.swaps = 0;
+    function get(k) {
+        const f = cache.get(k);
+        if (f !== undefined) {
+            ++ac.hits;
+            return f;
+        }
+        const r = fn(k);
+        cache.set(k, r);
+        ac.swaps = cache.swaps;
+        ++ac.misses;
+        return r;
+    }
+    return ac;
+}
+export function extractStats(ac) {
+    const { hits, misses, swaps } = ac;
+    return { hits, misses, swaps };
+}

package/dist/esm/util/AutoResolve.d.mts

@@ -0,0 +1,21 @@
+export declare function autoResolve<K, V>(map: Map<K, V>, key: K, resolve: (k: K) => V): V;
+export declare class AutoResolveCache<K, V> {
+    readonly map: Map<K, V>;
+    get(k: K): V | undefined;
+    get(k: K, resolve: (k: K) => V): V;
+    get(k: K, resolve?: (k: K) => V): V | undefined;
+    has(k: K): boolean;
+    set(k: K, v: V): this;
+}
+export declare function createAutoResolveCache<K, V>(): AutoResolveCache<K, V>;
+export declare function autoResolveWeak<K extends object, V>(map: WeakMap<K, V>, key: K, resolve: (k: K) => V): V;
+export declare class AutoResolveWeakCache<K extends object, V> {
+    readonly map: WeakMap<K, V>;
+    get(k: K): V | undefined;
+    get(k: K, resolve: (k: K) => V): V;
+    get(k: K, resolve?: (k: K) => V): V | undefined;
+    has(k: K): boolean;
+    set(k: K, v: V): this;
+}
+export declare function createAutoResolveWeakCache<K extends object, V>(): AutoResolveWeakCache<K, V>;
+//# sourceMappingURL=AutoResolve.d.mts.map

package/dist/esm/util/AutoResolve.mjs

@@ -0,0 +1,52 @@
+export function autoResolve(map, key, resolve) {
+    const found = map.get(key);
+    if (found !== undefined || map.has(key))
+        return found;
+    const value = resolve(key);
+    map.set(key, value);
+    return value;
+}
+export class AutoResolveCache {
+    constructor() {
+        this.map = new Map();
+    }
+    get(k, resolve) {
+        return resolve ? autoResolve(this.map, k, resolve) : this.map.get(k);
+    }
+    has(k) {
+        return this.map.has(k);
+    }
+    set(k, v) {
+        this.map.set(k, v);
+        return this;
+    }
+}
+export function createAutoResolveCache() {
+    return new AutoResolveCache();
+}
+export function autoResolveWeak(map, key, resolve) {
+    const found = map.get(key);
+    if (found !== undefined || map.has(key))
+        return found;
+    const value = resolve(key);
+    map.set(key, value);
+    return value;
+}
+export class AutoResolveWeakCache {
+    constructor() {
+        this.map = new WeakMap();
+    }
+    get(k, resolve) {
+        return resolve ? autoResolveWeak(this.map, k, resolve) : this.map.get(k);
+    }
+    has(k) {
+        return this.map.has(k);
+    }
+    set(k, v) {
+        this.map.set(k, v);
+        return this;
+    }
+}
+export function createAutoResolveWeakCache() {
+    return new AutoResolveWeakCache();
+}

package/dist/esm/util/IterableLike.d.mts

@@ -0,0 +1,4 @@
+export interface IterableLike<T> {
+    [Symbol.iterator]: () => Iterator<T> | IterableIterator<T>;
+}
+//# sourceMappingURL=IterableLike.d.mts.map

package/dist/esm/util/IterableLike.mjs

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

package/dist/esm/util/clean.d.mts

@@ -0,0 +1,7 @@
+import type { RemoveUndefined } from './types.mjs';
+/**
+ * Delete all `undefined` fields from an object.
+ * @param src - object to be cleaned
+ */
+export declare function clean<T extends object>(src: T): RemoveUndefined<T>;
+//# sourceMappingURL=clean.d.mts.map

package/dist/esm/util/clean.mjs

@@ -0,0 +1,13 @@
+/**
+ * Delete all `undefined` fields from an object.
+ * @param src - object to be cleaned
+ */
+export function clean(src) {
+    const r = src;
+    for (const key of Object.keys(r)) {
+        if (r[key] === undefined) {
+            delete r[key];
+        }
+    }
+    return r;
+}

package/dist/esm/util/regexHelper.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Escape a string so it can be used as an exact match within a RegExp.
+ * @param s - string to escape
+ * @returns - the escaped string.
+ */
+export declare function escapeRegEx(s: string): string;
+//# sourceMappingURL=regexHelper.d.mts.map

package/dist/esm/util/regexHelper.mjs

@@ -0,0 +1,8 @@
+/**
+ * Escape a string so it can be used as an exact match within a RegExp.
+ * @param s - string to escape
+ * @returns - the escaped string.
+ */
+export function escapeRegEx(s) {
+    return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+}

package/dist/esm/util/repMap.d.mts

@@ -0,0 +1,27 @@
+import type { CharacterSet, ReplaceMap } from '@cspell/cspell-types';
+export type ReplaceMapper = (src: string) => string;
+export declare function createMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): ReplaceMapper;
+declare function charsetToRepMapRegEx(charset: CharacterSet | undefined, replaceWith?: string): ReplaceMap | undefined;
+declare function createMapperRegExp(repMap: ReplaceMap): RegExp;
+interface RepTrieNode {
+    rep?: string[];
+    children?: Record<string, RepTrieNode>;
+}
+interface Edit {
+    b: number;
+    e: number;
+    r: string;
+}
+export declare function createRepMapper(repMap: ReplaceMap | undefined, ignoreCharset?: string): (word: string) => string[];
+declare function applyEdits(word: string, edits: Edit[]): string[];
+declare function calcAllEdits(root: RepTrieNode, word: string): Edit[];
+declare function createTrie(repMap: ReplaceMap | undefined, ignoreCharset?: string): RepTrieNode;
+export declare const __testing__: {
+    charsetToRepMap: typeof charsetToRepMapRegEx;
+    createMapperRegExp: typeof createMapperRegExp;
+    createTrie: typeof createTrie;
+    calcAllEdits: typeof calcAllEdits;
+    applyEdits: typeof applyEdits;
+};
+export {};
+//# sourceMappingURL=repMap.d.mts.map