@itwin/core-bentley 3.6.0-dev.65 → 3.6.0-dev.66

package/lib/cjs/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/cjs/ClassUtils.js

@@ -1,28 +1,28 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSubclassOf = exports.isProperSubclassOf = void 0;
-/** 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`
- */
-function isProperSubclassOf(subclass, superclass) {
-    return subclass.prototype instanceof superclass;
-}
-exports.isProperSubclassOf = isProperSubclassOf;
-/** 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`
- */
-function isSubclassOf(subclass, superclass) {
-    return subclass === superclass || isProperSubclassOf(subclass, superclass);
-}
-exports.isSubclassOf = isSubclassOf;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSubclassOf = exports.isProperSubclassOf = void 0;
+/** 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`
+ */
+function isProperSubclassOf(subclass, superclass) {
+    return subclass.prototype instanceof superclass;
+}
+exports.isProperSubclassOf = isProperSubclassOf;
+/** 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`
+ */
+function isSubclassOf(subclass, superclass) {
+    return subclass === superclass || isProperSubclassOf(subclass, superclass);
+}
+exports.isSubclassOf = isSubclassOf;
 //# sourceMappingURL=ClassUtils.js.map

package/lib/cjs/ClassUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"ClassUtils.js","sourceRoot":"","sources":["../../src/ClassUtils.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;;;AAE/F;;;;;GAKG;AACH,SAAgB,kBAAkB,CAIhC,QAAgC,EAAE,UAAsB;IACxD,OAAO,QAAQ,CAAC,SAAS,YAAY,UAAU,CAAC;AAClD,CAAC;AAND,gDAMC;AAED;;;;;GAKG;AACH,SAAgB,YAAY,CAI1B,QAA6C,EAAE,UAAsB;IACrE,OAAO,QAAQ,KAAK,UAAU,IAAI,kBAAkB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;AAC7E,CAAC;AAND,oCAMC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n\n/** Check if class `subclass` is a different class from `superclass` but extends from `superclass`\n * @internal\n * @param subclass the class that may be a subclass of `superclass`\n * @param superclass the class that may be a base class of `subclass`\n * @returns whether `subclass` is a proper subclass of `superclass`\n */\nexport function isProperSubclassOf<\n  SuperClass extends new (..._: any[]) => any,\n  NonSubClass extends new (..._: any[]) => any,\n  SubClass extends new (..._: any[]) => InstanceType<SuperClass>,\n>(subclass: SubClass | NonSubClass, superclass: SuperClass): subclass is SubClass {\n  return subclass.prototype instanceof superclass;\n}\n\n/** Check if class `subclass` is `superclass` or extends from `superclass`\n * @internal\n * @param subclass the class that may be a subclass of `superclass`\n * @param superclass the class that may be a base class of `subclass`\n * @returns whether `subclass` is a subclass of `superclass`\n */\nexport function isSubclassOf<\n  SuperClass extends new (..._: any[]) => any,\n  NonSubClass extends new (..._: any[]) => any,\n  SubClass extends new (..._: any[]) => InstanceType<SuperClass>,\n>(subclass: SuperClass | SubClass | NonSubClass, superclass: SuperClass): subclass is SubClass | SuperClass {\n  return subclass === superclass || isProperSubclassOf(subclass, superclass);\n}\n"]}
+{"version":3,"file":"ClassUtils.js","sourceRoot":"","sources":["../../src/ClassUtils.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;;;AAE/F;;;;;GAKG;AACH,SAAgB,kBAAkB,CAIhC,QAAgC,EAAE,UAAsB;IACxD,OAAO,QAAQ,CAAC,SAAS,YAAY,UAAU,CAAC;AAClD,CAAC;AAND,gDAMC;AAED;;;;;GAKG;AACH,SAAgB,YAAY,CAI1B,QAA6C,EAAE,UAAsB;IACrE,OAAO,QAAQ,KAAK,UAAU,IAAI,kBAAkB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;AAC7E,CAAC;AAND,oCAMC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n\r\n/** Check if class `subclass` is a different class from `superclass` but extends from `superclass`\r\n * @internal\r\n * @param subclass the class that may be a subclass of `superclass`\r\n * @param superclass the class that may be a base class of `subclass`\r\n * @returns whether `subclass` is a proper subclass of `superclass`\r\n */\r\nexport function isProperSubclassOf<\r\n  SuperClass extends new (..._: any[]) => any,\r\n  NonSubClass extends new (..._: any[]) => any,\r\n  SubClass extends new (..._: any[]) => InstanceType<SuperClass>,\r\n>(subclass: SubClass | NonSubClass, superclass: SuperClass): subclass is SubClass {\r\n  return subclass.prototype instanceof superclass;\r\n}\r\n\r\n/** Check if class `subclass` is `superclass` or extends from `superclass`\r\n * @internal\r\n * @param subclass the class that may be a subclass of `superclass`\r\n * @param superclass the class that may be a base class of `subclass`\r\n * @returns whether `subclass` is a subclass of `superclass`\r\n */\r\nexport function isSubclassOf<\r\n  SuperClass extends new (..._: any[]) => any,\r\n  NonSubClass extends new (..._: any[]) => any,\r\n  SubClass extends new (..._: any[]) => InstanceType<SuperClass>,\r\n>(subclass: SuperClass | SubClass | NonSubClass, superclass: SuperClass): subclass is SubClass | SuperClass {\r\n  return subclass === superclass || isProperSubclassOf(subclass, superclass);\r\n}\r\n"]}

package/lib/cjs/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 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;
 //# sourceMappingURL=Compare.d.ts.map

package/lib/cjs/Compare.js

@@ -1,76 +1,76 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* 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
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.areEqualPossiblyUndefined = exports.compareBooleansOrUndefined = exports.compareNumbersOrUndefined = exports.compareStringsOrUndefined = exports.comparePossiblyUndefined = exports.compareStrings = exports.compareBooleans = exports.compareNumbers = exports.compareWithTolerance = void 0;
-/**
- * An [[OrderedComparator]] for numbers that treats two numbers as equal if the absolute value of their difference is less than a specified tolerance.
- * @public
- */
-function compareWithTolerance(a, b, tolerance = 0.1) {
-    if (a < b - tolerance)
-        return -1;
-    else if (a > b + tolerance)
-        return 1;
-    else
-        return 0;
-}
-exports.compareWithTolerance = compareWithTolerance;
-/** @public */
-function compareNumbers(a, b) {
-    return a - b;
-}
-exports.compareNumbers = compareNumbers;
-/** @public */
-function compareBooleans(a, b) {
-    return a !== b ? (a < b ? -1 : 1) : 0;
-}
-exports.compareBooleans = compareBooleans;
-/** @public */
-function compareStrings(a, b) {
-    return a === b ? 0 : (a < b ? -1 : 1);
-}
-exports.compareStrings = compareStrings;
-/** @public */
-function comparePossiblyUndefined(compareDefined, lhs, rhs) {
-    if (undefined === lhs)
-        return undefined === rhs ? 0 : -1;
-    else if (undefined === rhs)
-        return 1;
-    else
-        return compareDefined(lhs, rhs);
-}
-exports.comparePossiblyUndefined = comparePossiblyUndefined;
-/** @public */
-function compareStringsOrUndefined(lhs, rhs) {
-    return comparePossiblyUndefined(compareStrings, lhs, rhs);
-}
-exports.compareStringsOrUndefined = compareStringsOrUndefined;
-/** @public */
-function compareNumbersOrUndefined(lhs, rhs) {
-    return comparePossiblyUndefined(compareNumbers, lhs, rhs);
-}
-exports.compareNumbersOrUndefined = compareNumbersOrUndefined;
-/** @public */
-function compareBooleansOrUndefined(lhs, rhs) {
-    return comparePossiblyUndefined(compareBooleans, lhs, rhs);
-}
-exports.compareBooleansOrUndefined = compareBooleansOrUndefined;
-/** Compare two possibly-undefined values for equality. If both are undefined, the comparison is performed by the supplied `areEqual` function.
- * @public
- */
-function areEqualPossiblyUndefined(t, u, areEqual) {
-    if (undefined === t)
-        return undefined === u;
-    else if (undefined === u)
-        return false;
-    else
-        return areEqual(t, u);
-}
-exports.areEqualPossiblyUndefined = areEqualPossiblyUndefined;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areEqualPossiblyUndefined = exports.compareBooleansOrUndefined = exports.compareNumbersOrUndefined = exports.compareStringsOrUndefined = exports.comparePossiblyUndefined = exports.compareStrings = exports.compareBooleans = exports.compareNumbers = exports.compareWithTolerance = void 0;
+/**
+ * An [[OrderedComparator]] for numbers that treats two numbers as equal if the absolute value of their difference is less than a specified tolerance.
+ * @public
+ */
+function compareWithTolerance(a, b, tolerance = 0.1) {
+    if (a < b - tolerance)
+        return -1;
+    else if (a > b + tolerance)
+        return 1;
+    else
+        return 0;
+}
+exports.compareWithTolerance = compareWithTolerance;
+/** @public */
+function compareNumbers(a, b) {
+    return a - b;
+}
+exports.compareNumbers = compareNumbers;
+/** @public */
+function compareBooleans(a, b) {
+    return a !== b ? (a < b ? -1 : 1) : 0;
+}
+exports.compareBooleans = compareBooleans;
+/** @public */
+function compareStrings(a, b) {
+    return a === b ? 0 : (a < b ? -1 : 1);
+}
+exports.compareStrings = compareStrings;
+/** @public */
+function comparePossiblyUndefined(compareDefined, lhs, rhs) {
+    if (undefined === lhs)
+        return undefined === rhs ? 0 : -1;
+    else if (undefined === rhs)
+        return 1;
+    else
+        return compareDefined(lhs, rhs);
+}
+exports.comparePossiblyUndefined = comparePossiblyUndefined;
+/** @public */
+function compareStringsOrUndefined(lhs, rhs) {
+    return comparePossiblyUndefined(compareStrings, lhs, rhs);
+}
+exports.compareStringsOrUndefined = compareStringsOrUndefined;
+/** @public */
+function compareNumbersOrUndefined(lhs, rhs) {
+    return comparePossiblyUndefined(compareNumbers, lhs, rhs);
+}
+exports.compareNumbersOrUndefined = compareNumbersOrUndefined;
+/** @public */
+function compareBooleansOrUndefined(lhs, rhs) {
+    return comparePossiblyUndefined(compareBooleans, lhs, rhs);
+}
+exports.compareBooleansOrUndefined = compareBooleansOrUndefined;
+/** Compare two possibly-undefined values for equality. If both are undefined, the comparison is performed by the supplied `areEqual` function.
+ * @public
+ */
+function areEqualPossiblyUndefined(t, u, areEqual) {
+    if (undefined === t)
+        return undefined === u;
+    else if (undefined === u)
+        return false;
+    else
+        return areEqual(t, u);
+}
+exports.areEqualPossiblyUndefined = areEqualPossiblyUndefined;
 //# sourceMappingURL=Compare.js.map

package/lib/cjs/Compare.js.map

@@ -1 +1 @@
-{"version":3,"file":"Compare.js","sourceRoot":"","sources":["../../src/Compare.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAwBH;;;GAGG;AACH,SAAgB,oBAAoB,CAAC,CAAS,EAAE,CAAS,EAAE,SAAS,GAAG,GAAG;IACxE,IAAI,CAAC,GAAG,CAAC,GAAG,SAAS;QACnB,OAAO,CAAC,CAAC,CAAC;SACP,IAAI,CAAC,GAAG,CAAC,GAAG,SAAS;QACxB,OAAO,CAAC,CAAC;;QAET,OAAO,CAAC,CAAC;AACb,CAAC;AAPD,oDAOC;AAED,cAAc;AACd,SAAgB,cAAc,CAAC,CAAS,EAAE,CAAS;IACjD,OAAO,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAFD,wCAEC;AAED,cAAc;AACd,SAAgB,eAAe,CAAC,CAAU,EAAE,CAAU;IACpD,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxC,CAAC;AAFD,0CAEC;AAED,cAAc;AACd,SAAgB,cAAc,CAAC,CAAS,EAAE,CAAS;IACjD,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxC,CAAC;AAFD,wCAEC;AAED,cAAc;AACd,SAAgB,wBAAwB,CAAI,cAA0C,EAAE,GAAO,EAAE,GAAO;IACtG,IAAI,SAAS,KAAK,GAAG;QACnB,OAAO,SAAS,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/B,IAAI,SAAS,KAAK,GAAG;QACxB,OAAO,CAAC,CAAC;;QAET,OAAO,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACpC,CAAC;AAPD,4DAOC;AAED,cAAc;AACd,SAAgB,yBAAyB,CAAC,GAAY,EAAE,GAAY;IAClE,OAAO,wBAAwB,CAAC,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAC5D,CAAC;AAFD,8DAEC;AAED,cAAc;AACd,SAAgB,yBAAyB,CAAC,GAAY,EAAE,GAAY;IAClE,OAAO,wBAAwB,CAAC,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAC5D,CAAC;AAFD,8DAEC;AAED,cAAc;AACd,SAAgB,0BAA0B,CAAC,GAAa,EAAE,GAAa;IACrE,OAAO,wBAAwB,CAAC,eAAe,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAC7D,CAAC;AAFD,gEAEC;AAED;;GAEG;AACH,SAAgB,yBAAyB,CAAO,CAAgB,EAAE,CAAgB,EAAE,QAAiC;IACnH,IAAI,SAAS,KAAK,CAAC;QACjB,OAAO,SAAS,KAAK,CAAC,CAAC;SACpB,IAAI,SAAS,KAAK,CAAC;QACtB,OAAO,KAAK,CAAC;;QAEb,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1B,CAAC;AAPD,8DAOC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n* See LICENSE.md in the project root for license terms and full copyright notice.\n*--------------------------------------------------------------------------------------------*/\n/** @packageDocumentation\n * @module Utils\n */\n\n/**\n * A function that returns a numerical value indicating how two objects are ordered in relation to one another.\n * Such functions are used by various collection classes throughout the library.\n * Given values `lhs` and `rhs`, the function returns:\n *  - Zero if lhs == rhs\n *  - A negative number if lhs < rhs\n *  - A positive number if lhs > rhs\n *\n * 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:\n *  - `compare(x, x)` returns zero.\n *  - If `compare(x, y)` returns zero, then so does `compare(y, x)` (i.e., `x == y` implies `y == x`).\n *  - 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`).\n *  - 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`).\n *\n * @see SortedArray\n * @see Dictionary\n * @see IndexMap\n * @see PriorityQueue\n * @public\n */\nexport type OrderedComparator<T, U = T> = (lhs: T, rhs: U) => number;\n\n/**\n * An [[OrderedComparator]] for numbers that treats two numbers as equal if the absolute value of their difference is less than a specified tolerance.\n * @public\n */\nexport function compareWithTolerance(a: number, b: number, tolerance = 0.1): number {\n  if (a < b - tolerance)\n    return -1;\n  else if (a > b + tolerance)\n    return 1;\n  else\n    return 0;\n}\n\n/** @public */\nexport function compareNumbers(a: number, b: number): number {\n  return a - b;\n}\n\n/** @public */\nexport function compareBooleans(a: boolean, b: boolean): number {\n  return a !== b ? (a < b ? -1 : 1) : 0;\n}\n\n/** @public */\nexport function compareStrings(a: string, b: string): number {\n  return a === b ? 0 : (a < b ? -1 : 1);\n}\n\n/** @public */\nexport function comparePossiblyUndefined<T>(compareDefined: (lhs: T, rhs: T) => number, lhs?: T, rhs?: T): number {\n  if (undefined === lhs)\n    return undefined === rhs ? 0 : -1;\n  else if (undefined === rhs)\n    return 1;\n  else\n    return compareDefined(lhs, rhs);\n}\n\n/** @public */\nexport function compareStringsOrUndefined(lhs?: string, rhs?: string): number {\n  return comparePossiblyUndefined(compareStrings, lhs, rhs);\n}\n\n/** @public */\nexport function compareNumbersOrUndefined(lhs?: number, rhs?: number): number {\n  return comparePossiblyUndefined(compareNumbers, lhs, rhs);\n}\n\n/** @public */\nexport function compareBooleansOrUndefined(lhs?: boolean, rhs?: boolean): number {\n  return comparePossiblyUndefined(compareBooleans, lhs, rhs);\n}\n\n/** Compare two possibly-undefined values for equality. If both are undefined, the comparison is performed by the supplied `areEqual` function.\n * @public\n */\nexport function areEqualPossiblyUndefined<T, U>(t: T | undefined, u: U | undefined, areEqual: (t: T, u: U) => boolean): boolean {\n  if (undefined === t)\n    return undefined === u;\n  else if (undefined === u)\n    return false;\n  else\n    return areEqual(t, u);\n}\n"]}
+{"version":3,"file":"Compare.js","sourceRoot":"","sources":["../../src/Compare.ts"],"names":[],"mappings":";AAAA;;;+FAG+F;AAC/F;;GAEG;;;AAwBH;;;GAGG;AACH,SAAgB,oBAAoB,CAAC,CAAS,EAAE,CAAS,EAAE,SAAS,GAAG,GAAG;IACxE,IAAI,CAAC,GAAG,CAAC,GAAG,SAAS;QACnB,OAAO,CAAC,CAAC,CAAC;SACP,IAAI,CAAC,GAAG,CAAC,GAAG,SAAS;QACxB,OAAO,CAAC,CAAC;;QAET,OAAO,CAAC,CAAC;AACb,CAAC;AAPD,oDAOC;AAED,cAAc;AACd,SAAgB,cAAc,CAAC,CAAS,EAAE,CAAS;IACjD,OAAO,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAFD,wCAEC;AAED,cAAc;AACd,SAAgB,eAAe,CAAC,CAAU,EAAE,CAAU;IACpD,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxC,CAAC;AAFD,0CAEC;AAED,cAAc;AACd,SAAgB,cAAc,CAAC,CAAS,EAAE,CAAS;IACjD,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACxC,CAAC;AAFD,wCAEC;AAED,cAAc;AACd,SAAgB,wBAAwB,CAAI,cAA0C,EAAE,GAAO,EAAE,GAAO;IACtG,IAAI,SAAS,KAAK,GAAG;QACnB,OAAO,SAAS,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/B,IAAI,SAAS,KAAK,GAAG;QACxB,OAAO,CAAC,CAAC;;QAET,OAAO,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACpC,CAAC;AAPD,4DAOC;AAED,cAAc;AACd,SAAgB,yBAAyB,CAAC,GAAY,EAAE,GAAY;IAClE,OAAO,wBAAwB,CAAC,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAC5D,CAAC;AAFD,8DAEC;AAED,cAAc;AACd,SAAgB,yBAAyB,CAAC,GAAY,EAAE,GAAY;IAClE,OAAO,wBAAwB,CAAC,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAC5D,CAAC;AAFD,8DAEC;AAED,cAAc;AACd,SAAgB,0BAA0B,CAAC,GAAa,EAAE,GAAa;IACrE,OAAO,wBAAwB,CAAC,eAAe,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAC7D,CAAC;AAFD,gEAEC;AAED;;GAEG;AACH,SAAgB,yBAAyB,CAAO,CAAgB,EAAE,CAAgB,EAAE,QAAiC;IACnH,IAAI,SAAS,KAAK,CAAC;QACjB,OAAO,SAAS,KAAK,CAAC,CAAC;SACpB,IAAI,SAAS,KAAK,CAAC;QACtB,OAAO,KAAK,CAAC;;QAEb,OAAO,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1B,CAAC;AAPD,8DAOC","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n/** @packageDocumentation\r\n * @module Utils\r\n */\r\n\r\n/**\r\n * A function that returns a numerical value indicating how two objects are ordered in relation to one another.\r\n * Such functions are used by various collection classes throughout the library.\r\n * Given values `lhs` and `rhs`, the function returns:\r\n *  - Zero if lhs == rhs\r\n *  - A negative number if lhs < rhs\r\n *  - A positive number if lhs > rhs\r\n *\r\n * 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:\r\n *  - `compare(x, x)` returns zero.\r\n *  - If `compare(x, y)` returns zero, then so does `compare(y, x)` (i.e., `x == y` implies `y == x`).\r\n *  - 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`).\r\n *  - 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`).\r\n *\r\n * @see SortedArray\r\n * @see Dictionary\r\n * @see IndexMap\r\n * @see PriorityQueue\r\n * @public\r\n */\r\nexport type OrderedComparator<T, U = T> = (lhs: T, rhs: U) => number;\r\n\r\n/**\r\n * An [[OrderedComparator]] for numbers that treats two numbers as equal if the absolute value of their difference is less than a specified tolerance.\r\n * @public\r\n */\r\nexport function compareWithTolerance(a: number, b: number, tolerance = 0.1): number {\r\n  if (a < b - tolerance)\r\n    return -1;\r\n  else if (a > b + tolerance)\r\n    return 1;\r\n  else\r\n    return 0;\r\n}\r\n\r\n/** @public */\r\nexport function compareNumbers(a: number, b: number): number {\r\n  return a - b;\r\n}\r\n\r\n/** @public */\r\nexport function compareBooleans(a: boolean, b: boolean): number {\r\n  return a !== b ? (a < b ? -1 : 1) : 0;\r\n}\r\n\r\n/** @public */\r\nexport function compareStrings(a: string, b: string): number {\r\n  return a === b ? 0 : (a < b ? -1 : 1);\r\n}\r\n\r\n/** @public */\r\nexport function comparePossiblyUndefined<T>(compareDefined: (lhs: T, rhs: T) => number, lhs?: T, rhs?: T): number {\r\n  if (undefined === lhs)\r\n    return undefined === rhs ? 0 : -1;\r\n  else if (undefined === rhs)\r\n    return 1;\r\n  else\r\n    return compareDefined(lhs, rhs);\r\n}\r\n\r\n/** @public */\r\nexport function compareStringsOrUndefined(lhs?: string, rhs?: string): number {\r\n  return comparePossiblyUndefined(compareStrings, lhs, rhs);\r\n}\r\n\r\n/** @public */\r\nexport function compareNumbersOrUndefined(lhs?: number, rhs?: number): number {\r\n  return comparePossiblyUndefined(compareNumbers, lhs, rhs);\r\n}\r\n\r\n/** @public */\r\nexport function compareBooleansOrUndefined(lhs?: boolean, rhs?: boolean): number {\r\n  return comparePossiblyUndefined(compareBooleans, lhs, rhs);\r\n}\r\n\r\n/** Compare two possibly-undefined values for equality. If both are undefined, the comparison is performed by the supplied `areEqual` function.\r\n * @public\r\n */\r\nexport function areEqualPossiblyUndefined<T, U>(t: T | undefined, u: U | undefined, areEqual: (t: T, u: U) => boolean): boolean {\r\n  if (undefined === t)\r\n    return undefined === u;\r\n  else if (undefined === u)\r\n    return false;\r\n  else\r\n    return areEqual(t, u);\r\n}\r\n"]}