@itwin/core-bentley 3.5.0-dev.8 → 3.5.1

package/lib/esm/TypedArrayBuilder.d.ts

@@ -1,98 +1,156 @@
-/** @packageDocumentation
- * @module Collections
- */
-import { Constructor } from "./UtilityTypes";
-/** Options used to construct a [[TypedArrayBuilder]].
- * @public
- */
-export interface TypedArrayBuilderOptions {
-    /** Controls how much additional memory is allocated when the TypedArray needs to be resized to accomodate more elements.
-     * [[TypedArrayBuilder.ensureCapacity]] multiplies the required capacity by this factor to determine the new capacity.
-     * Default: 1.5
-     * Minimum: 1.0, which causes the TypedArray to allocate exactly the space it needs each time it is resized.
-     */
-    growthFactor?: number;
-    /** The number of elements to allocate memory for in the TypedArray when creating the builder.
-     * If you know the minimum number of elements you intend to add to the builder, you should specify that as the
-     * initial capacity to avoid reallocations when populating the array.
-     * Default: 0.
-     * Minimum: 0.
-     */
-    initialCapacity?: number;
-}
-/** Incrementally builds a [TypedArray] of unsigned 8-, 16-, or 32-bit integers.
- * Sometimes you wish to populate a `TypedArray`, but you don't know how many elements you will need.
- * `TypedArray` requires you to specify the size upon construction, and does not permit you to change the size later.
- *
- * `TypedArrayBuilder` manages a `TypedArray`, permitting you to [[push]] and [[append]] elements to it. It exposes two "size" properties":
- *  - [[capacity]], the number of elements it has currently allocated space for - i.e., the length of the underlying TypedArray; and
- *  - [[length]], the number of elements that have so far been added to it, which is never bigger than [[capacity]].
- * When [[capacity]] is exceeded, a new, bigger TypedArray is allocated and the contents of the previous array are copied over to it.
- *
- * Once you've finished adding elements, you can obtain the finished `TypedArray` via [[toTypedArray]].
- * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], and [[Uint32ArrayBuilder]] to build specific types of arrays.
- * @public
- */
-export declare class TypedArrayBuilder<T extends Uint8Array | Uint16Array | Uint32Array> {
-    /** The constructor for the specific type of array being populated. */
-    protected readonly _constructor: Constructor<T>;
-    /** The underlying typed array, to be reallocated and copied when its capacity is exceeded. */
-    protected _data: T;
-    /** The number of elements added to the array so far. */
-    protected _length: number;
-    /** Multiplier applied to required capacity by [[ensureCapacity]]. */
-    readonly growthFactor: number;
-    /** Constructs a new builder from the specified options, with a [[length]] of zero. */
-    protected constructor(constructor: Constructor<T>, options?: TypedArrayBuilderOptions);
-    /** The number of elements currently in the array. */
-    get length(): number;
-    /** The number of elements that can fit into the memory currently allocated for the array. */
-    get capacity(): number;
-    /** Like [TypedArray.at](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at),
-     * returns the element at the specified index, with negative integers counting back from the end of the array.
-     * @note It is your responsibility to ensure the index falls within the bounds of the array.
-     */
-    at(index: number): number;
-    /** Ensure that [[capacity]] is at least equal to `newCapacity`.
-     * This is used internally by methods like [[push]] and [[append]] to ensure the array has room for the element(s) to be added.
-     * It can also be useful when you know you intend to add some number of additional elements, to minimize reallocations.
-     *
-     * If `newCapacity` is not greater than the current [[capacity]], this function does nothing.
-     * Otherwise, it allocates a new `TypedArray` with room for `newCapacity * growthFactor` elements, and copies the contents of the previous `TypedArray` into it.
-     * [[length]] remains unchanged; [[capacity]] reflects the size of the new TypeArray.
-     */
-    ensureCapacity(newCapacity: number): number;
-    /** Append the specified value, resizing if necessary. */
-    push(value: number): void;
-    /** Append an array of values, resizing (at most once) if necessary. */
-    append(values: T): void;
-    /** Obtain the finished array.
-     * @param includeUnusedCapacity If true, the length of the returned array will be equal to [[capacity]], with extra bytes initialized to zero; otherwise, the
-     * returned array's length will be equal to [[length]].
-     */
-    toTypedArray(includeUnusedCapacity?: boolean): T;
-}
-/** A [[TypedArrayBuilder]] for producing a [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
- * @public
- */
-export declare class Uint8ArrayBuilder extends TypedArrayBuilder<Uint8Array> {
-    /** @see [[TypedArrayBuilder]] constructor. */
-    constructor(options?: TypedArrayBuilderOptions);
-}
-/** A [[TypedArrayBuilder]] for producing a [Uint16Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array).
- * @public
- */
-export declare class Uint16ArrayBuilder extends TypedArrayBuilder<Uint16Array> {
-    /** @see [[TypedArrayBuilder]] constructor. */
-    constructor(options?: TypedArrayBuilderOptions);
-}
-/** A [[TypedArrayBuilder]] for producing a [Uint32Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array).
- * @public
- */
-export declare class Uint32ArrayBuilder extends TypedArrayBuilder<Uint32Array> {
-    /** @see [[TypedArrayBuilder]] constructor. */
-    constructor(options?: TypedArrayBuilderOptions);
-    /** Obtain a view of the finished array as an array of bytes. */
-    toUint8Array(includeUnusedCapacity?: boolean): Uint8Array;
-}
+/** @packageDocumentation
+ * @module Collections
+ */
+import { Constructor } from "./UtilityTypes";
+/** Options used to construct a [[TypedArrayBuilder]].
+ * @public
+ */
+export interface TypedArrayBuilderOptions {
+    /** Controls how much additional memory is allocated when the TypedArray needs to be resized to accomodate more elements.
+     * [[TypedArrayBuilder.ensureCapacity]] multiplies the required capacity by this factor to determine the new capacity.
+     * Default: 1.5
+     * Minimum: 1.0, which causes the TypedArray to allocate exactly the space it needs each time it is resized.
+     */
+    growthFactor?: number;
+    /** The number of elements to allocate memory for in the TypedArray when creating the builder.
+     * If you know the minimum number of elements you intend to add to the builder, you should specify that as the
+     * initial capacity to avoid reallocations when populating the array.
+     * Default: 0.
+     * Minimum: 0.
+     */
+    initialCapacity?: number;
+}
+/** A [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) containing unsigned 8-, 16-, or 32-bit integers.
+ * @see [[UintArrayBuilder]] to construct such an array.
+ * @public
+ */
+export declare type UintArray = Uint8Array | Uint16Array | Uint32Array;
+/** Incrementally builds a [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) of unsigned 8-, 16-, or 32-bit integers.
+ * Sometimes you wish to populate a `TypedArray`, but you don't know how many elements you will need.
+ * `TypedArray` requires you to specify the size upon construction, and does not permit you to change the size later.
+ *
+ * `TypedArrayBuilder` manages a `TypedArray`, permitting you to [[push]] and [[append]] elements to it. It exposes two "size" properties":
+ *  - [[capacity]], the number of elements it has currently allocated space for - i.e., the length of the underlying TypedArray; and
+ *  - [[length]], the number of elements that have so far been added to it, which is never bigger than [[capacity]].
+ * When [[capacity]] is exceeded, a new, bigger TypedArray is allocated and the contents of the previous array are copied over to it.
+ *
+ * Once you've finished adding elements, you can obtain the finished `TypedArray` via [[toTypedArray]].
+ * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], and [[Uint32ArrayBuilder]] to build specific types of arrays.
+ * @see [[UintArrayBuilder]] when you don't know the maximum number of bytes required for each element in the array.
+ * @public
+ */
+export declare class TypedArrayBuilder<T extends UintArray> {
+    /** The constructor for the specific type of array being populated. */
+    protected _constructor: Constructor<T>;
+    /** The underlying typed array, to be reallocated and copied when its capacity is exceeded. */
+    protected _data: T;
+    /** The number of elements added to the array so far. */
+    protected _length: number;
+    /** Multiplier applied to required capacity by [[ensureCapacity]]. */
+    readonly growthFactor: number;
+    /** Constructs a new builder from the specified options, with a [[length]] of zero. */
+    protected constructor(constructor: Constructor<T>, options?: TypedArrayBuilderOptions);
+    /** The number of elements currently in the array. */
+    get length(): number;
+    /** The number of elements that can fit into the memory currently allocated for the array. */
+    get capacity(): number;
+    /** Like [TypedArray.at](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at),
+     * returns the element at the specified index, with negative integers counting back from the end of the array.
+     * @note It is your responsibility to ensure the index falls within the bounds of the array.
+     */
+    at(index: number): number;
+    /** Ensure that [[capacity]] is at least equal to `newCapacity`.
+     * This is used internally by methods like [[push]] and [[append]] to ensure the array has room for the element(s) to be added.
+     * It can also be useful when you know you intend to add some number of additional elements, to minimize reallocations.
+     *
+     * If `newCapacity` is not greater than the current [[capacity]], this function does nothing.
+     * Otherwise, it allocates a new `TypedArray` with room for `newCapacity * growthFactor` elements, and copies the contents of the previous `TypedArray` into it.
+     * [[length]] remains unchanged; [[capacity]] reflects the size of the new TypeArray.
+     */
+    ensureCapacity(newCapacity: number): number;
+    /** Append the specified value, resizing if necessary. */
+    push(value: number): void;
+    /** Append an array of values, resizing (at most once) if necessary. */
+    append(values: T): void;
+    /** Obtain the finished array.
+     * @param includeUnusedCapacity If true, the length of the returned array will be equal to [[capacity]], with extra bytes initialized to zero; otherwise, the
+     * returned array's length will be equal to [[length]].
+     */
+    toTypedArray(includeUnusedCapacity?: boolean): T;
+}
+/** A [[TypedArrayBuilder]] for producing a [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
+ * @public
+ */
+export declare class Uint8ArrayBuilder extends TypedArrayBuilder<Uint8Array> {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options?: TypedArrayBuilderOptions);
+}
+/** A [[TypedArrayBuilder]] for producing a [Uint16Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array).
+ * @public
+ */
+export declare class Uint16ArrayBuilder extends TypedArrayBuilder<Uint16Array> {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options?: TypedArrayBuilderOptions);
+}
+/** A [[TypedArrayBuilder]] for producing a [Uint32Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array).
+ * @public
+ */
+export declare class Uint32ArrayBuilder extends TypedArrayBuilder<Uint32Array> {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options?: TypedArrayBuilderOptions);
+    /** Obtain a view of the finished array as an array of bytes. */
+    toUint8Array(includeUnusedCapacity?: boolean): Uint8Array;
+}
+/** Options used to construct a [[UintArrayBuilder]].
+ * @public
+ */
+export interface UintArrayBuilderOptions extends TypedArrayBuilderOptions {
+    /** The type of the initial empty `TypedArray` created by the builder. For example, if you know that you will be adding values larger than
+     * 255 to the array, specify `{ initialType: Uint16Array }` to avoid replacing the otherwise default `Uint8Array` when the first such value is added.
+     * Default: `Uint8Array`.
+     */
+    initialType?: typeof Uint8Array | typeof Uint16Array | typeof Uint32Array;
+}
+/** A [[TypedArrayBuilder]] that can populate a [[UintArray]] with the minimum
+ * [bytes per element](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT) required.
+ *
+ * By default, the underlying array is a `Uint8Array`, though this can be configured via [[UintArrayBuilderOptions.initialType]].
+ * As values are added to the array, if the bytes per element supported by the underlying array is too small to hold one of the new values, the array is
+ * reallocated to a type large enough to hold all of the new values. For example, the following produces a `Uint8Array` because all values are less than 256:
+ *
+ * ```ts
+ *  const builder = new UintArrayBuilder();
+ *  builder.append([1, 2, 254, 255]);
+ *  const array = builder.toTypedArray();
+ *  assert(array instanceof Uint8Array);
+ * ```
+ *
+ * However, the following produces a `Uint16Array` because one of the values is larger than 255 but none are larger than 65,535:
+ *
+ * ```ts
+ *  const builder = new UintArrayBuilder();
+ *  builder.append([1, 255, 257, 65535]);
+ *  const array = builder.toTypedArray();
+ *  assert(array instanceof Uint16Array);
+ * ```
+ *
+ * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], or [[Uint32ArrayBuilder]] if you know the number of bytes you want to allocate for each element in the array.
+ * @public
+ */
+export declare class UintArrayBuilder extends TypedArrayBuilder<UintArray> {
+    constructor(options?: UintArrayBuilderOptions);
+    /** The number of bytes (1, 2, or 4) currently allocated per element by the underlying array.
+     * This may change as larger values are added to the array.
+     */
+    get bytesPerElement(): number;
+    /** Ensures that the underlying array is of a type that can contain the largest value in `newValues`.
+     * For example, if `_data` is a `Uint16Array` and `newValues` contains any value(s) larger than 65,535, it will be replaced with a `Uint32Array`.
+     * This method is invoked by [[push]] and [[append]].
+     */
+    protected ensureBytesPerElement(newValues: Iterable<number>): void;
+    /** See [[TypedArrayBuilder.push]]. */
+    push(value: number): void;
+    /** See [[TypedArrayBuilder.append]]. */
+    append(values: UintArray): void;
+}
 //# sourceMappingURL=TypedArrayBuilder.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TypedArrayBuilder.d.ts","sourceRoot":"","sources":["../../src/TypedArrayBuilder.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB,CAAC,CAAC,SAAS,UAAU,GAAG,WAAW,GAAG,WAAW;IAC7E,sEAAsE;IACtE,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAChD,8FAA8F;IAC9F,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;IACnB,wDAAwD;IACxD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,SAAgB,YAAY,EAAE,MAAM,CAAC;IAErC,sFAAsF;IACtF,SAAS,aAAa,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,wBAAwB;IAOrF,qDAAqD;IACrD,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,6FAA6F;IAC7F,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;OAGG;IACI,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAShC;;;;;;;OAOG;IACI,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAclD,yDAAyD;IAClD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMhC,uEAAuE;IAChE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI;IAO9B;;;OAGG;IACI,YAAY,CAAC,qBAAqB,UAAQ,GAAG,CAAC;CAStD;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB,CAAC,UAAU,CAAC;IAClE,8CAA8C;gBAC3B,OAAO,CAAC,EAAE,wBAAwB;CAGtD;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACpE,8CAA8C;gBAC3B,OAAO,CAAC,EAAE,wBAAwB;CAGtD;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACpE,8CAA8C;gBAC3B,OAAO,CAAC,EAAE,wBAAwB;IAIrD,gEAAgE;IACzD,YAAY,CAAC,qBAAqB,UAAQ,GAAG,UAAU;CAM/D"}
+{"version":3,"file":"TypedArrayBuilder.d.ts","sourceRoot":"","sources":["../../src/TypedArrayBuilder.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG7C;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,oBAAY,SAAS,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,CAAC;AAE/D;;;;;;;;;;;;;GAaG;AACH,qBAAa,iBAAiB,CAAC,CAAC,SAAS,SAAS;IAChD,sEAAsE;IACtE,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACvC,8FAA8F;IAC9F,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;IACnB,wDAAwD;IACxD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,SAAgB,YAAY,EAAE,MAAM,CAAC;IAErC,sFAAsF;IACtF,SAAS,aAAa,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,wBAAwB;IAOrF,qDAAqD;IACrD,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,6FAA6F;IAC7F,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;OAGG;IACI,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAShC;;;;;;;OAOG;IACI,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAclD,yDAAyD;IAClD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAMhC,uEAAuE;IAChE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI;IAO9B;;;OAGG;IACI,YAAY,CAAC,qBAAqB,UAAQ,GAAG,CAAC;CAStD;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB,CAAC,UAAU,CAAC;IAClE,6CAA6C;gBAC1B,OAAO,CAAC,EAAE,wBAAwB;CAGtD;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACpE,6CAA6C;gBAC1B,OAAO,CAAC,EAAE,wBAAwB;CAGtD;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,iBAAiB,CAAC,WAAW,CAAC;IACpE,6CAA6C;gBAC1B,OAAO,CAAC,EAAE,wBAAwB;IAIrD,gEAAgE;IACzD,YAAY,CAAC,qBAAqB,UAAQ,GAAG,UAAU;CAM/D;AAED;;GAEG;AACH,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,UAAU,GAAG,OAAO,WAAW,GAAG,OAAO,WAAW,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,gBAAiB,SAAQ,iBAAiB,CAAC,SAAS,CAAC;gBAC7C,OAAO,CAAC,EAAE,uBAAuB;IAIpD;;OAEG;IACH,IAAW,eAAe,IAAI,MAAM,CAEnC;IAED;;;OAGG;IACH,SAAS,CAAC,qBAAqB,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI;IAuBlE,sCAAsC;IACtB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKzC,wCAAwC;IACxB,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;CAIhD"}

package/lib/esm/TypedArrayBuilder.js

@@ -1,128 +1,201 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Collections
- */
-import { assert } from "./Assert";
-/** Incrementally builds a [TypedArray] of unsigned 8-, 16-, or 32-bit integers.
- * Sometimes you wish to populate a `TypedArray`, but you don't know how many elements you will need.
- * `TypedArray` requires you to specify the size upon construction, and does not permit you to change the size later.
- *
- * `TypedArrayBuilder` manages a `TypedArray`, permitting you to [[push]] and [[append]] elements to it. It exposes two "size" properties":
- *  - [[capacity]], the number of elements it has currently allocated space for - i.e., the length of the underlying TypedArray; and
- *  - [[length]], the number of elements that have so far been added to it, which is never bigger than [[capacity]].
- * When [[capacity]] is exceeded, a new, bigger TypedArray is allocated and the contents of the previous array are copied over to it.
- *
- * Once you've finished adding elements, you can obtain the finished `TypedArray` via [[toTypedArray]].
- * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], and [[Uint32ArrayBuilder]] to build specific types of arrays.
- * @public
- */
-export class TypedArrayBuilder {
-    /** Constructs a new builder from the specified options, with a [[length]] of zero. */
-    constructor(constructor, options) {
-        var _a, _b;
-        this._constructor = constructor;
-        this._data = new constructor((_a = options === null || options === void 0 ? void 0 : options.initialCapacity) !== null && _a !== void 0 ? _a : 0);
-        this.growthFactor = Math.max(1.0, (_b = options === null || options === void 0 ? void 0 : options.growthFactor) !== null && _b !== void 0 ? _b : 1.5);
-        this._length = 0;
-    }
-    /** The number of elements currently in the array. */
-    get length() {
-        return this._length;
-    }
-    /** The number of elements that can fit into the memory currently allocated for the array. */
-    get capacity() {
-        return this._data.length;
-    }
-    /** Like [TypedArray.at](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at),
-     * returns the element at the specified index, with negative integers counting back from the end of the array.
-     * @note It is your responsibility to ensure the index falls within the bounds of the array.
-     */
-    at(index) {
-        if (index < 0)
-            index = this.length - index;
-        const value = this._data[index];
-        assert(value !== undefined, "index out of bounds");
-        return value;
-    }
-    /** Ensure that [[capacity]] is at least equal to `newCapacity`.
-     * This is used internally by methods like [[push]] and [[append]] to ensure the array has room for the element(s) to be added.
-     * It can also be useful when you know you intend to add some number of additional elements, to minimize reallocations.
-     *
-     * If `newCapacity` is not greater than the current [[capacity]], this function does nothing.
-     * Otherwise, it allocates a new `TypedArray` with room for `newCapacity * growthFactor` elements, and copies the contents of the previous `TypedArray` into it.
-     * [[length]] remains unchanged; [[capacity]] reflects the size of the new TypeArray.
-     */
-    ensureCapacity(newCapacity) {
-        if (this.capacity >= newCapacity)
-            return this.capacity;
-        assert(this.growthFactor >= 1.0);
-        newCapacity = Math.ceil(newCapacity * this.growthFactor);
-        const prevData = this._data;
-        this._data = new this._constructor(newCapacity);
-        this._data.set(prevData, 0);
-        assert(this.capacity === newCapacity);
-        return this.capacity;
-    }
-    /** Append the specified value, resizing if necessary. */
-    push(value) {
-        this.ensureCapacity(this.length + 1);
-        this._data[this.length] = value;
-        ++this._length;
-    }
-    /** Append an array of values, resizing (at most once) if necessary. */
-    append(values) {
-        const newLength = this.length + values.length;
-        this.ensureCapacity(newLength);
-        this._data.set(values, this.length);
-        this._length = newLength;
-    }
-    /** Obtain the finished array.
-     * @param includeUnusedCapacity If true, the length of the returned array will be equal to [[capacity]], with extra bytes initialized to zero; otherwise, the
-     * returned array's length will be equal to [[length]].
-     */
-    toTypedArray(includeUnusedCapacity = false) {
-        if (includeUnusedCapacity)
-            return this._data;
-        const subarray = this._data.subarray(0, this.length);
-        assert(subarray instanceof this._constructor);
-        assert(subarray.buffer === this._data.buffer);
-        return subarray;
-    }
-}
-/** A [[TypedArrayBuilder]] for producing a [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
- * @public
- */
-export class Uint8ArrayBuilder extends TypedArrayBuilder {
-    /** @see [[TypedArrayBuilder]] constructor. */
-    constructor(options) {
-        super(Uint8Array, options);
-    }
-}
-/** A [[TypedArrayBuilder]] for producing a [Uint16Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array).
- * @public
- */
-export class Uint16ArrayBuilder extends TypedArrayBuilder {
-    /** @see [[TypedArrayBuilder]] constructor. */
-    constructor(options) {
-        super(Uint16Array, options);
-    }
-}
-/** A [[TypedArrayBuilder]] for producing a [Uint32Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array).
- * @public
- */
-export class Uint32ArrayBuilder extends TypedArrayBuilder {
-    /** @see [[TypedArrayBuilder]] constructor. */
-    constructor(options) {
-        super(Uint32Array, options);
-    }
-    /** Obtain a view of the finished array as an array of bytes. */
-    toUint8Array(includeUnusedCapacity = false) {
-        if (includeUnusedCapacity)
-            return new Uint8Array(this._data.buffer);
-        return new Uint8Array(this._data.buffer, 0, this.length * 4);
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Collections
+ */
+import { assert } from "./Assert";
+/** Incrementally builds a [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) of unsigned 8-, 16-, or 32-bit integers.
+ * Sometimes you wish to populate a `TypedArray`, but you don't know how many elements you will need.
+ * `TypedArray` requires you to specify the size upon construction, and does not permit you to change the size later.
+ *
+ * `TypedArrayBuilder` manages a `TypedArray`, permitting you to [[push]] and [[append]] elements to it. It exposes two "size" properties":
+ *  - [[capacity]], the number of elements it has currently allocated space for - i.e., the length of the underlying TypedArray; and
+ *  - [[length]], the number of elements that have so far been added to it, which is never bigger than [[capacity]].
+ * When [[capacity]] is exceeded, a new, bigger TypedArray is allocated and the contents of the previous array are copied over to it.
+ *
+ * Once you've finished adding elements, you can obtain the finished `TypedArray` via [[toTypedArray]].
+ * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], and [[Uint32ArrayBuilder]] to build specific types of arrays.
+ * @see [[UintArrayBuilder]] when you don't know the maximum number of bytes required for each element in the array.
+ * @public
+ */
+export class TypedArrayBuilder {
+    /** Constructs a new builder from the specified options, with a [[length]] of zero. */
+    constructor(constructor, options) {
+        var _a, _b;
+        this._constructor = constructor;
+        this._data = new constructor((_a = options === null || options === void 0 ? void 0 : options.initialCapacity) !== null && _a !== void 0 ? _a : 0);
+        this.growthFactor = Math.max(1.0, (_b = options === null || options === void 0 ? void 0 : options.growthFactor) !== null && _b !== void 0 ? _b : 1.5);
+        this._length = 0;
+    }
+    /** The number of elements currently in the array. */
+    get length() {
+        return this._length;
+    }
+    /** The number of elements that can fit into the memory currently allocated for the array. */
+    get capacity() {
+        return this._data.length;
+    }
+    /** Like [TypedArray.at](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/at),
+     * returns the element at the specified index, with negative integers counting back from the end of the array.
+     * @note It is your responsibility to ensure the index falls within the bounds of the array.
+     */
+    at(index) {
+        if (index < 0)
+            index = this.length - index;
+        const value = this._data[index];
+        assert(value !== undefined, "index out of bounds");
+        return value;
+    }
+    /** Ensure that [[capacity]] is at least equal to `newCapacity`.
+     * This is used internally by methods like [[push]] and [[append]] to ensure the array has room for the element(s) to be added.
+     * It can also be useful when you know you intend to add some number of additional elements, to minimize reallocations.
+     *
+     * If `newCapacity` is not greater than the current [[capacity]], this function does nothing.
+     * Otherwise, it allocates a new `TypedArray` with room for `newCapacity * growthFactor` elements, and copies the contents of the previous `TypedArray` into it.
+     * [[length]] remains unchanged; [[capacity]] reflects the size of the new TypeArray.
+     */
+    ensureCapacity(newCapacity) {
+        if (this.capacity >= newCapacity)
+            return this.capacity;
+        assert(this.growthFactor >= 1.0);
+        newCapacity = Math.ceil(newCapacity * this.growthFactor);
+        const prevData = this._data;
+        this._data = new this._constructor(newCapacity);
+        this._data.set(prevData, 0);
+        assert(this.capacity === newCapacity);
+        return this.capacity;
+    }
+    /** Append the specified value, resizing if necessary. */
+    push(value) {
+        this.ensureCapacity(this.length + 1);
+        this._data[this.length] = value;
+        ++this._length;
+    }
+    /** Append an array of values, resizing (at most once) if necessary. */
+    append(values) {
+        const newLength = this.length + values.length;
+        this.ensureCapacity(newLength);
+        this._data.set(values, this.length);
+        this._length = newLength;
+    }
+    /** Obtain the finished array.
+     * @param includeUnusedCapacity If true, the length of the returned array will be equal to [[capacity]], with extra bytes initialized to zero; otherwise, the
+     * returned array's length will be equal to [[length]].
+     */
+    toTypedArray(includeUnusedCapacity = false) {
+        if (includeUnusedCapacity)
+            return this._data;
+        const subarray = this._data.subarray(0, this.length);
+        assert(subarray instanceof this._constructor);
+        assert(subarray.buffer === this._data.buffer);
+        return subarray;
+    }
+}
+/** A [[TypedArrayBuilder]] for producing a [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array).
+ * @public
+ */
+export class Uint8ArrayBuilder extends TypedArrayBuilder {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options) {
+        super(Uint8Array, options);
+    }
+}
+/** A [[TypedArrayBuilder]] for producing a [Uint16Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array).
+ * @public
+ */
+export class Uint16ArrayBuilder extends TypedArrayBuilder {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options) {
+        super(Uint16Array, options);
+    }
+}
+/** A [[TypedArrayBuilder]] for producing a [Uint32Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array).
+ * @public
+ */
+export class Uint32ArrayBuilder extends TypedArrayBuilder {
+    /** See [[TypedArrayBuilder]] constructor. */
+    constructor(options) {
+        super(Uint32Array, options);
+    }
+    /** Obtain a view of the finished array as an array of bytes. */
+    toUint8Array(includeUnusedCapacity = false) {
+        if (includeUnusedCapacity)
+            return new Uint8Array(this._data.buffer);
+        return new Uint8Array(this._data.buffer, 0, this.length * 4);
+    }
+}
+/** A [[TypedArrayBuilder]] that can populate a [[UintArray]] with the minimum
+ * [bytes per element](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/BYTES_PER_ELEMENT) required.
+ *
+ * By default, the underlying array is a `Uint8Array`, though this can be configured via [[UintArrayBuilderOptions.initialType]].
+ * As values are added to the array, if the bytes per element supported by the underlying array is too small to hold one of the new values, the array is
+ * reallocated to a type large enough to hold all of the new values. For example, the following produces a `Uint8Array` because all values are less than 256:
+ *
+ * ```ts
+ *  const builder = new UintArrayBuilder();
+ *  builder.append([1, 2, 254, 255]);
+ *  const array = builder.toTypedArray();
+ *  assert(array instanceof Uint8Array);
+ * ```
+ *
+ * However, the following produces a `Uint16Array` because one of the values is larger than 255 but none are larger than 65,535:
+ *
+ * ```ts
+ *  const builder = new UintArrayBuilder();
+ *  builder.append([1, 255, 257, 65535]);
+ *  const array = builder.toTypedArray();
+ *  assert(array instanceof Uint16Array);
+ * ```
+ *
+ * @see [[Uint8ArrayBuilder]], [[Uint16ArrayBuilder]], or [[Uint32ArrayBuilder]] if you know the number of bytes you want to allocate for each element in the array.
+ * @public
+ */
+export class UintArrayBuilder extends TypedArrayBuilder {
+    constructor(options) {
+        var _a;
+        super((_a = options === null || options === void 0 ? void 0 : options.initialType) !== null && _a !== void 0 ? _a : Uint8Array, options);
+    }
+    /** The number of bytes (1, 2, or 4) currently allocated per element by the underlying array.
+     * This may change as larger values are added to the array.
+     */
+    get bytesPerElement() {
+        return this._data.BYTES_PER_ELEMENT;
+    }
+    /** Ensures that the underlying array is of a type that can contain the largest value in `newValues`.
+     * For example, if `_data` is a `Uint16Array` and `newValues` contains any value(s) larger than 65,535, it will be replaced with a `Uint32Array`.
+     * This method is invoked by [[push]] and [[append]].
+     */
+    ensureBytesPerElement(newValues) {
+        const curBytesPerElem = this.bytesPerElement;
+        assert(curBytesPerElem === 1 || curBytesPerElem === 2 || curBytesPerElem === 4);
+        if (curBytesPerElem >= 4)
+            return;
+        let neededBytesPerElem = curBytesPerElem;
+        for (const value of newValues) {
+            if (value > 0xffff) {
+                neededBytesPerElem = 4;
+                break;
+            }
+            else if (value > 0xff) {
+                neededBytesPerElem = 2;
+            }
+        }
+        if (neededBytesPerElem <= curBytesPerElem)
+            return;
+        this._constructor = neededBytesPerElem === 1 ? Uint8Array : (neededBytesPerElem === 2 ? Uint16Array : Uint32Array);
+        this._data = new this._constructor(this._data);
+    }
+    /** See [[TypedArrayBuilder.push]]. */
+    push(value) {
+        this.ensureBytesPerElement([value]);
+        super.push(value);
+    }
+    /** See [[TypedArrayBuilder.append]]. */
+    append(values) {
+        this.ensureBytesPerElement(values);
+        super.append(values);
+    }
+}
 //# sourceMappingURL=TypedArrayBuilder.js.map