@fluidframework/core-utils 2.0.0-dev-rc.1.0.0.224419

package/lib/core-utils-untrimmed.d.ts

@@ -0,0 +1,414 @@
+/**
+ * A browser friendly assert library.
+ * Use this instead of the 'assert' package, which has a big impact on bundle sizes.
+ * @param condition - The condition that should be true, if the condition is false an error will be thrown.
+ * Only use this API when `false` indicates a logic error in the problem and thus a bug that should be fixed.
+ * @param message - The message to include in the error when the condition does not hold.
+ * A number should not be specified manually: use a string.
+ * Before a release, policy-check should be run, which will convert any asserts still using strings to
+ * use numbered error codes instead.
+ * @alpha
+ */
+export declare function assert(condition: boolean, message: string | number): asserts condition;
+
+/**
+ * Compare two arrays.  Returns true if their elements are equivalent and in the same order.
+ *
+ * @alpha
+ *
+ * @param left - The first array to compare
+ * @param right - The second array to compare
+ * @param comparator - The function used to check if two `T`s are equivalent.
+ * Defaults to `Object.is()` equality (a shallow compare where NaN = NaN and -0 ≠ 0)
+ */
+export declare const compareArrays: <T>(left: readonly T[], right: readonly T[], comparator?: (leftItem: T, rightItem: T, index: number) => boolean) => boolean;
+
+/**
+ * A deferred creates a promise and the ability to resolve or reject it
+ * @alpha
+ */
+export declare class Deferred<T> {
+    private readonly p;
+    private res;
+    private rej;
+    private completed;
+    constructor();
+    /**
+     * Returns whether the underlying promise has been completed
+     */
+    get isCompleted(): boolean;
+    /**
+     * Retrieves the underlying promise for the deferred
+     *
+     * @returns the underlying promise
+     */
+    get promise(): Promise<T>;
+    /**
+     * Resolves the promise
+     *
+     * @param value - the value to resolve the promise with
+     */
+    resolve(value: T | PromiseLike<T>): void;
+    /**
+     * Rejects the promise
+     *
+     * @param value - the value to reject the promise with
+     */
+    reject(error: any): void;
+}
+
+/**
+ * Returns a promise that resolves after `timeMs`.
+ * @param timeMs - Time in milliseconds to wait.
+ * @internal
+ */
+export declare const delay: (timeMs: number) => Promise<void>;
+
+/**
+ * Ordered {@link https://en.wikipedia.org/wiki/Heap_(data_structure) | Heap} data structure implementation.
+ * @internal
+ */
+export declare class Heap<T> {
+    comp: IComparer<T>;
+    private L;
+    /**
+     * Creates an instance of `Heap` with comparer.
+     * @param comp - A comparer that specify how elements are ordered.
+     */
+    constructor(comp: IComparer<T>);
+    /**
+     * Return the smallest element in the heap as determined by the order of the comparer
+     *
+     * @returns Heap node containing the smallest element
+     */
+    peek(): IHeapNode<T> | undefined;
+    /**
+     * Get and remove the smallest element in the heap as determined by the order of the comparer
+     *
+     * @returns The smallest value in the heap
+     */
+    get(): T | undefined;
+    /**
+     * Add a value to the heap
+     *
+     * @param x - value to add
+     * @returns The heap node that contains the value
+     */
+    add(x: T): IHeapNode<T>;
+    /**
+     * Allows for the Heap to be updated after a node's value changes.
+     */
+    update(node: IHeapNode<T>): void;
+    /**
+     * Removes the given node from the heap.
+     *
+     * @param node - The node to remove from the heap.
+     */
+    remove(node: IHeapNode<T>): void;
+    /**
+     * Get the number of elements in the Heap.
+     *
+     * @returns The number of elements in the Heap.
+     */
+    count(): number;
+    private fixup;
+    private isGreaterThanParent;
+    private fixdown;
+    private swap;
+}
+
+/**
+ * Interface for a comparer.
+ * @internal
+ */
+export declare interface IComparer<T> {
+    /**
+     * The minimum value of type T.
+     */
+    min: T;
+    /**
+     * Compare the two value
+     *
+     * @returns 0 if the value is equal, negative number if a is smaller then b, positive number otherwise
+     */
+    compare(a: T, b: T): number;
+}
+
+/**
+ * Interface to a node in {@link Heap}.
+ * @internal
+ */
+export declare interface IHeapNode<T> {
+    value: T;
+    position: number;
+}
+
+/**
+ * Timer which offers a promise that fulfills when the timer
+ * completes.
+ * @internal
+ */
+export declare interface IPromiseTimer extends ITimer {
+    /**
+     * Starts the timer and returns a promise that
+     * resolves when the timer times out or is canceled.
+     */
+    start(): Promise<IPromiseTimerResult>;
+}
+
+/**
+ * @internal
+ */
+export declare interface IPromiseTimerResult {
+    timerResult: "timeout" | "cancel";
+}
+
+/**
+ * @internal
+ */
+export declare interface ITimer {
+    /**
+     * True if timer is currently running
+     */
+    readonly hasTimer: boolean;
+    /**
+     * Starts the timer
+     */
+    start(): void;
+    /**
+     * Cancels the timer if already running
+     */
+    clear(): void;
+}
+
+/**
+ * Helper class for lazy initialized values. Ensures the value is only generated once, and remain immutable.
+ * @internal
+ */
+export declare class Lazy<T> {
+    private readonly valueGenerator;
+    private _value;
+    private _evaluated;
+    /**
+     * Instantiates an instance of Lazy<T>.
+     * @param valueGenerator - The function that will generate the value when value is accessed the first time.
+     */
+    constructor(valueGenerator: () => T);
+    /**
+     * Return true if the value as been generated, otherwise false.
+     */
+    get evaluated(): boolean;
+    /**
+     * Get the value. If this is the first call the value will be generated.
+     */
+    get value(): T;
+}
+
+/**
+ * A lazy evaluated promise. The execute function is delayed until
+ * the promise is used, e.g. await, then, catch ...
+ * The execute function is only called once.
+ * All calls are then proxied to the promise returned by the execute method.
+ * @alpha
+ */
+export declare class LazyPromise<T> implements Promise<T> {
+    private readonly execute;
+    get [Symbol.toStringTag](): string;
+    private result;
+    constructor(execute: () => Promise<T>);
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    private getPromise;
+}
+
+/**
+ * A comparer for numbers.
+ * @internal
+ */
+export declare const NumberComparer: IComparer<number>;
+
+/**
+ * A specialized cache for async work, allowing you to safely cache the promised result of some async work
+ * without fear of running it multiple times or losing track of errors.
+ * @alpha
+ */
+export declare class PromiseCache<TKey, TResult> {
+    private readonly cache;
+    private readonly gc;
+    private readonly removeOnError;
+    /**
+     * Create the PromiseCache with the given options, with the following defaults:
+     *
+     * expiry: indefinite, removeOnError: true for all errors
+     */
+    constructor({ expiry, removeOnError, }?: PromiseCacheOptions);
+    /**
+     * Check if there's anything cached at the given key
+     */
+    has(key: TKey): boolean;
+    /**
+     * Get the Promise for the given key, or undefined if it's not found.
+     * Extend expiry if applicable.
+     */
+    get(key: TKey): Promise<TResult> | undefined;
+    /**
+     * Remove the Promise for the given key, returning true if it was found and removed
+     */
+    remove(key: TKey): boolean;
+    /**
+     * Try to add the result of the given asyncFn, without overwriting an existing cache entry at that key.
+     * Returns a Promise for the added or existing async work being done at that key.
+     * @param key - key name where to store the async work
+     * @param asyncFn - the async work to do and store, if not already in progress under the given key
+     */
+    addOrGet(key: TKey, asyncFn: () => Promise<TResult>): Promise<TResult>;
+    /**
+     * Try to add the result of the given asyncFn, without overwriting an existing cache entry at that key.
+     * Returns false if the cache already contained an entry at that key, and true otherwise.
+     * @param key - key name where to store the async work
+     * @param asyncFn - the async work to do and store, if not already in progress under the given key
+     */
+    add(key: TKey, asyncFn: () => Promise<TResult>): boolean;
+    /**
+     * Try to add the given value, without overwriting an existing cache entry at that key.
+     * Returns a Promise for the added or existing async work being done at that key.
+     * @param key - key name where to store the async work
+     * @param value - value to store
+     */
+    addValueOrGet(key: TKey, value: TResult): Promise<TResult>;
+    /**
+     * Try to add the given value, without overwriting an existing cache entry at that key.
+     * Returns false if the cache already contained an entry at that key, and true otherwise.
+     * @param key - key name where to store the value
+     * @param value - value to store
+     */
+    addValue(key: TKey, value: TResult): boolean;
+}
+
+/**
+ * Three supported expiry policies:
+ * - indefinite: entries don't expire and must be explicitly removed
+ * - absolute: entries expire after the given duration in MS, even if accessed multiple times in the mean time
+ * - sliding: entries expire after the given duration in MS of inactivity (i.e. get resets the clock)
+ * @alpha
+ */
+export declare type PromiseCacheExpiry = {
+    policy: "indefinite";
+} | {
+    policy: "absolute" | "sliding";
+    durationMs: number;
+};
+
+/**
+ * Options for configuring the {@link PromiseCache}
+ * @alpha
+ */
+export declare interface PromiseCacheOptions {
+    /**
+     * Common expiration policy for all items added to this cache
+     */
+    expiry?: PromiseCacheExpiry;
+    /**
+     * If the stored Promise is rejected with a particular error, should the given key be removed?
+     */
+    removeOnError?: (error: any) => boolean;
+}
+
+/**
+ * This class is a wrapper over setTimeout and clearTimeout which
+ * makes it simpler to keep track of recurring timeouts with the
+ * same handlers and timeouts, while also providing a promise that
+ * resolves when it times out.
+ * @internal
+ */
+export declare class PromiseTimer implements IPromiseTimer {
+    private deferred?;
+    private readonly timer;
+    /**
+     * {@inheritDoc Timer.hasTimer}
+     */
+    get hasTimer(): boolean;
+    constructor(defaultTimeout: number, defaultHandler: () => void);
+    /**
+     * {@inheritDoc IPromiseTimer.start}
+     */
+    start(ms?: number, handler?: () => void): Promise<IPromiseTimerResult>;
+    clear(): void;
+    protected wrapHandler(handler: () => void): void;
+}
+
+/**
+ * Sets timeouts like the setTimeout function allowing timeouts to exceed the setTimeout's max timeout limit.
+ * Timeouts may not be exactly accurate due to browser implementations and the OS.
+ * https://stackoverflow.com/questions/21097421/what-is-the-reason-javascript-settimeout-is-so-inaccurate
+ * @param timeoutFn - Executed when the timeout expires
+ * @param timeoutMs - Duration of the timeout in milliseconds
+ * @param setTimeoutIdFn - Executed to update the timeout if multiple timeouts are required when
+ * timeoutMs greater than maxTimeout
+ * @returns The initial timeout
+ * @internal
+ */
+export declare function setLongTimeout(timeoutFn: () => void, timeoutMs: number, setTimeoutIdFn?: (timeoutId: ReturnType<typeof setTimeout>) => void): ReturnType<typeof setTimeout>;
+
+/**
+ * This class is a thin wrapper over setTimeout and clearTimeout which
+ * makes it simpler to keep track of recurring timeouts with the same
+ * or similar handlers and timeouts. This class supports long timeouts
+ * or timeouts exceeding (2^31)-1 ms or approximately 24.8 days.
+ * @internal
+ */
+export declare class Timer implements ITimer {
+    private readonly defaultTimeout;
+    private readonly defaultHandler;
+    private readonly getCurrentTick;
+    /**
+     * Returns true if the timer is running.
+     */
+    get hasTimer(): boolean;
+    private runningState;
+    constructor(defaultTimeout: number, defaultHandler: () => void, getCurrentTick?: () => number);
+    /**
+     * Calls setTimeout and tracks the resulting timeout.
+     * @param ms - overrides default timeout in ms
+     * @param handler - overrides default handler
+     */
+    start(ms?: number, handler?: () => void): void;
+    /**
+     * Calls clearTimeout on the underlying timeout if running.
+     */
+    clear(): void;
+    /**
+     * Restarts the timer with the new handler and duration.
+     * If a new handler is passed, the original handler may
+     * never execute.
+     * This is a potentially more efficient way to clear and start
+     * a new timer.
+     * @param ms - overrides previous or default timeout in ms
+     * @param handler - overrides previous or default handler
+     */
+    restart(ms?: number, handler?: () => void): void;
+    private startCore;
+    private handler;
+    private calculateRemainingTime;
+}
+
+/**
+ * This function can be used to assert at compile time that a given value has type never.
+ * One common usage is in the default case of a switch block,
+ * to ensure that all cases are explicitly handled.
+ *
+ * Example:
+ * ```typescript
+ * const bool: true | false = ...;
+ * switch(bool) {
+ *   case true: {...}
+ *   case false: {...}
+ *   default: unreachableCase(bool);
+ * }
+ * ```
+ * @internal
+ */
+export declare function unreachableCase(_: never, message?: string): never;
+
+export { }

package/lib/delay.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Returns a promise that resolves after `timeMs`.
+ * @param timeMs - Time in milliseconds to wait.
+ * @internal
+ */
+export declare const delay: (timeMs: number) => Promise<void>;
+//# sourceMappingURL=delay.d.ts.map

package/lib/delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.d.ts","sourceRoot":"","sources":["../src/delay.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,eAAO,MAAM,KAAK,WAAkB,MAAM,KAAG,QAAQ,IAAI,CACK,CAAC"}

package/lib/delay.js

@@ -0,0 +1,15 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+/**
+ * Returns a promise that resolves after `timeMs`.
+ * @param timeMs - Time in milliseconds to wait.
+ * @internal
+ */
+const delay = async (timeMs) => new Promise((resolve) => setTimeout(() => resolve(), timeMs));
+exports.delay = delay;
+//# sourceMappingURL=delay.js.map

package/lib/delay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delay.js","sourceRoot":"","sources":["../src/delay.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;;;GAIG;AACI,MAAM,KAAK,GAAG,KAAK,EAAE,MAAc,EAAiB,EAAE,CAC5D,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;AADlD,QAAA,KAAK,SAC6C","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Returns a promise that resolves after `timeMs`.\n * @param timeMs - Time in milliseconds to wait.\n * @internal\n */\nexport const delay = async (timeMs: number): Promise<void> =>\n\tnew Promise((resolve) => setTimeout(() => resolve(), timeMs));\n"]}

package/lib/heap.d.ts

@@ -0,0 +1,86 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Interface for a comparer.
+ * @internal
+ */
+export interface IComparer<T> {
+    /**
+     * The minimum value of type T.
+     */
+    min: T;
+    /**
+     * Compare the two value
+     *
+     * @returns 0 if the value is equal, negative number if a is smaller then b, positive number otherwise
+     */
+    compare(a: T, b: T): number;
+}
+/**
+ * A comparer for numbers.
+ * @internal
+ */
+export declare const NumberComparer: IComparer<number>;
+/**
+ * Interface to a node in {@link Heap}.
+ * @internal
+ */
+export interface IHeapNode<T> {
+    value: T;
+    position: number;
+}
+/**
+ * Ordered {@link https://en.wikipedia.org/wiki/Heap_(data_structure) | Heap} data structure implementation.
+ * @internal
+ */
+export declare class Heap<T> {
+    comp: IComparer<T>;
+    private L;
+    /**
+     * Creates an instance of `Heap` with comparer.
+     * @param comp - A comparer that specify how elements are ordered.
+     */
+    constructor(comp: IComparer<T>);
+    /**
+     * Return the smallest element in the heap as determined by the order of the comparer
+     *
+     * @returns Heap node containing the smallest element
+     */
+    peek(): IHeapNode<T> | undefined;
+    /**
+     * Get and remove the smallest element in the heap as determined by the order of the comparer
+     *
+     * @returns The smallest value in the heap
+     */
+    get(): T | undefined;
+    /**
+     * Add a value to the heap
+     *
+     * @param x - value to add
+     * @returns The heap node that contains the value
+     */
+    add(x: T): IHeapNode<T>;
+    /**
+     * Allows for the Heap to be updated after a node's value changes.
+     */
+    update(node: IHeapNode<T>): void;
+    /**
+     * Removes the given node from the heap.
+     *
+     * @param node - The node to remove from the heap.
+     */
+    remove(node: IHeapNode<T>): void;
+    /**
+     * Get the number of elements in the Heap.
+     *
+     * @returns The number of elements in the Heap.
+     */
+    count(): number;
+    private fixup;
+    private isGreaterThanParent;
+    private fixdown;
+    private swap;
+}
+//# sourceMappingURL=heap.d.ts.map

package/lib/heap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap.d.ts","sourceRoot":"","sources":["../src/heap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC3B;;OAEG;IACH,GAAG,EAAE,CAAC,CAAC;IAEP;;;;OAIG;IACH,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC;CAC5B;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,CAAC,MAAM,CAW5C,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,qBAAa,IAAI,CAAC,CAAC;IAOC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;IANrC,OAAO,CAAC,CAAC,CAAiB;IAE1B;;;OAGG;gBACgB,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;IAIrC;;;;OAIG;IACI,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS;IAIvC;;;;OAIG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;IAY3B;;;;;OAKG;IACI,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAQ9B;;OAEG;IACI,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI;IASvC;;;;OAIG;IACI,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI;IAYvC;;;;OAIG;IACI,KAAK,IAAI,MAAM;IAItB,OAAO,CAAC,KAAK;IAUb,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,OAAO;IAiBf,OAAO,CAAC,IAAI;CAOZ"}

package/lib/heap.js

@@ -0,0 +1,144 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heap = exports.NumberComparer = void 0;
+/**
+ * A comparer for numbers.
+ * @internal
+ */
+exports.NumberComparer = {
+    /**
+     * The compare function for numbers.
+     * @returns The difference of the two numbers.
+     */
+    compare: (a, b) => a - b,
+    /**
+     * The minimum value of a JavaScript number, which is `Number.MIN_VALUE`.
+     */
+    min: Number.MIN_VALUE,
+};
+/**
+ * Ordered {@link https://en.wikipedia.org/wiki/Heap_(data_structure) | Heap} data structure implementation.
+ * @internal
+ */
+class Heap {
+    /**
+     * Creates an instance of `Heap` with comparer.
+     * @param comp - A comparer that specify how elements are ordered.
+     */
+    constructor(comp) {
+        this.comp = comp;
+        this.L = [{ value: comp.min, position: 0 }];
+    }
+    /**
+     * Return the smallest element in the heap as determined by the order of the comparer
+     *
+     * @returns Heap node containing the smallest element
+     */
+    peek() {
+        return this.L[1];
+    }
+    /**
+     * Get and remove the smallest element in the heap as determined by the order of the comparer
+     *
+     * @returns The smallest value in the heap
+     */
+    get() {
+        if (this.L.length === 0) {
+            return undefined;
+        }
+        this.swap(1, this.count());
+        const x = this.L.pop();
+        this.fixdown(1);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return x.value;
+    }
+    /**
+     * Add a value to the heap
+     *
+     * @param x - value to add
+     * @returns The heap node that contains the value
+     */
+    add(x) {
+        const node = { value: x, position: this.L.length };
+        this.L.push(node);
+        this.fixup(this.count());
+        return node;
+    }
+    /**
+     * Allows for the Heap to be updated after a node's value changes.
+     */
+    update(node) {
+        const k = node.position;
+        if (this.isGreaterThanParent(k)) {
+            this.fixup(k);
+        }
+        else {
+            this.fixdown(k);
+        }
+    }
+    /**
+     * Removes the given node from the heap.
+     *
+     * @param node - The node to remove from the heap.
+     */
+    remove(node) {
+        // Move the node we want to remove to the end of the array
+        const position = node.position;
+        this.swap(node.position, this.L.length - 1);
+        this.L.splice(-1);
+        // Update the swapped node assuming we didn't remove the end of the list
+        if (position !== this.L.length) {
+            this.update(this.L[position]);
+        }
+    }
+    /**
+     * Get the number of elements in the Heap.
+     *
+     * @returns The number of elements in the Heap.
+     */
+    count() {
+        return this.L.length - 1;
+    }
+    fixup(pos) {
+        let k = pos;
+        while (this.isGreaterThanParent(k)) {
+            // eslint-disable-next-line no-bitwise
+            const parent = k >> 1;
+            this.swap(k, parent);
+            k = parent;
+        }
+    }
+    isGreaterThanParent(k) {
+        // eslint-disable-next-line no-bitwise
+        return k > 1 && this.comp.compare(this.L[k >> 1].value, this.L[k].value) > 0;
+    }
+    fixdown(pos) {
+        let k = pos;
+        // eslint-disable-next-line no-bitwise
+        while (k << 1 <= this.count()) {
+            // eslint-disable-next-line no-bitwise
+            let j = k << 1;
+            if (j < this.count() && this.comp.compare(this.L[j].value, this.L[j + 1].value) > 0) {
+                j++;
+            }
+            if (this.comp.compare(this.L[k].value, this.L[j].value) <= 0) {
+                break;
+            }
+            this.swap(k, j);
+            k = j;
+        }
+    }
+    swap(k, j) {
+        const tmp = this.L[k];
+        this.L[k] = this.L[j];
+        this.L[k].position = k;
+        this.L[j] = tmp;
+        this.L[j].position = j;
+    }
+}
+exports.Heap = Heap;
+//# sourceMappingURL=heap.js.map