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
21 /// <reference lib="es2015.symbol" />
\r
23 interface SymbolConstructor {
\r
25 * A method that returns the default iterator for an object. Called by the semantics of the
\r
28 readonly iterator: symbol;
\r
31 interface IteratorYieldResult<TYield> {
\r
36 interface IteratorReturnResult<TReturn> {
\r
41 type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
\r
43 interface Iterator<T, TReturn = any, TNext = undefined> {
\r
44 // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
\r
45 next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
\r
46 return?(value?: TReturn): IteratorResult<T, TReturn>;
\r
47 throw?(e?: any): IteratorResult<T, TReturn>;
\r
50 interface Iterable<T> {
\r
51 [Symbol.iterator](): Iterator<T>;
\r
54 interface IterableIterator<T> extends Iterator<T> {
\r
55 [Symbol.iterator](): IterableIterator<T>;
\r
58 interface Array<T> {
\r
60 [Symbol.iterator](): IterableIterator<T>;
\r
63 * Returns an iterable of key, value pairs for every entry in the array
\r
65 entries(): IterableIterator<[number, T]>;
\r
68 * Returns an iterable of keys in the array
\r
70 keys(): IterableIterator<number>;
\r
73 * Returns an iterable of values in the array
\r
75 values(): IterableIterator<T>;
\r
78 interface ArrayConstructor {
\r
80 * Creates an array from an iterable object.
\r
81 * @param iterable An iterable object to convert to an array.
\r
83 from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
\r
86 * Creates an array from an iterable object.
\r
87 * @param iterable An iterable object to convert to an array.
\r
88 * @param mapfn A mapping function to call on every element of the array.
\r
89 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
91 from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
\r
94 interface ReadonlyArray<T> {
\r
95 /** Iterator of values in the array. */
\r
96 [Symbol.iterator](): IterableIterator<T>;
\r
99 * Returns an iterable of key, value pairs for every entry in the array
\r
101 entries(): IterableIterator<[number, T]>;
\r
104 * Returns an iterable of keys in the array
\r
106 keys(): IterableIterator<number>;
\r
109 * Returns an iterable of values in the array
\r
111 values(): IterableIterator<T>;
\r
114 interface IArguments {
\r
116 [Symbol.iterator](): IterableIterator<any>;
\r
119 interface Map<K, V> {
\r
120 /** Returns an iterable of entries in the map. */
\r
121 [Symbol.iterator](): IterableIterator<[K, V]>;
\r
124 * Returns an iterable of key, value pairs for every entry in the map.
\r
126 entries(): IterableIterator<[K, V]>;
\r
129 * Returns an iterable of keys in the map
\r
131 keys(): IterableIterator<K>;
\r
134 * Returns an iterable of values in the map
\r
136 values(): IterableIterator<V>;
\r
139 interface ReadonlyMap<K, V> {
\r
140 /** Returns an iterable of entries in the map. */
\r
141 [Symbol.iterator](): IterableIterator<[K, V]>;
\r
144 * Returns an iterable of key, value pairs for every entry in the map.
\r
146 entries(): IterableIterator<[K, V]>;
\r
149 * Returns an iterable of keys in the map
\r
151 keys(): IterableIterator<K>;
\r
154 * Returns an iterable of values in the map
\r
156 values(): IterableIterator<V>;
\r
159 interface MapConstructor {
\r
160 new <K, V>(iterable: Iterable<readonly [K, V]>): Map<K, V>;
\r
163 interface WeakMap<K extends object, V> { }
\r
165 interface WeakMapConstructor {
\r
166 new <K extends object, V>(iterable: Iterable<[K, V]>): WeakMap<K, V>;
\r
170 /** Iterates over values in the set. */
\r
171 [Symbol.iterator](): IterableIterator<T>;
\r
173 * Returns an iterable of [v,v] pairs for every value `v` in the set.
\r
175 entries(): IterableIterator<[T, T]>;
\r
177 * Despite its name, returns an iterable of the values in the set.
\r
179 keys(): IterableIterator<T>;
\r
182 * Returns an iterable of values in the set.
\r
184 values(): IterableIterator<T>;
\r
187 interface ReadonlySet<T> {
\r
188 /** Iterates over values in the set. */
\r
189 [Symbol.iterator](): IterableIterator<T>;
\r
192 * Returns an iterable of [v,v] pairs for every value `v` in the set.
\r
194 entries(): IterableIterator<[T, T]>;
\r
197 * Despite its name, returns an iterable of the values in the set.
\r
199 keys(): IterableIterator<T>;
\r
202 * Returns an iterable of values in the set.
\r
204 values(): IterableIterator<T>;
\r
207 interface SetConstructor {
\r
208 new <T>(iterable?: Iterable<T> | null): Set<T>;
\r
211 interface WeakSet<T extends object> { }
\r
213 interface WeakSetConstructor {
\r
214 new <T extends object = object>(iterable: Iterable<T>): WeakSet<T>;
\r
217 interface Promise<T> { }
\r
219 interface PromiseConstructor {
\r
221 * Creates a Promise that is resolved with an array of results when all of the provided Promises
\r
222 * resolve, or rejected when any Promise is rejected.
\r
223 * @param values An iterable of Promises.
\r
224 * @returns A new Promise.
\r
226 all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>;
\r
229 * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
\r
231 * @param values An iterable of Promises.
\r
232 * @returns A new Promise.
\r
234 race<T>(values: Iterable<T>): Promise<T extends PromiseLike<infer U> ? U : T>;
\r
237 * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
\r
239 * @param values An iterable of Promises.
\r
240 * @returns A new Promise.
\r
242 race<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>;
\r
247 [Symbol.iterator](): IterableIterator<string>;
\r
250 interface Int8Array {
\r
251 [Symbol.iterator](): IterableIterator<number>;
\r
253 * Returns an array of key, value pairs for every entry in the array
\r
255 entries(): IterableIterator<[number, number]>;
\r
257 * Returns an list of keys in the array
\r
259 keys(): IterableIterator<number>;
\r
261 * Returns an list of values in the array
\r
263 values(): IterableIterator<number>;
\r
266 interface Int8ArrayConstructor {
\r
267 new (elements: Iterable<number>): Int8Array;
\r
270 * Creates an array from an array-like or iterable object.
\r
271 * @param arrayLike An array-like or iterable object to convert to an array.
\r
272 * @param mapfn A mapping function to call on every element of the array.
\r
273 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
275 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array;
\r
278 interface Uint8Array {
\r
279 [Symbol.iterator](): IterableIterator<number>;
\r
281 * Returns an array of key, value pairs for every entry in the array
\r
283 entries(): IterableIterator<[number, number]>;
\r
285 * Returns an list of keys in the array
\r
287 keys(): IterableIterator<number>;
\r
289 * Returns an list of values in the array
\r
291 values(): IterableIterator<number>;
\r
294 interface Uint8ArrayConstructor {
\r
295 new (elements: Iterable<number>): Uint8Array;
\r
298 * Creates an array from an array-like or iterable object.
\r
299 * @param arrayLike An array-like or iterable object to convert to an array.
\r
300 * @param mapfn A mapping function to call on every element of the array.
\r
301 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
303 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array;
\r
306 interface Uint8ClampedArray {
\r
307 [Symbol.iterator](): IterableIterator<number>;
\r
309 * Returns an array of key, value pairs for every entry in the array
\r
311 entries(): IterableIterator<[number, number]>;
\r
314 * Returns an list of keys in the array
\r
316 keys(): IterableIterator<number>;
\r
319 * Returns an list of values in the array
\r
321 values(): IterableIterator<number>;
\r
324 interface Uint8ClampedArrayConstructor {
\r
325 new (elements: Iterable<number>): Uint8ClampedArray;
\r
329 * Creates an array from an array-like or iterable object.
\r
330 * @param arrayLike An array-like or iterable object to convert to an array.
\r
331 * @param mapfn A mapping function to call on every element of the array.
\r
332 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
334 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray;
\r
337 interface Int16Array {
\r
338 [Symbol.iterator](): IterableIterator<number>;
\r
340 * Returns an array of key, value pairs for every entry in the array
\r
342 entries(): IterableIterator<[number, number]>;
\r
345 * Returns an list of keys in the array
\r
347 keys(): IterableIterator<number>;
\r
350 * Returns an list of values in the array
\r
352 values(): IterableIterator<number>;
\r
355 interface Int16ArrayConstructor {
\r
356 new (elements: Iterable<number>): Int16Array;
\r
359 * Creates an array from an array-like or iterable object.
\r
360 * @param arrayLike An array-like or iterable object to convert to an array.
\r
361 * @param mapfn A mapping function to call on every element of the array.
\r
362 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
364 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array;
\r
367 interface Uint16Array {
\r
368 [Symbol.iterator](): IterableIterator<number>;
\r
370 * Returns an array of key, value pairs for every entry in the array
\r
372 entries(): IterableIterator<[number, number]>;
\r
374 * Returns an list of keys in the array
\r
376 keys(): IterableIterator<number>;
\r
378 * Returns an list of values in the array
\r
380 values(): IterableIterator<number>;
\r
383 interface Uint16ArrayConstructor {
\r
384 new (elements: Iterable<number>): Uint16Array;
\r
387 * Creates an array from an array-like or iterable object.
\r
388 * @param arrayLike An array-like or iterable object to convert to an array.
\r
389 * @param mapfn A mapping function to call on every element of the array.
\r
390 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
392 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array;
\r
395 interface Int32Array {
\r
396 [Symbol.iterator](): IterableIterator<number>;
\r
398 * Returns an array of key, value pairs for every entry in the array
\r
400 entries(): IterableIterator<[number, number]>;
\r
402 * Returns an list of keys in the array
\r
404 keys(): IterableIterator<number>;
\r
406 * Returns an list of values in the array
\r
408 values(): IterableIterator<number>;
\r
411 interface Int32ArrayConstructor {
\r
412 new (elements: Iterable<number>): Int32Array;
\r
415 * Creates an array from an array-like or iterable object.
\r
416 * @param arrayLike An array-like or iterable object to convert to an array.
\r
417 * @param mapfn A mapping function to call on every element of the array.
\r
418 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
420 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array;
\r
423 interface Uint32Array {
\r
424 [Symbol.iterator](): IterableIterator<number>;
\r
426 * Returns an array of key, value pairs for every entry in the array
\r
428 entries(): IterableIterator<[number, number]>;
\r
430 * Returns an list of keys in the array
\r
432 keys(): IterableIterator<number>;
\r
434 * Returns an list of values in the array
\r
436 values(): IterableIterator<number>;
\r
439 interface Uint32ArrayConstructor {
\r
440 new (elements: Iterable<number>): Uint32Array;
\r
443 * Creates an array from an array-like or iterable object.
\r
444 * @param arrayLike An array-like or iterable object to convert to an array.
\r
445 * @param mapfn A mapping function to call on every element of the array.
\r
446 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
448 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array;
\r
451 interface Float32Array {
\r
452 [Symbol.iterator](): IterableIterator<number>;
\r
454 * Returns an array of key, value pairs for every entry in the array
\r
456 entries(): IterableIterator<[number, number]>;
\r
458 * Returns an list of keys in the array
\r
460 keys(): IterableIterator<number>;
\r
462 * Returns an list of values in the array
\r
464 values(): IterableIterator<number>;
\r
467 interface Float32ArrayConstructor {
\r
468 new (elements: Iterable<number>): Float32Array;
\r
471 * Creates an array from an array-like or iterable object.
\r
472 * @param arrayLike An array-like or iterable object to convert to an array.
\r
473 * @param mapfn A mapping function to call on every element of the array.
\r
474 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
476 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array;
\r
479 interface Float64Array {
\r
480 [Symbol.iterator](): IterableIterator<number>;
\r
482 * Returns an array of key, value pairs for every entry in the array
\r
484 entries(): IterableIterator<[number, number]>;
\r
486 * Returns an list of keys in the array
\r
488 keys(): IterableIterator<number>;
\r
490 * Returns an list of values in the array
\r
492 values(): IterableIterator<number>;
\r
495 interface Float64ArrayConstructor {
\r
496 new (elements: Iterable<number>): Float64Array;
\r
499 * Creates an array from an array-like or iterable object.
\r
500 * @param arrayLike An array-like or iterable object to convert to an array.
\r
501 * @param mapfn A mapping function to call on every element of the array.
\r
502 * @param thisArg Value of 'this' used to invoke the mapfn.
\r
504 from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;
\r