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

package/lib/esm/ByteStream.js

@@ -1,156 +1,156 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Utils
- */
-import { assert } from "./Assert";
-import { Id64 } from "./Id";
-/** Allows the contents of an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
- * to be consumed sequentially using methods to extract
- * data of a particular type from the bytes beginning at the current read position.
- * Methods and properties beginning with 'read' and taking no arguments consume data at the current read position and advance it
- * by the size of the data read. The read position can also be directly adjusted by the caller.
- * @public
- */
-export class ByteStream {
-    /** Construct a new ByteStream with the read position set to the beginning.
-     * @param buffer The underlying buffer from which data is to be extracted.
-     * @param subView If defined, specifies the subset of the underlying buffer's data to use.
-     * This constructor is subject to two common mistakes:
-     *
-     * 1. Given `bytes: Uint8Array`, `new ByteStream(bytes)` will compile but at run-time will produce an error asserting that
-     * the DataView constructor requires an ArrayBuffer. The correct usage is `new ByteStream(bytes.buffer)`.
-     * 2. Given `bytes: Uint8Array`, `new ByteStream(bytes.buffer)` creates a stream for the entire range of bytes represented by the underlying
-     * ArrayBuffer. If `bytes` represents only a **sub-range** of the underlying buffer's data, the results will be unexpected unless the optional `subView`
-     * argument is supplied, with correct offset and length.
-     *
-     * For both of the above reasons, prefer to use [[fromUint8Array]].
-     * @deprecated in 3.x. Use [[fromUint8Array]] or [[fromArrayBuffer]].
-     */
-    constructor(buffer, subView) {
-        this._curPos = 0;
-        if (undefined !== subView) {
-            this._view = new DataView(buffer, subView.byteOffset, subView.byteLength);
-            this._byteOffset = subView.byteOffset;
-        }
-        else {
-            this._view = new DataView(buffer);
-            this._byteOffset = 0;
-        }
-    }
-    /** Construct a new ByteStream for the range of bytes represented by `bytes`, which may be a subset of the range of bytes
-     * represented by the underlying ArrayBuffer. The read position will be set to the beginning of the range of bytes.
-     */
-    static fromUint8Array(bytes) {
-        const { byteOffset, byteLength } = bytes;
-        return new ByteStream(bytes.buffer, { byteOffset, byteLength }); // eslint-disable-line deprecation/deprecation
-    }
-    /** Construct a new ByteStream with the read position set to the beginning.
-     * @param buffer The underlying buffer from which data is to be extracted.
-     * @param subView If defined, specifies the subset of the underlying buffer's data to use.
-     */
-    static fromArrayBuffer(buffer, subView) {
-        return new ByteStream(buffer, subView); // eslint-disable-line deprecation/deprecation
-    }
-    /** The number of bytes in this stream */
-    get length() {
-        return this._view.byteLength;
-    }
-    /** The number of bytes remaining to be read, from [[curPos]] to the end of the stream. */
-    get remainingLength() {
-        return this.length - this.curPos;
-    }
-    /** Returns true if the current read position has been advanced past the end of the stream. This generally indicates that an attempt was made to read more data than is available.
-     * @see [[isAtTheEnd]]
-     */
-    get isPastTheEnd() {
-        return this.curPos > this.length;
-    }
-    /** Returns true if the current read position has advanced precisely to the end of the stream, indicating all of the data has been consumed.
-     * @see [[isPastTheEnd]].
-     */
-    get isAtTheEnd() {
-        return this.curPos === this.length;
-    }
-    /** The current read position as an index into the stream of bytes. */
-    get curPos() { return this._curPos; }
-    set curPos(pos) {
-        this._curPos = pos;
-        assert(!this.isPastTheEnd);
-    }
-    /** Adds the specified number of bytes to the current read position */
-    advance(numBytes) {
-        this.curPos = (this.curPos + numBytes);
-        return !this.isPastTheEnd;
-    }
-    /** Subtracts the specified number of bytes from the current read position */
-    rewind(numBytes) {
-        if (this.curPos - numBytes < 0)
-            return false;
-        this.curPos = this.curPos - numBytes;
-        return true;
-    }
-    /** Resets the current read position to the beginning of the stream */
-    reset() { this.curPos = 0; }
-    /** Read a unsigned 8-bit integer from the current read position and advance by 1 byte. */
-    readUint8() { return this.read(1, (view) => view.getUint8(this.curPos)); }
-    /** Read an unsigned 16-bit integer from the current read position and advance by 2 bytes. */
-    readUint16() { return this.read(2, (view) => view.getUint16(this.curPos, true)); }
-    /** Read an unsigned 32-bit integer from the current read position and advance by 4 bytes. */
-    readUint32() { return this.read(4, (view) => view.getUint32(this.curPos, true)); }
-    /** Read a signed 32-bit integer from the current read position and advance by 4 bytes. */
-    readInt32() { return this.read(4, (view) => view.getInt32(this.curPos, true)); }
-    /** Read a 32-bit floating point number from the current read position and advance by 4 bytes. */
-    readFloat32() { return this.read(4, (view) => view.getFloat32(this.curPos, true)); }
-    /** Read a 64-bit floating point number from the current read position and advance by 8 bytes. */
-    readFloat64() { return this.read(8, (view) => view.getFloat64(this.curPos, true)); }
-    /** Read an unsigned 64-bit integer from the current read position, advance by 8 bytes, and return the 64-bit value as an Id64String. */
-    readId64() { return Id64.fromUint32Pair(this.readUint32(), this.readUint32()); }
-    /** Read an unsigned 24-bit integer from the current read position and advance by 3 bytes. */
-    readUint24() { return this.readUint8() | (this.readUint8() << 8) | (this.readUint8() << 16); }
-    /** @deprecated in 3.x. use [[readUint8]]. */
-    get nextUint8() { return this.readUint8(); }
-    /** @deprecated in 3.x. use [[readUint16]]. */
-    get nextUint16() { return this.readUint16(); }
-    /** @deprecated in 3.x. use [[readUint32]]. */
-    get nextUint32() { return this.readUint32(); }
-    /** @deprecated in 3.x. use [[readInt32]]. */
-    get nextInt32() { return this.readInt32(); }
-    /** @deprecated in 3.x. use [[readFloat32]]. */
-    get nextFloat32() { return this.readFloat32(); }
-    /** @deprecated in 3.x. use [[readFloat64]]. */
-    get nextFloat64() { return this.readFloat64(); }
-    /** @deprecated in 3.x. use [[readId64]]. */
-    get nextId64() { return this.readId64(); }
-    /** @deprecated in 3.x. use [[readUint32]]. */
-    get nextUint24() { return this.readUint24(); }
-    /** Read the specified number of bytes beginning at the current read position into a Uint8Array and advance by the specified number of byte.
-     * @param numBytes The number of bytes to read.
-     */
-    nextBytes(numBytes) {
-        const bytes = new Uint8Array(this.arrayBuffer, this.curPos + this._byteOffset, numBytes);
-        this.advance(numBytes);
-        return bytes;
-    }
-    /** Read the specified number of bytes at the specified offset without changing the read position. */
-    readBytes(readPos, numBytes) {
-        return new Uint8Array(this.arrayBuffer, readPos + this._byteOffset, numBytes);
-    }
-    /** Read the specified number of unsigned 32-bit integers from the current read position and advance the read position. */
-    nextUint32s(numUint32s) {
-        const numBytes = numUint32s * 4;
-        const uint32s = new Uint32Array(this.arrayBuffer, this.curPos + this._byteOffset, numUint32s);
-        this.advance(numBytes);
-        return uint32s;
-    }
-    /** Returns the underlying array buffer */
-    get arrayBuffer() { return this._view.buffer; }
-    read(numBytes, read) {
-        const result = read(this._view);
-        this.advance(numBytes);
-        return result;
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Utils
+ */
+import { assert } from "./Assert";
+import { Id64 } from "./Id";
+/** Allows the contents of an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer)
+ * to be consumed sequentially using methods to extract
+ * data of a particular type from the bytes beginning at the current read position.
+ * Methods and properties beginning with 'read' and taking no arguments consume data at the current read position and advance it
+ * by the size of the data read. The read position can also be directly adjusted by the caller.
+ * @public
+ */
+export class ByteStream {
+    /** Construct a new ByteStream with the read position set to the beginning.
+     * @param buffer The underlying buffer from which data is to be extracted.
+     * @param subView If defined, specifies the subset of the underlying buffer's data to use.
+     * This constructor is subject to two common mistakes:
+     *
+     * 1. Given `bytes: Uint8Array`, `new ByteStream(bytes)` will compile but at run-time will produce an error asserting that
+     * the DataView constructor requires an ArrayBuffer. The correct usage is `new ByteStream(bytes.buffer)`.
+     * 2. Given `bytes: Uint8Array`, `new ByteStream(bytes.buffer)` creates a stream for the entire range of bytes represented by the underlying
+     * ArrayBuffer. If `bytes` represents only a **sub-range** of the underlying buffer's data, the results will be unexpected unless the optional `subView`
+     * argument is supplied, with correct offset and length.
+     *
+     * For both of the above reasons, prefer to use [[fromUint8Array]].
+     * @deprecated in 3.x. Use [[fromUint8Array]] or [[fromArrayBuffer]].
+     */
+    constructor(buffer, subView) {
+        this._curPos = 0;
+        if (undefined !== subView) {
+            this._view = new DataView(buffer, subView.byteOffset, subView.byteLength);
+            this._byteOffset = subView.byteOffset;
+        }
+        else {
+            this._view = new DataView(buffer);
+            this._byteOffset = 0;
+        }
+    }
+    /** Construct a new ByteStream for the range of bytes represented by `bytes`, which may be a subset of the range of bytes
+     * represented by the underlying ArrayBuffer. The read position will be set to the beginning of the range of bytes.
+     */
+    static fromUint8Array(bytes) {
+        const { byteOffset, byteLength } = bytes;
+        return new ByteStream(bytes.buffer, { byteOffset, byteLength }); // eslint-disable-line deprecation/deprecation
+    }
+    /** Construct a new ByteStream with the read position set to the beginning.
+     * @param buffer The underlying buffer from which data is to be extracted.
+     * @param subView If defined, specifies the subset of the underlying buffer's data to use.
+     */
+    static fromArrayBuffer(buffer, subView) {
+        return new ByteStream(buffer, subView); // eslint-disable-line deprecation/deprecation
+    }
+    /** The number of bytes in this stream */
+    get length() {
+        return this._view.byteLength;
+    }
+    /** The number of bytes remaining to be read, from [[curPos]] to the end of the stream. */
+    get remainingLength() {
+        return this.length - this.curPos;
+    }
+    /** Returns true if the current read position has been advanced past the end of the stream. This generally indicates that an attempt was made to read more data than is available.
+     * @see [[isAtTheEnd]]
+     */
+    get isPastTheEnd() {
+        return this.curPos > this.length;
+    }
+    /** Returns true if the current read position has advanced precisely to the end of the stream, indicating all of the data has been consumed.
+     * @see [[isPastTheEnd]].
+     */
+    get isAtTheEnd() {
+        return this.curPos === this.length;
+    }
+    /** The current read position as an index into the stream of bytes. */
+    get curPos() { return this._curPos; }
+    set curPos(pos) {
+        this._curPos = pos;
+        assert(!this.isPastTheEnd);
+    }
+    /** Adds the specified number of bytes to the current read position */
+    advance(numBytes) {
+        this.curPos = (this.curPos + numBytes);
+        return !this.isPastTheEnd;
+    }
+    /** Subtracts the specified number of bytes from the current read position */
+    rewind(numBytes) {
+        if (this.curPos - numBytes < 0)
+            return false;
+        this.curPos = this.curPos - numBytes;
+        return true;
+    }
+    /** Resets the current read position to the beginning of the stream */
+    reset() { this.curPos = 0; }
+    /** Read a unsigned 8-bit integer from the current read position and advance by 1 byte. */
+    readUint8() { return this.read(1, (view) => view.getUint8(this.curPos)); }
+    /** Read an unsigned 16-bit integer from the current read position and advance by 2 bytes. */
+    readUint16() { return this.read(2, (view) => view.getUint16(this.curPos, true)); }
+    /** Read an unsigned 32-bit integer from the current read position and advance by 4 bytes. */
+    readUint32() { return this.read(4, (view) => view.getUint32(this.curPos, true)); }
+    /** Read a signed 32-bit integer from the current read position and advance by 4 bytes. */
+    readInt32() { return this.read(4, (view) => view.getInt32(this.curPos, true)); }
+    /** Read a 32-bit floating point number from the current read position and advance by 4 bytes. */
+    readFloat32() { return this.read(4, (view) => view.getFloat32(this.curPos, true)); }
+    /** Read a 64-bit floating point number from the current read position and advance by 8 bytes. */
+    readFloat64() { return this.read(8, (view) => view.getFloat64(this.curPos, true)); }
+    /** Read an unsigned 64-bit integer from the current read position, advance by 8 bytes, and return the 64-bit value as an Id64String. */
+    readId64() { return Id64.fromUint32Pair(this.readUint32(), this.readUint32()); }
+    /** Read an unsigned 24-bit integer from the current read position and advance by 3 bytes. */
+    readUint24() { return this.readUint8() | (this.readUint8() << 8) | (this.readUint8() << 16); }
+    /** @deprecated in 3.x. use [[readUint8]]. */
+    get nextUint8() { return this.readUint8(); }
+    /** @deprecated in 3.x. use [[readUint16]]. */
+    get nextUint16() { return this.readUint16(); }
+    /** @deprecated in 3.x. use [[readUint32]]. */
+    get nextUint32() { return this.readUint32(); }
+    /** @deprecated in 3.x. use [[readInt32]]. */
+    get nextInt32() { return this.readInt32(); }
+    /** @deprecated in 3.x. use [[readFloat32]]. */
+    get nextFloat32() { return this.readFloat32(); }
+    /** @deprecated in 3.x. use [[readFloat64]]. */
+    get nextFloat64() { return this.readFloat64(); }
+    /** @deprecated in 3.x. use [[readId64]]. */
+    get nextId64() { return this.readId64(); }
+    /** @deprecated in 3.x. use [[readUint32]]. */
+    get nextUint24() { return this.readUint24(); }
+    /** Read the specified number of bytes beginning at the current read position into a Uint8Array and advance by the specified number of byte.
+     * @param numBytes The number of bytes to read.
+     */
+    nextBytes(numBytes) {
+        const bytes = new Uint8Array(this.arrayBuffer, this.curPos + this._byteOffset, numBytes);
+        this.advance(numBytes);
+        return bytes;
+    }
+    /** Read the specified number of bytes at the specified offset without changing the read position. */
+    readBytes(readPos, numBytes) {
+        return new Uint8Array(this.arrayBuffer, readPos + this._byteOffset, numBytes);
+    }
+    /** Read the specified number of unsigned 32-bit integers from the current read position and advance the read position. */
+    nextUint32s(numUint32s) {
+        const numBytes = numUint32s * 4;
+        const uint32s = new Uint32Array(this.arrayBuffer, this.curPos + this._byteOffset, numUint32s);
+        this.advance(numBytes);
+        return uint32s;
+    }
+    /** Returns the underlying array buffer */
+    get arrayBuffer() { return this._view.buffer; }
+    read(numBytes, read) {
+        const result = read(this._view);
+        this.advance(numBytes);
+        return result;
+    }
+}
 //# sourceMappingURL=ByteStream.js.map

package/lib/esm/ClassUtils.d.ts

@@ -1,15 +1,15 @@
-/** Check if class `subclass` is a different class from `superclass` but extends from `superclass`
- * @internal
- * @param subclass the class that may be a subclass of `superclass`
- * @param superclass the class that may be a base class of `subclass`
- * @returns whether `subclass` is a proper subclass of `superclass`
- */
-export declare function isProperSubclassOf<SuperClass extends new (..._: any[]) => any, NonSubClass extends new (..._: any[]) => any, SubClass extends new (..._: any[]) => InstanceType<SuperClass>>(subclass: SubClass | NonSubClass, superclass: SuperClass): subclass is SubClass;
-/** Check if class `subclass` is `superclass` or extends from `superclass`
- * @internal
- * @param subclass the class that may be a subclass of `superclass`
- * @param superclass the class that may be a base class of `subclass`
- * @returns whether `subclass` is a subclass of `superclass`
- */
-export declare function isSubclassOf<SuperClass extends new (..._: any[]) => any, NonSubClass extends new (..._: any[]) => any, SubClass extends new (..._: any[]) => InstanceType<SuperClass>>(subclass: SuperClass | SubClass | NonSubClass, superclass: SuperClass): subclass is SubClass | SuperClass;
+/** Check if class `subclass` is a different class from `superclass` but extends from `superclass`
+ * @internal
+ * @param subclass the class that may be a subclass of `superclass`
+ * @param superclass the class that may be a base class of `subclass`
+ * @returns whether `subclass` is a proper subclass of `superclass`
+ */
+export declare function isProperSubclassOf<SuperClass extends new (..._: any[]) => any, NonSubClass extends new (..._: any[]) => any, SubClass extends new (..._: any[]) => InstanceType<SuperClass>>(subclass: SubClass | NonSubClass, superclass: SuperClass): subclass is SubClass;
+/** Check if class `subclass` is `superclass` or extends from `superclass`
+ * @internal
+ * @param subclass the class that may be a subclass of `superclass`
+ * @param superclass the class that may be a base class of `subclass`
+ * @returns whether `subclass` is a subclass of `superclass`
+ */
+export declare function isSubclassOf<SuperClass extends new (..._: any[]) => any, NonSubClass extends new (..._: any[]) => any, SubClass extends new (..._: any[]) => InstanceType<SuperClass>>(subclass: SuperClass | SubClass | NonSubClass, superclass: SuperClass): subclass is SubClass | SuperClass;
 //# sourceMappingURL=ClassUtils.d.ts.map

package/lib/esm/ClassUtils.js

@@ -1,23 +1,23 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** Check if class `subclass` is a different class from `superclass` but extends from `superclass`
- * @internal
- * @param subclass the class that may be a subclass of `superclass`
- * @param superclass the class that may be a base class of `subclass`
- * @returns whether `subclass` is a proper subclass of `superclass`
- */
-export function isProperSubclassOf(subclass, superclass) {
-    return subclass.prototype instanceof superclass;
-}
-/** Check if class `subclass` is `superclass` or extends from `superclass`
- * @internal
- * @param subclass the class that may be a subclass of `superclass`
- * @param superclass the class that may be a base class of `subclass`
- * @returns whether `subclass` is a subclass of `superclass`
- */
-export function isSubclassOf(subclass, superclass) {
-    return subclass === superclass || isProperSubclassOf(subclass, superclass);
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** Check if class `subclass` is a different class from `superclass` but extends from `superclass`
+ * @internal
+ * @param subclass the class that may be a subclass of `superclass`
+ * @param superclass the class that may be a base class of `subclass`
+ * @returns whether `subclass` is a proper subclass of `superclass`
+ */
+export function isProperSubclassOf(subclass, superclass) {
+    return subclass.prototype instanceof superclass;
+}
+/** Check if class `subclass` is `superclass` or extends from `superclass`
+ * @internal
+ * @param subclass the class that may be a subclass of `superclass`
+ * @param superclass the class that may be a base class of `subclass`
+ * @returns whether `subclass` is a subclass of `superclass`
+ */
+export function isSubclassOf(subclass, superclass) {
+    return subclass === superclass || isProperSubclassOf(subclass, superclass);
+}
 //# sourceMappingURL=ClassUtils.js.map

package/lib/esm/Compare.d.ts

@@ -1,48 +1,48 @@
-/** @packageDocumentation
- * @module Utils
- */
-/**
- * A function that returns a numerical value indicating how two objects are ordered in relation to one another.
- * Such functions are used by various collection classes throughout the library.
- * Given values `lhs` and `rhs`, the function returns:
- *  - Zero if lhs == rhs
- *  - A negative number if lhs < rhs
- *  - A positive number if lhs > rhs
- *
- * An OrderedComparator `must` implement [strict weak ordering](https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings), which can be summarized by the following rules:
- *  - `compare(x, x)` returns zero.
- *  - If `compare(x, y)` returns zero, then so does `compare(y, x)` (i.e., `x == y` implies `y == x`).
- *  - If `compare(x, y)` returns non-zero, then `compare(y, x)` returns a value with an opposite sign (i.e., `x < y` implies `y > x`).
- *  - If `compare(x, y)` and `compare(y, z)` return non-zero values with the same sign, then `compare(x, z)` returns a value with the same sign (i.e., `x < y < z` implies `x < z`).
- *
- * @see SortedArray
- * @see Dictionary
- * @see IndexMap
- * @see PriorityQueue
- * @public
- */
-export declare type OrderedComparator<T, U = T> = (lhs: T, rhs: U) => number;
-/**
- * An [[OrderedComparator]] for numbers that treats two numbers as equal if the absolute value of their difference is less than a specified tolerance.
- * @public
- */
-export declare function compareWithTolerance(a: number, b: number, tolerance?: number): number;
-/** @public */
-export declare function compareNumbers(a: number, b: number): number;
-/** @public */
-export declare function compareBooleans(a: boolean, b: boolean): number;
-/** @public */
-export declare function compareStrings(a: string, b: string): number;
-/** @public */
-export declare function comparePossiblyUndefined<T>(compareDefined: (lhs: T, rhs: T) => number, lhs?: T, rhs?: T): number;
-/** @public */
-export declare function compareStringsOrUndefined(lhs?: string, rhs?: string): number;
-/** @public */
-export declare function compareNumbersOrUndefined(lhs?: number, rhs?: number): number;
-/** @public */
-export declare function compareBooleansOrUndefined(lhs?: boolean, rhs?: boolean): number;
-/** Compare two possibly-undefined values for equality. If both are undefined, the comparison is performed by the supplied `areEqual` function.
- * @public
- */
-export declare function areEqualPossiblyUndefined<T, U>(t: T | undefined, u: U | undefined, areEqual: (t: T, u: U) => boolean): boolean;
+/** @packageDocumentation
+ * @module Utils
+ */
+/**
+ * A function that returns a numerical value indicating how two objects are ordered in relation to one another.
+ * Such functions are used by various collection classes throughout the library.
+ * Given values `lhs` and `rhs`, the function returns:
+ *  - Zero if lhs == rhs
+ *  - A negative number if lhs < rhs
+ *  - A positive number if lhs > rhs
+ *
+ * An OrderedComparator `must` implement [strict weak ordering](https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings), which can be summarized by the following rules:
+ *  - `compare(x, x)` returns zero.
+ *  - If `compare(x, y)` returns zero, then so does `compare(y, x)` (i.e., `x == y` implies `y == x`).
+ *  - If `compare(x, y)` returns non-zero, then `compare(y, x)` returns a value with an opposite sign (i.e., `x < y` implies `y > x`).
+ *  - If `compare(x, y)` and `compare(y, z)` return non-zero values with the same sign, then `compare(x, z)` returns a value with the same sign (i.e., `x < y < z` implies `x < z`).
+ *
+ * @see SortedArray
+ * @see Dictionary
+ * @see IndexMap
+ * @see PriorityQueue
+ * @public
+ */
+export type OrderedComparator<T, U = T> = (lhs: T, rhs: U) => number;
+/**
+ * An [[OrderedComparator]] for numbers that treats two numbers as equal if the absolute value of their difference is less than a specified tolerance.
+ * @public
+ */
+export declare function compareWithTolerance(a: number, b: number, tolerance?: number): number;
+/** @public */
+export declare function compareNumbers(a: number, b: number): number;
+/** @public */
+export declare function compareBooleans(a: boolean, b: boolean): number;
+/** @public */
+export declare function compareStrings(a: string, b: string): number;
+/** @public */
+export declare function comparePossiblyUndefined<T>(compareDefined: (lhs: T, rhs: T) => number, lhs?: T, rhs?: T): number;
+/** @public */
+export declare function compareStringsOrUndefined(lhs?: string, rhs?: string): number;
+/** @public */
+export declare function compareNumbersOrUndefined(lhs?: number, rhs?: number): number;
+/** @public */
+export declare function compareBooleansOrUndefined(lhs?: boolean, rhs?: boolean): number;
+/** Compare two possibly-undefined values for equality. If both are undefined, the comparison is performed by the supplied `areEqual` function.
+ * @public
+ */
+export declare function areEqualPossiblyUndefined<T, U>(t: T | undefined, u: U | undefined, areEqual: (t: T, u: U) => boolean): boolean;
 //# sourceMappingURL=Compare.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Compare.d.ts","sourceRoot":"","sources":["../../src/Compare.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,oBAAY,iBAAiB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,MAAM,CAAC;AAErE;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,SAAM,GAAG,MAAM,CAOlF;AAED,cAAc;AACd,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,cAAc;AACd,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAE9D;AAED,cAAc;AACd,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,cAAc;AACd,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAOhH;AAED,cAAc;AACd,wBAAgB,yBAAyB,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,cAAc;AACd,wBAAgB,yBAAyB,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,cAAc;AACd,wBAAgB,0BAA0B,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,MAAM,CAE/E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAO9H"}
+{"version":3,"file":"Compare.d.ts","sourceRoot":"","sources":["../../src/Compare.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,MAAM,CAAC;AAErE;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,SAAM,GAAG,MAAM,CAOlF;AAED,cAAc;AACd,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,cAAc;AACd,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAE9D;AAED,cAAc;AACd,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,cAAc;AACd,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAOhH;AAED,cAAc;AACd,wBAAgB,yBAAyB,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,cAAc;AACd,wBAAgB,yBAAyB,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED,cAAc;AACd,wBAAgB,0BAA0B,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,MAAM,CAE/E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAO9H"}

package/lib/esm/Compare.js

@@ -1,64 +1,64 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Utils
- */
-/**
- * An [[OrderedComparator]] for numbers that treats two numbers as equal if the absolute value of their difference is less than a specified tolerance.
- * @public
- */
-export function compareWithTolerance(a, b, tolerance = 0.1) {
-    if (a < b - tolerance)
-        return -1;
-    else if (a > b + tolerance)
-        return 1;
-    else
-        return 0;
-}
-/** @public */
-export function compareNumbers(a, b) {
-    return a - b;
-}
-/** @public */
-export function compareBooleans(a, b) {
-    return a !== b ? (a < b ? -1 : 1) : 0;
-}
-/** @public */
-export function compareStrings(a, b) {
-    return a === b ? 0 : (a < b ? -1 : 1);
-}
-/** @public */
-export function comparePossiblyUndefined(compareDefined, lhs, rhs) {
-    if (undefined === lhs)
-        return undefined === rhs ? 0 : -1;
-    else if (undefined === rhs)
-        return 1;
-    else
-        return compareDefined(lhs, rhs);
-}
-/** @public */
-export function compareStringsOrUndefined(lhs, rhs) {
-    return comparePossiblyUndefined(compareStrings, lhs, rhs);
-}
-/** @public */
-export function compareNumbersOrUndefined(lhs, rhs) {
-    return comparePossiblyUndefined(compareNumbers, lhs, rhs);
-}
-/** @public */
-export function compareBooleansOrUndefined(lhs, rhs) {
-    return comparePossiblyUndefined(compareBooleans, lhs, rhs);
-}
-/** Compare two possibly-undefined values for equality. If both are undefined, the comparison is performed by the supplied `areEqual` function.
- * @public
- */
-export function areEqualPossiblyUndefined(t, u, areEqual) {
-    if (undefined === t)
-        return undefined === u;
-    else if (undefined === u)
-        return false;
-    else
-        return areEqual(t, u);
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Utils
+ */
+/**
+ * An [[OrderedComparator]] for numbers that treats two numbers as equal if the absolute value of their difference is less than a specified tolerance.
+ * @public
+ */
+export function compareWithTolerance(a, b, tolerance = 0.1) {
+    if (a < b - tolerance)
+        return -1;
+    else if (a > b + tolerance)
+        return 1;
+    else
+        return 0;
+}
+/** @public */
+export function compareNumbers(a, b) {
+    return a - b;
+}
+/** @public */
+export function compareBooleans(a, b) {
+    return a !== b ? (a < b ? -1 : 1) : 0;
+}
+/** @public */
+export function compareStrings(a, b) {
+    return a === b ? 0 : (a < b ? -1 : 1);
+}
+/** @public */
+export function comparePossiblyUndefined(compareDefined, lhs, rhs) {
+    if (undefined === lhs)
+        return undefined === rhs ? 0 : -1;
+    else if (undefined === rhs)
+        return 1;
+    else
+        return compareDefined(lhs, rhs);
+}
+/** @public */
+export function compareStringsOrUndefined(lhs, rhs) {
+    return comparePossiblyUndefined(compareStrings, lhs, rhs);
+}
+/** @public */
+export function compareNumbersOrUndefined(lhs, rhs) {
+    return comparePossiblyUndefined(compareNumbers, lhs, rhs);
+}
+/** @public */
+export function compareBooleansOrUndefined(lhs, rhs) {
+    return comparePossiblyUndefined(compareBooleans, lhs, rhs);
+}
+/** Compare two possibly-undefined values for equality. If both are undefined, the comparison is performed by the supplied `areEqual` function.
+ * @public
+ */
+export function areEqualPossiblyUndefined(t, u, areEqual) {
+    if (undefined === t)
+        return undefined === u;
+    else if (undefined === u)
+        return false;
+    else
+        return areEqual(t, u);
+}
 //# sourceMappingURL=Compare.js.map