@typescript-deploys/pr-build 4.7.0-pr-48581-7 → 4.7.0-pr-48788-2

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-insiders.20220406";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220420";
     /* @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";
@@ -8911,6 +8910,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."),
@@ -15159,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 */:
@@ -16519,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)
@@ -16737,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);
         }
@@ -17259,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;
@@ -17275,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) {
@@ -17300,6 +17310,7 @@ var ts;
             case 275 /* ExportSpecifier */:
             case 271 /* ExportAssignment */:
             case 265 /* ImportEqualsDeclaration */:
+            case 274 /* NamespaceExport */:
                 return node.parent;
             case 161 /* QualifiedName */:
                 do {
@@ -19126,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
@@ -19777,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) {
@@ -20724,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) {
@@ -21412,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;
@@ -33323,7 +33380,8 @@ var ts;
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
             var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
-            var typeArguments = tryParseTypeArguments();
+            // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression.
+            var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined;
             return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
@@ -34642,23 +34700,7 @@ var ts;
                     return undefined;
                 }
             }
-            // Given:
-            //     x ? y => ({ y }) : z => ({ z })
-            // We try to parse the body of the first arrow function by looking at:
-            //     ({ y }) : z => ({ z })
-            // This is a valid arrow function with "z" as the return type.
-            //
-            // But, if we're in the true side of a conditional expression, this colon
-            // terminates the expression, so we cannot allow a return type if we aren't
-            // certain whether or not the preceding text was parsed as a parameter list.
-            //
-            // For example,
-            //     a() ? (b: number, c?: string): void => d() : e
-            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
-            // be an arrow expression, so we allow a return type.
-            if (disallowReturnTypeInArrowFunction && token() === 58 /* ColonToken */) {
-                return undefined;
-            }
+            var hasReturnColon = token() === 58 /* ColonToken */;
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -34689,6 +34731,30 @@ var ts;
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
                 ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), disallowReturnTypeInArrowFunction)
                 : parseIdentifier();
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            //
+            // For example,
+            //     a() ? (b: number, c?: string): void => d() : e
+            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
+            // be an arrow expression, so we allow a return type.
+            if (disallowReturnTypeInArrowFunction && hasReturnColon) {
+                // However, if the arrow function we were able to parse is followed by another colon
+                // as in:
+                //     a ? (x): string => x : null
+                // Then allow the arrow function, and treat the second colon as terminating
+                // the conditional expression.
+                if (token() !== 58 /* ColonToken */) {
+                    return undefined;
+                }
+            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
@@ -35565,34 +35631,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()) {
@@ -38810,7 +38852,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) {
@@ -42318,7 +42360,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) {
@@ -43263,7 +43306,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) {
@@ -43272,6 +43329,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,
@@ -43279,7 +43340,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);
@@ -43455,9 +43516,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);
     }
@@ -43487,20 +43548,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) {
@@ -43727,6 +43790,7 @@ var ts;
             switch (extensions) {
                 case Extensions.JavaScript:
                 case Extensions.Json:
+                case Extensions.TsOnly:
                     packageFile = readPackageJsonMainField(jsonContent, candidate, state);
                     break;
                 case Extensions.TypeScript:
@@ -43799,14 +43863,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 */
@@ -45966,6 +46032,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 */;
@@ -45984,7 +46051,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 */;
@@ -50562,27 +50628,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;
@@ -52379,13 +52445,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) {
@@ -52499,7 +52589,7 @@ var ts;
                     // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead
                     // of types allows us to catch circular references to instantiations of the same anonymous type
                     if (!context.visitedTypes) {
-                        context.visitedTypes = new ts.Map();
+                        context.visitedTypes = new ts.Set();
                     }
                     if (id && !context.symbolDepth) {
                         context.symbolDepth = new ts.Map();
@@ -52517,22 +52607,15 @@ var ts;
                         context.approximateLength += cachedResult.addedLength;
                         return deepCloneOrReuseNode(cachedResult);
                     }
-                    var totalDepth = 0;
-                    var symbolDepth = id ? context.symbolDepth.get(id) : undefined;
-                    if (symbolDepth) {
-                        totalDepth += symbolDepth;
-                    }
-                    var visitedTypeDepth = context.visitedTypes.get(typeId);
-                    if (visitedTypeDepth) {
-                        totalDepth += visitedTypeDepth;
-                    }
-                    if (totalDepth > 10) {
-                        return createElidedInformationPlaceholder(context);
-                    }
+                    var depth;
                     if (id) {
-                        context.symbolDepth.set(id, (symbolDepth || 0) + 1);
+                        depth = context.symbolDepth.get(id) || 0;
+                        if (depth > 10) {
+                            return createElidedInformationPlaceholder(context);
+                        }
+                        context.symbolDepth.set(id, depth + 1);
                     }
-                    context.visitedTypes.set(typeId, (visitedTypeDepth || 0) + 1);
+                    context.visitedTypes.add(typeId);
                     var startLength = context.approximateLength;
                     var result = transform(type);
                     var addedLength = context.approximateLength - startLength;
@@ -52543,19 +52626,9 @@ var ts;
                         result.addedLength = addedLength;
                         (_b = links === null || links === void 0 ? void 0 : links.serializedTypes) === null || _b === void 0 ? void 0 : _b.set(key, result);
                     }
-                    if (visitedTypeDepth !== undefined) {
-                        context.visitedTypes.set(typeId, visitedTypeDepth);
-                    }
-                    else {
-                        context.visitedTypes.delete(typeId);
-                    }
+                    context.visitedTypes.delete(typeId);
                     if (id) {
-                        if (symbolDepth !== undefined) {
-                            context.symbolDepth.set(id, symbolDepth);
-                        }
-                        else {
-                            context.symbolDepth.delete(id);
-                        }
+                        context.symbolDepth.set(id, depth);
                     }
                     return result;
                     function deepCloneOrReuseNode(node) {
@@ -53101,9 +53174,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 */;
@@ -53662,7 +53732,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;
@@ -53679,6 +53749,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);
@@ -55950,7 +56030,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));
@@ -58699,8 +58779,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();
                     }
@@ -62056,11 +62137,14 @@ var ts;
                     return type[cache] = elementType;
                 }
             }
-            // If the object type is a mapped type { [P in K]: E }, where K is generic, instantiate E using a mapper
-            // that substitutes the index type for P. For example, for an index access { [P in K]: Box<T[P]> }[X], we
-            // construct the type Box<T[X]>.
-            if (isGenericMappedType(objectType) && !objectType.declaration.nameType) {
-                return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+            // If the object type is a mapped type { [P in K]: E }, where K is generic, or { [P in K as N]: E }, where
+            // K is generic and N is assignable to P, instantiate E using a mapper that substitutes the index type for P.
+            // For example, for an index access { [P in K]: Box<T[P]> }[X], we construct the type Box<T[X]>.
+            if (isGenericMappedType(objectType)) {
+                var nameType = getNameTypeFromMappedType(objectType);
+                if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
+                    return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); });
+                }
             }
             return type[cache] = type;
         }
@@ -66898,12 +66982,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) {
@@ -74380,10 +74464,15 @@ var ts;
                 prop = getPropertyOfType(apparentType, right.escapedText);
             }
             // In `Foo.Bar.Baz`, 'Foo' is not referenced if 'Bar' is a const enum or a module containing only const enums.
+            // `Foo` is also not referenced in `enum FooCopy { Bar = Foo.Bar }`, because the enum member value gets inlined
+            // here even if `Foo` is not a const enum.
+            //
             // The exceptions are:
             //   1. if 'isolatedModules' is enabled, because the const enum value will not be inlined, and
             //   2. if 'preserveConstEnums' is enabled and the expression is itself an export, e.g. `export = Foo.Bar.Baz`.
-            if (ts.isIdentifier(left) && parentSymbol && (compilerOptions.isolatedModules || !(prop && isConstEnumOrConstEnumOnlyModule(prop)) || ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
+            if (ts.isIdentifier(left) && parentSymbol && (compilerOptions.isolatedModules ||
+                !(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && node.parent.kind === 299 /* EnumMember */)) ||
+                ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
                 markAliasReferenced(parentSymbol, node);
             }
             var propType;
@@ -76905,7 +76994,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);
         }
@@ -79717,19 +79806,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
@@ -80219,7 +80317,7 @@ var ts;
                                         superCallStatement = statement;
                                         break;
                                     }
-                                    if (!ts.isPrologueDirective(statement) && nodeImmediatelyReferencesSuperOrThis(statement)) {
+                                    if (nodeImmediatelyReferencesSuperOrThis(statement)) {
                                         break;
                                     }
                                 }
@@ -85572,6 +85670,9 @@ var ts;
                 case 226 /* ClassExpression */:
                     checkClassExpressionDeferred(node);
                     break;
+                case 163 /* TypeParameter */:
+                    checkTypeParameterDeferred(node);
+                    break;
                 case 279 /* JsxSelfClosingElement */:
                     checkJsxSelfClosingElementDeferred(node);
                     break;
@@ -86106,15 +86207,20 @@ var ts;
                         return propertyDeclaration;
                     }
                 }
-                else if (ts.isMetaProperty(parent)) {
-                    var parentType = getTypeOfNode(parent);
-                    var propertyDeclaration = getPropertyOfType(parentType, node.escapedText);
-                    if (propertyDeclaration) {
-                        return propertyDeclaration;
-                    }
-                    if (parent.keywordToken === 103 /* NewKeyword */) {
+                else if (ts.isMetaProperty(parent) && parent.name === node) {
+                    if (parent.keywordToken === 103 /* NewKeyword */ && ts.idText(node) === "target") {
+                        // `target` in `new.target`
                         return checkNewTargetMetaProperty(parent).symbol;
                     }
+                    // The `meta` in `import.meta` could be given `getTypeOfNode(parent).symbol` (the `ImportMeta` interface symbol), but
+                    // we have a fake expression type made for other reasons already, whose transient `meta`
+                    // member should more exactly be the kind of (declarationless) symbol we want.
+                    // (See #44364 and #45031 for relevant implementation PRs)
+                    if (parent.keywordToken === 100 /* ImportKeyword */ && ts.idText(node) === "meta") {
+                        return getGlobalImportMetaExpressionType().members.get("meta");
+                    }
+                    // no other meta properties are valid syntax, thus no others should have symbols
+                    return undefined;
                 }
             }
             switch (node.kind) {
@@ -86386,11 +86492,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) {
@@ -86620,7 +86726,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))) {
@@ -86668,11 +86774,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) {
@@ -87589,8 +87690,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) {
@@ -92824,11 +92924,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:
             //
@@ -92847,12 +92947,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);
@@ -94798,7 +94898,7 @@ var ts;
             }
             resumeLexicalEnvironment();
             var needsSyntheticConstructor = !constructor && isDerivedClass;
-            var indexOfFirstStatementAfterSuper = 0;
+            var indexOfFirstStatementAfterSuperAndPrologue = 0;
             var prologueStatementCount = 0;
             var superStatementIndex = -1;
             var statements = [];
@@ -94807,8 +94907,11 @@ var ts;
                 superStatementIndex = ts.findSuperStatementIndex(constructor.body.statements, prologueStatementCount);
                 // If there was a super call, visit existing statements up to and including it
                 if (superStatementIndex >= 0) {
-                    indexOfFirstStatementAfterSuper = superStatementIndex + 1;
-                    statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, prologueStatementCount, indexOfFirstStatementAfterSuper - prologueStatementCount), true), statements.slice(prologueStatementCount), true);
+                    indexOfFirstStatementAfterSuperAndPrologue = superStatementIndex + 1;
+                    statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, prologueStatementCount, indexOfFirstStatementAfterSuperAndPrologue - prologueStatementCount), true), statements.slice(prologueStatementCount), true);
+                }
+                else if (prologueStatementCount >= 0) {
+                    indexOfFirstStatementAfterSuperAndPrologue = prologueStatementCount;
                 }
             }
             if (needsSyntheticConstructor) {
@@ -94844,22 +94947,20 @@ var ts;
                         }
                     }
                     if (parameterPropertyDeclarationCount > 0) {
-                        var parameterProperties = ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatementAfterSuper, parameterPropertyDeclarationCount);
+                        var parameterProperties = ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatementAfterSuperAndPrologue, parameterPropertyDeclarationCount);
                         // If there was a super() call found, add parameter properties immediately after it
                         if (superStatementIndex >= 0) {
                             ts.addRange(statements, parameterProperties);
                         }
-                        // If a synthetic super() call was added, add them just after it
-                        else if (needsSyntheticConstructor) {
-                            statements = __spreadArray(__spreadArray([
-                                statements[0]
-                            ], parameterProperties, true), statements.slice(1), true);
-                        }
-                        // Since there wasn't a super() call, add them to the top of the constructor
                         else {
-                            statements = __spreadArray(__spreadArray([], parameterProperties, true), statements, true);
+                            // Add add parameter properties to the top of the constructor after the prologue
+                            var superAndPrologueStatementCount = prologueStatementCount;
+                            // If a synthetic super() call was added, need to account for that
+                            if (needsSyntheticConstructor)
+                                superAndPrologueStatementCount++;
+                            statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, superAndPrologueStatementCount), true), parameterProperties, true), statements.slice(superAndPrologueStatementCount), true);
                         }
-                        indexOfFirstStatementAfterSuper += parameterPropertyDeclarationCount;
+                        indexOfFirstStatementAfterSuperAndPrologue += parameterPropertyDeclarationCount;
                     }
                 }
             }
@@ -94869,7 +94970,7 @@ var ts;
             addPropertyOrClassStaticBlockStatements(statements, properties, receiver);
             // Add existing statements after the initial prologues and super call
             if (constructor) {
-                ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitBodyStatement, ts.isStatement, indexOfFirstStatementAfterSuper + prologueStatementCount));
+                ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitBodyStatement, ts.isStatement, indexOfFirstStatementAfterSuperAndPrologue));
             }
             statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
             return ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), 
@@ -98910,7 +99011,7 @@ var ts;
                 // ```
                 insertCaptureThisForNodeIfNeeded(prologue, constructor);
             }
-            var body = factory.createBlock(ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], existingPrologue, true), prologue, true), (superStatementIndex <= existingPrologue.length ? ts.emptyArray : ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, existingPrologue.length, superStatementIndex)), true), statements, true)), 
+            var body = factory.createBlock(ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], existingPrologue, true), prologue, true), (superStatementIndex <= existingPrologue.length ? ts.emptyArray : ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, existingPrologue.length, superStatementIndex - existingPrologue.length)), true), statements, true)), 
             /*location*/ constructor.body.statements), 
             /*multiLine*/ true);
             ts.setTextRange(body, constructor.body);
@@ -108616,6 +108717,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) {
@@ -109747,7 +109852,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);
@@ -109792,7 +109897,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*/
@@ -109834,7 +109939,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)
@@ -115184,7 +115289,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;
@@ -116357,7 +116462,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 });
                                     }
                                 }
@@ -116548,7 +116653,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
@@ -117939,7 +118044,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
@@ -117988,7 +118093,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);
                             }
@@ -118789,7 +118894,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 */)) ||
@@ -119122,13 +119227,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); },
@@ -119144,30 +119245,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;
             }
@@ -119182,11 +119282,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;
@@ -119415,7 +119514,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);
@@ -119473,20 +119572,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); });
             }
@@ -119820,7 +119905,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) {
@@ -119831,7 +119917,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++;
@@ -119843,6 +119929,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
@@ -119872,6 +119959,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
      */
@@ -119891,9 +119983,7 @@ var ts;
                     }
                 }
             }
-            state.affectedFilesPendingEmit = undefined;
-            state.affectedFilesPendingEmitKind = undefined;
-            state.affectedFilesPendingEmitIndex = undefined;
+            clearAffectedFilesPendingEmit(state);
         }
         return undefined;
     }
@@ -119901,7 +119991,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
@@ -119926,14 +120016,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);
@@ -119944,8 +120034,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 */);
@@ -120142,13 +120231,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;
@@ -120393,7 +120487,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) {
@@ -120438,54 +120532,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);
         }
@@ -120495,7 +120583,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;
@@ -123615,9 +123703,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;
@@ -124180,7 +124265,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);
@@ -124521,7 +124606,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);
                 }
@@ -124675,7 +124760,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);
@@ -131987,17 +132072,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";
@@ -132220,8 +132301,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;
             }
@@ -132250,16 +132330,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));
@@ -132292,11 +132371,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();
@@ -132306,11 +132380,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;
@@ -132673,20 +132755,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");
@@ -135507,7 +135575,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 });
@@ -137447,6 +137515,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;
@@ -139083,7 +139175,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) {
@@ -139106,33 +139200,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);
                 }
@@ -139144,7 +139268,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
@@ -139167,7 +139291,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;
         /**
@@ -139265,24 +139389,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) {
@@ -139324,13 +139448,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:
         //
@@ -139344,26 +139472,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
@@ -139387,26 +139534,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))
@@ -139439,8 +139587,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); });
@@ -152555,9 +152703,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))) {
@@ -152733,8 +152882,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 */
@@ -157092,7 +157242,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 */);
@@ -159471,6 +159620,7 @@ var ts;
                 Messages.cannotAccessVariablesFromNestedScopes = createMessage("Cannot access variables from nested scopes");
                 Messages.cannotExtractToJSClass = createMessage("Cannot extract constant to a class scope in JS");
                 Messages.cannotExtractToExpressionArrowFunction = createMessage("Cannot extract constant to an arrow function without a block");
+                Messages.cannotExtractFunctionsContainingThisToMethod = createMessage("Cannot extract functions containing this to method");
             })(Messages = extractSymbol.Messages || (extractSymbol.Messages = {}));
             var RangeFacts;
             (function (RangeFacts) {
@@ -159479,10 +159629,11 @@ var ts;
                 RangeFacts[RangeFacts["IsGenerator"] = 2] = "IsGenerator";
                 RangeFacts[RangeFacts["IsAsyncFunction"] = 4] = "IsAsyncFunction";
                 RangeFacts[RangeFacts["UsesThis"] = 8] = "UsesThis";
+                RangeFacts[RangeFacts["UsesThisInFunction"] = 16] = "UsesThisInFunction";
                 /**
                  * The range is in a function which needs the 'static' modifier in a class
                  */
-                RangeFacts[RangeFacts["InStaticRegion"] = 16] = "InStaticRegion";
+                RangeFacts[RangeFacts["InStaticRegion"] = 32] = "InStaticRegion";
             })(RangeFacts || (RangeFacts = {}));
             /**
              * getRangeToExtract takes a span inside a text file and returns either an expression or an array
@@ -159513,6 +159664,7 @@ var ts;
                 // We'll modify these flags as we walk the tree to collect data
                 // about what things need to be done as part of the extraction.
                 var rangeFacts = RangeFacts.None;
+                var thisNode;
                 if (!start || !end) {
                     // cannot find either start or end node
                     return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
@@ -159551,7 +159703,7 @@ var ts;
                         // the expression.
                         return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
                     }
-                    return { targetRange: { range: statements, facts: rangeFacts, declarations: declarations } };
+                    return { targetRange: { range: statements, facts: rangeFacts, declarations: declarations, thisNode: thisNode } };
                 }
                 if (ts.isReturnStatement(start) && !start.expression) {
                     // Makes no sense to extract an expression-less return statement.
@@ -159563,7 +159715,7 @@ var ts;
                 if (errors) {
                     return { errors: errors };
                 }
-                return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, declarations: declarations } }; // TODO: GH#18217
+                return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, declarations: declarations, thisNode: thisNode } }; // TODO: GH#18217
                 /**
                  * Attempt to refine the extraction node (generally, by shrinking it) to produce better results.
                  * @param node The unrefined extraction node.
@@ -159655,6 +159807,14 @@ var ts;
                     var permittedJumps = 4 /* Return */;
                     var seenLabels;
                     visit(nodeToCheck);
+                    if (rangeFacts & RangeFacts.UsesThis) {
+                        var container = ts.getThisContainer(nodeToCheck, /** includeArrowFunctions */ false);
+                        if (container.kind === 256 /* FunctionDeclaration */ ||
+                            (container.kind === 169 /* MethodDeclaration */ && container.parent.kind === 205 /* ObjectLiteralExpression */) ||
+                            container.kind === 213 /* FunctionExpression */) {
+                            rangeFacts |= RangeFacts.UsesThisInFunction;
+                        }
+                    }
                     return errors;
                     function visit(node) {
                         if (errors) {
@@ -159693,6 +159853,7 @@ var ts;
                                 }
                                 else {
                                     rangeFacts |= RangeFacts.UsesThis;
+                                    thisNode = node;
                                 }
                                 break;
                             case 214 /* ArrowFunction */:
@@ -159700,6 +159861,7 @@ var ts;
                                 ts.forEachChild(node, function check(n) {
                                     if (ts.isThis(n)) {
                                         rangeFacts |= RangeFacts.UsesThis;
+                                        thisNode = node;
                                     }
                                     else if (ts.isClassLike(n) || (ts.isFunctionLike(n) && !ts.isArrowFunction(n))) {
                                         return false;
@@ -159756,6 +159918,7 @@ var ts;
                             case 192 /* ThisType */:
                             case 108 /* ThisKeyword */:
                                 rangeFacts |= RangeFacts.UsesThis;
+                                thisNode = node;
                                 break;
                             case 250 /* LabeledStatement */: {
                                 var label = node.label;
@@ -159843,7 +160006,7 @@ var ts;
              */
             function collectEnclosingScopes(range) {
                 var current = isReadonlyArray(range.range) ? ts.first(range.range) : range.range;
-                if (range.facts & RangeFacts.UsesThis) {
+                if (range.facts & RangeFacts.UsesThis && !(range.facts & RangeFacts.UsesThisInFunction)) {
                     // if range uses this as keyword or as type inside the class then it can only be extracted to a method of the containing class
                     var containingClass = ts.getContainingClass(current);
                     if (containingClass) {
@@ -160049,6 +160212,7 @@ var ts;
                 var _b = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & RangeFacts.HasReturn)), body = _b.body, returnValueProperty = _b.returnValueProperty;
                 ts.suppressLeadingAndTrailingTrivia(body);
                 var newFunction;
+                var callThis = !!(range.facts & RangeFacts.UsesThisInFunction);
                 if (ts.isClassLike(scope)) {
                     // always create private method in TypeScript files
                     var modifiers = isJS ? [] : [ts.factory.createModifier(121 /* PrivateKeyword */)];
@@ -160063,6 +160227,15 @@ var ts;
                     /*questionToken*/ undefined, typeParameters, parameters, returnType, body);
                 }
                 else {
+                    if (callThis) {
+                        parameters.unshift(ts.factory.createParameterDeclaration(
+                        /*decorators*/ undefined, 
+                        /*modifiers*/ undefined, 
+                        /*dotDotDotToken*/ undefined, 
+                        /*name*/ "this", 
+                        /*questionToken*/ undefined, checker.typeToTypeNode(checker.getTypeAtLocation(range.thisNode), scope, 1 /* NoTruncation */), 
+                        /*initializer*/ undefined));
+                    }
                     newFunction = ts.factory.createFunctionDeclaration(
                     /*decorators*/ undefined, range.facts & RangeFacts.IsAsyncFunction ? [ts.factory.createToken(131 /* AsyncKeyword */)] : undefined, range.facts & RangeFacts.IsGenerator ? ts.factory.createToken(41 /* AsteriskToken */) : undefined, functionName, typeParameters, parameters, returnType, body);
                 }
@@ -160079,7 +160252,10 @@ var ts;
                 var newNodes = [];
                 // replace range with function call
                 var called = getCalledExpression(scope, range, functionNameText);
-                var call = ts.factory.createCallExpression(called, callTypeArguments, // Note that no attempt is made to take advantage of type argument inference
+                if (callThis) {
+                    callArguments.unshift(ts.factory.createIdentifier("this"));
+                }
+                var call = ts.factory.createCallExpression(callThis ? ts.factory.createPropertyAccessExpression(called, "call") : called, callTypeArguments, // Note that no attempt is made to take advantage of type argument inference
                 callArguments);
                 if (range.facts & RangeFacts.IsGenerator) {
                     call = ts.factory.createYieldExpression(ts.factory.createToken(41 /* AsteriskToken */), call);
@@ -160690,6 +160866,9 @@ var ts;
                         var errorNode = isReadonlyArray(targetRange.range) ? targetRange.range[0] : targetRange.range;
                         constantErrorsPerScope[i].push(ts.createDiagnosticForNode(errorNode, Messages.cannotAccessVariablesFromNestedScopes));
                     }
+                    if (targetRange.facts & RangeFacts.UsesThisInFunction && ts.isClassLike(scopes[i])) {
+                        functionErrorsPerScope[i].push(ts.createDiagnosticForNode(targetRange.thisNode, Messages.cannotExtractFunctionsContainingThisToMethod));
+                    }
                     var hasWrite = false;
                     var readonlyClassPropertyWrite;
                     usagesPerScope[i].usages.forEach(function (value) {
@@ -164643,9 +164822,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();