cspell-dictionary 6.9.0 → 6.10.1

package/dist/util/Memorizer.d.ts

@@ -1,65 +0,0 @@
-/** 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

@@ -1,138 +0,0 @@
-"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

@@ -1,23 +0,0 @@
-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

package/dist/util/MinHeapQueue.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.MinHeapQueue = void 0;
-function swap(t, i, j) {
-    const a = t[i];
-    t[i] = t[j];
-    t[j] = a;
-}
-function addToHeap(t, c, compare) {
-    t.push(c);
-    let b = t.length - 1;
-    let a = (b - 1) >> 1;
-    while (b > 0 && compare(t[a], t[b]) >= 0) {
-        swap(t, a, b);
-        b = a;
-        a = (b - 1) >> 1;
-    }
-}
-function takeFromHeap(t, compare) {
-    const result = t[0];
-    if (t.length <= 1) {
-        t.length = 0;
-        return result;
-    }
-    t[0] = t[t.length - 1];
-    t.length -= 1;
-    const m = t.length - 1;
-    let i = 0;
-    let j = i * 2 + 1;
-    while (j < m) {
-        const a = j;
-        const b = j + 1;
-        const k = compare(t[a], t[b]) < 0 ? a : b;
-        if (compare(t[i], t[k]) <= 0) {
-            break;
-        }
-        swap(t, i, k);
-        i = k;
-        j = i * 2 + 1;
-    }
-    if (j === m) {
-        if (compare(t[i], t[j]) > 0) {
-            swap(t, i, j);
-        }
-    }
-    return result;
-}
-/**
- * MinHeapQueue - based upon a minHeap array.
- */
-class MinHeapQueue {
-    constructor(compare) {
-        this.compare = compare;
-        this.values = [];
-    }
-    add(t) {
-        addToHeap(this.values, t, this.compare);
-        return this;
-    }
-    get length() {
-        return this.values.length;
-    }
-    dequeue() {
-        return takeFromHeap(this.values, this.compare);
-    }
-    concat(i) {
-        for (const v of i) {
-            this.add(v);
-        }
-        return this;
-    }
-    next() {
-        const value = this.dequeue();
-        return value !== undefined
-            ? {
-                value,
-            }
-            : {
-                value,
-                done: true,
-            };
-    }
-    [Symbol.iterator]() {
-        return this;
-    }
-    clone() {
-        const clone = new MinHeapQueue(this.compare);
-        clone.values = this.values.concat();
-        return clone;
-    }
-}
-exports.MinHeapQueue = MinHeapQueue;
-exports.__testing__ = {
-    addToHeap,
-    takeFromHeap,
-};
-//# sourceMappingURL=MinHeapQueue.js.map

package/dist/util/PairingHeap.d.ts

@@ -1,32 +0,0 @@
-export interface PairHeapNode<T> {
-    /** Value */
-    v: T;
-    /** Siblings */
-    s: PairHeapNode<T> | undefined;
-    /** Children */
-    c: PairHeapNode<T> | undefined;
-}
-export declare type CompareFn<T> = (a: T, b: T) => number;
-export declare class PairingHeap<T> implements IterableIterator<T> {
-    readonly compare: CompareFn<T>;
-    private _heap;
-    private _size;
-    constructor(compare: CompareFn<T>);
-    add(v: T): this;
-    dequeue(): T | undefined;
-    concat(i: Iterable<T>): this;
-    next(): IteratorResult<T>;
-    peek(): T | undefined;
-    [Symbol.iterator](): IterableIterator<T>;
-    get length(): number;
-}
-declare function insert<T>(compare: CompareFn<T>, heap: PairHeapNode<T> | undefined, v: T): PairHeapNode<T>;
-declare function merge<T>(compare: CompareFn<T>, a: PairHeapNode<T>, b: PairHeapNode<T>): PairHeapNode<T>;
-declare function mergeSiblings<T>(compare: CompareFn<T>, n: PairHeapNode<T>): PairHeapNode<T>;
-export declare const heapMethods: {
-    insert: typeof insert;
-    merge: typeof merge;
-    mergeSiblings: typeof mergeSiblings;
-};
-export {};
-//# sourceMappingURL=PairingHeap.d.ts.map

package/dist/util/PairingHeap.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.heapMethods = exports.PairingHeap = void 0;
-class PairingHeap {
-    constructor(compare) {
-        this.compare = compare;
-        this._size = 0;
-    }
-    add(v) {
-        this._heap = insert(this.compare, this._heap, v);
-        ++this._size;
-        return this;
-    }
-    dequeue() {
-        const n = this.next();
-        if (n.done)
-            return undefined;
-        return n.value;
-    }
-    concat(i) {
-        for (const v of i) {
-            this.add(v);
-        }
-        return this;
-    }
-    next() {
-        if (!this._heap) {
-            return { value: undefined, done: true };
-        }
-        const value = this._heap.v;
-        --this._size;
-        this._heap = removeHead(this.compare, this._heap);
-        return { value };
-    }
-    peek() {
-        return this._heap?.v;
-    }
-    [Symbol.iterator]() {
-        return this;
-    }
-    get length() {
-        return this._size;
-    }
-}
-exports.PairingHeap = PairingHeap;
-function removeHead(compare, heap) {
-    if (!heap || !heap.c)
-        return undefined;
-    return mergeSiblings(compare, heap.c);
-}
-function insert(compare, heap, v) {
-    const n = {
-        v,
-        s: undefined,
-        c: undefined,
-    };
-    if (!heap || compare(v, heap.v) <= 0) {
-        n.c = heap;
-        return n;
-    }
-    n.s = heap.c;
-    heap.c = n;
-    return heap;
-}
-function merge(compare, a, b) {
-    if (compare(a.v, b.v) <= 0) {
-        a.s = undefined;
-        b.s = a.c;
-        a.c = b;
-        return a;
-    }
-    b.s = undefined;
-    a.s = b.c;
-    b.c = a;
-    return b;
-}
-function mergeSiblings(compare, n) {
-    if (!n.s)
-        return n;
-    const s = n.s;
-    const ss = s.s;
-    const m = merge(compare, n, s);
-    return ss ? merge(compare, m, mergeSiblings(compare, ss)) : m;
-}
-exports.heapMethods = {
-    insert,
-    merge,
-    mergeSiblings,
-};
-//# sourceMappingURL=PairingHeap.js.map

package/dist/util/TextMap.d.ts

@@ -1,15 +0,0 @@
-import { MappedText } from '@cspell/cspell-types';
-import { Range } from '@cspell/cspell-types/Parser';
-/**
- * Extract a substring from a TextMap.
- * @param textMap - A text range with an optional map
- * @param extractRange - The range in the original document to extract
- * @returns The TextMap covering extractRange
- */
-export declare function extractTextMapRangeOrigin(textMap: MappedText, extractRange: Range): MappedText;
-interface WithRange {
-    readonly range: Range;
-}
-export declare function doesIntersect(textMap: WithRange, rangeOrigin: Range): boolean;
-export {};
-//# sourceMappingURL=TextMap.d.ts.map

package/dist/util/TextMap.js

@@ -1,62 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.doesIntersect = exports.extractTextMapRangeOrigin = void 0;
-const assert_1 = __importDefault(require("assert"));
-/**
- * Extract a substring from a TextMap.
- * @param textMap - A text range with an optional map
- * @param extractRange - The range in the original document to extract
- * @returns The TextMap covering extractRange
- */
-function extractTextMapRangeOrigin(textMap, extractRange) {
-    const { text: srcTxt, range: srcRange, map: srcMap } = textMap;
-    const [r0, r1] = srcRange;
-    const startOrig = Math.min(Math.max(extractRange[0], r0), r1);
-    const endOrig = Math.min(Math.max(extractRange[1], r0), r1);
-    const a = startOrig - r0;
-    const b = endOrig - r0;
-    const range = [startOrig, endOrig];
-    if (!srcMap || !srcMap.length || a === b) {
-        const text = srcTxt.slice(a, b);
-        return { text, range };
-    }
-    (0, assert_1.default)((srcMap.length & 1) === 0, 'Map must be pairs of values.');
-    const mapLen = srcMap.length;
-    const mapEndSrc = srcMap[mapLen - 2];
-    const mapEndDst = srcMap[mapLen - 1];
-    const endDiff = srcTxt.length - mapEndDst;
-    const head = !srcMap[0] && !srcMap[1] ? [] : [0, 0];
-    const tail = [mapEndSrc + endDiff, mapEndDst + endDiff];
-    const sMap = head.concat(srcMap).concat(tail);
-    let idx = 0;
-    for (; idx < sMap.length && a >= sMap[idx]; idx += 2) {
-        // empty
-    }
-    const aIdx = idx;
-    idx -= 2;
-    const a0 = a - sMap[idx];
-    const a1 = a0 + sMap[idx + 1];
-    for (; idx < sMap.length && b > sMap[idx]; idx += 2) {
-        // empty
-    }
-    const bIdx = idx;
-    const b0 = b - sMap[idx];
-    const b1 = b0 + sMap[idx + 1];
-    const text = srcTxt.slice(a1, b1);
-    if (bIdx === aIdx) {
-        return { text, range };
-    }
-    const ab = [a0, a1];
-    const map = sMap.slice(aIdx, bIdx + 2).map((v, i) => v - ab[i & 1]);
-    return { text, range, map };
-}
-exports.extractTextMapRangeOrigin = extractTextMapRangeOrigin;
-function doesIntersect(textMap, rangeOrigin) {
-    const r = textMap.range;
-    return r[0] < rangeOrigin[1] && r[1] > rangeOrigin[0];
-}
-exports.doesIntersect = doesIntersect;
-//# sourceMappingURL=TextMap.js.map

package/dist/util/TextRange.d.ts

@@ -1,28 +0,0 @@
-export interface MatchRange {
-    startPos: number;
-    endPos: number;
-}
-export interface MatchRangeWithText extends MatchRange {
-    text: string;
-}
-export interface MatchRangeOptionalText extends MatchRange {
-    text?: string;
-}
-export declare function findMatchingRanges(pattern: RegExp, text: string): MatchRangeOptionalText[];
-export declare function unionRanges(ranges: MatchRange[]): MatchRange[];
-export declare function findMatchingRangesForPatterns(patterns: RegExp[], text: string): MatchRange[];
-/**
- * Create a new set of positions that have the excluded position ranges removed.
- */
-export declare function excludeRanges(includeRanges: MatchRange[], excludeRanges: MatchRange[]): MatchRange[];
-export declare function extractRangeText(text: string, ranges: MatchRange[]): MatchRangeWithText[];
-declare const SymSortedMatchRangeArray: unique symbol;
-interface SortedMatchRangeArray extends Array<MatchRange> {
-    [SymSortedMatchRangeArray]: true;
-}
-declare function makeSortedMatchRangeArray(sortedValues: MatchRange[]): SortedMatchRangeArray;
-export declare const __testing__: {
-    makeSortedMatchRangeArray: typeof makeSortedMatchRangeArray;
-};
-export {};
-//# sourceMappingURL=TextRange.d.ts.map