es6.js (18868B)
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) {};