cspell-dictionary 6.9.0

package/dist/util/MinHeapQueue.js

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

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

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

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

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

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

package/dist/util/TextRange.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.extractRangeText = exports.excludeRanges = exports.findMatchingRangesForPatterns = exports.unionRanges = exports.findMatchingRanges = void 0;
+const GS = __importStar(require("gensequence"));
+function toMatchRangeWithText(m) {
+    const index = m.index || 0;
+    const _text = m[0];
+    return {
+        startPos: index,
+        endPos: index + _text.length,
+        text: _text,
+    };
+}
+function findMatchingRanges(pattern, text) {
+    if (pattern.source === '.*') {
+        return [{ startPos: 0, endPos: text.length }];
+    }
+    const regex = new RegExp(pattern);
+    if (!regex.global) {
+        const m = text.match(regex);
+        if (!m)
+            return [];
+        return [toMatchRangeWithText(m)];
+    }
+    return [...text.matchAll(regex)].map(toMatchRangeWithText);
+}
+exports.findMatchingRanges = findMatchingRanges;
+function compareRanges(a, b) {
+    return a.startPos - b.startPos || a.endPos - b.endPos;
+}
+function unionRanges(ranges) {
+    return makeSortedMatchRangeArray([..._unionRanges(ranges)]);
+}
+exports.unionRanges = unionRanges;
+function* _unionRanges(ranges) {
+    const sortedRanges = sortMatchRangeArray(ranges);
+    if (!sortedRanges.length)
+        return;
+    let { startPos, endPos } = sortedRanges[0];
+    for (const r of ranges) {
+        if (r.startPos > endPos) {
+            yield { startPos, endPos };
+            startPos = r.startPos;
+            endPos = r.endPos;
+            continue;
+        }
+        endPos = Math.max(endPos, r.endPos);
+    }
+    if (startPos < endPos) {
+        yield { startPos, endPos };
+    }
+}
+function findMatchingRangesForPatterns(patterns, text) {
+    const matchedPatterns = GS.genSequence(patterns).concatMap((pattern) => findMatchingRanges(pattern, text));
+    return unionRanges(matchedPatterns.toArray());
+}
+exports.findMatchingRangesForPatterns = findMatchingRangesForPatterns;
+/**
+ * Create a new set of positions that have the excluded position ranges removed.
+ */
+function excludeRanges(includeRanges, excludeRanges) {
+    return [..._excludeRanges(sortMatchRangeArray(includeRanges), sortMatchRangeArray(excludeRanges))];
+}
+exports.excludeRanges = excludeRanges;
+function* _excludeRanges(includeRanges, excludeRanges) {
+    if (!includeRanges.length)
+        return;
+    if (!excludeRanges.length) {
+        yield* includeRanges;
+        return;
+    }
+    let exIndex = 0;
+    const limit = excludeRanges.length;
+    for (const incRange of includeRanges) {
+        const endPos = incRange.endPos;
+        let startPos = incRange.startPos;
+        for (; exIndex < limit; ++exIndex) {
+            const ex = excludeRanges[exIndex];
+            if (ex.startPos >= endPos)
+                break;
+            if (ex.endPos <= startPos)
+                continue;
+            if (ex.startPos > startPos) {
+                yield { startPos, endPos: ex.startPos };
+            }
+            startPos = ex.endPos;
+            if (startPos >= endPos)
+                break;
+        }
+        if (startPos < endPos) {
+            yield { startPos, endPos };
+        }
+    }
+}
+function extractRangeText(text, ranges) {
+    return ranges.map(({ startPos, endPos }) => ({
+        startPos,
+        endPos,
+        text: text.slice(startPos, endPos),
+    }));
+}
+exports.extractRangeText = extractRangeText;
+const SymSortedMatchRangeArray = Symbol('SortedMatchRangeArray');
+function sortMatchRangeArray(values) {
+    if (isSortedMatchRangeArray(values))
+        return values;
+    return makeSortedMatchRangeArray(values.sort(compareRanges));
+}
+function isSortedMatchRangeArray(a) {
+    return a[SymSortedMatchRangeArray] === true;
+}
+function makeSortedMatchRangeArray(sortedValues) {
+    const sorted = sortedValues;
+    sorted[SymSortedMatchRangeArray] = true;
+    Object.freeze(sorted);
+    return sorted;
+}
+exports.__testing__ = {
+    makeSortedMatchRangeArray,
+};
+//# sourceMappingURL=TextRange.js.map

package/dist/util/clean.d.ts

@@ -0,0 +1,7 @@
+import type { RemoveUndefined } from './types';
+/**
+ * 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.ts.map

package/dist/util/clean.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clean = void 0;
+/**
+ * Delete all `undefined` fields from an object.
+ * @param src - object to be cleaned
+ */
+function clean(src) {
+    const r = src;
+    for (const key of Object.keys(r)) {
+        if (r[key] === undefined) {
+            delete r[key];
+        }
+    }
+    return r;
+}
+exports.clean = clean;
+//# sourceMappingURL=clean.js.map

package/dist/util/debugPerf.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Measure and log result.
+ * @param fn - function to measure.
+ * @param message - message to log
+ * @param callback - called when the function has finished.
+ * @returns a function
+ */
+export declare function perfFn<P extends any[], R>(fn: (...args: P) => R, message: string, callback?: (m: string, elapsedMs: number) => void): (...args: P) => R;
+//# sourceMappingURL=debugPerf.d.ts.map

package/dist/util/debugPerf.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perfFn = void 0;
+const timer_1 = require("./timer");
+/**
+ * Measure and log result.
+ * @param fn - function to measure.
+ * @param message - message to log
+ * @param callback - called when the function has finished.
+ * @returns a function
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function perfFn(fn, message, callback = (message, time) => console.error(`${message}: ${time.toFixed(2)}ms`)) {
+    return (...args) => {
+        const timer = (0, timer_1.createTimer)();
+        const r = fn(...args);
+        callback(message, timer.elapsed());
+        return r;
+    };
+}
+exports.perfFn = perfFn;
+//# sourceMappingURL=debugPerf.js.map

package/dist/util/errors.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+declare function getTypeOf(t: unknown): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export declare function isErrnoException(e: unknown): e is NodeJS.ErrnoException;
+export declare function isError(e: unknown): e is Error;
+export declare function toError(e: unknown, errorFactory?: UnknownErrorConstructor): Error;
+interface UnknownErrorConstructor {
+    new (cause: unknown): Error;
+}
+export declare class UnknownError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+export declare const __testing__: {
+    getTypeOf: typeof getTypeOf;
+};
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/util/errors.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__testing__ = exports.UnknownError = exports.toError = exports.isError = exports.isErrnoException = void 0;
+const util_1 = require("util");
+function getTypeOf(t) {
+    return typeof t;
+}
+const allowStringOrUndefined = {
+    string: true,
+    undefined: true,
+};
+const allowNumberOrUndefined = {
+    number: true,
+    undefined: true,
+};
+function isErrnoException(e) {
+    if (!e || typeof e !== 'object')
+        return false;
+    if (!isError(e))
+        return false;
+    const ex = e;
+    return (typeof ex.errno in allowNumberOrUndefined &&
+        typeof ex.code in allowStringOrUndefined &&
+        typeof ex.path in allowStringOrUndefined);
+}
+exports.isErrnoException = isErrnoException;
+function isError(e) {
+    if (e instanceof Error)
+        return true;
+    if (!e || typeof e !== 'object')
+        return false;
+    const ex = e;
+    return typeof ex.name == 'string' && typeof ex.message == 'string' && typeof ex.stack in allowStringOrUndefined;
+}
+exports.isError = isError;
+function toError(e, errorFactory = UnknownError) {
+    if (isError(e))
+        return e;
+    return new errorFactory(e);
+}
+exports.toError = toError;
+class UnknownError extends Error {
+    constructor(cause) {
+        super((0, util_1.format)(cause));
+        this.cause = cause;
+    }
+}
+exports.UnknownError = UnknownError;
+exports.__testing__ = {
+    getTypeOf,
+};
+//# sourceMappingURL=errors.js.map

package/dist/util/fileReader.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+export declare function readLines(filename: string, encoding?: BufferEncoding): Promise<IterableIterator<string>>;
+export declare function readLinesSync(filename: string, encoding?: BufferEncoding): string[];
+//# sourceMappingURL=fileReader.d.ts.map

package/dist/util/fileReader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLinesSync = exports.readLines = void 0;
+const cspell_io_1 = require("cspell-io");
+const iterableIteratorLib_1 = require("./iterableIteratorLib");
+async function readLines(filename, encoding = 'utf8') {
+    try {
+        const content = await (0, cspell_io_1.readFile)(filename, encoding);
+        return (0, iterableIteratorLib_1.toIterableIterator)(content.split(/\r?\n/g));
+    }
+    catch (e) {
+        return Promise.reject(e);
+    }
+}
+exports.readLines = readLines;
+function readLinesSync(filename, encoding = 'utf8') {
+    const content = (0, cspell_io_1.readFileSync)(filename, encoding);
+    return content.split(/\r?\n/g);
+}
+exports.readLinesSync = readLinesSync;
+//# sourceMappingURL=fileReader.js.map

package/dist/util/iterableIteratorLib.d.ts

@@ -0,0 +1,4 @@
+import { IterableLike } from './IterableLike';
+export declare function toIterableIterator<T>(i: IterableLike<T>): IterableIterator<T>;
+export declare function concatIterables<T>(...iterables: IterableLike<T>[]): IterableIterator<T>;
+//# sourceMappingURL=iterableIteratorLib.d.ts.map

package/dist/util/iterableIteratorLib.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatIterables = exports.toIterableIterator = void 0;
+function* toIterableIterator(i) {
+    yield* i;
+}
+exports.toIterableIterator = toIterableIterator;
+function* concatIterables(...iterables) {
+    for (const i of iterables) {
+        yield* i;
+    }
+}
+exports.concatIterables = concatIterables;
+//# sourceMappingURL=iterableIteratorLib.js.map

package/dist/util/logger.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+/// <reference types="node" />
+declare type Console = typeof console;
+export interface Logger {
+    log: Console['log'];
+    warn: Console['warn'];
+    error: Console['error'];
+}
+/**
+ * See `Console.error`
+ */
+export declare function logError(...args: any[]): void;
+/**
+ * See `Console.warn`
+ */
+export declare function logWarning(...args: any[]): void;
+/**
+ * See `Console.log`
+ */
+export declare function log(...args: any[]): void;
+/**
+ * Set the global cspell-lib logger
+ * @param logger - a logger like `console`
+ * @returns the old logger.
+ */
+export declare function setLogger(logger: Logger): Logger;
+/**
+ * Get the current cspell-lib logger.
+ * @returns the current logger.
+ */
+export declare function getLogger(): Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map