.config/coc/extensions/node_modules/coc-prettier/node_modules/prettier-eslint/node_modules/typescript/lib/lib.es2015.iterable.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 /// <reference lib="es2015.symbol" />\r
  22 \r
  23 interface SymbolConstructor {\r
  24     /**\r
  25      * A method that returns the default iterator for an object. Called by the semantics of the\r
  26      * for-of statement.\r
  27      */\r
  28     readonly iterator: symbol;\r
  29 }\r
  30 \r
  31 interface IteratorYieldResult<TYield> {\r
  32     done?: false;\r
  33     value: TYield;\r
  34 }\r
  35 \r
  36 interface IteratorReturnResult<TReturn> {\r
  37     done: true;\r
  38     value: TReturn;\r
  39 }\r
  40 \r
  41 type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;\r
  42 \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
  48 }\r
  49 \r
  50 interface Iterable<T> {\r
  51     [Symbol.iterator](): Iterator<T>;\r
  52 }\r
  53 \r
  54 interface IterableIterator<T> extends Iterator<T> {\r
  55     [Symbol.iterator](): IterableIterator<T>;\r
  56 }\r
  57 \r
  58 interface Array<T> {\r
  59     /** Iterator */\r
  60     [Symbol.iterator](): IterableIterator<T>;\r
  61 \r
  62     /**\r
  63      * Returns an iterable of key, value pairs for every entry in the array\r
  64      */\r
  65     entries(): IterableIterator<[number, T]>;\r
  66 \r
  67     /**\r
  68      * Returns an iterable of keys in the array\r
  69      */\r
  70     keys(): IterableIterator<number>;\r
  71 \r
  72     /**\r
  73      * Returns an iterable of values in the array\r
  74      */\r
  75     values(): IterableIterator<T>;\r
  76 }\r
  77 \r
  78 interface ArrayConstructor {\r
  79     /**\r
  80      * Creates an array from an iterable object.\r
  81      * @param iterable An iterable object to convert to an array.\r
  82      */\r
  83     from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];\r
  84 \r
  85     /**\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
  90      */\r
  91     from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];\r
  92 }\r
  93 \r
  94 interface ReadonlyArray<T> {\r
  95     /** Iterator of values in the array. */\r
  96     [Symbol.iterator](): IterableIterator<T>;\r
  97 \r
  98     /**\r
  99      * Returns an iterable of key, value pairs for every entry in the array\r
 100      */\r
 101     entries(): IterableIterator<[number, T]>;\r
 102 \r
 103     /**\r
 104      * Returns an iterable of keys in the array\r
 105      */\r
 106     keys(): IterableIterator<number>;\r
 107 \r
 108     /**\r
 109      * Returns an iterable of values in the array\r
 110      */\r
 111     values(): IterableIterator<T>;\r
 112 }\r
 113 \r
 114 interface IArguments {\r
 115     /** Iterator */\r
 116     [Symbol.iterator](): IterableIterator<any>;\r
 117 }\r
 118 \r
 119 interface Map<K, V> {\r
 120     /** Returns an iterable of entries in the map. */\r
 121     [Symbol.iterator](): IterableIterator<[K, V]>;\r
 122 \r
 123     /**\r
 124      * Returns an iterable of key, value pairs for every entry in the map.\r
 125      */\r
 126     entries(): IterableIterator<[K, V]>;\r
 127 \r
 128     /**\r
 129      * Returns an iterable of keys in the map\r
 130      */\r
 131     keys(): IterableIterator<K>;\r
 132 \r
 133     /**\r
 134      * Returns an iterable of values in the map\r
 135      */\r
 136     values(): IterableIterator<V>;\r
 137 }\r
 138 \r
 139 interface ReadonlyMap<K, V> {\r
 140     /** Returns an iterable of entries in the map. */\r
 141     [Symbol.iterator](): IterableIterator<[K, V]>;\r
 142 \r
 143     /**\r
 144      * Returns an iterable of key, value pairs for every entry in the map.\r
 145      */\r
 146     entries(): IterableIterator<[K, V]>;\r
 147 \r
 148     /**\r
 149      * Returns an iterable of keys in the map\r
 150      */\r
 151     keys(): IterableIterator<K>;\r
 152 \r
 153     /**\r
 154      * Returns an iterable of values in the map\r
 155      */\r
 156     values(): IterableIterator<V>;\r
 157 }\r
 158 \r
 159 interface MapConstructor {\r
 160     new <K, V>(iterable: Iterable<readonly [K, V]>): Map<K, V>;\r
 161 }\r
 162 \r
 163 interface WeakMap<K extends object, V> { }\r
 164 \r
 165 interface WeakMapConstructor {\r
 166     new <K extends object, V>(iterable: Iterable<[K, V]>): WeakMap<K, V>;\r
 167 }\r
 168 \r
 169 interface Set<T> {\r
 170     /** Iterates over values in the set. */\r
 171     [Symbol.iterator](): IterableIterator<T>;\r
 172     /**\r
 173      * Returns an iterable of [v,v] pairs for every value `v` in the set.\r
 174      */\r
 175     entries(): IterableIterator<[T, T]>;\r
 176     /**\r
 177      * Despite its name, returns an iterable of the values in the set,\r
 178      */\r
 179     keys(): IterableIterator<T>;\r
 180 \r
 181     /**\r
 182      * Returns an iterable of values in the set.\r
 183      */\r
 184     values(): IterableIterator<T>;\r
 185 }\r
 186 \r
 187 interface ReadonlySet<T> {\r
 188     /** Iterates over values in the set. */\r
 189     [Symbol.iterator](): IterableIterator<T>;\r
 190 \r
 191     /**\r
 192      * Returns an iterable of [v,v] pairs for every value `v` in the set.\r
 193      */\r
 194     entries(): IterableIterator<[T, T]>;\r
 195 \r
 196     /**\r
 197      * Despite its name, returns an iterable of the values in the set,\r
 198      */\r
 199     keys(): IterableIterator<T>;\r
 200 \r
 201     /**\r
 202      * Returns an iterable of values in the set.\r
 203      */\r
 204     values(): IterableIterator<T>;\r
 205 }\r
 206 \r
 207 interface SetConstructor {\r
 208     new <T>(iterable?: Iterable<T> | null): Set<T>;\r
 209 }\r
 210 \r
 211 interface WeakSet<T extends object> { }\r
 212 \r
 213 interface WeakSetConstructor {\r
 214     new <T extends object = object>(iterable: Iterable<T>): WeakSet<T>;\r
 215 }\r
 216 \r
 217 interface Promise<T> { }\r
 218 \r
 219 interface PromiseConstructor {\r
 220     /**\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
 225      */\r
 226     all<T>(values: Iterable<T | PromiseLike<T>>): Promise<T[]>;\r
 227 \r
 228     /**\r
 229      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved\r
 230      * or rejected.\r
 231      * @param values An iterable of Promises.\r
 232      * @returns A new Promise.\r
 233      */\r
 234     race<T>(values: Iterable<T>): Promise<T extends PromiseLike<infer U> ? U : T>;\r
 235 \r
 236     /**\r
 237      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved\r
 238      * or rejected.\r
 239      * @param values An iterable of Promises.\r
 240      * @returns A new Promise.\r
 241      */\r
 242     race<T>(values: Iterable<T | PromiseLike<T>>): Promise<T>;\r
 243 }\r
 244 \r
 245 declare namespace Reflect {\r
 246     function enumerate(target: object): IterableIterator<any>;\r
 247 }\r
 248 \r
 249 interface String {\r
 250     /** Iterator */\r
 251     [Symbol.iterator](): IterableIterator<string>;\r
 252 }\r
 253 \r
 254 interface Int8Array {\r
 255     [Symbol.iterator](): IterableIterator<number>;\r
 256     /**\r
 257      * Returns an array of key, value pairs for every entry in the array\r
 258      */\r
 259     entries(): IterableIterator<[number, number]>;\r
 260     /**\r
 261      * Returns an list of keys in the array\r
 262      */\r
 263     keys(): IterableIterator<number>;\r
 264     /**\r
 265      * Returns an list of values in the array\r
 266      */\r
 267     values(): IterableIterator<number>;\r
 268 }\r
 269 \r
 270 interface Int8ArrayConstructor {\r
 271     new (elements: Iterable<number>): Int8Array;\r
 272 \r
 273     /**\r
 274      * Creates an array from an array-like or iterable object.\r
 275      * @param arrayLike An array-like or iterable object to convert to an array.\r
 276      * @param mapfn A mapping function to call on every element of the array.\r
 277      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 278      */\r
 279     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array;\r
 280 }\r
 281 \r
 282 interface Uint8Array {\r
 283     [Symbol.iterator](): IterableIterator<number>;\r
 284     /**\r
 285      * Returns an array of key, value pairs for every entry in the array\r
 286      */\r
 287     entries(): IterableIterator<[number, number]>;\r
 288     /**\r
 289      * Returns an list of keys in the array\r
 290      */\r
 291     keys(): IterableIterator<number>;\r
 292     /**\r
 293      * Returns an list of values in the array\r
 294      */\r
 295     values(): IterableIterator<number>;\r
 296 }\r
 297 \r
 298 interface Uint8ArrayConstructor {\r
 299     new (elements: Iterable<number>): Uint8Array;\r
 300 \r
 301     /**\r
 302      * Creates an array from an array-like or iterable object.\r
 303      * @param arrayLike An array-like or iterable object to convert to an array.\r
 304      * @param mapfn A mapping function to call on every element of the array.\r
 305      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 306      */\r
 307     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array;\r
 308 }\r
 309 \r
 310 interface Uint8ClampedArray {\r
 311     [Symbol.iterator](): IterableIterator<number>;\r
 312     /**\r
 313      * Returns an array of key, value pairs for every entry in the array\r
 314      */\r
 315     entries(): IterableIterator<[number, number]>;\r
 316 \r
 317     /**\r
 318      * Returns an list of keys in the array\r
 319      */\r
 320     keys(): IterableIterator<number>;\r
 321 \r
 322     /**\r
 323      * Returns an list of values in the array\r
 324      */\r
 325     values(): IterableIterator<number>;\r
 326 }\r
 327 \r
 328 interface Uint8ClampedArrayConstructor {\r
 329     new (elements: Iterable<number>): Uint8ClampedArray;\r
 330 \r
 331 \r
 332     /**\r
 333      * Creates an array from an array-like or iterable object.\r
 334      * @param arrayLike An array-like or iterable object to convert to an array.\r
 335      * @param mapfn A mapping function to call on every element of the array.\r
 336      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 337      */\r
 338     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray;\r
 339 }\r
 340 \r
 341 interface Int16Array {\r
 342     [Symbol.iterator](): IterableIterator<number>;\r
 343     /**\r
 344      * Returns an array of key, value pairs for every entry in the array\r
 345      */\r
 346     entries(): IterableIterator<[number, number]>;\r
 347 \r
 348     /**\r
 349      * Returns an list of keys in the array\r
 350      */\r
 351     keys(): IterableIterator<number>;\r
 352 \r
 353     /**\r
 354      * Returns an list of values in the array\r
 355      */\r
 356     values(): IterableIterator<number>;\r
 357 }\r
 358 \r
 359 interface Int16ArrayConstructor {\r
 360     new (elements: Iterable<number>): Int16Array;\r
 361 \r
 362     /**\r
 363      * Creates an array from an array-like or iterable object.\r
 364      * @param arrayLike An array-like or iterable object to convert to an array.\r
 365      * @param mapfn A mapping function to call on every element of the array.\r
 366      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 367      */\r
 368     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array;\r
 369 }\r
 370 \r
 371 interface Uint16Array {\r
 372     [Symbol.iterator](): IterableIterator<number>;\r
 373     /**\r
 374      * Returns an array of key, value pairs for every entry in the array\r
 375      */\r
 376     entries(): IterableIterator<[number, number]>;\r
 377     /**\r
 378      * Returns an list of keys in the array\r
 379      */\r
 380     keys(): IterableIterator<number>;\r
 381     /**\r
 382      * Returns an list of values in the array\r
 383      */\r
 384     values(): IterableIterator<number>;\r
 385 }\r
 386 \r
 387 interface Uint16ArrayConstructor {\r
 388     new (elements: Iterable<number>): Uint16Array;\r
 389 \r
 390     /**\r
 391      * Creates an array from an array-like or iterable object.\r
 392      * @param arrayLike An array-like or iterable object to convert to an array.\r
 393      * @param mapfn A mapping function to call on every element of the array.\r
 394      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 395      */\r
 396     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array;\r
 397 }\r
 398 \r
 399 interface Int32Array {\r
 400     [Symbol.iterator](): IterableIterator<number>;\r
 401     /**\r
 402      * Returns an array of key, value pairs for every entry in the array\r
 403      */\r
 404     entries(): IterableIterator<[number, number]>;\r
 405     /**\r
 406      * Returns an list of keys in the array\r
 407      */\r
 408     keys(): IterableIterator<number>;\r
 409     /**\r
 410      * Returns an list of values in the array\r
 411      */\r
 412     values(): IterableIterator<number>;\r
 413 }\r
 414 \r
 415 interface Int32ArrayConstructor {\r
 416     new (elements: Iterable<number>): Int32Array;\r
 417 \r
 418     /**\r
 419      * Creates an array from an array-like or iterable object.\r
 420      * @param arrayLike An array-like or iterable object to convert to an array.\r
 421      * @param mapfn A mapping function to call on every element of the array.\r
 422      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 423      */\r
 424     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array;\r
 425 }\r
 426 \r
 427 interface Uint32Array {\r
 428     [Symbol.iterator](): IterableIterator<number>;\r
 429     /**\r
 430      * Returns an array of key, value pairs for every entry in the array\r
 431      */\r
 432     entries(): IterableIterator<[number, number]>;\r
 433     /**\r
 434      * Returns an list of keys in the array\r
 435      */\r
 436     keys(): IterableIterator<number>;\r
 437     /**\r
 438      * Returns an list of values in the array\r
 439      */\r
 440     values(): IterableIterator<number>;\r
 441 }\r
 442 \r
 443 interface Uint32ArrayConstructor {\r
 444     new (elements: Iterable<number>): Uint32Array;\r
 445 \r
 446     /**\r
 447      * Creates an array from an array-like or iterable object.\r
 448      * @param arrayLike An array-like or iterable object to convert to an array.\r
 449      * @param mapfn A mapping function to call on every element of the array.\r
 450      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 451      */\r
 452     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array;\r
 453 }\r
 454 \r
 455 interface Float32Array {\r
 456     [Symbol.iterator](): IterableIterator<number>;\r
 457     /**\r
 458      * Returns an array of key, value pairs for every entry in the array\r
 459      */\r
 460     entries(): IterableIterator<[number, number]>;\r
 461     /**\r
 462      * Returns an list of keys in the array\r
 463      */\r
 464     keys(): IterableIterator<number>;\r
 465     /**\r
 466      * Returns an list of values in the array\r
 467      */\r
 468     values(): IterableIterator<number>;\r
 469 }\r
 470 \r
 471 interface Float32ArrayConstructor {\r
 472     new (elements: Iterable<number>): Float32Array;\r
 473 \r
 474     /**\r
 475      * Creates an array from an array-like or iterable object.\r
 476      * @param arrayLike An array-like or iterable object to convert to an array.\r
 477      * @param mapfn A mapping function to call on every element of the array.\r
 478      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 479      */\r
 480     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array;\r
 481 }\r
 482 \r
 483 interface Float64Array {\r
 484     [Symbol.iterator](): IterableIterator<number>;\r
 485     /**\r
 486      * Returns an array of key, value pairs for every entry in the array\r
 487      */\r
 488     entries(): IterableIterator<[number, number]>;\r
 489     /**\r
 490      * Returns an list of keys in the array\r
 491      */\r
 492     keys(): IterableIterator<number>;\r
 493     /**\r
 494      * Returns an list of values in the array\r
 495      */\r
 496     values(): IterableIterator<number>;\r
 497 }\r
 498 \r
 499 interface Float64ArrayConstructor {\r
 500     new (elements: Iterable<number>): Float64Array;\r
 501 \r
 502     /**\r
 503      * Creates an array from an array-like or iterable object.\r
 504      * @param arrayLike An array-like or iterable object to convert to an array.\r
 505      * @param mapfn A mapping function to call on every element of the array.\r
 506      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 507      */\r
 508     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;\r
 509 }\r