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

package/lib/cjs/ProcessDetector.js.map

@@ -1 +1 @@
-{"version":3,"file":"ProcessDetector.js","sourceRoot":"","sources":["../../src/ProcessDetector.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 ProcessDetector\r\n */\r\n\r\n/** Functions to determine the type of JavaScript process currently executing.\r\n * @public\r\n */\r\nexport class ProcessDetector {\r\n\r\n  /** Is this a browser process?\r\n   * @note this method will also return `true` for the frontend of Electron or Mobile apps. They *are* browser processes.\r\n   */\r\n  public static get isBrowserProcess() { return typeof window === \"object\" && typeof window.navigator === \"object\"; }\r\n\r\n  /** Is this a Node process?\r\n   * @note this means \"is this a backend process\"? It will return `true` for all backend process, including Electron and mobile apps.\r\n  */\r\n  public static get isNodeProcess() { return typeof process === \"object\" && undefined !== process.platform; }\r\n\r\n  /** Is this process the frontend of an Electron app? */\r\n  public static get isElectronAppFrontend() { return typeof navigator === \"object\" && navigator.userAgent.toLowerCase().indexOf(\"electron\") >= 0; }\r\n\r\n  /** Is this process the backend of an Electron app? */\r\n  public static get isElectronAppBackend() { return typeof process === \"object\" && process.versions.hasOwnProperty(\"electron\"); }\r\n\r\n  /** Is this process running in a browser on an iPad?\r\n   * @note This method will return `true` for any frontend running on an iPad, whether it is a user-launched web browser (e.g. Safari) or the frontend of a mobile app.\r\n   */\r\n  public static get isIPadBrowser() {\r\n    return this.isBrowserProcess && window.navigator.platform === \"iPad\" || (window.navigator.platform === \"MacIntel\" && window.navigator.maxTouchPoints > 0 && !(\"MSStream\" in window)); /* eslint-disable-line deprecation/deprecation */\r\n  }\r\n\r\n  /** Is this process running in a browser on an iPhone?\r\n   * @note This method will return `true` for any frontend running on an iPhone, whether it is a user-launched web browser (e.g. Safari) or the frontend of a mobile app.\r\n   */\r\n  public static get isIPhoneBrowser() { return this.isBrowserProcess && (/(iphone|ipod)/i.test(window.navigator.userAgent)); }\r\n\r\n  /** Is this process running in a browser on an iOS device?\r\n   * @note This method will return `true` for any frontend running on an iOS device, whether it is a user-launched web browser (e.g. Safari) or the frontend of a mobile app.\r\n  */\r\n  public static get isIOSBrowser() { return this.isIPadBrowser || this.isIPhoneBrowser; }\r\n\r\n  /** Is this process running in a browser on an Android device?\r\n   * @note This method will return `true` for any frontend running on an Android device, whether it is a user-launched web browser (e.g. Chrome) or the frontend of a mobile app.\r\n  */\r\n  public static get isAndroidBrowser() { return this.isBrowserProcess && /android/i.test(window.navigator.userAgent); }\r\n\r\n  /** Is this process running in a browser on a mobile device?\r\n   * @note This method will return `true` for any frontend running on a mobile device, whether it is a user-launched web browser or the frontend of a mobile app.\r\n  */\r\n  public static get isMobileBrowser() { return this.isIOSBrowser || this.isAndroidBrowser; }\r\n\r\n  /** Is this process running in a Chromium based browser (Chrome / new Edge / Electron front end)? */\r\n  public static get isChromium() {\r\n    return (this.isBrowserProcess && window.navigator.userAgent.indexOf(\"Chrome\") > -1 && window.navigator.userAgent.indexOf(\"OP\") === -1) || this.isElectronAppFrontend;\r\n  }\r\n\r\n  /** Is this process the frontend of an iTwin mobile application?\r\n   * @note this indicates that this is a browser process started by an iTwin mobile application.\r\n   * It will return `false` when running user-launched web browsers on a mobile device.\r\n   */\r\n  public static get isMobileAppFrontend() { return this.isAndroidAppFrontend || this.isIOSAppFrontend; }\r\n\r\n  /** Is this process the frontend of an iOS mobile application? */\r\n  public static get isIOSAppFrontend() { return this.isBrowserProcess && window.location.hash.indexOf(\"platform=ios\") !== -1; }\r\n\r\n  /** Is this process the frontend of an Android mobile application? */\r\n  public static get isAndroidAppFrontend() { return this.isBrowserProcess && window.location.hash.indexOf(\"platform=android\") !== -1; }\r\n\r\n  /** Is this process the backend of an iOS mobile application? */\r\n  public static get isIOSAppBackend() { return this.isNodeProcess && (process.platform as any) === \"ios\"; }\r\n\r\n  /** Is this process the backend of an Android mobile application? */\r\n  public static get isAndroidAppBackend() { return this.isNodeProcess && (process.platform as any) === \"android\"; }\r\n\r\n  /**  Is this process a mobile app backend? */\r\n  public static get isMobileAppBackend() { return this.isIOSAppBackend || this.isAndroidAppBackend; }\r\n\r\n  /** Is this process the frontend of a native (Electron or Mobile) app? */\r\n  public static get isNativeAppFrontend() { return this.isElectronAppFrontend || this.isMobileAppFrontend; }\r\n}\r\n"]}
+{"version":3,"file":"ProcessDetector.js","sourceRoot":"","sources":["../../src/ProcessDetector.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 ProcessDetector\n */\n\n/** Functions to determine the type of JavaScript process currently executing.\n * @public\n */\nexport class ProcessDetector {\n\n  /** Is this a browser process?\n   * @note this method will also return `true` for the frontend of Electron or Mobile apps. They *are* browser processes.\n   */\n  public static get isBrowserProcess() { return typeof window === \"object\" && typeof window.navigator === \"object\"; }\n\n  /** Is this a Node process?\n   * @note this means \"is this a backend process\"? It will return `true` for all backend process, including Electron and mobile apps.\n  */\n  public static get isNodeProcess() { return typeof process === \"object\" && undefined !== process.platform; }\n\n  /** Is this process the frontend of an Electron app? */\n  public static get isElectronAppFrontend() { return typeof navigator === \"object\" && navigator.userAgent.toLowerCase().indexOf(\"electron\") >= 0; }\n\n  /** Is this process the backend of an Electron app? */\n  public static get isElectronAppBackend() { return typeof process === \"object\" && process.versions.hasOwnProperty(\"electron\"); }\n\n  /** Is this process running in a browser on an iPad?\n   * @note This method will return `true` for any frontend running on an iPad, whether it is a user-launched web browser (e.g. Safari) or the frontend of a mobile app.\n   */\n  public static get isIPadBrowser() {\n    return this.isBrowserProcess && window.navigator.platform === \"iPad\" || (window.navigator.platform === \"MacIntel\" && window.navigator.maxTouchPoints > 0 && !(\"MSStream\" in window)); /* eslint-disable-line deprecation/deprecation */\n  }\n\n  /** Is this process running in a browser on an iPhone?\n   * @note This method will return `true` for any frontend running on an iPhone, whether it is a user-launched web browser (e.g. Safari) or the frontend of a mobile app.\n   */\n  public static get isIPhoneBrowser() { return this.isBrowserProcess && (/(iphone|ipod)/i.test(window.navigator.userAgent)); }\n\n  /** Is this process running in a browser on an iOS device?\n   * @note This method will return `true` for any frontend running on an iOS device, whether it is a user-launched web browser (e.g. Safari) or the frontend of a mobile app.\n  */\n  public static get isIOSBrowser() { return this.isIPadBrowser || this.isIPhoneBrowser; }\n\n  /** Is this process running in a browser on an Android device?\n   * @note This method will return `true` for any frontend running on an Android device, whether it is a user-launched web browser (e.g. Chrome) or the frontend of a mobile app.\n  */\n  public static get isAndroidBrowser() { return this.isBrowserProcess && /android/i.test(window.navigator.userAgent); }\n\n  /** Is this process running in a browser on a mobile device?\n   * @note This method will return `true` for any frontend running on a mobile device, whether it is a user-launched web browser or the frontend of a mobile app.\n  */\n  public static get isMobileBrowser() { return this.isIOSBrowser || this.isAndroidBrowser; }\n\n  /** Is this process running in a Chromium based browser (Chrome / new Edge / Electron front end)? */\n  public static get isChromium() {\n    return (this.isBrowserProcess && window.navigator.userAgent.indexOf(\"Chrome\") > -1 && window.navigator.userAgent.indexOf(\"OP\") === -1) || this.isElectronAppFrontend;\n  }\n\n  /** Is this process the frontend of an iTwin mobile application?\n   * @note this indicates that this is a browser process started by an iTwin mobile application.\n   * It will return `false` when running user-launched web browsers on a mobile device.\n   */\n  public static get isMobileAppFrontend() { return this.isAndroidAppFrontend || this.isIOSAppFrontend; }\n\n  /** Is this process the frontend of an iOS mobile application? */\n  public static get isIOSAppFrontend() { return this.isBrowserProcess && window.location.hash.indexOf(\"platform=ios\") !== -1; }\n\n  /** Is this process the frontend of an Android mobile application? */\n  public static get isAndroidAppFrontend() { return this.isBrowserProcess && window.location.hash.indexOf(\"platform=android\") !== -1; }\n\n  /** Is this process the backend of an iOS mobile application? */\n  public static get isIOSAppBackend() { return this.isNodeProcess && (process.platform as any) === \"ios\"; }\n\n  /** Is this process the backend of an Android mobile application? */\n  public static get isAndroidAppBackend() { return this.isNodeProcess && (process.platform as any) === \"android\"; }\n\n  /**  Is this process a mobile app backend? */\n  public static get isMobileAppBackend() { return this.isIOSAppBackend || this.isAndroidAppBackend; }\n\n  /** Is this process the frontend of a native (Electron or Mobile) app? */\n  public static get isNativeAppFrontend() { return this.isElectronAppFrontend || this.isMobileAppFrontend; }\n}\n"]}

package/lib/cjs/SortedArray.d.ts

@@ -1,233 +1,237 @@
-/** @packageDocumentation
- * @module Collections
- */
-import { OrderedComparator } from "./Compare";
-/**
- * A function that, given a value of type T, returns a copy of that value. Such functions are used by various collection classes.
- * It is up to the function to decide how deeply or shallowly the value is cloned. For example, [[shallowClone]] simply returns the input.
- * @public
- */
-export declare type CloneFunction<T> = (value: T) => T;
-/**
- * A [[CloneFunction]] that, given a value of type T, returns the same value.
- * Useful as a default argument for functions that can alternatively accept custom logic for cloning values of object type.
- * @param value The value to clone.
- * @returns the input value.
- * @public
- */
-export declare function shallowClone<T>(value: T): T;
-/**
- * Given a sorted array, computes the position at which the specified value should be inserted into the array so that the array remains sorted.
- * @param value The value whose position is to be computed.
- * @param list An array of U already sorted according to the comparison criterion.
- * @param compare The function used to compare the value with elements in `list`.
- * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent element already exists at that index.
- * @public
- */
-export declare function lowerBound<T, U = T>(value: T, list: U[], compare: OrderedComparator<T, U>): {
-    index: number;
-    equal: boolean;
-};
-/** Describes how duplicate values are handled when inserting into a [[SortedArray]].
- * A "duplicate" value is one that compares equal to a value already present in the array, per the array's comparison function.
- * @public
- */
-export declare enum DuplicatePolicy {
-    /** The array allows duplicate values to be inserted. All duplicate values will be adjacent in the array, but the ordering between duplicate values is unspecified.
-     * @note In the presence of duplicate values, functions like [[SortedArray.indexOf]] and [[SortedArray.findEqual]] will return one of the values - exactly which one is unspecified.
-     */
-    Allow = 0,
-    /** Duplicate values are forbidden - when attempting to insert a value equivalent to one already present, the already-present value is retained. */
-    Retain = 1,
-    /** Duplicate values are forbidden - when attempting to insert a value equivalent to one already present, the already-present value is replaced by the new value.
-     * This can be useful when the value type carries additional data that is not evaluated by the comparison function.
-     */
-    Replace = 2
-}
-/**
- * A read-only view of an array of some type T sorted according to some user-supplied criterion.
- * Duplicate elements may be present, though sub-types may enforce uniqueness of elements.
- * In the absence of duplicates, a ReadonlySortedArray<T> can behave like a Set<T> where T is an object and equality is determined
- * by some criterion other than object identity.
- *
- * Because the array is always sorted, querying for the presence of an element is performed using binary
- * search, which is more efficient than a linear search for reasonably large arrays.
- *
- * The comparison function must meet the following criteria, given 'lhs' and 'rhs' of type T:
- *  - If lhs is equal to rhs, returns 0
- *  - If lhs is less than rhs, returns a negative value
- *  - If lhs is greater than rhs, returns a positive value
- *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0
- *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.
- *
- * Note that the array is read-only only from the perspective of its public interface. Mutation methods are defined for internal use by sub-types.
- *
- * @see [[SortedArray]] for a general-purpose mutable sorted array.
- * @public
- */
-export declare class ReadonlySortedArray<T> implements Iterable<T> {
-    protected _array: T[];
-    protected readonly _compare: OrderedComparator<T>;
-    protected readonly _clone: CloneFunction<T>;
-    protected readonly _duplicatePolicy: DuplicatePolicy;
-    /**
-     * Construct a new ReadonlySortedArray<T>.
-     * @param compare The function used to compare elements within the array.
-     * @param duplicatePolicy Policy for handling attempts to insert a value when an equivalent value already exists. If the input is a boolean, then `true` indicates [[DuplicatePolicy.Allow]], and `false` indicates [[DuplicatePolicy.Retain]].
-     * @param clone The function invoked to clone a new element for insertion into the array. The default implementation simply returns its input.
-     */
-    protected constructor(compare: OrderedComparator<T>, duplicatePolicy?: DuplicatePolicy | boolean, clone?: CloneFunction<T>);
-    /** The number of elements in the array */
-    get length(): number;
-    /** Returns true if the array contains no elements. */
-    get isEmpty(): boolean;
-    /** Returns an iterator over the contents of the array in sorted order, suitable for use in `for-of` loops. */
-    [Symbol.iterator](): Iterator<T>;
-    /**
-     * Looks up the index of an element comparing equal to the specified value using binary search.
-     * @param value The value to search for
-     * @returns the index of the first equivalent element found in the array, or -1 if no such element exists.
-     */
-    indexOf(value: T): number;
-    /**
-     * Returns true if this array contains at least one value comparing equal to the specified value.
-     * @param value The value to search for
-     * @returns true if an equivalent element exists in the array.
-     */
-    contains(value: T): boolean;
-    /**
-     * Looks up an element comparing equal to the specified value using binary search.
-     * @param value The value to search for
-     * @returns the first equivalent element found in the array, or undefined if no such element exists.
-     */
-    findEqual(value: T): T | undefined;
-    /** Find an element that compares as equivalent based on some criterion. If multiple elements are equivalent, the specific one returned is unspecified.
-     * As an example, consider a `SortedArray<ModelState>` which uses `ModelState.id` as its ordering criterion. To find a model by its Id,
-     * use `sortedArray.findEquivalent((element) => compareStrings(element.id, modelId))` where `modelId` is an [[Id64String]].
-     * @param criterion A function accepting an element and returning 0 if it compares as equivalent, a negative number if it compares as "less-than", or a positive value if it compares as "greater-than".
-     * @returns The first element found that meets the criterion, or `undefined` if no elements meet the criterion.
-     * @see [[indexOfEquivalent]].
-     * @public
-     */
-    findEquivalent(criterion: (element: T) => number): T | undefined;
-    /** Find the index of an element that compares as equivalent based on some criterion. If multiple elements are equivalent, the specific one returned is unspecified.
-     * As an example, consider a `SortedArray<ModelState>` which uses `ModelState.id` as its ordering criterion. To find the index of a model by its Id,
-     * use `sortedArray.indexOfEquivalent((element) => compareStrings(element.id, modelId))` where `modelId` is an [[Id64String]].
-     * @param criterion A function accepting an element and returning 0 if it compares as equivalent, a negative number if the element compares as "less-than", or a positive value if the element compares as "greater-than".
-     * @returns The index of the first element found that meets the criterion, or -1 if no elements meet the criterion.
-     * @public
-     */
-    indexOfEquivalent(criterion: (element: T) => number): number;
-    /**
-     * Looks up an element by its index in the array.
-     * @param index The array index
-     * @returns the element corresponding to that position in the array, or undefined if the supplied index exceeds the length of the array.
-     */
-    get(index: number): T | undefined;
-    /** Apply a function to each element in the array, in sorted order.
-     * @param func The function to be applied.
-     */
-    forEach(func: (value: T) => void): void;
-    /**
-     * Computes the position at which the specified value should be inserted to maintain sorted order.
-     * @param value The value whose position is to be computed.
-     * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent element already exists at that index.
-     */
-    protected lowerBound(value: T): {
-        index: number;
-        equal: boolean;
-    };
-    /** Clears the contents of the sorted array. */
-    protected _clear(): void;
-    /** Extracts the sorted array as a T[] and empties the contents of this ReadonlySortedArray.
-     * @returns the contents of this ReadonlySortedArray as a T[].
-     */
-    protected _extractArray(): T[];
-    /**
-     * Attempts to insert a new value into the array at a position determined by the ordering.
-     * The behavior differs based on the array's [[DuplicatePolicy]]:
-     * If duplicates are **not** permitted, then:
-     *  - If an equivalent element already exists in the array:
-     *    - [[DuplicatePolicy.Retain]]: nothing will be inserted and the index of the existing element will be returned.
-     *    - [[DuplicatePolicy.Replace]]: the input value will overwrite the existing element at the same index and that index will be returned.
-     *  - Otherwise, the element is inserted and its index is returned.
-     * If duplicates **are** permitted, then:
-     *  - The element will be inserted in a correct position based on the sorting criterion;
-     *  - The position of the element relative to other elements comparing as equal to it is unspecified; and
-     *  - The actual index of the newly-inserted element is returned.
-     * If the element is to be inserted, then the supplied value will be passed to the clone function supplied to the constructor and the result will be inserted into the array.
-     * @param value The value to insert
-     * @param onInsert The optional callback method to call if insertion occurs with the inserted value
-     * @returns the index in the array of the newly-inserted value, or, if duplicates are not permitted and an equivalent value already exists, the index of the equivalent value.
-     */
-    protected _insert(value: T, onInsert?: (value: T) => any): number;
-    /**
-     * Removes the first occurrence of a value comparing equal to the specified value from the array.
-     * @param value The value of the element to delete
-     * @returns the index of the deleted value, or -1 if no such element exists.
-     */
-    protected _remove(value: T): number;
-}
-/**
- * Maintains an array of some type T in sorted order. The ordering is specified by a function supplied
- * by the user.
- * By default, only unique elements are permitted; attempting to insert a new element that compares
- * as equal to an element already in the array will not modify the contents of the array.
- *
- * This allows a SortedArray<T> to behave like a Set<T> where T is an object and equality is determined
- * by some criterion other than object identity.
- *
- * Because the array is always sorted, querying for the presence of an element is performed using binary
- * search, which is more efficient than a linear search for reasonably large arrays.
- *
- * The user can also specify how the SortedArray takes ownership of inserted values, e.g., by cloning them.
- *
- * The comparison function must meet the following criteria, given 'lhs' and 'rhs' of type T:
- *  - If lhs is equal to rhs, returns 0
- *  - If lhs is less than rhs, returns a negative value
- *  - If lhs is greater than rhs, returns a positive value
- *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0
- *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.
- *
- * Modifying an element in a way that affects the comparison function will produce unpredictable results, the
- * most likely of which is that the array will cease to be sorted.
- * @public
- */
-export declare class SortedArray<T> extends ReadonlySortedArray<T> {
-    /**
-     * Construct a new SortedArray<T>.
-     * @param compare The function used to compare elements within the array.
-     * @param duplicatePolicy Policy for handling attempts to insert a value when an equivalent value already exists. If the input is a boolean, then `true` indicates [[DuplicatePolicy.Allow]], and `false` indicates [[DuplicatePolicy.Retain]].
-     * @param clone The function invoked to clone a new element for insertion into the array. The default implementation simply returns its input.
-     */
-    constructor(compare: OrderedComparator<T>, duplicatePolicy?: DuplicatePolicy | boolean, clone?: CloneFunction<T>);
-    /** Clears the contents of the sorted array. */
-    clear(): void;
-    /** Extracts the sorted array as a T[] and empties the contents of this SortedArray.
-     * @returns the contents of this SortedArray as a T[].
-     */
-    extractArray(): T[];
-    /**
-     * Attempts to insert a new value into the array at a position determined by the ordering.
-     * The behavior differs based on whether or not duplicate elements are permitted.
-     * If duplicates are **not** permitted, then:
-     *  - If an equivalent element already exists in the array, nothing will be inserted and the index of the existing element will be returned.
-     *  - Otherwise, the element is inserted and its index is returned.
-     * If duplicates **are** permitted, then:
-     *  - The element will be inserted in a correct position based on the sorting criterion;
-     *  - The position of the element relative to other elements comparing as equal to it is unspecified; and
-     *  - The actual index of the newly-inserted element is returned.
-     * If the element is to be inserted, then the supplied value will be passed to the clone function supplied to the constructor and the result will be inserted into the array.
-     * @param value The value to insert
-     * @param onInsert The optional callback method to call if insertion occurs with the inserted value
-     * @returns the index in the array of the newly-inserted value, or, if duplicates are not permitted and an equivalent value already exists, the index of the equivalent value.
-     */
-    insert(value: T, onInsert?: (value: T) => any): number;
-    /**
-     * Removes the first occurrence of a value comparing equal to the specified value from the array.
-     * @param value The value of the element to delete
-     * @returns the index of the deleted value, or -1 if no such element exists.
-     */
-    remove(value: T): number;
-}
+/** @packageDocumentation
+ * @module Collections
+ */
+import { OrderedComparator } from "./Compare";
+/**
+ * A function that, given a value of type T, returns a copy of that value. Such functions are used by various collection classes.
+ * It is up to the function to decide how deeply or shallowly the value is cloned. For example, [[shallowClone]] simply returns the input.
+ * @public
+ */
+export type CloneFunction<T> = (value: T) => T;
+/**
+ * A [[CloneFunction]] that, given a value of type T, returns the same value.
+ * Useful as a default argument for functions that can alternatively accept custom logic for cloning values of object type.
+ * @param value The value to clone.
+ * @returns the input value.
+ * @public
+ */
+export declare function shallowClone<T>(value: T): T;
+/**
+ * Given a sorted array, computes the position at which the specified value should be inserted into the array so that the array remains sorted.
+ * @param value The value whose position is to be computed.
+ * @param list An array of U already sorted according to the comparison criterion.
+ * @param compare The function used to compare the value with elements in `list`.
+ * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent element already exists at that index.
+ * @public
+ */
+export declare function lowerBound<T, U = T>(value: T, list: U[], compare: OrderedComparator<T, U>): {
+    index: number;
+    equal: boolean;
+};
+/** Describes how duplicate values are handled when inserting into a [[SortedArray]].
+ * A "duplicate" value is one that compares equal to a value already present in the array, per the array's comparison function.
+ * @public
+ */
+export declare enum DuplicatePolicy {
+    /** The array allows duplicate values to be inserted. All duplicate values will be adjacent in the array, but the ordering between duplicate values is unspecified.
+     * @note In the presence of duplicate values, functions like [[SortedArray.indexOf]] and [[SortedArray.findEqual]] will return one of the values - exactly which one is unspecified.
+     */
+    Allow = 0,
+    /** Duplicate values are forbidden - when attempting to insert a value equivalent to one already present, the already-present value is retained. */
+    Retain = 1,
+    /** Duplicate values are forbidden - when attempting to insert a value equivalent to one already present, the already-present value is replaced by the new value.
+     * This can be useful when the value type carries additional data that is not evaluated by the comparison function.
+     */
+    Replace = 2
+}
+/**
+ * A read-only view of an array of some type T sorted according to some user-supplied criterion.
+ * Duplicate elements may be present, though sub-types may enforce uniqueness of elements.
+ * In the absence of duplicates, a ReadonlySortedArray<T> can behave like a Set<T> where T is an object and equality is determined
+ * by some criterion other than object identity.
+ *
+ * Because the array is always sorted, querying for the presence of an element is performed using binary
+ * search, which is more efficient than a linear search for reasonably large arrays.
+ *
+ * The comparison function must meet the following criteria, given 'lhs' and 'rhs' of type T:
+ *  - If lhs is equal to rhs, returns 0
+ *  - If lhs is less than rhs, returns a negative value
+ *  - If lhs is greater than rhs, returns a positive value
+ *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0
+ *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.
+ *
+ * Note that the array is read-only only from the perspective of its public interface. Mutation methods are defined for internal use by sub-types.
+ *
+ * @see [[SortedArray]] for a general-purpose mutable sorted array.
+ * @public
+ */
+export declare class ReadonlySortedArray<T> implements Iterable<T> {
+    protected _array: T[];
+    protected readonly _compare: OrderedComparator<T>;
+    protected readonly _clone: CloneFunction<T>;
+    protected readonly _duplicatePolicy: DuplicatePolicy;
+    /**
+     * Construct a new ReadonlySortedArray<T>.
+     * @param compare The function used to compare elements within the array.
+     * @param duplicatePolicy Policy for handling attempts to insert a value when an equivalent value already exists. If the input is a boolean, then `true` indicates [[DuplicatePolicy.Allow]], and `false` indicates [[DuplicatePolicy.Retain]].
+     * @param clone The function invoked to clone a new element for insertion into the array. The default implementation simply returns its input.
+     */
+    protected constructor(compare: OrderedComparator<T>, duplicatePolicy?: DuplicatePolicy | boolean, clone?: CloneFunction<T>);
+    /** The number of elements in the array */
+    get length(): number;
+    /** Returns true if the array contains no elements. */
+    get isEmpty(): boolean;
+    /** Returns an iterator over the contents of the array in sorted order, suitable for use in `for-of` loops. */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Looks up the index of an element comparing equal to the specified value using binary search.
+     * @param value The value to search for
+     * @returns the index of the first equivalent element found in the array, or -1 if no such element exists.
+     */
+    indexOf(value: T): number;
+    /**
+     * Returns true if this array contains at least one value comparing equal to the specified value.
+     * @param value The value to search for
+     * @returns true if an equivalent element exists in the array.
+     */
+    contains(value: T): boolean;
+    /**
+     * Looks up an element comparing equal to the specified value using binary search.
+     * @param value The value to search for
+     * @returns the first equivalent element found in the array, or undefined if no such element exists.
+     */
+    findEqual(value: T): T | undefined;
+    /** Find an element that compares as equivalent based on some criterion. If multiple elements are equivalent, the specific one returned is unspecified.
+     * As an example, consider a `SortedArray<ModelState>` which uses `ModelState.id` as its ordering criterion. To find a model by its Id,
+     * use `sortedArray.findEquivalent((element) => compareStrings(element.id, modelId))` where `modelId` is an [[Id64String]].
+     * @param criterion A function accepting an element and returning 0 if it compares as equivalent, a negative number if it compares as "less-than", or a positive value if it compares as "greater-than".
+     * @returns The first element found that meets the criterion, or `undefined` if no elements meet the criterion.
+     * @see [[indexOfEquivalent]].
+     * @public
+     */
+    findEquivalent(criterion: (element: T) => number): T | undefined;
+    /** Find the index of an element that compares as equivalent based on some criterion. If multiple elements are equivalent, the specific one returned is unspecified.
+     * As an example, consider a `SortedArray<ModelState>` which uses `ModelState.id` as its ordering criterion. To find the index of a model by its Id,
+     * use `sortedArray.indexOfEquivalent((element) => compareStrings(element.id, modelId))` where `modelId` is an [[Id64String]].
+     * @param criterion A function accepting an element and returning 0 if it compares as equivalent, a negative number if the element compares as "less-than", or a positive value if the element compares as "greater-than".
+     * @returns The index of the first element found that meets the criterion, or -1 if no elements meet the criterion.
+     * @public
+     */
+    indexOfEquivalent(criterion: (element: T) => number): number;
+    /**
+     * Looks up an element by its index in the array.
+     * @param index The array index
+     * @returns the element corresponding to that position in the array, or undefined if the supplied index exceeds the length of the array.
+     */
+    get(index: number): T | undefined;
+    /** Apply a function to each element in the array, in sorted order.
+     * @param func The function to be applied.
+     */
+    forEach(func: (value: T) => void): void;
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start?: number, end?: number): ReadonlySortedArray<T>;
+    /**
+     * Computes the position at which the specified value should be inserted to maintain sorted order.
+     * @param value The value whose position is to be computed.
+     * @returns an object with 'index' corresponding to the computed position and 'equal' set to true if an equivalent element already exists at that index.
+     */
+    protected lowerBound(value: T): {
+        index: number;
+        equal: boolean;
+    };
+    /** Clears the contents of the sorted array. */
+    protected _clear(): void;
+    /** Extracts the sorted array as a T[] and empties the contents of this ReadonlySortedArray.
+     * @returns the contents of this ReadonlySortedArray as a T[].
+     */
+    protected _extractArray(): T[];
+    /**
+     * Attempts to insert a new value into the array at a position determined by the ordering.
+     * The behavior differs based on the array's [[DuplicatePolicy]]:
+     * If duplicates are **not** permitted, then:
+     *  - If an equivalent element already exists in the array:
+     *    - [[DuplicatePolicy.Retain]]: nothing will be inserted and the index of the existing element will be returned.
+     *    - [[DuplicatePolicy.Replace]]: the input value will overwrite the existing element at the same index and that index will be returned.
+     *  - Otherwise, the element is inserted and its index is returned.
+     * If duplicates **are** permitted, then:
+     *  - The element will be inserted in a correct position based on the sorting criterion;
+     *  - The position of the element relative to other elements comparing as equal to it is unspecified; and
+     *  - The actual index of the newly-inserted element is returned.
+     * If the element is to be inserted, then the supplied value will be passed to the clone function supplied to the constructor and the result will be inserted into the array.
+     * @param value The value to insert
+     * @param onInsert The optional callback method to call if insertion occurs with the inserted value
+     * @returns the index in the array of the newly-inserted value, or, if duplicates are not permitted and an equivalent value already exists, the index of the equivalent value.
+     */
+    protected _insert(value: T, onInsert?: (value: T) => any): number;
+    /**
+     * Removes the first occurrence of a value comparing equal to the specified value from the array.
+     * @param value The value of the element to delete
+     * @returns the index of the deleted value, or -1 if no such element exists.
+     */
+    protected _remove(value: T): number;
+}
+/**
+ * Maintains an array of some type T in sorted order. The ordering is specified by a function supplied
+ * by the user.
+ * By default, only unique elements are permitted; attempting to insert a new element that compares
+ * as equal to an element already in the array will not modify the contents of the array.
+ *
+ * This allows a SortedArray<T> to behave like a Set<T> where T is an object and equality is determined
+ * by some criterion other than object identity.
+ *
+ * Because the array is always sorted, querying for the presence of an element is performed using binary
+ * search, which is more efficient than a linear search for reasonably large arrays.
+ *
+ * The user can also specify how the SortedArray takes ownership of inserted values, e.g., by cloning them.
+ *
+ * The comparison function must meet the following criteria, given 'lhs' and 'rhs' of type T:
+ *  - If lhs is equal to rhs, returns 0
+ *  - If lhs is less than rhs, returns a negative value
+ *  - If lhs is greater than rhs, returns a positive value
+ *  - If compare(lhs, rhs) returns 0, then compare(rhs, lhs) must also return 0
+ *  - If compare(lhs, rhs) returns a negative value, then compare(rhs, lhs) must return a positive value, and vice versa.
+ *
+ * Modifying an element in a way that affects the comparison function will produce unpredictable results, the
+ * most likely of which is that the array will cease to be sorted.
+ * @public
+ */
+export declare class SortedArray<T> extends ReadonlySortedArray<T> {
+    /**
+     * Construct a new SortedArray<T>.
+     * @param compare The function used to compare elements within the array.
+     * @param duplicatePolicy Policy for handling attempts to insert a value when an equivalent value already exists. If the input is a boolean, then `true` indicates [[DuplicatePolicy.Allow]], and `false` indicates [[DuplicatePolicy.Retain]].
+     * @param clone The function invoked to clone a new element for insertion into the array. The default implementation simply returns its input.
+     */
+    constructor(compare: OrderedComparator<T>, duplicatePolicy?: DuplicatePolicy | boolean, clone?: CloneFunction<T>);
+    /** Clears the contents of the sorted array. */
+    clear(): void;
+    /** Extracts the sorted array as a T[] and empties the contents of this SortedArray.
+     * @returns the contents of this SortedArray as a T[].
+     */
+    extractArray(): T[];
+    /**
+     * Attempts to insert a new value into the array at a position determined by the ordering.
+     * The behavior differs based on whether or not duplicate elements are permitted.
+     * If duplicates are **not** permitted, then:
+     *  - If an equivalent element already exists in the array, nothing will be inserted and the index of the existing element will be returned.
+     *  - Otherwise, the element is inserted and its index is returned.
+     * If duplicates **are** permitted, then:
+     *  - The element will be inserted in a correct position based on the sorting criterion;
+     *  - The position of the element relative to other elements comparing as equal to it is unspecified; and
+     *  - The actual index of the newly-inserted element is returned.
+     * If the element is to be inserted, then the supplied value will be passed to the clone function supplied to the constructor and the result will be inserted into the array.
+     * @param value The value to insert
+     * @param onInsert The optional callback method to call if insertion occurs with the inserted value
+     * @returns the index in the array of the newly-inserted value, or, if duplicates are not permitted and an equivalent value already exists, the index of the equivalent value.
+     */
+    insert(value: T, onInsert?: (value: T) => any): number;
+    /**
+     * Removes the first occurrence of a value comparing equal to the specified value from the array.
+     * @param value The value of the element to delete
+     * @returns the index of the deleted value, or -1 if no such element exists.
+     */
+    remove(value: T): number;
+    /** The equivalent of [Array.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice). */
+    slice(start?: number, end?: number): SortedArray<T>;
+}
 //# sourceMappingURL=SortedArray.d.ts.map

package/lib/cjs/SortedArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SortedArray.d.ts","sourceRoot":"","sources":["../../src/SortedArray.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"SortedArray.d.ts","sourceRoot":"","sources":["../../src/SortedArray.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAEvC;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAE7H;AAmBD;;;GAGG;AACH,oBAAY,eAAe;IACzB;;OAEG;IACH,KAAK,IAAA;IACL,mJAAmJ;IACnJ,MAAM,IAAA;IACN;;OAEG;IACH,OAAO,IAAA;CACR;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAmB,CAAC,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,CAAC;IACxD,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,CAAM;IAC3B,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAClD,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAC5C,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,eAAe,CAAC;IAErD;;;;;OAKG;IACH,SAAS,aAAa,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,eAAe,GAAE,eAAe,GAAG,OAAe,EAAE,KAAK,GAAE,aAAa,CAAC,CAAC,CAAgB;IAS/I,0CAA0C;IAC1C,IAAW,MAAM,IAAI,MAAM,CAA+B;IAE1D,sDAAsD;IACtD,IAAW,OAAO,IAAI,OAAO,CAA8B;IAE3D,8GAA8G;IACvG,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;IAEvC;;;;OAIG;IACI,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM;IAKhC;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAIlC;;;;OAIG;IACI,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAKzC;;;;;;;OAOG;IACI,cAAc,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC,GAAG,SAAS;IAKvE;;;;;;OAMG;IACI,iBAAiB,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM;IAMnE;;;;OAIG;IACI,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAExC;;OAEG;IACI,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI;IAK9C,qIAAqI;IAC9H,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAAC,CAAC,CAAC;IAMlE;;;;OAIG;IACH,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE;IAEjE,+CAA+C;IAC/C,SAAS,CAAC,MAAM,IAAI,IAAI;IAExB;;OAEG;IACH,SAAS,CAAC,aAAa,IAAI,CAAC,EAAE;IAM9B;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,GAAG,GAAG,MAAM;IAuBjE;;;;OAIG;IACH,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM;CASpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,mBAAmB,CAAC,CAAC,CAAC;IACxD;;;;;OAKG;gBACgB,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,eAAe,GAAE,eAAe,GAAG,OAAe,EAAE,KAAK,GAAE,aAAa,CAAC,CAAC,CAAgB;IAI5I,+CAA+C;IACxC,KAAK,IAAI,IAAI;IAEpB;;OAEG;IACI,YAAY,IAAI,CAAC,EAAE;IAE1B;;;;;;;;;;;;;;OAcG;IACI,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,GAAG,GAAG,MAAM;IAE7D;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM;IAE/B,qIAAqI;IACrH,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;CAKpE"}