lib.es2020.bigint.d.ts (38185B)
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 /// <reference lib="es2020.intl" /> 20 21 interface BigIntToLocaleStringOptions { 22 /** 23 * The locale matching algorithm to use.The default is "best fit". For information about this option, see the {@link https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation Intl page}. 24 */ 25 localeMatcher?: string; 26 /** 27 * The formatting style to use , the default is "decimal". 28 */ 29 style?: string; 30 31 numberingSystem?: string; 32 /** 33 * The unit to use in unit formatting, Possible values are core unit identifiers, defined in UTS #35, Part 2, Section 6. A subset of units from the full list was selected for use in ECMAScript. Pairs of simple units can be concatenated with "-per-" to make a compound unit. There is no default value; if the style is "unit", the unit property must be provided. 34 */ 35 unit?: string; 36 37 /** 38 * The unit formatting style to use in unit formatting, the defaults is "short". 39 */ 40 unitDisplay?: string; 41 42 /** 43 * The currency to use in currency formatting. Possible values are the ISO 4217 currency codes, such as "USD" for the US dollar, "EUR" for the euro, or "CNY" for the Chinese RMB — see the Current currency & funds code list. There is no default value; if the style is "currency", the currency property must be provided. It is only used when [[Style]] has the value "currency". 44 */ 45 currency?: string; 46 47 /** 48 * How to display the currency in currency formatting. It is only used when [[Style]] has the value "currency". The default is "symbol". 49 * 50 * "symbol" to use a localized currency symbol such as €, 51 * 52 * "code" to use the ISO currency code, 53 * 54 * "name" to use a localized currency name such as "dollar" 55 */ 56 currencyDisplay?: string; 57 58 /** 59 * Whether to use grouping separators, such as thousands separators or thousand/lakh/crore separators. The default is true. 60 */ 61 useGrouping?: boolean; 62 63 /** 64 * The minimum number of integer digits to use. Possible values are from 1 to 21; the default is 1. 65 */ 66 minimumIntegerDigits?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21; 67 68 /** 69 * The minimum number of fraction digits to use. Possible values are from 0 to 20; the default for plain number and percent formatting is 0; the default for currency formatting is the number of minor unit digits provided by the {@link http://www.currency-iso.org/en/home/tables/table-a1.html ISO 4217 currency codes list} (2 if the list doesn't provide that information). 70 */ 71 minimumFractionDigits?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20; 72 73 /** 74 * The maximum number of fraction digits to use. Possible values are from 0 to 20; the default for plain number formatting is the larger of minimumFractionDigits and 3; the default for currency formatting is the larger of minimumFractionDigits and the number of minor unit digits provided by the {@link http://www.currency-iso.org/en/home/tables/table-a1.html ISO 4217 currency codes list} (2 if the list doesn't provide that information); the default for percent formatting is the larger of minimumFractionDigits and 0. 75 */ 76 maximumFractionDigits?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20; 77 78 /** 79 * The minimum number of significant digits to use. Possible values are from 1 to 21; the default is 1. 80 */ 81 minimumSignificantDigits?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21; 82 83 /** 84 * The maximum number of significant digits to use. Possible values are from 1 to 21; the default is 21. 85 */ 86 maximumSignificantDigits?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21; 87 88 /** 89 * The formatting that should be displayed for the number, the defaults is "standard" 90 * 91 * "standard" plain number formatting 92 * 93 * "scientific" return the order-of-magnitude for formatted number. 94 * 95 * "engineering" return the exponent of ten when divisible by three 96 * 97 * "compact" string representing exponent, defaults is using the "short" form 98 */ 99 notation?: string; 100 101 /** 102 * used only when notation is "compact" 103 */ 104 compactDisplay?: string; 105 } 106 107 interface BigInt { 108 /** 109 * Returns a string representation of an object. 110 * @param radix Specifies a radix for converting numeric values to strings. 111 */ 112 toString(radix?: number): string; 113 114 /** Returns a string representation appropriate to the host environment's current locale. */ 115 toLocaleString(locales?: Intl.LocalesArgument, options?: BigIntToLocaleStringOptions): string; 116 117 /** Returns the primitive value of the specified object. */ 118 valueOf(): bigint; 119 120 readonly [Symbol.toStringTag]: "BigInt"; 121 } 122 123 interface BigIntConstructor { 124 (value: bigint | boolean | number | string): bigint; 125 readonly prototype: BigInt; 126 127 /** 128 * Interprets the low bits of a BigInt as a 2's-complement signed integer. 129 * All higher bits are discarded. 130 * @param bits The number of low bits to use 131 * @param int The BigInt whose bits to extract 132 */ 133 asIntN(bits: number, int: bigint): bigint; 134 /** 135 * Interprets the low bits of a BigInt as an unsigned integer. 136 * All higher bits are discarded. 137 * @param bits The number of low bits to use 138 * @param int The BigInt whose bits to extract 139 */ 140 asUintN(bits: number, int: bigint): bigint; 141 } 142 143 declare var BigInt: BigIntConstructor; 144 145 /** 146 * A typed array of 64-bit signed integer values. The contents are initialized to 0. If the 147 * requested number of bytes could not be allocated, an exception is raised. 148 */ 149 interface BigInt64Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> { 150 /** The size in bytes of each element in the array. */ 151 readonly BYTES_PER_ELEMENT: number; 152 153 /** The ArrayBuffer instance referenced by the array. */ 154 readonly buffer: TArrayBuffer; 155 156 /** The length in bytes of the array. */ 157 readonly byteLength: number; 158 159 /** The offset in bytes of the array. */ 160 readonly byteOffset: number; 161 162 /** 163 * Returns the this object after copying a section of the array identified by start and end 164 * to the same array starting at position target 165 * @param target If target is negative, it is treated as length+target where length is the 166 * length of the array. 167 * @param start If start is negative, it is treated as length+start. If end is negative, it 168 * is treated as length+end. 169 * @param end If not specified, length of the this object is used as its default value. 170 */ 171 copyWithin(target: number, start: number, end?: number): this; 172 173 /** Yields index, value pairs for every entry in the array. */ 174 entries(): ArrayIterator<[number, bigint]>; 175 176 /** 177 * Determines whether all the members of an array satisfy the specified test. 178 * @param predicate A function that accepts up to three arguments. The every method calls 179 * the predicate function for each element in the array until the predicate returns false, 180 * or until the end of the array. 181 * @param thisArg An object to which the this keyword can refer in the predicate function. 182 * If thisArg is omitted, undefined is used as the this value. 183 */ 184 every(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => boolean, thisArg?: any): boolean; 185 186 /** 187 * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array 188 * @param value value to fill array section with 189 * @param start index to start filling the array at. If start is negative, it is treated as 190 * length+start where length is the length of the array. 191 * @param end index to stop filling the array at. If end is negative, it is treated as 192 * length+end. 193 */ 194 fill(value: bigint, start?: number, end?: number): this; 195 196 /** 197 * Returns the elements of an array that meet the condition specified in a callback function. 198 * @param predicate A function that accepts up to three arguments. The filter method calls 199 * the predicate function one time for each element in the array. 200 * @param thisArg An object to which the this keyword can refer in the predicate function. 201 * If thisArg is omitted, undefined is used as the this value. 202 */ 203 filter(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => any, thisArg?: any): BigInt64Array<ArrayBuffer>; 204 205 /** 206 * Returns the value of the first element in the array where predicate is true, and undefined 207 * otherwise. 208 * @param predicate find calls predicate once for each element of the array, in ascending 209 * order, until it finds one where predicate returns true. If such an element is found, find 210 * immediately returns that element value. Otherwise, find returns undefined. 211 * @param thisArg If provided, it will be used as the this value for each invocation of 212 * predicate. If it is not provided, undefined is used instead. 213 */ 214 find(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => boolean, thisArg?: any): bigint | undefined; 215 216 /** 217 * Returns the index of the first element in the array where predicate is true, and -1 218 * otherwise. 219 * @param predicate find calls predicate once for each element of the array, in ascending 220 * order, until it finds one where predicate returns true. If such an element is found, 221 * findIndex immediately returns that element index. Otherwise, findIndex returns -1. 222 * @param thisArg If provided, it will be used as the this value for each invocation of 223 * predicate. If it is not provided, undefined is used instead. 224 */ 225 findIndex(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => boolean, thisArg?: any): number; 226 227 /** 228 * Performs the specified action for each element in an array. 229 * @param callbackfn A function that accepts up to three arguments. forEach calls the 230 * callbackfn function one time for each element in the array. 231 * @param thisArg An object to which the this keyword can refer in the callbackfn function. 232 * If thisArg is omitted, undefined is used as the this value. 233 */ 234 forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => void, thisArg?: any): void; 235 236 /** 237 * Determines whether an array includes a certain element, returning true or false as appropriate. 238 * @param searchElement The element to search for. 239 * @param fromIndex The position in this array at which to begin searching for searchElement. 240 */ 241 includes(searchElement: bigint, fromIndex?: number): boolean; 242 243 /** 244 * Returns the index of the first occurrence of a value in an array. 245 * @param searchElement The value to locate in the array. 246 * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the 247 * search starts at index 0. 248 */ 249 indexOf(searchElement: bigint, fromIndex?: number): number; 250 251 /** 252 * Adds all the elements of an array separated by the specified separator string. 253 * @param separator A string used to separate one element of an array from the next in the 254 * resulting String. If omitted, the array elements are separated with a comma. 255 */ 256 join(separator?: string): string; 257 258 /** Yields each index in the array. */ 259 keys(): ArrayIterator<number>; 260 261 /** 262 * Returns the index of the last occurrence of a value in an array. 263 * @param searchElement The value to locate in the array. 264 * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the 265 * search starts at index 0. 266 */ 267 lastIndexOf(searchElement: bigint, fromIndex?: number): number; 268 269 /** The length of the array. */ 270 readonly length: number; 271 272 /** 273 * Calls a defined callback function on each element of an array, and returns an array that 274 * contains the results. 275 * @param callbackfn A function that accepts up to three arguments. The map method calls the 276 * callbackfn function one time for each element in the array. 277 * @param thisArg An object to which the this keyword can refer in the callbackfn function. 278 * If thisArg is omitted, undefined is used as the this value. 279 */ 280 map(callbackfn: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => bigint, thisArg?: any): BigInt64Array<ArrayBuffer>; 281 282 /** 283 * Calls the specified callback function for all the elements in an array. The return value of 284 * the callback function is the accumulated result, and is provided as an argument in the next 285 * call to the callback function. 286 * @param callbackfn A function that accepts up to four arguments. The reduce method calls the 287 * callbackfn function one time for each element in the array. 288 * @param initialValue If initialValue is specified, it is used as the initial value to start 289 * the accumulation. The first call to the callbackfn function provides this value as an argument 290 * instead of an array value. 291 */ 292 reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array<TArrayBuffer>) => bigint): bigint; 293 294 /** 295 * Calls the specified callback function for all the elements in an array. The return value of 296 * the callback function is the accumulated result, and is provided as an argument in the next 297 * call to the callback function. 298 * @param callbackfn A function that accepts up to four arguments. The reduce method calls the 299 * callbackfn function one time for each element in the array. 300 * @param initialValue If initialValue is specified, it is used as the initial value to start 301 * the accumulation. The first call to the callbackfn function provides this value as an argument 302 * instead of an array value. 303 */ 304 reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array<TArrayBuffer>) => U, initialValue: U): U; 305 306 /** 307 * Calls the specified callback function for all the elements in an array, in descending order. 308 * The return value of the callback function is the accumulated result, and is provided as an 309 * argument in the next call to the callback function. 310 * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls 311 * the callbackfn function one time for each element in the array. 312 * @param initialValue If initialValue is specified, it is used as the initial value to start 313 * the accumulation. The first call to the callbackfn function provides this value as an 314 * argument instead of an array value. 315 */ 316 reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array<TArrayBuffer>) => bigint): bigint; 317 318 /** 319 * Calls the specified callback function for all the elements in an array, in descending order. 320 * The return value of the callback function is the accumulated result, and is provided as an 321 * argument in the next call to the callback function. 322 * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls 323 * the callbackfn function one time for each element in the array. 324 * @param initialValue If initialValue is specified, it is used as the initial value to start 325 * the accumulation. The first call to the callbackfn function provides this value as an argument 326 * instead of an array value. 327 */ 328 reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array<TArrayBuffer>) => U, initialValue: U): U; 329 330 /** Reverses the elements in the array. */ 331 reverse(): this; 332 333 /** 334 * Sets a value or an array of values. 335 * @param array A typed or untyped array of values to set. 336 * @param offset The index in the current array at which the values are to be written. 337 */ 338 set(array: ArrayLike<bigint>, offset?: number): void; 339 340 /** 341 * Returns a section of an array. 342 * @param start The beginning of the specified portion of the array. 343 * @param end The end of the specified portion of the array. 344 */ 345 slice(start?: number, end?: number): BigInt64Array<ArrayBuffer>; 346 347 /** 348 * Determines whether the specified callback function returns true for any element of an array. 349 * @param predicate A function that accepts up to three arguments. The some method calls the 350 * predicate function for each element in the array until the predicate returns true, or until 351 * the end of the array. 352 * @param thisArg An object to which the this keyword can refer in the predicate function. 353 * If thisArg is omitted, undefined is used as the this value. 354 */ 355 some(predicate: (value: bigint, index: number, array: BigInt64Array<TArrayBuffer>) => boolean, thisArg?: any): boolean; 356 357 /** 358 * Sorts the array. 359 * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order. 360 */ 361 sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this; 362 363 /** 364 * Gets a new BigInt64Array view of the ArrayBuffer store for this array, referencing the elements 365 * at begin, inclusive, up to end, exclusive. 366 * @param begin The index of the beginning of the array. 367 * @param end The index of the end of the array. 368 */ 369 subarray(begin?: number, end?: number): BigInt64Array<TArrayBuffer>; 370 371 /** Converts the array to a string by using the current locale. */ 372 toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions): string; 373 374 /** Returns a string representation of the array. */ 375 toString(): string; 376 377 /** Returns the primitive value of the specified object. */ 378 valueOf(): BigInt64Array<TArrayBuffer>; 379 380 /** Yields each value in the array. */ 381 values(): ArrayIterator<bigint>; 382 383 [Symbol.iterator](): ArrayIterator<bigint>; 384 385 readonly [Symbol.toStringTag]: "BigInt64Array"; 386 387 [index: number]: bigint; 388 } 389 interface BigInt64ArrayConstructor { 390 readonly prototype: BigInt64Array<ArrayBufferLike>; 391 new (length?: number): BigInt64Array<ArrayBuffer>; 392 new (array: ArrayLike<bigint> | Iterable<bigint>): BigInt64Array<ArrayBuffer>; 393 new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number): BigInt64Array<TArrayBuffer>; 394 new (buffer: ArrayBuffer, byteOffset?: number, length?: number): BigInt64Array<ArrayBuffer>; 395 new (array: ArrayLike<bigint> | ArrayBuffer): BigInt64Array<ArrayBuffer>; 396 397 /** The size in bytes of each element in the array. */ 398 readonly BYTES_PER_ELEMENT: number; 399 400 /** 401 * Returns a new array from a set of elements. 402 * @param items A set of elements to include in the new array object. 403 */ 404 of(...items: bigint[]): BigInt64Array<ArrayBuffer>; 405 406 /** 407 * Creates an array from an array-like or iterable object. 408 * @param arrayLike An array-like object to convert to an array. 409 */ 410 from(arrayLike: ArrayLike<bigint>): BigInt64Array<ArrayBuffer>; 411 412 /** 413 * Creates an array from an array-like or iterable object. 414 * @param arrayLike An array-like object to convert to an array. 415 * @param mapfn A mapping function to call on every element of the array. 416 * @param thisArg Value of 'this' used to invoke the mapfn. 417 */ 418 from<U>(arrayLike: ArrayLike<U>, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array<ArrayBuffer>; 419 420 /** 421 * Creates an array from an array-like or iterable object. 422 * @param elements An iterable object to convert to an array. 423 */ 424 from(elements: Iterable<bigint>): BigInt64Array<ArrayBuffer>; 425 426 /** 427 * Creates an array from an array-like or iterable object. 428 * @param elements An iterable object to convert to an array. 429 * @param mapfn A mapping function to call on every element of the array. 430 * @param thisArg Value of 'this' used to invoke the mapfn. 431 */ 432 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => bigint, thisArg?: any): BigInt64Array<ArrayBuffer>; 433 } 434 declare var BigInt64Array: BigInt64ArrayConstructor; 435 436 /** 437 * A typed array of 64-bit unsigned integer values. The contents are initialized to 0. If the 438 * requested number of bytes could not be allocated, an exception is raised. 439 */ 440 interface BigUint64Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> { 441 /** The size in bytes of each element in the array. */ 442 readonly BYTES_PER_ELEMENT: number; 443 444 /** The ArrayBuffer instance referenced by the array. */ 445 readonly buffer: TArrayBuffer; 446 447 /** The length in bytes of the array. */ 448 readonly byteLength: number; 449 450 /** The offset in bytes of the array. */ 451 readonly byteOffset: number; 452 453 /** 454 * Returns the this object after copying a section of the array identified by start and end 455 * to the same array starting at position target 456 * @param target If target is negative, it is treated as length+target where length is the 457 * length of the array. 458 * @param start If start is negative, it is treated as length+start. If end is negative, it 459 * is treated as length+end. 460 * @param end If not specified, length of the this object is used as its default value. 461 */ 462 copyWithin(target: number, start: number, end?: number): this; 463 464 /** Yields index, value pairs for every entry in the array. */ 465 entries(): ArrayIterator<[number, bigint]>; 466 467 /** 468 * Determines whether all the members of an array satisfy the specified test. 469 * @param predicate A function that accepts up to three arguments. The every method calls 470 * the predicate function for each element in the array until the predicate returns false, 471 * or until the end of the array. 472 * @param thisArg An object to which the this keyword can refer in the predicate function. 473 * If thisArg is omitted, undefined is used as the this value. 474 */ 475 every(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => boolean, thisArg?: any): boolean; 476 477 /** 478 * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array 479 * @param value value to fill array section with 480 * @param start index to start filling the array at. If start is negative, it is treated as 481 * length+start where length is the length of the array. 482 * @param end index to stop filling the array at. If end is negative, it is treated as 483 * length+end. 484 */ 485 fill(value: bigint, start?: number, end?: number): this; 486 487 /** 488 * Returns the elements of an array that meet the condition specified in a callback function. 489 * @param predicate A function that accepts up to three arguments. The filter method calls 490 * the predicate function one time for each element in the array. 491 * @param thisArg An object to which the this keyword can refer in the predicate function. 492 * If thisArg is omitted, undefined is used as the this value. 493 */ 494 filter(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => any, thisArg?: any): BigUint64Array<ArrayBuffer>; 495 496 /** 497 * Returns the value of the first element in the array where predicate is true, and undefined 498 * otherwise. 499 * @param predicate find calls predicate once for each element of the array, in ascending 500 * order, until it finds one where predicate returns true. If such an element is found, find 501 * immediately returns that element value. Otherwise, find returns undefined. 502 * @param thisArg If provided, it will be used as the this value for each invocation of 503 * predicate. If it is not provided, undefined is used instead. 504 */ 505 find(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => boolean, thisArg?: any): bigint | undefined; 506 507 /** 508 * Returns the index of the first element in the array where predicate is true, and -1 509 * otherwise. 510 * @param predicate find calls predicate once for each element of the array, in ascending 511 * order, until it finds one where predicate returns true. If such an element is found, 512 * findIndex immediately returns that element index. Otherwise, findIndex returns -1. 513 * @param thisArg If provided, it will be used as the this value for each invocation of 514 * predicate. If it is not provided, undefined is used instead. 515 */ 516 findIndex(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => boolean, thisArg?: any): number; 517 518 /** 519 * Performs the specified action for each element in an array. 520 * @param callbackfn A function that accepts up to three arguments. forEach calls the 521 * callbackfn function one time for each element in the array. 522 * @param thisArg An object to which the this keyword can refer in the callbackfn function. 523 * If thisArg is omitted, undefined is used as the this value. 524 */ 525 forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => void, thisArg?: any): void; 526 527 /** 528 * Determines whether an array includes a certain element, returning true or false as appropriate. 529 * @param searchElement The element to search for. 530 * @param fromIndex The position in this array at which to begin searching for searchElement. 531 */ 532 includes(searchElement: bigint, fromIndex?: number): boolean; 533 534 /** 535 * Returns the index of the first occurrence of a value in an array. 536 * @param searchElement The value to locate in the array. 537 * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the 538 * search starts at index 0. 539 */ 540 indexOf(searchElement: bigint, fromIndex?: number): number; 541 542 /** 543 * Adds all the elements of an array separated by the specified separator string. 544 * @param separator A string used to separate one element of an array from the next in the 545 * resulting String. If omitted, the array elements are separated with a comma. 546 */ 547 join(separator?: string): string; 548 549 /** Yields each index in the array. */ 550 keys(): ArrayIterator<number>; 551 552 /** 553 * Returns the index of the last occurrence of a value in an array. 554 * @param searchElement The value to locate in the array. 555 * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the 556 * search starts at index 0. 557 */ 558 lastIndexOf(searchElement: bigint, fromIndex?: number): number; 559 560 /** The length of the array. */ 561 readonly length: number; 562 563 /** 564 * Calls a defined callback function on each element of an array, and returns an array that 565 * contains the results. 566 * @param callbackfn A function that accepts up to three arguments. The map method calls the 567 * callbackfn function one time for each element in the array. 568 * @param thisArg An object to which the this keyword can refer in the callbackfn function. 569 * If thisArg is omitted, undefined is used as the this value. 570 */ 571 map(callbackfn: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => bigint, thisArg?: any): BigUint64Array<ArrayBuffer>; 572 573 /** 574 * Calls the specified callback function for all the elements in an array. The return value of 575 * the callback function is the accumulated result, and is provided as an argument in the next 576 * call to the callback function. 577 * @param callbackfn A function that accepts up to four arguments. The reduce method calls the 578 * callbackfn function one time for each element in the array. 579 * @param initialValue If initialValue is specified, it is used as the initial value to start 580 * the accumulation. The first call to the callbackfn function provides this value as an argument 581 * instead of an array value. 582 */ 583 reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array<TArrayBuffer>) => bigint): bigint; 584 585 /** 586 * Calls the specified callback function for all the elements in an array. The return value of 587 * the callback function is the accumulated result, and is provided as an argument in the next 588 * call to the callback function. 589 * @param callbackfn A function that accepts up to four arguments. The reduce method calls the 590 * callbackfn function one time for each element in the array. 591 * @param initialValue If initialValue is specified, it is used as the initial value to start 592 * the accumulation. The first call to the callbackfn function provides this value as an argument 593 * instead of an array value. 594 */ 595 reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array<TArrayBuffer>) => U, initialValue: U): U; 596 597 /** 598 * Calls the specified callback function for all the elements in an array, in descending order. 599 * The return value of the callback function is the accumulated result, and is provided as an 600 * argument in the next call to the callback function. 601 * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls 602 * the callbackfn function one time for each element in the array. 603 * @param initialValue If initialValue is specified, it is used as the initial value to start 604 * the accumulation. The first call to the callbackfn function provides this value as an 605 * argument instead of an array value. 606 */ 607 reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array<TArrayBuffer>) => bigint): bigint; 608 609 /** 610 * Calls the specified callback function for all the elements in an array, in descending order. 611 * The return value of the callback function is the accumulated result, and is provided as an 612 * argument in the next call to the callback function. 613 * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls 614 * the callbackfn function one time for each element in the array. 615 * @param initialValue If initialValue is specified, it is used as the initial value to start 616 * the accumulation. The first call to the callbackfn function provides this value as an argument 617 * instead of an array value. 618 */ 619 reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array<TArrayBuffer>) => U, initialValue: U): U; 620 621 /** Reverses the elements in the array. */ 622 reverse(): this; 623 624 /** 625 * Sets a value or an array of values. 626 * @param array A typed or untyped array of values to set. 627 * @param offset The index in the current array at which the values are to be written. 628 */ 629 set(array: ArrayLike<bigint>, offset?: number): void; 630 631 /** 632 * Returns a section of an array. 633 * @param start The beginning of the specified portion of the array. 634 * @param end The end of the specified portion of the array. 635 */ 636 slice(start?: number, end?: number): BigUint64Array<ArrayBuffer>; 637 638 /** 639 * Determines whether the specified callback function returns true for any element of an array. 640 * @param predicate A function that accepts up to three arguments. The some method calls the 641 * predicate function for each element in the array until the predicate returns true, or until 642 * the end of the array. 643 * @param thisArg An object to which the this keyword can refer in the predicate function. 644 * If thisArg is omitted, undefined is used as the this value. 645 */ 646 some(predicate: (value: bigint, index: number, array: BigUint64Array<TArrayBuffer>) => boolean, thisArg?: any): boolean; 647 648 /** 649 * Sorts the array. 650 * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order. 651 */ 652 sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this; 653 654 /** 655 * Gets a new BigUint64Array view of the ArrayBuffer store for this array, referencing the elements 656 * at begin, inclusive, up to end, exclusive. 657 * @param begin The index of the beginning of the array. 658 * @param end The index of the end of the array. 659 */ 660 subarray(begin?: number, end?: number): BigUint64Array<TArrayBuffer>; 661 662 /** Converts the array to a string by using the current locale. */ 663 toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions): string; 664 665 /** Returns a string representation of the array. */ 666 toString(): string; 667 668 /** Returns the primitive value of the specified object. */ 669 valueOf(): BigUint64Array<TArrayBuffer>; 670 671 /** Yields each value in the array. */ 672 values(): ArrayIterator<bigint>; 673 674 [Symbol.iterator](): ArrayIterator<bigint>; 675 676 readonly [Symbol.toStringTag]: "BigUint64Array"; 677 678 [index: number]: bigint; 679 } 680 interface BigUint64ArrayConstructor { 681 readonly prototype: BigUint64Array<ArrayBufferLike>; 682 new (length?: number): BigUint64Array<ArrayBuffer>; 683 new (array: ArrayLike<bigint> | Iterable<bigint>): BigUint64Array<ArrayBuffer>; 684 new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(buffer: TArrayBuffer, byteOffset?: number, length?: number): BigUint64Array<TArrayBuffer>; 685 new (buffer: ArrayBuffer, byteOffset?: number, length?: number): BigUint64Array<ArrayBuffer>; 686 new (array: ArrayLike<bigint> | ArrayBuffer): BigUint64Array<ArrayBuffer>; 687 688 /** The size in bytes of each element in the array. */ 689 readonly BYTES_PER_ELEMENT: number; 690 691 /** 692 * Returns a new array from a set of elements. 693 * @param items A set of elements to include in the new array object. 694 */ 695 of(...items: bigint[]): BigUint64Array<ArrayBuffer>; 696 697 /** 698 * Creates an array from an array-like or iterable object. 699 * @param arrayLike An array-like object to convert to an array. 700 */ 701 from(arrayLike: ArrayLike<bigint>): BigUint64Array<ArrayBuffer>; 702 703 /** 704 * Creates an array from an array-like or iterable object. 705 * @param arrayLike An array-like object to convert to an array. 706 * @param mapfn A mapping function to call on every element of the array. 707 * @param thisArg Value of 'this' used to invoke the mapfn. 708 */ 709 from<U>(arrayLike: ArrayLike<U>, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigUint64Array<ArrayBuffer>; 710 711 /** 712 * Creates an array from an array-like or iterable object. 713 * @param elements An iterable object to convert to an array. 714 */ 715 from(elements: Iterable<bigint>): BigUint64Array<ArrayBuffer>; 716 717 /** 718 * Creates an array from an array-like or iterable object. 719 * @param elements An iterable object to convert to an array. 720 * @param mapfn A mapping function to call on every element of the array. 721 * @param thisArg Value of 'this' used to invoke the mapfn. 722 */ 723 from<T>(elements: Iterable<T>, mapfn?: (v: T, k: number) => bigint, thisArg?: any): BigUint64Array<ArrayBuffer>; 724 } 725 declare var BigUint64Array: BigUint64ArrayConstructor; 726 727 interface DataView<TArrayBuffer extends ArrayBufferLike> { 728 /** 729 * Gets the BigInt64 value at the specified byte offset from the start of the view. There is 730 * no alignment constraint; multi-byte values may be fetched from any offset. 731 * @param byteOffset The place in the buffer at which the value should be retrieved. 732 * @param littleEndian If false or undefined, a big-endian value should be read. 733 */ 734 getBigInt64(byteOffset: number, littleEndian?: boolean): bigint; 735 736 /** 737 * Gets the BigUint64 value at the specified byte offset from the start of the view. There is 738 * no alignment constraint; multi-byte values may be fetched from any offset. 739 * @param byteOffset The place in the buffer at which the value should be retrieved. 740 * @param littleEndian If false or undefined, a big-endian value should be read. 741 */ 742 getBigUint64(byteOffset: number, littleEndian?: boolean): bigint; 743 744 /** 745 * Stores a BigInt64 value at the specified byte offset from the start of the view. 746 * @param byteOffset The place in the buffer at which the value should be set. 747 * @param value The value to set. 748 * @param littleEndian If false or undefined, a big-endian value should be written. 749 */ 750 setBigInt64(byteOffset: number, value: bigint, littleEndian?: boolean): void; 751 752 /** 753 * Stores a BigUint64 value at the specified byte offset from the start of the view. 754 * @param byteOffset The place in the buffer at which the value should be set. 755 * @param value The value to set. 756 * @param littleEndian If false or undefined, a big-endian value should be written. 757 */ 758 setBigUint64(byteOffset: number, value: bigint, littleEndian?: boolean): void; 759 } 760 761 declare namespace Intl { 762 interface NumberFormat { 763 format(value: number | bigint): string; 764 } 765 }