.config/coc/extensions/node_modules/coc-prettier/node_modules/prettier-eslint/node_modules/typescript/lib/lib.es2020.bigint.d.ts

   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
  18 /// <reference no-default-lib="true"/>\r
  19
  20
  21 interface BigInt {\r
  22     /**\r
  23      * Returns a string representation of an object.\r
  24      * @param radix Specifies a radix for converting numeric values to strings.\r
  25      */\r
  26     toString(radix?: number): string;\r
  27 \r
  28     /** Returns a string representation appropriate to the host environment's current locale. */\r
  29     toLocaleString(): string;\r
  30 \r
  31     /** Returns the primitive value of the specified object. */\r
  32     valueOf(): bigint;\r
  33 \r
  34     readonly [Symbol.toStringTag]: "BigInt";\r
  35 }\r
  36 \r
  37 interface BigIntConstructor {\r
  38     (value?: any): bigint;\r
  39     readonly prototype: BigInt;\r
  40 \r
  41     /**\r
  42      * Interprets the low bits of a BigInt as a 2's-complement signed integer.\r
  43      * All higher bits are discarded.\r
  44      * @param bits The number of low bits to use\r
  45      * @param int The BigInt whose bits to extract\r
  46      */\r
  47     asIntN(bits: number, int: bigint): bigint;\r
  48     /**\r
  49      * Interprets the low bits of a BigInt as an unsigned integer.\r
  50      * All higher bits are discarded.\r
  51      * @param bits The number of low bits to use\r
  52      * @param int The BigInt whose bits to extract\r
  53      */\r
  54     asUintN(bits: number, int: bigint): bigint;\r
  55 }\r
  56 \r
  57 declare var BigInt: BigIntConstructor;\r
  58 \r
  59 /**\r
  60  * A typed array of 64-bit signed integer values. The contents are initialized to 0. If the\r
  61  * requested number of bytes could not be allocated, an exception is raised.\r
  62  */\r
  63 interface BigInt64Array {\r
  64     /** The size in bytes of each element in the array. */\r
  65     readonly BYTES_PER_ELEMENT: number;\r
  66 \r
  67     /** The ArrayBuffer instance referenced by the array. */\r
  68     readonly buffer: ArrayBufferLike;\r
  69 \r
  70     /** The length in bytes of the array. */\r
  71     readonly byteLength: number;\r
  72 \r
  73     /** The offset in bytes of the array. */\r
  74     readonly byteOffset: number;\r
  75 \r
  76     /**\r
  77      * Returns the this object after copying a section of the array identified by start and end\r
  78      * to the same array starting at position target\r
  79      * @param target If target is negative, it is treated as length+target where length is the\r
  80      * length of the array.\r
  81      * @param start If start is negative, it is treated as length+start. If end is negative, it\r
  82      * is treated as length+end.\r
  83      * @param end If not specified, length of the this object is used as its default value.\r
  84      */\r
  85     copyWithin(target: number, start: number, end?: number): this;\r
  86 \r
  87     /** Yields index, value pairs for every entry in the array. */\r
  88     entries(): IterableIterator<[number, bigint]>;\r
  89 \r
  90     /**\r
  91      * Determines whether all the members of an array satisfy the specified test.\r
  92      * @param callbackfn A function that accepts up to three arguments. The every method calls\r
  93      * the callbackfn function for each element in the array until the callbackfn returns false,\r
  94      * or until the end of the array.\r
  95      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
  96      * If thisArg is omitted, undefined is used as the this value.\r
  97      */\r
  98     every(callbackfn: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean;\r
  99 \r
 100     /**\r
 101      * Returns the this object after filling the section identified by start and end with value\r
 102      * @param value value to fill array section with\r
 103      * @param start index to start filling the array at. If start is negative, it is treated as\r
 104      * length+start where length is the length of the array.\r
 105      * @param end index to stop filling the array at. If end is negative, it is treated as\r
 106      * length+end.\r
 107      */\r
 108     fill(value: bigint, start?: number, end?: number): this;\r
 109 \r
 110     /**\r
 111      * Returns the elements of an array that meet the condition specified in a callback function.\r
 112      * @param callbackfn A function that accepts up to three arguments. The filter method calls\r
 113      * the callbackfn function one time for each element in the array.\r
 114      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 115      * If thisArg is omitted, undefined is used as the this value.\r
 116      */\r
 117     filter(callbackfn: (value: bigint, index: number, array: BigInt64Array) => any, thisArg?: any): BigInt64Array;\r
 118 \r
 119     /**\r
 120      * Returns the value of the first element in the array where predicate is true, and undefined\r
 121      * otherwise.\r
 122      * @param predicate find calls predicate once for each element of the array, in ascending\r
 123      * order, until it finds one where predicate returns true. If such an element is found, find\r
 124      * immediately returns that element value. Otherwise, find returns undefined.\r
 125      * @param thisArg If provided, it will be used as the this value for each invocation of\r
 126      * predicate. If it is not provided, undefined is used instead.\r
 127      */\r
 128     find(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): bigint | undefined;\r
 129 \r
 130     /**\r
 131      * Returns the index of the first element in the array where predicate is true, and -1\r
 132      * otherwise.\r
 133      * @param predicate find calls predicate once for each element of the array, in ascending\r
 134      * order, until it finds one where predicate returns true. If such an element is found,\r
 135      * findIndex immediately returns that element index. Otherwise, findIndex returns -1.\r
 136      * @param thisArg If provided, it will be used as the this value for each invocation of\r
 137      * predicate. If it is not provided, undefined is used instead.\r
 138      */\r
 139     findIndex(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): number;\r
 140 \r
 141     /**\r
 142      * Performs the specified action for each element in an array.\r
 143      * @param callbackfn A function that accepts up to three arguments. forEach calls the\r
 144      * callbackfn function one time for each element in the array.\r
 145      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 146      * If thisArg is omitted, undefined is used as the this value.\r
 147      */\r
 148     forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array) => void, thisArg?: any): void;\r
 149 \r
 150     /**\r
 151      * Determines whether an array includes a certain element, returning true or false as appropriate.\r
 152      * @param searchElement The element to search for.\r
 153      * @param fromIndex The position in this array at which to begin searching for searchElement.\r
 154      */\r
 155     includes(searchElement: bigint, fromIndex?: number): boolean;\r
 156 \r
 157     /**\r
 158      * Returns the index of the first occurrence of a value in an array.\r
 159      * @param searchElement The value to locate in the array.\r
 160      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\r
 161      * search starts at index 0.\r
 162      */\r
 163     indexOf(searchElement: bigint, fromIndex?: number): number;\r
 164 \r
 165     /**\r
 166      * Adds all the elements of an array separated by the specified separator string.\r
 167      * @param separator A string used to separate one element of an array from the next in the\r
 168      * resulting String. If omitted, the array elements are separated with a comma.\r
 169      */\r
 170     join(separator?: string): string;\r
 171 \r
 172     /** Yields each index in the array. */\r
 173     keys(): IterableIterator<number>;\r
 174 \r
 175     /**\r
 176      * Returns the index of the last occurrence of a value in an array.\r
 177      * @param searchElement The value to locate in the array.\r
 178      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\r
 179      * search starts at index 0.\r
 180      */\r
 181     lastIndexOf(searchElement: bigint, fromIndex?: number): number;\r
 182 \r
 183     /** The length of the array. */\r
 184     readonly length: number;\r
 185 \r
 186     /**\r
 187      * Calls a defined callback function on each element of an array, and returns an array that\r
 188      * contains the results.\r
 189      * @param callbackfn A function that accepts up to three arguments. The map method calls the\r
 190      * callbackfn function one time for each element in the array.\r
 191      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 192      * If thisArg is omitted, undefined is used as the this value.\r
 193      */\r
 194     map(callbackfn: (value: bigint, index: number, array: BigInt64Array) => bigint, thisArg?: any): BigInt64Array;\r
 195 \r
 196     /**\r
 197      * Calls the specified callback function for all the elements in an array. The return value of\r
 198      * the callback function is the accumulated result, and is provided as an argument in the next\r
 199      * call to the callback function.\r
 200      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\r
 201      * callbackfn function one time for each element in the array.\r
 202      * @param initialValue If initialValue is specified, it is used as the initial value to start\r
 203      * the accumulation. The first call to the callbackfn function provides this value as an argument\r
 204      * instead of an array value.\r
 205      */\r
 206     reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint;\r
 207 \r
 208     /**\r
 209      * Calls the specified callback function for all the elements in an array. The return value of\r
 210      * the callback function is the accumulated result, and is provided as an argument in the next\r
 211      * call to the callback function.\r
 212      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\r
 213      * callbackfn function one time for each element in the array.\r
 214      * @param initialValue If initialValue is specified, it is used as the initial value to start\r
 215      * the accumulation. The first call to the callbackfn function provides this value as an argument\r
 216      * instead of an array value.\r
 217      */\r
 218     reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U;\r
 219 \r
 220     /**\r
 221      * Calls the specified callback function for all the elements in an array, in descending order.\r
 222      * The return value of the callback function is the accumulated result, and is provided as an\r
 223      * argument in the next call to the callback function.\r
 224      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\r
 225      * the callbackfn function one time for each element in the array.\r
 226      * @param initialValue If initialValue is specified, it is used as the initial value to start\r
 227      * the accumulation. The first call to the callbackfn function provides this value as an\r
 228      * argument instead of an array value.\r
 229      */\r
 230     reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint;\r
 231 \r
 232     /**\r
 233      * Calls the specified callback function for all the elements in an array, in descending order.\r
 234      * The return value of the callback function is the accumulated result, and is provided as an\r
 235      * argument in the next call to the callback function.\r
 236      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\r
 237      * the callbackfn function one time for each element in the array.\r
 238      * @param initialValue If initialValue is specified, it is used as the initial value to start\r
 239      * the accumulation. The first call to the callbackfn function provides this value as an argument\r
 240      * instead of an array value.\r
 241      */\r
 242     reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U;\r
 243 \r
 244     /** Reverses the elements in the array. */\r
 245     reverse(): this;\r
 246 \r
 247     /**\r
 248      * Sets a value or an array of values.\r
 249      * @param array A typed or untyped array of values to set.\r
 250      * @param offset The index in the current array at which the values are to be written.\r
 251      */\r
 252     set(array: ArrayLike<bigint>, offset?: number): void;\r
 253 \r
 254     /**\r
 255      * Returns a section of an array.\r
 256      * @param start The beginning of the specified portion of the array.\r
 257      * @param end The end of the specified portion of the array.\r
 258      */\r
 259     slice(start?: number, end?: number): BigInt64Array;\r
 260 \r
 261     /**\r
 262      * Determines whether the specified callback function returns true for any element of an array.\r
 263      * @param callbackfn A function that accepts up to three arguments. The some method calls the\r
 264      * callbackfn function for each element in the array until the callbackfn returns true, or until\r
 265      * the end of the array.\r
 266      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 267      * If thisArg is omitted, undefined is used as the this value.\r
 268      */\r
 269     some(callbackfn: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean;\r
 270 \r
 271     /**\r
 272      * Sorts the array.\r
 273      * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order.\r
 274      */\r
 275     sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this;\r
 276 \r
 277     /**\r
 278      * Gets a new BigInt64Array view of the ArrayBuffer store for this array, referencing the elements\r
 279      * at begin, inclusive, up to end, exclusive.\r
 280      * @param begin The index of the beginning of the array.\r
 281      * @param end The index of the end of the array.\r
 282      */\r
 283     subarray(begin?: number, end?: number): BigInt64Array;\r
 284 \r
 285     /** Converts the array to a string by using the current locale. */\r
 286     toLocaleString(): string;\r
 287 \r
 288     /** Returns a string representation of the array. */\r
 289     toString(): string;\r
 290 \r
 291     /** Returns the primitive value of the specified object. */\r
 292     valueOf(): BigInt64Array;\r
 293 \r
 294     /** Yields each value in the array. */\r
 295     values(): IterableIterator<bigint>;\r
 296 \r
 297     [Symbol.iterator](): IterableIterator<bigint>;\r
 298 \r
 299     readonly [Symbol.toStringTag]: "BigInt64Array";\r
 300 \r
 301     [index: number]: bigint;\r
 302 }\r
 303 \r
 304 interface BigInt64ArrayConstructor {\r
 305     readonly prototype: BigInt64Array;\r
 306     new(length?: number): BigInt64Array;\r
 307     new(array: Iterable<bigint>): BigInt64Array;\r
 308     new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigInt64Array;\r
 309 \r
 310     /** The size in bytes of each element in the array. */\r
 311     readonly BYTES_PER_ELEMENT: number;\r
 312 \r
 313     /**\r
 314      * Returns a new array from a set of elements.\r
 315      * @param items A set of elements to include in the new array object.\r
 316      */\r
 317     of(...items: bigint[]): BigInt64Array;\r
 318 \r
 319     /**\r
 320      * Creates an array from an array-like or iterable object.\r
 321      * @param arrayLike An array-like or iterable object to convert to an array.\r
 322      * @param mapfn A mapping function to call on every element of the array.\r
 323      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 324      */\r
 325     from(arrayLike: ArrayLike<bigint>): BigInt64Array;\r
 326     from<U>(arrayLike: ArrayLike<U>, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array;\r
 327 }\r
 328 \r
 329 declare var BigInt64Array: BigInt64ArrayConstructor;\r
 330 \r
 331 /**\r
 332  * A typed array of 64-bit unsigned integer values. The contents are initialized to 0. If the\r
 333  * requested number of bytes could not be allocated, an exception is raised.\r
 334  */\r
 335 interface BigUint64Array {\r
 336     /** The size in bytes of each element in the array. */\r
 337     readonly BYTES_PER_ELEMENT: number;\r
 338 \r
 339     /** The ArrayBuffer instance referenced by the array. */\r
 340     readonly buffer: ArrayBufferLike;\r
 341 \r
 342     /** The length in bytes of the array. */\r
 343     readonly byteLength: number;\r
 344 \r
 345     /** The offset in bytes of the array. */\r
 346     readonly byteOffset: number;\r
 347 \r
 348     /**\r
 349      * Returns the this object after copying a section of the array identified by start and end\r
 350      * to the same array starting at position target\r
 351      * @param target If target is negative, it is treated as length+target where length is the\r
 352      * length of the array.\r
 353      * @param start If start is negative, it is treated as length+start. If end is negative, it\r
 354      * is treated as length+end.\r
 355      * @param end If not specified, length of the this object is used as its default value.\r
 356      */\r
 357     copyWithin(target: number, start: number, end?: number): this;\r
 358 \r
 359     /** Yields index, value pairs for every entry in the array. */\r
 360     entries(): IterableIterator<[number, bigint]>;\r
 361 \r
 362     /**\r
 363      * Determines whether all the members of an array satisfy the specified test.\r
 364      * @param callbackfn A function that accepts up to three arguments. The every method calls\r
 365      * the callbackfn function for each element in the array until the callbackfn returns false,\r
 366      * or until the end of the array.\r
 367      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 368      * If thisArg is omitted, undefined is used as the this value.\r
 369      */\r
 370     every(callbackfn: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean;\r
 371 \r
 372     /**\r
 373      * Returns the this object after filling the section identified by start and end with value\r
 374      * @param value value to fill array section with\r
 375      * @param start index to start filling the array at. If start is negative, it is treated as\r
 376      * length+start where length is the length of the array.\r
 377      * @param end index to stop filling the array at. If end is negative, it is treated as\r
 378      * length+end.\r
 379      */\r
 380     fill(value: bigint, start?: number, end?: number): this;\r
 381 \r
 382     /**\r
 383      * Returns the elements of an array that meet the condition specified in a callback function.\r
 384      * @param callbackfn A function that accepts up to three arguments. The filter method calls\r
 385      * the callbackfn function one time for each element in the array.\r
 386      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 387      * If thisArg is omitted, undefined is used as the this value.\r
 388      */\r
 389     filter(callbackfn: (value: bigint, index: number, array: BigUint64Array) => any, thisArg?: any): BigUint64Array;\r
 390 \r
 391     /**\r
 392      * Returns the value of the first element in the array where predicate is true, and undefined\r
 393      * otherwise.\r
 394      * @param predicate find calls predicate once for each element of the array, in ascending\r
 395      * order, until it finds one where predicate returns true. If such an element is found, find\r
 396      * immediately returns that element value. Otherwise, find returns undefined.\r
 397      * @param thisArg If provided, it will be used as the this value for each invocation of\r
 398      * predicate. If it is not provided, undefined is used instead.\r
 399      */\r
 400     find(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): bigint | undefined;\r
 401 \r
 402     /**\r
 403      * Returns the index of the first element in the array where predicate is true, and -1\r
 404      * otherwise.\r
 405      * @param predicate find calls predicate once for each element of the array, in ascending\r
 406      * order, until it finds one where predicate returns true. If such an element is found,\r
 407      * findIndex immediately returns that element index. Otherwise, findIndex returns -1.\r
 408      * @param thisArg If provided, it will be used as the this value for each invocation of\r
 409      * predicate. If it is not provided, undefined is used instead.\r
 410      */\r
 411     findIndex(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): number;\r
 412 \r
 413     /**\r
 414      * Performs the specified action for each element in an array.\r
 415      * @param callbackfn A function that accepts up to three arguments. forEach calls the\r
 416      * callbackfn function one time for each element in the array.\r
 417      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 418      * If thisArg is omitted, undefined is used as the this value.\r
 419      */\r
 420     forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array) => void, thisArg?: any): void;\r
 421 \r
 422     /**\r
 423      * Determines whether an array includes a certain element, returning true or false as appropriate.\r
 424      * @param searchElement The element to search for.\r
 425      * @param fromIndex The position in this array at which to begin searching for searchElement.\r
 426      */\r
 427     includes(searchElement: bigint, fromIndex?: number): boolean;\r
 428 \r
 429     /**\r
 430      * Returns the index of the first occurrence of a value in an array.\r
 431      * @param searchElement The value to locate in the array.\r
 432      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\r
 433      * search starts at index 0.\r
 434      */\r
 435     indexOf(searchElement: bigint, fromIndex?: number): number;\r
 436 \r
 437     /**\r
 438      * Adds all the elements of an array separated by the specified separator string.\r
 439      * @param separator A string used to separate one element of an array from the next in the\r
 440      * resulting String. If omitted, the array elements are separated with a comma.\r
 441      */\r
 442     join(separator?: string): string;\r
 443 \r
 444     /** Yields each index in the array. */\r
 445     keys(): IterableIterator<number>;\r
 446 \r
 447     /**\r
 448      * Returns the index of the last occurrence of a value in an array.\r
 449      * @param searchElement The value to locate in the array.\r
 450      * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the\r
 451      * search starts at index 0.\r
 452      */\r
 453     lastIndexOf(searchElement: bigint, fromIndex?: number): number;\r
 454 \r
 455     /** The length of the array. */\r
 456     readonly length: number;\r
 457 \r
 458     /**\r
 459      * Calls a defined callback function on each element of an array, and returns an array that\r
 460      * contains the results.\r
 461      * @param callbackfn A function that accepts up to three arguments. The map method calls the\r
 462      * callbackfn function one time for each element in the array.\r
 463      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 464      * If thisArg is omitted, undefined is used as the this value.\r
 465      */\r
 466     map(callbackfn: (value: bigint, index: number, array: BigUint64Array) => bigint, thisArg?: any): BigUint64Array;\r
 467 \r
 468     /**\r
 469      * Calls the specified callback function for all the elements in an array. The return value of\r
 470      * the callback function is the accumulated result, and is provided as an argument in the next\r
 471      * call to the callback function.\r
 472      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\r
 473      * callbackfn function one time for each element in the array.\r
 474      * @param initialValue If initialValue is specified, it is used as the initial value to start\r
 475      * the accumulation. The first call to the callbackfn function provides this value as an argument\r
 476      * instead of an array value.\r
 477      */\r
 478     reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint;\r
 479 \r
 480     /**\r
 481      * Calls the specified callback function for all the elements in an array. The return value of\r
 482      * the callback function is the accumulated result, and is provided as an argument in the next\r
 483      * call to the callback function.\r
 484      * @param callbackfn A function that accepts up to four arguments. The reduce method calls the\r
 485      * callbackfn function one time for each element in the array.\r
 486      * @param initialValue If initialValue is specified, it is used as the initial value to start\r
 487      * the accumulation. The first call to the callbackfn function provides this value as an argument\r
 488      * instead of an array value.\r
 489      */\r
 490     reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U;\r
 491 \r
 492     /**\r
 493      * Calls the specified callback function for all the elements in an array, in descending order.\r
 494      * The return value of the callback function is the accumulated result, and is provided as an\r
 495      * argument in the next call to the callback function.\r
 496      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\r
 497      * the callbackfn function one time for each element in the array.\r
 498      * @param initialValue If initialValue is specified, it is used as the initial value to start\r
 499      * the accumulation. The first call to the callbackfn function provides this value as an\r
 500      * argument instead of an array value.\r
 501      */\r
 502     reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint;\r
 503 \r
 504     /**\r
 505      * Calls the specified callback function for all the elements in an array, in descending order.\r
 506      * The return value of the callback function is the accumulated result, and is provided as an\r
 507      * argument in the next call to the callback function.\r
 508      * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls\r
 509      * the callbackfn function one time for each element in the array.\r
 510      * @param initialValue If initialValue is specified, it is used as the initial value to start\r
 511      * the accumulation. The first call to the callbackfn function provides this value as an argument\r
 512      * instead of an array value.\r
 513      */\r
 514     reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U;\r
 515 \r
 516     /** Reverses the elements in the array. */\r
 517     reverse(): this;\r
 518 \r
 519     /**\r
 520      * Sets a value or an array of values.\r
 521      * @param array A typed or untyped array of values to set.\r
 522      * @param offset The index in the current array at which the values are to be written.\r
 523      */\r
 524     set(array: ArrayLike<bigint>, offset?: number): void;\r
 525 \r
 526     /**\r
 527      * Returns a section of an array.\r
 528      * @param start The beginning of the specified portion of the array.\r
 529      * @param end The end of the specified portion of the array.\r
 530      */\r
 531     slice(start?: number, end?: number): BigUint64Array;\r
 532 \r
 533     /**\r
 534      * Determines whether the specified callback function returns true for any element of an array.\r
 535      * @param callbackfn A function that accepts up to three arguments. The some method calls the\r
 536      * callbackfn function for each element in the array until the callbackfn returns true, or until\r
 537      * the end of the array.\r
 538      * @param thisArg An object to which the this keyword can refer in the callbackfn function.\r
 539      * If thisArg is omitted, undefined is used as the this value.\r
 540      */\r
 541     some(callbackfn: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean;\r
 542 \r
 543     /**\r
 544      * Sorts the array.\r
 545      * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order.\r
 546      */\r
 547     sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this;\r
 548 \r
 549     /**\r
 550      * Gets a new BigUint64Array view of the ArrayBuffer store for this array, referencing the elements\r
 551      * at begin, inclusive, up to end, exclusive.\r
 552      * @param begin The index of the beginning of the array.\r
 553      * @param end The index of the end of the array.\r
 554      */\r
 555     subarray(begin?: number, end?: number): BigUint64Array;\r
 556 \r
 557     /** Converts the array to a string by using the current locale. */\r
 558     toLocaleString(): string;\r
 559 \r
 560     /** Returns a string representation of the array. */\r
 561     toString(): string;\r
 562 \r
 563     /** Returns the primitive value of the specified object. */\r
 564     valueOf(): BigUint64Array;\r
 565 \r
 566     /** Yields each value in the array. */\r
 567     values(): IterableIterator<bigint>;\r
 568 \r
 569     [Symbol.iterator](): IterableIterator<bigint>;\r
 570 \r
 571     readonly [Symbol.toStringTag]: "BigUint64Array";\r
 572 \r
 573     [index: number]: bigint;\r
 574 }\r
 575 \r
 576 interface BigUint64ArrayConstructor {\r
 577     readonly prototype: BigUint64Array;\r
 578     new(length?: number): BigUint64Array;\r
 579     new(array: Iterable<bigint>): BigUint64Array;\r
 580     new(buffer: ArrayBufferLike, byteOffset?: number, length?: number): BigUint64Array;\r
 581 \r
 582     /** The size in bytes of each element in the array. */\r
 583     readonly BYTES_PER_ELEMENT: number;\r
 584 \r
 585     /**\r
 586      * Returns a new array from a set of elements.\r
 587      * @param items A set of elements to include in the new array object.\r
 588      */\r
 589     of(...items: bigint[]): BigUint64Array;\r
 590 \r
 591     /**\r
 592      * Creates an array from an array-like or iterable object.\r
 593      * @param arrayLike An array-like or iterable object to convert to an array.\r
 594      * @param mapfn A mapping function to call on every element of the array.\r
 595      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 596      */\r
 597     from(arrayLike: ArrayLike<bigint>): BigUint64Array;\r
 598     from<U>(arrayLike: ArrayLike<U>, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigUint64Array;\r
 599 }\r
 600 \r
 601 declare var BigUint64Array: BigUint64ArrayConstructor;\r
 602 \r
 603 interface DataView {\r
 604     /**\r
 605      * Gets the BigInt64 value at the specified byte offset from the start of the view. There is\r
 606      * no alignment constraint; multi-byte values may be fetched from any offset.\r
 607      * @param byteOffset The place in the buffer at which the value should be retrieved.\r
 608      */\r
 609     getBigInt64(byteOffset: number, littleEndian?: boolean): bigint;\r
 610 \r
 611     /**\r
 612      * Gets the BigUint64 value at the specified byte offset from the start of the view. There is\r
 613      * no alignment constraint; multi-byte values may be fetched from any offset.\r
 614      * @param byteOffset The place in the buffer at which the value should be retrieved.\r
 615      */\r
 616     getBigUint64(byteOffset: number, littleEndian?: boolean): bigint;\r
 617 \r
 618     /**\r
 619      * Stores a BigInt64 value at the specified byte offset from the start of the view.\r
 620      * @param byteOffset The place in the buffer at which the value should be set.\r
 621      * @param value The value to set.\r
 622      * @param littleEndian If false or undefined, a big-endian value should be written,\r
 623      * otherwise a little-endian value should be written.\r
 624      */\r
 625     setBigInt64(byteOffset: number, value: bigint, littleEndian?: boolean): void;\r
 626 \r
 627     /**\r
 628      * Stores a BigUint64 value at the specified byte offset from the start of the view.\r
 629      * @param byteOffset The place in the buffer at which the value should be set.\r
 630      * @param value The value to set.\r
 631      * @param littleEndian If false or undefined, a big-endian value should be written,\r
 632      * otherwise a little-endian value should be written.\r
 633      */\r
 634     setBigUint64(byteOffset: number, value: bigint, littleEndian?: boolean): void;\r
 635 }\r