lib.es2023.array.d.ts (40236B)
1 /*! ***************************************************************************** 2 Copyright (c) Microsoft Corporation. All rights reserved. 3 Licensed under the Apache License, Version 2.0 (the "License"); you may not use 4 this file except in compliance with the License. You may obtain a copy of the 5 License at http://www.apache.org/licenses/LICENSE-2.0 6 7 THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 8 KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED 9 WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 10 MERCHANTABLITY OR NON-INFRINGEMENT. 11 12 See the Apache Version 2.0 License for specific language governing permissions 13 and limitations under the License. 14 ***************************************************************************** */ 15 16 17 /// <reference no-default-lib="true"/> 18 19 interface Array<T> { 20 /** 21 * Returns the value of the last element in the array where predicate is true, and undefined 22 * otherwise. 23 * @param predicate findLast calls predicate once for each element of the array, in descending 24 * order, until it finds one where predicate returns true. If such an element is found, findLast 25 * immediately returns that element value. Otherwise, findLast returns undefined. 26 * @param thisArg If provided, it will be used as the this value for each invocation of 27 * predicate. If it is not provided, undefined is used instead. 28 */ 29 findLast<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S | undefined; 30 findLast(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T | undefined; 31 32 /** 33 * Returns the index of the last element in the array where predicate is true, and -1 34 * otherwise. 35 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 36 * order, until it finds one where predicate returns true. If such an element is found, 37 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 38 * @param thisArg If provided, it will be used as the this value for each invocation of 39 * predicate. If it is not provided, undefined is used instead. 40 */ 41 findLastIndex(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): number; 42 43 /** 44 * Returns a copy of an array with its elements reversed. 45 */ 46 toReversed(): T[]; 47 48 /** 49 * Returns a copy of an array with its elements sorted. 50 * @param compareFn Function used to determine the order of the elements. It is expected to return 51 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 52 * value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order. 53 * ```ts 54 * [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22] 55 * ``` 56 */ 57 toSorted(compareFn?: (a: T, b: T) => number): T[]; 58 59 /** 60 * Copies an array and removes elements and, if necessary, inserts new elements in their place. Returns the copied array. 61 * @param start The zero-based location in the array from which to start removing elements. 62 * @param deleteCount The number of elements to remove. 63 * @param items Elements to insert into the copied array in place of the deleted elements. 64 * @returns The copied array. 65 */ 66 toSpliced(start: number, deleteCount: number, ...items: T[]): T[]; 67 68 /** 69 * Copies an array and removes elements while returning the remaining elements. 70 * @param start The zero-based location in the array from which to start removing elements. 71 * @param deleteCount The number of elements to remove. 72 * @returns A copy of the original array with the remaining elements. 73 */ 74 toSpliced(start: number, deleteCount?: number): T[]; 75 76 /** 77 * Copies an array, then overwrites the value at the provided index with the 78 * given value. If the index is negative, then it replaces from the end 79 * of the array. 80 * @param index The index of the value to overwrite. If the index is 81 * negative, then it replaces from the end of the array. 82 * @param value The value to write into the copied array. 83 * @returns The copied array with the updated value. 84 */ 85 with(index: number, value: T): T[]; 86 } 87 88 interface ReadonlyArray<T> { 89 /** 90 * Returns the value of the last element in the array where predicate is true, and undefined 91 * otherwise. 92 * @param predicate findLast calls predicate once for each element of the array, in descending 93 * order, until it finds one where predicate returns true. If such an element is found, findLast 94 * immediately returns that element value. Otherwise, findLast returns undefined. 95 * @param thisArg If provided, it will be used as the this value for each invocation of 96 * predicate. If it is not provided, undefined is used instead. 97 */ 98 findLast<S extends T>( 99 predicate: (value: T, index: number, array: readonly T[]) => value is S, 100 thisArg?: any, 101 ): S | undefined; 102 findLast( 103 predicate: (value: T, index: number, array: readonly T[]) => unknown, 104 thisArg?: any, 105 ): T | undefined; 106 107 /** 108 * Returns the index of the last element in the array where predicate is true, and -1 109 * otherwise. 110 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 111 * order, until it finds one where predicate returns true. If such an element is found, 112 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 113 * @param thisArg If provided, it will be used as the this value for each invocation of 114 * predicate. If it is not provided, undefined is used instead. 115 */ 116 findLastIndex( 117 predicate: (value: T, index: number, array: readonly T[]) => unknown, 118 thisArg?: any, 119 ): number; 120 121 /** 122 * Copies the array and returns the copied array with all of its elements reversed. 123 */ 124 toReversed(): T[]; 125 126 /** 127 * Copies and sorts the array. 128 * @param compareFn Function used to determine the order of the elements. It is expected to return 129 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 130 * value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order. 131 * ```ts 132 * [11, 2, 22, 1].toSorted((a, b) => a - b) // [1, 2, 11, 22] 133 * ``` 134 */ 135 toSorted(compareFn?: (a: T, b: T) => number): T[]; 136 137 /** 138 * Copies an array and removes elements while, if necessary, inserting new elements in their place, returning the remaining elements. 139 * @param start The zero-based location in the array from which to start removing elements. 140 * @param deleteCount The number of elements to remove. 141 * @param items Elements to insert into the copied array in place of the deleted elements. 142 * @returns A copy of the original array with the remaining elements. 143 */ 144 toSpliced(start: number, deleteCount: number, ...items: T[]): T[]; 145 146 /** 147 * Copies an array and removes elements while returning the remaining elements. 148 * @param start The zero-based location in the array from which to start removing elements. 149 * @param deleteCount The number of elements to remove. 150 * @returns A copy of the original array with the remaining elements. 151 */ 152 toSpliced(start: number, deleteCount?: number): T[]; 153 154 /** 155 * Copies an array, then overwrites the value at the provided index with the 156 * given value. If the index is negative, then it replaces from the end 157 * of the array 158 * @param index The index of the value to overwrite. If the index is 159 * negative, then it replaces from the end of the array. 160 * @param value The value to insert into the copied array. 161 * @returns A copy of the original array with the inserted value. 162 */ 163 with(index: number, value: T): T[]; 164 } 165 166 interface Int8Array<TArrayBuffer extends ArrayBufferLike> { 167 /** 168 * Returns the value of the last element in the array where predicate is true, and undefined 169 * otherwise. 170 * @param predicate findLast calls predicate once for each element of the array, in descending 171 * order, until it finds one where predicate returns true. If such an element is found, findLast 172 * immediately returns that element value. Otherwise, findLast returns undefined. 173 * @param thisArg If provided, it will be used as the this value for each invocation of 174 * predicate. If it is not provided, undefined is used instead. 175 */ 176 findLast<S extends number>( 177 predicate: ( 178 value: number, 179 index: number, 180 array: this, 181 ) => value is S, 182 thisArg?: any, 183 ): S | undefined; 184 findLast( 185 predicate: (value: number, index: number, array: this) => unknown, 186 thisArg?: any, 187 ): number | undefined; 188 189 /** 190 * Returns the index of the last element in the array where predicate is true, and -1 191 * otherwise. 192 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 193 * order, until it finds one where predicate returns true. If such an element is found, 194 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 195 * @param thisArg If provided, it will be used as the this value for each invocation of 196 * predicate. If it is not provided, undefined is used instead. 197 */ 198 findLastIndex( 199 predicate: (value: number, index: number, array: this) => unknown, 200 thisArg?: any, 201 ): number; 202 203 /** 204 * Copies the array and returns the copy with the elements in reverse order. 205 */ 206 toReversed(): Int8Array<ArrayBuffer>; 207 208 /** 209 * Copies and sorts the array. 210 * @param compareFn Function used to determine the order of the elements. It is expected to return 211 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 212 * value otherwise. If omitted, the elements are sorted in ascending order. 213 * ```ts 214 * const myNums = Int8Array.from([11, 2, 22, 1]); 215 * myNums.toSorted((a, b) => a - b) // Int8Array(4) [1, 2, 11, 22] 216 * ``` 217 */ 218 toSorted(compareFn?: (a: number, b: number) => number): Int8Array<ArrayBuffer>; 219 220 /** 221 * Copies the array and inserts the given number at the provided index. 222 * @param index The index of the value to overwrite. If the index is 223 * negative, then it replaces from the end of the array. 224 * @param value The value to insert into the copied array. 225 * @returns A copy of the original array with the inserted value. 226 */ 227 with(index: number, value: number): Int8Array<ArrayBuffer>; 228 } 229 230 interface Uint8Array<TArrayBuffer extends ArrayBufferLike> { 231 /** 232 * Returns the value of the last element in the array where predicate is true, and undefined 233 * otherwise. 234 * @param predicate findLast calls predicate once for each element of the array, in descending 235 * order, until it finds one where predicate returns true. If such an element is found, findLast 236 * immediately returns that element value. Otherwise, findLast returns undefined. 237 * @param thisArg If provided, it will be used as the this value for each invocation of 238 * predicate. If it is not provided, undefined is used instead. 239 */ 240 findLast<S extends number>( 241 predicate: ( 242 value: number, 243 index: number, 244 array: this, 245 ) => value is S, 246 thisArg?: any, 247 ): S | undefined; 248 findLast( 249 predicate: (value: number, index: number, array: this) => unknown, 250 thisArg?: any, 251 ): number | undefined; 252 253 /** 254 * Returns the index of the last element in the array where predicate is true, and -1 255 * otherwise. 256 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 257 * order, until it finds one where predicate returns true. If such an element is found, 258 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 259 * @param thisArg If provided, it will be used as the this value for each invocation of 260 * predicate. If it is not provided, undefined is used instead. 261 */ 262 findLastIndex( 263 predicate: (value: number, index: number, array: this) => unknown, 264 thisArg?: any, 265 ): number; 266 267 /** 268 * Copies the array and returns the copy with the elements in reverse order. 269 */ 270 toReversed(): Uint8Array<ArrayBuffer>; 271 272 /** 273 * Copies and sorts the array. 274 * @param compareFn Function used to determine the order of the elements. It is expected to return 275 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 276 * value otherwise. If omitted, the elements are sorted in ascending order. 277 * ```ts 278 * const myNums = Uint8Array.from([11, 2, 22, 1]); 279 * myNums.toSorted((a, b) => a - b) // Uint8Array(4) [1, 2, 11, 22] 280 * ``` 281 */ 282 toSorted(compareFn?: (a: number, b: number) => number): Uint8Array<ArrayBuffer>; 283 284 /** 285 * Copies the array and inserts the given number at the provided index. 286 * @param index The index of the value to overwrite. If the index is 287 * negative, then it replaces from the end of the array. 288 * @param value The value to insert into the copied array. 289 * @returns A copy of the original array with the inserted value. 290 */ 291 with(index: number, value: number): Uint8Array<ArrayBuffer>; 292 } 293 294 interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> { 295 /** 296 * Returns the value of the last element in the array where predicate is true, and undefined 297 * otherwise. 298 * @param predicate findLast calls predicate once for each element of the array, in descending 299 * order, until it finds one where predicate returns true. If such an element is found, findLast 300 * immediately returns that element value. Otherwise, findLast returns undefined. 301 * @param thisArg If provided, it will be used as the this value for each invocation of 302 * predicate. If it is not provided, undefined is used instead. 303 */ 304 findLast<S extends number>( 305 predicate: ( 306 value: number, 307 index: number, 308 array: this, 309 ) => value is S, 310 thisArg?: any, 311 ): S | undefined; 312 findLast( 313 predicate: ( 314 value: number, 315 index: number, 316 array: this, 317 ) => unknown, 318 thisArg?: any, 319 ): number | undefined; 320 321 /** 322 * Returns the index of the last element in the array where predicate is true, and -1 323 * otherwise. 324 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 325 * order, until it finds one where predicate returns true. If such an element is found, 326 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 327 * @param thisArg If provided, it will be used as the this value for each invocation of 328 * predicate. If it is not provided, undefined is used instead. 329 */ 330 findLastIndex( 331 predicate: ( 332 value: number, 333 index: number, 334 array: this, 335 ) => unknown, 336 thisArg?: any, 337 ): number; 338 339 /** 340 * Copies the array and returns the copy with the elements in reverse order. 341 */ 342 toReversed(): Uint8ClampedArray<ArrayBuffer>; 343 344 /** 345 * Copies and sorts the array. 346 * @param compareFn Function used to determine the order of the elements. It is expected to return 347 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 348 * value otherwise. If omitted, the elements are sorted in ascending order. 349 * ```ts 350 * const myNums = Uint8ClampedArray.from([11, 2, 22, 1]); 351 * myNums.toSorted((a, b) => a - b) // Uint8ClampedArray(4) [1, 2, 11, 22] 352 * ``` 353 */ 354 toSorted(compareFn?: (a: number, b: number) => number): Uint8ClampedArray<ArrayBuffer>; 355 356 /** 357 * Copies the array and inserts the given number at the provided index. 358 * @param index The index of the value to overwrite. If the index is 359 * negative, then it replaces from the end of the array. 360 * @param value The value to insert into the copied array. 361 * @returns A copy of the original array with the inserted value. 362 */ 363 with(index: number, value: number): Uint8ClampedArray<ArrayBuffer>; 364 } 365 366 interface Int16Array<TArrayBuffer extends ArrayBufferLike> { 367 /** 368 * Returns the value of the last element in the array where predicate is true, and undefined 369 * otherwise. 370 * @param predicate findLast calls predicate once for each element of the array, in descending 371 * order, until it finds one where predicate returns true. If such an element is found, findLast 372 * immediately returns that element value. Otherwise, findLast returns undefined. 373 * @param thisArg If provided, it will be used as the this value for each invocation of 374 * predicate. If it is not provided, undefined is used instead. 375 */ 376 findLast<S extends number>( 377 predicate: ( 378 value: number, 379 index: number, 380 array: this, 381 ) => value is S, 382 thisArg?: any, 383 ): S | undefined; 384 findLast( 385 predicate: (value: number, index: number, array: this) => unknown, 386 thisArg?: any, 387 ): number | undefined; 388 389 /** 390 * Returns the index of the last element in the array where predicate is true, and -1 391 * otherwise. 392 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 393 * order, until it finds one where predicate returns true. If such an element is found, 394 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 395 * @param thisArg If provided, it will be used as the this value for each invocation of 396 * predicate. If it is not provided, undefined is used instead. 397 */ 398 findLastIndex( 399 predicate: (value: number, index: number, array: this) => unknown, 400 thisArg?: any, 401 ): number; 402 403 /** 404 * Copies the array and returns the copy with the elements in reverse order. 405 */ 406 toReversed(): Int16Array<ArrayBuffer>; 407 408 /** 409 * Copies and sorts the array. 410 * @param compareFn Function used to determine the order of the elements. It is expected to return 411 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 412 * value otherwise. If omitted, the elements are sorted in ascending order. 413 * ```ts 414 * const myNums = Int16Array.from([11, 2, -22, 1]); 415 * myNums.toSorted((a, b) => a - b) // Int16Array(4) [-22, 1, 2, 11] 416 * ``` 417 */ 418 toSorted(compareFn?: (a: number, b: number) => number): Int16Array<ArrayBuffer>; 419 420 /** 421 * Copies the array and inserts the given number at the provided index. 422 * @param index The index of the value to overwrite. If the index is 423 * negative, then it replaces from the end of the array. 424 * @param value The value to insert into the copied array. 425 * @returns A copy of the original array with the inserted value. 426 */ 427 with(index: number, value: number): Int16Array<ArrayBuffer>; 428 } 429 430 interface Uint16Array<TArrayBuffer extends ArrayBufferLike> { 431 /** 432 * Returns the value of the last element in the array where predicate is true, and undefined 433 * otherwise. 434 * @param predicate findLast calls predicate once for each element of the array, in descending 435 * order, until it finds one where predicate returns true. If such an element is found, findLast 436 * immediately returns that element value. Otherwise, findLast returns undefined. 437 * @param thisArg If provided, it will be used as the this value for each invocation of 438 * predicate. If it is not provided, undefined is used instead. 439 */ 440 findLast<S extends number>( 441 predicate: ( 442 value: number, 443 index: number, 444 array: this, 445 ) => value is S, 446 thisArg?: any, 447 ): S | undefined; 448 findLast( 449 predicate: ( 450 value: number, 451 index: number, 452 array: this, 453 ) => unknown, 454 thisArg?: any, 455 ): number | undefined; 456 457 /** 458 * Returns the index of the last element in the array where predicate is true, and -1 459 * otherwise. 460 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 461 * order, until it finds one where predicate returns true. If such an element is found, 462 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 463 * @param thisArg If provided, it will be used as the this value for each invocation of 464 * predicate. If it is not provided, undefined is used instead. 465 */ 466 findLastIndex( 467 predicate: ( 468 value: number, 469 index: number, 470 array: this, 471 ) => unknown, 472 thisArg?: any, 473 ): number; 474 475 /** 476 * Copies the array and returns the copy with the elements in reverse order. 477 */ 478 toReversed(): Uint16Array<ArrayBuffer>; 479 480 /** 481 * Copies and sorts the array. 482 * @param compareFn Function used to determine the order of the elements. It is expected to return 483 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 484 * value otherwise. If omitted, the elements are sorted in ascending order. 485 * ```ts 486 * const myNums = Uint16Array.from([11, 2, 22, 1]); 487 * myNums.toSorted((a, b) => a - b) // Uint16Array(4) [1, 2, 11, 22] 488 * ``` 489 */ 490 toSorted(compareFn?: (a: number, b: number) => number): Uint16Array<ArrayBuffer>; 491 492 /** 493 * Copies the array and inserts the given number at the provided index. 494 * @param index The index of the value to overwrite. If the index is 495 * negative, then it replaces from the end of the array. 496 * @param value The value to insert into the copied array. 497 * @returns A copy of the original array with the inserted value. 498 */ 499 with(index: number, value: number): Uint16Array<ArrayBuffer>; 500 } 501 502 interface Int32Array<TArrayBuffer extends ArrayBufferLike> { 503 /** 504 * Returns the value of the last element in the array where predicate is true, and undefined 505 * otherwise. 506 * @param predicate findLast calls predicate once for each element of the array, in descending 507 * order, until it finds one where predicate returns true. If such an element is found, findLast 508 * immediately returns that element value. Otherwise, findLast returns undefined. 509 * @param thisArg If provided, it will be used as the this value for each invocation of 510 * predicate. If it is not provided, undefined is used instead. 511 */ 512 findLast<S extends number>( 513 predicate: ( 514 value: number, 515 index: number, 516 array: this, 517 ) => value is S, 518 thisArg?: any, 519 ): S | undefined; 520 findLast( 521 predicate: (value: number, index: number, array: this) => unknown, 522 thisArg?: any, 523 ): number | undefined; 524 525 /** 526 * Returns the index of the last element in the array where predicate is true, and -1 527 * otherwise. 528 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 529 * order, until it finds one where predicate returns true. If such an element is found, 530 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 531 * @param thisArg If provided, it will be used as the this value for each invocation of 532 * predicate. If it is not provided, undefined is used instead. 533 */ 534 findLastIndex( 535 predicate: (value: number, index: number, array: this) => unknown, 536 thisArg?: any, 537 ): number; 538 539 /** 540 * Copies the array and returns the copy with the elements in reverse order. 541 */ 542 toReversed(): Int32Array<ArrayBuffer>; 543 544 /** 545 * Copies and sorts the array. 546 * @param compareFn Function used to determine the order of the elements. It is expected to return 547 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 548 * value otherwise. If omitted, the elements are sorted in ascending order. 549 * ```ts 550 * const myNums = Int32Array.from([11, 2, -22, 1]); 551 * myNums.toSorted((a, b) => a - b) // Int32Array(4) [-22, 1, 2, 11] 552 * ``` 553 */ 554 toSorted(compareFn?: (a: number, b: number) => number): Int32Array<ArrayBuffer>; 555 556 /** 557 * Copies the array and inserts the given number at the provided index. 558 * @param index The index of the value to overwrite. If the index is 559 * negative, then it replaces from the end of the array. 560 * @param value The value to insert into the copied array. 561 * @returns A copy of the original array with the inserted value. 562 */ 563 with(index: number, value: number): Int32Array<ArrayBuffer>; 564 } 565 566 interface Uint32Array<TArrayBuffer extends ArrayBufferLike> { 567 /** 568 * Returns the value of the last element in the array where predicate is true, and undefined 569 * otherwise. 570 * @param predicate findLast calls predicate once for each element of the array, in descending 571 * order, until it finds one where predicate returns true. If such an element is found, findLast 572 * immediately returns that element value. Otherwise, findLast returns undefined. 573 * @param thisArg If provided, it will be used as the this value for each invocation of 574 * predicate. If it is not provided, undefined is used instead. 575 */ 576 findLast<S extends number>( 577 predicate: ( 578 value: number, 579 index: number, 580 array: this, 581 ) => value is S, 582 thisArg?: any, 583 ): S | undefined; 584 findLast( 585 predicate: ( 586 value: number, 587 index: number, 588 array: this, 589 ) => unknown, 590 thisArg?: any, 591 ): number | undefined; 592 593 /** 594 * Returns the index of the last element in the array where predicate is true, and -1 595 * otherwise. 596 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 597 * order, until it finds one where predicate returns true. If such an element is found, 598 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 599 * @param thisArg If provided, it will be used as the this value for each invocation of 600 * predicate. If it is not provided, undefined is used instead. 601 */ 602 findLastIndex( 603 predicate: ( 604 value: number, 605 index: number, 606 array: this, 607 ) => unknown, 608 thisArg?: any, 609 ): number; 610 611 /** 612 * Copies the array and returns the copy with the elements in reverse order. 613 */ 614 toReversed(): Uint32Array<ArrayBuffer>; 615 616 /** 617 * Copies and sorts the array. 618 * @param compareFn Function used to determine the order of the elements. It is expected to return 619 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 620 * value otherwise. If omitted, the elements are sorted in ascending order. 621 * ```ts 622 * const myNums = Uint32Array.from([11, 2, 22, 1]); 623 * myNums.toSorted((a, b) => a - b) // Uint32Array(4) [1, 2, 11, 22] 624 * ``` 625 */ 626 toSorted(compareFn?: (a: number, b: number) => number): Uint32Array<ArrayBuffer>; 627 628 /** 629 * Copies the array and inserts the given number at the provided index. 630 * @param index The index of the value to overwrite. If the index is 631 * negative, then it replaces from the end of the array. 632 * @param value The value to insert into the copied array. 633 * @returns A copy of the original array with the inserted value. 634 */ 635 with(index: number, value: number): Uint32Array<ArrayBuffer>; 636 } 637 638 interface Float32Array<TArrayBuffer extends ArrayBufferLike> { 639 /** 640 * Returns the value of the last element in the array where predicate is true, and undefined 641 * otherwise. 642 * @param predicate findLast calls predicate once for each element of the array, in descending 643 * order, until it finds one where predicate returns true. If such an element is found, findLast 644 * immediately returns that element value. Otherwise, findLast returns undefined. 645 * @param thisArg If provided, it will be used as the this value for each invocation of 646 * predicate. If it is not provided, undefined is used instead. 647 */ 648 findLast<S extends number>( 649 predicate: ( 650 value: number, 651 index: number, 652 array: this, 653 ) => value is S, 654 thisArg?: any, 655 ): S | undefined; 656 findLast( 657 predicate: ( 658 value: number, 659 index: number, 660 array: this, 661 ) => unknown, 662 thisArg?: any, 663 ): number | undefined; 664 665 /** 666 * Returns the index of the last element in the array where predicate is true, and -1 667 * otherwise. 668 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 669 * order, until it finds one where predicate returns true. If such an element is found, 670 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 671 * @param thisArg If provided, it will be used as the this value for each invocation of 672 * predicate. If it is not provided, undefined is used instead. 673 */ 674 findLastIndex( 675 predicate: ( 676 value: number, 677 index: number, 678 array: this, 679 ) => unknown, 680 thisArg?: any, 681 ): number; 682 683 /** 684 * Copies the array and returns the copy with the elements in reverse order. 685 */ 686 toReversed(): Float32Array<ArrayBuffer>; 687 688 /** 689 * Copies and sorts the array. 690 * @param compareFn Function used to determine the order of the elements. It is expected to return 691 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 692 * value otherwise. If omitted, the elements are sorted in ascending order. 693 * ```ts 694 * const myNums = Float32Array.from([11.25, 2, -22.5, 1]); 695 * myNums.toSorted((a, b) => a - b) // Float32Array(4) [-22.5, 1, 2, 11.5] 696 * ``` 697 */ 698 toSorted(compareFn?: (a: number, b: number) => number): Float32Array<ArrayBuffer>; 699 700 /** 701 * Copies the array and inserts the given number at the provided index. 702 * @param index The index of the value to overwrite. If the index is 703 * negative, then it replaces from the end of the array. 704 * @param value The value to insert into the copied array. 705 * @returns A copy of the original array with the inserted value. 706 */ 707 with(index: number, value: number): Float32Array<ArrayBuffer>; 708 } 709 710 interface Float64Array<TArrayBuffer extends ArrayBufferLike> { 711 /** 712 * Returns the value of the last element in the array where predicate is true, and undefined 713 * otherwise. 714 * @param predicate findLast calls predicate once for each element of the array, in descending 715 * order, until it finds one where predicate returns true. If such an element is found, findLast 716 * immediately returns that element value. Otherwise, findLast returns undefined. 717 * @param thisArg If provided, it will be used as the this value for each invocation of 718 * predicate. If it is not provided, undefined is used instead. 719 */ 720 findLast<S extends number>( 721 predicate: ( 722 value: number, 723 index: number, 724 array: this, 725 ) => value is S, 726 thisArg?: any, 727 ): S | undefined; 728 findLast( 729 predicate: ( 730 value: number, 731 index: number, 732 array: this, 733 ) => unknown, 734 thisArg?: any, 735 ): number | undefined; 736 737 /** 738 * Returns the index of the last element in the array where predicate is true, and -1 739 * otherwise. 740 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 741 * order, until it finds one where predicate returns true. If such an element is found, 742 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 743 * @param thisArg If provided, it will be used as the this value for each invocation of 744 * predicate. If it is not provided, undefined is used instead. 745 */ 746 findLastIndex( 747 predicate: ( 748 value: number, 749 index: number, 750 array: this, 751 ) => unknown, 752 thisArg?: any, 753 ): number; 754 755 /** 756 * Copies the array and returns the copy with the elements in reverse order. 757 */ 758 toReversed(): Float64Array<ArrayBuffer>; 759 760 /** 761 * Copies and sorts the array. 762 * @param compareFn Function used to determine the order of the elements. It is expected to return 763 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 764 * value otherwise. If omitted, the elements are sorted in ascending order. 765 * ```ts 766 * const myNums = Float64Array.from([11.25, 2, -22.5, 1]); 767 * myNums.toSorted((a, b) => a - b) // Float64Array(4) [-22.5, 1, 2, 11.5] 768 * ``` 769 */ 770 toSorted(compareFn?: (a: number, b: number) => number): Float64Array<ArrayBuffer>; 771 772 /** 773 * Copies the array and inserts the given number at the provided index. 774 * @param index The index of the value to overwrite. If the index is 775 * negative, then it replaces from the end of the array. 776 * @param value The value to insert into the copied array. 777 * @returns A copy of the original array with the inserted value. 778 */ 779 with(index: number, value: number): Float64Array<ArrayBuffer>; 780 } 781 782 interface BigInt64Array<TArrayBuffer extends ArrayBufferLike> { 783 /** 784 * Returns the value of the last element in the array where predicate is true, and undefined 785 * otherwise. 786 * @param predicate findLast calls predicate once for each element of the array, in descending 787 * order, until it finds one where predicate returns true. If such an element is found, findLast 788 * immediately returns that element value. Otherwise, findLast returns undefined. 789 * @param thisArg If provided, it will be used as the this value for each invocation of 790 * predicate. If it is not provided, undefined is used instead. 791 */ 792 findLast<S extends bigint>( 793 predicate: ( 794 value: bigint, 795 index: number, 796 array: this, 797 ) => value is S, 798 thisArg?: any, 799 ): S | undefined; 800 findLast( 801 predicate: ( 802 value: bigint, 803 index: number, 804 array: this, 805 ) => unknown, 806 thisArg?: any, 807 ): bigint | undefined; 808 809 /** 810 * Returns the index of the last element in the array where predicate is true, and -1 811 * otherwise. 812 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 813 * order, until it finds one where predicate returns true. If such an element is found, 814 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 815 * @param thisArg If provided, it will be used as the this value for each invocation of 816 * predicate. If it is not provided, undefined is used instead. 817 */ 818 findLastIndex( 819 predicate: ( 820 value: bigint, 821 index: number, 822 array: this, 823 ) => unknown, 824 thisArg?: any, 825 ): number; 826 827 /** 828 * Copies the array and returns the copy with the elements in reverse order. 829 */ 830 toReversed(): BigInt64Array<ArrayBuffer>; 831 832 /** 833 * Copies and sorts the array. 834 * @param compareFn Function used to determine the order of the elements. It is expected to return 835 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 836 * value otherwise. If omitted, the elements are sorted in ascending order. 837 * ```ts 838 * const myNums = BigInt64Array.from([11n, 2n, -22n, 1n]); 839 * myNums.toSorted((a, b) => Number(a - b)) // BigInt64Array(4) [-22n, 1n, 2n, 11n] 840 * ``` 841 */ 842 toSorted(compareFn?: (a: bigint, b: bigint) => number): BigInt64Array<ArrayBuffer>; 843 844 /** 845 * Copies the array and inserts the given bigint at the provided index. 846 * @param index The index of the value to overwrite. If the index is 847 * negative, then it replaces from the end of the array. 848 * @param value The value to insert into the copied array. 849 * @returns A copy of the original array with the inserted value. 850 */ 851 with(index: number, value: bigint): BigInt64Array<ArrayBuffer>; 852 } 853 854 interface BigUint64Array<TArrayBuffer extends ArrayBufferLike> { 855 /** 856 * Returns the value of the last element in the array where predicate is true, and undefined 857 * otherwise. 858 * @param predicate findLast calls predicate once for each element of the array, in descending 859 * order, until it finds one where predicate returns true. If such an element is found, findLast 860 * immediately returns that element value. Otherwise, findLast returns undefined. 861 * @param thisArg If provided, it will be used as the this value for each invocation of 862 * predicate. If it is not provided, undefined is used instead. 863 */ 864 findLast<S extends bigint>( 865 predicate: ( 866 value: bigint, 867 index: number, 868 array: this, 869 ) => value is S, 870 thisArg?: any, 871 ): S | undefined; 872 findLast( 873 predicate: ( 874 value: bigint, 875 index: number, 876 array: this, 877 ) => unknown, 878 thisArg?: any, 879 ): bigint | undefined; 880 881 /** 882 * Returns the index of the last element in the array where predicate is true, and -1 883 * otherwise. 884 * @param predicate findLastIndex calls predicate once for each element of the array, in descending 885 * order, until it finds one where predicate returns true. If such an element is found, 886 * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1. 887 * @param thisArg If provided, it will be used as the this value for each invocation of 888 * predicate. If it is not provided, undefined is used instead. 889 */ 890 findLastIndex( 891 predicate: ( 892 value: bigint, 893 index: number, 894 array: this, 895 ) => unknown, 896 thisArg?: any, 897 ): number; 898 899 /** 900 * Copies the array and returns the copy with the elements in reverse order. 901 */ 902 toReversed(): BigUint64Array<ArrayBuffer>; 903 904 /** 905 * Copies and sorts the array. 906 * @param compareFn Function used to determine the order of the elements. It is expected to return 907 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive 908 * value otherwise. If omitted, the elements are sorted in ascending order. 909 * ```ts 910 * const myNums = BigUint64Array.from([11n, 2n, 22n, 1n]); 911 * myNums.toSorted((a, b) => Number(a - b)) // BigUint64Array(4) [1n, 2n, 11n, 22n] 912 * ``` 913 */ 914 toSorted(compareFn?: (a: bigint, b: bigint) => number): BigUint64Array<ArrayBuffer>; 915 916 /** 917 * Copies the array and inserts the given bigint at the provided index. 918 * @param index The index of the value to overwrite. If the index is 919 * negative, then it replaces from the end of the array. 920 * @param value The value to insert into the copied array. 921 * @returns A copy of the original array with the inserted value. 922 */ 923 with(index: number, value: bigint): BigUint64Array<ArrayBuffer>; 924 }