@itwin/core-bentley 4.0.0-dev.22 → 4.0.0-dev.23

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

package/lib/esm/OrderedId64Iterable.js.map

@@ -1 +1 @@
-{"version":3,"file":"OrderedId64Iterable.js","sourceRoot":"","sources":["../../src/OrderedId64Iterable.ts"],"names":[],"mappings":"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","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 Ids\r\n */\r\n\r\nimport { assert } from \"./Assert\";\r\nimport { CompressedId64Set } from \"./CompressedId64Set\";\r\nimport { Id64Array, Id64String } from \"./Id\";\r\n\r\n/** @public */\r\nexport type OrderedId64Iterable = Iterable<Id64String>;\r\n\r\n/** A collection of **valid** [[Id64String]]s sorted in ascending order by the unsigned 64-bit integer value of the Ids.\r\n * This ordering is a requirement for several groups of APIs including [[CompressedId64Set]].\r\n * When used as input to a function, duplicate Ids are ignored; when returned as a function output, no duplicates are present.\r\n * @see [[CompressedId64Set]] for a compact string representation of such an ordered collection.\r\n * @see [[OrderedId64Iterable.compare]] for a function that compares Ids based on this criterion.\r\n * @see [[OrderedId64Array]] for a mutable implementation.\r\n * @public\r\n */\r\nexport namespace OrderedId64Iterable { // eslint-disable-line @typescript-eslint/no-redeclare\r\n  /** An ordered comparison of [[Id64String]]s suitable for use with sorting routines like\r\n   * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) and sorted containers\r\n   * like [[SortedArray]] and [[Dictionary]]. The comparison compares the 64-bit numerical values of the two Ids, returning a negative number if lhs < rhs,\r\n   * a positive number if lhs > rhs, or zero if lhs == rhs.\r\n   * 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\".\r\n   * @see [[OrderedId64Iterable.sortArray]] for a convenient way to sort an array of Id64Strings.\r\n   */\r\n  export function compare(lhs: Id64String, rhs: Id64String): number {\r\n    if (lhs.length !== rhs.length)\r\n      return lhs.length < rhs.length ? -1 : 1;\r\n\r\n    // This is faster than localeCompare(). Unclear why there is no string.compare() - would be generally useful in\r\n    // array sort functions...\r\n    if (lhs !== rhs)\r\n      return lhs < rhs ? -1 : 1;\r\n\r\n    return 0;\r\n  }\r\n\r\n  /** Sort an array of [[Id64String]]s **in-place** in ascending order by their 64-bit numerical values.\r\n   * @see [[OrderedId64Iterable.compare]] for the comparison routine used.\r\n   * @returns the input array.\r\n   * @note This function returns its input for consistency with Javascript's\r\n   * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method.\r\n   * It **does not** create a **new** array.\r\n   */\r\n  export function sortArray(ids: Id64Array): Id64Array {\r\n    ids.sort((x, y) => compare(x, y));\r\n    return ids;\r\n  }\r\n\r\n  /** Given two ordered collections of [[Id64String]]s, determine whether they are identical sets. Duplicate Ids are ignored.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function areEqualSets(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): boolean {\r\n    const leftIter = uniqueIterator(ids1);\r\n    const rightIter = uniqueIterator(ids2);\r\n    let leftState = leftIter.next();\r\n    let rightState = rightIter.next();\r\n\r\n    while (!leftState.done && !rightState.done) {\r\n      const left = leftState.value;\r\n      const right = rightState.value;\r\n      if (0 !== compare(left, right))\r\n        return false;\r\n\r\n      leftState = leftIter.next();\r\n      rightState = rightIter.next();\r\n    }\r\n\r\n    if (leftState.done && rightState.done)\r\n      return true;\r\n\r\n    return false;\r\n  }\r\n\r\n  /** Given an ordered collection of [[Id64String]]s, determine if it contains any Ids.\r\n   * @param ids A well-formed, ordered collection of zero or more valid Ids.\r\n   * @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.\r\n   */\r\n  export function isEmptySet(ids: OrderedId64Iterable | CompressedId64Set): boolean {\r\n    if (typeof ids === \"string\")\r\n      return \"\" === ids;\r\n\r\n    return true === ids[Symbol.iterator]().next().done;\r\n  }\r\n\r\n  /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered collection containing no duplicates.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function unique(ids: OrderedId64Iterable): OrderedId64Iterable {\r\n    return { [Symbol.iterator]: () => uniqueIterator(ids) };\r\n  }\r\n\r\n  /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered iterator over the distinct Ids, eliminating duplicates.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function* uniqueIterator(ids: OrderedId64Iterable) {\r\n    const iter = ids[Symbol.iterator]();\r\n    let state = iter.next();\r\n    let prev: Id64String | undefined;\r\n\r\n    while (!state.done) {\r\n      const id = state.value;\r\n      state = iter.next();\r\n      if (id !== prev) {\r\n        prev = id;\r\n        yield id;\r\n      }\r\n    }\r\n  }\r\n\r\n  /** 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.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function union(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable {\r\n    return { [Symbol.iterator]: () => unionIterator(ids1, ids2) };\r\n  }\r\n\r\n  /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function intersection(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable {\r\n    return { [Symbol.iterator]: () => intersectionIterator(ids1, ids2) };\r\n  }\r\n\r\n  /** 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`.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function difference(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable {\r\n    return { [Symbol.iterator]: () => differenceIterator(ids1, ids2) };\r\n  }\r\n\r\n  /** 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.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function* unionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable) {\r\n    const leftIter = ids1[Symbol.iterator]();\r\n    const rightIter = ids2[Symbol.iterator]();\r\n    let leftState = leftIter.next();\r\n    let rightState = rightIter.next();\r\n\r\n    let prev: string | undefined;\r\n    while (!leftState.done || !rightState.done) {\r\n      const left = leftState.done ? undefined : leftState.value;\r\n      const right = rightState.done ? undefined : rightState.value;\r\n\r\n      assert(undefined !== left || undefined !== right);\r\n      if (undefined === left && undefined === right)\r\n        break;\r\n\r\n      let next: Id64String;\r\n      if (undefined === left) {\r\n        assert(undefined !== right);\r\n        next = right;\r\n        rightState = rightIter.next();\r\n      } else if (undefined === right) {\r\n        next = left;\r\n        leftState = leftIter.next();\r\n      } else {\r\n        const cmp = compare(left, right);\r\n        if (cmp <= 0) {\r\n          next = left;\r\n          leftState = leftIter.next();\r\n          if (0 === cmp)\r\n            rightState = rightIter.next();\r\n        } else {\r\n          next = right;\r\n          rightState = rightIter.next();\r\n        }\r\n      }\r\n\r\n      if (prev === next)\r\n        continue;\r\n\r\n      prev = next;\r\n      yield next;\r\n    }\r\n  }\r\n\r\n  /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function* intersectionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable) {\r\n    const leftIter = ids1[Symbol.iterator]();\r\n    const rightIter = ids2[Symbol.iterator]();\r\n    let leftState = leftIter.next();\r\n    let rightState = rightIter.next();\r\n\r\n    let prev: string | undefined;\r\n    while (!leftState.done && !rightState.done) {\r\n      const left = leftState.value;\r\n      leftState = leftIter.next();\r\n      if (left === prev)\r\n        continue;\r\n\r\n      prev = left;\r\n\r\n      let right = rightState.value;\r\n      let cmp = compare(left, right);\r\n      while (cmp > 0) {\r\n        rightState = rightIter.next();\r\n        if (rightState.done)\r\n          return;\r\n\r\n        right = rightState.value;\r\n        cmp = compare(left, right);\r\n      }\r\n\r\n      if (0 === cmp)\r\n        yield left;\r\n    }\r\n  }\r\n\r\n  /** 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`.\r\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\r\n   */\r\n  export function* differenceIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable) {\r\n    const leftIter = ids1[Symbol.iterator]();\r\n    const rightIter = ids2[Symbol.iterator]();\r\n    let leftState = leftIter.next();\r\n    let rightState = rightIter.next();\r\n\r\n    let prev: string | undefined;\r\n    while (!leftState.done) {\r\n      const left = leftState.value;\r\n      leftState = leftIter.next();\r\n      if (left === prev)\r\n        continue;\r\n      else if (rightState.done) {\r\n        yield prev = left;\r\n        continue;\r\n      }\r\n\r\n      let right = rightState.value;\r\n      let cmp = compare(left, right);\r\n      while (cmp > 0 && !rightState.done) {\r\n        rightState = rightIter.next();\r\n        if (rightState.done) {\r\n          yield prev = left;\r\n          continue;\r\n        }\r\n\r\n        right = rightState.value;\r\n        cmp = compare(left, right);\r\n      }\r\n\r\n      if (cmp < 0)\r\n        yield prev = left;\r\n    }\r\n  }\r\n}\r\n"]}
+{"version":3,"file":"OrderedId64Iterable.js","sourceRoot":"","sources":["../../src/OrderedId64Iterable.ts"],"names":[],"mappings":"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","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 Ids\n */\n\nimport { assert } from \"./Assert\";\nimport { CompressedId64Set } from \"./CompressedId64Set\";\nimport { Id64Array, Id64String } from \"./Id\";\n\n/** @public */\nexport type OrderedId64Iterable = Iterable<Id64String>;\n\n/** A collection of **valid** [[Id64String]]s sorted in ascending order by the unsigned 64-bit integer value of the Ids.\n * This ordering is a requirement for several groups of APIs including [[CompressedId64Set]].\n * When used as input to a function, duplicate Ids are ignored; when returned as a function output, no duplicates are present.\n * @see [[CompressedId64Set]] for a compact string representation of such an ordered collection.\n * @see [[OrderedId64Iterable.compare]] for a function that compares Ids based on this criterion.\n * @see [[OrderedId64Array]] for a mutable implementation.\n * @public\n */\nexport namespace OrderedId64Iterable { // eslint-disable-line @typescript-eslint/no-redeclare\n  /** An ordered comparison of [[Id64String]]s suitable for use with sorting routines like\n   * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) and sorted containers\n   * like [[SortedArray]] and [[Dictionary]]. The comparison compares the 64-bit numerical values of the two Ids, returning a negative number if lhs < rhs,\n   * a positive number if lhs > rhs, or zero if lhs == rhs.\n   * 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\".\n   * @see [[OrderedId64Iterable.sortArray]] for a convenient way to sort an array of Id64Strings.\n   */\n  export function compare(lhs: Id64String, rhs: Id64String): number {\n    if (lhs.length !== rhs.length)\n      return lhs.length < rhs.length ? -1 : 1;\n\n    // This is faster than localeCompare(). Unclear why there is no string.compare() - would be generally useful in\n    // array sort functions...\n    if (lhs !== rhs)\n      return lhs < rhs ? -1 : 1;\n\n    return 0;\n  }\n\n  /** Sort an array of [[Id64String]]s **in-place** in ascending order by their 64-bit numerical values.\n   * @see [[OrderedId64Iterable.compare]] for the comparison routine used.\n   * @returns the input array.\n   * @note This function returns its input for consistency with Javascript's\n   * [Array.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method.\n   * It **does not** create a **new** array.\n   */\n  export function sortArray(ids: Id64Array): Id64Array {\n    ids.sort((x, y) => compare(x, y));\n    return ids;\n  }\n\n  /** Given two ordered collections of [[Id64String]]s, determine whether they are identical sets. Duplicate Ids are ignored.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function areEqualSets(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): boolean {\n    const leftIter = uniqueIterator(ids1);\n    const rightIter = uniqueIterator(ids2);\n    let leftState = leftIter.next();\n    let rightState = rightIter.next();\n\n    while (!leftState.done && !rightState.done) {\n      const left = leftState.value;\n      const right = rightState.value;\n      if (0 !== compare(left, right))\n        return false;\n\n      leftState = leftIter.next();\n      rightState = rightIter.next();\n    }\n\n    if (leftState.done && rightState.done)\n      return true;\n\n    return false;\n  }\n\n  /** Given an ordered collection of [[Id64String]]s, determine if it contains any Ids.\n   * @param ids A well-formed, ordered collection of zero or more valid Ids.\n   * @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.\n   */\n  export function isEmptySet(ids: OrderedId64Iterable | CompressedId64Set): boolean {\n    if (typeof ids === \"string\")\n      return \"\" === ids;\n\n    return true === ids[Symbol.iterator]().next().done;\n  }\n\n  /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered collection containing no duplicates.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function unique(ids: OrderedId64Iterable): OrderedId64Iterable {\n    return { [Symbol.iterator]: () => uniqueIterator(ids) };\n  }\n\n  /** Given an ordered collection of [[Id64String]]s possibly containing duplicates, produce an ordered iterator over the distinct Ids, eliminating duplicates.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function* uniqueIterator(ids: OrderedId64Iterable) {\n    const iter = ids[Symbol.iterator]();\n    let state = iter.next();\n    let prev: Id64String | undefined;\n\n    while (!state.done) {\n      const id = state.value;\n      state = iter.next();\n      if (id !== prev) {\n        prev = id;\n        yield id;\n      }\n    }\n  }\n\n  /** 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.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function union(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable {\n    return { [Symbol.iterator]: () => unionIterator(ids1, ids2) };\n  }\n\n  /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function intersection(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable {\n    return { [Symbol.iterator]: () => intersectionIterator(ids1, ids2) };\n  }\n\n  /** 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`.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function difference(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable): OrderedId64Iterable {\n    return { [Symbol.iterator]: () => differenceIterator(ids1, ids2) };\n  }\n\n  /** 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.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function* unionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable) {\n    const leftIter = ids1[Symbol.iterator]();\n    const rightIter = ids2[Symbol.iterator]();\n    let leftState = leftIter.next();\n    let rightState = rightIter.next();\n\n    let prev: string | undefined;\n    while (!leftState.done || !rightState.done) {\n      const left = leftState.done ? undefined : leftState.value;\n      const right = rightState.done ? undefined : rightState.value;\n\n      assert(undefined !== left || undefined !== right);\n      if (undefined === left && undefined === right)\n        break;\n\n      let next: Id64String;\n      if (undefined === left) {\n        assert(undefined !== right);\n        next = right;\n        rightState = rightIter.next();\n      } else if (undefined === right) {\n        next = left;\n        leftState = leftIter.next();\n      } else {\n        const cmp = compare(left, right);\n        if (cmp <= 0) {\n          next = left;\n          leftState = leftIter.next();\n          if (0 === cmp)\n            rightState = rightIter.next();\n        } else {\n          next = right;\n          rightState = rightIter.next();\n        }\n      }\n\n      if (prev === next)\n        continue;\n\n      prev = next;\n      yield next;\n    }\n  }\n\n  /** Given two ordered collections of [[Id64String]]s, produce an iterator representing their intersection - i.e., the Ids that are present in both collections.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function* intersectionIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable) {\n    const leftIter = ids1[Symbol.iterator]();\n    const rightIter = ids2[Symbol.iterator]();\n    let leftState = leftIter.next();\n    let rightState = rightIter.next();\n\n    let prev: string | undefined;\n    while (!leftState.done && !rightState.done) {\n      const left = leftState.value;\n      leftState = leftIter.next();\n      if (left === prev)\n        continue;\n\n      prev = left;\n\n      let right = rightState.value;\n      let cmp = compare(left, right);\n      while (cmp > 0) {\n        rightState = rightIter.next();\n        if (rightState.done)\n          return;\n\n        right = rightState.value;\n        cmp = compare(left, right);\n      }\n\n      if (0 === cmp)\n        yield left;\n    }\n  }\n\n  /** 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`.\n   * @note If the inputs are not ordered as required by [[OrderedId64Iterable]], the results are unpredictable.\n   */\n  export function* differenceIterator(ids1: OrderedId64Iterable, ids2: OrderedId64Iterable) {\n    const leftIter = ids1[Symbol.iterator]();\n    const rightIter = ids2[Symbol.iterator]();\n    let leftState = leftIter.next();\n    let rightState = rightIter.next();\n\n    let prev: string | undefined;\n    while (!leftState.done) {\n      const left = leftState.value;\n      leftState = leftIter.next();\n      if (left === prev)\n        continue;\n      else if (rightState.done) {\n        yield prev = left;\n        continue;\n      }\n\n      let right = rightState.value;\n      let cmp = compare(left, right);\n      while (cmp > 0 && !rightState.done) {\n        rightState = rightIter.next();\n        if (rightState.done) {\n          yield prev = left;\n          continue;\n        }\n\n        right = rightState.value;\n        cmp = compare(left, right);\n      }\n\n      if (cmp < 0)\n        yield prev = left;\n    }\n  }\n}\n"]}

package/lib/esm/OrderedSet.d.ts

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