cspell-dictionary 6.28.0 → 6.29.1

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

package/dist/esm/util/repMap.mjs

@@ -0,0 +1,152 @@
+import { expandCharacterSet } from 'cspell-trie-lib';
+import { escapeRegEx } from './regexHelper.mjs';
+import { isDefined } from './util.mjs';
+export function createMapper(repMap, ignoreCharset) {
+    if (!repMap && !ignoreCharset)
+        return (a) => a;
+    repMap = repMap || [];
+    const charsetMap = charsetToRepMapRegEx(ignoreCharset);
+    if (charsetMap) {
+        repMap = repMap.concat(charsetMap);
+    }
+    const filteredMap = repMap.filter(([match, _]) => !!match);
+    if (!filteredMap.length) {
+        return (a) => a;
+    }
+    const regEx = createMapperRegExp(repMap);
+    const values = repMap.filter(([match, _]) => !!match).map(([_, into]) => into);
+    function resolve(m, ...matches) {
+        const index = matches.findIndex((a) => !!a);
+        return 0 <= index && index < values.length ? values[index] : m;
+    }
+    return function (s) {
+        return s.replace(regEx, resolve);
+    };
+}
+function charsetToRepMapRegEx(charset, replaceWith = '') {
+    if (!charset)
+        return undefined;
+    return charset
+        .split('|')
+        .map((chars) => `[${chars.replace(/[\][\\]/g, '\\$&')}]`)
+        .map((map) => [map, replaceWith]);
+}
+function charsetToRepMap(charset, replaceWith = '') {
+    if (!charset)
+        return undefined;
+    return charset
+        .split('|')
+        .flatMap((chars) => [...expandCharacterSet(chars)])
+        .map((char) => [char, replaceWith]);
+}
+function expandReplaceMap(repMap) {
+    return repMap.flatMap(([from, replaceWith]) => from.split('|').map((w) => [w, replaceWith]));
+}
+function createMapperRegExp(repMap) {
+    const filteredMap = repMap.filter(([match, _]) => !!match);
+    if (!filteredMap.length) {
+        return /$^/;
+    }
+    const regExStr = filteredMap
+        .map(([from, _]) => from)
+        // make sure it compiles into a regex
+        .map((s) => {
+        try {
+            // fix up any nested ()
+            const r = s.match(/\(/) ? s.replace(/\((?=.*\))/g, '(?:').replace(/\(\?:\?/g, '(?') : s;
+            new RegExp(r);
+            s = r;
+        }
+        catch (err) {
+            return escapeRegEx(s);
+        }
+        return s;
+    })
+        .map((s) => `(${s})`)
+        .join('|');
+    const regEx = new RegExp(regExStr, 'g');
+    return regEx;
+}
+export function createRepMapper(repMap, ignoreCharset) {
+    if (!repMap && !ignoreCharset)
+        return (word) => [word];
+    const trie = createTrie(repMap, ignoreCharset);
+    // const root = createTrie(repMap, ignoreCharset);
+    return (word) => {
+        const edits = calcAllEdits(trie, word);
+        return applyEdits(word, edits);
+    };
+}
+function applyEdits(word, edits) {
+    if (!edits.length)
+        return [word];
+    // Prepare
+    const letterEdits = [];
+    for (let i = 0; i < word.length; ++i) {
+        letterEdits[i] = { edits: [{ b: i, e: i + 1, r: word[i] }], suffixes: [] };
+    }
+    letterEdits[word.length] = { edits: [], suffixes: [''] };
+    // Add edits
+    for (const edit of edits) {
+        const le = letterEdits[edit.b];
+        le.edits.push(edit);
+    }
+    // Apply edits in reverse
+    for (let i = word.length - 1; i >= 0; --i) {
+        const le = letterEdits[i];
+        const sfx = le.suffixes;
+        for (const edit of le.edits) {
+            const pfx = edit.r;
+            const nSfx = letterEdits[edit.e].suffixes;
+            for (const s of nSfx) {
+                sfx.push(pfx + s);
+            }
+        }
+    }
+    const results = new Set(letterEdits[0].suffixes);
+    return [...results];
+}
+function calcAllEdits(root, word) {
+    const edits = [];
+    function walk(node, b, e) {
+        if (node.rep) {
+            node.rep.forEach((r) => edits.push({ b, e, r }));
+        }
+        if (e === word.length || !node.children)
+            return;
+        const n = node.children[word[e]];
+        if (!n)
+            return;
+        walk(n, b, e + 1);
+    }
+    for (let i = 0; i < word.length; ++i) {
+        walk(root, i, i);
+    }
+    return edits;
+}
+function createTrie(repMap, ignoreCharset) {
+    const combined = [repMap, charsetToRepMap(ignoreCharset)].filter(isDefined).flatMap((a) => a);
+    const expanded = expandReplaceMap(combined);
+    const trieRoot = Object.create(null);
+    expanded.forEach(([match, replaceWith]) => addToTrie(trieRoot, match, replaceWith));
+    return trieRoot;
+}
+function addToTrie(node, match, replaceWith) {
+    while (match) {
+        const children = node.children || (node.children = Object.create(null));
+        const k = match[0];
+        const childNode = children[k] || (children[k] = Object.create(null));
+        node = childNode;
+        match = match.slice(1);
+    }
+    const s = new Set(node.rep || []);
+    s.add(replaceWith);
+    node.rep = [...s];
+}
+export const __testing__ = {
+    charsetToRepMap: charsetToRepMapRegEx,
+    createMapperRegExp,
+    createTrie,
+    calcAllEdits,
+    applyEdits,
+};

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

@@ -0,0 +1,46 @@
+export declare class SimpleWeakCache<K extends object, T> {
+    readonly size: number;
+    private L0;
+    private L1;
+    private L2;
+    private sizeL0;
+    constructor(size: number);
+    has(key: K): boolean;
+    get(key: K): T | undefined;
+    set(key: K, value: T): void;
+    private _set;
+    private caches;
+    private rotate;
+}
+export declare class AutoWeakCache<K extends object, T> extends SimpleWeakCache<K, T> {
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T, size: number);
+    get(key: K): T;
+}
+/**
+ * This will cache between `size` and 3 x `size` items.
+ * It has three stashes, L0, L1, and L2. Each can contain `size` items.
+ * When L0 is full, its items are given to L1 and L1's are given to L2, and L2 is empties.
+ *
+ * The stashes are searched in order, L0...L2. If an item is found in L1, or L2, it is
+ * promoted to L0.
+ */
+export declare class SimpleCache<K, T> {
+    readonly size: number;
+    private L0;
+    private L1;
+    private L2;
+    constructor(size: number);
+    has(key: K): boolean;
+    get(key: K): T | undefined;
+    set(key: K, value: T): void;
+    private _set;
+    private caches;
+    private rotate;
+}
+export declare class AutoCache<K, T> extends SimpleCache<K, T> {
+    readonly factory: (key: K) => T;
+    constructor(factory: (key: K) => T, size: number);
+    get(key: K): T;
+}
+//# sourceMappingURL=simpleCache.d.mts.map