typescript 4.7.0-dev.20220303 → 4.7.0-dev.20220306

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.20220303";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220306";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -39225,7 +39225,8 @@ var ts;
             name: "jsxFragmentFactory",
             type: "string",
             category: ts.Diagnostics.Language_and_Environment,
-            description: ts.Diagnostics.Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment
+            description: ts.Diagnostics.Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment,
+            defaultValueDescription: "React.Fragment",
         },
         {
             name: "jsxImportSource",
@@ -44314,7 +44315,7 @@ var ts;
             return ts.isDottedName(expr)
                 || (ts.isPropertyAccessExpression(expr) || ts.isNonNullExpression(expr) || ts.isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression)
                 || ts.isBinaryExpression(expr) && expr.operatorToken.kind === 27 /* CommaToken */ && isNarrowableReference(expr.right)
-                || ts.isElementAccessExpression(expr) && ts.isStringOrNumericLiteralLike(expr.argumentExpression) && isNarrowableReference(expr.expression)
+                || ts.isElementAccessExpression(expr) && (ts.isStringOrNumericLiteralLike(expr.argumentExpression) || ts.isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression)
                 || ts.isAssignmentExpression(expr) && isNarrowableReference(expr.left);
         }
         function containsNarrowableReference(expr) {
@@ -52550,7 +52551,15 @@ var ts;
                             });
                         }
                     }
-                    if (!symbolName) {
+                    if (symbolName === undefined) {
+                        var name = ts.firstDefined(symbol.declarations, ts.getNameOfDeclaration);
+                        if (name && ts.isComputedPropertyName(name) && ts.isEntityName(name.expression)) {
+                            var LHS = createAccessFromSymbolChain(chain, index - 1, stopper);
+                            if (ts.isEntityName(LHS)) {
+                                return ts.factory.createIndexedAccessTypeNode(ts.factory.createParenthesizedType(ts.factory.createTypeQueryNode(LHS)), ts.factory.createTypeQueryNode(name.expression));
+                            }
+                            return LHS;
+                        }
                         symbolName = getNameOfSymbolAsWritten(symbol, context);
                     }
                     context.approximateLength += symbolName.length + 1;
@@ -65290,7 +65299,7 @@ var ts;
                 var requireOptionalProperties = (relation === subtypeRelation || relation === strictSubtypeRelation) && !isObjectLiteralType(source) && !isEmptyArrayLiteralType(source) && !isTupleType(source);
                 var unmatchedProperty = getUnmatchedProperty(source, target, requireOptionalProperties, /*matchDiscriminantProperties*/ false);
                 if (unmatchedProperty) {
-                    if (reportErrors) {
+                    if (reportErrors && shouldReportUnmatchedPropertyError(source, target)) {
                         reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties);
                     }
                     return 0 /* False */;
@@ -65446,6 +65455,19 @@ var ts;
                 }
                 return result;
             }
+            function shouldReportUnmatchedPropertyError(source, target) {
+                var typeCallSignatures = getSignaturesOfStructuredType(source, 0 /* Call */);
+                var typeConstructSignatures = getSignaturesOfStructuredType(source, 1 /* Construct */);
+                var typeProperties = getPropertiesOfObjectType(source);
+                if ((typeCallSignatures.length || typeConstructSignatures.length) && !typeProperties.length) {
+                    if ((getSignaturesOfType(target, 0 /* Call */).length && typeCallSignatures.length) ||
+                        (getSignaturesOfType(target, 1 /* Construct */).length && typeConstructSignatures.length)) {
+                        return true; // target has similar signature kinds to source, still focus on the unmatched property
+                    }
+                    return false;
+                }
+                return true;
+            }
             function reportIncompatibleCallSignatureReturn(siga, sigb) {
                 if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
                     return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); };
@@ -68021,8 +68043,9 @@ var ts;
                     return isMatchingReference(source.expression, target);
                 case 205 /* PropertyAccessExpression */:
                 case 206 /* ElementAccessExpression */:
-                    return ts.isAccessExpression(target) &&
-                        getAccessedPropertyName(source) === getAccessedPropertyName(target) &&
+                    var sourcePropertyName = getAccessedPropertyName(source);
+                    var targetPropertyName = ts.isAccessExpression(target) ? getAccessedPropertyName(target) : undefined;
+                    return sourcePropertyName !== undefined && targetPropertyName !== undefined && targetPropertyName === sourcePropertyName &&
                         isMatchingReference(source.expression, target.expression);
                 case 160 /* QualifiedName */:
                     return ts.isAccessExpression(target) &&
@@ -68034,12 +68057,49 @@ var ts;
             return false;
         }
         function getAccessedPropertyName(access) {
-            var propertyName;
-            return access.kind === 205 /* PropertyAccessExpression */ ? access.name.escapedText :
-                access.kind === 206 /* ElementAccessExpression */ && ts.isStringOrNumericLiteralLike(access.argumentExpression) ? ts.escapeLeadingUnderscores(access.argumentExpression.text) :
-                    access.kind === 202 /* BindingElement */ && (propertyName = getDestructuringPropertyName(access)) ? ts.escapeLeadingUnderscores(propertyName) :
-                        access.kind === 163 /* Parameter */ ? ("" + access.parent.parameters.indexOf(access)) :
-                            undefined;
+            if (ts.isPropertyAccessExpression(access)) {
+                return access.name.escapedText;
+            }
+            if (ts.isElementAccessExpression(access)) {
+                return tryGetElementAccessExpressionName(access);
+            }
+            if (ts.isBindingElement(access)) {
+                var name = getDestructuringPropertyName(access);
+                return name ? ts.escapeLeadingUnderscores(name) : undefined;
+            }
+            if (ts.isParameter(access)) {
+                return ("" + access.parent.parameters.indexOf(access));
+            }
+            return undefined;
+        }
+        function tryGetNameFromType(type) {
+            return type.flags & 8192 /* UniqueESSymbol */ ? type.escapedName :
+                type.flags & 384 /* StringOrNumberLiteral */ ? ts.escapeLeadingUnderscores("" + type.value) : undefined;
+        }
+        function tryGetElementAccessExpressionName(node) {
+            if (ts.isStringOrNumericLiteralLike(node.argumentExpression)) {
+                return ts.escapeLeadingUnderscores(node.argumentExpression.text);
+            }
+            if (ts.isEntityNameExpression(node.argumentExpression)) {
+                var symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, /*ignoreErrors*/ true);
+                if (!symbol || !isConstVariable(symbol))
+                    return undefined;
+                var declaration = symbol.valueDeclaration;
+                if (declaration === undefined)
+                    return undefined;
+                var type = tryGetTypeFromEffectiveTypeNode(declaration);
+                if (type) {
+                    var name = tryGetNameFromType(type);
+                    if (name !== undefined) {
+                        return name;
+                    }
+                }
+                if (ts.hasOnlyExpressionInitializer(declaration)) {
+                    var initializer = ts.getEffectiveInitializer(declaration);
+                    return initializer && tryGetNameFromType(getTypeOfExpression(initializer));
+                }
+            }
+            return undefined;
         }
         function containsMatchingReference(source, target) {
             while (ts.isAccessExpression(source)) {
@@ -71545,11 +71605,21 @@ var ts;
             }
             return false;
         }
+        function uniqueStrings(strings) {
+            var unique = new ts.Set(strings);
+            var result = [];
+            unique.forEach(function (str) { return result.push(str); });
+            return result;
+        }
         function discriminateContextualTypeByObjectMembers(node, contextualType) {
-            return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 295 /* PropertyAssignment */ && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return getContextFreeTypeOfExpression(prop.initializer); }, prop.symbol.escapedName]; }), ts.map(ts.filter(getPropertiesOfType(contextualType), function (s) { var _a; return !!(s.flags & 16777216 /* Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return [function () { return undefinedType; }, s.escapedName]; })), isTypeAssignableTo, contextualType);
+            return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 295 /* PropertyAssignment */ && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return getContextFreeTypeOfExpression(prop.initializer); }, prop.symbol.escapedName]; }), ts.map(uniqueStrings(ts.flatMap(contextualType.types, function (memberType) {
+                return ts.map(ts.filter(getPropertiesOfType(memberType), function (s) { var _a; return !!(s.flags & 16777216 /* Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return s.escapedName; });
+            })), function (name) { return [function () { return undefinedType; }, name]; })), isTypeAssignableTo, contextualType);
         }
         function discriminateContextualTypeByJSXAttributes(node, contextualType) {
-            return discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 284 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return getContextFreeTypeOfExpression(prop.initializer); }), prop.symbol.escapedName]; }), ts.map(ts.filter(getPropertiesOfType(contextualType), function (s) { var _a; return !!(s.flags & 16777216 /* Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return [function () { return undefinedType; }, s.escapedName]; })), isTypeAssignableTo, contextualType);
+            return discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 284 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return getContextFreeTypeOfExpression(prop.initializer); }), prop.symbol.escapedName]; }), ts.map(uniqueStrings(ts.flatMap(contextualType.types, function (memberType) {
+                return ts.map(ts.filter(getPropertiesOfType(memberType), function (s) { var _a; return !!(s.flags & 16777216 /* Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return s.escapedName; });
+            })), function (name) { return [function () { return undefinedType; }, name]; })), isTypeAssignableTo, contextualType);
         }
         // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily
         // be "pushed" onto a node using the contextualType property.
@@ -73044,21 +73114,20 @@ var ts;
             // of the property as base classes
             var enclosingClass = forEachEnclosingClass(location, function (enclosingDeclaration) {
                 var enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration));
-                return isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing) ? enclosingClass : undefined;
+                return isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
             });
             // A protected property is accessible if the property is within the declaring class or classes derived from it
             if (!enclosingClass) {
                 // allow PropertyAccessibility if context is in function with this parameter
-                // static member access is disallow
-                var thisParameter = void 0;
-                if (flags & 32 /* Static */ || !(thisParameter = getThisParameterFromNodeContext(location)) || !thisParameter.type) {
+                // static member access is disallowed
+                enclosingClass = getEnclosingClassFromThisParameter(location);
+                enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
+                if (flags & 32 /* Static */ || !enclosingClass) {
                     if (errorNode) {
                         error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || containingType));
                     }
                     return false;
                 }
-                var thisType = getTypeFromTypeNode(thisParameter.type);
-                enclosingClass = ((thisType.flags & 262144 /* TypeParameter */) ? getConstraintOfTypeParameter(thisType) : thisType).target;
             }
             // No further restrictions for static properties
             if (flags & 32 /* Static */) {
@@ -73076,6 +73145,17 @@ var ts;
             }
             return true;
         }
+        function getEnclosingClassFromThisParameter(node) {
+            var thisParameter = getThisParameterFromNodeContext(node);
+            var thisType = (thisParameter === null || thisParameter === void 0 ? void 0 : thisParameter.type) && getTypeFromTypeNode(thisParameter.type);
+            if (thisType && thisType.flags & 262144 /* TypeParameter */) {
+                thisType = getConstraintOfTypeParameter(thisType);
+            }
+            if (thisType && ts.getObjectFlags(thisType) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
+                return getTargetType(thisType);
+            }
+            return undefined;
+        }
         function getThisParameterFromNodeContext(node) {
             var thisContainer = ts.getThisContainer(node, /* includeArrowFunctions */ false);
             return thisContainer && ts.isFunctionLike(thisContainer) ? ts.getThisParameter(thisContainer) : undefined;
@@ -75184,7 +75264,7 @@ var ts;
                 // then it cannot be instantiated.
                 // In the case of a merged class-module or class-interface declaration,
                 // only the class declaration node will have the Abstract flag set.
-                if (constructSignatures.some(function (signature) { return signature.flags & 4 /* Abstract */; })) {
+                if (someSignature(constructSignatures, function (signature) { return !!(signature.flags & 4 /* Abstract */); })) {
                     error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
                     return resolveErrorCall(node);
                 }
@@ -75215,6 +75295,12 @@ var ts;
             invocationError(node.expression, expressionType, 1 /* Construct */);
             return resolveErrorCall(node);
         }
+        function someSignature(signatures, f) {
+            if (ts.isArray(signatures)) {
+                return ts.some(signatures, function (signature) { return someSignature(signature, f); });
+            }
+            return signatures.compositeKind === 1048576 /* Union */ ? ts.some(signatures.compositeSignatures, f) : f(signatures);
+        }
         function typeHasProtectedAccessibleBase(target, type) {
             var baseTypes = getBaseTypes(type);
             if (!ts.length(baseTypes)) {
@@ -77057,7 +77143,7 @@ var ts;
                 case 40 /* MinusToken */:
                 case 54 /* TildeToken */:
                     checkNonNullType(operandType, node.operand);
-                    if (maybeTypeOfKind(operandType, 12288 /* ESSymbolLike */)) {
+                    if (maybeTypeOfKindConsideringBaseConstraint(operandType, 12288 /* ESSymbolLike */)) {
                         error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator));
                     }
                     if (node.operator === 39 /* PlusToken */) {
@@ -77105,6 +77191,13 @@ var ts;
             // If it's not a bigint type, implicit coercion will result in a number
             return numberType;
         }
+        function maybeTypeOfKindConsideringBaseConstraint(type, kind) {
+            if (maybeTypeOfKind(type, kind)) {
+                return true;
+            }
+            var baseConstraint = getBaseConstraintOrType(type);
+            return !!baseConstraint && maybeTypeOfKind(baseConstraint, kind);
+        }
         // Return true if type might be of the given kind. A union or intersection type might be of a given
         // kind if at least one constituent type is of the given kind.
         function maybeTypeOfKind(type, kind) {
@@ -77814,8 +77907,8 @@ var ts;
             }
             // Return true if there was no error, false if there was an error.
             function checkForDisallowedESSymbolOperand(operator) {
-                var offendingSymbolOperand = maybeTypeOfKind(leftType, 12288 /* ESSymbolLike */) ? left :
-                    maybeTypeOfKind(rightType, 12288 /* ESSymbolLike */) ? right :
+                var offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* ESSymbolLike */) ? left :
+                    maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* ESSymbolLike */) ? right :
                         undefined;
                 if (offendingSymbolOperand) {
                     error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator));
@@ -78019,7 +78112,7 @@ var ts;
             for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) {
                 var span = _a[_i];
                 var type = checkExpression(span.expression);
-                if (maybeTypeOfKind(type, 12288 /* ESSymbolLike */)) {
+                if (maybeTypeOfKindConsideringBaseConstraint(type, 12288 /* ESSymbolLike */)) {
                     error(span.expression, ts.Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String);
                 }
                 texts.push(span.literal.text);
@@ -83046,7 +83139,7 @@ var ts;
                 }
                 if (!ts.isStatic(member) && isPropertyWithoutInitializer(member)) {
                     var propName = member.name;
-                    if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName)) {
+                    if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName) || ts.isComputedPropertyName(propName)) {
                         var type = getTypeOfSymbol(getSymbolOfNode(member));
                         if (!(type.flags & 3 /* AnyOrUnknown */ || getFalsyFlags(type) & 32768 /* Undefined */)) {
                             if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) {
@@ -83081,7 +83174,9 @@ var ts;
             return false;
         }
         function isPropertyInitializedInConstructor(propName, propType, constructor) {
-            var reference = ts.factory.createPropertyAccessExpression(ts.factory.createThis(), propName);
+            var reference = ts.isComputedPropertyName(propName)
+                ? ts.factory.createElementAccessExpression(ts.factory.createThis(), propName.expression)
+                : ts.factory.createPropertyAccessExpression(ts.factory.createThis(), propName);
             ts.setParent(reference.expression, reference);
             ts.setParent(reference, constructor);
             reference.flowNode = constructor.returnFlowNode;
@@ -92627,6 +92722,9 @@ var ts;
         function substituteElementAccessExpression(node) {
             return substituteConstantValue(node);
         }
+        function safeMultiLineComment(value) {
+            return value.replace(/\*\//g, "*_/");
+        }
         function substituteConstantValue(node) {
             var constantValue = tryGetConstEnumValue(node);
             if (constantValue !== undefined) {
@@ -92635,10 +92733,7 @@ var ts;
                 var substitute = typeof constantValue === "string" ? factory.createStringLiteral(constantValue) : factory.createNumericLiteral(constantValue);
                 if (!compilerOptions.removeComments) {
                     var originalNode = ts.getOriginalNode(node, ts.isAccessExpression);
-                    var propertyName = ts.isPropertyAccessExpression(originalNode)
-                        ? ts.declarationNameToString(originalNode.name)
-                        : ts.getTextOfNode(originalNode.argumentExpression);
-                    ts.addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, " " + propertyName + " ");
+                    ts.addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, " " + safeMultiLineComment(ts.getTextOfNode(originalNode)) + " ");
                 }
                 return substitute;
             }

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

@@ -1539,6 +1539,7 @@
   "Type_catch_clause_variables_as_unknown_instead_of_any_6803": "将 catch 子句变量键入为 “unknown” 而不是 “any”。",
   "Type_declaration_files_to_be_included_in_compilation_6124": "要包含在编译中类型声明文件。",
   "Type_expected_1110": "应为类型。",
+  "Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require_1456": "类型导入断言应恰好有一个键 - \"resolution-mode\" - 值为 \"import\" 或 \"require\"。",
   "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589": "类型实例化过深，且可能无限。",
   "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062": "类型在其自身的 \"then\" 方法的 fulfillment 回调中被直接或间接引用。",
   "Type_library_referenced_via_0_from_file_1_1402": "通过 \"{0}\" 从文件 \"{1}\" 引用了库类型",
@@ -1781,6 +1782,8 @@
   "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024": "\"readonly\" 修饰符仅可出现在属性声明或索引签名中。",
   "readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types_1354": "仅允许对数组和元组文本类型使用 \"readonly\" 类型修饰符。",
   "require_call_may_be_converted_to_an_import_80005": "可将“要求”调用转换为导入。",
+  "resolution_mode_can_only_be_set_for_type_only_imports_1454": "只能为仅类型导入设置 \"resolution-mode\"。",
+  "resolution_mode_is_the_only_valid_key_for_type_import_assertions_1455": "\"resolution-mode\" 是类型导入断言的唯一有效密钥。",
   "resolution_mode_should_be_either_require_or_import_1453": "“resolution-mode”应为“require”或“import”。",
   "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107": "设置了 \"rootDirs\" 选项，可将其用于解析相对模块名称“{0}”。",
   "super_can_only_be_referenced_in_a_derived_class_2335": "只能在派生类中引用 \"super\"。",

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

@@ -1539,6 +1539,7 @@
   "Type_catch_clause_variables_as_unknown_instead_of_any_6803": "將 catch 子句變數輸入為 'unknown' 而非 'any'。",
   "Type_declaration_files_to_be_included_in_compilation_6124": "要包含在編譯內的類型宣告檔案。",
   "Type_expected_1110": "必須是類型。",
+  "Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require_1456": "輸入匯入判斷提示應該只有一個索引鍵 - 'resolution-mode' - 值為 'import' 或 'require'。",
   "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589": "類型具現化過深，可能會有無限深度。",
   "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062": "類型在其本身 'then' 方法的完成回撥中直接或間接受到參考。",
   "Type_library_referenced_via_0_from_file_1_1402": "透過 '{0}' 從檔案 '{1}' 參考的型別程式庫",
@@ -1781,6 +1782,8 @@
   "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024": "'readonly' 修飾元只能出現在屬性宣告或索引簽章。",
   "readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types_1354": "'readonly' 類型修飾元只可用於陣列與元組常值類型。",
   "require_call_may_be_converted_to_an_import_80005": "'require' 呼叫可能會轉換為匯入。",
+  "resolution_mode_can_only_be_set_for_type_only_imports_1454": "只能針對僅限輸入的匯入設定 'resolution-mode'。",
+  "resolution_mode_is_the_only_valid_key_for_type_import_assertions_1455": "'resolution-mode' 是輸入匯入判斷提示唯一有效的索引鍵。",
   "resolution_mode_should_be_either_require_or_import_1453": "`resolution-mode` 應該是 `require` 或 `import`。",
   "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107": "'rootDirs' 選項已設定。該選項將用於解析相對的模組名稱 '{0}'。",
   "super_can_only_be_referenced_in_a_derived_class_2335": "只有衍生類別中才可參考 'super'。",

package/package.json

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