@itwin/core-bentley 4.0.0-dev.8 → 4.0.0-dev.81

package/lib/esm/OrderedId64Iterable.d.ts

@@ -1,75 +1,75 @@
-/** @packageDocumentation
- * @module Ids
- */
-import { CompressedId64Set } from "./CompressedId64Set";
-import { Id64Array, Id64String } from "./Id";
-/** @public */
-export declare type OrderedId64Iterable = Iterable<Id64String>;
-/** A collection of **valid** [[Id64String]]s sorted in ascending order by the unsigned 64-bit integer value of the Ids.
- * This ordering is a requirement for several groups of APIs including [[CompressedId64Set]].
- * When used as input to a function, duplicate Ids are ignored; when returned as a function output, no duplicates are present.
- * @see [[CompressedId64Set]] for a compact string representation of such an ordered collection.
- * @see [[OrderedId64Iterable.compare]] for a function that compares Ids based on this criterion.
- * @see [[OrderedId64Array]] for a mutable implementation.
- * @public
- */
-export declare namespace OrderedId64Iterable {
-    /** An ordered comparison of [[Id64String]]s suitable for use with sorting routines like
-     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) and sorted containers
-     * like [[SortedArray]] and [[Dictionary]]. The comparison compares the 64-bit numerical values of the two Ids, returning a negative number if lhs < rhs,
-     * a positive number if lhs > rhs, or zero if lhs == rhs.
-     * The default string comparison is fine (and more efficient) when numerical ordering is not required; use this instead if you want e.g., "0x100" to be greater than "0xf".
-     * @see [[OrderedId64Iterable.sortArray]] for a convenient way to sort an array of Id64Strings.
-     */
-    function compare(lhs: Id64String, rhs: Id64String): number;
-    /** Sort an array of [[Id64String]]s **in-place** in ascending order by their 64-bit numerical values.
-     * @see [[OrderedId64Iterable.compare]] for the comparison routine used.
-     * @returns the input array.
-     * @note This function returns its input for consistency with Javascript's
-     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method.
-     * It **does not** create a **new** array.
-     */
-    function sortArray(ids: Id64Array): Id64Array;
-    /** Given two ordered collections of [[Id64String]]s, determine whether they are identical sets. Duplicate Ids are ignored.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function areEqualSets(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): boolean;
-    /** Given an ordered collection of [[Id64String]]s, determine if it contains any Ids.
-     * @param ids A well-formed, ordered collection of zero or more valid Ids.
-     * @returns true if the input represents an empty set of Ids. The result is unspecified if the input does not meet the criteria for the input type.
-     */
-    function isEmptySet(ids: OrderedId64Iterable | CompressedId64Set): boolean;
-    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered collection containing no duplicates.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function unique(ids: OrderedId64Iterable): OrderedId64Iterable;
-    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered iterator over the distinct Ids, eliminating duplicates.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function uniqueIterator(ids: OrderedId64Iterable): Generator<string, void, unknown>;
-    /** Given two ordered collections of [[Id64String]]s, produce a collection representing their union - i.e., the Ids that are present in either or both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function union(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function intersection(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function difference(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their union - i.e., the Ids that are present in either or both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function unionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function intersectionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function differenceIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
-}
+/** @packageDocumentation
+ * @module Ids
+ */
+import { CompressedId64Set } from "./CompressedId64Set";
+import { Id64Array, Id64String } from "./Id";
+/** @public */
+export type OrderedId64Iterable = Iterable<Id64String>;
+/** A collection of **valid** [[Id64String]]s sorted in ascending order by the unsigned 64-bit integer value of the Ids.
+ * This ordering is a requirement for several groups of APIs including [[CompressedId64Set]].
+ * When used as input to a function, duplicate Ids are ignored; when returned as a function output, no duplicates are present.
+ * @see [[CompressedId64Set]] for a compact string representation of such an ordered collection.
+ * @see [[OrderedId64Iterable.compare]] for a function that compares Ids based on this criterion.
+ * @see [[OrderedId64Array]] for a mutable implementation.
+ * @public
+ */
+export declare namespace OrderedId64Iterable {
+    /** An ordered comparison of [[Id64String]]s suitable for use with sorting routines like
+     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) and sorted containers
+     * like [[SortedArray]] and [[Dictionary]]. The comparison compares the 64-bit numerical values of the two Ids, returning a negative number if lhs < rhs,
+     * a positive number if lhs > rhs, or zero if lhs == rhs.
+     * The default string comparison is fine (and more efficient) when numerical ordering is not required; use this instead if you want e.g., "0x100" to be greater than "0xf".
+     * @see [[OrderedId64Iterable.sortArray]] for a convenient way to sort an array of Id64Strings.
+     */
+    function compare(lhs: Id64String, rhs: Id64String): number;
+    /** Sort an array of [[Id64String]]s **in-place** in ascending order by their 64-bit numerical values.
+     * @see [[OrderedId64Iterable.compare]] for the comparison routine used.
+     * @returns the input array.
+     * @note This function returns its input for consistency with Javascript's
+     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method.
+     * It **does not** create a **new** array.
+     */
+    function sortArray(ids: Id64Array): Id64Array;
+    /** Given two ordered collections of [[Id64String]]s, determine whether they are identical sets. Duplicate Ids are ignored.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function areEqualSets(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): boolean;
+    /** Given an ordered collection of [[Id64String]]s, determine if it contains any Ids.
+     * @param ids A well-formed, ordered collection of zero or more valid Ids.
+     * @returns true if the input represents an empty set of Ids. The result is unspecified if the input does not meet the criteria for the input type.
+     */
+    function isEmptySet(ids: OrderedId64Iterable | CompressedId64Set): boolean;
+    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered collection containing no duplicates.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function unique(ids: OrderedId64Iterable): OrderedId64Iterable;
+    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered iterator over the distinct Ids, eliminating duplicates.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function uniqueIterator(ids: OrderedId64Iterable): Generator<string, void, unknown>;
+    /** Given two ordered collections of [[Id64String]]s, produce a collection representing their union - i.e., the Ids that are present in either or both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function union(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function intersection(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function difference(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their union - i.e., the Ids that are present in either or both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function unionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function intersectionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function differenceIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): Generator<string, void, unknown>;
+}
 //# sourceMappingURL=OrderedId64Iterable.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"OrderedId64Iterable.d.ts","sourceRoot":"","sources":["../../src/OrderedId64Iterable.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAE7C,cAAc;AACd,oBAAY,mBAAmB,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;AAEvD;;;;;;;GAOG;AACH,yBAAiB,mBAAmB,CAAC;IACnC;;;;;;OAMG;IACH,SAAgB,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAUhE;IAED;;;;;;OAMG;IACH,SAAgB,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAGnD;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAoB1F;IAED;;;OAGG;IACH,SAAgB,UAAU,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,OAAO,CAKhF;IAED;;OAEG;IACH,SAAgB,MAAM,CAAC,GAAG,EAAE,mBAAmB,GAAG,mBAAmB,CAEpE;IAED;;OAEG;IACH,SAAiB,cAAc,CAAC,GAAG,EAAE,mBAAmB,oCAavD;IAED;;OAEG;IACH,SAAgB,KAAK,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAE/F;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAEtG;IAED;;OAEG;IACH,SAAgB,UAAU,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAEpG;IAED;;OAEG;IACH,SAAiB,aAAa,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCA0ClF;IAED;;OAEG;IACH,SAAiB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCA6BzF;IAED;;OAEG;IACH,SAAiB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCAiCvF;CACF"}
+{"version":3,"file":"OrderedId64Iterable.d.ts","sourceRoot":"","sources":["../../src/OrderedId64Iterable.ts"],"names":[],"mappings":"AAIA;;GAEG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAE7C,cAAc;AACd,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;AAEvD;;;;;;;GAOG;AACH,yBAAiB,mBAAmB,CAAC;IACnC;;;;;;OAMG;IACH,SAAgB,OAAO,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,MAAM,CAUhE;IAED;;;;;;OAMG;IACH,SAAgB,SAAS,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS,CAGnD;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAoB1F;IAED;;;OAGG;IACH,SAAgB,UAAU,CAAC,GAAG,EAAE,mBAAmB,GAAG,iBAAiB,GAAG,OAAO,CAKhF;IAED;;OAEG;IACH,SAAgB,MAAM,CAAC,GAAG,EAAE,mBAAmB,GAAG,mBAAmB,CAEpE;IAED;;OAEG;IACH,SAAiB,cAAc,CAAC,GAAG,EAAE,mBAAmB,oCAavD;IAED;;OAEG;IACH,SAAgB,KAAK,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAE/F;IAED;;OAEG;IACH,SAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAEtG;IAED;;OAEG;IACH,SAAgB,UAAU,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,CAEpG;IAED;;OAEG;IACH,SAAiB,aAAa,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCA0ClF;IAED;;OAEG;IACH,SAAiB,oBAAoB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCA6BzF;IAED;;OAEG;IACH,SAAiB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,oCAiCvF;CACF"}

package/lib/esm/OrderedId64Iterable.js

@@ -1,233 +1,233 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Ids
- */
-import { assert } from "./Assert";
-/** A collection of **valid** [[Id64String]]s sorted in ascending order by the unsigned 64-bit integer value of the Ids.
- * This ordering is a requirement for several groups of APIs including [[CompressedId64Set]].
- * When used as input to a function, duplicate Ids are ignored; when returned as a function output, no duplicates are present.
- * @see [[CompressedId64Set]] for a compact string representation of such an ordered collection.
- * @see [[OrderedId64Iterable.compare]] for a function that compares Ids based on this criterion.
- * @see [[OrderedId64Array]] for a mutable implementation.
- * @public
- */
-export var OrderedId64Iterable;
-(function (OrderedId64Iterable) {
-    /** An ordered comparison of [[Id64String]]s suitable for use with sorting routines like
-     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) and sorted containers
-     * like [[SortedArray]] and [[Dictionary]]. The comparison compares the 64-bit numerical values of the two Ids, returning a negative number if lhs < rhs,
-     * a positive number if lhs > rhs, or zero if lhs == rhs.
-     * The default string comparison is fine (and more efficient) when numerical ordering is not required; use this instead if you want e.g., "0x100" to be greater than "0xf".
-     * @see [[OrderedId64Iterable.sortArray]] for a convenient way to sort an array of Id64Strings.
-     */
-    function compare(lhs, rhs) {
-        if (lhs.length !== rhs.length)
-            return lhs.length < rhs.length ? -1 : 1;
-        // This is faster than localeCompare(). Unclear why there is no string.compare() - would be generally useful in
-        // array sort functions...
-        if (lhs !== rhs)
-            return lhs < rhs ? -1 : 1;
-        return 0;
-    }
-    OrderedId64Iterable.compare = compare;
-    /** Sort an array of [[Id64String]]s **in-place** in ascending order by their 64-bit numerical values.
-     * @see [[OrderedId64Iterable.compare]] for the comparison routine used.
-     * @returns the input array.
-     * @note This function returns its input for consistency with Javascript's
-     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method.
-     * It **does not** create a **new** array.
-     */
-    function sortArray(ids) {
-        ids.sort((x, y) => compare(x, y));
-        return ids;
-    }
-    OrderedId64Iterable.sortArray = sortArray;
-    /** Given two ordered collections of [[Id64String]]s, determine whether they are identical sets. Duplicate Ids are ignored.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function areEqualSets(ids1, ids2) {
-        const leftIter = uniqueIterator(ids1);
-        const rightIter = uniqueIterator(ids2);
-        let leftState = leftIter.next();
-        let rightState = rightIter.next();
-        while (!leftState.done && !rightState.done) {
-            const left = leftState.value;
-            const right = rightState.value;
-            if (0 !== compare(left, right))
-                return false;
-            leftState = leftIter.next();
-            rightState = rightIter.next();
-        }
-        if (leftState.done && rightState.done)
-            return true;
-        return false;
-    }
-    OrderedId64Iterable.areEqualSets = areEqualSets;
-    /** Given an ordered collection of [[Id64String]]s, determine if it contains any Ids.
-     * @param ids A well-formed, ordered collection of zero or more valid Ids.
-     * @returns true if the input represents an empty set of Ids. The result is unspecified if the input does not meet the criteria for the input type.
-     */
-    function isEmptySet(ids) {
-        if (typeof ids === "string")
-            return "" === ids;
-        return true === ids[Symbol.iterator]().next().done;
-    }
-    OrderedId64Iterable.isEmptySet = isEmptySet;
-    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered collection containing no duplicates.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function unique(ids) {
-        return { [Symbol.iterator]: () => uniqueIterator(ids) };
-    }
-    OrderedId64Iterable.unique = unique;
-    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered iterator over the distinct Ids, eliminating duplicates.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function* uniqueIterator(ids) {
-        const iter = ids[Symbol.iterator]();
-        let state = iter.next();
-        let prev;
-        while (!state.done) {
-            const id = state.value;
-            state = iter.next();
-            if (id !== prev) {
-                prev = id;
-                yield id;
-            }
-        }
-    }
-    OrderedId64Iterable.uniqueIterator = uniqueIterator;
-    /** Given two ordered collections of [[Id64String]]s, produce a collection representing their union - i.e., the Ids that are present in either or both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function union(ids1, ids2) {
-        return { [Symbol.iterator]: () => unionIterator(ids1, ids2) };
-    }
-    OrderedId64Iterable.union = union;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function intersection(ids1, ids2) {
-        return { [Symbol.iterator]: () => intersectionIterator(ids1, ids2) };
-    }
-    OrderedId64Iterable.intersection = intersection;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function difference(ids1, ids2) {
-        return { [Symbol.iterator]: () => differenceIterator(ids1, ids2) };
-    }
-    OrderedId64Iterable.difference = difference;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their union - i.e., the Ids that are present in either or both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function* unionIterator(ids1, ids2) {
-        const leftIter = ids1[Symbol.iterator]();
-        const rightIter = ids2[Symbol.iterator]();
-        let leftState = leftIter.next();
-        let rightState = rightIter.next();
-        let prev;
-        while (!leftState.done || !rightState.done) {
-            const left = leftState.done ? undefined : leftState.value;
-            const right = rightState.done ? undefined : rightState.value;
-            assert(undefined !== left || undefined !== right);
-            if (undefined === left && undefined === right)
-                break;
-            let next;
-            if (undefined === left) {
-                assert(undefined !== right);
-                next = right;
-                rightState = rightIter.next();
-            }
-            else if (undefined === right) {
-                next = left;
-                leftState = leftIter.next();
-            }
-            else {
-                const cmp = compare(left, right);
-                if (cmp <= 0) {
-                    next = left;
-                    leftState = leftIter.next();
-                    if (0 === cmp)
-                        rightState = rightIter.next();
-                }
-                else {
-                    next = right;
-                    rightState = rightIter.next();
-                }
-            }
-            if (prev === next)
-                continue;
-            prev = next;
-            yield next;
-        }
-    }
-    OrderedId64Iterable.unionIterator = unionIterator;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function* intersectionIterator(ids1, ids2) {
-        const leftIter = ids1[Symbol.iterator]();
-        const rightIter = ids2[Symbol.iterator]();
-        let leftState = leftIter.next();
-        let rightState = rightIter.next();
-        let prev;
-        while (!leftState.done && !rightState.done) {
-            const left = leftState.value;
-            leftState = leftIter.next();
-            if (left === prev)
-                continue;
-            prev = left;
-            let right = rightState.value;
-            let cmp = compare(left, right);
-            while (cmp > 0) {
-                rightState = rightIter.next();
-                if (rightState.done)
-                    return;
-                right = rightState.value;
-                cmp = compare(left, right);
-            }
-            if (0 === cmp)
-                yield left;
-        }
-    }
-    OrderedId64Iterable.intersectionIterator = intersectionIterator;
-    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
-     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
-     */
-    function* differenceIterator(ids1, ids2) {
-        const leftIter = ids1[Symbol.iterator]();
-        const rightIter = ids2[Symbol.iterator]();
-        let leftState = leftIter.next();
-        let rightState = rightIter.next();
-        let prev;
-        while (!leftState.done) {
-            const left = leftState.value;
-            leftState = leftIter.next();
-            if (left === prev)
-                continue;
-            else if (rightState.done) {
-                yield prev = left;
-                continue;
-            }
-            let right = rightState.value;
-            let cmp = compare(left, right);
-            while (cmp > 0 && !rightState.done) {
-                rightState = rightIter.next();
-                if (rightState.done) {
-                    yield prev = left;
-                    continue;
-                }
-                right = rightState.value;
-                cmp = compare(left, right);
-            }
-            if (cmp < 0)
-                yield prev = left;
-        }
-    }
-    OrderedId64Iterable.differenceIterator = differenceIterator;
-})(OrderedId64Iterable || (OrderedId64Iterable = {}));
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Ids
+ */
+import { assert } from "./Assert";
+/** A collection of **valid** [[Id64String]]s sorted in ascending order by the unsigned 64-bit integer value of the Ids.
+ * This ordering is a requirement for several groups of APIs including [[CompressedId64Set]].
+ * When used as input to a function, duplicate Ids are ignored; when returned as a function output, no duplicates are present.
+ * @see [[CompressedId64Set]] for a compact string representation of such an ordered collection.
+ * @see [[OrderedId64Iterable.compare]] for a function that compares Ids based on this criterion.
+ * @see [[OrderedId64Array]] for a mutable implementation.
+ * @public
+ */
+export var OrderedId64Iterable;
+(function (OrderedId64Iterable) {
+    /** An ordered comparison of [[Id64String]]s suitable for use with sorting routines like
+     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) and sorted containers
+     * like [[SortedArray]] and [[Dictionary]]. The comparison compares the 64-bit numerical values of the two Ids, returning a negative number if lhs < rhs,
+     * a positive number if lhs > rhs, or zero if lhs == rhs.
+     * The default string comparison is fine (and more efficient) when numerical ordering is not required; use this instead if you want e.g., "0x100" to be greater than "0xf".
+     * @see [[OrderedId64Iterable.sortArray]] for a convenient way to sort an array of Id64Strings.
+     */
+    function compare(lhs, rhs) {
+        if (lhs.length !== rhs.length)
+            return lhs.length < rhs.length ? -1 : 1;
+        // This is faster than localeCompare(). Unclear why there is no string.compare() - would be generally useful in
+        // array sort functions...
+        if (lhs !== rhs)
+            return lhs < rhs ? -1 : 1;
+        return 0;
+    }
+    OrderedId64Iterable.compare = compare;
+    /** Sort an array of [[Id64String]]s **in-place** in ascending order by their 64-bit numerical values.
+     * @see [[OrderedId64Iterable.compare]] for the comparison routine used.
+     * @returns the input array.
+     * @note This function returns its input for consistency with Javascript's
+     * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method.
+     * It **does not** create a **new** array.
+     */
+    function sortArray(ids) {
+        ids.sort((x, y) => compare(x, y));
+        return ids;
+    }
+    OrderedId64Iterable.sortArray = sortArray;
+    /** Given two ordered collections of [[Id64String]]s, determine whether they are identical sets. Duplicate Ids are ignored.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function areEqualSets(ids1, ids2) {
+        const leftIter = uniqueIterator(ids1);
+        const rightIter = uniqueIterator(ids2);
+        let leftState = leftIter.next();
+        let rightState = rightIter.next();
+        while (!leftState.done && !rightState.done) {
+            const left = leftState.value;
+            const right = rightState.value;
+            if (0 !== compare(left, right))
+                return false;
+            leftState = leftIter.next();
+            rightState = rightIter.next();
+        }
+        if (leftState.done && rightState.done)
+            return true;
+        return false;
+    }
+    OrderedId64Iterable.areEqualSets = areEqualSets;
+    /** Given an ordered collection of [[Id64String]]s, determine if it contains any Ids.
+     * @param ids A well-formed, ordered collection of zero or more valid Ids.
+     * @returns true if the input represents an empty set of Ids. The result is unspecified if the input does not meet the criteria for the input type.
+     */
+    function isEmptySet(ids) {
+        if (typeof ids === "string")
+            return "" === ids;
+        return true === ids[Symbol.iterator]().next().done;
+    }
+    OrderedId64Iterable.isEmptySet = isEmptySet;
+    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered collection containing no duplicates.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function unique(ids) {
+        return { [Symbol.iterator]: () => uniqueIterator(ids) };
+    }
+    OrderedId64Iterable.unique = unique;
+    /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered iterator over the distinct Ids, eliminating duplicates.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function* uniqueIterator(ids) {
+        const iter = ids[Symbol.iterator]();
+        let state = iter.next();
+        let prev;
+        while (!state.done) {
+            const id = state.value;
+            state = iter.next();
+            if (id !== prev) {
+                prev = id;
+                yield id;
+            }
+        }
+    }
+    OrderedId64Iterable.uniqueIterator = uniqueIterator;
+    /** Given two ordered collections of [[Id64String]]s, produce a collection representing their union - i.e., the Ids that are present in either or both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function union(ids1, ids2) {
+        return { [Symbol.iterator]: () => unionIterator(ids1, ids2) };
+    }
+    OrderedId64Iterable.union = union;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function intersection(ids1, ids2) {
+        return { [Symbol.iterator]: () => intersectionIterator(ids1, ids2) };
+    }
+    OrderedId64Iterable.intersection = intersection;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function difference(ids1, ids2) {
+        return { [Symbol.iterator]: () => differenceIterator(ids1, ids2) };
+    }
+    OrderedId64Iterable.difference = difference;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their union - i.e., the Ids that are present in either or both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function* unionIterator(ids1, ids2) {
+        const leftIter = ids1[Symbol.iterator]();
+        const rightIter = ids2[Symbol.iterator]();
+        let leftState = leftIter.next();
+        let rightState = rightIter.next();
+        let prev;
+        while (!leftState.done || !rightState.done) {
+            const left = leftState.done ? undefined : leftState.value;
+            const right = rightState.done ? undefined : rightState.value;
+            assert(undefined !== left || undefined !== right);
+            if (undefined === left && undefined === right)
+                break;
+            let next;
+            if (undefined === left) {
+                assert(undefined !== right);
+                next = right;
+                rightState = rightIter.next();
+            }
+            else if (undefined === right) {
+                next = left;
+                leftState = leftIter.next();
+            }
+            else {
+                const cmp = compare(left, right);
+                if (cmp <= 0) {
+                    next = left;
+                    leftState = leftIter.next();
+                    if (0 === cmp)
+                        rightState = rightIter.next();
+                }
+                else {
+                    next = right;
+                    rightState = rightIter.next();
+                }
+            }
+            if (prev === next)
+                continue;
+            prev = next;
+            yield next;
+        }
+    }
+    OrderedId64Iterable.unionIterator = unionIterator;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function* intersectionIterator(ids1, ids2) {
+        const leftIter = ids1[Symbol.iterator]();
+        const rightIter = ids2[Symbol.iterator]();
+        let leftState = leftIter.next();
+        let rightState = rightIter.next();
+        let prev;
+        while (!leftState.done && !rightState.done) {
+            const left = leftState.value;
+            leftState = leftIter.next();
+            if (left === prev)
+                continue;
+            prev = left;
+            let right = rightState.value;
+            let cmp = compare(left, right);
+            while (cmp > 0) {
+                rightState = rightIter.next();
+                if (rightState.done)
+                    return;
+                right = rightState.value;
+                cmp = compare(left, right);
+            }
+            if (0 === cmp)
+                yield left;
+        }
+    }
+    OrderedId64Iterable.intersectionIterator = intersectionIterator;
+    /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their difference - i.e., the Ids that are present in `ids1` but not present in `ids2`.
+     * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.
+     */
+    function* differenceIterator(ids1, ids2) {
+        const leftIter = ids1[Symbol.iterator]();
+        const rightIter = ids2[Symbol.iterator]();
+        let leftState = leftIter.next();
+        let rightState = rightIter.next();
+        let prev;
+        while (!leftState.done) {
+            const left = leftState.value;
+            leftState = leftIter.next();
+            if (left === prev)
+                continue;
+            else if (rightState.done) {
+                yield prev = left;
+                continue;
+            }
+            let right = rightState.value;
+            let cmp = compare(left, right);
+            while (cmp > 0 && !rightState.done) {
+                rightState = rightIter.next();
+                if (rightState.done) {
+                    yield prev = left;
+                    continue;
+                }
+                right = rightState.value;
+                cmp = compare(left, right);
+            }
+            if (cmp < 0)
+                yield prev = left;
+        }
+    }
+    OrderedId64Iterable.differenceIterator = differenceIterator;
+})(OrderedId64Iterable || (OrderedId64Iterable = {}));
 //# sourceMappingURL=OrderedId64Iterable.js.map