dom/canvas/test/webgl-conf/checkout/deqp/temp_externs/es6.js

   1 /*
   2  * Copyright 2014 The Closure Compiler Authors
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @fileoverview Definitions for ECMAScript 6.
  19  * @see http://wiki.ecmascript.org/doku.php?id=harmony:specification_drafts
  20  * @see https://www.khronos.org/registry/typedarray/specs/latest/
  21  * @externs
  22  */
  23
  24 // TODO(johnlenz): symbol should be a primitive type.
  25 /** @typedef {?} */
  26 var symbol;
  27
  28 /**
  29  * @param {string} description
  30  * @return {symbol}
  31  */
  32 function Symbol(description) {}
  33
  34 /** @const {symbol} */
  35 Symbol.iterator;
  36
  37
  38 /**
  39  * @interface
  40  * @template VALUE
  41  */
  42 function Iterable() {}
  43
  44 // TODO(johnlenz): remove this when the compiler understands "symbol" natively
  45 /**
  46  * @return {Iterator.<VALUE>}
  47  * @suppress {externsValidation}
  48  */
  49 Iterable.prototype[Symbol.iterator] = function() {};
  50
  51
  52
  53 // TODO(johnlenz): Iterator should be a templated record type.
  54 /**
  55  * @interface
  56  * @template VALUE
  57  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol
  58  */
  59 function Iterator() {}
  60
  61 /**
  62  * @param {VALUE=} value
  63  * @return {{value:VALUE, done:boolean}}
  64  */
  65 Iterator.prototype.next;
  66
  67
  68 /**
  69  * @constructor
  70  * @see http://people.mozilla.org/~jorendorff/es6-draft.html#sec-generator-objects
  71  * @implements {Iterator<VALUE>}
  72  * @template VALUE
  73  */
  74 var Generator = function() {};
  75
  76 /**
  77  * @param {?=} opt_value
  78  * @return {{value:VALUE, done:boolean}}
  79  * @override
  80  */
  81 Generator.prototype.next = function(opt_value) {};
  82
  83 /**
  84  * @param {VALUE} value
  85  * @return {{value:VALUE, done:boolean}}
  86  */
  87 Generator.prototype.return = function(value) {};
  88
  89 /**
  90  * @param {?} exception
  91  * @return {{value:VALUE, done:boolean}}
  92  */
  93 Generator.prototype.throw = function(exception) {};
  94
  95
  96 // TODO(johnlenz): Array should be Iterable.
  97
  98
  99
 100 /**
 101  * @param {number} value
 102  * @return {number}
 103  * @nosideeffects
 104  */
 105 Math.log10 = function(value) {};
 106
 107 /**
 108  * @param {number} value
 109  * @return {number}
 110  * @nosideeffects
 111  */
 112 Math.log2 = function(value) {};
 113
 114 /**
 115  * @param {number} value
 116  * @return {number}
 117  * @nosideeffects
 118  */
 119 Math.log1p = function(value) {};
 120
 121 /**
 122  * @param {number} value
 123  * @return {number}
 124  * @nosideeffects
 125  */
 126 Math.expm1 = function(value) {};
 127
 128 /**
 129  * @param {number} value
 130  * @return {number}
 131  * @nosideeffects
 132  */
 133 Math.cosh = function(value) {};
 134
 135 /**
 136  * @param {number} value
 137  * @return {number}
 138  * @nosideeffects
 139  */
 140 Math.sinh = function(value) {};
 141
 142 /**
 143  * @param {number} value
 144  * @return {number}
 145  * @nosideeffects
 146  */
 147 Math.tanh = function(value) {};
 148
 149 /**
 150  * @param {number} value
 151  * @return {number}
 152  * @nosideeffects
 153  */
 154 Math.acosh = function(value) {};
 155
 156 /**
 157  * @param {number} value
 158  * @return {number}
 159  * @nosideeffects
 160  */
 161 Math.asinh = function(value) {};
 162
 163 /**
 164  * @param {number} value
 165  * @return {number}
 166  * @nosideeffects
 167  */
 168 Math.atanh = function(value) {};
 169
 170 /**
 171  * @param {number} value
 172  * @return {number}
 173  * @nosideeffects
 174  */
 175 Math.trunc = function(value) {};
 176
 177 /**
 178  * @param {number} value
 179  * @return {number}
 180  * @nosideeffects
 181  */
 182 Math.sign = function(value) {};
 183
 184 /**
 185  * @param {number} value
 186  * @return {number}
 187  * @nosideeffects
 188  */
 189 Math.cbrt = function(value) {};
 190
 191 /**
 192  * @param {number} value1
 193  * @param {...number} var_args
 194  * @return {number}
 195  * @nosideeffects
 196  * @see http://people.mozilla.org/~jorendorff/es6-draft.html#sec-math.hypot
 197  */
 198 Math.hypot = function(value1, var_args) {};
 199
 200
 201 /**
 202  * @param {*} a
 203  * @param {*} b
 204  * @return {boolean}
 205  * @see http://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.is
 206  */
 207 Object.is;
 208
 209
 210 /**
 211  * Returns a language-sensitive string representation of this number.
 212  * @param {(string|!Array<string>)=} opt_locales
 213  * @param {Object=} opt_options
 214  * @return {string}
 215  * @nosideeffects
 216  * @see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
 217  * @see http://www.ecma-international.org/ecma-402/1.0/#sec-13.2.1
 218  * @override
 219  */
 220 Number.prototype.toLocaleString = function(opt_locales, opt_options) {};
 221
 222
 223 /**
 224  * @see http://dev.w3.org/html5/postmsg/
 225  * @interface
 226  */
 227 function Transferable() {}
 228
 229 /**
 230  * @param {number} length The length in bytes
 231  * @constructor
 232  * @noalias
 233  * @throws {Error}
 234  * @nosideeffects
 235  * @implements {Transferable}
 236  */
 237 function ArrayBuffer(length) {}
 238
 239 /** @type {number} */
 240 ArrayBuffer.prototype.byteLength;
 241
 242 /**
 243  * @param {number} begin
 244  * @param {number=} opt_end
 245  * @return {!ArrayBuffer}
 246  * @nosideeffects
 247  */
 248 ArrayBuffer.prototype.slice = function(begin, opt_end) {};
 249
 250
 251 /**
 252  * @constructor
 253  * @noalias
 254  */
 255 function ArrayBufferView() {}
 256
 257 /** @type {!ArrayBuffer} */
 258 ArrayBufferView.prototype.buffer;
 259
 260 /** @type {number} */
 261 ArrayBufferView.prototype.byteOffset;
 262
 263 /** @type {number} */
 264 ArrayBufferView.prototype.byteLength;
 265
 266
 267 /**
 268  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 269  *     or buffer
 270  * @param {number=} opt_byteOffset
 271  * @param {number=} opt_length
 272  * @extends {ArrayBufferView}
 273  * @constructor
 274  * @noalias
 275  * @throws {Error}
 276  * @modifies {arguments} If the user passes a backing array, then indexed
 277  *     accesses will modify the backing array. JSCompiler does not model
 278  *     this well. In other words, if you have:
 279  *     <code>
 280  *     var x = new ArrayBuffer(1);
 281  *     var y = new Int8Array(x);
 282  *     y[0] = 2;
 283  *     </code>
 284  *     JSCompiler will not recognize that the last assignment modifies x.
 285  *     We workaround this by marking all these arrays as @modifies {arguments},
 286  *     to introduce the possibility that x aliases y.
 287  */
 288 function Int8Array(length, opt_byteOffset, opt_length) {}
 289
 290 /** @type {number} */
 291 Int8Array.BYTES_PER_ELEMENT;
 292
 293 /** @type {number} */
 294 Int8Array.prototype.BYTES_PER_ELEMENT;
 295
 296 /** @type {number} */
 297 Int8Array.prototype.length;
 298
 299 /**
 300  * @param {ArrayBufferView|Array.<number>} array
 301  * @param {number=} opt_offset
 302  */
 303 Int8Array.prototype.set = function(array, opt_offset) {};
 304
 305 /**
 306  * @param {number} begin
 307  * @param {number=} opt_end
 308  * @return {!Int8Array}
 309  * @nosideeffects
 310  */
 311 Int8Array.prototype.subarray = function(begin, opt_end) {};
 312
 313
 314 /**
 315  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 316  *     or buffer
 317  * @param {number=} opt_byteOffset
 318  * @param {number=} opt_length
 319  * @extends {ArrayBufferView}
 320  * @constructor
 321  * @noalias
 322  * @throws {Error}
 323  * @modifies {arguments}
 324  */
 325 function Uint8Array(length, opt_byteOffset, opt_length) {}
 326
 327 /** @type {number} */
 328 Uint8Array.BYTES_PER_ELEMENT;
 329
 330 /** @type {number} */
 331 Uint8Array.prototype.BYTES_PER_ELEMENT;
 332
 333 /** @type {number} */
 334 Uint8Array.prototype.length;
 335
 336 /**
 337  * @param {ArrayBufferView|Array.<number>} array
 338  * @param {number=} opt_offset
 339  */
 340 Uint8Array.prototype.set = function(array, opt_offset) {};
 341
 342 /**
 343  * @param {number} begin
 344  * @param {number=} opt_end
 345  * @return {!Uint8Array}
 346  * @nosideeffects
 347  */
 348 Uint8Array.prototype.subarray = function(begin, opt_end) {};
 349
 350
 351 /**
 352  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 353  *     or buffer
 354  * @param {number=} opt_byteOffset
 355  * @param {number=} opt_length
 356  * @extends {ArrayBufferView}
 357  * @constructor
 358  * @noalias
 359  * @throws {Error}
 360  * @modifies {arguments}
 361  */
 362 function Uint8ClampedArray(length, opt_byteOffset, opt_length) {}
 363
 364 /** @type {number} */
 365 Uint8ClampedArray.BYTES_PER_ELEMENT;
 366
 367 /** @type {number} */
 368 Uint8ClampedArray.prototype.BYTES_PER_ELEMENT;
 369
 370 /** @type {number} */
 371 Uint8ClampedArray.prototype.length;
 372
 373 /**
 374  * @param {ArrayBufferView|Array.<number>} array
 375  * @param {number=} opt_offset
 376  */
 377 Uint8ClampedArray.prototype.set = function(array, opt_offset) {};
 378
 379 /**
 380  * @param {number} begin
 381  * @param {number=} opt_end
 382  * @return {!Uint8ClampedArray}
 383  * @nosideeffects
 384  */
 385 Uint8ClampedArray.prototype.subarray = function(begin, opt_end) {};
 386
 387
 388 /**
 389  * @typedef {Uint8ClampedArray}
 390  * @deprecated CanvasPixelArray has been replaced by Uint8ClampedArray
 391  *     in the latest spec.
 392  * @see http://www.w3.org/TR/2dcontext/#imagedata
 393  */
 394 var CanvasPixelArray;
 395
 396
 397 /**
 398  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 399  *     or buffer
 400  * @param {number=} opt_byteOffset
 401  * @param {number=} opt_length
 402  * @extends {ArrayBufferView}
 403  * @constructor
 404  * @noalias
 405  * @throws {Error}
 406  * @modifies {arguments}
 407  */
 408 function Int16Array(length, opt_byteOffset, opt_length) {}
 409
 410 /** @type {number} */
 411 Int16Array.BYTES_PER_ELEMENT;
 412
 413 /** @type {number} */
 414 Int16Array.prototype.BYTES_PER_ELEMENT;
 415
 416 /** @type {number} */
 417 Int16Array.prototype.length;
 418
 419 /**
 420  * @param {ArrayBufferView|Array.<number>} array
 421  * @param {number=} opt_offset
 422  */
 423 Int16Array.prototype.set = function(array, opt_offset) {};
 424
 425 /**
 426  * @param {number} begin
 427  * @param {number=} opt_end
 428  * @return {!Int16Array}
 429  * @nosideeffects
 430  */
 431 Int16Array.prototype.subarray = function(begin, opt_end) {};
 432
 433
 434 /**
 435  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 436  *     or buffer
 437  * @param {number=} opt_byteOffset
 438  * @param {number=} opt_length
 439  * @extends {ArrayBufferView}
 440  * @constructor
 441  * @noalias
 442  * @throws {Error}
 443  * @modifies {arguments}
 444  */
 445 function Uint16Array(length, opt_byteOffset, opt_length) {}
 446
 447 /** @type {number} */
 448 Uint16Array.BYTES_PER_ELEMENT;
 449
 450 /** @type {number} */
 451 Uint16Array.prototype.BYTES_PER_ELEMENT;
 452
 453 /** @type {number} */
 454 Uint16Array.prototype.length;
 455
 456 /**
 457  * @param {ArrayBufferView|Array.<number>} array
 458  * @param {number=} opt_offset
 459  */
 460 Uint16Array.prototype.set = function(array, opt_offset) {};
 461
 462 /**
 463  * @param {number} begin
 464  * @param {number=} opt_end
 465  * @return {!Uint16Array}
 466  * @nosideeffects
 467  */
 468 Uint16Array.prototype.subarray = function(begin, opt_end) {};
 469
 470
 471 /**
 472  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 473  *     or buffer
 474  * @param {number=} opt_byteOffset
 475  * @param {number=} opt_length
 476  * @extends {ArrayBufferView}
 477  * @constructor
 478  * @noalias
 479  * @throws {Error}
 480  * @modifies {arguments}
 481  */
 482 function Int32Array(length, opt_byteOffset, opt_length) {}
 483
 484 /** @type {number} */
 485 Int32Array.BYTES_PER_ELEMENT;
 486
 487 /** @type {number} */
 488 Int32Array.prototype.BYTES_PER_ELEMENT;
 489
 490 /** @type {number} */
 491 Int32Array.prototype.length;
 492
 493 /**
 494  * @param {ArrayBufferView|Array.<number>} array
 495  * @param {number=} opt_offset
 496  */
 497 Int32Array.prototype.set = function(array, opt_offset) {};
 498
 499 /**
 500  * @param {number} begin
 501  * @param {number=} opt_end
 502  * @return {!Int32Array}
 503  * @nosideeffects
 504  */
 505 Int32Array.prototype.subarray = function(begin, opt_end) {};
 506
 507
 508 /**
 509  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 510  *     or buffer
 511  * @param {number=} opt_byteOffset
 512  * @param {number=} opt_length
 513  * @extends {ArrayBufferView}
 514  * @constructor
 515  * @noalias
 516  * @throws {Error}
 517  * @modifies {arguments}
 518  */
 519 function Uint32Array(length, opt_byteOffset, opt_length) {}
 520
 521 /** @type {number} */
 522 Uint32Array.BYTES_PER_ELEMENT;
 523
 524 /** @type {number} */
 525 Uint32Array.prototype.BYTES_PER_ELEMENT;
 526
 527 /** @type {number} */
 528 Uint32Array.prototype.length;
 529
 530 /**
 531  * @param {ArrayBufferView|Array.<number>} array
 532  * @param {number=} opt_offset
 533  */
 534 Uint32Array.prototype.set = function(array, opt_offset) {};
 535
 536 /**
 537  * @param {number} begin
 538  * @param {number=} opt_end
 539  * @return {!Uint32Array}
 540  * @nosideeffects
 541  */
 542 Uint32Array.prototype.subarray = function(begin, opt_end) {};
 543
 544
 545 /**
 546  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 547  *     or buffer
 548  * @param {number=} opt_byteOffset
 549  * @param {number=} opt_length
 550  * @extends {ArrayBufferView}
 551  * @constructor
 552  * @noalias
 553  * @throws {Error}
 554  * @modifies {arguments}
 555  */
 556 function Float32Array(length, opt_byteOffset, opt_length) {}
 557
 558 /** @type {number} */
 559 Float32Array.BYTES_PER_ELEMENT;
 560
 561 /** @type {number} */
 562 Float32Array.prototype.BYTES_PER_ELEMENT;
 563
 564 /** @type {number} */
 565 Float32Array.prototype.length;
 566
 567 /**
 568  * @param {ArrayBufferView|Array.<number>} array
 569  * @param {number=} opt_offset
 570  */
 571 Float32Array.prototype.set = function(array, opt_offset) {};
 572
 573 /**
 574  * @param {number} begin
 575  * @param {number=} opt_end
 576  * @return {!Float32Array}
 577  * @nosideeffects
 578  */
 579 Float32Array.prototype.subarray = function(begin, opt_end) {};
 580
 581
 582 /**
 583  * @param {number|ArrayBufferView|Array.<number>|ArrayBuffer} length or array
 584  *     or buffer
 585  * @param {number=} opt_byteOffset
 586  * @param {number=} opt_length
 587  * @extends {ArrayBufferView}
 588  * @constructor
 589  * @noalias
 590  * @throws {Error}
 591  * @modifies {arguments}
 592  */
 593 function Float64Array(length, opt_byteOffset, opt_length) {}
 594
 595 /** @type {number} */
 596 Float64Array.BYTES_PER_ELEMENT;
 597
 598 /** @type {number} */
 599 Float64Array.prototype.BYTES_PER_ELEMENT;
 600
 601 /** @type {number} */
 602 Float64Array.prototype.length;
 603
 604 /**
 605  * @param {ArrayBufferView|Array.<number>} array
 606  * @param {number=} opt_offset
 607  */
 608 Float64Array.prototype.set = function(array, opt_offset) {};
 609
 610 /**
 611  * @param {number} begin
 612  * @param {number=} opt_end
 613  * @return {!Float64Array}
 614  * @nosideeffects
 615  */
 616 Float64Array.prototype.subarray = function(begin, opt_end) {};
 617
 618
 619 /**
 620  * @param {ArrayBuffer} buffer
 621  * @param {number=} opt_byteOffset
 622  * @param {number=} opt_byteLength
 623  * @extends {ArrayBufferView}
 624  * @constructor
 625  * @noalias
 626  * @throws {Error}
 627  * @nosideeffects
 628  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays/DataView
 629  */
 630 function DataView(buffer, opt_byteOffset, opt_byteLength) {}
 631
 632 /**
 633  * @param {number} byteOffset
 634  * @return {number}
 635  * @throws {Error}
 636  * @nosideeffects
 637  */
 638 DataView.prototype.getInt8 = function(byteOffset) {};
 639
 640 /**
 641  * @param {number} byteOffset
 642  * @return {number}
 643  * @throws {Error}
 644  * @nosideeffects
 645  */
 646 DataView.prototype.getUint8 = function(byteOffset) {};
 647
 648 /**
 649  * @param {number} byteOffset
 650  * @param {boolean=} opt_littleEndian
 651  * @return {number}
 652  * @throws {Error}
 653  * @nosideeffects
 654  */
 655 DataView.prototype.getInt16 = function(byteOffset, opt_littleEndian) {};
 656
 657 /**
 658  * @param {number} byteOffset
 659  * @param {boolean=} opt_littleEndian
 660  * @return {number}
 661  * @throws {Error}
 662  * @nosideeffects
 663  */
 664 DataView.prototype.getUint16 = function(byteOffset, opt_littleEndian) {};
 665
 666 /**
 667  * @param {number} byteOffset
 668  * @param {boolean=} opt_littleEndian
 669  * @return {number}
 670  * @throws {Error}
 671  * @nosideeffects
 672  */
 673 DataView.prototype.getInt32 = function(byteOffset, opt_littleEndian) {};
 674
 675 /**
 676  * @param {number} byteOffset
 677  * @param {boolean=} opt_littleEndian
 678  * @return {number}
 679  * @throws {Error}
 680  * @nosideeffects
 681  */
 682 DataView.prototype.getUint32 = function(byteOffset, opt_littleEndian) {};
 683
 684 /**
 685  * @param {number} byteOffset
 686  * @param {boolean=} opt_littleEndian
 687  * @return {number}
 688  * @throws {Error}
 689  * @nosideeffects
 690  */
 691 DataView.prototype.getFloat32 = function(byteOffset, opt_littleEndian) {};
 692
 693 /**
 694  * @param {number} byteOffset
 695  * @param {boolean=} opt_littleEndian
 696  * @return {number}
 697  * @throws {Error}
 698  * @nosideeffects
 699  */
 700 DataView.prototype.getFloat64 = function(byteOffset, opt_littleEndian) {};
 701
 702 /**
 703  * @param {number} byteOffset
 704  * @param {number} value
 705  * @throws {Error}
 706  */
 707 DataView.prototype.setInt8 = function(byteOffset, value) {};
 708
 709 /**
 710  * @param {number} byteOffset
 711  * @param {number} value
 712  * @throws {Error}
 713  */
 714 DataView.prototype.setUint8 = function(byteOffset, value) {};
 715
 716 /**
 717  * @param {number} byteOffset
 718  * @param {number} value
 719  * @param {boolean=} opt_littleEndian
 720  * @throws {Error}
 721  */
 722 DataView.prototype.setInt16 = function(byteOffset, value, opt_littleEndian) {};
 723
 724 /**
 725  * @param {number} byteOffset
 726  * @param {number} value
 727  * @param {boolean=} opt_littleEndian
 728  * @throws {Error}
 729  */
 730 DataView.prototype.setUint16 = function(byteOffset, value, opt_littleEndian) {};
 731
 732 /**
 733  * @param {number} byteOffset
 734  * @param {number} value
 735  * @param {boolean=} opt_littleEndian
 736  * @throws {Error}
 737  */
 738 DataView.prototype.setInt32 = function(byteOffset, value, opt_littleEndian) {};
 739
 740 /**
 741  * @param {number} byteOffset
 742  * @param {number} value
 743  * @param {boolean=} opt_littleEndian
 744  * @throws {Error}
 745  */
 746 DataView.prototype.setUint32 = function(byteOffset, value, opt_littleEndian) {};
 747
 748 /**
 749  * @param {number} byteOffset
 750  * @param {number} value
 751  * @param {boolean=} opt_littleEndian
 752  * @throws {Error}
 753  */
 754 DataView.prototype.setFloat32 = function(
 755     byteOffset, value, opt_littleEndian) {};
 756
 757 /**
 758  * @param {number} byteOffset
 759  * @param {number} value
 760  * @param {boolean=} opt_littleEndian
 761  * @throws {Error}
 762  */
 763 DataView.prototype.setFloat64 = function(
 764     byteOffset, value, opt_littleEndian) {};
 765
 766
 767 /**
 768  * @see https://github.com/promises-aplus/promises-spec
 769  * @typedef {{then: !Function}}
 770  */
 771 var Thenable;
 772
 773
 774 /**
 775  * This is not an official DOM interface. It is used to add generic typing
 776  * and respective type inference where available.
 777  * {@see goog.Thenable} inherits from this making all promises
 778  * interoperate.
 779  * @interface
 780  * @template TYPE
 781  */
 782 var IThenable = function() {};
 783
 784
 785 /**
 786  * @param {?(function(TYPE):
 787  *             (RESULT|IThenable.<RESULT>|Thenable))=} opt_onFulfilled
 788  * @param {?(function(*): *)=} opt_onRejected
 789  * @return {!IThenable.<RESULT>}
 790  * @template RESULT
 791  */
 792 IThenable.prototype.then = function(opt_onFulfilled, opt_onRejected) {};
 793
 794
 795 /**
 796  * @see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-promise-objects
 797  * @param {function(
 798  *             function((TYPE|IThenable.<TYPE>|Thenable|null)=),
 799  *             function(*=))} resolver
 800  * @constructor
 801  * @implements {IThenable.<TYPE>}
 802  * @template TYPE
 803  */
 804 var Promise = function(resolver) {};
 805
 806
 807 /**
 808  * @param {(TYPE|IThenable.<TYPE>)=} opt_value
 809  * @return {!Promise.<TYPE>}
 810  * @template TYPE
 811  */
 812 Promise.resolve = function(opt_value) {};
 813
 814
 815 /**
 816  * @param {*=} opt_error
 817  * @return {!Promise.<?>}
 818  */
 819 Promise.reject = function(opt_error) {};
 820
 821
 822 /**
 823  * @template T
 824  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
 825  * @param {!Array<T|!Promise<T>>} iterable
 826  * @return {!Promise<!Array<T>>}
 827  */
 828 Promise.all = function(iterable) {};
 829
 830
 831 /**
 832  * @template T
 833  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
 834  * @param {!Array.<T>} iterable
 835  * @return {!Promise.<T>}
 836  */
 837 Promise.race = function(iterable) {};
 838
 839
 840 /**
 841  * @param {?(function(TYPE):
 842  *             (RESULT|IThenable.<RESULT>|Thenable))=} opt_onFulfilled
 843  * @param {?(function(*): *)=} opt_onRejected
 844  * @return {!Promise.<RESULT>}
 845  * @template RESULT
 846  * @override
 847  */
 848 Promise.prototype.then = function(opt_onFulfilled, opt_onRejected) {};
 849
 850
 851 /**
 852  * @param {function(*): RESULT} onRejected
 853  * @return {!Promise.<RESULT>}
 854  * @template RESULT
 855  */
 856 Promise.prototype.catch = function(onRejected) {};