typescript 4.7.0-dev.20220408 → 4.7.0-dev.20220415

package/lib/typescript.js

@@ -294,7 +294,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.20220408";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220415";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4854,7 +4854,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";
@@ -15160,6 +15159,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 */:
@@ -16520,17 +16523,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)
@@ -16738,14 +16737,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);
         }
@@ -17260,7 +17259,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;
@@ -17276,21 +17278,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) {
@@ -17301,6 +17310,7 @@ var ts;
             case 275 /* ExportSpecifier */:
             case 271 /* ExportAssignment */:
             case 265 /* ImportEqualsDeclaration */:
+            case 274 /* NamespaceExport */:
                 return node.parent;
             case 161 /* QualifiedName */:
                 do {
@@ -19127,6 +19137,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
@@ -19778,6 +19793,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) {
@@ -20725,6 +20775,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) {
@@ -21413,6 +21464,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;
@@ -35566,34 +35622,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()) {
@@ -38811,7 +38843,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) {
@@ -42319,7 +42351,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) {
@@ -43264,7 +43297,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) {
@@ -43273,6 +43320,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,
@@ -43280,7 +43331,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);
@@ -43456,9 +43507,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);
     }
@@ -43488,20 +43539,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) {
@@ -43728,6 +43781,7 @@ var ts;
             switch (extensions) {
                 case Extensions.JavaScript:
                 case Extensions.Json:
+                case Extensions.TsOnly:
                     packageFile = readPackageJsonMainField(jsonContent, candidate, state);
                     break;
                 case Extensions.TypeScript:
@@ -43800,14 +43854,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 */
@@ -53109,9 +53165,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 */;
@@ -53670,7 +53723,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;
@@ -53687,6 +53740,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);
@@ -55958,7 +56021,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));
@@ -58707,8 +58770,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();
                     }
@@ -66906,12 +66970,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) {
@@ -79725,11 +79789,16 @@ 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) {
                     var symbol = getSymbolOfNode(node.parent);
-                    if (node.parent.kind === 259 /* TypeAliasDeclaration */ && !(ts.getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
+                    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 */) {
@@ -79742,7 +79811,6 @@ var ts;
                     }
                 }
             }
-            addLazyDiagnostic(function () { return checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); });
         }
         function checkParameter(node) {
             // Grammar checking
@@ -80232,7 +80300,7 @@ var ts;
                                         superCallStatement = statement;
                                         break;
                                     }
-                                    if (!ts.isPrologueDirective(statement) && nodeImmediatelyReferencesSuperOrThis(statement)) {
+                                    if (nodeImmediatelyReferencesSuperOrThis(statement)) {
                                         break;
                                     }
                                 }
@@ -85585,6 +85653,9 @@ var ts;
                 case 226 /* ClassExpression */:
                     checkClassExpressionDeferred(node);
                     break;
+                case 163 /* TypeParameter */:
+                    checkTypeParameterDeferred(node);
+                    break;
                 case 279 /* JsxSelfClosingElement */:
                     checkJsxSelfClosingElementDeferred(node);
                     break;
@@ -86681,11 +86752,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) {
@@ -87602,8 +87668,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) {
@@ -92837,11 +92902,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:
             //
@@ -92860,12 +92925,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);
@@ -109764,7 +109829,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);
@@ -109809,7 +109874,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*/
@@ -109851,7 +109916,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)
@@ -115201,7 +115266,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;
@@ -116374,7 +116439,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 });
                                     }
                                 }
@@ -116565,7 +116630,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
@@ -117956,7 +118021,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
@@ -118005,7 +118070,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);
                             }
@@ -118806,7 +118871,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 */)) ||
@@ -119432,7 +119497,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);
@@ -119837,7 +119902,7 @@ 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) {
         while (true) {
             var affectedFiles = state.affectedFiles;
             if (affectedFiles) {
@@ -119848,7 +119913,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++;
@@ -119889,6 +119954,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
      */
@@ -119908,9 +119978,7 @@ var ts;
                     }
                 }
             }
-            state.affectedFilesPendingEmit = undefined;
-            state.affectedFilesPendingEmitKind = undefined;
-            state.affectedFilesPendingEmitIndex = undefined;
+            clearAffectedFilesPendingEmit(state);
         }
         return undefined;
     }
@@ -119918,7 +119986,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
@@ -119943,14 +120011,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);
@@ -119961,8 +120029,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 */);
@@ -120159,13 +120226,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;
@@ -120410,7 +120482,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) {
@@ -120455,54 +120527,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);
         }
@@ -120512,7 +120578,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;
@@ -123632,9 +123698,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;
@@ -124197,7 +124260,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);
@@ -124538,7 +124601,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);
                 }
@@ -124692,7 +124755,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);
@@ -132004,17 +132067,13 @@ var ts;
                 }
             }
             if (origin && originIsObjectLiteralMethod(origin)) {
-                var importAdder = void 0;
-                (insertText = origin.insertText, isSnippet = origin.isSnippet, importAdder = origin.importAdder, labelDetails = origin.labelDetails);
+                (insertText = origin.insertText, isSnippet = origin.isSnippet, labelDetails = origin.labelDetails);
                 if (!preferences.useLabelDetailsInCompletionEntries) {
                     name = name + labelDetails.detail;
                     labelDetails = undefined;
                 }
                 source = CompletionSource.ObjectLiteralMethodSnippet;
                 sortText = Completions.SortText.SortBelow(sortText);
-                if (importAdder.hasFixes()) {
-                    hasAction = true;
-                }
             }
             if (isJsxIdentifierExpected && !isRightOfOpenTag && preferences.includeCompletionsWithSnippetText && preferences.jsxAttributeCompletionStyle && preferences.jsxAttributeCompletionStyle !== "none") {
                 var useBraces_1 = preferences.jsxAttributeCompletionStyle === "braces";
@@ -132237,8 +132296,7 @@ var ts;
             var isSnippet = preferences.includeCompletionsWithSnippetText || undefined;
             var insertText = name;
             var sourceFile = enclosingDeclaration.getSourceFile();
-            var importAdder = ts.codefix.createImportAdder(sourceFile, program, preferences, host);
-            var method = createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences, importAdder);
+            var method = createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences);
             if (!method) {
                 return undefined;
             }
@@ -132267,16 +132325,15 @@ var ts;
             /*modifiers*/ undefined, 
             /*name*/ "", method.questionToken, method.typeParameters, method.parameters, method.type);
             var labelDetails = { detail: signaturePrinter.printNode(4 /* Unspecified */, methodSignature, sourceFile) };
-            return { isSnippet: isSnippet, insertText: insertText, importAdder: importAdder, labelDetails: labelDetails };
+            return { isSnippet: isSnippet, insertText: insertText, labelDetails: labelDetails };
         }
         ;
-        function createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences, importAdder) {
+        function createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences) {
             var declarations = symbol.getDeclarations();
             if (!(declarations && declarations.length)) {
                 return undefined;
             }
             var checker = program.getTypeChecker();
-            var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
             var declaration = declarations[0];
             var name = ts.getSynthesizedDeepClone(ts.getNameOfDeclaration(declaration), /*includeTrivia*/ false);
             var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
@@ -132309,11 +132366,6 @@ var ts;
                     if (!typeNode || !ts.isFunctionTypeNode(typeNode)) {
                         return undefined;
                     }
-                    var importableReference = ts.codefix.tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
-                    if (importableReference) {
-                        typeNode = importableReference.typeNode;
-                        ts.codefix.importSymbols(importAdder, importableReference.symbols);
-                    }
                     var body = void 0;
                     if (preferences.includeCompletionsWithSnippetText) {
                         var emptyStmt = ts.factory.createEmptyStatement();
@@ -132323,11 +132375,19 @@ var ts;
                     else {
                         body = ts.factory.createBlock([], /* multiline */ true);
                     }
+                    var parameters = typeNode.parameters.map(function (typedParam) {
+                        return ts.factory.createParameterDeclaration(
+                        /*decorators*/ undefined, 
+                        /*modifiers*/ undefined, typedParam.dotDotDotToken, typedParam.name, typedParam.questionToken, 
+                        /*type*/ undefined, typedParam.initializer);
+                    });
                     return ts.factory.createMethodDeclaration(
                     /*decorators*/ undefined, 
                     /*modifiers*/ undefined, 
                     /*asteriskToken*/ undefined, name, 
-                    /*questionToken*/ undefined, typeNode.typeParameters, typeNode.parameters, typeNode.type, body);
+                    /*questionToken*/ undefined, 
+                    /*typeParameters*/ undefined, parameters, 
+                    /*type*/ undefined, body);
                 }
                 default:
                     return undefined;
@@ -132690,20 +132750,6 @@ var ts;
                     };
                 }
             }
-            if (source === CompletionSource.ObjectLiteralMethodSnippet) {
-                var enclosingDeclaration = tryGetObjectLikeCompletionContainer(contextToken);
-                var importAdder = getEntryForObjectLiteralMethodCompletion(symbol, name, enclosingDeclaration, program, host, compilerOptions, preferences, formatContext).importAdder;
-                if (importAdder.hasFixes()) {
-                    var changes = ts.textChanges.ChangeTracker.with({ host: host, formatContext: formatContext, preferences: preferences }, importAdder.writeFixes);
-                    return {
-                        sourceDisplay: undefined,
-                        codeActions: [{
-                                changes: changes,
-                                description: ts.diagnosticToString([ts.Diagnostics.Includes_imports_of_types_referenced_by_0, name]),
-                            }],
-                    };
-                }
-            }
             if (originIsTypeOnlyAlias(origin)) {
                 var codeAction_1 = ts.codefix.getPromoteTypeOnlyCompletionAction(sourceFile, origin.declaration.name, program, host, formatContext, preferences);
                 ts.Debug.assertIsDefined(codeAction_1, "Expected to have a code action for promoting type-only alias");
@@ -135524,7 +135570,7 @@ var ts;
                 // It is fairly suspicious to have one path in two buckets - you'd expect dependencies to have similar configurations.
                 // If this occurs unexpectedly, the fix is likely to synchronize the project settings.
                 // Skip .d.ts files to reduce noise (should also cover most of node_modules).
-                var otherBucketKey = !ts.fileExtensionIs(path, ".d.ts" /* Dts */) &&
+                var otherBucketKey = !ts.isDeclarationFileName(path) &&
                     ts.forEachEntry(buckets, function (bucket, bucketKey) { return bucketKey !== key && bucket.has(path) && bucketKey; });
                 if (otherBucketKey) {
                     ts.tracing.instant("session" /* Session */, "documentRegistryBucketOverlap", { path: path, key1: otherBucketKey, key2: key });
@@ -137464,6 +137510,30 @@ var ts;
                 }
             }
             Core.eachSymbolReferenceInFile = eachSymbolReferenceInFile;
+            function getTopMostDeclarationNamesInFile(declarationName, sourceFile) {
+                var candidates = ts.filter(getPossibleSymbolReferenceNodes(sourceFile, declarationName), function (name) { return !!ts.getDeclarationFromName(name); });
+                return candidates.reduce(function (topMost, decl) {
+                    var depth = getDepth(decl);
+                    if (!ts.some(topMost.declarationNames) || depth === topMost.depth) {
+                        topMost.declarationNames.push(decl);
+                        topMost.depth = depth;
+                    }
+                    else if (depth < topMost.depth) {
+                        topMost.declarationNames = [decl];
+                        topMost.depth = depth;
+                    }
+                    return topMost;
+                }, { depth: Infinity, declarationNames: [] }).declarationNames;
+                function getDepth(declaration) {
+                    var depth = 0;
+                    while (declaration) {
+                        declaration = ts.getContainerNode(declaration);
+                        depth++;
+                    }
+                    return depth;
+                }
+            }
+            Core.getTopMostDeclarationNamesInFile = getTopMostDeclarationNamesInFile;
             function someSignatureUsage(signature, sourceFiles, checker, cb) {
                 if (!signature.name || !ts.isIdentifier(signature.name))
                     return false;
@@ -139100,7 +139170,9 @@ var ts;
 (function (ts) {
     var GoToDefinition;
     (function (GoToDefinition) {
-        function getDefinitionAtPosition(program, sourceFile, position) {
+        function getDefinitionAtPosition(program, sourceFile, position, searchOtherFilesOnly) {
+            var _a;
+            var _b;
             var resolvedRef = getReferenceAtPosition(sourceFile, position, program);
             var fileReferenceDefinition = resolvedRef && [getDefinitionInfoForFileReference(resolvedRef.reference.fileName, resolvedRef.fileName, resolvedRef.unverified)] || ts.emptyArray;
             if (resolvedRef === null || resolvedRef === void 0 ? void 0 : resolvedRef.file) {
@@ -139123,33 +139195,63 @@ var ts;
             }
             if (ts.isStaticModifier(node) && ts.isClassStaticBlockDeclaration(node.parent)) {
                 var classDecl = node.parent.parent;
-                var symbol_1 = getSymbol(classDecl, typeChecker);
+                var _c = getSymbol(classDecl, typeChecker), symbol_1 = _c.symbol, failedAliasResolution_1 = _c.failedAliasResolution;
                 var staticBlocks = ts.filter(classDecl.members, ts.isClassStaticBlockDeclaration);
                 var containerName_1 = symbol_1 ? typeChecker.symbolToString(symbol_1, classDecl) : "";
                 var sourceFile_1 = node.getSourceFile();
                 return ts.map(staticBlocks, function (staticBlock) {
                     var pos = ts.moveRangePastModifiers(staticBlock).pos;
                     pos = ts.skipTrivia(sourceFile_1.text, pos);
-                    return createDefinitionInfoFromName(typeChecker, staticBlock, "constructor" /* constructorImplementationElement */, "static {}", containerName_1, { start: pos, length: "static".length });
+                    return createDefinitionInfoFromName(typeChecker, staticBlock, "constructor" /* constructorImplementationElement */, "static {}", containerName_1, /*unverified*/ false, failedAliasResolution_1, { start: pos, length: "static".length });
                 });
             }
-            var symbol = getSymbol(node, typeChecker);
+            var _d = getSymbol(node, typeChecker), symbol = _d.symbol, failedAliasResolution = _d.failedAliasResolution;
+            var fallbackNode = node;
+            if (searchOtherFilesOnly && failedAliasResolution) {
+                // We couldn't resolve the specific import, try on the module specifier.
+                var importDeclaration = ts.forEach(__spreadArray([node], (symbol === null || symbol === void 0 ? void 0 : symbol.declarations) || ts.emptyArray, true), function (n) { return ts.findAncestor(n, ts.isAnyImportOrBareOrAccessedRequire); });
+                var moduleSpecifier = importDeclaration && ts.tryGetModuleSpecifierFromDeclaration(importDeclaration);
+                if (moduleSpecifier) {
+                    (_a = getSymbol(moduleSpecifier, typeChecker), symbol = _a.symbol, failedAliasResolution = _a.failedAliasResolution);
+                    fallbackNode = moduleSpecifier;
+                }
+            }
+            if (!symbol && ts.isModuleSpecifierLike(fallbackNode)) {
+                // We couldn't resolve the module specifier as an external module, but it could
+                // be that module resolution succeeded but the target was not a module.
+                var ref = (_b = sourceFile.resolvedModules) === null || _b === void 0 ? void 0 : _b.get(fallbackNode.text, ts.getModeForUsageLocation(sourceFile, fallbackNode));
+                if (ref) {
+                    return [{
+                            name: fallbackNode.text,
+                            fileName: ref.resolvedFileName,
+                            containerName: undefined,
+                            containerKind: undefined,
+                            kind: "script" /* scriptElement */,
+                            textSpan: ts.createTextSpan(0, 0),
+                            failedAliasResolution: failedAliasResolution,
+                            isAmbient: ts.isDeclarationFileName(ref.resolvedFileName),
+                            unverified: fallbackNode !== node,
+                        }];
+                }
+            }
             // Could not find a symbol e.g. node is string or number keyword,
             // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
             if (!symbol) {
                 return ts.concatenate(fileReferenceDefinition, getDefinitionInfoForIndexSignatures(node, typeChecker));
             }
+            if (searchOtherFilesOnly && ts.every(symbol.declarations, function (d) { return d.getSourceFile().fileName === sourceFile.fileName; }))
+                return undefined;
             var calledDeclaration = tryGetSignatureDeclaration(typeChecker, node);
             // Don't go to the component constructor definition for a JSX element, just go to the component definition.
             if (calledDeclaration && !(ts.isJsxOpeningLikeElement(node.parent) && isConstructorLike(calledDeclaration))) {
-                var sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration);
+                var sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration, failedAliasResolution);
                 // For a function, if this is the original function definition, return just sigInfo.
                 // If this is the original constructor definition, parent is the class.
                 if (typeChecker.getRootSymbols(symbol).some(function (s) { return symbolMatchesSignature(s, calledDeclaration); })) {
                     return [sigInfo];
                 }
                 else {
-                    var defs = getDefinitionFromSymbol(typeChecker, symbol, node, calledDeclaration) || ts.emptyArray;
+                    var defs = getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution, calledDeclaration) || ts.emptyArray;
                     // For a 'super()' call, put the signature first, else put the variable first.
                     return node.kind === 106 /* SuperKeyword */ ? __spreadArray([sigInfo], defs, true) : __spreadArray(__spreadArray([], defs, true), [sigInfo], false);
                 }
@@ -139161,7 +139263,7 @@ var ts;
             // assignment. This case and others are handled by the following code.
             if (node.parent.kind === 297 /* ShorthandPropertyAssignment */) {
                 var shorthandSymbol_1 = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
-                var definitions = (shorthandSymbol_1 === null || shorthandSymbol_1 === void 0 ? void 0 : shorthandSymbol_1.declarations) ? shorthandSymbol_1.declarations.map(function (decl) { return createDefinitionInfo(decl, typeChecker, shorthandSymbol_1, node); }) : ts.emptyArray;
+                var definitions = (shorthandSymbol_1 === null || shorthandSymbol_1 === void 0 ? void 0 : shorthandSymbol_1.declarations) ? shorthandSymbol_1.declarations.map(function (decl) { return createDefinitionInfo(decl, typeChecker, shorthandSymbol_1, node, /*unverified*/ false, failedAliasResolution); }) : ts.emptyArray;
                 return ts.concatenate(definitions, getDefinitionFromObjectLiteralElement(typeChecker, node) || ts.emptyArray);
             }
             // If the node is the name of a BindingElement within an ObjectBindingPattern instead of just returning the
@@ -139184,7 +139286,7 @@ var ts;
                     return prop && getDefinitionFromSymbol(typeChecker, prop, node);
                 });
             }
-            return ts.concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node));
+            return ts.concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution));
         }
         GoToDefinition.getDefinitionAtPosition = getDefinitionAtPosition;
         /**
@@ -139282,24 +139384,24 @@ var ts;
                 return undefined;
             }
             if (ts.isImportMeta(node.parent) && node.parent.name === node) {
-                return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent);
+                return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent, /*failedAliasResolution*/ false);
             }
-            var symbol = getSymbol(node, typeChecker);
+            var _a = getSymbol(node, typeChecker), symbol = _a.symbol, failedAliasResolution = _a.failedAliasResolution;
             if (!symbol)
                 return undefined;
             var typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
             var returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
-            var fromReturnType = returnType && definitionFromType(returnType, typeChecker, node);
+            var fromReturnType = returnType && definitionFromType(returnType, typeChecker, node, failedAliasResolution);
             // If a function returns 'void' or some other type with no definition, just return the function definition.
-            var typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node);
+            var typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution);
             return typeDefinitions.length ? typeDefinitions
-                : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, ts.skipAlias(symbol, typeChecker), node)
+                : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, ts.skipAlias(symbol, typeChecker), node, failedAliasResolution)
                     : undefined;
         }
         GoToDefinition.getTypeDefinitionAtPosition = getTypeDefinitionAtPosition;
-        function definitionFromType(type, checker, node) {
+        function definitionFromType(type, checker, node, failedAliasResolution) {
             return ts.flatMap(type.isUnion() && !(type.flags & 32 /* Enum */) ? type.types : [type], function (t) {
-                return t.symbol && getDefinitionFromSymbol(checker, t.symbol, node);
+                return t.symbol && getDefinitionFromSymbol(checker, t.symbol, node, failedAliasResolution);
             });
         }
         function tryGetReturnTypeOfFunction(symbol, type, checker) {
@@ -139341,13 +139443,17 @@ var ts;
             // get the aliased symbol instead. This allows for goto def on an import e.g.
             //   import {A, B} from "mod";
             // to jump to the implementation directly.
+            var failedAliasResolution = false;
             if ((symbol === null || symbol === void 0 ? void 0 : symbol.declarations) && symbol.flags & 2097152 /* Alias */ && shouldSkipAlias(node, symbol.declarations[0])) {
                 var aliased = checker.getAliasedSymbol(symbol);
                 if (aliased.declarations) {
-                    return aliased;
+                    return { symbol: aliased };
+                }
+                else {
+                    failedAliasResolution = true;
                 }
             }
-            return symbol;
+            return { symbol: symbol, failedAliasResolution: failedAliasResolution };
         }
         // Go to the original declaration for cases:
         //
@@ -139361,26 +139467,45 @@ var ts;
             if (node.parent === declaration) {
                 return true;
             }
-            switch (declaration.kind) {
-                case 267 /* ImportClause */:
-                case 265 /* ImportEqualsDeclaration */:
-                    return true;
-                case 270 /* ImportSpecifier */:
-                    return declaration.parent.kind === 269 /* NamedImports */;
-                case 203 /* BindingElement */:
-                case 254 /* VariableDeclaration */:
-                    return ts.isInJSFile(declaration) && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(declaration);
-                default:
-                    return false;
+            if (declaration.kind === 268 /* NamespaceImport */) {
+                return false;
             }
+            return true;
+        }
+        /**
+         * ```ts
+         * function f() {}
+         * f.foo = 0;
+         * ```
+         *
+         * Here, `f` has two declarations: the function declaration, and the identifier in the next line.
+         * The latter is a declaration for `f` because it gives `f` the `SymbolFlags.Namespace` meaning so
+         * it can contain `foo`. However, that declaration is pretty uninteresting and not intuitively a
+         * "definition" for `f`. Ideally, the question we'd like to answer is "what SymbolFlags does this
+         * declaration contribute to the symbol for `f`?" If the answer is just `Namespace` and the
+         * declaration looks like an assignment, that declaration is in no sense a definition for `f`.
+         * But that information is totally lost during binding and/or symbol merging, so we need to do
+         * our best to reconstruct it or use other heuristics. This function (and the logic around its
+         * calling) covers our tests but feels like a hack, and it would be great if someone could come
+         * up with a more precise definition of what counts as a definition.
+         */
+        function isExpandoDeclaration(node) {
+            if (!ts.isAssignmentDeclaration(node))
+                return false;
+            var containingAssignment = ts.findAncestor(node, function (p) {
+                if (ts.isAssignmentExpression(p))
+                    return true;
+                if (!ts.isAssignmentDeclaration(p))
+                    return "quit";
+                return false;
+            });
+            return !!containingAssignment && ts.getAssignmentDeclarationKind(containingAssignment) === 5 /* Property */;
         }
-        function getDefinitionFromSymbol(typeChecker, symbol, node, declarationNode) {
-            // There are cases when you extend a function by adding properties to it afterwards,
-            // we want to strip those extra properties.
-            // For deduping purposes, we also want to exclude any declarationNodes if provided.
-            var filteredDeclarations = ts.filter(symbol.declarations, function (d) { return d !== declarationNode && (!ts.isAssignmentDeclaration(d) || d === symbol.valueDeclaration); })
-                || undefined;
-            return getConstructSignatureDefinition() || getCallSignatureDefinition() || ts.map(filteredDeclarations, function (declaration) { return createDefinitionInfo(declaration, typeChecker, symbol, node); });
+        function getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution, excludeDeclaration) {
+            var filteredDeclarations = ts.filter(symbol.declarations, function (d) { return d !== excludeDeclaration; });
+            var withoutExpandos = ts.filter(filteredDeclarations, function (d) { return !isExpandoDeclaration(d); });
+            var results = ts.some(withoutExpandos) ? withoutExpandos : filteredDeclarations;
+            return getConstructSignatureDefinition() || getCallSignatureDefinition() || ts.map(results, function (declaration) { return createDefinitionInfo(declaration, typeChecker, symbol, node, /*unverified*/ false, failedAliasResolution); });
             function getConstructSignatureDefinition() {
                 // Applicable only if we are in a new expression, or we are on a constructor declaration
                 // and in either case the symbol has a construct signature definition, i.e. class
@@ -139404,26 +139529,27 @@ var ts;
                 return declarations.length
                     ? declarationsWithBody.length !== 0
                         ? declarationsWithBody.map(function (x) { return createDefinitionInfo(x, typeChecker, symbol, node); })
-                        : [createDefinitionInfo(ts.last(declarations), typeChecker, symbol, node)]
+                        : [createDefinitionInfo(ts.last(declarations), typeChecker, symbol, node, /*unverified*/ false, failedAliasResolution)]
                     : undefined;
             }
         }
         /** Creates a DefinitionInfo from a Declaration, using the declaration's name if possible. */
-        function createDefinitionInfo(declaration, checker, symbol, node) {
+        function createDefinitionInfo(declaration, checker, symbol, node, unverified, failedAliasResolution) {
             var symbolName = checker.symbolToString(symbol); // Do not get scoped name, just the name of the symbol
             var symbolKind = ts.SymbolDisplay.getSymbolKind(checker, symbol, node);
             var containerName = symbol.parent ? checker.symbolToString(symbol.parent, node) : "";
-            return createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName);
+            return createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, unverified, failedAliasResolution);
         }
+        GoToDefinition.createDefinitionInfo = createDefinitionInfo;
         /** Creates a DefinitionInfo directly from the name of a declaration. */
-        function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, textSpan) {
+        function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, unverified, failedAliasResolution, textSpan) {
             var sourceFile = declaration.getSourceFile();
             if (!textSpan) {
                 var name = ts.getNameOfDeclaration(declaration) || declaration;
                 textSpan = ts.createTextSpanFromNode(name, sourceFile);
             }
             return __assign(__assign({ fileName: sourceFile.fileName, textSpan: textSpan, kind: symbolKind, name: symbolName, containerKind: undefined, // TODO: GH#18217
-                containerName: containerName }, ts.FindAllReferences.toContextSpan(textSpan, sourceFile, ts.FindAllReferences.getContextNode(declaration))), { isLocal: !isDefinitionVisible(checker, declaration) });
+                containerName: containerName }, ts.FindAllReferences.toContextSpan(textSpan, sourceFile, ts.FindAllReferences.getContextNode(declaration))), { isLocal: !isDefinitionVisible(checker, declaration), isAmbient: !!(declaration.flags & 16777216 /* Ambient */), unverified: unverified, failedAliasResolution: failedAliasResolution });
         }
         function isDefinitionVisible(checker, declaration) {
             if (checker.isDeclarationVisible(declaration))
@@ -139456,8 +139582,8 @@ var ts;
                     return false;
             }
         }
-        function createDefinitionFromSignatureDeclaration(typeChecker, decl) {
-            return createDefinitionInfo(decl, typeChecker, decl.symbol, decl);
+        function createDefinitionFromSignatureDeclaration(typeChecker, decl, failedAliasResolution) {
+            return createDefinitionInfo(decl, typeChecker, decl.symbol, decl, /*unverified*/ false, failedAliasResolution);
         }
         function findReferenceInPosition(refs, pos) {
             return ts.find(refs, function (ref) { return ts.textRangeContainsPositionInclusive(ref, pos); });
@@ -152572,9 +152698,10 @@ var ts;
             //     2. add "member3" to the second import statement's import list
             // and it is up to the user to decide which one fits best.
             return ts.firstDefined(existingImports, function (_a) {
+                var _b;
                 var declaration = _a.declaration;
                 var namespacePrefix = getNamespaceLikeImportText(declaration);
-                var moduleSpecifier = ts.tryGetModuleSpecifierFromDeclaration(declaration);
+                var moduleSpecifier = (_b = ts.tryGetModuleSpecifierFromDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.text;
                 if (namespacePrefix && moduleSpecifier) {
                     var moduleSymbol = getTargetModuleFromNamespaceLikeImport(declaration, checker);
                     if (moduleSymbol && moduleSymbol.exports.has(ts.escapeLeadingUnderscores(symbolName))) {
@@ -152750,8 +152877,9 @@ var ts;
             return existingDeclaration ? [existingDeclaration] : getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfos, host, preferences).fixes;
         }
         function newImportInfoFromExistingSpecifier(_a, isValidTypeOnlyUseSite, useRequire, checker, compilerOptions) {
+            var _b;
             var declaration = _a.declaration, importKind = _a.importKind, symbol = _a.symbol, targetFlags = _a.targetFlags;
-            var moduleSpecifier = ts.tryGetModuleSpecifierFromDeclaration(declaration);
+            var moduleSpecifier = (_b = ts.tryGetModuleSpecifierFromDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.text;
             if (moduleSpecifier) {
                 var addAsTypeOnly = useRequire
                     ? 4 /* NotAllowed */
@@ -157109,7 +157237,6 @@ var ts;
             var checker = program.getTypeChecker();
             var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
             var flags = 1 /* NoTruncation */
-                | 1073741824 /* NoUndefinedOptionalParameterType */
                 | 256 /* SuppressAnyReturnType */
                 | 524288 /* AllowEmptyTuple */
                 | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
@@ -164690,9 +164817,9 @@ var ts;
             }
         }
         /// Goto definition
-        function getDefinitionAtPosition(fileName, position) {
+        function getDefinitionAtPosition(fileName, position, searchOtherFilesOnly) {
             synchronizeHostData();
-            return ts.GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position);
+            return ts.GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position, searchOtherFilesOnly);
         }
         function getDefinitionAndBoundSpan(fileName, position) {
             synchronizeHostData();