@itwin/core-bentley 4.0.0-dev.7 → 4.0.0-dev.72

package/lib/esm/OrderedSet.d.ts

@@ -1,41 +1,41 @@
-/** @packageDocumentation
- * @module Collections
- */
-import { OrderedComparator } from "./Compare";
-import { CloneFunction, SortedArray } from "./SortedArray";
-/** A read-only equivalent of `Set<T>` that maintains its elements in sorted order as specified by a comparison function.
- * Iteration returns elements in the order specified by the comparison function, as opposed to `Set` which returns elements in insertion order.
- * Implemented in terms of [[SortedArray]].
- * @public
- */
-export declare class ReadonlyOrderedSet<T> implements Iterable<T> {
-    protected readonly _array: SortedArray<T>;
-    /** Construct a new ReadonlyOrderedSet<T>.
-     * @param compare The function used to compare elements within the set, determining their ordering.
-     * @param clone The function invoked to clone a new element for insertion into the set. The default implementation simply returns its input.
-     */
-    constructor(compare: OrderedComparator<T>, clone?: CloneFunction<T>);
-    /** The number of elements in the set. */
-    get size(): number;
-    /** Returns true if `value` is present in the set. */
-    has(value: T): boolean;
-    /** Iterate over the elements in sorted order (as opposed to `Set`'s iterator, which returns elements in insertion order). */
-    [Symbol.iterator](): Iterator<T>;
-}
-/** A mutable [[ReadonlyOrderedSet]].
- * @public
- */
-export declare class OrderedSet<T> extends ReadonlyOrderedSet<T> {
-    /** Construct a new OrderedSet<T>.
-     * @param compare The function used to compare elements within the set, determining their ordering.
-     * @param clone The function invoked to clone a new element for insertion into the set. The default implementation simply returns its input.
-     */
-    constructor(compare: OrderedComparator<T>, clone?: CloneFunction<T>);
-    /** Remove all elements from the set. */
-    clear(): void;
-    /** Add the specified element to the set. Returns this set. */
-    add(value: T): this;
-    /** Removes the specified element from the set. Returns `true` if the element was present. */
-    delete(value: T): boolean;
-}
+/** @packageDocumentation
+ * @module Collections
+ */
+import { OrderedComparator } from "./Compare";
+import { CloneFunction, SortedArray } from "./SortedArray";
+/** A read-only equivalent of `Set<T>` that maintains its elements in sorted order as specified by a comparison function.
+ * Iteration returns elements in the order specified by the comparison function, as opposed to `Set` which returns elements in insertion order.
+ * Implemented in terms of [[SortedArray]].
+ * @public
+ */
+export declare class ReadonlyOrderedSet<T> implements Iterable<T> {
+    protected readonly _array: SortedArray<T>;
+    /** Construct a new ReadonlyOrderedSet<T>.
+     * @param compare The function used to compare elements within the set, determining their ordering.
+     * @param clone The function invoked to clone a new element for insertion into the set. The default implementation simply returns its input.
+     */
+    constructor(compare: OrderedComparator<T>, clone?: CloneFunction<T>);
+    /** The number of elements in the set. */
+    get size(): number;
+    /** Returns true if `value` is present in the set. */
+    has(value: T): boolean;
+    /** Iterate over the elements in sorted order (as opposed to `Set`'s iterator, which returns elements in insertion order). */
+    [Symbol.iterator](): Iterator<T>;
+}
+/** A mutable [[ReadonlyOrderedSet]].
+ * @public
+ */
+export declare class OrderedSet<T> extends ReadonlyOrderedSet<T> {
+    /** Construct a new OrderedSet<T>.
+     * @param compare The function used to compare elements within the set, determining their ordering.
+     * @param clone The function invoked to clone a new element for insertion into the set. The default implementation simply returns its input.
+     */
+    constructor(compare: OrderedComparator<T>, clone?: CloneFunction<T>);
+    /** Remove all elements from the set. */
+    clear(): void;
+    /** Add the specified element to the set. Returns this set. */
+    add(value: T): this;
+    /** Removes the specified element from the set. Returns `true` if the element was present. */
+    delete(value: T): boolean;
+}
 //# sourceMappingURL=OrderedSet.d.ts.map

package/lib/esm/OrderedSet.js

@@ -1,60 +1,60 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Collections
- */
-import { shallowClone, SortedArray } from "./SortedArray";
-/** A read-only equivalent of `Set<T>` that maintains its elements in sorted order as specified by a comparison function.
- * Iteration returns elements in the order specified by the comparison function, as opposed to `Set` which returns elements in insertion order.
- * Implemented in terms of [[SortedArray]].
- * @public
- */
-export class ReadonlyOrderedSet {
-    /** Construct a new ReadonlyOrderedSet<T>.
-     * @param compare The function used to compare elements within the set, determining their ordering.
-     * @param clone The function invoked to clone a new element for insertion into the set. The default implementation simply returns its input.
-     */
-    constructor(compare, clone = shallowClone) {
-        this._array = new SortedArray(compare, false, clone);
-    }
-    /** The number of elements in the set. */
-    get size() {
-        return this._array.length;
-    }
-    /** Returns true if `value` is present in the set. */
-    has(value) {
-        return -1 !== this._array.indexOf(value);
-    }
-    /** Iterate over the elements in sorted order (as opposed to `Set`'s iterator, which returns elements in insertion order). */
-    [Symbol.iterator]() {
-        return this._array[Symbol.iterator]();
-    }
-}
-/** A mutable [[ReadonlyOrderedSet]].
- * @public
- */
-export class OrderedSet extends ReadonlyOrderedSet {
-    /** Construct a new OrderedSet<T>.
-     * @param compare The function used to compare elements within the set, determining their ordering.
-     * @param clone The function invoked to clone a new element for insertion into the set. The default implementation simply returns its input.
-     */
-    constructor(compare, clone = shallowClone) {
-        super(compare, clone);
-    }
-    /** Remove all elements from the set. */
-    clear() {
-        this._array.clear();
-    }
-    /** Add the specified element to the set. Returns this set. */
-    add(value) {
-        this._array.insert(value);
-        return this;
-    }
-    /** Removes the specified element from the set. Returns `true` if the element was present. */
-    delete(value) {
-        return -1 !== this._array.remove(value);
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Collections
+ */
+import { shallowClone, SortedArray } from "./SortedArray";
+/** A read-only equivalent of `Set<T>` that maintains its elements in sorted order as specified by a comparison function.
+ * Iteration returns elements in the order specified by the comparison function, as opposed to `Set` which returns elements in insertion order.
+ * Implemented in terms of [[SortedArray]].
+ * @public
+ */
+export class ReadonlyOrderedSet {
+    /** Construct a new ReadonlyOrderedSet<T>.
+     * @param compare The function used to compare elements within the set, determining their ordering.
+     * @param clone The function invoked to clone a new element for insertion into the set. The default implementation simply returns its input.
+     */
+    constructor(compare, clone = shallowClone) {
+        this._array = new SortedArray(compare, false, clone);
+    }
+    /** The number of elements in the set. */
+    get size() {
+        return this._array.length;
+    }
+    /** Returns true if `value` is present in the set. */
+    has(value) {
+        return -1 !== this._array.indexOf(value);
+    }
+    /** Iterate over the elements in sorted order (as opposed to `Set`'s iterator, which returns elements in insertion order). */
+    [Symbol.iterator]() {
+        return this._array[Symbol.iterator]();
+    }
+}
+/** A mutable [[ReadonlyOrderedSet]].
+ * @public
+ */
+export class OrderedSet extends ReadonlyOrderedSet {
+    /** Construct a new OrderedSet<T>.
+     * @param compare The function used to compare elements within the set, determining their ordering.
+     * @param clone The function invoked to clone a new element for insertion into the set. The default implementation simply returns its input.
+     */
+    constructor(compare, clone = shallowClone) {
+        super(compare, clone);
+    }
+    /** Remove all elements from the set. */
+    clear() {
+        this._array.clear();
+    }
+    /** Add the specified element to the set. Returns this set. */
+    add(value) {
+        this._array.insert(value);
+        return this;
+    }
+    /** Removes the specified element from the set. Returns `true` if the element was present. */
+    delete(value) {
+        return -1 !== this._array.remove(value);
+    }
+}
 //# sourceMappingURL=OrderedSet.js.map

package/lib/esm/PriorityQueue.d.ts

@@ -1,71 +1,71 @@
-/** @packageDocumentation
- * @module Collections
- */
-import { OrderedComparator } from "./Compare";
-import { CloneFunction } from "./SortedArray";
-/** @public */
-export declare type ComputePriorityFunction<T> = (value: T) => number;
-/**
- * A [priority queue](https://en.wikipedia.org/wiki/Priority_queue) implemented as a heap array.
- * The queue is ordered by an [[OrderedComparator]] function supplied by the user such that the value in the queue that compares less than all other values is always located at the front of the queue.
- * @public
- */
-export declare class PriorityQueue<T> implements Iterable<T> {
-    protected _array: T[];
-    protected readonly _compare: OrderedComparator<T>;
-    protected readonly _clone: CloneFunction<T>;
-    /**
-     * Constructor
-     * @param compare The function used to compare values in the queue. If `compare(x, y)` returns a negative value, then x is placed before y in the queue.
-     * @param clone The function used to clone a value for insertion onto the queue. The default implementation simply returns its input.
-     * @note If the criterion which control the result of the `compare` function changes, then [[PriorityQueue.sort]] should be used to reorder the queue according to the new criterion.
-     */
-    constructor(compare: OrderedComparator<T>, clone?: CloneFunction<T>);
-    /** The number of values in the queue. */
-    get length(): number;
-    /** Returns true if the queue contains no values. */
-    get isEmpty(): boolean;
-    /** Returns an iterator over the contents of the heap suitable for use in `for-of` loops. */
-    [Symbol.iterator](): Iterator<T>;
-    protected _swap(a: number, b: number): void;
-    protected _heapify(index: number): void;
-    /**
-     * Reorders the queue. This function should only (and *always*) be called when the criteria governing the ordering of items on the queue have changed.
-     * For example, a priority queue containing graphics sorted by their distance from the camera would need to be reordered when the position of the camera changes.
-     */
-    sort(): void;
-    /**
-     * Pushes a value onto the queue according to the sorting criterion.
-     * @param value The value to insert
-     * @returns The inserted value, cloned according to the [[CloneFunction]] supplied to this queue's constructor.
-     */
-    push(value: T): T;
-    /** Pushes a value onto the back of the queue without making any attempt to enforce ordering.
-     * After using this function, you must manually invoke sort() to ensure the queue is sorted again.
-     * @param value The value to append
-     * @returns The appended value, cloned according to the [[CloneFunction]] supplied to this queue's constructor.
-     */
-    append(value: T): T;
-    /** Returns the element at the front of the queue, or `undefined` if the queue is empty. */
-    get front(): T | undefined;
-    /**
-     * Removes the front-most element off of the queue and returns it.
-     * @returns The front-most element, or undefined if the queue is empty.
-     */
-    pop(): T | undefined;
-    /** Removes all values from the queue. */
-    clear(): void;
-    /**
-     * Removes the value at the specified index from the queue and reorders the queue.
-     * @param index The index of the value to remove
-     * @returns the value at the specified index, or undefined if the index is out of range.
-     */
-    protected _pop(index: number): T | undefined;
-    /**
-     * Returns the value at the specified index in the queue.
-     * @param index The index of the value to retrieve
-     * @returns the value at the specified index, or undefined if the index is out of range.
-     */
-    protected _peek(index: number): T | undefined;
-}
+/** @packageDocumentation
+ * @module Collections
+ */
+import { OrderedComparator } from "./Compare";
+import { CloneFunction } from "./SortedArray";
+/** @public */
+export type ComputePriorityFunction<T> = (value: T) => number;
+/**
+ * A [priority queue](https://en.wikipedia.org/wiki/Priority_queue) implemented as a heap array.
+ * The queue is ordered by an [[OrderedComparator]] function supplied by the user such that the value in the queue that compares less than all other values is always located at the front of the queue.
+ * @public
+ */
+export declare class PriorityQueue<T> implements Iterable<T> {
+    protected _array: T[];
+    protected readonly _compare: OrderedComparator<T>;
+    protected readonly _clone: CloneFunction<T>;
+    /**
+     * Constructor
+     * @param compare The function used to compare values in the queue. If `compare(x, y)` returns a negative value, then x is placed before y in the queue.
+     * @param clone The function used to clone a value for insertion onto the queue. The default implementation simply returns its input.
+     * @note If the criterion which control the result of the `compare` function changes, then [[PriorityQueue.sort]] should be used to reorder the queue according to the new criterion.
+     */
+    constructor(compare: OrderedComparator<T>, clone?: CloneFunction<T>);
+    /** The number of values in the queue. */
+    get length(): number;
+    /** Returns true if the queue contains no values. */
+    get isEmpty(): boolean;
+    /** Returns an iterator over the contents of the heap suitable for use in `for-of` loops. */
+    [Symbol.iterator](): Iterator<T>;
+    protected _swap(a: number, b: number): void;
+    protected _heapify(index: number): void;
+    /**
+     * Reorders the queue. This function should only (and *always*) be called when the criteria governing the ordering of items on the queue have changed.
+     * For example, a priority queue containing graphics sorted by their distance from the camera would need to be reordered when the position of the camera changes.
+     */
+    sort(): void;
+    /**
+     * Pushes a value onto the queue according to the sorting criterion.
+     * @param value The value to insert
+     * @returns The inserted value, cloned according to the [[CloneFunction]] supplied to this queue's constructor.
+     */
+    push(value: T): T;
+    /** Pushes a value onto the back of the queue without making any attempt to enforce ordering.
+     * After using this function, you must manually invoke sort() to ensure the queue is sorted again.
+     * @param value The value to append
+     * @returns The appended value, cloned according to the [[CloneFunction]] supplied to this queue's constructor.
+     */
+    append(value: T): T;
+    /** Returns the element at the front of the queue, or `undefined` if the queue is empty. */
+    get front(): T | undefined;
+    /**
+     * Removes the front-most element off of the queue and returns it.
+     * @returns The front-most element, or undefined if the queue is empty.
+     */
+    pop(): T | undefined;
+    /** Removes all values from the queue. */
+    clear(): void;
+    /**
+     * Removes the value at the specified index from the queue and reorders the queue.
+     * @param index The index of the value to remove
+     * @returns the value at the specified index, or undefined if the index is out of range.
+     */
+    protected _pop(index: number): T | undefined;
+    /**
+     * Returns the value at the specified index in the queue.
+     * @param index The index of the value to retrieve
+     * @returns the value at the specified index, or undefined if the index is out of range.
+     */
+    protected _peek(index: number): T | undefined;
+}
 //# sourceMappingURL=PriorityQueue.d.ts.map

package/lib/esm/PriorityQueue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PriorityQueue.d.ts","sourceRoot":"","sources":["../../src/PriorityQueue.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAgB,MAAM,eAAe,CAAC;AAE5D,cAAc;AACd,oBAAY,uBAAuB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;AAE9D;;;;GAIG;AACH,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IAClD,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,CAAM;IAC3B,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAClD,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAE5C;;;;;OAKG;gBACgB,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,KAAK,GAAE,aAAa,CAAC,CAAC,CAAgB;IAKxF,yCAAyC;IACzC,IAAW,MAAM,IAAI,MAAM,CAA+B;IAE1D,oDAAoD;IACpD,IAAW,OAAO,IAAI,OAAO,CAA8B;IAE3D,4FAA4F;IACrF,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;IAEvC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAMpC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAsBvC;;;OAGG;IACI,IAAI,IAAI,IAAI;IAKnB;;;;OAIG;IACI,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC;IAmBxB;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC;IAM1B,2FAA2F;IAC3F,IAAW,KAAK,IAAI,CAAC,GAAG,SAAS,CAEhC;IAED;;;OAGG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;IAI3B,yCAAyC;IAClC,KAAK,IAAI,IAAI;IAIpB;;;;OAIG;IACH,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAY5C;;;;OAIG;IACH,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;CAM9C"}
+{"version":3,"file":"PriorityQueue.d.ts","sourceRoot":"","sources":["../../src/PriorityQueue.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAgB,MAAM,eAAe,CAAC;AAE5D,cAAc;AACd,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;AAE9D;;;;GAIG;AACH,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IAClD,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,CAAM;IAC3B,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAClD,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAE5C;;;;;OAKG;gBACgB,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,KAAK,GAAE,aAAa,CAAC,CAAC,CAAgB;IAKxF,yCAAyC;IACzC,IAAW,MAAM,IAAI,MAAM,CAA+B;IAE1D,oDAAoD;IACpD,IAAW,OAAO,IAAI,OAAO,CAA8B;IAE3D,4FAA4F;IACrF,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;IAEvC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAMpC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAsBvC;;;OAGG;IACI,IAAI,IAAI,IAAI;IAKnB;;;;OAIG;IACI,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC;IAmBxB;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC;IAM1B,2FAA2F;IAC3F,IAAW,KAAK,IAAI,CAAC,GAAG,SAAS,CAEhC;IAED;;;OAGG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;IAI3B,yCAAyC;IAClC,KAAK,IAAI,IAAI;IAIpB;;;;OAIG;IACH,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAY5C;;;;OAIG;IACH,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;CAM9C"}

package/lib/esm/PriorityQueue.js

@@ -1,137 +1,137 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Collections
- */
-import { shallowClone } from "./SortedArray";
-/**
- * A [priority queue](https://en.wikipedia.org/wiki/Priority_queue) implemented as a heap array.
- * The queue is ordered by an [[OrderedComparator]] function supplied by the user such that the value in the queue that compares less than all other values is always located at the front of the queue.
- * @public
- */
-export class PriorityQueue {
-    /**
-     * Constructor
-     * @param compare The function used to compare values in the queue. If `compare(x, y)` returns a negative value, then x is placed before y in the queue.
-     * @param clone The function used to clone a value for insertion onto the queue. The default implementation simply returns its input.
-     * @note If the criterion which control the result of the `compare` function changes, then [[PriorityQueue.sort]] should be used to reorder the queue according to the new criterion.
-     */
-    constructor(compare, clone = shallowClone) {
-        this._array = [];
-        this._compare = compare;
-        this._clone = clone;
-    }
-    /** The number of values in the queue. */
-    get length() { return this._array.length; }
-    /** Returns true if the queue contains no values. */
-    get isEmpty() { return 0 === this.length; }
-    /** Returns an iterator over the contents of the heap suitable for use in `for-of` loops. */
-    [Symbol.iterator]() { return this._array[Symbol.iterator](); }
-    _swap(a, b) {
-        const temp = this._array[a];
-        this._array[a] = this._array[b];
-        this._array[b] = temp;
-    }
-    _heapify(index) {
-        let candidate = -1;
-        while (true) {
-            const right = 2 * (index + 1);
-            const left = right - 1;
-            if (left < this.length && this._compare(this._array[left], this._array[index]) < 0)
-                candidate = left;
-            else
-                candidate = index;
-            if (right < this.length && this._compare(this._array[right], this._array[candidate]) < 0)
-                candidate = right;
-            if (candidate !== index) {
-                this._swap(candidate, index);
-                index = candidate;
-            }
-            else {
-                break;
-            }
-        }
-    }
-    /**
-     * Reorders the queue. This function should only (and *always*) be called when the criteria governing the ordering of items on the queue have changed.
-     * For example, a priority queue containing graphics sorted by their distance from the camera would need to be reordered when the position of the camera changes.
-     */
-    sort() {
-        for (let i = Math.ceil(this.length / 2); i >= 0; i--)
-            this._heapify(i);
-    }
-    /**
-     * Pushes a value onto the queue according to the sorting criterion.
-     * @param value The value to insert
-     * @returns The inserted value, cloned according to the [[CloneFunction]] supplied to this queue's constructor.
-     */
-    push(value) {
-        const clone = this._clone(value);
-        let index = this.length;
-        this._array.push(clone);
-        while (index !== 0) {
-            const parent = Math.floor((index - 1) / 2);
-            if (this._compare(this._array[index], this._array[parent]) < 0) {
-                this._swap(index, parent);
-                index = parent;
-            }
-            else {
-                break;
-            }
-        }
-        return clone;
-    }
-    /** Pushes a value onto the back of the queue without making any attempt to enforce ordering.
-     * After using this function, you must manually invoke sort() to ensure the queue is sorted again.
-     * @param value The value to append
-     * @returns The appended value, cloned according to the [[CloneFunction]] supplied to this queue's constructor.
-     */
-    append(value) {
-        const clone = this._clone(value);
-        this._array.push(clone);
-        return clone;
-    }
-    /** Returns the element at the front of the queue, or `undefined` if the queue is empty. */
-    get front() {
-        return this._peek(0);
-    }
-    /**
-     * Removes the front-most element off of the queue and returns it.
-     * @returns The front-most element, or undefined if the queue is empty.
-     */
-    pop() {
-        return this._pop(0);
-    }
-    /** Removes all values from the queue. */
-    clear() {
-        this._array.length = 0;
-    }
-    /**
-     * Removes the value at the specified index from the queue and reorders the queue.
-     * @param index The index of the value to remove
-     * @returns the value at the specified index, or undefined if the index is out of range.
-     */
-    _pop(index) {
-        if (index < 0 || index >= this.length)
-            return undefined;
-        const root = this._array[index];
-        this._swap(index, this.length - 1);
-        this._array.length--;
-        this._heapify(index);
-        return root;
-    }
-    /**
-     * Returns the value at the specified index in the queue.
-     * @param index The index of the value to retrieve
-     * @returns the value at the specified index, or undefined if the index is out of range.
-     */
-    _peek(index) {
-        if (index < 0 || index >= this.length)
-            return undefined;
-        else
-            return this._array[index];
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Collections
+ */
+import { shallowClone } from "./SortedArray";
+/**
+ * A [priority queue](https://en.wikipedia.org/wiki/Priority_queue) implemented as a heap array.
+ * The queue is ordered by an [[OrderedComparator]] function supplied by the user such that the value in the queue that compares less than all other values is always located at the front of the queue.
+ * @public
+ */
+export class PriorityQueue {
+    /**
+     * Constructor
+     * @param compare The function used to compare values in the queue. If `compare(x, y)` returns a negative value, then x is placed before y in the queue.
+     * @param clone The function used to clone a value for insertion onto the queue. The default implementation simply returns its input.
+     * @note If the criterion which control the result of the `compare` function changes, then [[PriorityQueue.sort]] should be used to reorder the queue according to the new criterion.
+     */
+    constructor(compare, clone = shallowClone) {
+        this._array = [];
+        this._compare = compare;
+        this._clone = clone;
+    }
+    /** The number of values in the queue. */
+    get length() { return this._array.length; }
+    /** Returns true if the queue contains no values. */
+    get isEmpty() { return 0 === this.length; }
+    /** Returns an iterator over the contents of the heap suitable for use in `for-of` loops. */
+    [Symbol.iterator]() { return this._array[Symbol.iterator](); }
+    _swap(a, b) {
+        const temp = this._array[a];
+        this._array[a] = this._array[b];
+        this._array[b] = temp;
+    }
+    _heapify(index) {
+        let candidate = -1;
+        while (true) {
+            const right = 2 * (index + 1);
+            const left = right - 1;
+            if (left < this.length && this._compare(this._array[left], this._array[index]) < 0)
+                candidate = left;
+            else
+                candidate = index;
+            if (right < this.length && this._compare(this._array[right], this._array[candidate]) < 0)
+                candidate = right;
+            if (candidate !== index) {
+                this._swap(candidate, index);
+                index = candidate;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * Reorders the queue. This function should only (and *always*) be called when the criteria governing the ordering of items on the queue have changed.
+     * For example, a priority queue containing graphics sorted by their distance from the camera would need to be reordered when the position of the camera changes.
+     */
+    sort() {
+        for (let i = Math.ceil(this.length / 2); i >= 0; i--)
+            this._heapify(i);
+    }
+    /**
+     * Pushes a value onto the queue according to the sorting criterion.
+     * @param value The value to insert
+     * @returns The inserted value, cloned according to the [[CloneFunction]] supplied to this queue's constructor.
+     */
+    push(value) {
+        const clone = this._clone(value);
+        let index = this.length;
+        this._array.push(clone);
+        while (index !== 0) {
+            const parent = Math.floor((index - 1) / 2);
+            if (this._compare(this._array[index], this._array[parent]) < 0) {
+                this._swap(index, parent);
+                index = parent;
+            }
+            else {
+                break;
+            }
+        }
+        return clone;
+    }
+    /** Pushes a value onto the back of the queue without making any attempt to enforce ordering.
+     * After using this function, you must manually invoke sort() to ensure the queue is sorted again.
+     * @param value The value to append
+     * @returns The appended value, cloned according to the [[CloneFunction]] supplied to this queue's constructor.
+     */
+    append(value) {
+        const clone = this._clone(value);
+        this._array.push(clone);
+        return clone;
+    }
+    /** Returns the element at the front of the queue, or `undefined` if the queue is empty. */
+    get front() {
+        return this._peek(0);
+    }
+    /**
+     * Removes the front-most element off of the queue and returns it.
+     * @returns The front-most element, or undefined if the queue is empty.
+     */
+    pop() {
+        return this._pop(0);
+    }
+    /** Removes all values from the queue. */
+    clear() {
+        this._array.length = 0;
+    }
+    /**
+     * Removes the value at the specified index from the queue and reorders the queue.
+     * @param index The index of the value to remove
+     * @returns the value at the specified index, or undefined if the index is out of range.
+     */
+    _pop(index) {
+        if (index < 0 || index >= this.length)
+            return undefined;
+        const root = this._array[index];
+        this._swap(index, this.length - 1);
+        this._array.length--;
+        this._heapify(index);
+        return root;
+    }
+    /**
+     * Returns the value at the specified index in the queue.
+     * @param index The index of the value to retrieve
+     * @returns the value at the specified index, or undefined if the index is out of range.
+     */
+    _peek(index) {
+        if (index < 0 || index >= this.length)
+            return undefined;
+        else
+            return this._array[index];
+    }
+}
 //# sourceMappingURL=PriorityQueue.js.map