typescript 4.7.0-dev.20220406 → 4.7.0-dev.20220416

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.20220406";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220416";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4649,7 +4649,6 @@ var ts;
         NodeBuilderFlags[NodeBuilderFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
         NodeBuilderFlags[NodeBuilderFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
         NodeBuilderFlags[NodeBuilderFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction";
-        NodeBuilderFlags[NodeBuilderFlags["NoUndefinedOptionalParameterType"] = 1073741824] = "NoUndefinedOptionalParameterType";
         // Error handling
         NodeBuilderFlags[NodeBuilderFlags["AllowThisInObjectLiteral"] = 32768] = "AllowThisInObjectLiteral";
         NodeBuilderFlags[NodeBuilderFlags["AllowQualifiedNameInPlaceOfIdentifier"] = 65536] = "AllowQualifiedNameInPlaceOfIdentifier";
@@ -8706,6 +8705,7 @@ var ts;
         _0_index_signatures_are_incompatible: diag(2634, ts.DiagnosticCategory.Error, "_0_index_signatures_are_incompatible_2634", "'{0}' index signatures are incompatible."),
         Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: diag(2635, ts.DiagnosticCategory.Error, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."),
         Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation: diag(2636, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation_2636", "Type '{0}' is not assignable to type '{1}' as implied by variance annotation."),
+        Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types: diag(2637, ts.DiagnosticCategory.Error, "Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_t_2637", "Variance annotations are only supported in type aliases for object, function, constructor, and mapped types."),
         Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."),
         A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."),
         Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."),
@@ -14954,6 +14954,10 @@ var ts;
         }
     }
     ts.isAnyImportSyntax = isAnyImportSyntax;
+    function isAnyImportOrBareOrAccessedRequire(node) {
+        return isAnyImportSyntax(node) || isVariableDeclarationInitializedToBareOrAccessedRequire(node);
+    }
+    ts.isAnyImportOrBareOrAccessedRequire = isAnyImportOrBareOrAccessedRequire;
     function isLateVisibilityPaintedStatement(node) {
         switch (node.kind) {
             case 266 /* ImportDeclaration */:
@@ -16314,17 +16318,13 @@ var ts;
         if (isPropertyNameLiteral(name) && isPropertyNameLiteral(initializer)) {
             return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(initializer);
         }
-        if (ts.isIdentifier(name) && isLiteralLikeAccess(initializer) &&
+        if (ts.isMemberName(name) && isLiteralLikeAccess(initializer) &&
             (initializer.expression.kind === 108 /* ThisKeyword */ ||
                 ts.isIdentifier(initializer.expression) &&
                     (initializer.expression.escapedText === "window" ||
                         initializer.expression.escapedText === "self" ||
                         initializer.expression.escapedText === "global"))) {
-            var nameOrArgument = getNameOrArgument(initializer);
-            if (ts.isPrivateIdentifier(nameOrArgument)) {
-                ts.Debug.fail("Unexpected PrivateIdentifier in name expression with literal-like access.");
-            }
-            return isSameEntityName(name, nameOrArgument);
+            return isSameEntityName(name, getNameOrArgument(initializer));
         }
         if (isLiteralLikeAccess(name) && isLiteralLikeAccess(initializer)) {
             return getElementOrPropertyAccessName(name) === getElementOrPropertyAccessName(initializer)
@@ -16532,14 +16532,14 @@ var ts;
     }
     ts.isFunctionSymbol = isFunctionSymbol;
     function tryGetModuleSpecifierFromDeclaration(node) {
-        var _a, _b, _c;
+        var _a, _b;
         switch (node.kind) {
             case 254 /* VariableDeclaration */:
-                return node.initializer.arguments[0].text;
+                return (_a = ts.findAncestor(node.initializer, function (node) { return isRequireCall(node, /*requireStringLiteralLikeArgument*/ true); })) === null || _a === void 0 ? void 0 : _a.arguments[0];
             case 266 /* ImportDeclaration */:
-                return (_a = ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike)) === null || _a === void 0 ? void 0 : _a.text;
+                return ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike);
             case 265 /* ImportEqualsDeclaration */:
-                return (_c = ts.tryCast((_b = ts.tryCast(node.moduleReference, ts.isExternalModuleReference)) === null || _b === void 0 ? void 0 : _b.expression, ts.isStringLiteralLike)) === null || _c === void 0 ? void 0 : _c.text;
+                return ts.tryCast((_b = ts.tryCast(node.moduleReference, ts.isExternalModuleReference)) === null || _b === void 0 ? void 0 : _b.expression, ts.isStringLiteralLike);
             default:
                 ts.Debug.assertNever(node);
         }
@@ -17054,7 +17054,10 @@ var ts;
                 return parent.propertyName === node;
             case 275 /* ExportSpecifier */:
             case 285 /* JsxAttribute */:
-                // Any name in an export specifier or JSX Attribute
+            case 279 /* JsxSelfClosingElement */:
+            case 280 /* JsxOpeningElement */:
+            case 281 /* JsxClosingElement */:
+                // Any name in an export specifier or JSX Attribute or Jsx Element
                 return true;
         }
         return false;
@@ -17070,21 +17073,28 @@ var ts;
     // export = <EntityNameExpression>
     // export default <EntityNameExpression>
     // module.exports = <EntityNameExpression>
-    // {<Identifier>}
-    // {name: <EntityNameExpression>}
+    // module.exports.x = <EntityNameExpression>
+    // const x = require("...")
+    // const { x } = require("...")
+    // const x = require("...").y
+    // const { x } = require("...").y
     function isAliasSymbolDeclaration(node) {
-        return node.kind === 265 /* ImportEqualsDeclaration */ ||
+        if (node.kind === 265 /* ImportEqualsDeclaration */ ||
             node.kind === 264 /* NamespaceExportDeclaration */ ||
             node.kind === 267 /* ImportClause */ && !!node.name ||
             node.kind === 268 /* NamespaceImport */ ||
             node.kind === 274 /* NamespaceExport */ ||
             node.kind === 270 /* ImportSpecifier */ ||
             node.kind === 275 /* ExportSpecifier */ ||
-            node.kind === 271 /* ExportAssignment */ && exportAssignmentIsAlias(node) ||
-            ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) ||
-            ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */ && isAliasableExpression(node.parent.right) ||
-            node.kind === 297 /* ShorthandPropertyAssignment */ ||
-            node.kind === 296 /* PropertyAssignment */ && isAliasableExpression(node.initializer);
+            node.kind === 271 /* ExportAssignment */ && exportAssignmentIsAlias(node)) {
+            return true;
+        }
+        return isInJSFile(node) && (ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) ||
+            ts.isPropertyAccessExpression(node)
+                && ts.isBinaryExpression(node.parent)
+                && node.parent.left === node
+                && node.parent.operatorToken.kind === 63 /* EqualsToken */
+                && isAliasableExpression(node.parent.right));
     }
     ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration;
     function getAliasDeclarationFromName(node) {
@@ -17095,6 +17105,7 @@ var ts;
             case 275 /* ExportSpecifier */:
             case 271 /* ExportAssignment */:
             case 265 /* ImportEqualsDeclaration */:
+            case 274 /* NamespaceExport */:
                 return node.parent;
             case 161 /* QualifiedName */:
                 do {
@@ -18921,6 +18932,11 @@ var ts;
             (node.parent.kind === 206 /* PropertyAccessExpression */ && node.parent.name === node);
     }
     ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess;
+    function isRightSideOfAccessExpression(node) {
+        return ts.isPropertyAccessExpression(node.parent) && node.parent.name === node
+            || ts.isElementAccessExpression(node.parent) && node.parent.argumentExpression === node;
+    }
+    ts.isRightSideOfAccessExpression = isRightSideOfAccessExpression;
     function isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName(node) {
         return ts.isQualifiedName(node.parent) && node.parent.right === node
             || ts.isPropertyAccessExpression(node.parent) && node.parent.name === node
@@ -19572,6 +19588,41 @@ var ts;
         return expr;
     }
     ts.getLeftmostAccessExpression = getLeftmostAccessExpression;
+    function forEachNameInAccessChainWalkingLeft(name, action) {
+        if (isAccessExpression(name.parent) && isRightSideOfAccessExpression(name)) {
+            return walkAccessExpression(name.parent);
+        }
+        function walkAccessExpression(access) {
+            if (access.kind === 206 /* PropertyAccessExpression */) {
+                var res = action(access.name);
+                if (res !== undefined) {
+                    return res;
+                }
+            }
+            else if (access.kind === 207 /* ElementAccessExpression */) {
+                if (ts.isIdentifier(access.argumentExpression) || ts.isStringLiteralLike(access.argumentExpression)) {
+                    var res = action(access.argumentExpression);
+                    if (res !== undefined) {
+                        return res;
+                    }
+                }
+                else {
+                    // Chain interrupted by non-static-name access 'x[expr()].y.z'
+                    return undefined;
+                }
+            }
+            if (isAccessExpression(access.expression)) {
+                return walkAccessExpression(access.expression);
+            }
+            if (ts.isIdentifier(access.expression)) {
+                // End of chain at Identifier 'x.y.z'
+                return action(access.expression);
+            }
+            // End of chain at non-Identifier 'x().y.z'
+            return undefined;
+        }
+    }
+    ts.forEachNameInAccessChainWalkingLeft = forEachNameInAccessChainWalkingLeft;
     function getLeftmostExpression(node, stopAtCallExpressions) {
         while (true) {
             switch (node.kind) {
@@ -20519,6 +20570,7 @@ var ts;
     ts.supportedJSExtensionsFlat = ts.flatten(ts.supportedJSExtensions);
     var allSupportedExtensions = [[".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */, ".js" /* Js */, ".jsx" /* Jsx */], [".cts" /* Cts */, ".d.cts" /* Dcts */, ".cjs" /* Cjs */], [".mts" /* Mts */, ".d.mts" /* Dmts */, ".mjs" /* Mjs */]];
     var allSupportedExtensionsWithJson = __spreadArray(__spreadArray([], allSupportedExtensions, true), [[".json" /* Json */]], false);
+    ts.supportedDeclarationExtensions = [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */];
     function getSupportedExtensions(options, extraFileExtensions) {
         var needJsExtensions = options && getAllowJSCompilerOption(options);
         if (!extraFileExtensions || extraFileExtensions.length === 0) {
@@ -21207,6 +21259,11 @@ var ts;
         return state > 1 /* NodeModules */ ? { topLevelNodeModulesIndex: topLevelNodeModulesIndex, topLevelPackageNameIndex: topLevelPackageNameIndex, packageRootIndex: packageRootIndex, fileNameIndex: fileNameIndex } : undefined;
     }
     ts.getNodeModulePathParts = getNodeModulePathParts;
+    function getParameterTypeNode(parameter) {
+        var _a;
+        return parameter.kind === 340 /* JSDocParameterTag */ ? (_a = parameter.typeExpression) === null || _a === void 0 ? void 0 : _a.type : parameter.type;
+    }
+    ts.getParameterTypeNode = getParameterTypeNode;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -35360,34 +35417,10 @@ var ts;
                 case 20 /* OpenParenToken */: // foo<x>(
                 case 14 /* NoSubstitutionTemplateLiteral */: // foo<T> `...`
                 case 15 /* TemplateHead */: // foo<T> `...${100}...`
-                // These tokens can't follow in a call expression, nor can they start an
-                // expression. So, consider the type argument list part of an instantiation
-                // expression.
-                // falls through
-                case 27 /* CommaToken */: // foo<x>,
-                case 24 /* DotToken */: // foo<x>.
-                case 28 /* QuestionDotToken */: // foo<x>?.
-                case 21 /* CloseParenToken */: // foo<x>)
-                case 23 /* CloseBracketToken */: // foo<x>]
-                case 58 /* ColonToken */: // foo<x>:
-                case 26 /* SemicolonToken */: // foo<x>;
-                case 57 /* QuestionToken */: // foo<x>?
-                case 34 /* EqualsEqualsToken */: // foo<x> ==
-                case 36 /* EqualsEqualsEqualsToken */: // foo<x> ===
-                case 35 /* ExclamationEqualsToken */: // foo<x> !=
-                case 37 /* ExclamationEqualsEqualsToken */: // foo<x> !==
-                case 55 /* AmpersandAmpersandToken */: // foo<x> &&
-                case 56 /* BarBarToken */: // foo<x> ||
-                case 60 /* QuestionQuestionToken */: // foo<x> ??
-                case 52 /* CaretToken */: // foo<x> ^
-                case 50 /* AmpersandToken */: // foo<x> &
-                case 51 /* BarToken */: // foo<x> |
-                case 19 /* CloseBraceToken */: // foo<x> }
-                case 1 /* EndOfFileToken */: // foo<x>
                     return true;
             }
-            // Treat anything else as an expression.
-            return false;
+            // Consider something a type argument list only if the following token can't start an expression.
+            return !isStartOfExpression();
         }
         function parsePrimaryExpression() {
             switch (token()) {
@@ -38605,7 +38638,7 @@ var ts;
     })(IncrementalParser || (IncrementalParser = {}));
     /** @internal */
     function isDeclarationFileName(fileName) {
-        return ts.fileExtensionIsOneOf(fileName, [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */]);
+        return ts.fileExtensionIsOneOf(fileName, ts.supportedDeclarationExtensions);
     }
     ts.isDeclarationFileName = isDeclarationFileName;
     function parseResolutionMode(mode, pos, end, reportDiagnostic) {
@@ -42113,7 +42146,8 @@ var ts;
         Extensions[Extensions["JavaScript"] = 1] = "JavaScript";
         Extensions[Extensions["Json"] = 2] = "Json";
         Extensions[Extensions["TSConfig"] = 3] = "TSConfig";
-        Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly"; /** Only '.d.ts' */
+        Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly";
+        Extensions[Extensions["TsOnly"] = 5] = "TsOnly";
     })(Extensions || (Extensions = {}));
     /** Used with `Extensions.DtsOnly` to extract the path from TypeScript results. */
     function resolvedTypeScriptOnly(resolved) {
@@ -43058,7 +43092,21 @@ var ts;
         return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, /*cache*/ undefined, jsOnlyExtensions, /*redirectedReferences*/ undefined);
     }
     function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) {
-        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference);
+        var extensions;
+        if (lookupConfig) {
+            extensions = tsconfigExtensions;
+        }
+        else if (compilerOptions.noDtsResolution) {
+            extensions = [Extensions.TsOnly];
+            if (compilerOptions.allowJs)
+                extensions.push(Extensions.JavaScript);
+            if (compilerOptions.resolveJsonModule)
+                extensions.push(Extensions.Json);
+        }
+        else {
+            extensions = compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions;
+        }
+        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, redirectedReference);
     }
     ts.nodeModuleNameResolver = nodeModuleNameResolver;
     function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
@@ -43067,6 +43115,10 @@ var ts;
         var failedLookupLocations = [];
         // conditions are only used by the node12/nodenext resolver - there's no priority order in the list,
         //it's essentially a set (priority is determined by object insertion order in the object we look at).
+        var conditions = features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"];
+        if (compilerOptions.noDtsResolution) {
+            conditions.pop();
+        }
         var state = {
             compilerOptions: compilerOptions,
             host: host,
@@ -43074,7 +43126,7 @@ var ts;
             failedLookupLocations: failedLookupLocations,
             packageJsonInfoCache: cache,
             features: features,
-            conditions: features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"]
+            conditions: conditions,
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
         return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
@@ -43250,9 +43302,9 @@ var ts;
         }
     }
     function loadJSOrExactTSFileName(extensions, candidate, onlyRecordFailures, state) {
-        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.fileExtensionIsOneOf(candidate, [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */])) {
+        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.isDeclarationFileName(candidate)) {
             var result = tryFile(candidate, onlyRecordFailures, state);
-            return result !== undefined ? { path: candidate, ext: ts.forEach([".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */], function (e) { return ts.fileExtensionIs(candidate, e) ? e : undefined; }) } : undefined;
+            return result !== undefined ? { path: candidate, ext: ts.forEach(ts.supportedDeclarationExtensions, function (e) { return ts.fileExtensionIs(candidate, e) ? e : undefined; }) } : undefined;
         }
         return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
     }
@@ -43282,20 +43334,22 @@ var ts;
                     default: return tryExtension(".d.ts" /* Dts */);
                 }
             case Extensions.TypeScript:
+            case Extensions.TsOnly:
+                var useDts = extensions === Extensions.TypeScript;
                 switch (originalExtension) {
                     case ".mjs" /* Mjs */:
                     case ".mts" /* Mts */:
                     case ".d.mts" /* Dmts */:
-                        return tryExtension(".mts" /* Mts */) || tryExtension(".d.mts" /* Dmts */);
+                        return tryExtension(".mts" /* Mts */) || (useDts ? tryExtension(".d.mts" /* Dmts */) : undefined);
                     case ".cjs" /* Cjs */:
                     case ".cts" /* Cts */:
                     case ".d.cts" /* Dcts */:
-                        return tryExtension(".cts" /* Cts */) || tryExtension(".d.cts" /* Dcts */);
+                        return tryExtension(".cts" /* Cts */) || (useDts ? tryExtension(".d.cts" /* Dcts */) : undefined);
                     case ".json" /* Json */:
                         candidate += ".json" /* Json */;
-                        return tryExtension(".d.ts" /* Dts */);
+                        return useDts ? tryExtension(".d.ts" /* Dts */) : undefined;
                     default:
-                        return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || tryExtension(".d.ts" /* Dts */);
+                        return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || (useDts ? tryExtension(".d.ts" /* Dts */) : undefined);
                 }
             case Extensions.JavaScript:
                 switch (originalExtension) {
@@ -43522,6 +43576,7 @@ var ts;
             switch (extensions) {
                 case Extensions.JavaScript:
                 case Extensions.Json:
+                case Extensions.TsOnly:
                     packageFile = readPackageJsonMainField(jsonContent, candidate, state);
                     break;
                 case Extensions.TypeScript:
@@ -43594,14 +43649,16 @@ var ts;
     function extensionIsOk(extensions, extension) {
         switch (extensions) {
             case Extensions.JavaScript:
-                return extension === ".js" /* Js */ || extension === ".jsx" /* Jsx */;
+                return extension === ".js" /* Js */ || extension === ".jsx" /* Jsx */ || extension === ".mjs" /* Mjs */ || extension === ".cjs" /* Cjs */;
             case Extensions.TSConfig:
             case Extensions.Json:
                 return extension === ".json" /* Json */;
             case Extensions.TypeScript:
-                return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".d.ts" /* Dts */;
+                return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".mts" /* Mts */ || extension === ".cts" /* Cts */ || extension === ".d.ts" /* Dts */ || extension === ".d.mts" /* Dmts */ || extension === ".d.cts" /* Dcts */;
+            case Extensions.TsOnly:
+                return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".mts" /* Mts */ || extension === ".cts" /* Cts */;
             case Extensions.DtsOnly:
-                return extension === ".d.ts" /* Dts */;
+                return extension === ".d.ts" /* Dts */ || extension === ".d.mts" /* Dmts */ || extension === ".d.cts" /* Dcts */;
         }
     }
     /* @internal */
@@ -45761,6 +45818,7 @@ var ts;
                 case 261 /* ModuleDeclaration */:
                 case 259 /* TypeAliasDeclaration */:
                 case 195 /* MappedType */:
+                case 176 /* IndexSignature */:
                     return 1 /* IsContainer */ | 32 /* HasLocals */;
                 case 305 /* SourceFile */:
                     return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */;
@@ -45779,7 +45837,6 @@ var ts;
                 case 317 /* JSDocFunctionType */:
                 case 179 /* FunctionType */:
                 case 175 /* ConstructSignature */:
-                case 176 /* IndexSignature */:
                 case 180 /* ConstructorType */:
                 case 170 /* ClassStaticBlockDeclaration */:
                     return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */;
@@ -50357,27 +50414,27 @@ var ts;
         function resolveAlias(symbol) {
             ts.Debug.assert((symbol.flags & 2097152 /* Alias */) !== 0, "Should only get Alias here.");
             var links = getSymbolLinks(symbol);
-            if (!links.target) {
-                links.target = resolvingSymbol;
+            if (!links.aliasTarget) {
+                links.aliasTarget = resolvingSymbol;
                 var node = getDeclarationOfAliasSymbol(symbol);
                 if (!node)
                     return ts.Debug.fail();
                 var target = getTargetOfAliasDeclaration(node);
-                if (links.target === resolvingSymbol) {
-                    links.target = target || unknownSymbol;
+                if (links.aliasTarget === resolvingSymbol) {
+                    links.aliasTarget = target || unknownSymbol;
                 }
                 else {
                     error(node, ts.Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol));
                 }
             }
-            else if (links.target === resolvingSymbol) {
-                links.target = unknownSymbol;
+            else if (links.aliasTarget === resolvingSymbol) {
+                links.aliasTarget = unknownSymbol;
             }
-            return links.target;
+            return links.aliasTarget;
         }
         function tryResolveAlias(symbol) {
             var links = getSymbolLinks(symbol);
-            if (links.target !== resolvingSymbol) {
+            if (links.aliasTarget !== resolvingSymbol) {
                 return resolveAlias(symbol);
             }
             return undefined;
@@ -52174,13 +52231,37 @@ var ts;
                 return ts.Debug.fail("Should be unreachable.");
                 function conditionalTypeToTypeNode(type) {
                     var checkTypeNode = typeToTypeNodeHelper(type.checkType, context);
+                    context.approximateLength += 15;
+                    if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && type.root.isDistributive && !(type.checkType.flags & 262144 /* TypeParameter */)) {
+                        var newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
+                        var name = typeParameterToName(newParam, context);
+                        var newTypeVariable = ts.factory.createTypeReferenceNode(name);
+                        context.approximateLength += 37; // 15 each for two added conditionals, 7 for an added infer type
+                        var newMapper = prependTypeMapping(type.root.checkType, newParam, type.combinedMapper || type.mapper);
+                        var saveInferTypeParameters_1 = context.inferTypeParameters;
+                        context.inferTypeParameters = type.root.inferTypeParameters;
+                        var extendsTypeNode_1 = typeToTypeNodeHelper(instantiateType(type.root.extendsType, newMapper), context);
+                        context.inferTypeParameters = saveInferTypeParameters_1;
+                        var trueTypeNode_1 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type.root.node.trueType), newMapper));
+                        var falseTypeNode_1 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type.root.node.falseType), newMapper));
+                        // outermost conditional makes `T` a type parameter, allowing the inner conditionals to be distributive
+                        // second conditional makes `T` have `T & checkType` substitution, so it is correctly usable as the checkType
+                        // inner conditional runs the check the user provided on the check type (distributively) and returns the result
+                        // checkType extends infer T ? T extends checkType ? T extends extendsType<T> ? trueType<T> : falseType<T> : never : never;
+                        // this is potentially simplifiable to
+                        // checkType extends infer T ? T extends checkType & extendsType<T> ? trueType<T> : falseType<T> : never;
+                        // but that may confuse users who read the output more.
+                        // On the other hand,
+                        // checkType extends infer T extends checkType ? T extends extendsType<T> ? trueType<T> : falseType<T> : never;
+                        // may also work with `infer ... extends ...` in, but would produce declarations only compatible with the latest TS.
+                        return ts.factory.createConditionalTypeNode(checkTypeNode, ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName))), ts.factory.createConditionalTypeNode(ts.factory.createTypeReferenceNode(ts.factory.cloneNode(name)), typeToTypeNodeHelper(type.checkType, context), ts.factory.createConditionalTypeNode(newTypeVariable, extendsTypeNode_1, trueTypeNode_1, falseTypeNode_1), ts.factory.createKeywordTypeNode(143 /* NeverKeyword */)), ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
+                    }
                     var saveInferTypeParameters = context.inferTypeParameters;
                     context.inferTypeParameters = type.root.inferTypeParameters;
                     var extendsTypeNode = typeToTypeNodeHelper(type.extendsType, context);
                     context.inferTypeParameters = saveInferTypeParameters;
                     var trueTypeNode = typeToTypeNodeOrCircularityElision(getTrueTypeFromConditionalType(type));
                     var falseTypeNode = typeToTypeNodeOrCircularityElision(getFalseTypeFromConditionalType(type));
-                    context.approximateLength += 15;
                     return ts.factory.createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);
                 }
                 function typeToTypeNodeOrCircularityElision(type) {
@@ -52879,9 +52960,6 @@ var ts;
                 if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
                     parameterType = getOptionalType(parameterType);
                 }
-                if ((context.flags & 1073741824 /* NoUndefinedOptionalParameterType */) && parameterDeclaration && !ts.isJSDocParameterTag(parameterDeclaration) && isOptionalUninitializedParameter(parameterDeclaration)) {
-                    parameterType = getTypeWithFacts(parameterType, 524288 /* NEUndefined */);
-                }
                 var parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
                 var modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && parameterDeclaration.modifiers ? parameterDeclaration.modifiers.map(ts.factory.cloneNode) : undefined;
                 var isRest = parameterDeclaration && ts.isRestParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
@@ -53440,7 +53518,7 @@ var ts;
                     if (declWithExistingAnnotation && !ts.isFunctionLikeDeclaration(declWithExistingAnnotation) && !ts.isGetAccessorDeclaration(declWithExistingAnnotation)) {
                         // try to reuse the existing annotation
                         var existing = ts.getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-                        if (getTypeFromTypeNode(existing) === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
+                        if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
                             var result_6 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
                             if (result_6) {
                                 return result_6;
@@ -53457,6 +53535,16 @@ var ts;
                 context.flags = oldFlags;
                 return result;
             }
+            function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type) {
+                var typeFromTypeNode = getTypeFromTypeNode(typeNode);
+                if (typeFromTypeNode === type) {
+                    return true;
+                }
+                if (ts.isParameter(annotatedDeclaration) && annotatedDeclaration.questionToken) {
+                    return getTypeWithFacts(type, 524288 /* NEUndefined */) === typeFromTypeNode;
+                }
+                return false;
+            }
             function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
                 if (!isErrorType(type) && context.enclosingDeclaration) {
                     var annotation = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration);
@@ -55728,7 +55816,7 @@ var ts;
                         }
                     }
                     var sourceTypes = ts.some(constructorTypes, function (t) { return !!(t.flags & ~98304 /* Nullable */); }) ? constructorTypes : types; // TODO: GH#18217
-                    type = getUnionType(sourceTypes, 2 /* Subtype */);
+                    type = getUnionType(sourceTypes);
                 }
             }
             var widened = getWidenedType(addOptionality(type, /*isProperty*/ false, definedInMethod && !definedInConstructor));
@@ -58477,8 +58565,9 @@ var ts;
                     // levels of nesting, we are presumably exploring a repeating pattern with a long cycle that hasn't
                     // yet triggered the deeply nested limiter. We have no test cases that actually get to 50 levels of
                     // nesting, so it is effectively just a safety stop.
-                    if (stack.length < 10 || stack.length < 50 && !isDeeplyNestedType(t, stack, stack.length)) {
-                        stack.push(t);
+                    var identity_1 = getRecursionIdentity(t);
+                    if (stack.length < 10 || stack.length < 50 && !ts.contains(stack, identity_1)) {
+                        stack.push(identity_1);
                         result = computeBaseConstraint(getSimplifiedType(t, /*writing*/ false));
                         stack.pop();
                     }
@@ -66676,12 +66765,12 @@ var ts;
         function isDeeplyNestedType(type, stack, depth, maxDepth) {
             if (maxDepth === void 0) { maxDepth = 3; }
             if (depth >= maxDepth) {
-                var identity_1 = getRecursionIdentity(type);
+                var identity_2 = getRecursionIdentity(type);
                 var count = 0;
                 var lastTypeId = 0;
                 for (var i = 0; i < depth; i++) {
                     var t = stack[i];
-                    if (getRecursionIdentity(t) === identity_1) {
+                    if (getRecursionIdentity(t) === identity_2) {
                         // We only count occurrences with a higher type id than the previous occurrence, since higher
                         // type ids are an indicator of newer instantiations caused by recursion.
                         if (t.id >= lastTypeId) {
@@ -76683,7 +76772,7 @@ var ts;
             var newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
             newSymbol.parent = originalSymbol;
             newSymbol.nameType = getStringLiteralType("default");
-            newSymbol.target = resolveSymbol(symbol);
+            newSymbol.aliasTarget = resolveSymbol(symbol);
             memberTable.set("default" /* Default */, newSymbol);
             return createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, ts.emptyArray);
         }
@@ -79495,19 +79584,28 @@ var ts;
             if (constraintType && defaultType) {
                 checkTypeAssignableTo(defaultType, getTypeWithThisArgument(instantiateType(constraintType, makeUnaryTypeMapper(typeParameter, defaultType)), defaultType), node.default, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
             }
-            if (node.parent.kind === 258 /* InterfaceDeclaration */ || node.parent.kind === 257 /* ClassDeclaration */ || node.parent.kind === 259 /* TypeAliasDeclaration */) {
+            checkNodeDeferred(node);
+            addLazyDiagnostic(function () { return checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); });
+        }
+        function checkTypeParameterDeferred(node) {
+            if (ts.isInterfaceDeclaration(node.parent) || ts.isClassLike(node.parent) || ts.isTypeAliasDeclaration(node.parent)) {
+                var typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
                 var modifiers = getVarianceModifiers(typeParameter);
-                if (modifiers === 32768 /* In */ || modifiers === 65536 /* Out */) {
+                if (modifiers) {
                     var symbol = getSymbolOfNode(node.parent);
-                    var source = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSubType : markerSuperType);
-                    var target = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSuperType : markerSubType);
-                    var saveVarianceTypeParameter = typeParameter;
-                    varianceTypeParameter = typeParameter;
-                    checkTypeAssignableTo(source, target, node, ts.Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation);
-                    varianceTypeParameter = saveVarianceTypeParameter;
+                    if (ts.isTypeAliasDeclaration(node.parent) && !(ts.getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
+                        error(node, ts.Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types);
+                    }
+                    else if (modifiers === 32768 /* In */ || modifiers === 65536 /* Out */) {
+                        var source = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSubType : markerSuperType);
+                        var target = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSuperType : markerSubType);
+                        var saveVarianceTypeParameter = typeParameter;
+                        varianceTypeParameter = typeParameter;
+                        checkTypeAssignableTo(source, target, node, ts.Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation);
+                        varianceTypeParameter = saveVarianceTypeParameter;
+                    }
                 }
             }
-            addLazyDiagnostic(function () { return checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); });
         }
         function checkParameter(node) {
             // Grammar checking
@@ -79997,7 +80095,7 @@ var ts;
                                         superCallStatement = statement;
                                         break;
                                     }
-                                    if (!ts.isPrologueDirective(statement) && nodeImmediatelyReferencesSuperOrThis(statement)) {
+                                    if (nodeImmediatelyReferencesSuperOrThis(statement)) {
                                         break;
                                     }
                                 }
@@ -85350,6 +85448,9 @@ var ts;
                 case 226 /* ClassExpression */:
                     checkClassExpressionDeferred(node);
                     break;
+                case 163 /* TypeParameter */:
+                    checkTypeParameterDeferred(node);
+                    break;
                 case 279 /* JsxSelfClosingElement */:
                     checkJsxSelfClosingElementDeferred(node);
                     break;
@@ -86164,11 +86265,11 @@ var ts;
                 var _a = symbol, leftSpread = _a.leftSpread, rightSpread = _a.rightSpread, syntheticOrigin = _a.syntheticOrigin;
                 return leftSpread ? [leftSpread, rightSpread]
                     : syntheticOrigin ? [syntheticOrigin]
-                        : ts.singleElementArray(tryGetAliasTarget(symbol));
+                        : ts.singleElementArray(tryGetTarget(symbol));
             }
             return undefined;
         }
-        function tryGetAliasTarget(symbol) {
+        function tryGetTarget(symbol) {
             var target;
             var next = symbol;
             while (next = getSymbolLinks(next).target) {
@@ -86398,7 +86499,7 @@ var ts;
                 if (links === null || links === void 0 ? void 0 : links.referenced) {
                     return true;
                 }
-                var target = getSymbolLinks(symbol).target; // TODO: GH#18217
+                var target = getSymbolLinks(symbol).aliasTarget; // TODO: GH#18217
                 if (target && ts.getEffectiveModifierFlags(node) & 1 /* Export */ &&
                     target.flags & 111551 /* Value */ &&
                     (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
@@ -86446,11 +86547,6 @@ var ts;
                 !parameter.initializer &&
                 ts.hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
         }
-        function isOptionalUninitializedParameter(parameter) {
-            return !!strictNullChecks &&
-                isOptionalParameter(parameter) &&
-                !parameter.initializer;
-        }
         function isExpandoFunctionDeclaration(node) {
             var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration);
             if (!declaration) {
@@ -87367,8 +87463,7 @@ var ts;
                     case 144 /* OutKeyword */:
                         var inOutFlag = modifier.kind === 101 /* InKeyword */ ? 32768 /* In */ : 65536 /* Out */;
                         var inOutText = modifier.kind === 101 /* InKeyword */ ? "in" : "out";
-                        if (node.kind !== 163 /* TypeParameter */ || (node.parent.kind !== 258 /* InterfaceDeclaration */ &&
-                            node.parent.kind !== 257 /* ClassDeclaration */ && node.parent.kind !== 259 /* TypeAliasDeclaration */)) {
+                        if (node.kind !== 163 /* TypeParameter */ || !(ts.isInterfaceDeclaration(node.parent) || ts.isClassLike(node.parent) || ts.isTypeAliasDeclaration(node.parent))) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias, inOutText);
                         }
                         if (flags & inOutFlag) {
@@ -92602,11 +92697,11 @@ var ts;
             }
             var statements = [];
             resumeLexicalEnvironment();
-            var indexAfterLastPrologueStatement = factory.copyPrologue(body.statements, statements, /*ensureUseStrict*/ false, visitor);
-            var superStatementIndex = ts.findSuperStatementIndex(body.statements, indexAfterLastPrologueStatement);
+            var prologueStatementCount = factory.copyPrologue(body.statements, statements, /*ensureUseStrict*/ false, visitor);
+            var superStatementIndex = ts.findSuperStatementIndex(body.statements, prologueStatementCount);
             // If there was a super call, visit existing statements up to and including it
             if (superStatementIndex >= 0) {
-                ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, indexAfterLastPrologueStatement, superStatementIndex + 1 - indexAfterLastPrologueStatement));
+                ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, prologueStatementCount, superStatementIndex + 1 - prologueStatementCount));
             }
             // Transform parameters into property assignments. Transforms this:
             //
@@ -92625,12 +92720,12 @@ var ts;
             if (superStatementIndex >= 0) {
                 ts.addRange(statements, parameterPropertyAssignments);
             }
-            // Since there was no super() call, parameter properties are the first statements in the constructor
+            // Since there was no super() call, parameter properties are the first statements in the constructor after any prologue statements
             else {
-                statements = ts.addRange(parameterPropertyAssignments, statements);
+                statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
             }
-            // Add remaining statements from the body, skipping the super() call if it was found
-            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1));
+            // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
+            ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
             // End the lexical environment.
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -108394,6 +108489,10 @@ var ts;
             return factory.updateModifiers(statement, modifiers);
         }
         function transformTopLevelDeclaration(input) {
+            if (lateMarkedStatements) {
+                while (ts.orderedRemoveItem(lateMarkedStatements, input))
+                    ;
+            }
             if (shouldStripInternal(input))
                 return;
             switch (input.kind) {
@@ -109525,7 +109624,7 @@ var ts;
         addOutput(buildInfoPath);
     }
     function getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory) {
-        if (ts.fileExtensionIs(inputFileName, ".d.ts" /* Dts */))
+        if (ts.isDeclarationFileName(inputFileName))
             return;
         var js = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory);
         addOutput(js);
@@ -109570,7 +109669,7 @@ var ts;
     /*@internal*/
     function getCommonSourceDirectoryOfConfig(_a, ignoreCase) {
         var options = _a.options, fileNames = _a.fileNames;
-        return getCommonSourceDirectory(options, function () { return ts.filter(fileNames, function (file) { return !(options.noEmitForJsFiles && ts.fileExtensionIsOneOf(file, ts.supportedJSExtensionsFlat)) && !ts.fileExtensionIs(file, ".d.ts" /* Dts */); }); }, ts.getDirectoryPath(ts.normalizeSlashes(ts.Debug.checkDefined(options.configFilePath))), ts.createGetCanonicalFileName(!ignoreCase));
+        return getCommonSourceDirectory(options, function () { return ts.filter(fileNames, function (file) { return !(options.noEmitForJsFiles && ts.fileExtensionIsOneOf(file, ts.supportedJSExtensionsFlat)) && !ts.isDeclarationFileName(file); }); }, ts.getDirectoryPath(ts.normalizeSlashes(ts.Debug.checkDefined(options.configFilePath))), ts.createGetCanonicalFileName(!ignoreCase));
     }
     ts.getCommonSourceDirectoryOfConfig = getCommonSourceDirectoryOfConfig;
     /*@internal*/
@@ -109612,7 +109711,7 @@ var ts;
         var getCommonSourceDirectory = ts.memoize(function () { return getCommonSourceDirectoryOfConfig(configFile, ignoreCase); });
         for (var _a = 0, _b = configFile.fileNames; _a < _b.length; _a++) {
             var inputFileName = _b[_a];
-            if (ts.fileExtensionIs(inputFileName, ".d.ts" /* Dts */))
+            if (ts.isDeclarationFileName(inputFileName))
                 continue;
             var jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory);
             if (jsFilePath)
@@ -114962,7 +115061,7 @@ var ts;
         if (ts.outFile(options) || options.outDir)
             return false;
         // File if emitted next to input needs to be ignored
-        if (ts.fileExtensionIs(fileOrDirectoryPath, ".d.ts" /* Dts */)) {
+        if (ts.isDeclarationFileName(fileOrDirectoryPath)) {
             // If its declaration directory: its not ignored if not excluded by config
             if (options.declarationDir)
                 return false;
@@ -116135,7 +116234,7 @@ var ts;
                                 var getCommonSourceDirectory_2 = ts.memoize(function () { return ts.getCommonSourceDirectoryOfConfig(parsedRef.commandLine, !host.useCaseSensitiveFileNames()); });
                                 for (var _b = 0, _c = parsedRef.commandLine.fileNames; _b < _c.length; _b++) {
                                     var fileName = _c[_b];
-                                    if (!ts.fileExtensionIs(fileName, ".d.ts" /* Dts */) && !ts.fileExtensionIs(fileName, ".json" /* Json */)) {
+                                    if (!ts.isDeclarationFileName(fileName) && !ts.fileExtensionIs(fileName, ".json" /* Json */)) {
                                         processProjectReferenceFile(ts.getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory_2), { kind: ts.FileIncludeKind.OutputFromProjectReference, index: index });
                                     }
                                 }
@@ -116326,7 +116425,7 @@ var ts;
         }
         function getRedirectReferenceForResolution(file) {
             var redirect = getResolvedProjectReferenceToRedirect(file.originalFileName);
-            if (redirect || !ts.fileExtensionIsOneOf(file.originalFileName, [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */]))
+            if (redirect || !ts.isDeclarationFileName(file.originalFileName))
                 return redirect;
             // The originalFileName could not be actual source file name if file found was d.ts from referecned project
             // So in this case try to look up if this is output from referenced project, if it is use the redirected project in that case
@@ -117717,7 +117816,7 @@ var ts;
         }
         function getProjectReferenceRedirectProject(fileName) {
             // Ignore dts or any json files
-            if (!resolvedProjectReferences || !resolvedProjectReferences.length || ts.fileExtensionIs(fileName, ".d.ts" /* Dts */) || ts.fileExtensionIs(fileName, ".json" /* Json */)) {
+            if (!resolvedProjectReferences || !resolvedProjectReferences.length || ts.isDeclarationFileName(fileName) || ts.fileExtensionIs(fileName, ".json" /* Json */)) {
                 return undefined;
             }
             // If this file is produced by a referenced project, we need to rewrite it to
@@ -117766,7 +117865,7 @@ var ts;
                     else {
                         var getCommonSourceDirectory_3 = ts.memoize(function () { return ts.getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()); });
                         ts.forEach(resolvedRef.commandLine.fileNames, function (fileName) {
-                            if (!ts.fileExtensionIs(fileName, ".d.ts" /* Dts */) && !ts.fileExtensionIs(fileName, ".json" /* Json */)) {
+                            if (!ts.isDeclarationFileName(fileName) && !ts.fileExtensionIs(fileName, ".json" /* Json */)) {
                                 var outputDts = ts.getOutputDeclarationFileName(fileName, resolvedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory_3);
                                 mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), fileName);
                             }
@@ -118567,7 +118666,7 @@ var ts;
             if (options.outDir) {
                 return ts.containsPath(options.outDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames());
             }
-            if (ts.fileExtensionIsOneOf(filePath, ts.supportedJSExtensionsFlat) || ts.fileExtensionIs(filePath, ".d.ts" /* Dts */)) {
+            if (ts.fileExtensionIsOneOf(filePath, ts.supportedJSExtensionsFlat) || ts.isDeclarationFileName(filePath)) {
                 // Otherwise just check if sourceFile with the name exists
                 var filePathWithoutExtension = ts.removeFileExtension(filePath);
                 return !!getSourceFileByPath((filePathWithoutExtension + ".ts" /* Ts */)) ||
@@ -118900,13 +118999,9 @@ var ts;
     ts.getFileEmitOutput = getFileEmitOutput;
     var BuilderState;
     (function (BuilderState) {
-        var manyToManyPathMapCount = 0;
         function createManyToManyPathMap() {
             function create(forward, reverse, deleted) {
-                var version = 0;
                 var map = {
-                    id: manyToManyPathMapCount++,
-                    version: function () { return version; },
                     clone: function () { return create(new ts.Map(forward), new ts.Map(reverse), deleted && new ts.Set(deleted)); },
                     forEach: function (fn) { return forward.forEach(fn); },
                     getKeys: function (v) { return reverse.get(v); },
@@ -118922,30 +119017,29 @@ var ts;
                         }
                         set.forEach(function (v) { return deleteFromMultimap(reverse, v, k); });
                         forward.delete(k);
-                        version++;
                         return true;
                     },
                     set: function (k, vSet) {
-                        var changed = !!(deleted === null || deleted === void 0 ? void 0 : deleted.delete(k));
+                        deleted === null || deleted === void 0 ? void 0 : deleted.delete(k);
                         var existingVSet = forward.get(k);
                         forward.set(k, vSet);
                         existingVSet === null || existingVSet === void 0 ? void 0 : existingVSet.forEach(function (v) {
                             if (!vSet.has(v)) {
-                                changed = true;
                                 deleteFromMultimap(reverse, v, k);
                             }
                         });
                         vSet.forEach(function (v) {
                             if (!(existingVSet === null || existingVSet === void 0 ? void 0 : existingVSet.has(v))) {
-                                changed = true;
                                 addToMultimap(reverse, v, k);
                             }
                         });
-                        if (changed) {
-                            version++;
-                        }
                         return map;
                     },
+                    clear: function () {
+                        forward.clear();
+                        reverse.clear();
+                        deleted === null || deleted === void 0 ? void 0 : deleted.clear();
+                    }
                 };
                 return map;
             }
@@ -118960,11 +119054,10 @@ var ts;
             }
             set.add(v);
         }
-        function deleteFromMultimap(map, k, v, removeEmpty) {
-            if (removeEmpty === void 0) { removeEmpty = true; }
+        function deleteFromMultimap(map, k, v) {
             var set = map.get(k);
             if (set === null || set === void 0 ? void 0 : set.delete(v)) {
-                if (removeEmpty && !set.size) {
+                if (!set.size) {
                     map.delete(k);
                 }
                 return true;
@@ -119193,7 +119286,7 @@ var ts;
                 /*forceDtsEmit*/ true);
                 var firstDts_1 = ts.firstOrUndefined(emitOutput_1.outputFiles);
                 if (firstDts_1) {
-                    ts.Debug.assert(ts.fileExtensionIsOneOf(firstDts_1.name, [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */]), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
+                    ts.Debug.assert(ts.isDeclarationFileName(firstDts_1.name), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
                     latestSignature = (computeHash || ts.generateDjb2Hash)(firstDts_1.text);
                     if (exportedModulesMapCache && latestSignature !== prevSignature) {
                         updateExportedModules(sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
@@ -119251,20 +119344,6 @@ var ts;
             var _a;
             if (exportedModulesMapCache) {
                 ts.Debug.assert(!!state.exportedModulesMap);
-                var cacheId = exportedModulesMapCache.id;
-                var cacheVersion = exportedModulesMapCache.version();
-                if (state.previousCache) {
-                    if (state.previousCache.id === cacheId && state.previousCache.version === cacheVersion) {
-                        // If this is the same cache at the same version as last time this BuilderState
-                        // was updated, there's no need to update again
-                        return;
-                    }
-                    state.previousCache.id = cacheId;
-                    state.previousCache.version = cacheVersion;
-                }
-                else {
-                    state.previousCache = { id: cacheId, version: cacheVersion };
-                }
                 (_a = exportedModulesMapCache.deletedKeys()) === null || _a === void 0 ? void 0 : _a.forEach(function (path) { return state.exportedModulesMap.deleteKey(path); });
                 exportedModulesMapCache.forEach(function (exportedModules, path) { return state.exportedModulesMap.set(path, exportedModules); });
             }
@@ -119598,7 +119677,8 @@ var ts;
      * This is to allow the callers to be able to actually remove affected file only when the operation is complete
      * eg. if during diagnostics check cancellation token ends up cancelling the request, the affected file should be retained
      */
-    function getNextAffectedFile(state, cancellationToken, computeHash) {
+    function getNextAffectedFile(state, cancellationToken, computeHash, host) {
+        var _a;
         while (true) {
             var affectedFiles = state.affectedFiles;
             if (affectedFiles) {
@@ -119609,7 +119689,7 @@ var ts;
                     if (!seenAffectedFiles.has(affectedFile.resolvedPath)) {
                         // Set the next affected file as seen and remove the cached semantic diagnostics
                         state.affectedFilesIndex = affectedFilesIndex;
-                        handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash);
+                        handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host);
                         return affectedFile;
                     }
                     affectedFilesIndex++;
@@ -119621,6 +119701,7 @@ var ts;
                 ts.BuilderState.updateSignaturesFromCache(state, state.currentAffectedFilesSignatures);
                 state.currentAffectedFilesSignatures.clear();
                 ts.BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap);
+                (_a = state.currentAffectedFilesExportedModulesMap) === null || _a === void 0 ? void 0 : _a.clear();
                 state.affectedFiles = undefined;
             }
             // Get next changed file
@@ -119650,6 +119731,11 @@ var ts;
                 state.seenAffectedFiles = new ts.Set();
         }
     }
+    function clearAffectedFilesPendingEmit(state) {
+        state.affectedFilesPendingEmit = undefined;
+        state.affectedFilesPendingEmitKind = undefined;
+        state.affectedFilesPendingEmitIndex = undefined;
+    }
     /**
      * Returns next file to be emitted from files that retrieved semantic diagnostics but did not emit yet
      */
@@ -119669,9 +119755,7 @@ var ts;
                     }
                 }
             }
-            state.affectedFilesPendingEmit = undefined;
-            state.affectedFilesPendingEmitKind = undefined;
-            state.affectedFilesPendingEmitIndex = undefined;
+            clearAffectedFilesPendingEmit(state);
         }
         return undefined;
     }
@@ -119679,7 +119763,7 @@ var ts;
      *  Handles semantic diagnostics and dts emit for affectedFile and files, that are referencing modules that export entities from affected file
      *  This is because even though js emit doesnt change, dts emit / type used can change resulting in need for dts emit and js change
      */
-    function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash) {
+    function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host) {
         var _a;
         removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
         // If affected files is everything except default library, then nothing more to do
@@ -119704,14 +119788,14 @@ var ts;
             ts.Debug.assert(state.hasCalledUpdateShapeSignature.has(affectedFile.resolvedPath) || ((_a = state.currentAffectedFilesSignatures) === null || _a === void 0 ? void 0 : _a.has(affectedFile.resolvedPath)), "Signature not updated for affected file: " + affectedFile.fileName);
         }
         if (!state.compilerOptions.assumeChangesOnlyAffectDirectDependencies) {
-            forEachReferencingModulesOfExportOfAffectedFile(state, affectedFile, function (state, path) { return handleDtsMayChangeOf(state, path, cancellationToken, computeHash); });
+            forEachReferencingModulesOfExportOfAffectedFile(state, affectedFile, function (state, path) { return handleDtsMayChangeOf(state, path, cancellationToken, computeHash, host); });
         }
     }
     /**
      * Handle the dts may change, so they need to be added to pending emit if dts emit is enabled,
      * Also we need to make sure signature is updated for these files
      */
-    function handleDtsMayChangeOf(state, path, cancellationToken, computeHash) {
+    function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, host) {
         removeSemanticDiagnosticsOf(state, path);
         if (!state.changedFilesSet.has(path)) {
             var program = ts.Debug.checkDefined(state.program);
@@ -119722,8 +119806,7 @@ var ts;
                 // This ensures that we dont later during incremental builds considering wrong signature.
                 // Eg where this also is needed to ensure that .tsbuildinfo generated by incremental build should be same as if it was first fresh build
                 // But we avoid expensive full shape computation, as using file version as shape is enough for correctness.
-                ts.BuilderState.updateShapeSignature(state, program, sourceFile, ts.Debug.checkDefined(state.currentAffectedFilesSignatures), cancellationToken, computeHash, state.currentAffectedFilesExportedModulesMap, 
-                /* useFileVersionAsSignature */ true);
+                ts.BuilderState.updateShapeSignature(state, program, sourceFile, ts.Debug.checkDefined(state.currentAffectedFilesSignatures), cancellationToken, computeHash, state.currentAffectedFilesExportedModulesMap, !host.disableUseFileVersionAsSignature);
                 // If not dts emit, nothing more to do
                 if (ts.getEmitDeclarations(state.compilerOptions)) {
                     addToAffectedFilesPendingEmit(state, path, 0 /* DtsOnly */);
@@ -119920,13 +120003,18 @@ var ts;
             var signature = state.currentAffectedFilesSignatures && state.currentAffectedFilesSignatures.get(key);
             var actualSignature = signature !== null && signature !== void 0 ? signature : value.signature;
             return value.version === actualSignature ?
-                value.affectsGlobalScope ?
-                    { version: value.version, signature: undefined, affectsGlobalScope: true, impliedFormat: value.impliedFormat } :
+                value.affectsGlobalScope || value.impliedFormat ?
+                    // If file version is same as signature, dont serialize signature
+                    { version: value.version, signature: undefined, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } :
+                    // If file info only contains version and signature and both are same we can just write string
                     value.version :
-                actualSignature !== undefined ?
+                actualSignature !== undefined ? // If signature is not same as version, encode signature in the fileInfo
                     signature === undefined ?
+                        // If we havent computed signature, use fileInfo as is
                         value :
+                        // Serialize fileInfo with new updated signature
                         { version: value.version, signature: signature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } :
+                    // Signature of the FileInfo is undefined, serialize it as false
                     { version: value.version, signature: false, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat };
         });
         var referencedMap;
@@ -120171,7 +120259,7 @@ var ts;
          * in that order would be used to write the files
          */
         function emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
-            var affected = getNextAffectedFile(state, cancellationToken, computeHash);
+            var affected = getNextAffectedFile(state, cancellationToken, computeHash, host);
             var emitKind = 1 /* Full */;
             var isPendingEmitFile = false;
             if (!affected) {
@@ -120216,54 +120304,48 @@ var ts;
          * in that order would be used to write the files
          */
         function emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
-            var restorePendingEmitOnHandlingNoEmitSuccess = false;
-            var savedAffectedFilesPendingEmit;
-            var savedAffectedFilesPendingEmitKind;
-            var savedAffectedFilesPendingEmitIndex;
-            // Backup and restore affected pendings emit state for non emit Builder if noEmitOnError is enabled and emitBuildInfo could be written in case there are errors
-            // This ensures pending files to emit is updated in tsbuildinfo
-            // Note that when there are no errors, emit proceeds as if everything is emitted as it is callers reponsibility to write the files to disk if at all (because its builder that doesnt track files to emit)
-            if (kind !== BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram &&
-                !targetSourceFile &&
-                !ts.outFile(state.compilerOptions) &&
-                !state.compilerOptions.noEmit &&
-                state.compilerOptions.noEmitOnError) {
-                restorePendingEmitOnHandlingNoEmitSuccess = true;
-                savedAffectedFilesPendingEmit = state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice();
-                savedAffectedFilesPendingEmitKind = state.affectedFilesPendingEmitKind && new ts.Map(state.affectedFilesPendingEmitKind);
-                savedAffectedFilesPendingEmitIndex = state.affectedFilesPendingEmitIndex;
-            }
+            var _a;
             if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
                 assertSourceFileOkWithoutNextAffectedCall(state, targetSourceFile);
             }
             var result = ts.handleNoEmitOptions(builderProgram, targetSourceFile, writeFile, cancellationToken);
             if (result)
                 return result;
-            if (restorePendingEmitOnHandlingNoEmitSuccess) {
-                state.affectedFilesPendingEmit = savedAffectedFilesPendingEmit;
-                state.affectedFilesPendingEmitKind = savedAffectedFilesPendingEmitKind;
-                state.affectedFilesPendingEmitIndex = savedAffectedFilesPendingEmitIndex;
-            }
             // Emit only affected files if using builder for emit
-            if (!targetSourceFile && kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
-                // Emit and report any errors we ran into.
-                var sourceMaps = [];
-                var emitSkipped = false;
-                var diagnostics = void 0;
-                var emittedFiles = [];
-                var affectedEmitResult = void 0;
-                while (affectedEmitResult = emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers)) {
-                    emitSkipped = emitSkipped || affectedEmitResult.result.emitSkipped;
-                    diagnostics = ts.addRange(diagnostics, affectedEmitResult.result.diagnostics);
-                    emittedFiles = ts.addRange(emittedFiles, affectedEmitResult.result.emittedFiles);
-                    sourceMaps = ts.addRange(sourceMaps, affectedEmitResult.result.sourceMaps);
+            if (!targetSourceFile) {
+                if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
+                    // Emit and report any errors we ran into.
+                    var sourceMaps = [];
+                    var emitSkipped = false;
+                    var diagnostics = void 0;
+                    var emittedFiles = [];
+                    var affectedEmitResult = void 0;
+                    while (affectedEmitResult = emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers)) {
+                        emitSkipped = emitSkipped || affectedEmitResult.result.emitSkipped;
+                        diagnostics = ts.addRange(diagnostics, affectedEmitResult.result.diagnostics);
+                        emittedFiles = ts.addRange(emittedFiles, affectedEmitResult.result.emittedFiles);
+                        sourceMaps = ts.addRange(sourceMaps, affectedEmitResult.result.sourceMaps);
+                    }
+                    return {
+                        emitSkipped: emitSkipped,
+                        diagnostics: diagnostics || ts.emptyArray,
+                        emittedFiles: emittedFiles,
+                        sourceMaps: sourceMaps
+                    };
+                }
+                // In non Emit builder, clear affected files pending emit
+                else if ((_a = state.affectedFilesPendingEmitKind) === null || _a === void 0 ? void 0 : _a.size) {
+                    ts.Debug.assert(kind === BuilderProgramKind.SemanticDiagnosticsBuilderProgram);
+                    // State can clear affected files pending emit if
+                    if (!emitOnlyDtsFiles // If we are doing complete emit, affected files pending emit can be cleared
+                        // If every file pending emit is pending on only dts emit
+                        || ts.every(state.affectedFilesPendingEmit, function (path, index) {
+                            return index < state.affectedFilesPendingEmitIndex ||
+                                state.affectedFilesPendingEmitKind.get(path) === 0 /* DtsOnly */;
+                        })) {
+                        clearAffectedFilesPendingEmit(state);
+                    }
                 }
-                return {
-                    emitSkipped: emitSkipped,
-                    diagnostics: diagnostics || ts.emptyArray,
-                    emittedFiles: emittedFiles,
-                    sourceMaps: sourceMaps
-                };
             }
             return ts.Debug.checkDefined(state.program).emit(targetSourceFile, writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
         }
@@ -120273,7 +120355,7 @@ var ts;
          */
         function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) {
             while (true) {
-                var affected = getNextAffectedFile(state, cancellationToken, computeHash);
+                var affected = getNextAffectedFile(state, cancellationToken, computeHash, host);
                 if (!affected) {
                     // Done
                     return undefined;
@@ -123393,9 +123475,6 @@ var ts;
     function newer(date1, date2) {
         return date2 > date1 ? date2 : date1;
     }
-    function isDeclarationFile(fileName) {
-        return ts.fileExtensionIs(fileName, ".d.ts" /* Dts */);
-    }
     /*@internal*/
     function isCircularBuildOrder(buildOrder) {
         return !!buildOrder && !!buildOrder.buildOrder;
@@ -123958,7 +124037,7 @@ var ts;
             outputFiles.forEach(function (_a) {
                 var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark;
                 var priorChangeTime;
-                if (!anyDtsChanged && isDeclarationFile(name)) {
+                if (!anyDtsChanged && ts.isDeclarationFileName(name)) {
                     // Check for unchanged .d.ts files
                     if (host.fileExists(name) && state.readFileWithCache(name) === text) {
                         priorChangeTime = host.getModifiedTime(name);
@@ -124299,7 +124378,7 @@ var ts;
                 // In addition to file timestamps, we also keep track of when a .d.ts file
                 // had its file touched but not had its contents changed - this allows us
                 // to skip a downstream typecheck
-                if (isDeclarationFile(output)) {
+                if (ts.isDeclarationFileName(output)) {
                     var outputModifiedTime = ts.getModifiedTime(host, output);
                     newestDeclarationFileContentChangedTime = newer(newestDeclarationFileContentChangedTime, outputModifiedTime);
                 }
@@ -124453,7 +124532,7 @@ var ts;
                     reportVerbose = false;
                     reportStatus(state, verboseMessage, proj.options.configFilePath);
                 }
-                if (isDeclarationFile(file)) {
+                if (ts.isDeclarationFileName(file)) {
                     priorNewestUpdateTime = newer(priorNewestUpdateTime, ts.getModifiedTime(host, file));
                 }
                 host.setModifiedTime(file, now);