typescript 5.7.0-dev.20240924 → 5.7.0-dev.20240925

package/lib/lib.es2023.array.d.ts

@@ -163,7 +163,7 @@ interface ReadonlyArray<T> {
     with(index: number, value: T): T[];
 }
 
-interface Int8Array {
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -177,12 +177,12 @@ interface Int8Array {
         predicate: (
             value: number,
             index: number,
-            array: Int8Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
     findLast(
-        predicate: (value: number, index: number, array: Int8Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
     ): number | undefined;
 
@@ -196,14 +196,14 @@ interface Int8Array {
      * predicate. If it is not provided, undefined is used instead.
      */
     findLastIndex(
-        predicate: (value: number, index: number, array: Int8Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
     ): number;
 
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Int8Array;
+    toReversed(): Int8Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -211,11 +211,11 @@ interface Int8Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -224,10 +224,10 @@ interface Int8Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Int8Array;
+    with(index: number, value: number): Int8Array<ArrayBuffer>;
 }
 
-interface Uint8Array {
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -241,12 +241,12 @@ interface Uint8Array {
         predicate: (
             value: number,
             index: number,
-            array: Uint8Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
     findLast(
-        predicate: (value: number, index: number, array: Uint8Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
     ): number | undefined;
 
@@ -260,14 +260,14 @@ interface Uint8Array {
      * predicate. If it is not provided, undefined is used instead.
      */
     findLastIndex(
-        predicate: (value: number, index: number, array: Uint8Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
     ): number;
 
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Uint8Array;
+    toReversed(): Uint8Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -275,11 +275,11 @@ interface Uint8Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -288,10 +288,10 @@ interface Uint8Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Uint8Array;
+    with(index: number, value: number): Uint8Array<ArrayBuffer>;
 }
 
-interface Uint8ClampedArray {
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -305,7 +305,7 @@ interface Uint8ClampedArray {
         predicate: (
             value: number,
             index: number,
-            array: Uint8ClampedArray,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
@@ -313,7 +313,7 @@ interface Uint8ClampedArray {
         predicate: (
             value: number,
             index: number,
-            array: Uint8ClampedArray,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number | undefined;
@@ -331,7 +331,7 @@ interface Uint8ClampedArray {
         predicate: (
             value: number,
             index: number,
-            array: Uint8ClampedArray,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number;
@@ -339,7 +339,7 @@ interface Uint8ClampedArray {
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Uint8ClampedArray;
+    toReversed(): Uint8ClampedArray<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -347,11 +347,11 @@ interface Uint8ClampedArray {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -360,10 +360,10 @@ interface Uint8ClampedArray {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Uint8ClampedArray;
+    with(index: number, value: number): Uint8ClampedArray<ArrayBuffer>;
 }
 
-interface Int16Array {
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -377,12 +377,12 @@ interface Int16Array {
         predicate: (
             value: number,
             index: number,
-            array: Int16Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
     findLast(
-        predicate: (value: number, index: number, array: Int16Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
     ): number | undefined;
 
@@ -396,14 +396,14 @@ interface Int16Array {
      * predicate. If it is not provided, undefined is used instead.
      */
     findLastIndex(
-        predicate: (value: number, index: number, array: Int16Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
     ): number;
 
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Int16Array;
+    toReversed(): Int16Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -411,11 +411,11 @@ interface Int16Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -424,10 +424,10 @@ interface Int16Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Int16Array;
+    with(index: number, value: number): Int16Array<ArrayBuffer>;
 }
 
-interface Uint16Array {
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -441,7 +441,7 @@ interface Uint16Array {
         predicate: (
             value: number,
             index: number,
-            array: Uint16Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
@@ -449,7 +449,7 @@ interface Uint16Array {
         predicate: (
             value: number,
             index: number,
-            array: Uint16Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number | undefined;
@@ -467,7 +467,7 @@ interface Uint16Array {
         predicate: (
             value: number,
             index: number,
-            array: Uint16Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number;
@@ -475,7 +475,7 @@ interface Uint16Array {
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Uint16Array;
+    toReversed(): Uint16Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -483,11 +483,11 @@ interface Uint16Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -496,10 +496,10 @@ interface Uint16Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Uint16Array;
+    with(index: number, value: number): Uint16Array<ArrayBuffer>;
 }
 
-interface Int32Array {
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -513,12 +513,12 @@ interface Int32Array {
         predicate: (
             value: number,
             index: number,
-            array: Int32Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
     findLast(
-        predicate: (value: number, index: number, array: Int32Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
     ): number | undefined;
 
@@ -532,14 +532,14 @@ interface Int32Array {
      * predicate. If it is not provided, undefined is used instead.
      */
     findLastIndex(
-        predicate: (value: number, index: number, array: Int32Array) => unknown,
+        predicate: (value: number, index: number, array: this) => unknown,
         thisArg?: any,
     ): number;
 
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Int32Array;
+    toReversed(): Int32Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -547,11 +547,11 @@ interface Int32Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -560,10 +560,10 @@ interface Int32Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Int32Array;
+    with(index: number, value: number): Int32Array<ArrayBuffer>;
 }
 
-interface Uint32Array {
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -577,7 +577,7 @@ interface Uint32Array {
         predicate: (
             value: number,
             index: number,
-            array: Uint32Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
@@ -585,7 +585,7 @@ interface Uint32Array {
         predicate: (
             value: number,
             index: number,
-            array: Uint32Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number | undefined;
@@ -603,7 +603,7 @@ interface Uint32Array {
         predicate: (
             value: number,
             index: number,
-            array: Uint32Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number;
@@ -611,7 +611,7 @@ interface Uint32Array {
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Uint32Array;
+    toReversed(): Uint32Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -619,11 +619,11 @@ interface Uint32Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -632,10 +632,10 @@ interface Uint32Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Uint32Array;
+    with(index: number, value: number): Uint32Array<ArrayBuffer>;
 }
 
-interface Float32Array {
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -649,7 +649,7 @@ interface Float32Array {
         predicate: (
             value: number,
             index: number,
-            array: Float32Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
@@ -657,7 +657,7 @@ interface Float32Array {
         predicate: (
             value: number,
             index: number,
-            array: Float32Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number | undefined;
@@ -675,7 +675,7 @@ interface Float32Array {
         predicate: (
             value: number,
             index: number,
-            array: Float32Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number;
@@ -683,7 +683,7 @@ interface Float32Array {
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Float32Array;
+    toReversed(): Float32Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -691,11 +691,11 @@ interface Float32Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -704,10 +704,10 @@ interface Float32Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Float32Array;
+    with(index: number, value: number): Float32Array<ArrayBuffer>;
 }
 
-interface Float64Array {
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -721,7 +721,7 @@ interface Float64Array {
         predicate: (
             value: number,
             index: number,
-            array: Float64Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
@@ -729,7 +729,7 @@ interface Float64Array {
         predicate: (
             value: number,
             index: number,
-            array: Float64Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number | undefined;
@@ -747,7 +747,7 @@ interface Float64Array {
         predicate: (
             value: number,
             index: number,
-            array: Float64Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number;
@@ -755,7 +755,7 @@ interface Float64Array {
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): Float64Array;
+    toReversed(): Float64Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -763,11 +763,11 @@ interface Float64Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given number at the provided index.
@@ -776,10 +776,10 @@ interface Float64Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: number): Float64Array;
+    with(index: number, value: number): Float64Array<ArrayBuffer>;
 }
 
-interface BigInt64Array {
+interface BigInt64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -793,7 +793,7 @@ interface BigInt64Array {
         predicate: (
             value: bigint,
             index: number,
-            array: BigInt64Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
@@ -801,7 +801,7 @@ interface BigInt64Array {
         predicate: (
             value: bigint,
             index: number,
-            array: BigInt64Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): bigint | undefined;
@@ -819,7 +819,7 @@ interface BigInt64Array {
         predicate: (
             value: bigint,
             index: number,
-            array: BigInt64Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number;
@@ -827,7 +827,7 @@ interface BigInt64Array {
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): BigInt64Array;
+    toReversed(): BigInt64Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -835,11 +835,11 @@ interface BigInt64Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given bigint at the provided index.
@@ -848,10 +848,10 @@ interface BigInt64Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: bigint): BigInt64Array;
+    with(index: number, value: bigint): BigInt64Array<ArrayBuffer>;
 }
 
-interface BigUint64Array {
+interface BigUint64Array<TArrayBuffer extends ArrayBufferLike> {
     /**
      * Returns the value of the last element in the array where predicate is true, and undefined
      * otherwise.
@@ -865,7 +865,7 @@ interface BigUint64Array {
         predicate: (
             value: bigint,
             index: number,
-            array: BigUint64Array,
+            array: this,
         ) => value is S,
         thisArg?: any,
     ): S | undefined;
@@ -873,7 +873,7 @@ interface BigUint64Array {
         predicate: (
             value: bigint,
             index: number,
-            array: BigUint64Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): bigint | undefined;
@@ -891,7 +891,7 @@ interface BigUint64Array {
         predicate: (
             value: bigint,
             index: number,
-            array: BigUint64Array,
+            array: this,
         ) => unknown,
         thisArg?: any,
     ): number;
@@ -899,7 +899,7 @@ interface BigUint64Array {
     /**
      * Copies the array and returns the copy with the elements in reverse order.
      */
-    toReversed(): BigUint64Array;
+    toReversed(): BigUint64Array<ArrayBuffer>;
 
     /**
      * Copies and sorts the array.
@@ -907,11 +907,11 @@ interface BigUint64Array {
      * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive
      * value otherwise. If omitted, the elements are sorted in ascending order.
      * ```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>;
 
     /**
      * Copies the array and inserts the given bigint at the provided index.
@@ -920,5 +920,5 @@ interface BigUint64Array {
      * @param value The value to insert into the copied array.
      * @returns A copy of the original array with the inserted value.
      */
-    with(index: number, value: bigint): BigUint64Array;
+    with(index: number, value: bigint): BigUint64Array<ArrayBuffer>;
 }