typescript 4.8.0-dev.20220616 → 4.8.0-dev.20220619

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220616";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220619";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -9652,6 +9652,8 @@ var ts;
         Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: diag(8032, ts.DiagnosticCategory.Error, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."),
         A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags: diag(8033, ts.DiagnosticCategory.Error, "A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags_8033", "A JSDoc '@typedef' comment may not contain multiple '@type' tags."),
         The_tag_was_first_specified_here: diag(8034, ts.DiagnosticCategory.Error, "The_tag_was_first_specified_here_8034", "The tag was first specified here."),
+        You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder: diag(8035, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder_8035", "You cannot rename elements that are defined in a 'node_modules' folder."),
+        You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder: diag(8036, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder_8036", "You cannot rename elements that are defined in another 'node_modules' folder."),
         Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9005, ts.DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."),
         Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, ts.DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."),
         JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17000, ts.DiagnosticCategory.Error, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."),
@@ -9922,6 +9924,9 @@ var ts;
         For_await_loops_cannot_be_used_inside_a_class_static_block: diag(18038, ts.DiagnosticCategory.Error, "For_await_loops_cannot_be_used_inside_a_class_static_block_18038", "'For await' loops cannot be used inside a class static block."),
         Invalid_use_of_0_It_cannot_be_used_inside_a_class_static_block: diag(18039, ts.DiagnosticCategory.Error, "Invalid_use_of_0_It_cannot_be_used_inside_a_class_static_block_18039", "Invalid use of '{0}'. It cannot be used inside a class static block."),
         A_return_statement_cannot_be_used_inside_a_class_static_block: diag(18041, ts.DiagnosticCategory.Error, "A_return_statement_cannot_be_used_inside_a_class_static_block_18041", "A 'return' statement cannot be used inside a class static block."),
+        _0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation: diag(18042, ts.DiagnosticCategory.Error, "_0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation_18042", "'{0}' is a type and cannot be imported in JavaScript files. Use '{1}' in a JSDoc type annotation."),
+        Types_cannot_appear_in_export_declarations_in_JavaScript_files: diag(18043, ts.DiagnosticCategory.Error, "Types_cannot_appear_in_export_declarations_in_JavaScript_files_18043", "Types cannot appear in export declarations in JavaScript files."),
+        _0_is_automatically_exported_here: diag(18044, ts.DiagnosticCategory.Message, "_0_is_automatically_exported_here_18044", "'{0}' is automatically exported here."),
     };
 })(ts || (ts = {}));
 var ts;
@@ -34510,10 +34515,10 @@ var ts;
                 setDecoratorContext(/*val*/ false);
             }
             var pos = getNodePos();
-            var expr = parseAssignmentExpressionOrHigher();
+            var expr = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
             var operatorToken;
             while ((operatorToken = parseOptionalToken(27 /* CommaToken */))) {
-                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(), pos);
+                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true), pos);
             }
             if (saveDecoratorContext) {
                 setDecoratorContext(/*val*/ true);
@@ -34521,9 +34526,9 @@ var ts;
             return expr;
         }
         function parseInitializer() {
-            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher() : undefined;
+            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true) : undefined;
         }
-        function parseAssignmentExpressionOrHigher() {
+        function parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction) {
             //  AssignmentExpression[in,yield]:
             //      1) ConditionalExpression[?in,?yield]
             //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -34549,7 +34554,7 @@ var ts;
             // If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
             // not a LeftHandSideExpression, nor does it start a ConditionalExpression.  So we are done
             // with AssignmentExpression if we see one.
-            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction);
             if (arrowExpression) {
                 return arrowExpression;
             }
@@ -34568,7 +34573,7 @@ var ts;
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
             // identifier and the current token is an arrow.
             if (expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
-                return parseSimpleArrowFunctionExpression(pos, expr, /*asyncModifier*/ undefined);
+                return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, /*asyncModifier*/ undefined);
             }
             // Now see if we might be in cases '2' or '3'.
             // If the expression was a LHS expression, and we have an assignment operator, then
@@ -34577,10 +34582,10 @@ var ts;
             // Note: we call reScanGreaterToken so that we get an appropriately merged token
             // for cases like `> > =` becoming `>>=`
             if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
-                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(), pos);
+                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
-            return parseConditionalExpressionRest(expr, pos);
+            return parseConditionalExpressionRest(expr, pos, allowReturnTypeInArrowFunction);
         }
         function isYieldExpression() {
             if (token() === 125 /* YieldKeyword */) {
@@ -34620,7 +34625,7 @@ var ts;
             nextToken();
             if (!scanner.hasPrecedingLineBreak() &&
                 (token() === 41 /* AsteriskToken */ || isStartOfExpression())) {
-                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher()), pos);
+                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true)), pos);
             }
             else {
                 // if the next token is not on the same line as yield.  or we don't have an '*' or
@@ -34628,7 +34633,7 @@ var ts;
                 return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos);
             }
         }
-        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier) {
+        function parseSimpleArrowFunctionExpression(pos, identifier, allowReturnTypeInArrowFunction, asyncModifier) {
             ts.Debug.assert(token() === 38 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
             var parameter = factory.createParameterDeclaration(
             /*modifiers*/ undefined, 
@@ -34639,11 +34644,11 @@ var ts;
             finishNode(parameter, identifier.pos);
             var parameters = createNodeArray([parameter], parameter.pos, parameter.end);
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
-            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
+            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier, allowReturnTypeInArrowFunction);
             var node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters, /*type*/ undefined, equalsGreaterThanToken, body);
             return addJSDocComment(finishNode(node, pos));
         }
-        function tryParseParenthesizedArrowFunctionExpression() {
+        function tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
             var triState = isParenthesizedArrowFunctionExpression();
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
@@ -34654,8 +34659,8 @@ 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) :
-                tryParse(parsePossibleParenthesizedArrowFunctionExpression);
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*allowReturnTypeInArrowFunction*/ true) :
+                tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
@@ -34789,25 +34794,25 @@ var ts;
                 return 2 /* Unknown */;
             }
         }
-        function parsePossibleParenthesizedArrowFunctionExpression() {
+        function parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
             var tokenPos = scanner.getTokenPos();
             if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
                 return undefined;
             }
-            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
+            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false, allowReturnTypeInArrowFunction);
             if (!result) {
                 (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
             }
             return result;
         }
-        function tryParseAsyncSimpleArrowFunctionExpression() {
+        function tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction) {
             // We do a check here so that we won't be doing unnecessarily call to "lookAhead"
             if (token() === 131 /* AsyncKeyword */) {
                 if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* True */) {
                     var pos = getNodePos();
                     var asyncModifier = parseModifiersForArrowFunction();
                     var expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
-                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
+                    return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, asyncModifier);
                 }
             }
             return undefined;
@@ -34831,7 +34836,7 @@ var ts;
             }
             return 0 /* False */;
         }
-        function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
+        function parseParenthesizedArrowFunctionExpression(allowAmbiguity, allowReturnTypeInArrowFunction) {
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiersForArrowFunction();
@@ -34866,6 +34871,7 @@ var ts;
                     return undefined;
                 }
             }
+            var hasReturnColon = token() === 58 /* ColonToken */;
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34894,12 +34900,37 @@ var ts;
             var lastToken = token();
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
-                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier))
+                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), allowReturnTypeInArrowFunction)
                 : 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 (!allowReturnTypeInArrowFunction && 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. It's okay to do this because this code would
+                // be a syntax error in JavaScript (as the second colon shouldn't be there).
+                if (token() !== 58 /* ColonToken */) {
+                    return undefined;
+                }
+            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function parseArrowFunctionExpressionBody(isAsync) {
+        function parseArrowFunctionExpressionBody(isAsync, allowReturnTypeInArrowFunction) {
             if (token() === 18 /* OpenBraceToken */) {
                 return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
             }
@@ -34927,12 +34958,12 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var node = isAsync
-                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
-                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
+                ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction); })
+                : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction); });
             topLevel = savedTopLevel;
             return node;
         }
-        function parseConditionalExpressionRest(leftOperand, pos) {
+        function parseConditionalExpressionRest(leftOperand, pos, allowReturnTypeInArrowFunction) {
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
             var questionToken = parseOptionalToken(57 /* QuestionToken */);
             if (!questionToken) {
@@ -34941,8 +34972,8 @@ var ts;
             // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
             // we do not that for the 'whenFalse' part.
             var colonToken;
-            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher()
+            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ false); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
+                ? parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction)
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {
@@ -35857,13 +35888,13 @@ var ts;
         function parseSpreadElement() {
             var pos = getNodePos();
             parseExpected(25 /* DotDotDotToken */);
-            var expression = parseAssignmentExpressionOrHigher();
+            var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
             return finishNode(factory.createSpreadElement(expression), pos);
         }
         function parseArgumentOrArrayLiteralElement() {
             return token() === 25 /* DotDotDotToken */ ? parseSpreadElement() :
                 token() === 27 /* CommaToken */ ? finishNode(factory.createOmittedExpression(), getNodePos()) :
-                    parseAssignmentExpressionOrHigher();
+                    parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
         }
         function parseArgumentExpression() {
             return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
@@ -35881,7 +35912,7 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             if (parseOptionalToken(25 /* DotDotDotToken */)) {
-                var expression = parseAssignmentExpressionOrHigher();
+                var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
                 return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc);
             }
             var decorators = parseDecorators();
@@ -35910,7 +35941,7 @@ var ts;
             var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58 /* ColonToken */);
             if (isShorthandPropertyAssignment) {
                 var equalsToken = parseOptionalToken(63 /* EqualsToken */);
-                var objectAssignmentInitializer = equalsToken ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
+                var objectAssignmentInitializer = equalsToken ? allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); }) : undefined;
                 node = factory.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
                 // Save equals token for error reporting.
                 // TODO(rbuckton): Consider manufacturing this when we need to report an error as it is otherwise not useful.
@@ -35918,7 +35949,7 @@ var ts;
             }
             else {
                 parseExpected(58 /* ColonToken */);
-                var initializer = allowInAnd(parseAssignmentExpressionOrHigher);
+                var initializer = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); });
                 node = factory.createPropertyAssignment(name, initializer);
             }
             // Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are reported in the grammar checker
@@ -36095,7 +36126,7 @@ var ts;
             }
             var node;
             if (awaitToken ? parseExpected(160 /* OfKeyword */) : parseOptional(160 /* OfKeyword */)) {
-                var expression = allowInAnd(parseAssignmentExpressionOrHigher);
+                var expression = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); });
                 parseExpected(21 /* CloseParenToken */);
                 node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement());
             }
@@ -37283,7 +37314,7 @@ var ts;
             var pos = getNodePos();
             var name = ts.tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10 /* StringLiteral */);
             parseExpected(58 /* ColonToken */);
-            var value = parseAssignmentExpressionOrHigher();
+            var value = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
             return finishNode(factory.createAssertEntry(name, value), pos);
         }
         function parseAssertClause(skipAssertKeyword) {
@@ -37524,7 +37555,7 @@ var ts;
             else {
                 parseExpected(88 /* DefaultKeyword */);
             }
-            var expression = parseAssignmentExpressionOrHigher();
+            var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
             parseSemicolon();
             setAwaitContext(savedAwaitContext);
             var node = factory.createExportAssignment(modifiers, isExportEquals, expression);
@@ -48890,9 +48921,9 @@ var ts;
                 return moduleSpecifier && resolveExternalModuleName(moduleSpecifier, moduleSpecifier, /*ignoreErrors*/ true);
             },
             resolveExternalModuleSymbol: resolveExternalModuleSymbol,
-            tryGetThisTypeAt: function (nodeIn, includeGlobalThis) {
+            tryGetThisTypeAt: function (nodeIn, includeGlobalThis, container) {
                 var node = ts.getParseTreeNode(nodeIn);
-                return node && tryGetThisTypeAt(node, includeGlobalThis);
+                return node && tryGetThisTypeAt(node, includeGlobalThis, container);
             },
             getTypeArgumentConstraint: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode);
@@ -59340,7 +59371,7 @@ var ts;
                 }
                 if (t.flags & 268435456 /* StringMapping */) {
                     var constraint = getBaseConstraint(t.type);
-                    return constraint ? getStringMappingType(t.symbol, constraint) : stringType;
+                    return constraint && constraint !== t.type ? getStringMappingType(t.symbol, constraint) : stringType;
                 }
                 if (t.flags & 8388608 /* IndexedAccess */) {
                     if (isMappedTypeGenericIndexedAccess(t)) {
@@ -62310,9 +62341,12 @@ var ts;
         }
         function getStringMappingType(symbol, type) {
             return type.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapType(type, function (t) { return getStringMappingType(symbol, t); }) :
-                isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) :
-                    type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) :
-                        type;
+                // Mapping<Mapping<T>> === Mapping<T>
+                type.flags & 268435456 /* StringMapping */ && symbol === type.symbol ? type :
+                    isGenericIndexType(type) || isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, isPatternLiteralPlaceholderType(type) && !(type.flags & 268435456 /* StringMapping */) ? getTemplateLiteralType(["", ""], [type]) : type) :
+                        type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) :
+                            type.flags & 134217728 /* TemplateLiteral */ ? getTemplateLiteralType.apply(void 0, applyTemplateStringMapping(symbol, type.texts, type.types)) :
+                                type;
         }
         function applyStringMapping(symbol, str) {
             switch (intrinsicTypeKinds.get(symbol.escapedName)) {
@@ -62323,6 +62357,15 @@ var ts;
             }
             return str;
         }
+        function applyTemplateStringMapping(symbol, texts, types) {
+            switch (intrinsicTypeKinds.get(symbol.escapedName)) {
+                case 0 /* Uppercase */: return [texts.map(function (t) { return t.toUpperCase(); }), types.map(function (t) { return getStringMappingType(symbol, t); })];
+                case 1 /* Lowercase */: return [texts.map(function (t) { return t.toLowerCase(); }), types.map(function (t) { return getStringMappingType(symbol, t); })];
+                case 2 /* Capitalize */: return [texts[0] === "" ? texts : __spreadArray([texts[0].charAt(0).toUpperCase() + texts[0].slice(1)], texts.slice(1), true), texts[0] === "" ? __spreadArray([getStringMappingType(symbol, types[0])], types.slice(1), true) : types];
+                case 3 /* Uncapitalize */: return [texts[0] === "" ? texts : __spreadArray([texts[0].charAt(0).toLowerCase() + texts[0].slice(1)], texts.slice(1), true), texts[0] === "" ? __spreadArray([getStringMappingType(symbol, types[0])], types.slice(1), true) : types];
+            }
+            return [texts, types];
+        }
         function getStringMappingTypeForGenericType(symbol, type) {
             var id = getSymbolId(symbol) + "," + getTypeId(type);
             var result = stringMappingTypes.get(id);
@@ -62564,7 +62607,7 @@ var ts;
                         accessNode;
         }
         function isPatternLiteralPlaceholderType(type) {
-            return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */));
+            return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) || !!(type.flags & 268435456 /* StringMapping */ && isPatternLiteralPlaceholderType(type.type));
         }
         function isPatternLiteralType(type) {
             return !!(type.flags & 134217728 /* TemplateLiteral */) && ts.every(type.types, isPatternLiteralPlaceholderType);
@@ -66276,6 +66319,13 @@ var ts;
                         return -1 /* True */;
                     }
                 }
+                else if (target.flags & 268435456 /* StringMapping */) {
+                    if (!(source.flags & 268435456 /* StringMapping */)) {
+                        if (isMemberOfStringMapping(source, target)) {
+                            return -1 /* True */;
+                        }
+                    }
+                }
                 if (sourceFlags & 8650752 /* TypeVariable */) {
                     // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
                     if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
@@ -66319,7 +66369,10 @@ var ts;
                     }
                 }
                 else if (sourceFlags & 268435456 /* StringMapping */) {
-                    if (targetFlags & 268435456 /* StringMapping */ && source.symbol === target.symbol) {
+                    if (targetFlags & 268435456 /* StringMapping */) {
+                        if (source.symbol !== target.symbol) {
+                            return 0 /* False */;
+                        }
                         if (result = isRelatedTo(source.type, target.type, 3 /* Both */, reportErrors)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
@@ -67244,7 +67297,7 @@ var ts;
                     return typeCouldHaveTopLevelSingletonTypes(constraint);
                 }
             }
-            return isUnitType(type) || !!(type.flags & 134217728 /* TemplateLiteral */);
+            return isUnitType(type) || !!(type.flags & 134217728 /* TemplateLiteral */) || !!(type.flags & 268435456 /* StringMapping */);
         }
         function getExactOptionalUnassignableProperties(source, target) {
             if (isTupleType(source) && isTupleType(target))
@@ -68715,6 +68768,31 @@ var ts;
             return success && result === 9 /* BigIntLiteral */ && scanner.getTextPos() === (s.length + 1) && !(flags & 512 /* ContainsSeparator */)
                 && (!roundTripOnly || s === ts.pseudoBigIntToString({ negative: negative, base10Value: ts.parsePseudoBigInt(scanner.getTokenValue()) }));
         }
+        function isMemberOfStringMapping(source, target) {
+            if (target.flags & (4 /* String */ | 3 /* AnyOrUnknown */)) {
+                return true;
+            }
+            if (target.flags & 134217728 /* TemplateLiteral */) {
+                return isTypeAssignableTo(source, target);
+            }
+            if (target.flags & 268435456 /* StringMapping */) {
+                // We need to see whether applying the same mappings of the target
+                // onto the source would produce an identical type *and* that
+                // it's compatible with the inner-most non-string-mapped type.
+                //
+                // The intuition here is that if same mappings don't affect the source at all,
+                // and the source is compatible with the unmapped target, then they must
+                // still reside in the same domain.
+                var mappingStack = [];
+                while (target.flags & 268435456 /* StringMapping */) {
+                    mappingStack.unshift(target.symbol);
+                    target = target.type;
+                }
+                var mappedSource = ts.reduceLeft(mappingStack, function (memo, value) { return getStringMappingType(value, memo); }, source);
+                return mappedSource === source && isMemberOfStringMapping(source, target);
+            }
+            return false;
+        }
         function isValidTypeForTemplateLiteralPlaceholder(source, target) {
             if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
                 return true;
@@ -68723,7 +68801,8 @@ var ts;
                 var value = source.value;
                 return !!(target.flags & 8 /* Number */ && isValidNumberString(value, /*roundTripOnly*/ false) ||
                     target.flags & 64 /* BigInt */ && isValidBigIntString(value, /*roundTripOnly*/ false) ||
-                    target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName);
+                    target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName ||
+                    target.flags & 268435456 /* StringMapping */ && isMemberOfStringMapping(getStringLiteralType(value), target));
             }
             if (source.flags & 134217728 /* TemplateLiteral */) {
                 var texts = source.texts;
@@ -85602,6 +85681,7 @@ var ts;
             return true;
         }
         function checkAliasSymbol(node) {
+            var _a, _b, _c, _d, _e;
             var symbol = getSymbolOfNode(node);
             var target = resolveAlias(symbol);
             if (target !== unknownSymbol) {
@@ -85612,6 +85692,31 @@ var ts;
                 // otherwise it will conflict with some local declaration). Note that in addition to normal flags we include matching SymbolFlags.Export*
                 // in order to prevent collisions with declarations that were exported from the current module (they still contribute to local names).
                 symbol = getMergedSymbol(symbol.exportSymbol || symbol);
+                // A type-only import/export will already have a grammar error in a JS file, so no need to issue more errors within
+                if (ts.isInJSFile(node) && !(target.flags & 111551 /* Value */) && !ts.isTypeOnlyImportOrExportDeclaration(node)) {
+                    var errorNode = ts.isImportOrExportSpecifier(node) ? node.propertyName || node.name :
+                        ts.isNamedDeclaration(node) ? node.name :
+                            node;
+                    ts.Debug.assert(node.kind !== 274 /* NamespaceExport */);
+                    if (node.kind === 275 /* ExportSpecifier */) {
+                        var diag = error(errorNode, ts.Diagnostics.Types_cannot_appear_in_export_declarations_in_JavaScript_files);
+                        var alreadyExportedSymbol = (_b = (_a = ts.getSourceFileOfNode(node).symbol) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.get((node.propertyName || node.name).escapedText);
+                        if (alreadyExportedSymbol === target) {
+                            var exportingDeclaration = (_c = alreadyExportedSymbol.declarations) === null || _c === void 0 ? void 0 : _c.find(ts.isJSDocNode);
+                            if (exportingDeclaration) {
+                                ts.addRelatedInfo(diag, ts.createDiagnosticForNode(exportingDeclaration, ts.Diagnostics._0_is_automatically_exported_here, ts.unescapeLeadingUnderscores(alreadyExportedSymbol.escapedName)));
+                            }
+                        }
+                    }
+                    else {
+                        ts.Debug.assert(node.kind !== 254 /* VariableDeclaration */);
+                        var importDeclaration = ts.findAncestor(node, ts.or(ts.isImportDeclaration, ts.isImportEqualsDeclaration));
+                        var moduleSpecifier = (_e = (importDeclaration && ((_d = ts.tryGetModuleSpecifierFromDeclaration(importDeclaration)) === null || _d === void 0 ? void 0 : _d.text))) !== null && _e !== void 0 ? _e : "...";
+                        var importedIdentifier = ts.unescapeLeadingUnderscores(ts.isIdentifier(errorNode) ? errorNode.escapedText : symbol.escapedName);
+                        error(errorNode, ts.Diagnostics._0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation, importedIdentifier, "import(\"" + moduleSpecifier + "\")." + importedIdentifier);
+                    }
+                    return;
+                }
                 var excludedMeanings = (symbol.flags & (111551 /* Value */ | 1048576 /* ExportValue */) ? 111551 /* Value */ : 0) |
                     (symbol.flags & 788968 /* Type */ ? 788968 /* Type */ : 0) |
                     (symbol.flags & 1920 /* Namespace */ ? 1920 /* Namespace */ : 0);

package/lib/zh-cn/diagnosticMessages.generated.json

@@ -132,6 +132,8 @@
   "Add_definite_assignment_assertion_to_property_0_95020": "向属性“{0}”添加明确的赋值断言",
   "Add_definite_assignment_assertions_to_all_uninitialized_properties_95028": "将明确赋值断言添加到未初始化的所有属性",
   "Add_export_to_make_this_file_into_a_module_95097": "添加 \"export {}\"，将此文件变为模块",
+  "Add_extends_constraint_2211": "添加 `extends` 约束。",
+  "Add_extends_constraint_to_all_type_parameters_2212": "将 `extends` 约束添加到所有类型参数",
   "Add_import_from_0_90057": "从“{0}”添加导入",
   "Add_index_signature_for_property_0_90017": "为属性“{0}”添加索引签名",
   "Add_initializer_to_property_0_95019": "向属性“{0}”添加初始值设定项",
@@ -1493,7 +1495,7 @@
   "This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found_2354": "此语法需要一个导入的帮助程序，但找不到模块“{0}”。",
   "This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_ve_2343": "此语法需要名为 \"{1}\" 的导入帮助器，\"{0}\" 中不存在该帮助器。请考虑升级 \"{0}\" 的版本。",
   "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807": "此语法需要一个名为 \"{1}\" 且包含 {2} 参数的导入帮助程序，该帮助程序与 \"{0}\" 中的相应帮助程序不兼容。请考虑升级 \"{0}\" 的版本。",
-  "This_type_parameter_probably_needs_an_extends_object_constraint_2208": "此类型参数可能需要 \"extends object\" 约束。",
+  "This_type_parameter_might_need_an_extends_0_constraint_2208": "此类型参数可能需要 `extends {0}` 约束。",
   "This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot__1326": "“import” 的这种用法无效。可以写入 “import()” 调用，但它们必须具有括号，并且不能带有类型参数。",
   "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_n_1378": "仅当 “module” 选项设置为 “es2022”、“esnext”、“system”、“node16” 或 “nodenext”，且 “target” 选项设置为 “es2017” 或更高版本时，才允许使用顶级 “await” 表达式。",
   "Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier_1046": ".d.ts 文件中的顶级声明必须以 \"declare\" 或 \"export\" 修饰符开头。",
@@ -1651,6 +1653,7 @@
   "Watch_and_Build_Modes_6250": "观看和生成模式",
   "Watch_input_files_6005": "监视输入文件。",
   "Watch_option_0_requires_a_value_of_type_1_5080": "观察选项 \"{0}\" 需要 {1} 类型的值。",
+  "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843": "我们只能通过在此处为整个参数添加类型来写入“{0}”的类型。",
   "When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible_6698": "分配函数时，请检查以确保参数和返回值与子类型兼容。",
   "When_type_checking_take_into_account_null_and_undefined_6699": "进行类型检查时，请考虑 “null” 和 “undefined”。",
   "Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen_6191": "是否在监视模式下保留过时的控制台输出，而不是清除屏幕。",
@@ -1690,6 +1693,7 @@
   "_0_index_type_1_is_not_assignable_to_2_index_type_3_2413": "“{0}”索引类型“{1}”不能分配给“{2}”索引类型“{3}”。",
   "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692": "“{0}”是基元，但“{1}”是包装器对象。如可能首选使用“{0}”。",
   "_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedMod_1444": "\"{0}\" 是一种类型，在同时启用了 \"preserveValueImports\" 和 \"isolatedModules\" 时，必须使用仅类型导入进行导入。",
+  "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842": "“{0}”是“{1}”的未使用重命名。是否打算将其用作类型批注?",
   "_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_5075": "\"{0}\" 可赋给 \"{1}\" 类型的约束，但可以使用约束 \"{2}\" 的其他子类型实例化 \"{1}\"。",
   "_0_is_declared_but_its_value_is_never_read_6133": "已声明“{0}”，但从未读取其值。",
   "_0_is_declared_but_never_used_6196": "“{0}”已声明，但从未使用过。",

package/lib/zh-tw/diagnosticMessages.generated.json

@@ -132,6 +132,8 @@
   "Add_definite_assignment_assertion_to_property_0_95020": "將明確指派判斷提示新增至屬性 '{0}'",
   "Add_definite_assignment_assertions_to_all_uninitialized_properties_95028": "為所有未初始化的屬性新增明確的指派判斷提示",
   "Add_export_to_make_this_file_into_a_module_95097": "新增 'export {}' 以將此檔案轉為模組",
+  "Add_extends_constraint_2211": "新增 'extends' 限制式。",
+  "Add_extends_constraint_to_all_type_parameters_2212": "將 'extends' 限制式新增至所有類型參數",
   "Add_import_from_0_90057": "從 \"{0}\" 新增匯入",
   "Add_index_signature_for_property_0_90017": "為屬性 '{0}' 新增索引簽章",
   "Add_initializer_to_property_0_95019": "將初始設定式新增至屬性 '{0}'",
@@ -1493,7 +1495,7 @@
   "This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found_2354": "此語法需要已匯入的協助程式，但找不到模組 '{0}'。",
   "This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_ve_2343": "此語法需要名為 '{1}' 的已匯入協助程式，但其不存在於 '{0}' 中。請考慮升級您的 '{0}' 版本。",
   "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807": "此語法需要名為 '{1}' 且具有 {2} 參數的匯入協助程式，其與 '{0}' 中的參數不相容。請考慮升級 '{0}' 的版本。",
-  "This_type_parameter_probably_needs_an_extends_object_constraint_2208": "此類型參數可能需要 'extends object' 限制式。",
+  "This_type_parameter_might_need_an_extends_0_constraint_2208": "此類型參數可能需要 'extends {0}' 限制式。",
   "This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot__1326": "此 'import' 的使用方式無效。'import()' 呼叫可以寫入，但必須有括弧，而且不能有類型引數。",
   "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_n_1378": "只有在 'module' 選項設定為 'es2022'、'esnext'、'system'、'node16' 或 'nodenext'，而且 'target' 選項設定為 'es2017' 或更高版本時，才允許最上層的 'await' 運算式。",
   "Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier_1046": ".d.ts 檔案中的最上層宣告必須以 'declare' 或 'export' 修飾元開頭。",
@@ -1651,6 +1653,7 @@
   "Watch_and_Build_Modes_6250": "觀看及建置模式",
   "Watch_input_files_6005": "監看輸入檔。",
   "Watch_option_0_requires_a_value_of_type_1_5080": "監看選項 '{0}' 需要 {1} 類型的值。",
+  "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843": "我們只能在此新增整個參數的類型，來寫入 '{0}' 的類型。",
   "When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible_6698": "指派函式時，請檢查以確認參數，而且傳回值是子類型相容的。",
   "When_type_checking_take_into_account_null_and_undefined_6699": "當型別檢查時，請將 'null' 和 'undefined' 納入考慮。",
   "Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen_6191": "是否要將已過期的主控台輸出，維持在監看模式下，而非清除螢幕。",
@@ -1690,6 +1693,7 @@
   "_0_index_type_1_is_not_assignable_to_2_index_type_3_2413": "'{0}' 索引類型 '{1}' 無法指派給 '{2}' 索引類型 '{3}'。",
   "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692": "'{0}' 為基元，但 '{1}' 為包裝函式物件。建議盡可能使用 '{0}'。",
   "_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedMod_1444": "'{0}' 是類型，而且當 'preserveValueImports' 和 'isolatedModules' 都啟用時，必須使用僅類型匯入來匯入。",
+  "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842": "'{0}' 是未使用的 '{1}' 重新命名。您是否想要使用它作為類型註釋?",
   "_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_5075": "'{0}' 可指派給 '{1}' 類型的條件約束，但可能會將 '{1}' 以不同的條件約束 '{2}' 子類型來具現化。",
   "_0_is_declared_but_its_value_is_never_read_6133": "'{0}' 已宣告但從未讀取其值。",
   "_0_is_declared_but_never_used_6196": "宣告了 '{0}'，但從未使用過。",