.config/coc/extensions/node_modules/coc-html/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 interface String {\r
 246     /** Iterator */\r
 247     [Symbol.iterator](): IterableIterator<string>;\r
 248 }\r
 249 \r
 250 interface Int8Array {\r
 251     [Symbol.iterator](): IterableIterator<number>;\r
 252     /**\r
 253      * Returns an array of key, value pairs for every entry in the array\r
 254      */\r
 255     entries(): IterableIterator<[number, number]>;\r
 256     /**\r
 257      * Returns an list of keys in the array\r
 258      */\r
 259     keys(): IterableIterator<number>;\r
 260     /**\r
 261      * Returns an list of values in the array\r
 262      */\r
 263     values(): IterableIterator<number>;\r
 264 }\r
 265 \r
 266 interface Int8ArrayConstructor {\r
 267     new (elements: Iterable<number>): Int8Array;\r
 268 \r
 269     /**\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
 274      */\r
 275     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int8Array;\r
 276 }\r
 277 \r
 278 interface Uint8Array {\r
 279     [Symbol.iterator](): IterableIterator<number>;\r
 280     /**\r
 281      * Returns an array of key, value pairs for every entry in the array\r
 282      */\r
 283     entries(): IterableIterator<[number, number]>;\r
 284     /**\r
 285      * Returns an list of keys in the array\r
 286      */\r
 287     keys(): IterableIterator<number>;\r
 288     /**\r
 289      * Returns an list of values in the array\r
 290      */\r
 291     values(): IterableIterator<number>;\r
 292 }\r
 293 \r
 294 interface Uint8ArrayConstructor {\r
 295     new (elements: Iterable<number>): Uint8Array;\r
 296 \r
 297     /**\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
 302      */\r
 303     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8Array;\r
 304 }\r
 305 \r
 306 interface Uint8ClampedArray {\r
 307     [Symbol.iterator](): IterableIterator<number>;\r
 308     /**\r
 309      * Returns an array of key, value pairs for every entry in the array\r
 310      */\r
 311     entries(): IterableIterator<[number, number]>;\r
 312 \r
 313     /**\r
 314      * Returns an list of keys in the array\r
 315      */\r
 316     keys(): IterableIterator<number>;\r
 317 \r
 318     /**\r
 319      * Returns an list of values in the array\r
 320      */\r
 321     values(): IterableIterator<number>;\r
 322 }\r
 323 \r
 324 interface Uint8ClampedArrayConstructor {\r
 325     new (elements: Iterable<number>): Uint8ClampedArray;\r
 326 \r
 327 \r
 328     /**\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
 333      */\r
 334     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint8ClampedArray;\r
 335 }\r
 336 \r
 337 interface Int16Array {\r
 338     [Symbol.iterator](): IterableIterator<number>;\r
 339     /**\r
 340      * Returns an array of key, value pairs for every entry in the array\r
 341      */\r
 342     entries(): IterableIterator<[number, number]>;\r
 343 \r
 344     /**\r
 345      * Returns an list of keys in the array\r
 346      */\r
 347     keys(): IterableIterator<number>;\r
 348 \r
 349     /**\r
 350      * Returns an list of values in the array\r
 351      */\r
 352     values(): IterableIterator<number>;\r
 353 }\r
 354 \r
 355 interface Int16ArrayConstructor {\r
 356     new (elements: Iterable<number>): Int16Array;\r
 357 \r
 358     /**\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
 363      */\r
 364     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int16Array;\r
 365 }\r
 366 \r
 367 interface Uint16Array {\r
 368     [Symbol.iterator](): IterableIterator<number>;\r
 369     /**\r
 370      * Returns an array of key, value pairs for every entry in the array\r
 371      */\r
 372     entries(): IterableIterator<[number, number]>;\r
 373     /**\r
 374      * Returns an list of keys in the array\r
 375      */\r
 376     keys(): IterableIterator<number>;\r
 377     /**\r
 378      * Returns an list of values in the array\r
 379      */\r
 380     values(): IterableIterator<number>;\r
 381 }\r
 382 \r
 383 interface Uint16ArrayConstructor {\r
 384     new (elements: Iterable<number>): Uint16Array;\r
 385 \r
 386     /**\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
 391      */\r
 392     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint16Array;\r
 393 }\r
 394 \r
 395 interface Int32Array {\r
 396     [Symbol.iterator](): IterableIterator<number>;\r
 397     /**\r
 398      * Returns an array of key, value pairs for every entry in the array\r
 399      */\r
 400     entries(): IterableIterator<[number, number]>;\r
 401     /**\r
 402      * Returns an list of keys in the array\r
 403      */\r
 404     keys(): IterableIterator<number>;\r
 405     /**\r
 406      * Returns an list of values in the array\r
 407      */\r
 408     values(): IterableIterator<number>;\r
 409 }\r
 410 \r
 411 interface Int32ArrayConstructor {\r
 412     new (elements: Iterable<number>): Int32Array;\r
 413 \r
 414     /**\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
 419      */\r
 420     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Int32Array;\r
 421 }\r
 422 \r
 423 interface Uint32Array {\r
 424     [Symbol.iterator](): IterableIterator<number>;\r
 425     /**\r
 426      * Returns an array of key, value pairs for every entry in the array\r
 427      */\r
 428     entries(): IterableIterator<[number, number]>;\r
 429     /**\r
 430      * Returns an list of keys in the array\r
 431      */\r
 432     keys(): IterableIterator<number>;\r
 433     /**\r
 434      * Returns an list of values in the array\r
 435      */\r
 436     values(): IterableIterator<number>;\r
 437 }\r
 438 \r
 439 interface Uint32ArrayConstructor {\r
 440     new (elements: Iterable<number>): Uint32Array;\r
 441 \r
 442     /**\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
 447      */\r
 448     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Uint32Array;\r
 449 }\r
 450 \r
 451 interface Float32Array {\r
 452     [Symbol.iterator](): IterableIterator<number>;\r
 453     /**\r
 454      * Returns an array of key, value pairs for every entry in the array\r
 455      */\r
 456     entries(): IterableIterator<[number, number]>;\r
 457     /**\r
 458      * Returns an list of keys in the array\r
 459      */\r
 460     keys(): IterableIterator<number>;\r
 461     /**\r
 462      * Returns an list of values in the array\r
 463      */\r
 464     values(): IterableIterator<number>;\r
 465 }\r
 466 \r
 467 interface Float32ArrayConstructor {\r
 468     new (elements: Iterable<number>): Float32Array;\r
 469 \r
 470     /**\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
 475      */\r
 476     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float32Array;\r
 477 }\r
 478 \r
 479 interface Float64Array {\r
 480     [Symbol.iterator](): IterableIterator<number>;\r
 481     /**\r
 482      * Returns an array of key, value pairs for every entry in the array\r
 483      */\r
 484     entries(): IterableIterator<[number, number]>;\r
 485     /**\r
 486      * Returns an list of keys in the array\r
 487      */\r
 488     keys(): IterableIterator<number>;\r
 489     /**\r
 490      * Returns an list of values in the array\r
 491      */\r
 492     values(): IterableIterator<number>;\r
 493 }\r
 494 \r
 495 interface Float64ArrayConstructor {\r
 496     new (elements: Iterable<number>): Float64Array;\r
 497 \r
 498     /**\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
 503      */\r
 504     from(arrayLike: Iterable<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;\r
 505 }\r