typescript - npm Package Compare versions

Comparing version 5.7.0-dev.20240924 to 5.7.0-dev.20240925

lib/lib.es2015.core.d.ts

@@ -563,36 +563,36 @@ /*! *****************************************************************************
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
 }

lib/lib.es2015.iterable.d.ts

@@ -273,3 +273,3 @@ /*! *****************************************************************************
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -291,3 +291,3 @@ /**
 interface Int8ArrayConstructor {
-    new (elements: Iterable<number>): Int8Array;
+    new (elements: Iterable<number>): Int8Array<ArrayBuffer>;
 
@@ -300,6 +300,13 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array;
+    from(arrayLike: Iterable<number>): Int8Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Int8Array<ArrayBuffer>;
 }
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -321,3 +328,3 @@ /**
 interface Uint8ArrayConstructor {
-    new (elements: Iterable<number>): Uint8Array;
+    new (elements: Iterable<number>): Uint8Array<ArrayBuffer>;
 
@@ -330,6 +337,13 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array;
+    from(arrayLike: Iterable<number>): Uint8Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8Array<ArrayBuffer>;
 }
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -353,3 +367,3 @@ /**
 interface Uint8ClampedArrayConstructor {
-    new (elements: Iterable<number>): Uint8ClampedArray;
+    new (elements: Iterable<number>): Uint8ClampedArray<ArrayBuffer>;
 
@@ -362,6 +376,13 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray;
+    from(arrayLike: Iterable<number>): Uint8ClampedArray<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint8ClampedArray<ArrayBuffer>;
 }
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -385,3 +406,3 @@ /**
 interface Int16ArrayConstructor {
-    new (elements: Iterable<number>): Int16Array;
+    new (elements: Iterable<number>): Int16Array<ArrayBuffer>;
 
@@ -394,6 +415,13 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array;
+    from(arrayLike: Iterable<number>): Int16Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Int16Array<ArrayBuffer>;
 }
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -415,3 +443,3 @@ /**
 interface Uint16ArrayConstructor {
-    new (elements: Iterable<number>): Uint16Array;
+    new (elements: Iterable<number>): Uint16Array<ArrayBuffer>;
 
@@ -424,6 +452,13 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array;
+    from(arrayLike: Iterable<number>): Uint16Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint16Array<ArrayBuffer>;
 }
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -445,3 +480,3 @@ /**
 interface Int32ArrayConstructor {
-    new (elements: Iterable<number>): Int32Array;
+    new (elements: Iterable<number>): Int32Array<ArrayBuffer>;
 
@@ -454,6 +489,13 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array;
+    from(arrayLike: Iterable<number>): Int32Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Int32Array<ArrayBuffer>;
 }
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -475,3 +517,3 @@ /**
 interface Uint32ArrayConstructor {
-    new (elements: Iterable<number>): Uint32Array;
+    new (elements: Iterable<number>): Uint32Array<ArrayBuffer>;
 
@@ -484,6 +526,13 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array;
+    from(arrayLike: Iterable<number>): Uint32Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Uint32Array<ArrayBuffer>;
 }
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -505,3 +554,3 @@ /**
 interface Float32ArrayConstructor {
-    new (elements: Iterable<number>): Float32Array;
+    new (elements: Iterable<number>): Float32Array<ArrayBuffer>;
 
@@ -514,6 +563,13 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array;
+    from(arrayLike: Iterable<number>): Float32Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Float32Array<ArrayBuffer>;
 }
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     [Symbol.iterator](): ArrayIterator<number>;
@@ -535,3 +591,3 @@ /**
 interface Float64ArrayConstructor {
-    new (elements: Iterable<number>): Float64Array;
+    new (elements: Iterable<number>): Float64Array<ArrayBuffer>;
 
@@ -544,3 +600,10 @@ /**
      */
-    from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;
+    from(arrayLike: Iterable<number>): Float64Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T>(arrayLike: Iterable<T>, mapfn?: (v: T, k: number) => number, thisArg?: any): Float64Array<ArrayBuffer>;
 }

lib/lib.es2015.symbol.wellknown.d.ts

@@ -275,39 +275,39 @@ /*! *****************************************************************************
 
-interface DataView {
+interface DataView<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: string;
 }
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Int8Array";
 }
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Uint8Array";
 }
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Uint8ClampedArray";
 }
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Int16Array";
 }
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Uint16Array";
 }
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Int32Array";
 }
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Uint32Array";
 }
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Float32Array";
 }
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     readonly [Symbol.toStringTag]: "Float64Array";
@@ -314,0 +314,0 @@ }

lib/lib.es2016.array.include.d.ts

@@ -37,3 +37,3 @@ /*! *****************************************************************************
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -47,3 +47,3 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -57,3 +57,3 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -67,3 +67,3 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -77,3 +77,3 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -87,3 +87,3 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -97,3 +97,3 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -107,3 +107,3 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -117,3 +117,3 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -120,0 +120,0 @@ * Determines whether an array includes a certain element, returning true or false as appropriate.

lib/lib.es2017.sharedmemory.d.ts

@@ -52,3 +52,3 @@ /*! *****************************************************************************
      */
-    add(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    add(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
@@ -60,3 +60,3 @@ /**
      */
-    and(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    and(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
@@ -68,3 +68,3 @@ /**
      */
-    compareExchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, expectedValue: number, replacementValue: number): number;
+    compareExchange(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, expectedValue: number, replacementValue: number): number;
 
@@ -76,3 +76,3 @@ /**
      */
-    exchange(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    exchange(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
@@ -90,3 +90,3 @@ /**
      */
-    load(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number): number;
+    load(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number): number;
 
@@ -98,3 +98,3 @@ /**
      */
-    or(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    or(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
@@ -105,3 +105,3 @@ /**
      */
-    store(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    store(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
@@ -113,3 +113,3 @@ /**
      */
-    sub(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    sub(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
@@ -122,3 +122,3 @@ /**
      */
-    wait(typedArray: Int32Array, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out";
+    wait(typedArray: Int32Array<ArrayBufferLike>, index: number, value: number, timeout?: number): "ok" | "not-equal" | "timed-out";
 
@@ -128,7 +128,7 @@ /**
      * number of agents that were awoken.
-     * @param typedArray A shared Int32Array.
+     * @param typedArray A shared Int32Array<ArrayBufferLike>.
      * @param index The position in the typedArray to wake up on.
      * @param count The number of sleeping agents to notify. Defaults to +Infinity.
      */
-    notify(typedArray: Int32Array, index: number, count?: number): number;
+    notify(typedArray: Int32Array<ArrayBufferLike>, index: number, count?: number): number;
 
@@ -140,3 +140,3 @@ /**
      */
-    xor(typedArray: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array, index: number, value: number): number;
+    xor(typedArray: Int8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>, index: number, value: number): number;
 
@@ -143,0 +143,0 @@ readonly [Symbol.toStringTag]: "Atomics";

lib/lib.es2017.typedarrays.d.ts

@@ -20,35 +20,35 @@ /*! *****************************************************************************
 interface Int8ArrayConstructor {
-    new (): Int8Array;
+    new (): Int8Array<ArrayBuffer>;
 }
 
 interface Uint8ArrayConstructor {
-    new (): Uint8Array;
+    new (): Uint8Array<ArrayBuffer>;
 }
 
 interface Uint8ClampedArrayConstructor {
-    new (): Uint8ClampedArray;
+    new (): Uint8ClampedArray<ArrayBuffer>;
 }
 
 interface Int16ArrayConstructor {
-    new (): Int16Array;
+    new (): Int16Array<ArrayBuffer>;
 }
 
 interface Uint16ArrayConstructor {
-    new (): Uint16Array;
+    new (): Uint16Array<ArrayBuffer>;
 }
 
 interface Int32ArrayConstructor {
-    new (): Int32Array;
+    new (): Int32Array<ArrayBuffer>;
 }
 
 interface Uint32ArrayConstructor {
-    new (): Uint32Array;
+    new (): Uint32Array<ArrayBuffer>;
 }
 
 interface Float32ArrayConstructor {
-    new (): Float32Array;
+    new (): Float32Array<ArrayBuffer>;
 }
 
 interface Float64ArrayConstructor {
-    new (): Float64Array;
+    new (): Float64Array<ArrayBuffer>;
 }

lib/lib.es2020.bigint.d.ts

@@ -149,3 +149,3 @@ /*! *****************************************************************************
  */
-interface BigInt64Array {
+interface BigInt64Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> {
     /** The size in bytes of each element in the array. */
@@ -155,3 +155,3 @@ readonly BYTES_PER_ELEMENT: number;
     /** The ArrayBuffer instance referenced by the array. */
-    readonly buffer: ArrayBufferLike;
+    readonly buffer: TArrayBuffer;
 
@@ -186,3 +186,3 @@ /** The length in bytes of the array. */
      */
-    every(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean;
+    every(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => boolean, thisArg?: any): boolean;
 
@@ -206,3 +206,3 @@ /**
      */
-    filter(predicate: (value: bigint, index: number, array: BigInt64Array) => any, thisArg?: any): BigInt64Array;
+    filter(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => any, thisArg?: any): BigInt64Array<ArrayBuffer>;
 
@@ -218,3 +218,3 @@ /**
      */
-    find(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): bigint | undefined;
+    find(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => boolean, thisArg?: any): bigint | undefined;
 
@@ -230,3 +230,3 @@ /**
      */
-    findIndex(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => boolean, thisArg?: any): number;
 
@@ -240,3 +240,3 @@ /**
      */
-    forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => void, thisArg?: any): void;
 
@@ -287,3 +287,3 @@ /**
      */
-    map(callbackfn: (value: bigint, index: number, array: BigInt64Array) => bigint, thisArg?: any): BigInt64Array;
+    map(callbackfn: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => bigint, thisArg?: any): BigInt64Array<ArrayBuffer>;
 
@@ -300,3 +300,3 @@ /**
      */
-    reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint;
+    reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array<TArrayBuffer>) => bigint): bigint;
 
@@ -313,3 +313,3 @@ /**
      */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array<TArrayBuffer>) => U, initialValue: U): U;
 
@@ -326,3 +326,3 @@ /**
      */
-    reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint;
+    reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array<TArrayBuffer>) => bigint): bigint;
 
@@ -339,3 +339,3 @@ /**
      */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array<TArrayBuffer>) => U, initialValue: U): U;
 
@@ -357,3 +357,3 @@ /** Reverses the elements in the array. */
      */
-    slice(start?: number, end?: number): BigInt64Array;
+    slice(start?: number, end?: number): BigInt64Array<ArrayBuffer>;
 
@@ -368,3 +368,3 @@ /**
      */
-    some(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean;
+    some(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => boolean, thisArg?: any): boolean;
 
@@ -383,3 +383,3 @@ /**
      */
-    subarray(begin?: number, end?: number): BigInt64Array;
+    subarray(begin?: number, end?: number): BigInt64Array<TArrayBuffer>;
 
@@ -393,3 +393,3 @@ /** Converts the array to a string by using the current locale. */
     /** Returns the primitive value of the specified object. */
-    valueOf(): BigInt64Array;
+    valueOf(): BigInt64Array<TArrayBuffer>;
 
@@ -405,8 +405,7 @@ /** Yields each value in the array. */
 }
-
 interface BigInt64ArrayConstructor {
-    readonly prototype: BigInt64Array;
-    new (length?: number): BigInt64Array;
-    new (array: Iterable<bigint>): BigInt64Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigInt64Array;
+    readonly prototype: BigInt64Array<ArrayBufferLike>;
+    new (length?: number): BigInt64Array<ArrayBuffer>;
+    new (array: ArrayLike<bigint> | Iterable<bigint>): BigInt64Array<ArrayBuffer>;
+    new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number): BigInt64Array<TArrayBuffer>;
 
@@ -420,3 +419,3 @@ /** The size in bytes of each element in the array. */
      */
-    of(...items: bigint[]): BigInt64Array;
+    of(...items: bigint[]): BigInt64Array<ArrayBuffer>;
 
@@ -429,6 +428,11 @@ /**
      */
-    from(arrayLike: ArrayLike<bigint>): BigInt64Array;
-    from<U>(arrayLike: ArrayLike<U>, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array;
+    from(arrayLike: ArrayLike<bigint>): BigInt64Array<ArrayBuffer>;
+    /**
+     * Creates an array from an array-like or iterable object.
+     * @param arrayLike An array-like or iterable object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<U>(arrayLike: ArrayLike<U>, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array<ArrayBuffer>;
 }
-
 declare var BigInt64Array: BigInt64ArrayConstructor;
@@ -440,3 +444,3 @@
  */
-interface BigUint64Array {
+interface BigUint64Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> {
     /** The size in bytes of each element in the array. */
@@ -446,3 +450,3 @@ readonly BYTES_PER_ELEMENT: number;
     /** The ArrayBuffer instance referenced by the array. */
-    readonly buffer: ArrayBufferLike;
+    readonly buffer: TArrayBuffer;
 
@@ -477,3 +481,3 @@ /** The length in bytes of the array. */
      */
-    every(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean;
+    every(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => boolean, thisArg?: any): boolean;
 
@@ -497,3 +501,3 @@ /**
      */
-    filter(predicate: (value: bigint, index: number, array: BigUint64Array) => any, thisArg?: any): BigUint64Array;
+    filter(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => any, thisArg?: any): BigUint64Array<ArrayBuffer>;
 
@@ -509,3 +513,3 @@ /**
      */
-    find(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): bigint | undefined;
+    find(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => boolean, thisArg?: any): bigint | undefined;
 
@@ -521,3 +525,3 @@ /**
      */
-    findIndex(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => boolean, thisArg?: any): number;
 
@@ -531,3 +535,3 @@ /**
      */
-    forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => void, thisArg?: any): void;
 
@@ -578,3 +582,3 @@ /**
      */
-    map(callbackfn: (value: bigint, index: number, array: BigUint64Array) => bigint, thisArg?: any): BigUint64Array;
+    map(callbackfn: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => bigint, thisArg?: any): BigUint64Array<ArrayBuffer>;
 
@@ -591,3 +595,3 @@ /**
      */
-    reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint;
+    reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array<TArrayBuffer>) => bigint): bigint;
 
@@ -604,3 +608,3 @@ /**
      */
-    reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array<TArrayBuffer>) => U, initialValue: U): U;
 
@@ -617,3 +621,3 @@ /**
      */
-    reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint;
+    reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array<TArrayBuffer>) => bigint): bigint;
 
@@ -630,3 +634,3 @@ /**
      */
-    reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array<TArrayBuffer>) => U, initialValue: U): U;
 
@@ -648,3 +652,3 @@ /** Reverses the elements in the array. */
      */
-    slice(start?: number, end?: number): BigUint64Array;
+    slice(start?: number, end?: number): BigUint64Array<ArrayBuffer>;
 
@@ -659,3 +663,3 @@ /**
      */
-    some(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean;
+    some(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => boolean, thisArg?: any): boolean;
 
@@ -674,3 +678,3 @@ /**
      */
-    subarray(begin?: number, end?: number): BigUint64Array;
+    subarray(begin?: number, end?: number): BigUint64Array<TArrayBuffer>;
 
@@ -684,3 +688,3 @@ /** Converts the array to a string by using the current locale. */
     /** Returns the primitive value of the specified object. */
-    valueOf(): BigUint64Array;
+    valueOf(): BigUint64Array<TArrayBuffer>;
 
@@ -696,8 +700,7 @@ /** Yields each value in the array. */
 }
-
 interface BigUint64ArrayConstructor {
-    readonly prototype: BigUint64Array;
-    new (length?: number): BigUint64Array;
-    new (array: Iterable<bigint>): BigUint64Array;
-    new (buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigUint64Array;
+    readonly prototype: BigUint64Array<ArrayBufferLike>;
+    new (length?: number): BigUint64Array<ArrayBuffer>;
+    new (array: ArrayLike<bigint> | Iterable<bigint>): BigUint64Array<ArrayBuffer>;
+    new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number): BigUint64Array<TArrayBuffer>;
 
@@ -711,3 +714,3 @@ /** The size in bytes of each element in the array. */
      */
-    of(...items: bigint[]): BigUint64Array;
+    of(...items: bigint[]): BigUint64Array<ArrayBuffer>;
 
@@ -723,6 +726,5 @@ /**
 }
-
 declare var BigUint64Array: BigUint64ArrayConstructor;
 
-interface DataView {
+interface DataView<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -729,0 +731,0 @@ * Gets the BigInt64 value at the specified byte offset from the start of the view. There is

lib/lib.es2020.sharedmemory.d.ts

@@ -25,3 +25,3 @@ /*! *****************************************************************************
      */
-    add(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint;
+    add(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number, value: bigint): bigint;
 
@@ -33,3 +33,3 @@ /**
      */
-    and(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint;
+    and(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number, value: bigint): bigint;
 
@@ -41,3 +41,3 @@ /**
      */
-    compareExchange(typedArray: BigInt64Array | BigUint64Array, index: number, expectedValue: bigint, replacementValue: bigint): bigint;
+    compareExchange(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number, expectedValue: bigint, replacementValue: bigint): bigint;
 
@@ -49,3 +49,3 @@ /**
      */
-    exchange(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint;
+    exchange(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number, value: bigint): bigint;
 
@@ -56,3 +56,3 @@ /**
      */
-    load(typedArray: BigInt64Array | BigUint64Array, index: number): bigint;
+    load(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number): bigint;
 
@@ -64,3 +64,3 @@ /**
      */
-    or(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint;
+    or(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number, value: bigint): bigint;
 
@@ -71,3 +71,3 @@ /**
      */
-    store(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint;
+    store(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number, value: bigint): bigint;
 
@@ -79,3 +79,3 @@ /**
      */
-    sub(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint;
+    sub(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number, value: bigint): bigint;
 
@@ -88,3 +88,3 @@ /**
      */
-    wait(typedArray: BigInt64Array, index: number, value: bigint, timeout?: number): "ok" | "not-equal" | "timed-out";
+    wait(typedArray: BigInt64Array<ArrayBufferLike>, index: number, value: bigint, timeout?: number): "ok" | "not-equal" | "timed-out";
 
@@ -98,3 +98,3 @@ /**
      */
-    notify(typedArray: BigInt64Array, index: number, count?: number): number;
+    notify(typedArray: BigInt64Array<ArrayBufferLike>, index: number, count?: number): number;
 
@@ -106,3 +106,3 @@ /**
      */
-    xor(typedArray: BigInt64Array | BigUint64Array, index: number, value: bigint): bigint;
+    xor(typedArray: BigInt64Array<ArrayBufferLike> | BigUint64Array<ArrayBufferLike>, index: number, value: bigint): bigint;
 }

lib/lib.es2022.array.d.ts

@@ -35,3 +35,3 @@ /*! *****************************************************************************
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -44,3 +44,3 @@ * Returns the item located at the specified index.
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -53,3 +53,3 @@ * Returns the item located at the specified index.
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -62,3 +62,3 @@ * Returns the item located at the specified index.
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -71,3 +71,3 @@ * Returns the item located at the specified index.
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -80,3 +80,3 @@ * Returns the item located at the specified index.
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -89,3 +89,3 @@ * Returns the item located at the specified index.
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -98,3 +98,3 @@ * Returns the item located at the specified index.
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -107,3 +107,3 @@ * Returns the item located at the specified index.
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -116,3 +116,3 @@ * Returns the item located at the specified index.
 
-interface BigInt64Array {
+interface BigInt64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -125,3 +125,3 @@ * Returns the item located at the specified index.
 
-interface BigUint64Array {
+interface BigUint64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -128,0 +128,0 @@ * Returns the item located at the specified index.

lib/lib.es2023.array.d.ts

@@ -166,3 +166,3 @@ /*! *****************************************************************************
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -181,3 +181,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Int8Array,
+            array: this,
         ) => value is S,
@@ -187,3 +187,3 @@ thisArg?: any,
     findLast(
-        predicate: (value: number, index: number, array: Int8Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
@@ -202,3 +202,3 @@ ): number | undefined;
     findLastIndex(
-        predicate: (value: number, index: number, array: Int8Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
@@ -210,3 +210,3 @@ ): number;
      */
-    toReversed(): Int8Array;
+    toReversed(): Int8Array<ArrayBuffer>;
 
@@ -219,7 +219,7 @@ /**
      * ```ts
-     * const myNums = Int8Array.from([11, 2, 22, 1]);
-     * myNums.toSorted((a, b) => a - b) // Int8Array(4) [1, 2, 11, 22]
+     * const myNums = Int8Array<Buffer>.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Int8Array<Buffer>(4) [1, 2, 11, 22]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Int8Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Int8Array<ArrayBuffer>;
 
@@ -233,6 +233,6 @@ /**
      */
-    with(index: number, value: number): Int8Array;
+    with(index: number, value: number): Int8Array<ArrayBuffer>;
 }
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -251,3 +251,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Uint8Array,
+            array: this,
         ) => value is S,
@@ -257,3 +257,3 @@ thisArg?: any,
     findLast(
-        predicate: (value: number, index: number, array: Uint8Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
@@ -272,3 +272,3 @@ ): number | undefined;
     findLastIndex(
-        predicate: (value: number, index: number, array: Uint8Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
@@ -280,3 +280,3 @@ ): number;
      */
-    toReversed(): Uint8Array;
+    toReversed(): Uint8Array<ArrayBuffer>;
 
@@ -289,7 +289,7 @@ /**
      * ```ts
-     * const myNums = Uint8Array.from([11, 2, 22, 1]);
-     * myNums.toSorted((a, b) => a - b) // Uint8Array(4) [1, 2, 11, 22]
+     * const myNums = Uint8Array<Buffer>.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint8Array<Buffer>(4) [1, 2, 11, 22]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Uint8Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Uint8Array<ArrayBuffer>;
 
@@ -303,6 +303,6 @@ /**
      */
-    with(index: number, value: number): Uint8Array;
+    with(index: number, value: number): Uint8Array<ArrayBuffer>;
 }
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -321,3 +321,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Uint8ClampedArray,
+            array: this,
         ) => value is S,
@@ -330,3 +330,3 @@ thisArg?: any,
             index: number,
-            array: Uint8ClampedArray,
+            array: this,
         ) => unknown,
@@ -349,3 +349,3 @@ thisArg?: any,
             index: number,
-            array: Uint8ClampedArray,
+            array: this,
         ) => unknown,
@@ -358,3 +358,3 @@ thisArg?: any,
      */
-    toReversed(): Uint8ClampedArray;
+    toReversed(): Uint8ClampedArray<ArrayBuffer>;
 
@@ -367,7 +367,7 @@ /**
      * ```ts
-     * const myNums = Uint8ClampedArray.from([11, 2, 22, 1]);
-     * myNums.toSorted((a, b) => a - b) // Uint8ClampedArray(4) [1, 2, 11, 22]
+     * const myNums = Uint8ClampedArray<Buffer>.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint8ClampedArray<Buffer>(4) [1, 2, 11, 22]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Uint8ClampedArray;
+    toSorted(compareFn?: (a: number, b: number) => number): Uint8ClampedArray<ArrayBuffer>;
 
@@ -381,6 +381,6 @@ /**
      */
-    with(index: number, value: number): Uint8ClampedArray;
+    with(index: number, value: number): Uint8ClampedArray<ArrayBuffer>;
 }
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -399,3 +399,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Int16Array,
+            array: this,
         ) => value is S,
@@ -405,3 +405,3 @@ thisArg?: any,
     findLast(
-        predicate: (value: number, index: number, array: Int16Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
@@ -420,3 +420,3 @@ ): number | undefined;
     findLastIndex(
-        predicate: (value: number, index: number, array: Int16Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
@@ -428,3 +428,3 @@ ): number;
      */
-    toReversed(): Int16Array;
+    toReversed(): Int16Array<ArrayBuffer>;
 
@@ -437,7 +437,7 @@ /**
      * ```ts
-     * const myNums = Int16Array.from([11, 2, -22, 1]);
-     * myNums.toSorted((a, b) => a - b) // Int16Array(4) [-22, 1, 2, 11]
+     * const myNums = Int16Array<Buffer>.from([11, 2, -22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Int16Array<Buffer>(4) [-22, 1, 2, 11]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Int16Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Int16Array<ArrayBuffer>;
 
@@ -451,6 +451,6 @@ /**
      */
-    with(index: number, value: number): Int16Array;
+    with(index: number, value: number): Int16Array<ArrayBuffer>;
 }
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -469,3 +469,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Uint16Array,
+            array: this,
         ) => value is S,
@@ -478,3 +478,3 @@ thisArg?: any,
             index: number,
-            array: Uint16Array,
+            array: this,
         ) => unknown,
@@ -497,3 +497,3 @@ thisArg?: any,
             index: number,
-            array: Uint16Array,
+            array: this,
         ) => unknown,
@@ -506,3 +506,3 @@ thisArg?: any,
      */
-    toReversed(): Uint16Array;
+    toReversed(): Uint16Array<ArrayBuffer>;
 
@@ -515,7 +515,7 @@ /**
      * ```ts
-     * const myNums = Uint16Array.from([11, 2, 22, 1]);
-     * myNums.toSorted((a, b) => a - b) // Uint16Array(4) [1, 2, 11, 22]
+     * const myNums = Uint16Array<Buffer>.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint16Array<Buffer>(4) [1, 2, 11, 22]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Uint16Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Uint16Array<ArrayBuffer>;
 
@@ -529,6 +529,6 @@ /**
      */
-    with(index: number, value: number): Uint16Array;
+    with(index: number, value: number): Uint16Array<ArrayBuffer>;
 }
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -547,3 +547,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Int32Array,
+            array: this,
         ) => value is S,
@@ -553,3 +553,3 @@ thisArg?: any,
     findLast(
-        predicate: (value: number, index: number, array: Int32Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
@@ -568,3 +568,3 @@ ): number | undefined;
     findLastIndex(
-        predicate: (value: number, index: number, array: Int32Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
@@ -576,3 +576,3 @@ ): number;
      */
-    toReversed(): Int32Array;
+    toReversed(): Int32Array<ArrayBuffer>;
 
@@ -585,7 +585,7 @@ /**
      * ```ts
-     * const myNums = Int32Array.from([11, 2, -22, 1]);
-     * myNums.toSorted((a, b) => a - b) // Int32Array(4) [-22, 1, 2, 11]
+     * const myNums = Int32Array<Buffer>.from([11, 2, -22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Int32Array<Buffer>(4) [-22, 1, 2, 11]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Int32Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Int32Array<ArrayBuffer>;
 
@@ -599,6 +599,6 @@ /**
      */
-    with(index: number, value: number): Int32Array;
+    with(index: number, value: number): Int32Array<ArrayBuffer>;
 }
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -617,3 +617,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Uint32Array,
+            array: this,
         ) => value is S,
@@ -626,3 +626,3 @@ thisArg?: any,
             index: number,
-            array: Uint32Array,
+            array: this,
         ) => unknown,
@@ -645,3 +645,3 @@ thisArg?: any,
             index: number,
-            array: Uint32Array,
+            array: this,
         ) => unknown,
@@ -654,3 +654,3 @@ thisArg?: any,
      */
-    toReversed(): Uint32Array;
+    toReversed(): Uint32Array<ArrayBuffer>;
 
@@ -663,7 +663,7 @@ /**
      * ```ts
-     * const myNums = Uint32Array.from([11, 2, 22, 1]);
-     * myNums.toSorted((a, b) => a - b) // Uint32Array(4) [1, 2, 11, 22]
+     * const myNums = Uint32Array<Buffer>.from([11, 2, 22, 1]);
+     * myNums.toSorted((a, b) => a - b) // Uint32Array<Buffer>(4) [1, 2, 11, 22]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Uint32Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Uint32Array<ArrayBuffer>;
 
@@ -677,6 +677,6 @@ /**
      */
-    with(index: number, value: number): Uint32Array;
+    with(index: number, value: number): Uint32Array<ArrayBuffer>;
 }
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -695,3 +695,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Float32Array,
+            array: this,
         ) => value is S,
@@ -704,3 +704,3 @@ thisArg?: any,
             index: number,
-            array: Float32Array,
+            array: this,
         ) => unknown,
@@ -723,3 +723,3 @@ thisArg?: any,
             index: number,
-            array: Float32Array,
+            array: this,
         ) => unknown,
@@ -732,3 +732,3 @@ thisArg?: any,
      */
-    toReversed(): Float32Array;
+    toReversed(): Float32Array<ArrayBuffer>;
 
@@ -741,7 +741,7 @@ /**
      * ```ts
-     * const myNums = Float32Array.from([11.25, 2, -22.5, 1]);
-     * myNums.toSorted((a, b) => a - b) // Float32Array(4) [-22.5, 1, 2, 11.5]
+     * const myNums = Float32Array<Buffer>.from([11.25, 2, -22.5, 1]);
+     * myNums.toSorted((a, b) => a - b) // Float32Array<Buffer>(4) [-22.5, 1, 2, 11.5]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Float32Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Float32Array<ArrayBuffer>;
 
@@ -755,6 +755,6 @@ /**
      */
-    with(index: number, value: number): Float32Array;
+    with(index: number, value: number): Float32Array<ArrayBuffer>;
 }
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -773,3 +773,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: Float64Array,
+            array: this,
         ) => value is S,
@@ -782,3 +782,3 @@ thisArg?: any,
             index: number,
-            array: Float64Array,
+            array: this,
         ) => unknown,
@@ -801,3 +801,3 @@ thisArg?: any,
             index: number,
-            array: Float64Array,
+            array: this,
         ) => unknown,
@@ -810,3 +810,3 @@ thisArg?: any,
      */
-    toReversed(): Float64Array;
+    toReversed(): Float64Array<ArrayBuffer>;
 
@@ -819,7 +819,7 @@ /**
      * ```ts
-     * const myNums = Float64Array.from([11.25, 2, -22.5, 1]);
-     * myNums.toSorted((a, b) => a - b) // Float64Array(4) [-22.5, 1, 2, 11.5]
+     * const myNums = Float64Array<Buffer>.from([11.25, 2, -22.5, 1]);
+     * myNums.toSorted((a, b) => a - b) // Float64Array<Buffer>(4) [-22.5, 1, 2, 11.5]
      * ```
      */
-    toSorted(compareFn?: (a: number, b: number) => number): Float64Array;
+    toSorted(compareFn?: (a: number, b: number) => number): Float64Array<ArrayBuffer>;
 
@@ -833,6 +833,6 @@ /**
      */
-    with(index: number, value: number): Float64Array;
+    with(index: number, value: number): Float64Array<ArrayBuffer>;
 }
 
-interface BigInt64Array {
+interface BigInt64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -851,3 +851,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: BigInt64Array,
+            array: this,
         ) => value is S,
@@ -860,3 +860,3 @@ thisArg?: any,
             index: number,
-            array: BigInt64Array,
+            array: this,
         ) => unknown,
@@ -879,3 +879,3 @@ thisArg?: any,
             index: number,
-            array: BigInt64Array,
+            array: this,
         ) => unknown,
@@ -888,3 +888,3 @@ thisArg?: any,
      */
-    toReversed(): BigInt64Array;
+    toReversed(): BigInt64Array<ArrayBuffer>;
 
@@ -897,7 +897,7 @@ /**
      * ```ts
-     * const myNums = BigInt64Array.from([11n, 2n, -22n, 1n]);
-     * myNums.toSorted((a, b) => Number(a - b)) // BigInt64Array(4) [-22n, 1n, 2n, 11n]
+     * const myNums = BigInt64Array<Buffer>.from([11n, 2n, -22n, 1n]);
+     * myNums.toSorted((a, b) => Number(a - b)) // BigInt64Array<Buffer>(4) [-22n, 1n, 2n, 11n]
      * ```
      */
-    toSorted(compareFn?: (a: bigint, b: bigint) => number): BigInt64Array;
+    toSorted(compareFn?: (a: bigint, b: bigint) => number): BigInt64Array<ArrayBuffer>;
 
@@ -911,6 +911,6 @@ /**
      */
-    with(index: number, value: bigint): BigInt64Array;
+    with(index: number, value: bigint): BigInt64Array<ArrayBuffer>;
 }
 
-interface BigUint64Array {
+interface BigUint64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
@@ -929,3 +929,3 @@ * Returns the value of the last element in the array where predicate is true, and undefined
             index: number,
-            array: BigUint64Array,
+            array: this,
         ) => value is S,
@@ -938,3 +938,3 @@ thisArg?: any,
             index: number,
-            array: BigUint64Array,
+            array: this,
         ) => unknown,
@@ -957,3 +957,3 @@ thisArg?: any,
             index: number,
-            array: BigUint64Array,
+            array: this,
         ) => unknown,
@@ -966,3 +966,3 @@ thisArg?: any,
      */
-    toReversed(): BigUint64Array;
+    toReversed(): BigUint64Array<ArrayBuffer>;
 
@@ -975,7 +975,7 @@ /**
      * ```ts
-     * const myNums = BigUint64Array.from([11n, 2n, 22n, 1n]);
-     * myNums.toSorted((a, b) => Number(a - b)) // BigUint64Array(4) [1n, 2n, 11n, 22n]
+     * const myNums = BigUint64Array<Buffer>.from([11n, 2n, 22n, 1n]);
+     * myNums.toSorted((a, b) => Number(a - b)) // BigUint64Array<Buffer>(4) [1n, 2n, 11n, 22n]
      * ```
      */
-    toSorted(compareFn?: (a: bigint, b: bigint) => number): BigUint64Array;
+    toSorted(compareFn?: (a: bigint, b: bigint) => number): BigUint64Array<ArrayBuffer>;
 
@@ -989,3 +989,3 @@ /**
      */
-    with(index: number, value: bigint): BigUint64Array;
+    with(index: number, value: bigint): BigUint64Array<ArrayBuffer>;
 }

package.json

@@ -5,3 +5,3 @@ {
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.7.0-dev.20240924",
+    "version": "5.7.0-dev.20240925",
     "license": "Apache-2.0",
@@ -120,3 +120,3 @@ "description": "TypeScript is a language for application scale JavaScript development",
     },
-    "gitHead": "fa0080f4802fd78fb0f01cd0160f299794d7843d"
+    "gitHead": "e962037df334de071b8d3a9c70b13e3a600d1bc9"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

22556969

increased by0.08%

Lines of code

90928

increased by0.09%

No dependency changes