@itwin/core-bentley 4.0.0-dev.52 → 4.0.0-dev.55

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

package/lib/esm/CompressedId64Set.d.ts

@@ -1,135 +1,135 @@
-/** @packageDocumentation
- * @module Ids
- */
-import { Id64Array, Id64Set, Id64String } from "./Id";
-import { OrderedId64Iterable } from "./OrderedId64Iterable";
-import { SortedArray } from "./SortedArray";
-/** @public */
-export declare type CompressedId64Set = string;
-/** A compact string representation of an [[Id64Set]]. Such a representation is useful when serializing potentially very large
- * sets of Ids.
- * @see [[CompressedId64Set.iterable]] to efficiently iterate the Ids represented by a compact string.
- * @see [[CompressedId64Set.compressSet]] and [[CompressedId64Set.compressArray]] to produce a compact string from a collection of Ids.
- * @see [[CompressedId64Set.decompressSet]] and [[CompressedId64Set.decompressArray]] to produce a collection of Ids from a compact string.
- * @see [[OrderedId64Iterable]] for a generic representation of an ordered set of Ids (compressed or otherwise).
- * @see [[MutableCompressedId64Set]] for a mutable version.
- * @public
- */
-export declare namespace CompressedId64Set {
-    /** Given a set of [[Id64String]]s, produce a compact string representation. Useful when serializing potentially large sets of Ids.
-     * @note Invalid Ids are ignored.
-     * @see [[CompressedId64Set.sortAndCompress]] to compress any unordered collection of Ids.
-     * @see [[CompressedId64Set.compressArray]] to perform the same operation on an [[Id64Array]].
-     * @see [[CompressedId64Set.decompressSet]] to perform the inverse operation.
-     */
-    function compressSet(ids: Id64Set): CompressedId64Set;
-    /** Create a sorted array from `ids`, then return a compact string representation of those Ids.
-     * @see [[compressIds]] if `ids` is known to already be sorted.
-     */
-    function sortAndCompress(ids: Iterable<Id64String>): CompressedId64Set;
-    /** Give a **numerically-ordered** array of [[Id64String]]s, produce a compact string representation. Useful when serializing potentially large sets of Ids.
-     * Duplicate Ids are included only once in the string representation.
-     * @throws Error if two consecutive Ids `x` and `y` exist such that the numerical value of `x` is greater than that of `y` - i.e., the array is not properly sorted.
-     * @note The array must be sorted according to the 64-bit numerical value of each Id.
-     * @note Invalid Ids are ignored.
-     * @see [[CompressedId64Set.decompressArray]] to perform the inverse operation.
-     * @see [[OrderedId64Iterable.sortArray]] to ensure the Ids are properly sorted.
-     * @see [[CompressedId64Set.sortAndCompress]] to compress any unordered collection of Ids.
-     */
-    function compressArray(ids: Id64Array): CompressedId64Set;
-    /** Give a **numerically-ordered** collection of [[Id64String]]s, produce a compact string representation. Useful when serializing potentially large sets of Ids.
-     * Duplicate Ids are included only once in the string representation.
-     * @throws Error if two consecutive Ids `x` and `y` exist such that the numerical value of `x` is greater than that of `y` - i.e., the collection is not properly sorted.
-     * @note The collection must be sorted according to the 64-bit numerical value of each Id.
-     * @note Invalid Ids are ignored.
-     * @see [[CompressedId64Set.iterable]] to perform the inverse operation.
-     * @see [[OrderedId64Iterable.sortArray]] or [[OrderedId64Iterable.compare]] to ensure the Ids are properly sorted.
-     * @see [[CompressedId64Set.sortAndCompress]] to compress any unordered collection of Ids.
-     */
-    function compressIds(ids: OrderedId64Iterable): CompressedId64Set;
-    /** Supplies an iterator over the [[Id64String]]s in a [[CompressedId64Set]].
-     * The Ids are iterated in ascending order based on their unsigned 64-bit integer values.
-     */
-    function iterator(ids: CompressedId64Set): Iterator<Id64String>;
-    /** Supplies an iterable over the [[Id64String]]s in a [[CompressedId64Set]].
-     * The Ids are iterated in ascending order based on their unsigned 64-bit integer values.
-     */
-    function iterable(ids: CompressedId64Set): OrderedId64Iterable;
-    /** Decompress the compact string representation of an [[Id64Set]] into an [[Id64Set]].
-     * @param compressedIds The compact string representation.
-     * @param out If supplied, the Ids will be inserted into this set rather than allocating and returning a new set.
-     * @returns The set containing the decompressed Ids.
-     * @throws Error if `compressedIds` is not a well-formed [[CompressedId64Set]].
-     * @see [[CompressedId64Set.compressSet]] to perform the inverse operation.
-     * @see [[CompressedId64Set.decompressArray]] to decompress as an [[Id64Array]] instead.
-     * @see [[CompressedId64Set.iterable]] to efficiently iterate the Ids.
-     */
-    function decompressSet(compressedIds: CompressedId64Set, out?: Id64Set): Id64Set;
-    /** Decompress the compact string representation of an [[Id64Set]] into an [[Id64Array]].
-     * @param compressedIds The compact string representation.
-     * @param out If supplied, the Ids will be appended to this array rather than allocating and returning a new array.
-     * @returns The array containing the decompressed Ids.
-     * @throws Error if `compressedIds` is not a well-formed [[CompressedId64Set]].
-     * @note The Ids are decompressed and appended to the array in ascending order based on their 64-bit numerical values.
-     * @see [[CompressedId64Set.compressArray]] to perform the inverse operation.
-     * @see [[CompressedId64Set.decompressSet]] to decompress as an [[Id64Set]] instead.
-     * @see [[CompressedId64Set.iterable]] to efficiently iterate the Ids.
-     */
-    function decompressArray(compressedIds: CompressedId64Set, out?: Id64Array): Id64Array;
-}
-/** A [[SortedArray]] of unique [[Id64String]]s sorted in ascending order by the 64-bit unsigned integer values of the Ids.
- * @see [[CompressedId64Set]] for an immutable compact string representation.
- * @public
- */
-export declare class OrderedId64Array extends SortedArray<Id64String> {
-    /** Construct a new, empty array. */
-    constructor();
-    /** An iterable that iterates over the Ids in sorted order. */
-    get ids(): OrderedId64Iterable;
-    /** The underlying array of Ids. */
-    get array(): ReadonlyArray<Id64String>;
-}
-/** A mutable set of valid [[Id64String]]s sorted in ascending order by the 64-bit unsigned integer value of the Ids.
- * Internally the set of Ids is maintained as a [[CompressedId64Set]] string representation.
- * Insertions and removals are buffered until the string representation needs to be recomputed. The string representation is recomputed by every public method except [[add]] and [[delete]] -
- * therefore, if multiple removals and/or insertions are required, it is most efficient to perform them all before invoking other methods.
- * @public
- */
-export declare class MutableCompressedId64Set implements OrderedId64Iterable {
-    private _ids;
-    private readonly _inserted;
-    private readonly _deleted;
-    /** Construct a new set, optionally initialized to contain the Ids represented by `ids`. */
-    constructor(ids?: CompressedId64Set);
-    /** Obtain the compact string representation of the contents of this set. If any insertions or removals are pending, they will be applied and the string recomputed. */
-    get ids(): CompressedId64Set;
-    /** Add the specified Id to the set.
-     * @throws Error if `id` is not a valid [[Id64String]].
-     */
-    add(id: Id64String): void;
-    /** Remove the specified Id from the set.
-     * @throws Error if `id` is not a valid [[Id64String]].
-     */
-    delete(id: Id64String): void;
-    /** Remove all Ids from the set. */
-    clear(): void;
-    /** Remove all Ids from the set, then add the specified Ids. */
-    reset(ids?: CompressedId64Set): void;
-    /** Obtain an iterator over the Ids in this set. The Ids are returned in ascending order based on their unsigned 64-bit integer values. */
-    [Symbol.iterator](): Iterator<string, any, undefined>;
-    /** Compute a compact string representation of the union of this and another set of Ids - i.e., those Ids present in either this and/or the other set. */
-    computeUnion(ids: OrderedId64Iterable | CompressedId64Set | MutableCompressedId64Set): CompressedId64Set;
-    /** Compute a compact string representation of the intersection of this and another set of Ids - i.e., those Ids present in both this and the other set. */
-    computeIntersection(ids: OrderedId64Iterable | CompressedId64Set | MutableCompressedId64Set): CompressedId64Set;
-    /** Compute a compact string representation of the difference between this and another set - i.e., those Ids present in this but not in the other set. */
-    computeDifference(ids: OrderedId64Iterable | CompressedId64Set | MutableCompressedId64Set): CompressedId64Set;
-    /** Return true if this set contains no Ids. */
-    get isEmpty(): boolean;
-    /** Return true if the set of Ids represented by `other` is identical to those in this set.
-     * @note This considers only the **distinct** Ids in `other` - duplicates are ignored.
-     */
-    equals(other: CompressedId64Set | MutableCompressedId64Set | OrderedId64Iterable): boolean;
-    private get _isDirty();
-    private updateIds;
-}
+/** @packageDocumentation
+ * @module Ids
+ */
+import { Id64Array, Id64Set, Id64String } from "./Id";
+import { OrderedId64Iterable } from "./OrderedId64Iterable";
+import { SortedArray } from "./SortedArray";
+/** @public */
+export type CompressedId64Set = string;
+/** A compact string representation of an [[Id64Set]]. Such a representation is useful when serializing potentially very large
+ * sets of Ids.
+ * @see [[CompressedId64Set.iterable]] to efficiently iterate the Ids represented by a compact string.
+ * @see [[CompressedId64Set.compressSet]] and [[CompressedId64Set.compressArray]] to produce a compact string from a collection of Ids.
+ * @see [[CompressedId64Set.decompressSet]] and [[CompressedId64Set.decompressArray]] to produce a collection of Ids from a compact string.
+ * @see [[OrderedId64Iterable]] for a generic representation of an ordered set of Ids (compressed or otherwise).
+ * @see [[MutableCompressedId64Set]] for a mutable version.
+ * @public
+ */
+export declare namespace CompressedId64Set {
+    /** Given a set of [[Id64String]]s, produce a compact string representation. Useful when serializing potentially large sets of Ids.
+     * @note Invalid Ids are ignored.
+     * @see [[CompressedId64Set.sortAndCompress]] to compress any unordered collection of Ids.
+     * @see [[CompressedId64Set.compressArray]] to perform the same operation on an [[Id64Array]].
+     * @see [[CompressedId64Set.decompressSet]] to perform the inverse operation.
+     */
+    function compressSet(ids: Id64Set): CompressedId64Set;
+    /** Create a sorted array from `ids`, then return a compact string representation of those Ids.
+     * @see [[compressIds]] if `ids` is known to already be sorted.
+     */
+    function sortAndCompress(ids: Iterable<Id64String>): CompressedId64Set;
+    /** Give a **numerically-ordered** array of [[Id64String]]s, produce a compact string representation. Useful when serializing potentially large sets of Ids.
+     * Duplicate Ids are included only once in the string representation.
+     * @throws Error if two consecutive Ids `x` and `y` exist such that the numerical value of `x` is greater than that of `y` - i.e., the array is not properly sorted.
+     * @note The array must be sorted according to the 64-bit numerical value of each Id.
+     * @note Invalid Ids are ignored.
+     * @see [[CompressedId64Set.decompressArray]] to perform the inverse operation.
+     * @see [[OrderedId64Iterable.sortArray]] to ensure the Ids are properly sorted.
+     * @see [[CompressedId64Set.sortAndCompress]] to compress any unordered collection of Ids.
+     */
+    function compressArray(ids: Id64Array): CompressedId64Set;
+    /** Give a **numerically-ordered** collection of [[Id64String]]s, produce a compact string representation. Useful when serializing potentially large sets of Ids.
+     * Duplicate Ids are included only once in the string representation.
+     * @throws Error if two consecutive Ids `x` and `y` exist such that the numerical value of `x` is greater than that of `y` - i.e., the collection is not properly sorted.
+     * @note The collection must be sorted according to the 64-bit numerical value of each Id.
+     * @note Invalid Ids are ignored.
+     * @see [[CompressedId64Set.iterable]] to perform the inverse operation.
+     * @see [[OrderedId64Iterable.sortArray]] or [[OrderedId64Iterable.compare]] to ensure the Ids are properly sorted.
+     * @see [[CompressedId64Set.sortAndCompress]] to compress any unordered collection of Ids.
+     */
+    function compressIds(ids: OrderedId64Iterable): CompressedId64Set;
+    /** Supplies an iterator over the [[Id64String]]s in a [[CompressedId64Set]].
+     * The Ids are iterated in ascending order based on their unsigned 64-bit integer values.
+     */
+    function iterator(ids: CompressedId64Set): Iterator<Id64String>;
+    /** Supplies an iterable over the [[Id64String]]s in a [[CompressedId64Set]].
+     * The Ids are iterated in ascending order based on their unsigned 64-bit integer values.
+     */
+    function iterable(ids: CompressedId64Set): OrderedId64Iterable;
+    /** Decompress the compact string representation of an [[Id64Set]] into an [[Id64Set]].
+     * @param compressedIds The compact string representation.
+     * @param out If supplied, the Ids will be inserted into this set rather than allocating and returning a new set.
+     * @returns The set containing the decompressed Ids.
+     * @throws Error if `compressedIds` is not a well-formed [[CompressedId64Set]].
+     * @see [[CompressedId64Set.compressSet]] to perform the inverse operation.
+     * @see [[CompressedId64Set.decompressArray]] to decompress as an [[Id64Array]] instead.
+     * @see [[CompressedId64Set.iterable]] to efficiently iterate the Ids.
+     */
+    function decompressSet(compressedIds: CompressedId64Set, out?: Id64Set): Id64Set;
+    /** Decompress the compact string representation of an [[Id64Set]] into an [[Id64Array]].
+     * @param compressedIds The compact string representation.
+     * @param out If supplied, the Ids will be appended to this array rather than allocating and returning a new array.
+     * @returns The array containing the decompressed Ids.
+     * @throws Error if `compressedIds` is not a well-formed [[CompressedId64Set]].
+     * @note The Ids are decompressed and appended to the array in ascending order based on their 64-bit numerical values.
+     * @see [[CompressedId64Set.compressArray]] to perform the inverse operation.
+     * @see [[CompressedId64Set.decompressSet]] to decompress as an [[Id64Set]] instead.
+     * @see [[CompressedId64Set.iterable]] to efficiently iterate the Ids.
+     */
+    function decompressArray(compressedIds: CompressedId64Set, out?: Id64Array): Id64Array;
+}
+/** A [[SortedArray]] of unique [[Id64String]]s sorted in ascending order by the 64-bit unsigned integer values of the Ids.
+ * @see [[CompressedId64Set]] for an immutable compact string representation.
+ * @public
+ */
+export declare class OrderedId64Array extends SortedArray<Id64String> {
+    /** Construct a new, empty array. */
+    constructor();
+    /** An iterable that iterates over the Ids in sorted order. */
+    get ids(): OrderedId64Iterable;
+    /** The underlying array of Ids. */
+    get array(): ReadonlyArray<Id64String>;
+}
+/** A mutable set of valid [[Id64String]]s sorted in ascending order by the 64-bit unsigned integer value of the Ids.
+ * Internally the set of Ids is maintained as a [[CompressedId64Set]] string representation.
+ * Insertions and removals are buffered until the string representation needs to be recomputed. The string representation is recomputed by every public method except [[add]] and [[delete]] -
+ * therefore, if multiple removals and/or insertions are required, it is most efficient to perform them all before invoking other methods.
+ * @public
+ */
+export declare class MutableCompressedId64Set implements OrderedId64Iterable {
+    private _ids;
+    private readonly _inserted;
+    private readonly _deleted;
+    /** Construct a new set, optionally initialized to contain the Ids represented by `ids`. */
+    constructor(ids?: CompressedId64Set);
+    /** Obtain the compact string representation of the contents of this set. If any insertions or removals are pending, they will be applied and the string recomputed. */
+    get ids(): CompressedId64Set;
+    /** Add the specified Id to the set.
+     * @throws Error if `id` is not a valid [[Id64String]].
+     */
+    add(id: Id64String): void;
+    /** Remove the specified Id from the set.
+     * @throws Error if `id` is not a valid [[Id64String]].
+     */
+    delete(id: Id64String): void;
+    /** Remove all Ids from the set. */
+    clear(): void;
+    /** Remove all Ids from the set, then add the specified Ids. */
+    reset(ids?: CompressedId64Set): void;
+    /** Obtain an iterator over the Ids in this set. The Ids are returned in ascending order based on their unsigned 64-bit integer values. */
+    [Symbol.iterator](): Iterator<string, any, undefined>;
+    /** Compute a compact string representation of the union of this and another set of Ids - i.e., those Ids present in either this and/or the other set. */
+    computeUnion(ids: OrderedId64Iterable | CompressedId64Set | MutableCompressedId64Set): CompressedId64Set;
+    /** Compute a compact string representation of the intersection of this and another set of Ids - i.e., those Ids present in both this and the other set. */
+    computeIntersection(ids: OrderedId64Iterable | CompressedId64Set | MutableCompressedId64Set): CompressedId64Set;
+    /** Compute a compact string representation of the difference between this and another set - i.e., those Ids present in this but not in the other set. */
+    computeDifference(ids: OrderedId64Iterable | CompressedId64Set | MutableCompressedId64Set): CompressedId64Set;
+    /** Return true if this set contains no Ids. */
+    get isEmpty(): boolean;
+    /** Return true if the set of Ids represented by `other` is identical to those in this set.
+     * @note This considers only the **distinct** Ids in `other` - duplicates are ignored.
+     */
+    equals(other: CompressedId64Set | MutableCompressedId64Set | OrderedId64Iterable): boolean;
+    private get _isDirty();
+    private updateIds;
+}
 //# sourceMappingURL=CompressedId64Set.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"CompressedId64Set.d.ts","sourceRoot":"","sources":["../../src/CompressedId64Set.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAQ,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,cAAc;AACd,oBAAY,iBAAiB,GAAG,MAAM,CAAC;AAEvC;;;;;;;;GAQG;AACH,yBAAiB,iBAAiB,CAAC;IAqBjC;;;;;OAKG;IACH,SAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,iBAAiB,CAE3D;IAED;;OAEG;IACH,SAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,iBAAiB,CAK5E;IAED;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,GAAG,iBAAiB,CAE/D;IAED;;;;;;;;OAQG;IACH,SAAgB,WAAW,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,CA2CvE;IAgFD;;OAEG;IACH,SAAiB,QAAQ,CAAC,GAAG,EAAE,iBAAiB,GAAG,QAAQ,CAAC,UAAU,CAAC,CA0FtE;IAED;;OAEG;IACH,SAAgB,QAAQ,CAAC,GAAG,EAAE,iBAAiB,GAAG,mBAAmB,CAIpE;IAED;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,aAAa,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAMtF;IAED;;;;;;;;;OASG;IACH,SAAgB,eAAe,CAAC,aAAa,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,SAAS,GAAG,SAAS,CAM5F;CACF;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,WAAW,CAAC,UAAU,CAAC;IAC3D,oCAAoC;;IAKpC,8DAA8D;IAC9D,IAAW,GAAG,IAAI,mBAAmB,CAAwB;IAE7D,mCAAmC;IACnC,IAAW,KAAK,IAAI,aAAa,CAAC,UAAU,CAAC,CAAwB;CACtE;AAED;;;;;GAKG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAClE,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;IAEnD,2FAA2F;gBACxE,GAAG,CAAC,EAAE,iBAAiB;IAI1C,uKAAuK;IACvK,IAAW,GAAG,IAAI,iBAAiB,CAGlC;IAED;;OAEG;IACI,GAAG,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI;IAQhC;;OAEG;IACI,MAAM,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI;IAQnC,mCAAmC;IAC5B,KAAK,IAAI,IAAI;IAMpB,+DAA+D;IACxD,KAAK,CAAC,GAAG,CAAC,EAAE,iBAAiB,GAAG,IAAI;IAK3C,0IAA0I;IACnI,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIxB,yJAAyJ;IAClJ,YAAY,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,wBAAwB,GAAG,iBAAiB;IAS/G,2JAA2J;IACpJ,mBAAmB,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,wBAAwB,GAAG,iBAAiB;IAStH,yJAAyJ;IAClJ,iBAAiB,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,wBAAwB,GAAG,iBAAiB;IAOpH,+CAA+C;IAC/C,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED;;OAEG;IACI,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,wBAAwB,GAAG,mBAAmB,GAAG,OAAO;IAgBjG,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,CAAC,SAAS;CAWlB"}
+{"version":3,"file":"CompressedId64Set.d.ts","sourceRoot":"","sources":["../../src/CompressedId64Set.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAQ,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,cAAc;AACd,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEvC;;;;;;;;GAQG;AACH,yBAAiB,iBAAiB,CAAC;IAqBjC;;;;;OAKG;IACH,SAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,iBAAiB,CAE3D;IAED;;OAEG;IACH,SAAgB,eAAe,CAAC,GAAG,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,iBAAiB,CAK5E;IAED;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,GAAG,iBAAiB,CAE/D;IAED;;;;;;;;OAQG;IACH,SAAgB,WAAW,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,CA2CvE;IAgFD;;OAEG;IACH,SAAiB,QAAQ,CAAC,GAAG,EAAE,iBAAiB,GAAG,QAAQ,CAAC,UAAU,CAAC,CA0FtE;IAED;;OAEG;IACH,SAAgB,QAAQ,CAAC,GAAG,EAAE,iBAAiB,GAAG,mBAAmB,CAIpE;IAED;;;;;;;;OAQG;IACH,SAAgB,aAAa,CAAC,aAAa,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,OAAO,CAMtF;IAED;;;;;;;;;OASG;IACH,SAAgB,eAAe,CAAC,aAAa,EAAE,iBAAiB,EAAE,GAAG,CAAC,EAAE,SAAS,GAAG,SAAS,CAM5F;CACF;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,WAAW,CAAC,UAAU,CAAC;IAC3D,oCAAoC;;IAKpC,8DAA8D;IAC9D,IAAW,GAAG,IAAI,mBAAmB,CAAwB;IAE7D,mCAAmC;IACnC,IAAW,KAAK,IAAI,aAAa,CAAC,UAAU,CAAC,CAAwB;CACtE;AAED;;;;;GAKG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAClE,OAAO,CAAC,IAAI,CAAoB;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0B;IAEnD,2FAA2F;gBACxE,GAAG,CAAC,EAAE,iBAAiB;IAI1C,uKAAuK;IACvK,IAAW,GAAG,IAAI,iBAAiB,CAGlC;IAED;;OAEG;IACI,GAAG,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI;IAQhC;;OAEG;IACI,MAAM,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI;IAQnC,mCAAmC;IAC5B,KAAK,IAAI,IAAI;IAMpB,+DAA+D;IACxD,KAAK,CAAC,GAAG,CAAC,EAAE,iBAAiB,GAAG,IAAI;IAK3C,0IAA0I;IACnI,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIxB,yJAAyJ;IAClJ,YAAY,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,wBAAwB,GAAG,iBAAiB;IAS/G,2JAA2J;IACpJ,mBAAmB,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,wBAAwB,GAAG,iBAAiB;IAStH,yJAAyJ;IAClJ,iBAAiB,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,wBAAwB,GAAG,iBAAiB;IAOpH,+CAA+C;IAC/C,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED;;OAEG;IACI,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,wBAAwB,GAAG,mBAAmB,GAAG,OAAO;IAgBjG,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,CAAC,SAAS;CAWlB"}