cspell-dictionary 6.9.0

package/dist/SpellingDictionary/SpellingDictionaryMethods.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testMethods__ = exports.createWeightMapFromDictionaryInformation = exports.suggestArgsToSuggestOptions = exports.hasOptionToSearchOption = exports.wordDictionaryFormsCollector = exports.wordSuggestForms = exports.wordSuggestFormsArray = exports.wordSearchForms = exports.defaultNumSuggestions = exports.suggestionCollector = exports.impersonateCollector = void 0;
+const cspell_trie_lib_1 = require("cspell-trie-lib");
+const clean_1 = require("../util/clean");
+const gensequence_1 = require("gensequence");
+const text_1 = require("../util/text");
+var cspell_trie_lib_2 = require("cspell-trie-lib");
+Object.defineProperty(exports, "impersonateCollector", { enumerable: true, get: function () { return cspell_trie_lib_2.impersonateCollector; } });
+Object.defineProperty(exports, "suggestionCollector", { enumerable: true, get: function () { return cspell_trie_lib_2.suggestionCollector; } });
+exports.defaultNumSuggestions = 10;
+function wordSearchFormsArray(word, isDictionaryCaseSensitive, ignoreCase) {
+    return [...wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase)];
+}
+function wordSearchForms(word, isDictionaryCaseSensitive, ignoreCase) {
+    const forms = new Set();
+    word = word.normalize('NFC');
+    const wordLc = word.toLowerCase();
+    if (ignoreCase) {
+        if (isDictionaryCaseSensitive) {
+            forms.add(wordLc);
+        }
+        else {
+            forms.add(wordLc);
+            // Legacy remove any unbound accents
+            forms.add(wordLc.replace(/\p{M}/gu, ''));
+        }
+    }
+    else {
+        if (isDictionaryCaseSensitive) {
+            forms.add(word);
+            forms.add(wordLc);
+            // HOUSE -> House, house
+            if ((0, text_1.isUpperCase)(word)) {
+                forms.add((0, text_1.ucFirst)(wordLc));
+            }
+        }
+        else {
+            forms.add(wordLc);
+            // Legacy remove any unbound accents
+            forms.add(wordLc.replace(/\p{M}/gu, ''));
+        }
+    }
+    return forms;
+}
+exports.wordSearchForms = wordSearchForms;
+function wordSuggestFormsArray(word) {
+    return [...wordSuggestForms(word)];
+}
+exports.wordSuggestFormsArray = wordSuggestFormsArray;
+function wordSuggestForms(word) {
+    word = word.normalize('NFC');
+    const forms = new Set([word]);
+    const wordLc = word.toLowerCase();
+    forms.add(wordLc);
+    return forms;
+}
+exports.wordSuggestForms = wordSuggestForms;
+function* wordDictionaryForms(word, prefixNoCase) {
+    word = word.normalize('NFC');
+    const wordLc = word.toLowerCase();
+    const wordNa = (0, text_1.removeAccents)(word);
+    const wordLcNa = (0, text_1.removeAccents)(wordLc);
+    function wf(w, p = '') {
+        return { w, p };
+    }
+    const prefix = prefixNoCase;
+    yield wf(word);
+    yield wf(wordNa, prefix);
+    yield wf(wordLc, prefix);
+    yield wf(wordLcNa, prefix);
+}
+function wordDictionaryFormsCollector(prefixNoCase) {
+    const knownWords = new Set();
+    return (word) => {
+        return (0, gensequence_1.genSequence)(wordDictionaryForms(word, prefixNoCase))
+            .filter((w) => !knownWords.has(w.w))
+            .map((w) => w.p + w.w)
+            .filter((w) => !knownWords.has(w))
+            .map((w) => (knownWords.add(w), w));
+    };
+}
+exports.wordDictionaryFormsCollector = wordDictionaryFormsCollector;
+const DEFAULT_HAS_OPTIONS = Object.freeze({});
+function hasOptionToSearchOption(opt) {
+    return !opt ? DEFAULT_HAS_OPTIONS : opt;
+}
+exports.hasOptionToSearchOption = hasOptionToSearchOption;
+function suggestArgsToSuggestOptions(args) {
+    const [_word, options, compoundMethod, numChanges, ignoreCase] = args;
+    const suggestOptions = typeof options === 'object'
+        ? options
+        : (0, clean_1.clean)({
+            numSuggestions: options,
+            compoundMethod,
+            numChanges,
+            ignoreCase,
+            includeTies: undefined,
+            timeout: undefined,
+        });
+    return suggestOptions;
+}
+exports.suggestArgsToSuggestOptions = suggestArgsToSuggestOptions;
+function createWeightMapFromDictionaryInformation(di) {
+    return di ? (0, cspell_trie_lib_1.mapDictionaryInformationToWeightMap)(di) : undefined;
+}
+exports.createWeightMapFromDictionaryInformation = createWeightMapFromDictionaryInformation;
+exports.__testMethods__ = {
+    wordSearchForms,
+    wordSearchFormsArray,
+    wordDictionaryForms,
+    wordDictionaryFormsCollector,
+};
+//# sourceMappingURL=SpellingDictionaryMethods.js.map

package/dist/SpellingDictionary/charset.d.ts

@@ -0,0 +1,3 @@
+import { CharacterSet } from '@cspell/cspell-types';
+export declare function charsetToRegExp(charset: CharacterSet | undefined): RegExp | undefined;
+//# sourceMappingURL=charset.d.ts.map

package/dist/SpellingDictionary/charset.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.charsetToRegExp = void 0;
+function charsetToRegExp(charset) {
+    if (!charset)
+        return undefined;
+    try {
+        const reg = `[${charset.replace(/[\][\\]/g, '\\$&')}]`;
+        return new RegExp(reg, 'g');
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+exports.charsetToRegExp = charsetToRegExp;
+//# sourceMappingURL=charset.js.map

package/dist/SpellingDictionary/createSpellingDictionary.d.ts

@@ -0,0 +1,17 @@
+import { IterableLike } from '../util/IterableLike';
+import { SpellingDictionary, SpellingDictionaryOptions, DictionaryInfo } from './SpellingDictionary';
+export declare function createSpellingDictionary(wordList: readonly string[] | IterableLike<string>, name: string, source: string, options: SpellingDictionaryOptions | undefined): SpellingDictionary;
+export declare function createForbiddenWordsDictionary(wordList: readonly 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(error: SpellingDictionaryLoadError): SpellingDictionary;
+export declare function createSpellingDictionaryLoadError(errorName: string, message: string, info: DictionaryInfo, cause?: Error): SpellingDictionaryLoadError;
+//# sourceMappingURL=createSpellingDictionary.d.ts.map

package/dist/SpellingDictionary/createSpellingDictionary.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpellingDictionaryLoadError = exports.createFailedToLoadDictionary = exports.createForbiddenWordsDictionary = exports.createSpellingDictionary = void 0;
+const cspell_trie_lib_1 = require("cspell-trie-lib");
+const fast_equals_1 = require("fast-equals");
+const gensequence_1 = require("gensequence");
+const simpleCache_1 = require("../util/simpleCache");
+const SpellingDictionaryFromTrie_1 = require("./SpellingDictionaryFromTrie");
+const SpellingDictionaryMethods_1 = require("./SpellingDictionaryMethods");
+const defaultOptions = Object.freeze({
+    weightMap: undefined,
+});
+const cachedDictionaries = new simpleCache_1.AutoWeakCache(_createSpellingDictionary, 64);
+const maxSetSize = 3;
+const cachedParamsByWordList = new simpleCache_1.SimpleCache(64);
+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 ((0, fast_equals_1.deepEqual)(params, cachedParams)) {
+            return cachedDictionaries.get(cachedParams);
+        }
+    }
+    if (cached.size > maxSetSize)
+        cached.clear();
+    cached.add(params);
+    cachedParamsByWordList.set(name, cached);
+    return cachedDictionaries.get(params);
+}
+exports.createSpellingDictionary = createSpellingDictionary;
+function _createSpellingDictionary(params) {
+    const [wordList, name, source, options] = params;
+    // console.log(`createSpellingDictionary ${name} ${source}`);
+    const parseOptions = { stripCaseAndAccents: options?.supportNonStrictSearches ?? true };
+    const words = (0, cspell_trie_lib_1.parseDictionaryLines)(wordList, parseOptions);
+    const trie = (0, cspell_trie_lib_1.buildTrieFast)(words);
+    const opts = { ...(options || defaultOptions) };
+    if (opts.weightMap === undefined && opts.dictionaryInformation) {
+        opts.weightMap = (0, SpellingDictionaryMethods_1.createWeightMapFromDictionaryInformation)(opts.dictionaryInformation);
+    }
+    return new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, opts, source);
+}
+function createForbiddenWordsDictionary(wordList, name, source, options) {
+    // console.log(`createSpellingDictionary ${name} ${source}`);
+    const words = (0, cspell_trie_lib_1.parseDictionaryLines)(wordList.concat(wordList.map((a) => a.toLowerCase())), {
+        stripCaseAndAccents: !options?.noSuggest,
+    });
+    const forbidWords = gensequence_1.operators.map((w) => '!' + w)(words);
+    const trie = (0, cspell_trie_lib_1.buildTrieFast)(forbidWords);
+    return new SpellingDictionaryFromTrie_1.SpellingDictionaryFromTrie(trie, name, options || defaultOptions, source);
+}
+exports.createForbiddenWordsDictionary = createForbiddenWordsDictionary;
+function createFailedToLoadDictionary(error) {
+    const { name, source, options } = error.info;
+    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],
+    };
+}
+exports.createFailedToLoadDictionary = createFailedToLoadDictionary;
+function createSpellingDictionaryLoadError(errorName, message, info, cause) {
+    const err = {
+        name: errorName,
+        message,
+        info,
+        cause,
+    };
+    const stack = cause?.stack;
+    stack && (err.stack = stack);
+    return err;
+}
+exports.createSpellingDictionaryLoadError = createSpellingDictionaryLoadError;
+//# sourceMappingURL=createSpellingDictionary.js.map

package/dist/SpellingDictionary/index.d.ts

@@ -0,0 +1,4 @@
+export { createForbiddenWordsDictionary, createSpellingDictionary } from './createSpellingDictionary';
+export type { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
+export { createCollection } from './SpellingDictionaryCollection';
+//# sourceMappingURL=index.d.ts.map

package/dist/SpellingDictionary/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCollection = exports.createSpellingDictionary = exports.createForbiddenWordsDictionary = void 0;
+var createSpellingDictionary_1 = require("./createSpellingDictionary");
+Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createForbiddenWordsDictionary; } });
+Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return createSpellingDictionary_1.createSpellingDictionary; } });
+var SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
+Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return SpellingDictionaryCollection_1.createCollection; } });
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createCollection, createForbiddenWordsDictionary, createSpellingDictionary } from './SpellingDictionary';
+export type { FindOptions, FindResult, HasOptions, SearchOptions, SpellingDictionary, SpellingDictionaryOptions, SuggestionCollector, SuggestionResult, SuggestOptions, } from './SpellingDictionary';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpellingDictionary = exports.createForbiddenWordsDictionary = exports.createCollection = void 0;
+var SpellingDictionary_1 = require("./SpellingDictionary");
+Object.defineProperty(exports, "createCollection", { enumerable: true, get: function () { return SpellingDictionary_1.createCollection; } });
+Object.defineProperty(exports, "createForbiddenWordsDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createForbiddenWordsDictionary; } });
+Object.defineProperty(exports, "createSpellingDictionary", { enumerable: true, get: function () { return SpellingDictionary_1.createSpellingDictionary; } });
+//# sourceMappingURL=index.js.map

package/dist/util/Comparable.d.ts

@@ -0,0 +1,20 @@
+export declare type Comparable = number | string | boolean | undefined | null | Date;
+export declare type ComparableFilter<T> = T extends Comparable ? T : never;
+export declare type ComparablePropertyNames<T> = {
+    [K in keyof T]: T[K] extends Comparable ? K : never;
+}[keyof T];
+export declare type ComparableProperties<T> = Pick<T, ComparablePropertyNames<T>>;
+export declare type CompareArg<T> = ComparablePropertyNames<T> | ((t: T) => Comparable);
+export declare type CompareFn<T> = (a: T, b: T) => number;
+export declare function compareBy<T>(extract: CompareArg<T>, ...extractors: CompareArg<T>[]): CompareFn<T>;
+export declare function compareBy<T>(extract: CompareArg<T>): CompareFn<T>;
+export declare function compareBy<T>(extract1: CompareArg<T>, extract2: CompareArg<T>): CompareFn<T>;
+export declare function compareBy<T>(extract1: CompareArg<T>, extract2: CompareArg<T>, extract3: CompareArg<T>): CompareFn<T>;
+export declare function compareByRev<T>(extract: CompareArg<T>, ...extractors: CompareArg<T>[]): CompareFn<T>;
+export declare function compareByRev<T>(extract: CompareArg<T>): CompareFn<T>;
+export declare function compareByRev<T>(extract1: CompareArg<T>, extract2: CompareArg<T>): CompareFn<T>;
+export declare function compareByRev<T>(extract1: CompareArg<T>, extract2: CompareArg<T>, extract3: CompareArg<T>): CompareFn<T>;
+export declare function compareEach<T>(...compareFn: CompareFn<T>[]): CompareFn<T>;
+export declare function compare<T>(a: ComparableFilter<T>, b: ComparableFilter<T>): number;
+export declare function reverse<T>(fn: CompareFn<T>): CompareFn<T>;
+//# sourceMappingURL=Comparable.d.ts.map

package/dist/util/Comparable.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverse = exports.compare = exports.compareEach = exports.compareByRev = exports.compareBy = void 0;
+function compareBy(extract, ...extractors) {
+    const compareFns = [extract, ...extractors]
+        .map((ex) => (typeof ex === 'function' ? ex : (t) => t[ex]))
+        .map((ex) => (a, b) => _compare(ex(a), ex(b)));
+    return compareEach(...compareFns);
+}
+exports.compareBy = compareBy;
+function compareByRev(extract, ...extractors) {
+    return reverse(compareBy(extract, ...extractors));
+}
+exports.compareByRev = compareByRev;
+function compareEach(...compareFn) {
+    return (a, b) => {
+        for (const fn of compareFn) {
+            const r = fn(a, b);
+            if (r) {
+                return r;
+            }
+        }
+        return 0;
+    };
+}
+exports.compareEach = compareEach;
+function _compare(a, b) {
+    if (a === b)
+        return 0;
+    if (a === undefined)
+        return 1;
+    if (b === undefined)
+        return -1;
+    if (a === null)
+        return 1;
+    if (b === null)
+        return -1;
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function compare(a, b) {
+    return _compare(a, b);
+}
+exports.compare = compare;
+function reverse(fn) {
+    return (a, b) => {
+        const r = fn(a, b);
+        return r ? -r : 0;
+    };
+}
+exports.reverse = reverse;
+//# sourceMappingURL=Comparable.js.map

package/dist/util/FreqCounter.d.ts

@@ -0,0 +1,16 @@
+import { IterableLike } from './IterableLike';
+export declare class FreqCounter<T> {
+    private _total;
+    readonly _counters: Map<T, number>;
+    get total(): number;
+    get counters(): Map<T, number>;
+    getCount(key: T): number | undefined;
+    getFreq(key: T): number;
+    addKeyCount(key: T, count: number): this;
+    addKey(key: T): this;
+    addKeys(keys: IterableLike<T>): void;
+    addKeyCounts(values: IterableLike<[T, number]>): void;
+    merge(...freqCounters: FreqCounter<T>[]): FreqCounter<T>;
+    static create<T>(values?: IterableLike<T>): FreqCounter<T>;
+}
+//# sourceMappingURL=FreqCounter.d.ts.map

package/dist/util/FreqCounter.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreqCounter = void 0;
+class FreqCounter {
+    constructor() {
+        this._total = 0;
+        this._counters = new Map();
+    }
+    get total() {
+        return this._total;
+    }
+    get counters() {
+        return this._counters;
+    }
+    getCount(key) {
+        return this._counters.get(key);
+    }
+    getFreq(key) {
+        return (this.getCount(key) || 0) / (this._total || 1);
+    }
+    addKeyCount(key, count) {
+        this._total += count;
+        this._counters.set(key, (this._counters.get(key) || 0) + count);
+        return this;
+    }
+    addKey(key) {
+        return this.addKeyCount(key, 1);
+    }
+    addKeys(keys) {
+        for (const key of keys) {
+            this.addKey(key);
+        }
+    }
+    addKeyCounts(values) {
+        for (const pair of values) {
+            this.addKeyCount(pair[0], pair[1]);
+        }
+    }
+    merge(...freqCounters) {
+        for (const fc of freqCounters) {
+            this.addKeyCounts(fc._counters);
+        }
+        return this;
+    }
+    static create(values) {
+        const fc = new FreqCounter();
+        fc.addKeys(values || []);
+        return fc;
+    }
+}
+exports.FreqCounter = FreqCounter;
+//# sourceMappingURL=FreqCounter.js.map

package/dist/util/IterableLike.d.ts

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

package/dist/util/IterableLike.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IterableLike.js.map

package/dist/util/Memorizer.d.ts

@@ -0,0 +1,65 @@
+/** Only types that can be easily turned into strings */
+declare type P0 = string | number | boolean | RegExp | undefined;
+declare type Primitive = P0 | P0[];
+/**
+ * Memorize the result of a function call to be returned on later calls with the same parameters.
+ *
+ * Note: The parameters are converted into a string: `key = args.join('>!@[')`
+ *
+ * For speed, it keeps two caches, L0 and L1. Each cache can contain up to `size` values. But that actual number
+ * of cached values is between `size + 1` and `size * 2`.
+ *
+ * Caches are NOT sorted. Items are added to L0 until it is full. Once it is full, L1 takes over L0's values and L0 is cleared.
+ *
+ * If an item is not found in L0, L1 is checked before calling the `fn` and the resulting value store in L0.
+ *
+ * @param fn - function to be called.
+ * @param size - size of cache
+ */
+export declare function memorizer<F extends (...args: Primitive[]) => any, Args extends Parameters<F> = Parameters<F>, R extends ReturnType<F> = ReturnType<F>>(fn: F, size?: number): (...args: Args) => R;
+/**
+ * Memorize the result of a function call to be returned on later calls with the same parameters.
+ *
+ * Note: `keyFn` is use to convert the function parameters into a string to look up in the cache.
+ *
+ * For speed, it keeps two caches, L0 and L1. Each cache can contain up to `size` values. But that actual number
+ * of cached values is between `size + 1` and `size * 2`.
+ *
+ * Caches are NOT sorted. Items are added to L0 until it is full. Once it is full, L1 takes over L0's values and L0 is cleared.
+ *
+ * If an item is not found in L0, L1 is checked before calling the `fn` and the resulting value store in L0.
+ *
+ * @param fn - function to be memorized
+ * @param keyFn - extracts a `key` value from the arguments to `fn` to be used as the key to the cache
+ * @param size - size of the cache.
+ * @returns A function
+ */
+export declare function memorizerKeyBy<F extends (...args: any[]) => any, Args extends Parameters<F> = Parameters<F>, R extends ReturnType<F> = ReturnType<F>>(fn: F, keyFn: (...args: Args) => string, size?: number): (...args: Args) => R;
+/**
+ * Create a function that memorizes the last call. If the next call is called with the same arguments, the
+ * the last value is returned.
+ * @param fn - function to memorize
+ * @returns a new function.
+ */
+export declare function memorizeLastCall<T>(fn: (...p: []) => T): (...p: []) => T;
+export declare function memorizeLastCall<T, K0>(fn: (...p: [K0]) => T): (...p: [K0]) => T;
+export declare function memorizeLastCall<T, K0, K1>(fn: (...p: [K0, K1]) => T): (...p: [K0, K1]) => T;
+export declare function memorizeLastCall<T, K0, K1, K2>(fn: (...p: [K0, K1, K2]) => T): (...p: [K0, K1, K2]) => T;
+export declare function memorizeLastCall<T, K0, K1, K2, K3>(fn: (...p: [K0, K1, K2, K3]) => T): (...p: [K0, K1, K2, K3]) => T;
+export declare function memorizeLastCall<T, K>(fn: (...p: [...K[]]) => T): (...p: [...K[]]) => T;
+/**
+ * Creates a function that will call `fn` exactly once when invoked and remember the value returned.
+ * All subsequent calls will return exactly same value.
+ * @param fn - function to call
+ * @returns a new function
+ */
+export declare function callOnce<T>(fn: () => T): () => T;
+/**
+ * Create a function that will memorize all calls to `fn` to ensure that `fn` is
+ * called exactly once for each unique set of arguments.
+ * @param fn - function to memorize
+ * @returns a function
+ */
+export declare function memorizerAll<K extends any[], T>(fn: (...p: K) => T): (...p: K) => T;
+export {};
+//# sourceMappingURL=Memorizer.d.ts.map

package/dist/util/Memorizer.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memorizerAll = exports.callOnce = exports.memorizeLastCall = exports.memorizerKeyBy = exports.memorizer = void 0;
+const util_1 = require("./util");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const defaultSize = 50000;
+/**
+ * Memorize the result of a function call to be returned on later calls with the same parameters.
+ *
+ * Note: The parameters are converted into a string: `key = args.join('>!@[')`
+ *
+ * For speed, it keeps two caches, L0 and L1. Each cache can contain up to `size` values. But that actual number
+ * of cached values is between `size + 1` and `size * 2`.
+ *
+ * Caches are NOT sorted. Items are added to L0 until it is full. Once it is full, L1 takes over L0's values and L0 is cleared.
+ *
+ * If an item is not found in L0, L1 is checked before calling the `fn` and the resulting value store in L0.
+ *
+ * @param fn - function to be called.
+ * @param size - size of cache
+ */
+function memorizer(fn, size) {
+    return memorizerKeyBy(fn, (...args) => args.join('>!@['), size);
+}
+exports.memorizer = memorizer;
+/**
+ * Memorize the result of a function call to be returned on later calls with the same parameters.
+ *
+ * Note: `keyFn` is use to convert the function parameters into a string to look up in the cache.
+ *
+ * For speed, it keeps two caches, L0 and L1. Each cache can contain up to `size` values. But that actual number
+ * of cached values is between `size + 1` and `size * 2`.
+ *
+ * Caches are NOT sorted. Items are added to L0 until it is full. Once it is full, L1 takes over L0's values and L0 is cleared.
+ *
+ * If an item is not found in L0, L1 is checked before calling the `fn` and the resulting value store in L0.
+ *
+ * @param fn - function to be memorized
+ * @param keyFn - extracts a `key` value from the arguments to `fn` to be used as the key to the cache
+ * @param size - size of the cache.
+ * @returns A function
+ */
+function memorizerKeyBy(fn, keyFn, size = defaultSize) {
+    let count = 0;
+    let cacheL0 = Object.create(null);
+    let cacheL1 = Object.create(null);
+    return (...args) => {
+        const key = keyFn(...args);
+        if (key in cacheL0)
+            return cacheL0[key];
+        const v = key in cacheL1 ? cacheL1[key] : fn(...args);
+        if (count >= size) {
+            cacheL1 = cacheL0;
+            cacheL0 = Object.create(null);
+            count = 0;
+        }
+        cacheL0[key] = v;
+        ++count;
+        return v;
+    };
+}
+exports.memorizerKeyBy = memorizerKeyBy;
+function memorizeLastCall(fn) {
+    let last;
+    return (...p) => {
+        if (last && (0, util_1.isArrayEqual)(last.args, p)) {
+            return last.value;
+        }
+        const args = p;
+        const value = fn(...args);
+        last = { args, value };
+        return value;
+    };
+}
+exports.memorizeLastCall = memorizeLastCall;
+/**
+ * Creates a function that will call `fn` exactly once when invoked and remember the value returned.
+ * All subsequent calls will return exactly same value.
+ * @param fn - function to call
+ * @returns a new function
+ */
+function callOnce(fn) {
+    let last;
+    return () => {
+        if (last) {
+            return last.value;
+        }
+        last = {
+            value: fn(),
+        };
+        return last.value;
+    };
+}
+exports.callOnce = callOnce;
+/**
+ * Create a function that will memorize all calls to `fn` to ensure that `fn` is
+ * called exactly once for each unique set of arguments.
+ * @param fn - function to memorize
+ * @returns a function
+ */
+function memorizerAll(fn) {
+    const r = {};
+    function find(p) {
+        let n = r;
+        for (const k of p) {
+            if (!n)
+                break;
+            n = n.c?.get(k);
+        }
+        return n;
+    }
+    function set(p, v) {
+        let n = r;
+        for (const k of p) {
+            const c = n.c?.get(k);
+            if (c) {
+                n = c;
+                continue;
+            }
+            const r = {};
+            n.c = n.c || new Map();
+            n.c.set(k, r);
+            n = r;
+        }
+        n.v = v;
+    }
+    return (...p) => {
+        const f = find(p);
+        if (f && 'v' in f) {
+            return f.v;
+        }
+        const v = fn(...p);
+        set(p, v);
+        return v;
+    };
+}
+exports.memorizerAll = memorizerAll;
+//# sourceMappingURL=Memorizer.js.map

package/dist/util/MinHeapQueue.d.ts

@@ -0,0 +1,23 @@
+declare function addToHeap<T>(t: T[], c: T, compare: (a: T, b: T) => number): void;
+declare function takeFromHeap<T>(t: T[], compare: (a: T, b: T) => number): T | undefined;
+/**
+ * MinHeapQueue - based upon a minHeap array.
+ */
+export declare class MinHeapQueue<T> implements IterableIterator<T> {
+    readonly compare: (a: T, b: T) => number;
+    private values;
+    constructor(compare: (a: T, b: T) => number);
+    add(t: T): MinHeapQueue<T>;
+    get length(): number;
+    dequeue(): T | undefined;
+    concat(i: Iterable<T>): MinHeapQueue<T>;
+    next(): IteratorResult<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+    clone(): MinHeapQueue<T>;
+}
+export declare const __testing__: {
+    addToHeap: typeof addToHeap;
+    takeFromHeap: typeof takeFromHeap;
+};
+export {};
+//# sourceMappingURL=MinHeapQueue.d.ts.map