.config/coc/extensions/node_modules/coc-tsserver/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: unique 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<readonly [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<Awaited<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 | PromiseLike<T>>): Promise<Awaited<T>>;\r
 235 }\r
 236 \r
 237 interface String {\r
 238     /** Iterator */\r
 239     [Symbol.iterator](): IterableIterator<string>;\r
 240 }\r
 241 \r
 242 interface Int8Array {\r
 243     [Symbol.iterator](): IterableIterator<number>;\r
 244     /**\r
 245      * Returns an array of key, value pairs for every entry in the array\r
 246      */\r
 247     entries(): IterableIterator<[number, number]>;\r
 248     /**\r
 249      * Returns an list of keys in the array\r
 250      */\r
 251     keys(): IterableIterator<number>;\r
 252     /**\r
 253      * Returns an list of values in the array\r
 254      */\r
 255     values(): IterableIterator<number>;\r
 256 }\r
 257 \r
 258 interface Int8ArrayConstructor {\r
 259     new (elements: Iterable<number>): Int8Array;\r
 260 \r
 261     /**\r
 262      * Creates an array from an array-like or iterable object.\r
 263      * @param arrayLike An array-like or iterable object to convert to an array.\r
 264      * @param mapfn A mapping function to call on every element of the array.\r
 265      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 266      */\r
 267     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array;\r
 268 }\r
 269 \r
 270 interface Uint8Array {\r
 271     [Symbol.iterator](): IterableIterator<number>;\r
 272     /**\r
 273      * Returns an array of key, value pairs for every entry in the array\r
 274      */\r
 275     entries(): IterableIterator<[number, number]>;\r
 276     /**\r
 277      * Returns an list of keys in the array\r
 278      */\r
 279     keys(): IterableIterator<number>;\r
 280     /**\r
 281      * Returns an list of values in the array\r
 282      */\r
 283     values(): IterableIterator<number>;\r
 284 }\r
 285 \r
 286 interface Uint8ArrayConstructor {\r
 287     new (elements: Iterable<number>): Uint8Array;\r
 288 \r
 289     /**\r
 290      * Creates an array from an array-like or iterable object.\r
 291      * @param arrayLike An array-like or iterable object to convert to an array.\r
 292      * @param mapfn A mapping function to call on every element of the array.\r
 293      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 294      */\r
 295     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array;\r
 296 }\r
 297 \r
 298 interface Uint8ClampedArray {\r
 299     [Symbol.iterator](): IterableIterator<number>;\r
 300     /**\r
 301      * Returns an array of key, value pairs for every entry in the array\r
 302      */\r
 303     entries(): IterableIterator<[number, number]>;\r
 304 \r
 305     /**\r
 306      * Returns an list of keys in the array\r
 307      */\r
 308     keys(): IterableIterator<number>;\r
 309 \r
 310     /**\r
 311      * Returns an list of values in the array\r
 312      */\r
 313     values(): IterableIterator<number>;\r
 314 }\r
 315 \r
 316 interface Uint8ClampedArrayConstructor {\r
 317     new (elements: Iterable<number>): Uint8ClampedArray;\r
 318 \r
 319 \r
 320     /**\r
 321      * Creates an array from an array-like or iterable object.\r
 322      * @param arrayLike An array-like or iterable object to convert to an array.\r
 323      * @param mapfn A mapping function to call on every element of the array.\r
 324      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 325      */\r
 326     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray;\r
 327 }\r
 328 \r
 329 interface Int16Array {\r
 330     [Symbol.iterator](): IterableIterator<number>;\r
 331     /**\r
 332      * Returns an array of key, value pairs for every entry in the array\r
 333      */\r
 334     entries(): IterableIterator<[number, number]>;\r
 335 \r
 336     /**\r
 337      * Returns an list of keys in the array\r
 338      */\r
 339     keys(): IterableIterator<number>;\r
 340 \r
 341     /**\r
 342      * Returns an list of values in the array\r
 343      */\r
 344     values(): IterableIterator<number>;\r
 345 }\r
 346 \r
 347 interface Int16ArrayConstructor {\r
 348     new (elements: Iterable<number>): Int16Array;\r
 349 \r
 350     /**\r
 351      * Creates an array from an array-like or iterable object.\r
 352      * @param arrayLike An array-like or iterable object to convert to an array.\r
 353      * @param mapfn A mapping function to call on every element of the array.\r
 354      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 355      */\r
 356     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array;\r
 357 }\r
 358 \r
 359 interface Uint16Array {\r
 360     [Symbol.iterator](): IterableIterator<number>;\r
 361     /**\r
 362      * Returns an array of key, value pairs for every entry in the array\r
 363      */\r
 364     entries(): IterableIterator<[number, number]>;\r
 365     /**\r
 366      * Returns an list of keys in the array\r
 367      */\r
 368     keys(): IterableIterator<number>;\r
 369     /**\r
 370      * Returns an list of values in the array\r
 371      */\r
 372     values(): IterableIterator<number>;\r
 373 }\r
 374 \r
 375 interface Uint16ArrayConstructor {\r
 376     new (elements: Iterable<number>): Uint16Array;\r
 377 \r
 378     /**\r
 379      * Creates an array from an array-like or iterable object.\r
 380      * @param arrayLike An array-like or iterable object to convert to an array.\r
 381      * @param mapfn A mapping function to call on every element of the array.\r
 382      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 383      */\r
 384     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array;\r
 385 }\r
 386 \r
 387 interface Int32Array {\r
 388     [Symbol.iterator](): IterableIterator<number>;\r
 389     /**\r
 390      * Returns an array of key, value pairs for every entry in the array\r
 391      */\r
 392     entries(): IterableIterator<[number, number]>;\r
 393     /**\r
 394      * Returns an list of keys in the array\r
 395      */\r
 396     keys(): IterableIterator<number>;\r
 397     /**\r
 398      * Returns an list of values in the array\r
 399      */\r
 400     values(): IterableIterator<number>;\r
 401 }\r
 402 \r
 403 interface Int32ArrayConstructor {\r
 404     new (elements: Iterable<number>): Int32Array;\r
 405 \r
 406     /**\r
 407      * Creates an array from an array-like or iterable object.\r
 408      * @param arrayLike An array-like or iterable object to convert to an array.\r
 409      * @param mapfn A mapping function to call on every element of the array.\r
 410      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 411      */\r
 412     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array;\r
 413 }\r
 414 \r
 415 interface Uint32Array {\r
 416     [Symbol.iterator](): IterableIterator<number>;\r
 417     /**\r
 418      * Returns an array of key, value pairs for every entry in the array\r
 419      */\r
 420     entries(): IterableIterator<[number, number]>;\r
 421     /**\r
 422      * Returns an list of keys in the array\r
 423      */\r
 424     keys(): IterableIterator<number>;\r
 425     /**\r
 426      * Returns an list of values in the array\r
 427      */\r
 428     values(): IterableIterator<number>;\r
 429 }\r
 430 \r
 431 interface Uint32ArrayConstructor {\r
 432     new (elements: Iterable<number>): Uint32Array;\r
 433 \r
 434     /**\r
 435      * Creates an array from an array-like or iterable object.\r
 436      * @param arrayLike An array-like or iterable object to convert to an array.\r
 437      * @param mapfn A mapping function to call on every element of the array.\r
 438      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 439      */\r
 440     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array;\r
 441 }\r
 442 \r
 443 interface Float32Array {\r
 444     [Symbol.iterator](): IterableIterator<number>;\r
 445     /**\r
 446      * Returns an array of key, value pairs for every entry in the array\r
 447      */\r
 448     entries(): IterableIterator<[number, number]>;\r
 449     /**\r
 450      * Returns an list of keys in the array\r
 451      */\r
 452     keys(): IterableIterator<number>;\r
 453     /**\r
 454      * Returns an list of values in the array\r
 455      */\r
 456     values(): IterableIterator<number>;\r
 457 }\r
 458 \r
 459 interface Float32ArrayConstructor {\r
 460     new (elements: Iterable<number>): Float32Array;\r
 461 \r
 462     /**\r
 463      * Creates an array from an array-like or iterable object.\r
 464      * @param arrayLike An array-like or iterable object to convert to an array.\r
 465      * @param mapfn A mapping function to call on every element of the array.\r
 466      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 467      */\r
 468     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array;\r
 469 }\r
 470 \r
 471 interface Float64Array {\r
 472     [Symbol.iterator](): IterableIterator<number>;\r
 473     /**\r
 474      * Returns an array of key, value pairs for every entry in the array\r
 475      */\r
 476     entries(): IterableIterator<[number, number]>;\r
 477     /**\r
 478      * Returns an list of keys in the array\r
 479      */\r
 480     keys(): IterableIterator<number>;\r
 481     /**\r
 482      * Returns an list of values in the array\r
 483      */\r
 484     values(): IterableIterator<number>;\r
 485 }\r
 486 \r
 487 interface Float64ArrayConstructor {\r
 488     new (elements: Iterable<number>): Float64Array;\r
 489 \r
 490     /**\r
 491      * Creates an array from an array-like or iterable object.\r
 492      * @param arrayLike An array-like or iterable object to convert to an array.\r
 493      * @param mapfn A mapping function to call on every element of the array.\r
 494      * @param thisArg Value of 'this' used to invoke the mapfn.\r
 495      */\r
 496     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;\r
 497 }\r