@typescript-deploys/pr-build 4.7.0-pr-48788-2 → 4.7.0-pr-48791-4

package/lib/tsc.js

@@ -27633,24 +27633,24 @@ var ts;
             return addJSDocComment(finishNode(node, pos));
         }
         function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
-            var triState = isParenthesizedArrowFunctionExpression();
+            var triState = isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction);
             if (triState === 0) {
                 return undefined;
             }
             return triState === 1 ?
-                parseParenthesizedArrowFunctionExpression(true, false) :
+                parseParenthesizedArrowFunctionExpression(true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
-        function isParenthesizedArrowFunctionExpression() {
+        function isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             if (token() === 20 || token() === 29 || token() === 131) {
-                return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
+                return lookAhead(function () { return isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction); });
             }
             if (token() === 38) {
                 return 1;
             }
             return 0;
         }
-        function isParenthesizedArrowFunctionExpressionWorker() {
+        function isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction) {
             if (token() === 131) {
                 nextToken();
                 if (scanner.hasPrecedingLineBreak()) {
@@ -27666,8 +27666,12 @@ var ts;
                 if (second === 21) {
                     var third = nextToken();
                     switch (third) {
-                        case 38:
                         case 58:
+                            if (disallowReturnTypeInArrowFunction) {
+                                return 0;
+                            }
+                            return 1;
+                        case 38:
                         case 18:
                             return 1;
                         default:
@@ -27796,7 +27800,9 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58;
+            if (disallowReturnTypeInArrowFunction && token() === 58) {
+                return undefined;
+            }
             var type = parseReturnType(58, false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -27814,11 +27820,6 @@ var ts;
             var body = (lastToken === 38 || lastToken === 18)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            if (disallowReturnTypeInArrowFunction && hasReturnColon) {
-                if (token() !== 58) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }

package/lib/tsserver.js

@@ -34288,7 +34288,7 @@ var ts;
             return addJSDocComment(finishNode(node, pos));
         }
         function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
-            var triState = isParenthesizedArrowFunctionExpression();
+            var triState = isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction);
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
                 return undefined;
@@ -34298,16 +34298,16 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
         //  Unknown     -> There *might* be a parenthesized arrow function here.
         //                 Speculatively look ahead to be sure, and rollback if not.
-        function isParenthesizedArrowFunctionExpression() {
+        function isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 131 /* AsyncKeyword */) {
-                return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
+                return lookAhead(function () { return isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction); });
             }
             if (token() === 38 /* EqualsGreaterThanToken */) {
                 // ERROR RECOVERY TWEAK:
@@ -34318,7 +34318,7 @@ var ts;
             // Definitely not a parenthesized arrow function.
             return 0 /* False */;
         }
-        function isParenthesizedArrowFunctionExpressionWorker() {
+        function isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction) {
             if (token() === 131 /* AsyncKeyword */) {
                 nextToken();
                 if (scanner.hasPrecedingLineBreak()) {
@@ -34338,8 +34338,13 @@ var ts;
                     // but this is probably what the user intended.
                     var third = nextToken();
                     switch (third) {
-                        case 38 /* EqualsGreaterThanToken */:
                         case 58 /* ColonToken */:
+                            if (disallowReturnTypeInArrowFunction) {
+                                // "a ? () : ..."
+                                return 0 /* False */;
+                            }
+                            return 1 /* True */;
+                        case 38 /* EqualsGreaterThanToken */:
                         case 18 /* OpenBraceToken */:
                             return 1 /* True */;
                         default:
@@ -34506,7 +34511,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34537,30 +34553,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // Given:
-            //     x ? y => ({ y }) : z => ({ z })
-            // We try to parse the body of the first arrow function by looking at:
-            //     ({ y }) : z => ({ z })
-            // This is a valid arrow function with "z" as the return type.
-            //
-            // But, if we're in the true side of a conditional expression, this colon
-            // terminates the expression, so we cannot allow a return type if we aren't
-            // certain whether or not the preceding text was parsed as a parameter list.
-            //
-            // For example,
-            //     a() ? (b: number, c?: string): void => d() : e
-            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
-            // be an arrow expression, so we allow a return type.
-            if (disallowReturnTypeInArrowFunction && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }

package/lib/tsserverlibrary.js

@@ -34482,7 +34482,7 @@ var ts;
             return addJSDocComment(finishNode(node, pos));
         }
         function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
-            var triState = isParenthesizedArrowFunctionExpression();
+            var triState = isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction);
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
                 return undefined;
@@ -34492,16 +34492,16 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
         //  Unknown     -> There *might* be a parenthesized arrow function here.
         //                 Speculatively look ahead to be sure, and rollback if not.
-        function isParenthesizedArrowFunctionExpression() {
+        function isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 131 /* AsyncKeyword */) {
-                return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
+                return lookAhead(function () { return isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction); });
             }
             if (token() === 38 /* EqualsGreaterThanToken */) {
                 // ERROR RECOVERY TWEAK:
@@ -34512,7 +34512,7 @@ var ts;
             // Definitely not a parenthesized arrow function.
             return 0 /* False */;
         }
-        function isParenthesizedArrowFunctionExpressionWorker() {
+        function isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction) {
             if (token() === 131 /* AsyncKeyword */) {
                 nextToken();
                 if (scanner.hasPrecedingLineBreak()) {
@@ -34532,8 +34532,13 @@ var ts;
                     // but this is probably what the user intended.
                     var third = nextToken();
                     switch (third) {
-                        case 38 /* EqualsGreaterThanToken */:
                         case 58 /* ColonToken */:
+                            if (disallowReturnTypeInArrowFunction) {
+                                // "a ? () : ..."
+                                return 0 /* False */;
+                            }
+                            return 1 /* True */;
+                        case 38 /* EqualsGreaterThanToken */:
                         case 18 /* OpenBraceToken */:
                             return 1 /* True */;
                         default:
@@ -34700,7 +34705,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34731,30 +34747,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // Given:
-            //     x ? y => ({ y }) : z => ({ z })
-            // We try to parse the body of the first arrow function by looking at:
-            //     ({ y }) : z => ({ z })
-            // This is a valid arrow function with "z" as the return type.
-            //
-            // But, if we're in the true side of a conditional expression, this colon
-            // terminates the expression, so we cannot allow a return type if we aren't
-            // certain whether or not the preceding text was parsed as a parameter list.
-            //
-            // For example,
-            //     a() ? (b: number, c?: string): void => d() : e
-            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
-            // be an arrow expression, so we allow a return type.
-            if (disallowReturnTypeInArrowFunction && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }

package/lib/typescript.js

@@ -34482,7 +34482,7 @@ var ts;
             return addJSDocComment(finishNode(node, pos));
         }
         function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
-            var triState = isParenthesizedArrowFunctionExpression();
+            var triState = isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction);
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
                 return undefined;
@@ -34492,16 +34492,16 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
         //  Unknown     -> There *might* be a parenthesized arrow function here.
         //                 Speculatively look ahead to be sure, and rollback if not.
-        function isParenthesizedArrowFunctionExpression() {
+        function isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 131 /* AsyncKeyword */) {
-                return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
+                return lookAhead(function () { return isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction); });
             }
             if (token() === 38 /* EqualsGreaterThanToken */) {
                 // ERROR RECOVERY TWEAK:
@@ -34512,7 +34512,7 @@ var ts;
             // Definitely not a parenthesized arrow function.
             return 0 /* False */;
         }
-        function isParenthesizedArrowFunctionExpressionWorker() {
+        function isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction) {
             if (token() === 131 /* AsyncKeyword */) {
                 nextToken();
                 if (scanner.hasPrecedingLineBreak()) {
@@ -34532,8 +34532,13 @@ var ts;
                     // but this is probably what the user intended.
                     var third = nextToken();
                     switch (third) {
-                        case 38 /* EqualsGreaterThanToken */:
                         case 58 /* ColonToken */:
+                            if (disallowReturnTypeInArrowFunction) {
+                                // "a ? () : ..."
+                                return 0 /* False */;
+                            }
+                            return 1 /* True */;
+                        case 38 /* EqualsGreaterThanToken */:
                         case 18 /* OpenBraceToken */:
                             return 1 /* True */;
                         default:
@@ -34700,7 +34705,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34731,30 +34747,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // Given:
-            //     x ? y => ({ y }) : z => ({ z })
-            // We try to parse the body of the first arrow function by looking at:
-            //     ({ y }) : z => ({ z })
-            // This is a valid arrow function with "z" as the return type.
-            //
-            // But, if we're in the true side of a conditional expression, this colon
-            // terminates the expression, so we cannot allow a return type if we aren't
-            // certain whether or not the preceding text was parsed as a parameter list.
-            //
-            // For example,
-            //     a() ? (b: number, c?: string): void => d() : e
-            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
-            // be an arrow expression, so we allow a return type.
-            if (disallowReturnTypeInArrowFunction && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }

package/lib/typescriptServices.js

@@ -34482,7 +34482,7 @@ var ts;
             return addJSDocComment(finishNode(node, pos));
         }
         function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
-            var triState = isParenthesizedArrowFunctionExpression();
+            var triState = isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction);
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
                 return undefined;
@@ -34492,16 +34492,16 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
         //  Unknown     -> There *might* be a parenthesized arrow function here.
         //                 Speculatively look ahead to be sure, and rollback if not.
-        function isParenthesizedArrowFunctionExpression() {
+        function isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 131 /* AsyncKeyword */) {
-                return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
+                return lookAhead(function () { return isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction); });
             }
             if (token() === 38 /* EqualsGreaterThanToken */) {
                 // ERROR RECOVERY TWEAK:
@@ -34512,7 +34512,7 @@ var ts;
             // Definitely not a parenthesized arrow function.
             return 0 /* False */;
         }
-        function isParenthesizedArrowFunctionExpressionWorker() {
+        function isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction) {
             if (token() === 131 /* AsyncKeyword */) {
                 nextToken();
                 if (scanner.hasPrecedingLineBreak()) {
@@ -34532,8 +34532,13 @@ var ts;
                     // but this is probably what the user intended.
                     var third = nextToken();
                     switch (third) {
-                        case 38 /* EqualsGreaterThanToken */:
                         case 58 /* ColonToken */:
+                            if (disallowReturnTypeInArrowFunction) {
+                                // "a ? () : ..."
+                                return 0 /* False */;
+                            }
+                            return 1 /* True */;
+                        case 38 /* EqualsGreaterThanToken */:
                         case 18 /* OpenBraceToken */:
                             return 1 /* True */;
                         default:
@@ -34700,7 +34705,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34731,30 +34747,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // Given:
-            //     x ? y => ({ y }) : z => ({ z })
-            // We try to parse the body of the first arrow function by looking at:
-            //     ({ y }) : z => ({ z })
-            // This is a valid arrow function with "z" as the return type.
-            //
-            // But, if we're in the true side of a conditional expression, this colon
-            // terminates the expression, so we cannot allow a return type if we aren't
-            // certain whether or not the preceding text was parsed as a parameter list.
-            //
-            // For example,
-            //     a() ? (b: number, c?: string): void => d() : e
-            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
-            // be an arrow expression, so we allow a return type.
-            if (disallowReturnTypeInArrowFunction && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }

package/lib/typingsInstaller.js

@@ -34277,7 +34277,7 @@ var ts;
             return addJSDocComment(finishNode(node, pos));
         }
         function tryParseParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
-            var triState = isParenthesizedArrowFunctionExpression();
+            var triState = isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction);
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
                 return undefined;
@@ -34287,16 +34287,16 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*disallowReturnTypeInArrowFunction*/ false) :
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, disallowReturnTypeInArrowFunction) :
                 tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
         //  Unknown     -> There *might* be a parenthesized arrow function here.
         //                 Speculatively look ahead to be sure, and rollback if not.
-        function isParenthesizedArrowFunctionExpression() {
+        function isParenthesizedArrowFunctionExpression(disallowReturnTypeInArrowFunction) {
             if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 131 /* AsyncKeyword */) {
-                return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
+                return lookAhead(function () { return isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction); });
             }
             if (token() === 38 /* EqualsGreaterThanToken */) {
                 // ERROR RECOVERY TWEAK:
@@ -34307,7 +34307,7 @@ var ts;
             // Definitely not a parenthesized arrow function.
             return 0 /* False */;
         }
-        function isParenthesizedArrowFunctionExpressionWorker() {
+        function isParenthesizedArrowFunctionExpressionWorker(disallowReturnTypeInArrowFunction) {
             if (token() === 131 /* AsyncKeyword */) {
                 nextToken();
                 if (scanner.hasPrecedingLineBreak()) {
@@ -34327,8 +34327,13 @@ var ts;
                     // but this is probably what the user intended.
                     var third = nextToken();
                     switch (third) {
-                        case 38 /* EqualsGreaterThanToken */:
                         case 58 /* ColonToken */:
+                            if (disallowReturnTypeInArrowFunction) {
+                                // "a ? () : ..."
+                                return 0 /* False */;
+                            }
+                            return 1 /* True */;
+                        case 38 /* EqualsGreaterThanToken */:
                         case 18 /* OpenBraceToken */:
                             return 1 /* True */;
                         default:
@@ -34495,7 +34500,18 @@ var ts;
                     return undefined;
                 }
             }
-            var hasReturnColon = token() === 58 /* ColonToken */;
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type, even if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
+                return undefined;
+            }
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34526,30 +34542,6 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
-            // Given:
-            //     x ? y => ({ y }) : z => ({ z })
-            // We try to parse the body of the first arrow function by looking at:
-            //     ({ y }) : z => ({ z })
-            // This is a valid arrow function with "z" as the return type.
-            //
-            // But, if we're in the true side of a conditional expression, this colon
-            // terminates the expression, so we cannot allow a return type if we aren't
-            // certain whether or not the preceding text was parsed as a parameter list.
-            //
-            // For example,
-            //     a() ? (b: number, c?: string): void => d() : e
-            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
-            // be an arrow expression, so we allow a return type.
-            if (disallowReturnTypeInArrowFunction && hasReturnColon) {
-                // However, if the arrow function we were able to parse is followed by another colon
-                // as in:
-                //     a ? (x): string => x : null
-                // Then allow the arrow function, and treat the second colon as terminating
-                // the conditional expression.
-                if (token() !== 58 /* ColonToken */) {
-                    return undefined;
-                }
-            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "4.7.0-pr-48788-2",
+  "version": "4.7.0-pr-48791-4",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [