Pinsave/counterstrike
1
1/*! *****************************************************************************2Copyright (c) Microsoft Corporation. All rights reserved.3Licensed under the Apache License, Version 2.0 (the "License"); you may not use4this file except in compliance with the License. You may obtain a copy of the5License at http://www.apache.org/licenses/LICENSE-2.06 7THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY8KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED9WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,10MERCHANTABLITY OR NON-INFRINGEMENT.11 12See the Apache Version 2.0 License for specific language governing permissions13and limitations under the License.14***************************************************************************** */15 16 17/// <reference no-default-lib="true"/>18 19interface Array<T> {20 /**21 * Returns the value of the last element in the array where predicate is true, and undefined22 * otherwise.23 * @param predicate findLast calls predicate once for each element of the array, in descending24 * order, until it finds one where predicate returns true. If such an element is found, findLast25 * 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 of27 * 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 -134 * otherwise.35 * @param predicate findLastIndex calls predicate once for each element of the array, in descending36 * 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 of39 * 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 return51 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive52 * value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.53 * ```ts54 * [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 the78 * given value. If the index is negative, then it replaces from the end79 * of the array.80 * @param index The index of the value to overwrite. If the index is81 * 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 88interface ReadonlyArray<T> {89 /**90 * Returns the value of the last element in the array where predicate is true, and undefined91 * otherwise.92 * @param predicate findLast calls predicate once for each element of the array, in descending93 * order, until it finds one where predicate returns true. If such an element is found, findLast94 * 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 of96 * 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 -1109 * otherwise.110 * @param predicate findLastIndex calls predicate once for each element of the array, in descending111 * 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 of114 * 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 return129 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive130 * value otherwise. If omitted, the elements are sorted in ascending, UTF-16 code unit order.131 * ```ts132 * [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 the156 * given value. If the index is negative, then it replaces from the end157 * of the array158 * @param index The index of the value to overwrite. If the index is159 * 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 166interface Int8Array<TArrayBuffer extends ArrayBufferLike> {167 /**168 * Returns the value of the last element in the array where predicate is true, and undefined169 * otherwise.170 * @param predicate findLast calls predicate once for each element of the array, in descending171 * order, until it finds one where predicate returns true. If such an element is found, findLast172 * 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 of174 * 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 -1191 * otherwise.192 * @param predicate findLastIndex calls predicate once for each element of the array, in descending193 * 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 of196 * 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 return211 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive212 * value otherwise. If omitted, the elements are sorted in ascending order.213 * ```ts214 * 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 is223 * 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 230interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {231 /**232 * Returns the value of the last element in the array where predicate is true, and undefined233 * otherwise.234 * @param predicate findLast calls predicate once for each element of the array, in descending235 * order, until it finds one where predicate returns true. If such an element is found, findLast236 * 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 of238 * 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 -1255 * otherwise.256 * @param predicate findLastIndex calls predicate once for each element of the array, in descending257 * 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 of260 * 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 return275 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive276 * value otherwise. If omitted, the elements are sorted in ascending order.277 * ```ts278 * 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 is287 * 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 294interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {295 /**296 * Returns the value of the last element in the array where predicate is true, and undefined297 * otherwise.298 * @param predicate findLast calls predicate once for each element of the array, in descending299 * order, until it finds one where predicate returns true. If such an element is found, findLast300 * 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 of302 * 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 -1323 * otherwise.324 * @param predicate findLastIndex calls predicate once for each element of the array, in descending325 * 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 of328 * 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 return347 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive348 * value otherwise. If omitted, the elements are sorted in ascending order.349 * ```ts350 * 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 is359 * 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 366interface Int16Array<TArrayBuffer extends ArrayBufferLike> {367 /**368 * Returns the value of the last element in the array where predicate is true, and undefined369 * otherwise.370 * @param predicate findLast calls predicate once for each element of the array, in descending371 * order, until it finds one where predicate returns true. If such an element is found, findLast372 * 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 of374 * 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 -1391 * otherwise.392 * @param predicate findLastIndex calls predicate once for each element of the array, in descending393 * 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 of396 * 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 return411 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive412 * value otherwise. If omitted, the elements are sorted in ascending order.413 * ```ts414 * 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 is423 * 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 430interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {431 /**432 * Returns the value of the last element in the array where predicate is true, and undefined433 * otherwise.434 * @param predicate findLast calls predicate once for each element of the array, in descending435 * order, until it finds one where predicate returns true. If such an element is found, findLast436 * 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 of438 * 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 -1459 * otherwise.460 * @param predicate findLastIndex calls predicate once for each element of the array, in descending461 * 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 of464 * 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 return483 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive484 * value otherwise. If omitted, the elements are sorted in ascending order.485 * ```ts486 * 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 is495 * 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 502interface Int32Array<TArrayBuffer extends ArrayBufferLike> {503 /**504 * Returns the value of the last element in the array where predicate is true, and undefined505 * otherwise.506 * @param predicate findLast calls predicate once for each element of the array, in descending507 * order, until it finds one where predicate returns true. If such an element is found, findLast508 * 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 of510 * 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 -1527 * otherwise.528 * @param predicate findLastIndex calls predicate once for each element of the array, in descending529 * 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 of532 * 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 return547 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive548 * value otherwise. If omitted, the elements are sorted in ascending order.549 * ```ts550 * 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 is559 * 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 566interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {567 /**568 * Returns the value of the last element in the array where predicate is true, and undefined569 * otherwise.570 * @param predicate findLast calls predicate once for each element of the array, in descending571 * order, until it finds one where predicate returns true. If such an element is found, findLast572 * 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 of574 * 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 -1595 * otherwise.596 * @param predicate findLastIndex calls predicate once for each element of the array, in descending597 * 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 of600 * 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 return619 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive620 * value otherwise. If omitted, the elements are sorted in ascending order.621 * ```ts622 * 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 is631 * 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 638interface Float32Array<TArrayBuffer extends ArrayBufferLike> {639 /**640 * Returns the value of the last element in the array where predicate is true, and undefined641 * otherwise.642 * @param predicate findLast calls predicate once for each element of the array, in descending643 * order, until it finds one where predicate returns true. If such an element is found, findLast644 * 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 of646 * 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 -1667 * otherwise.668 * @param predicate findLastIndex calls predicate once for each element of the array, in descending669 * 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 of672 * 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 return691 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive692 * value otherwise. If omitted, the elements are sorted in ascending order.693 * ```ts694 * 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 is703 * 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 710interface Float64Array<TArrayBuffer extends ArrayBufferLike> {711 /**712 * Returns the value of the last element in the array where predicate is true, and undefined713 * otherwise.714 * @param predicate findLast calls predicate once for each element of the array, in descending715 * order, until it finds one where predicate returns true. If such an element is found, findLast716 * 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 of718 * 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 -1739 * otherwise.740 * @param predicate findLastIndex calls predicate once for each element of the array, in descending741 * 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 of744 * 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 return763 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive764 * value otherwise. If omitted, the elements are sorted in ascending order.765 * ```ts766 * 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 is775 * 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 782interface BigInt64Array<TArrayBuffer extends ArrayBufferLike> {783 /**784 * Returns the value of the last element in the array where predicate is true, and undefined785 * otherwise.786 * @param predicate findLast calls predicate once for each element of the array, in descending787 * order, until it finds one where predicate returns true. If such an element is found, findLast788 * 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 of790 * 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 -1811 * otherwise.812 * @param predicate findLastIndex calls predicate once for each element of the array, in descending813 * 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 of816 * 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 return835 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive836 * value otherwise. If omitted, the elements are sorted in ascending order.837 * ```ts838 * 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 is847 * 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 854interface BigUint64Array<TArrayBuffer extends ArrayBufferLike> {855 /**856 * Returns the value of the last element in the array where predicate is true, and undefined857 * otherwise.858 * @param predicate findLast calls predicate once for each element of the array, in descending859 * order, until it finds one where predicate returns true. If such an element is found, findLast860 * 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 of862 * 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 -1883 * otherwise.884 * @param predicate findLastIndex calls predicate once for each element of the array, in descending885 * 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 of888 * 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 return907 * a negative value if the first argument is less than the second argument, zero if they're equal, and a positive908 * value otherwise. If omitted, the elements are sorted in ascending order.909 * ```ts910 * 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 is919 * 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}925