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
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.
12 See the Apache Version 2.0 License for specific language governing permissions
13 and limitations under the License.
14 ***************************************************************************** */
18 /// <reference no-default-lib="true"/>
\r
23 * Returns a string representation of an object.
\r
24 * @param radix Specifies a radix for converting numeric values to strings.
\r
26 toString(radix?: number): string;
\r
28 /** Returns a string representation appropriate to the host environment's current locale. */
\r
29 toLocaleString(): string;
\r
31 /** Returns the primitive value of the specified object. */
\r
34 readonly [Symbol.toStringTag]: "BigInt";
\r
37 interface BigIntConstructor {
\r
38 (value?: any): bigint;
\r
39 readonly prototype: BigInt;
\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
47 asIntN(bits: number, int: bigint): bigint;
\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
54 asUintN(bits: number, int: bigint): bigint;
\r
57 declare var BigInt: BigIntConstructor;
\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
63 interface BigInt64Array {
\r
64 /** The size in bytes of each element in the array. */
\r
65 readonly BYTES_PER_ELEMENT: number;
\r
67 /** The ArrayBuffer instance referenced by the array. */
\r
68 readonly buffer: ArrayBufferLike;
\r
70 /** The length in bytes of the array. */
\r
71 readonly byteLength: number;
\r
73 /** The offset in bytes of the array. */
\r
74 readonly byteOffset: number;
\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
85 copyWithin(target: number, start: number, end?: number): this;
\r
87 /** Yields index, value pairs for every entry in the array. */
\r
88 entries(): IterableIterator<[number, bigint]>;
\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
98 every(callbackfn: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean;
\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
108 fill(value: bigint, start?: number, end?: number): this;
\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
117 filter(callbackfn: (value: bigint, index: number, array: BigInt64Array) => any, thisArg?: any): BigInt64Array;
\r
120 * Returns the value of the first element in the array where predicate is true, and undefined
\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
128 find(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): bigint | undefined;
\r
131 * Returns the index of the first element in the array where predicate is true, and -1
\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
139 findIndex(predicate: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): number;
\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
148 forEach(callbackfn: (value: bigint, index: number, array: BigInt64Array) => void, thisArg?: any): void;
\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
155 includes(searchElement: bigint, fromIndex?: number): boolean;
\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
163 indexOf(searchElement: bigint, fromIndex?: number): number;
\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
170 join(separator?: string): string;
\r
172 /** Yields each index in the array. */
\r
173 keys(): IterableIterator<number>;
\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
181 lastIndexOf(searchElement: bigint, fromIndex?: number): number;
\r
183 /** The length of the array. */
\r
184 readonly length: number;
\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
194 map(callbackfn: (value: bigint, index: number, array: BigInt64Array) => bigint, thisArg?: any): BigInt64Array;
\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
206 reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint;
\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
218 reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U;
\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
230 reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigInt64Array) => bigint): bigint;
\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
242 reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array) => U, initialValue: U): U;
\r
244 /** Reverses the elements in the array. */
\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
252 set(array: ArrayLike<bigint>, offset?: number): void;
\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
259 slice(start?: number, end?: number): BigInt64Array;
\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
269 some(callbackfn: (value: bigint, index: number, array: BigInt64Array) => boolean, thisArg?: any): boolean;
\r
273 * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order.
\r
275 sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this;
\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
283 subarray(begin?: number, end?: number): BigInt64Array;
\r
285 /** Converts the array to a string by using the current locale. */
\r
286 toLocaleString(): string;
\r
288 /** Returns a string representation of the array. */
\r
289 toString(): string;
\r
291 /** Returns the primitive value of the specified object. */
\r
292 valueOf(): BigInt64Array;
\r
294 /** Yields each value in the array. */
\r
295 values(): IterableIterator<bigint>;
\r
297 [Symbol.iterator](): IterableIterator<bigint>;
\r
299 readonly [Symbol.toStringTag]: "BigInt64Array";
\r
301 [index: number]: bigint;
\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
310 /** The size in bytes of each element in the array. */
\r
311 readonly BYTES_PER_ELEMENT: number;
\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
317 of(...items: bigint[]): BigInt64Array;
\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
325 from(arrayLike: ArrayLike<bigint>): BigInt64Array;
\r
326 from<U>(arrayLike: ArrayLike<U>, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigInt64Array;
\r
329 declare var BigInt64Array: BigInt64ArrayConstructor;
\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
335 interface BigUint64Array {
\r
336 /** The size in bytes of each element in the array. */
\r
337 readonly BYTES_PER_ELEMENT: number;
\r
339 /** The ArrayBuffer instance referenced by the array. */
\r
340 readonly buffer: ArrayBufferLike;
\r
342 /** The length in bytes of the array. */
\r
343 readonly byteLength: number;
\r
345 /** The offset in bytes of the array. */
\r
346 readonly byteOffset: number;
\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
357 copyWithin(target: number, start: number, end?: number): this;
\r
359 /** Yields index, value pairs for every entry in the array. */
\r
360 entries(): IterableIterator<[number, bigint]>;
\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
370 every(callbackfn: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean;
\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
380 fill(value: bigint, start?: number, end?: number): this;
\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
389 filter(callbackfn: (value: bigint, index: number, array: BigUint64Array) => any, thisArg?: any): BigUint64Array;
\r
392 * Returns the value of the first element in the array where predicate is true, and undefined
\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
400 find(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): bigint | undefined;
\r
403 * Returns the index of the first element in the array where predicate is true, and -1
\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
411 findIndex(predicate: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): number;
\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
420 forEach(callbackfn: (value: bigint, index: number, array: BigUint64Array) => void, thisArg?: any): void;
\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
427 includes(searchElement: bigint, fromIndex?: number): boolean;
\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
435 indexOf(searchElement: bigint, fromIndex?: number): number;
\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
442 join(separator?: string): string;
\r
444 /** Yields each index in the array. */
\r
445 keys(): IterableIterator<number>;
\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
453 lastIndexOf(searchElement: bigint, fromIndex?: number): number;
\r
455 /** The length of the array. */
\r
456 readonly length: number;
\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
466 map(callbackfn: (value: bigint, index: number, array: BigUint64Array) => bigint, thisArg?: any): BigUint64Array;
\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
478 reduce(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint;
\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
490 reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U;
\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
502 reduceRight(callbackfn: (previousValue: bigint, currentValue: bigint, currentIndex: number, array: BigUint64Array) => bigint): bigint;
\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
514 reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array) => U, initialValue: U): U;
\r
516 /** Reverses the elements in the array. */
\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
524 set(array: ArrayLike<bigint>, offset?: number): void;
\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
531 slice(start?: number, end?: number): BigUint64Array;
\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
541 some(callbackfn: (value: bigint, index: number, array: BigUint64Array) => boolean, thisArg?: any): boolean;
\r
545 * @param compareFn The function used to determine the order of the elements. If omitted, the elements are sorted in ascending order.
\r
547 sort(compareFn?: (a: bigint, b: bigint) => number | bigint): this;
\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
555 subarray(begin?: number, end?: number): BigUint64Array;
\r
557 /** Converts the array to a string by using the current locale. */
\r
558 toLocaleString(): string;
\r
560 /** Returns a string representation of the array. */
\r
561 toString(): string;
\r
563 /** Returns the primitive value of the specified object. */
\r
564 valueOf(): BigUint64Array;
\r
566 /** Yields each value in the array. */
\r
567 values(): IterableIterator<bigint>;
\r
569 [Symbol.iterator](): IterableIterator<bigint>;
\r
571 readonly [Symbol.toStringTag]: "BigUint64Array";
\r
573 [index: number]: bigint;
\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
582 /** The size in bytes of each element in the array. */
\r
583 readonly BYTES_PER_ELEMENT: number;
\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
589 of(...items: bigint[]): BigUint64Array;
\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
597 from(arrayLike: ArrayLike<bigint>): BigUint64Array;
\r
598 from<U>(arrayLike: ArrayLike<U>, mapfn: (v: U, k: number) => bigint, thisArg?: any): BigUint64Array;
\r
601 declare var BigUint64Array: BigUint64ArrayConstructor;
\r
603 interface DataView {
\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
609 getBigInt64(byteOffset: number, littleEndian?: boolean): bigint;
\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
616 getBigUint64(byteOffset: number, littleEndian?: boolean): bigint;
\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
625 setBigInt64(byteOffset: number, value: bigint, littleEndian?: boolean): void;
\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
634 setBigUint64(byteOffset: number, value: bigint, littleEndian?: boolean): void;
\r