 < 
 < 
 < /**
-<  * @param {?(function(TYPE):VALUE)=} opt_onFulfilled
-<  * @param {?(function(*): *)=} opt_onRejected
-<  * @return {RESULT}
-<  * @template VALUE
-<  *
-<  * When a Promise (or thenable) is returned from the fulfilled callback,
-<  * the result is the payload of that promise, not the promise itself.
-<  *
-<  * @template RESULT := type('IThenable',
-<  *     cond(isUnknown(VALUE), unknown(),
-<  *       mapunion(VALUE, (V) =>
-<  *         cond(isTemplatized(V) && sub(rawTypeOf(V), 'IThenable'),
-<  *           templateTypeOf(V, 0),
-<  *           cond(sub(V, 'Thenable'),
-<  *              unknown(),
-<  *              V)))))
+<  * @param {?(function(TYPE):FULFILLED_VALUE)=} opt_onFulfilled
+<  * @param {?(function(*):REJECTED_VALUE)=} opt_onRejected
+<  * @return {!IThenable<RESULT>}
+<  *
+<  * @template FULFILLED_VALUE,REJECTED_VALUE
+<  *
+<  * When a `Thenable` is fulfilled or rejected with another `Thenable`, the
+<  * payload of the second is used as the payload of the first.
+<  *
+<  * @template VALUE := union(FULFILLED_VALUE, REJECTED_VALUE) =:
+<  * @template RESULT := cond(
+<  *     isUnknown(VALUE),
+<  *     unknown(),
+<  *     mapunion(VALUE, (V) =>
+<  *         cond(
+<  *             isTemplatized(V) && sub(rawTypeOf(V), 'IThenable'),
+<  *             templateTypeOf(V, 0),
+<  *             cond(
+<  *                 sub(V, 'Thenable'),
+<  *                 unknown(),
+<  *                 V))))
 <  * =:
 <  */
 < IThenable.prototype.then = function(opt_onFulfilled, opt_onRejected) {};

< 
< 
< /**
<  * @param {function(*): RESULT} onRejected
<  * @return {!Promise<RESULT>}
<  * @template RESULT
<  */
< Promise.prototype.catch = function(onRejected) {};
< 

1111,1278d1110
< 
< /**
<  * This is not an official DOM interface. It is used to add generic typing
