cspell-dictionary 6.9.0 → 6.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-dictionary",
-  "version": "6.9.0",
+  "version": "6.10.0",
   "description": "A spelling dictionary library useful for checking words and getting suggestions.",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -38,10 +38,11 @@
     "node": ">=14"
   },
   "dependencies": {
-    "@cspell/cspell-pipe": "workspace:^",
-    "@cspell/cspell-types": "workspace:^",
-    "cspell-trie-lib": "workspace:^",
+    "@cspell/cspell-pipe": "^6.10.0",
+    "@cspell/cspell-types": "^6.10.0",
+    "cspell-trie-lib": "^6.10.0",
     "fast-equals": "^4.0.3",
     "gensequence": "^4.0.2"
-  }
+  },
+  "gitHead": "244f2ff310aa64bdb41cf93e85ba9e9f35c2b937"
 }

package/dist/SpellingDictionary/Dictionaries.d.ts

@@ -1,9 +0,0 @@
-import { CSpellSettingsInternal, DictionaryDefinitionInternal } from '../Models/CSpellSettingsInternalDef';
-import { SpellingDictionary } from './SpellingDictionary';
-import { SpellingDictionaryCollection } from './SpellingDictionaryCollection';
-export declare function loadDictionaryDefs(defsToLoad: DictionaryDefinitionInternal[]): Promise<SpellingDictionary>[];
-export declare function loadDictionaryDefsSync(defsToLoad: DictionaryDefinitionInternal[]): SpellingDictionary[];
-export declare function refreshDictionaryCache(maxAge?: number): Promise<void>;
-export declare function getDictionaryInternal(settings: CSpellSettingsInternal): Promise<SpellingDictionaryCollection>;
-export declare function getDictionaryInternalSync(settings: CSpellSettingsInternal): SpellingDictionaryCollection;
-//# sourceMappingURL=Dictionaries.d.ts.map

package/dist/SpellingDictionary/Dictionaries.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDictionaryInternalSync = exports.getDictionaryInternal = exports.refreshDictionaryCache = exports.loadDictionaryDefsSync = exports.loadDictionaryDefs = void 0;
-const DictionarySettings_1 = require("../Settings/DictionarySettings");
-const util_1 = require("../util/util");
-const createSpellingDictionary_1 = require("./createSpellingDictionary");
-const DictionaryLoader_1 = require("./DictionaryLoader");
-const SpellingDictionaryCollection_1 = require("./SpellingDictionaryCollection");
-function loadDictionaryDefs(defsToLoad) {
-    return defsToLoad.map(DictionaryLoader_1.loadDictionary);
-}
-exports.loadDictionaryDefs = loadDictionaryDefs;
-function loadDictionaryDefsSync(defsToLoad) {
-    return defsToLoad.map(DictionaryLoader_1.loadDictionarySync);
-}
-exports.loadDictionaryDefsSync = loadDictionaryDefsSync;
-function refreshDictionaryCache(maxAge) {
-    return (0, DictionaryLoader_1.refreshCacheEntries)(maxAge);
-}
-exports.refreshDictionaryCache = refreshDictionaryCache;
-const emptyWords = Object.freeze([]);
-async function getDictionaryInternal(settings) {
-    const spellDictionaries = await Promise.all(loadDictionaryDefs((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings)));
-    return _getDictionaryInternal(settings, spellDictionaries);
-}
-exports.getDictionaryInternal = getDictionaryInternal;
-function getDictionaryInternalSync(settings) {
-    const spellDictionaries = loadDictionaryDefsSync((0, DictionarySettings_1.calcDictionaryDefsToLoad)(settings));
-    return _getDictionaryInternal(settings, spellDictionaries);
-}
-exports.getDictionaryInternalSync = getDictionaryInternalSync;
-function _getDictionaryInternal(settings, spellDictionaries) {
-    const { words = emptyWords, userWords = emptyWords, flagWords = emptyWords, ignoreWords = emptyWords } = settings;
-    const settingsWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(words, '[words]', 'From Settings `words`', {
-        caseSensitive: true,
-        weightMap: undefined,
-    });
-    const settingsUserWordsDictionary = userWords.length
-        ? (0, createSpellingDictionary_1.createSpellingDictionary)(userWords, '[userWords]', 'From Settings `userWords`', {
-            caseSensitive: true,
-            weightMap: undefined,
-        })
-        : undefined;
-    const ignoreWordsDictionary = (0, createSpellingDictionary_1.createSpellingDictionary)(ignoreWords, '[ignoreWords]', 'From Settings `ignoreWords`', {
-        caseSensitive: true,
-        noSuggest: true,
-        weightMap: undefined,
-    });
-    const flagWordsDictionary = (0, createSpellingDictionary_1.createForbiddenWordsDictionary)(flagWords, '[flagWords]', 'From Settings `flagWords`', {
-        weightMap: undefined,
-    });
-    const dictionaries = [
-        ...spellDictionaries,
-        settingsWordsDictionary,
-        settingsUserWordsDictionary,
-        ignoreWordsDictionary,
-        flagWordsDictionary,
-    ].filter(util_1.isDefined);
-    return (0, SpellingDictionaryCollection_1.createCollection)(dictionaries, 'dictionary collection');
-}
-//# sourceMappingURL=Dictionaries.js.map

package/dist/SpellingDictionary/SpellingDictionaryError.d.ts

@@ -1,10 +0,0 @@
-import { LoadOptions } from './DictionaryLoader';
-export declare class SpellingDictionaryLoadError extends Error {
-    readonly uri: string;
-    readonly options: LoadOptions;
-    readonly cause: Error;
-    readonly name: string;
-    constructor(uri: string, options: LoadOptions, cause: Error, message: string);
-}
-export declare function isSpellingDictionaryLoadError(e: Error): e is SpellingDictionaryLoadError;
-//# sourceMappingURL=SpellingDictionaryError.d.ts.map

package/dist/SpellingDictionary/SpellingDictionaryError.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSpellingDictionaryLoadError = exports.SpellingDictionaryLoadError = void 0;
-class SpellingDictionaryLoadError extends Error {
-    constructor(uri, options, cause, message) {
-        super(message);
-        this.uri = uri;
-        this.options = options;
-        this.cause = cause;
-        this.name = options.name;
-    }
-}
-exports.SpellingDictionaryLoadError = SpellingDictionaryLoadError;
-function isSpellingDictionaryLoadError(e) {
-    return e instanceof SpellingDictionaryLoadError;
-}
-exports.isSpellingDictionaryLoadError = isSpellingDictionaryLoadError;
-//# sourceMappingURL=SpellingDictionaryError.js.map

package/dist/util/Comparable.d.ts

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

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

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

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