typescript 4.5.0-dev.20211001 → 4.5.0-dev.20211002

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.20211001";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211002";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -31348,7 +31348,6 @@ var ts;
                 case 88 /* DefaultKeyword */:
                     return nextTokenCanFollowDefaultKeyword();
                 case 124 /* StaticKeyword */:
-                    return nextTokenIsOnSameLineAndCanFollowModifier();
                 case 136 /* GetKeyword */:
                 case 148 /* SetKeyword */:
                     nextToken();
@@ -35591,7 +35590,7 @@ var ts;
             }
             return list && createNodeArray(list, pos);
         }
-        function tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock) {
+        function tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
             var pos = getNodePos();
             var kind = token();
             if (token() === 85 /* ConstKeyword */ && permitInvalidConstAsModifier) {
@@ -35604,6 +35603,9 @@ var ts;
             else if (stopOnStartOfClassStaticBlock && token() === 124 /* StaticKeyword */ && lookAhead(nextTokenIsOpenBrace)) {
                 return undefined;
             }
+            else if (hasSeenStaticModifier && token() === 124 /* StaticKeyword */) {
+                return undefined;
+            }
             else {
                 if (!parseAnyContextualModifier()) {
                     return undefined;
@@ -35620,8 +35622,10 @@ var ts;
          */
         function parseModifiers(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock) {
             var pos = getNodePos();
-            var list, modifier;
-            while (modifier = tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock)) {
+            var list, modifier, hasSeenStatic = false;
+            while (modifier = tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStatic)) {
+                if (modifier.kind === 124 /* StaticKeyword */)
+                    hasSeenStatic = true;
                 list = ts.append(list, modifier);
             }
             return list && createNodeArray(list, pos);
@@ -40034,6 +40038,44 @@ var ts;
         }
         return result;
     }
+    /**
+     * Generate a list of the compiler options whose value is not the default.
+     * @param options compilerOptions to be evaluated.
+    /** @internal */
+    function getCompilerOptionsDiffValue(options, newLine) {
+        var compilerOptionsMap = getSerializedCompilerOption(options);
+        return getOverwrittenDefaultOptions();
+        function makePadding(paddingLength) {
+            return Array(paddingLength + 1).join(" ");
+        }
+        function getOverwrittenDefaultOptions() {
+            var result = [];
+            var tab = makePadding(2);
+            commandOptionsWithoutBuild.forEach(function (cmd) {
+                if (!compilerOptionsMap.has(cmd.name)) {
+                    return;
+                }
+                var newValue = compilerOptionsMap.get(cmd.name);
+                var defaultValue = getDefaultValueForOption(cmd);
+                if (newValue !== defaultValue) {
+                    result.push("" + tab + cmd.name + ": " + newValue);
+                }
+                else if (ts.hasProperty(ts.defaultInitCompilerOptions, cmd.name)) {
+                    result.push("" + tab + cmd.name + ": " + defaultValue);
+                }
+            });
+            return result.join(newLine) + newLine;
+        }
+    }
+    ts.getCompilerOptionsDiffValue = getCompilerOptionsDiffValue;
+    /**
+     * Get the compiler options to be written into the tsconfig.json.
+     * @param options commandlineOptions to be included in the compileOptions.
+     */
+    function getSerializedCompilerOption(options) {
+        var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions);
+        return serializeCompilerOptions(compilerOptions);
+    }
     /**
      * Generate tsconfig configuration when running command line "--init"
      * @param options commandlineOptions to be generated into tsconfig.json
@@ -40041,28 +40083,8 @@ var ts;
      */
     /* @internal */
     function generateTSConfig(options, fileNames, newLine) {
-        var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions);
-        var compilerOptionsMap = serializeCompilerOptions(compilerOptions);
+        var compilerOptionsMap = getSerializedCompilerOption(options);
         return writeConfigurations();
-        function getDefaultValueForOption(option) {
-            switch (option.type) {
-                case "number":
-                    return 1;
-                case "boolean":
-                    return true;
-                case "string":
-                    return option.isFilePath ? "./" : "";
-                case "list":
-                    return [];
-                case "object":
-                    return {};
-                default:
-                    var iterResult = option.type.keys().next();
-                    if (!iterResult.done)
-                        return iterResult.value;
-                    return ts.Debug.fail("Expected 'option.type' to have entries.");
-            }
-        }
         function makePadding(paddingLength) {
             return Array(paddingLength + 1).join(" ");
         }
@@ -41049,6 +41071,25 @@ var ts;
                 }); // TODO: GH#18217
         }
     }
+    function getDefaultValueForOption(option) {
+        switch (option.type) {
+            case "number":
+                return 1;
+            case "boolean":
+                return true;
+            case "string":
+                return option.isFilePath ? "./" : "";
+            case "list":
+                return [];
+            case "object":
+                return {};
+            default:
+                var iterResult = option.type.keys().next();
+                if (!iterResult.done)
+                    return iterResult.value;
+                return ts.Debug.fail("Expected 'option.type' to have entries.");
+        }
+    }
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
@@ -42425,9 +42466,11 @@ var ts;
         return idx === -1 ? { packageName: moduleName, rest: "" } : { packageName: moduleName.slice(0, idx), rest: moduleName.slice(idx + 1) };
     }
     ts.parsePackageName = parsePackageName;
+    /* @internal */
     function allKeysStartWithDot(obj) {
         return ts.every(ts.getOwnKeys(obj), function (k) { return ts.startsWith(k, "."); });
     }
+    ts.allKeysStartWithDot = allKeysStartWithDot;
     function noKeyStartsWithDot(obj) {
         return !ts.some(ts.getOwnKeys(obj), function (k) { return ts.startsWith(k, "."); });
     }
@@ -42634,17 +42677,19 @@ var ts;
             }
             return toSearchResult(/*value*/ undefined);
         }
-        function isApplicableVersionedTypesKey(conditions, key) {
-            if (conditions.indexOf("types") === -1)
-                return false; // only apply versioned types conditions if the types condition is applied
-            if (!ts.startsWith(key, "types@"))
-                return false;
-            var range = ts.VersionRange.tryParse(key.substring("types@".length));
-            if (!range)
-                return false;
-            return range.test(ts.version);
-        }
     }
+    /* @internal */
+    function isApplicableVersionedTypesKey(conditions, key) {
+        if (conditions.indexOf("types") === -1)
+            return false; // only apply versioned types conditions if the types condition is applied
+        if (!ts.startsWith(key, "types@"))
+            return false;
+        var range = ts.VersionRange.tryParse(key.substring("types@".length));
+        if (!range)
+            return false;
+        return range.test(ts.version);
+    }
+    ts.isApplicableVersionedTypesKey = isApplicableVersionedTypesKey;
     function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
         return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, /*typesScopeOnly*/ false, cache, redirectedReference);
     }
@@ -48698,7 +48743,21 @@ var ts;
         function isSyntacticDefault(node) {
             return ((ts.isExportAssignment(node) && !node.isExportEquals) || ts.hasSyntacticModifier(node, 512 /* Default */) || ts.isExportSpecifier(node));
         }
-        function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias) {
+        function getUsageModeForExpression(usage) {
+            return ts.isStringLiteralLike(usage) ? ts.getModeForUsageLocation(ts.getSourceFileOfNode(usage), usage) : undefined;
+        }
+        function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
+            return usageMode === ts.ModuleKind.ESNext && targetMode === ts.ModuleKind.CommonJS;
+        }
+        function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage) {
+            var usageMode = file && getUsageModeForExpression(usage);
+            if (file && usageMode !== undefined) {
+                var result = isESMFormatImportImportingCommonjsFormatFile(usageMode, file.impliedNodeFormat);
+                if (usageMode === ts.ModuleKind.ESNext || result) {
+                    return result;
+                }
+                // fallthrough on cjs usages so we imply defaults for interop'd imports, too
+            }
             if (!allowSyntheticDefaultImports) {
                 return false;
             }
@@ -48740,7 +48799,7 @@ var ts;
                     exportDefaultSymbol = resolveExportByName(moduleSymbol, "default" /* Default */, node, dontResolveAlias);
                 }
                 var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
-                var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias);
+                var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, node.parent.moduleSpecifier);
                 if (!exportDefaultSymbol && !hasSyntheticDefault) {
                     if (hasExportAssignmentSymbol(moduleSymbol)) {
                         var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop";
@@ -48880,7 +48939,7 @@ var ts;
                     var symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
                     if (symbolFromModule === undefined && name.escapedText === "default" /* Default */) {
                         var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
-                        if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias)) {
+                        if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
                             symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
                         }
                     }
@@ -49571,7 +49630,7 @@ var ts;
                             sigs = getSignaturesOfStructuredType(type, 1 /* Construct */);
                         }
                         if (sigs && sigs.length) {
-                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol);
+                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, ts.isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier);
                             // Create a new symbol which has the module's type less the call and construct signatures
                             var result = createSymbol(symbol.flags, symbol.escapedName);
                             result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
@@ -74748,18 +74807,18 @@ var ts;
             if (moduleSymbol) {
                 var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, /*dontRecursivelyResolve*/ true, /*suppressUsageError*/ false);
                 if (esModuleSymbol) {
-                    return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol));
+                    return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier));
                 }
             }
             return createPromiseReturnType(node, anyType);
         }
-        function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol) {
+        function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol, moduleSpecifier) {
             var _a;
             if (allowSyntheticDefaultImports && type && !isErrorType(type)) {
                 var synthType = type;
                 if (!synthType.syntheticType) {
                     var file = (_a = originalSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
-                    var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, /*dontResolveAlias*/ false);
+                    var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, /*dontResolveAlias*/ false, moduleSpecifier);
                     if (hasSyntheticDefault) {
                         var memberTable = ts.createSymbolTable();
                         var newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
@@ -87370,7 +87429,7 @@ var ts;
     }
     ts.createSourceMapGenerator = createSourceMapGenerator;
     // Sometimes tools can see the following line as a source mapping url comment, so we mangle it a bit (the [M])
-    var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)$/;
+    var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/;
     var whitespaceOrMapCommentRegExp = /^\s*(\/\/[@#] .*)?$/;
     function getLineInfo(text, lineStarts) {
         return {
@@ -118873,6 +118932,78 @@ var ts;
                 }
             }
         }
+        var MatchingMode;
+        (function (MatchingMode) {
+            MatchingMode[MatchingMode["Exact"] = 0] = "Exact";
+            MatchingMode[MatchingMode["Directory"] = 1] = "Directory";
+            MatchingMode[MatchingMode["Pattern"] = 2] = "Pattern";
+        })(MatchingMode || (MatchingMode = {}));
+        function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, exports, conditions, mode) {
+            if (mode === void 0) { mode = 0 /* Exact */; }
+            if (typeof exports === "string") {
+                var pathOrPattern = ts.getNormalizedAbsolutePath(ts.combinePaths(packageDirectory, exports), /*currentDirectory*/ undefined);
+                var extensionSwappedTarget = ts.hasTSFileExtension(targetFilePath) ? ts.removeFileExtension(targetFilePath) + tryGetJSExtensionForFile(targetFilePath, options) : undefined;
+                switch (mode) {
+                    case 0 /* Exact */:
+                        if (ts.comparePaths(targetFilePath, pathOrPattern) === 0 /* EqualTo */ || (extensionSwappedTarget && ts.comparePaths(extensionSwappedTarget, pathOrPattern) === 0 /* EqualTo */)) {
+                            return { moduleFileToTry: packageName };
+                        }
+                        break;
+                    case 1 /* Directory */:
+                        if (ts.containsPath(pathOrPattern, targetFilePath)) {
+                            var fragment = ts.getRelativePathFromDirectory(pathOrPattern, targetFilePath, /*ignoreCase*/ false);
+                            return { moduleFileToTry: ts.getNormalizedAbsolutePath(ts.combinePaths(ts.combinePaths(packageName, exports), fragment), /*currentDirectory*/ undefined) };
+                        }
+                        break;
+                    case 2 /* Pattern */:
+                        var starPos = pathOrPattern.indexOf("*");
+                        var leadingSlice = pathOrPattern.slice(0, starPos);
+                        var trailingSlice = pathOrPattern.slice(starPos + 1);
+                        if (ts.startsWith(targetFilePath, leadingSlice) && ts.endsWith(targetFilePath, trailingSlice)) {
+                            var starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length);
+                            return { moduleFileToTry: packageName.replace("*", starReplacement) };
+                        }
+                        if (extensionSwappedTarget && ts.startsWith(extensionSwappedTarget, leadingSlice) && ts.endsWith(extensionSwappedTarget, trailingSlice)) {
+                            var starReplacement = extensionSwappedTarget.slice(leadingSlice.length, extensionSwappedTarget.length - trailingSlice.length);
+                            return { moduleFileToTry: packageName.replace("*", starReplacement) };
+                        }
+                        break;
+                }
+            }
+            else if (Array.isArray(exports)) {
+                return ts.forEach(exports, function (e) { return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, e, conditions); });
+            }
+            else if (typeof exports === "object" && exports !== null) { // eslint-disable-line no-null/no-null
+                if (ts.allKeysStartWithDot(exports)) {
+                    // sub-mappings
+                    // 3 cases:
+                    // * directory mappings (legacyish, key ends with / (technically allows index/extension resolution under cjs mode))
+                    // * pattern mappings (contains a *)
+                    // * exact mappings (no *, does not end with /)
+                    return ts.forEach(ts.getOwnKeys(exports), function (k) {
+                        var subPackageName = ts.getNormalizedAbsolutePath(ts.combinePaths(packageName, k), /*currentDirectory*/ undefined);
+                        var mode = ts.endsWith(k, "/") ? 1 /* Directory */
+                            : ts.stringContains(k, "*") ? 2 /* Pattern */
+                                : 0 /* Exact */;
+                        return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, subPackageName, exports[k], conditions, mode);
+                    });
+                }
+                else {
+                    // conditional mapping
+                    for (var _i = 0, _a = ts.getOwnKeys(exports); _i < _a.length; _i++) {
+                        var key = _a[_i];
+                        if (key === "default" || conditions.indexOf(key) >= 0 || ts.isApplicableVersionedTypesKey(conditions, key)) {
+                            var subTarget = exports[key];
+                            var result = tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, subTarget, conditions);
+                            if (result) {
+                                return result;
+                            }
+                        }
+                    }
+                }
+            }
+            return undefined;
+        }
         function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) {
             var normalizedTargetPath = getPathRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
             if (normalizedTargetPath === undefined) {
@@ -118902,7 +119033,15 @@ var ts;
                 var moduleFileNameForExtensionless = void 0;
                 while (true) {
                     // If the module could be imported by a directory name, use that directory's name
-                    var _c = tryDirectoryWithPackageJson(packageRootIndex), moduleFileToTry = _c.moduleFileToTry, packageRootPath = _c.packageRootPath;
+                    var _c = tryDirectoryWithPackageJson(packageRootIndex), moduleFileToTry = _c.moduleFileToTry, packageRootPath = _c.packageRootPath, blockedByExports = _c.blockedByExports, verbatimFromExports = _c.verbatimFromExports;
+                    if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Classic) {
+                        if (blockedByExports) {
+                            return undefined; // File is under this package.json, but is not publicly exported - there's no way to name it via `node_modules` resolution
+                        }
+                        if (verbatimFromExports) {
+                            return moduleFileToTry;
+                        }
+                    }
                     if (packageRootPath) {
                         moduleSpecifier = packageRootPath;
                         isPackageRootPath = true;
@@ -118939,6 +119078,15 @@ var ts;
                 var moduleFileToTry = path;
                 if (host.fileExists(packageJsonPath)) {
                     var packageJsonContent = JSON.parse(host.readFile(packageJsonPath));
+                    // TODO: Inject `require` or `import` condition based on the intended import mode
+                    var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, packageJsonContent.name, packageJsonContent.exports, ["node", "types"]) : undefined;
+                    if (fromExports) {
+                        var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
+                        return __assign(__assign({}, withJsExtension), { verbatimFromExports: true });
+                    }
+                    if (packageJsonContent.exports) {
+                        return { moduleFileToTry: path, blockedByExports: true };
+                    }
                     var versionPaths = packageJsonContent.typesVersions
                         ? ts.getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions)
                         : undefined;

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

@@ -561,7 +561,7 @@
   "Duplicate_property_0_2718": "重复的属性 \"{0}\"。",
   "Dynamic_import_cannot_have_type_arguments_1326": "动态导入不能含有类型参数。",
   "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036": "动态导入的说明符类型必须是 \"string\"，但此处类型是 \"{0}\"。",
-  "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system__1323": "仅当 '--module' 标志设置为 'es2020'、'esnext'、 'commonjs'、'amd'、'system'、'umd'、'node12' 或 'nodenext' 时，才支持动态导入。",
+  "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323": "仅当 '--module' 标志设置为 'es2020'、'es2022'、'esnext'、 'commonjs'、'amd'、'system'、'umd'、'node12' 或 'nodenext' 时，才支持动态导入。",
   "Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments_1450": "动态导入只能接受模块说明符和可选断言作为参数",
   "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_1324": "只有在 \"--module\" 选项设置为 \"esnext\" 时，动态导入才支持第二个参数。",
   "Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_2762": "联合类型 \"{0}\" 的每个成员都有构造签名，但这些签名都不能互相兼容。",
@@ -1360,7 +1360,7 @@
   "The_global_type_JSX_0_may_not_have_more_than_one_property_2608": "全局类型 \"JSX.{0}\" 不可具有多个属性。",
   "The_implementation_signature_is_declared_here_2750": "在此处声明实现签名。",
   "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470": "将生成到 CommonJS 输出的文件中不允许 'import.meta' 元属性。",
-  "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_system_node12__1343": "仅当 '--module' 选项为 'es2020'、'esnext'、 'system'、'node12' 或 'nodenext' 时，才允许 'import.meta' 元属性。",
+  "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343": "仅当 '--module' 选项为 'es2020'、'es2022'、'esnext'、 'system'、'node12' 或 'nodenext' 时，才允许 'import.meta' 元属性。",
   "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_a_2742": "如果没有引用 \"{1}\"，则无法命名 \"{0}\" 的推断类型。这很可能不可移植。需要类型注释。",
   "The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialize_5088": "推断类型“{0}”引用的类型具有无法简单序列化的循环结构。必须具有类型注释。",
   "The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary_2527": "“{0}”的推断类型引用不可访问的“{1}”类型。需要类型批注。",
@@ -1459,9 +1459,9 @@
   "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}\" 的版本。",
-  "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_noden_1378": "仅当 'module' 选项设置为 'esnext'、'system' 或 'nodenext'，且 'target' 选项设置为 'es2017' 或更高版本时，才允许顶级 'await' 表达式。",
+  "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_o_1378": "仅当 'module' 选项设置为 'es2022'、'esnext'、'system' 或 '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\" 修饰符开头。",
-  "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenex_1432": "仅当 'module' 选项设置为 'esnext'、'system' 或 'nodenext'，且 'target' 选项设置为 'es2017' 或更高版本时，才允许顶级 'for await' 循环。",
+  "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or__1432": "仅当 'module' 选项设置为 'es2022'、'esnext'、'system' 或 'nodenext'，且 'target' 选项设置为 'es2017' 或更高版本时，才允许顶级 'for await' 循环。",
   "Trailing_comma_not_allowed_1009": "不允许使用尾随逗号。",
   "Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule_6153": "将每个文件转换为单独的模块(类似 \"ts.transpileModule\")。",
   "Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare__7035": "尝试使用 `npm i --save-dev @types/{1}` (如果存在)，或者添加一个包含 `declare module '{0}';` 的新声明(.d.ts)文件",

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

@@ -561,7 +561,7 @@
   "Duplicate_property_0_2718": "屬性 '{0}' 重複。",
   "Dynamic_import_cannot_have_type_arguments_1326": "動態匯入不可有型別引數。",
   "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036": "動態匯入的指定名稱必須屬於類型 'string'，但這裡的類型為 '{0}'。",
-  "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system__1323": "只有在 '--module' 旗標設定為 'es2020'、'esnext'、'commonjs'、'amd'、'system'、'umd'、'node12' 或 'nodenext'，才支援動態匯入。",
+  "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323": "只有在 '--module' 旗標設定為 'es2020'、'es2022'、'esnext'、'commonjs'、'amd'、'system'、'umd'、'node12' 或 'nodenext'，才支援動態匯入。",
   "Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments_1450": "動態匯入只能接受模組指定名稱和選擇性判斷提示來做為引數",
   "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_1324": "當 '--module' 選項設定為 'esnext' 時，動態匯入只支援第二個引數。",
   "Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_2762": "等位型別 '{0}' 的每個成員都有建構簽章，但這些簽章都互不相容。",
@@ -1360,7 +1360,7 @@
   "The_global_type_JSX_0_may_not_have_more_than_one_property_2608": "全域類型 'JSX.{0}' 的屬性不得超過一個。",
   "The_implementation_signature_is_declared_here_2750": "實作簽章宣告於此處。",
   "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470": "將會組建至 CommonJS 輸出的檔案中不允許 'import.meta' 中繼屬性。",
-  "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_esnext_system_node12__1343": "只有當 '--module' 選項為 'es2020'、'esnext'、'system'、, 'node12' 或 'nodenext' 時，才允許 'import.meta' 中繼屬性。",
+  "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343": "只有當 '--module' 選項為 'es2020'、'es2022'、'esnext'、'system'、, 'node12' 或 'nodenext' 時，才允許 'import.meta' 中繼屬性。",
   "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_a_2742": "'{0}' 的推斷類型無法在沒有 '{1}' 參考的情況下命名。其可能非可攜式。必須有型別註解。",
   "The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialize_5088": "'{0}' 的推斷型別參考了具有迴圈結構且不是可完整序列化的型別。必須有型別註解。",
   "The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary_2527": "'{0}' 的推斷型別參考了無法存取的 '{1}' 型別。必須有型別註解。",
@@ -1459,9 +1459,9 @@
   "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}' 的版本。",
-  "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_noden_1378": "只有在 'module' 選項設定為 'esnext'、'system' 或 'nodenext'，而且 'target' 選項設定為 'es2017' 或更高版本時，才允許最上層的 'await' 運算式。",
+  "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_o_1378": "只有在 'module' 選項設定為 'es2022'、'esnext'、'system' 或 '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' 修飾元開頭。",
-  "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_esnext_system_or_nodenex_1432": "只有在 'module' 選項設為 'esnext'、'system' 或 'nodenext'，而且 'target' 選項設為 'es2017' 或更高版本時，才允許最上層的 'for await' 迴圈。",
+  "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_or__1432": "只有在 'module' 選項設為 'es2022'、'esnext'、'system' 或 'nodenext'，而且 'target' 選項設為 'es2017' 或更高版本時，才允許最上層的 'for await' 迴圈。",
   "Trailing_comma_not_allowed_1009": "尾端不得為逗號。",
   "Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule_6153": "以個別模組的形式轉換每個檔案的語言 (類似於 'ts.transpileModule')。",
   "Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare__7035": "如有 `npm i --save-dev @types/{1}`，請嘗試使用，或新增包含 `declare module '{0}';` 的宣告 (.d.ts) 檔案",

package/package.json

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