typescript 5.5.0-dev.20240508 → 5.5.0-dev.20240510

package/lib/typescript.js

@@ -95,7 +95,7 @@ __export(typescript_exports, {
   IndexKind: () => IndexKind,
   InferenceFlags: () => InferenceFlags,
   InferencePriority: () => InferencePriority,
-  InlayHintKind: () => InlayHintKind,
+  InlayHintKind: () => InlayHintKind2,
   InlayHints: () => ts_InlayHints_exports,
   InternalEmitFlags: () => InternalEmitFlags,
   InternalSymbolName: () => InternalSymbolName,
@@ -632,6 +632,7 @@ __export(typescript_exports, {
   forEachKey: () => forEachKey,
   forEachLeadingCommentRange: () => forEachLeadingCommentRange,
   forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
+  forEachNameOfDefaultExport: () => forEachNameOfDefaultExport,
   forEachPropertyAssignment: () => forEachPropertyAssignment,
   forEachResolvedProjectReference: () => forEachResolvedProjectReference,
   forEachReturnStatement: () => forEachReturnStatement,
@@ -728,11 +729,11 @@ __export(typescript_exports, {
   getDeclaredExpandoInitializer: () => getDeclaredExpandoInitializer,
   getDecorators: () => getDecorators,
   getDefaultCompilerOptions: () => getDefaultCompilerOptions2,
-  getDefaultExportInfoWorker: () => getDefaultExportInfoWorker,
   getDefaultFormatCodeSettings: () => getDefaultFormatCodeSettings,
   getDefaultLibFileName: () => getDefaultLibFileName,
   getDefaultLibFilePath: () => getDefaultLibFilePath,
   getDefaultLikeExportInfo: () => getDefaultLikeExportInfo,
+  getDefaultLikeExportNameFromDeclaration: () => getDefaultLikeExportNameFromDeclaration,
   getDefaultResolutionModeForFileWorker: () => getDefaultResolutionModeForFileWorker,
   getDiagnosticText: () => getDiagnosticText,
   getDiagnosticsWithinSpan: () => getDiagnosticsWithinSpan,
@@ -1067,6 +1068,7 @@ __export(typescript_exports, {
   getSwitchedType: () => getSwitchedType,
   getSymbolId: () => getSymbolId,
   getSymbolNameForPrivateIdentifier: () => getSymbolNameForPrivateIdentifier,
+  getSymbolParentOrFail: () => getSymbolParentOrFail,
   getSymbolTarget: () => getSymbolTarget,
   getSyntacticClassifications: () => getSyntacticClassifications,
   getSyntacticModifierFlags: () => getSyntacticModifierFlags,
@@ -1931,7 +1933,9 @@ __export(typescript_exports, {
   moduleResolutionOptionDeclarations: () => moduleResolutionOptionDeclarations,
   moduleResolutionSupportsPackageJsonExportsAndImports: () => moduleResolutionSupportsPackageJsonExportsAndImports,
   moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
+  moduleSpecifierToValidIdentifier: () => moduleSpecifierToValidIdentifier,
   moduleSpecifiers: () => ts_moduleSpecifiers_exports,
+  moduleSymbolToValidIdentifier: () => moduleSymbolToValidIdentifier,
   moveEmitHelpers: () => moveEmitHelpers,
   moveRangeEnd: () => moveRangeEnd,
   moveRangePastDecorators: () => moveRangePastDecorators,
@@ -2011,6 +2015,7 @@ __export(typescript_exports, {
   parsePackageName: () => parsePackageName,
   parsePseudoBigInt: () => parsePseudoBigInt,
   parseValidBigInt: () => parseValidBigInt,
+  pasteEdits: () => ts_PasteEdits_exports,
   patchWriteFileEnsuringDirectory: () => patchWriteFileEnsuringDirectory,
   pathContainsNodeModules: () => pathContainsNodeModules,
   pathIsAbsolute: () => pathIsAbsolute,
@@ -2364,7 +2369,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240508`;
+var version = `${versionMajorMinor}.0-dev.20240510`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6342,7 +6347,7 @@ var NodeBuilderFlags = /* @__PURE__ */ ((NodeBuilderFlags2) => {
   NodeBuilderFlags2[NodeBuilderFlags2["NoSyntacticPrinter"] = -2147483648] = "NoSyntacticPrinter";
   NodeBuilderFlags2[NodeBuilderFlags2["AllowNodeModulesRelativePaths"] = 67108864] = "AllowNodeModulesRelativePaths";
   NodeBuilderFlags2[NodeBuilderFlags2["DoNotIncludeSymbolChain"] = 134217728] = "DoNotIncludeSymbolChain";
-  NodeBuilderFlags2[NodeBuilderFlags2["AllowUnresolvedComputedNames"] = 1] = "AllowUnresolvedComputedNames";
+  NodeBuilderFlags2[NodeBuilderFlags2["AllowUnresolvedNames"] = 1] = "AllowUnresolvedNames";
   NodeBuilderFlags2[NodeBuilderFlags2["IgnoreErrors"] = 70221824] = "IgnoreErrors";
   NodeBuilderFlags2[NodeBuilderFlags2["InObjectTypeLiteral"] = 4194304] = "InObjectTypeLiteral";
   NodeBuilderFlags2[NodeBuilderFlags2["InTypeAlias"] = 8388608] = "InTypeAlias";
@@ -6911,22 +6916,22 @@ var ScriptKind = /* @__PURE__ */ ((ScriptKind7) => {
   ScriptKind7[ScriptKind7["Deferred"] = 7] = "Deferred";
   return ScriptKind7;
 })(ScriptKind || {});
-var ScriptTarget = /* @__PURE__ */ ((ScriptTarget12) => {
-  ScriptTarget12[ScriptTarget12["ES3"] = 0] = "ES3";
-  ScriptTarget12[ScriptTarget12["ES5"] = 1] = "ES5";
-  ScriptTarget12[ScriptTarget12["ES2015"] = 2] = "ES2015";
-  ScriptTarget12[ScriptTarget12["ES2016"] = 3] = "ES2016";
-  ScriptTarget12[ScriptTarget12["ES2017"] = 4] = "ES2017";
-  ScriptTarget12[ScriptTarget12["ES2018"] = 5] = "ES2018";
-  ScriptTarget12[ScriptTarget12["ES2019"] = 6] = "ES2019";
-  ScriptTarget12[ScriptTarget12["ES2020"] = 7] = "ES2020";
-  ScriptTarget12[ScriptTarget12["ES2021"] = 8] = "ES2021";
-  ScriptTarget12[ScriptTarget12["ES2022"] = 9] = "ES2022";
-  ScriptTarget12[ScriptTarget12["ES2023"] = 10] = "ES2023";
-  ScriptTarget12[ScriptTarget12["ESNext"] = 99] = "ESNext";
-  ScriptTarget12[ScriptTarget12["JSON"] = 100] = "JSON";
-  ScriptTarget12[ScriptTarget12["Latest"] = 99 /* ESNext */] = "Latest";
-  return ScriptTarget12;
+var ScriptTarget = /* @__PURE__ */ ((ScriptTarget11) => {
+  ScriptTarget11[ScriptTarget11["ES3"] = 0] = "ES3";
+  ScriptTarget11[ScriptTarget11["ES5"] = 1] = "ES5";
+  ScriptTarget11[ScriptTarget11["ES2015"] = 2] = "ES2015";
+  ScriptTarget11[ScriptTarget11["ES2016"] = 3] = "ES2016";
+  ScriptTarget11[ScriptTarget11["ES2017"] = 4] = "ES2017";
+  ScriptTarget11[ScriptTarget11["ES2018"] = 5] = "ES2018";
+  ScriptTarget11[ScriptTarget11["ES2019"] = 6] = "ES2019";
+  ScriptTarget11[ScriptTarget11["ES2020"] = 7] = "ES2020";
+  ScriptTarget11[ScriptTarget11["ES2021"] = 8] = "ES2021";
+  ScriptTarget11[ScriptTarget11["ES2022"] = 9] = "ES2022";
+  ScriptTarget11[ScriptTarget11["ES2023"] = 10] = "ES2023";
+  ScriptTarget11[ScriptTarget11["ESNext"] = 99] = "ESNext";
+  ScriptTarget11[ScriptTarget11["JSON"] = 100] = "JSON";
+  ScriptTarget11[ScriptTarget11["Latest"] = 99 /* ESNext */] = "Latest";
+  return ScriptTarget11;
 })(ScriptTarget || {});
 var LanguageVariant = /* @__PURE__ */ ((LanguageVariant4) => {
   LanguageVariant4[LanguageVariant4["Standard"] = 0] = "Standard";
@@ -50266,7 +50271,8 @@ function createTypeChecker(host) {
     getTypeOnlyAliasDeclaration,
     getMemberOverrideModifierStatus,
     isTypeParameterPossiblyReferenced,
-    typeHasCallOrConstructSignatures
+    typeHasCallOrConstructSignatures,
+    getSymbolFlags
   };
   function getCandidateSignaturesForStringLiteralCompletions(call, editingArgument) {
     const candidatesSet = /* @__PURE__ */ new Set();
@@ -52456,37 +52462,6 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function markExportAsReferenced(node) {
-    if (!canCollectSymbolAliasAccessabilityData) {
-      return;
-    }
-    const symbol = getSymbolOfDeclaration(node);
-    const target = resolveAlias(symbol);
-    if (target) {
-      const markAlias = target === unknownSymbol || getSymbolFlags(
-        symbol,
-        /*excludeTypeOnlyMeanings*/
-        true
-      ) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target);
-      if (markAlias) {
-        markAliasSymbolAsReferenced(symbol);
-      }
-    }
-  }
-  function markAliasSymbolAsReferenced(symbol) {
-    Debug.assert(canCollectSymbolAliasAccessabilityData);
-    const links = getSymbolLinks(symbol);
-    if (!links.referenced) {
-      links.referenced = true;
-      const node = getDeclarationOfAliasSymbol(symbol);
-      if (!node) return Debug.fail();
-      if (isInternalModuleImportEqualsDeclaration(node)) {
-        if (getSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
-          checkExpressionCached(node.moduleReference);
-        }
-      }
-    }
-  }
   function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
     if (entityName.kind === 80 /* Identifier */ && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
       entityName = entityName.parent;
@@ -55918,7 +55893,7 @@ function createTypeChecker(host) {
       var _a;
       const addUndefined = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
       const enclosingDeclaration = context.enclosingDeclaration;
-      if (!isErrorType(type) && enclosingDeclaration) {
+      if (enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
         const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
@@ -56207,7 +56182,7 @@ function createTypeChecker(host) {
           );
         }
         if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !isLateBindableName(node.name)) {
-          if (!(context.flags & 1 /* AllowUnresolvedComputedNames */ && hasDynamicName(node) && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
+          if (!(context.flags & 1 /* AllowUnresolvedNames */ && hasDynamicName(node) && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
             return void 0;
           }
         }
@@ -73711,6 +73686,248 @@ function createTypeChecker(host) {
       return false;
     });
   }
+  function markLinkedReferences(location, hint, propSymbol, parentType) {
+    if (!canCollectSymbolAliasAccessabilityData) {
+      return;
+    }
+    if (location.flags & 33554432 /* Ambient */) {
+      return;
+    }
+    switch (hint) {
+      case 1 /* Identifier */:
+        return markIdentifierAliasReferenced(location);
+      case 2 /* Property */:
+        return markPropertyAliasReferenced(location, propSymbol, parentType);
+      case 3 /* ExportAssignment */:
+        return markExportAssignmentAliasReferenced(location);
+      case 4 /* Jsx */:
+        return markJsxAliasReferenced(location);
+      case 5 /* AsyncFunction */:
+        return markAsyncFunctionAliasReferenced(location);
+      case 6 /* ExportImportEquals */:
+        return markImportEqualsAliasReferenced(location);
+      case 7 /* ExportSpecifier */:
+        return markExportSpecifierAliasReferenced(location);
+      case 8 /* Decorator */:
+        return markDecoratorAliasReferenced(location);
+      case 0 /* Unspecified */: {
+        if (isIdentifier(location) && (isExpressionNode(location) || isShorthandPropertyAssignment(location.parent) || isImportEqualsDeclaration(location.parent) && location.parent.moduleReference === location) && shouldMarkIdentifierAliasReferenced(location)) {
+          if (isPropertyAccessOrQualifiedName(location.parent)) {
+            const left = isPropertyAccessExpression(location.parent) ? location.parent.expression : location.parent.left;
+            if (left !== location) return;
+          }
+          markIdentifierAliasReferenced(location);
+          return;
+        }
+        if (isPropertyAccessOrQualifiedName(location)) {
+          let topProp = location;
+          while (isPropertyAccessOrQualifiedName(topProp)) {
+            if (isPartOfTypeNode(topProp)) return;
+            topProp = topProp.parent;
+          }
+          return markPropertyAliasReferenced(location);
+        }
+        if (isExportAssignment(location)) {
+          return markExportAssignmentAliasReferenced(location);
+        }
+        if (isJsxOpeningLikeElement(location) || isJsxOpeningFragment(location)) {
+          return markJsxAliasReferenced(location);
+        }
+        if (isFunctionLikeDeclaration(location) || isMethodSignature(location)) {
+          return markAsyncFunctionAliasReferenced(location);
+        }
+        if (isImportEqualsDeclaration(location)) {
+          if (isInternalModuleImportEqualsDeclaration(location) || checkExternalImportOrExportDeclaration(location)) {
+            return markImportEqualsAliasReferenced(location);
+          }
+          return;
+        }
+        if (isExportSpecifier(location)) {
+          return markExportSpecifierAliasReferenced(location);
+        }
+        if (!compilerOptions.emitDecoratorMetadata) {
+          return;
+        }
+        if (!canHaveDecorators(location) || !hasDecorators(location) || !location.modifiers || !nodeCanBeDecorated(legacyDecorators, location, location.parent, location.parent.parent)) {
+          return;
+        }
+        return markDecoratorAliasReferenced(location);
+      }
+      default:
+        Debug.assertNever(hint, `Unhandled reference hint: ${hint}`);
+    }
+  }
+  function markIdentifierAliasReferenced(location) {
+    const symbol = getResolvedSymbol(location);
+    if (symbol && symbol !== argumentsSymbol && symbol !== unknownSymbol && !isThisInTypeQuery(location)) {
+      markAliasReferenced(symbol, location);
+    }
+  }
+  function markPropertyAliasReferenced(location, propSymbol, parentType) {
+    const left = isPropertyAccessExpression(location) ? location.expression : location.left;
+    if (isThisIdentifier(left) || !isIdentifier(left)) {
+      return;
+    }
+    const parentSymbol = getResolvedSymbol(left);
+    if (!parentSymbol || parentSymbol === unknownSymbol) {
+      return;
+    }
+    if (getIsolatedModules(compilerOptions) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location)) {
+      markAliasReferenced(parentSymbol, location);
+      return;
+    }
+    const leftType = parentType || checkExpressionCached(left);
+    if (isTypeAny(leftType) || leftType === silentNeverType) {
+      markAliasReferenced(parentSymbol, location);
+      return;
+    }
+    let prop = propSymbol;
+    if (!prop && !parentType) {
+      const right = isPropertyAccessExpression(location) ? location.name : location.right;
+      const lexicallyScopedSymbol = isPrivateIdentifier(right) && lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right);
+      const assignmentKind = getAssignmentTargetKind(location);
+      const apparentType = getApparentType(assignmentKind !== 0 /* None */ || isMethodAccessForCall(location) ? getWidenedType(leftType) : leftType);
+      prop = isPrivateIdentifier(right) ? lexicallyScopedSymbol && getPrivateIdentifierPropertyOfType(apparentType, lexicallyScopedSymbol) || void 0 : getPropertyOfType(apparentType, right.escapedText);
+    }
+    if (!(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && location.parent.kind === 306 /* EnumMember */))) {
+      markAliasReferenced(parentSymbol, location);
+    }
+    return;
+  }
+  function markExportAssignmentAliasReferenced(location) {
+    if (isIdentifier(location.expression)) {
+      const id = location.expression;
+      const sym = getExportSymbolOfValueSymbolIfExported(resolveEntityName(
+        id,
+        -1 /* All */,
+        /*ignoreErrors*/
+        true,
+        /*dontResolveAlias*/
+        true,
+        location
+      ));
+      if (sym) {
+        markAliasReferenced(sym, id);
+      }
+    }
+  }
+  function markJsxAliasReferenced(node) {
+    if (!getJsxNamespaceContainerForImplicitImport(node)) {
+      const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
+      const jsxFactoryNamespace = getJsxNamespace(node);
+      const jsxFactoryLocation = isJsxOpeningLikeElement(node) ? node.tagName : node;
+      let jsxFactorySym;
+      if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
+        jsxFactorySym = resolveName(
+          jsxFactoryLocation,
+          jsxFactoryNamespace,
+          111551 /* Value */,
+          jsxFactoryRefErr,
+          /*isUse*/
+          true
+        );
+      }
+      if (jsxFactorySym) {
+        jsxFactorySym.isReferenced = -1 /* All */;
+        if (canCollectSymbolAliasAccessabilityData && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
+          markAliasSymbolAsReferenced(jsxFactorySym);
+        }
+      }
+      if (isJsxOpeningFragment(node)) {
+        const file = getSourceFileOfNode(node);
+        const localJsxNamespace = getLocalJsxNamespace(file);
+        if (localJsxNamespace) {
+          resolveName(
+            jsxFactoryLocation,
+            localJsxNamespace,
+            111551 /* Value */,
+            jsxFactoryRefErr,
+            /*isUse*/
+            true
+          );
+        }
+      }
+    }
+    return;
+  }
+  function markAsyncFunctionAliasReferenced(location) {
+    if (languageVersion < 2 /* ES2015 */) {
+      if (getFunctionFlags(location) & 2 /* Async */) {
+        const returnTypeNode = getEffectiveReturnTypeNode(location);
+        markTypeNodeAsReferenced(returnTypeNode);
+      }
+    }
+  }
+  function markImportEqualsAliasReferenced(location) {
+    if (hasSyntacticModifier(location, 32 /* Export */)) {
+      markExportAsReferenced(location);
+    }
+  }
+  function markExportSpecifierAliasReferenced(location) {
+    if (!location.parent.parent.moduleSpecifier && !location.isTypeOnly && !location.parent.parent.isTypeOnly) {
+      const exportedName = location.propertyName || location.name;
+      const symbol = resolveName(
+        exportedName,
+        exportedName.escapedText,
+        111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
+        /*nameNotFoundMessage*/
+        void 0,
+        /*isUse*/
+        true
+      );
+      if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
+      } else {
+        const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
+        if (!target || getSymbolFlags(target) & 111551 /* Value */) {
+          markExportAsReferenced(location);
+          markIdentifierAliasReferenced(location.propertyName || location.name);
+        }
+      }
+      return;
+    }
+  }
+  function markDecoratorAliasReferenced(node) {
+    if (compilerOptions.emitDecoratorMetadata) {
+      const firstDecorator = find(node.modifiers, isDecorator);
+      if (!firstDecorator) {
+        return;
+      }
+      checkExternalEmitHelpers(firstDecorator, 16 /* Metadata */);
+      switch (node.kind) {
+        case 263 /* ClassDeclaration */:
+          const constructor = getFirstConstructorWithBody(node);
+          if (constructor) {
+            for (const parameter of constructor.parameters) {
+              markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+            }
+          }
+          break;
+        case 177 /* GetAccessor */:
+        case 178 /* SetAccessor */:
+          const otherKind = node.kind === 177 /* GetAccessor */ ? 178 /* SetAccessor */ : 177 /* GetAccessor */;
+          const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(node), otherKind);
+          markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
+          break;
+        case 174 /* MethodDeclaration */:
+          for (const parameter of node.parameters) {
+            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+          }
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(node));
+          break;
+        case 172 /* PropertyDeclaration */:
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveTypeAnnotationNode(node));
+          break;
+        case 169 /* Parameter */:
+          markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
+          const containingSignature = node.parent;
+          for (const parameter of containingSignature.parameters) {
+            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+          }
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(containingSignature));
+          break;
+      }
+    }
+  }
   function markAliasReferenced(symbol, location) {
     if (!canCollectSymbolAliasAccessabilityData) {
       return;
@@ -73732,6 +73949,77 @@ function createTypeChecker(host) {
       }
     }
   }
+  function markAliasSymbolAsReferenced(symbol) {
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
+    const links = getSymbolLinks(symbol);
+    if (!links.referenced) {
+      links.referenced = true;
+      const node = getDeclarationOfAliasSymbol(symbol);
+      if (!node) return Debug.fail();
+      if (isInternalModuleImportEqualsDeclaration(node)) {
+        if (getSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
+          const left = getFirstIdentifier(node.moduleReference);
+          markIdentifierAliasReferenced(left);
+        }
+      }
+    }
+  }
+  function markExportAsReferenced(node) {
+    const symbol = getSymbolOfDeclaration(node);
+    const target = resolveAlias(symbol);
+    if (target) {
+      const markAlias = target === unknownSymbol || getSymbolFlags(
+        symbol,
+        /*excludeTypeOnlyMeanings*/
+        true
+      ) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target);
+      if (markAlias) {
+        markAliasSymbolAsReferenced(symbol);
+      }
+    }
+  }
+  function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) {
+    if (!typeName) return;
+    const rootName = getFirstIdentifier(typeName);
+    const meaning = (typeName.kind === 80 /* Identifier */ ? 788968 /* Type */ : 1920 /* Namespace */) | 2097152 /* Alias */;
+    const rootSymbol = resolveName(
+      rootName,
+      rootName.escapedText,
+      meaning,
+      /*nameNotFoundMessage*/
+      void 0,
+      /*isUse*/
+      true
+    );
+    if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
+      if (canCollectSymbolAliasAccessabilityData && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
+        markAliasSymbolAsReferenced(rootSymbol);
+      } else if (forDecoratorMetadata && getIsolatedModules(compilerOptions) && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
+        const diag2 = error2(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
+        const aliasDeclaration = find(rootSymbol.declarations || emptyArray, isAliasSymbolDeclaration2);
+        if (aliasDeclaration) {
+          addRelatedInfo(diag2, createDiagnosticForNode(aliasDeclaration, Diagnostics._0_was_imported_here, idText(rootName)));
+        }
+      }
+    }
+  }
+  function markTypeNodeAsReferenced(node) {
+    markEntityNameOrEntityExpressionAsReference(
+      node && getEntityNameFromTypeNode(node),
+      /*forDecoratorMetadata*/
+      false
+    );
+  }
+  function markDecoratorMedataDataTypeNodeAsReferenced(node) {
+    const entityName = getEntityNameForDecoratorMetadata(node);
+    if (entityName && isEntityName(entityName)) {
+      markEntityNameOrEntityExpressionAsReference(
+        entityName,
+        /*forDecoratorMetadata*/
+        true
+      );
+    }
+  }
   function getNarrowedTypeOfSymbol(symbol, location, checkMode) {
     var _a;
     const type = getTypeOfSymbol(symbol, checkMode);
@@ -73827,7 +74115,7 @@ function createTypeChecker(host) {
       return getTypeOfSymbol(symbol);
     }
     if (shouldMarkIdentifierAliasReferenced(node)) {
-      markAliasReferenced(symbol, node);
+      markLinkedReferences(node, 1 /* Identifier */);
     }
     const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
     const targetSymbol = resolveAliasWithDeprecationCheck(localOrExportSymbol, node);
@@ -76370,42 +76658,7 @@ function createTypeChecker(host) {
       checkGrammarJsxElement(node);
     }
     checkJsxPreconditions(node);
-    if (!getJsxNamespaceContainerForImplicitImport(node)) {
-      const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
-      const jsxFactoryNamespace = getJsxNamespace(node);
-      const jsxFactoryLocation = isNodeOpeningLikeElement ? node.tagName : node;
-      let jsxFactorySym;
-      if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
-        jsxFactorySym = resolveName(
-          jsxFactoryLocation,
-          jsxFactoryNamespace,
-          111551 /* Value */,
-          jsxFactoryRefErr,
-          /*isUse*/
-          true
-        );
-      }
-      if (jsxFactorySym) {
-        jsxFactorySym.isReferenced = -1 /* All */;
-        if (canCollectSymbolAliasAccessabilityData && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
-          markAliasSymbolAsReferenced(jsxFactorySym);
-        }
-      }
-      if (isJsxOpeningFragment(node)) {
-        const file = getSourceFileOfNode(node);
-        const localJsxNamespace = getLocalJsxNamespace(file);
-        if (localJsxNamespace) {
-          resolveName(
-            jsxFactoryLocation,
-            localJsxNamespace,
-            111551 /* Value */,
-            jsxFactoryRefErr,
-            /*isUse*/
-            true
-          );
-        }
-      }
-    }
+    markLinkedReferences(node, 4 /* Jsx */);
     if (isNodeOpeningLikeElement) {
       const jsxOpeningLikeNode = node;
       const sig = getResolvedSignature(jsxOpeningLikeNode);
@@ -76836,7 +77089,13 @@ function createTypeChecker(host) {
     } else {
       if (isAnyLike) {
         if (isIdentifier(left) && parentSymbol) {
-          markAliasReferenced(parentSymbol, node);
+          markLinkedReferences(
+            node,
+            2 /* Property */,
+            /*propSymbol*/
+            void 0,
+            leftType
+          );
         }
         return isErrorType(apparentType) ? errorType : apparentType;
       }
@@ -76849,9 +77108,7 @@ function createTypeChecker(host) {
         node.kind === 166 /* QualifiedName */
       );
     }
-    if (isIdentifier(left) && parentSymbol && (getIsolatedModules(compilerOptions) || !(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && node.parent.kind === 306 /* EnumMember */)) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
-      markAliasReferenced(parentSymbol, node);
-    }
+    markLinkedReferences(node, 2 /* Property */, prop, leftType);
     let propType;
     if (!prop) {
       const indexInfo = !isPrivateIdentifier(right) && (assignmentKind === 0 /* None */ || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ? getApplicableIndexInfoForName(apparentType, right.escapedText) : void 0;
@@ -83784,7 +84041,7 @@ function createTypeChecker(host) {
         return;
       }
     } else {
-      markTypeNodeAsReferenced(returnTypeNode);
+      markLinkedReferences(node, 5 /* AsyncFunction */);
       if (isErrorType(returnType)) {
         return;
       }
@@ -83968,48 +84225,6 @@ function createTypeChecker(host) {
       voidType
     );
   }
-  function markTypeNodeAsReferenced(node) {
-    markEntityNameOrEntityExpressionAsReference(
-      node && getEntityNameFromTypeNode(node),
-      /*forDecoratorMetadata*/
-      false
-    );
-  }
-  function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) {
-    if (!typeName) return;
-    const rootName = getFirstIdentifier(typeName);
-    const meaning = (typeName.kind === 80 /* Identifier */ ? 788968 /* Type */ : 1920 /* Namespace */) | 2097152 /* Alias */;
-    const rootSymbol = resolveName(
-      rootName,
-      rootName.escapedText,
-      meaning,
-      /*nameNotFoundMessage*/
-      void 0,
-      /*isUse*/
-      true
-    );
-    if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
-      if (canCollectSymbolAliasAccessabilityData && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
-        markAliasSymbolAsReferenced(rootSymbol);
-      } else if (forDecoratorMetadata && getIsolatedModules(compilerOptions) && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
-        const diag2 = error2(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
-        const aliasDeclaration = find(rootSymbol.declarations || emptyArray, isAliasSymbolDeclaration2);
-        if (aliasDeclaration) {
-          addRelatedInfo(diag2, createDiagnosticForNode(aliasDeclaration, Diagnostics._0_was_imported_here, idText(rootName)));
-        }
-      }
-    }
-  }
-  function markDecoratorMedataDataTypeNodeAsReferenced(node) {
-    const entityName = getEntityNameForDecoratorMetadata(node);
-    if (entityName && isEntityName(entityName)) {
-      markEntityNameOrEntityExpressionAsReference(
-        entityName,
-        /*forDecoratorMetadata*/
-        true
-      );
-    }
-  }
   function getEntityNameForDecoratorMetadata(node) {
     if (node) {
       switch (node.kind) {
@@ -84089,42 +84304,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    if (compilerOptions.emitDecoratorMetadata) {
-      checkExternalEmitHelpers(firstDecorator, 16 /* Metadata */);
-      switch (node.kind) {
-        case 263 /* ClassDeclaration */:
-          const constructor = getFirstConstructorWithBody(node);
-          if (constructor) {
-            for (const parameter of constructor.parameters) {
-              markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-            }
-          }
-          break;
-        case 177 /* GetAccessor */:
-        case 178 /* SetAccessor */:
-          const otherKind = node.kind === 177 /* GetAccessor */ ? 178 /* SetAccessor */ : 177 /* GetAccessor */;
-          const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(node), otherKind);
-          markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
-          break;
-        case 174 /* MethodDeclaration */:
-          for (const parameter of node.parameters) {
-            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-          }
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(node));
-          break;
-        case 172 /* PropertyDeclaration */:
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveTypeAnnotationNode(node));
-          break;
-        case 169 /* Parameter */:
-          markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
-          const containingSignature = node.parent;
-          for (const parameter of containingSignature.parameters) {
-            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-          }
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(containingSignature));
-          break;
-      }
-    }
+    markLinkedReferences(node, 8 /* Decorator */);
     for (const modifier of node.modifiers) {
       if (isDecorator(modifier)) {
         checkDecorator(modifier);
@@ -87465,9 +87645,7 @@ function createTypeChecker(host) {
     checkGrammarModifiers(node);
     if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
       checkImportBinding(node);
-      if (hasSyntacticModifier(node, 32 /* Export */)) {
-        markExportAsReferenced(node);
-      }
+      markLinkedReferences(node, 6 /* ExportImportEquals */);
       if (node.moduleReference.kind !== 283 /* ExternalModuleReference */) {
         const target = resolveAlias(getSymbolOfDeclaration(node));
         if (target !== unknownSymbol) {
@@ -87565,13 +87743,7 @@ function createTypeChecker(host) {
       if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
         error2(exportedName, Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, idText(exportedName));
       } else {
-        if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) {
-          markExportAsReferenced(node);
-        }
-        const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
-        if (!target || getSymbolFlags(target) & 111551 /* Value */) {
-          checkExpressionCached(node.propertyName || node.name);
-        }
+        markLinkedReferences(node, 7 /* ExportSpecifier */);
       }
     } else {
       if (getESModuleInterop(compilerOptions) && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) < 4 /* System */ && idText(node.propertyName || node.name) === "default") {
@@ -87613,8 +87785,8 @@ function createTypeChecker(host) {
         node
       ));
       if (sym) {
+        markLinkedReferences(node, 3 /* ExportAssignment */);
         const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(sym, 111551 /* Value */);
-        markAliasReferenced(sym, id);
         if (getSymbolFlags(sym) & 111551 /* Value */) {
           checkExpressionCached(id);
           if (!isIllegalExportDefaultInCJS && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && typeOnlyDeclaration) {
@@ -114856,7 +115028,7 @@ function getDeclarationDiagnostics(host, resolver, file) {
   );
   return result.diagnostics;
 }
-var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 1 /* AllowUnresolvedComputedNames */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 1 /* AllowUnresolvedNames */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
 function transformDeclarations(context) {
   const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
   let getSymbolAccessibilityDiagnostic = throwDiagnostic;
@@ -134420,12 +134592,12 @@ var CompletionTriggerKind = /* @__PURE__ */ ((CompletionTriggerKind2) => {
   CompletionTriggerKind2[CompletionTriggerKind2["TriggerForIncompleteCompletions"] = 3] = "TriggerForIncompleteCompletions";
   return CompletionTriggerKind2;
 })(CompletionTriggerKind || {});
-var InlayHintKind = /* @__PURE__ */ ((InlayHintKind2) => {
-  InlayHintKind2["Type"] = "Type";
-  InlayHintKind2["Parameter"] = "Parameter";
-  InlayHintKind2["Enum"] = "Enum";
-  return InlayHintKind2;
-})(InlayHintKind || {});
+var InlayHintKind2 = /* @__PURE__ */ ((InlayHintKind3) => {
+  InlayHintKind3["Type"] = "Type";
+  InlayHintKind3["Parameter"] = "Parameter";
+  InlayHintKind3["Enum"] = "Enum";
+  return InlayHintKind3;
+})(InlayHintKind2 || {});
 var HighlightSpanKind = /* @__PURE__ */ ((HighlightSpanKind2) => {
   HighlightSpanKind2["none"] = "none";
   HighlightSpanKind2["definition"] = "definition";
@@ -134676,13 +134848,13 @@ var scanner = createScanner(
   /*skipTrivia*/
   true
 );
-var SemanticMeaning = /* @__PURE__ */ ((SemanticMeaning3) => {
-  SemanticMeaning3[SemanticMeaning3["None"] = 0] = "None";
-  SemanticMeaning3[SemanticMeaning3["Value"] = 1] = "Value";
-  SemanticMeaning3[SemanticMeaning3["Type"] = 2] = "Type";
-  SemanticMeaning3[SemanticMeaning3["Namespace"] = 4] = "Namespace";
-  SemanticMeaning3[SemanticMeaning3["All"] = 7] = "All";
-  return SemanticMeaning3;
+var SemanticMeaning = /* @__PURE__ */ ((SemanticMeaning2) => {
+  SemanticMeaning2[SemanticMeaning2["None"] = 0] = "None";
+  SemanticMeaning2[SemanticMeaning2["Value"] = 1] = "Value";
+  SemanticMeaning2[SemanticMeaning2["Type"] = 2] = "Type";
+  SemanticMeaning2[SemanticMeaning2["Namespace"] = 4] = "Namespace";
+  SemanticMeaning2[SemanticMeaning2["All"] = 7] = "All";
+  return SemanticMeaning2;
 })(SemanticMeaning || {});
 function getMeaningFromDeclaration(node) {
   switch (node.kind) {
@@ -136631,7 +136803,11 @@ function getPrecedingNonSpaceCharacterPosition(text, position) {
 function getSynthesizedDeepClone(node, includeTrivia = true) {
   const clone2 = node && getSynthesizedDeepCloneWorker(node);
   if (clone2 && !includeTrivia) suppressLeadingAndTrailingTrivia(clone2);
-  return clone2;
+  return setParentRecursive(
+    clone2,
+    /*incremental*/
+    false
+  );
 }
 function getSynthesizedDeepCloneWithReplacements(node, includeTrivia, replaceNode) {
   let clone2 = replaceNode(node);
@@ -137228,13 +137404,13 @@ function getNamesForExportedSymbol(symbol, scriptTarget) {
   if (needsNameFromDeclaration(symbol)) {
     const fromDeclaration = getDefaultLikeExportNameFromDeclaration(symbol);
     if (fromDeclaration) return fromDeclaration;
-    const fileNameCase = ts_codefix_exports.moduleSymbolToValidIdentifier(
+    const fileNameCase = moduleSymbolToValidIdentifier(
       getSymbolParentOrFail(symbol),
       scriptTarget,
       /*forceCapitalize*/
       false
     );
-    const capitalized = ts_codefix_exports.moduleSymbolToValidIdentifier(
+    const capitalized = moduleSymbolToValidIdentifier(
       getSymbolParentOrFail(symbol),
       scriptTarget,
       /*forceCapitalize*/
@@ -137247,7 +137423,7 @@ function getNamesForExportedSymbol(symbol, scriptTarget) {
 }
 function getNameForExportedSymbol(symbol, scriptTarget, preferCapitalized) {
   if (needsNameFromDeclaration(symbol)) {
-    return getDefaultLikeExportNameFromDeclaration(symbol) || ts_codefix_exports.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, !!preferCapitalized);
+    return getDefaultLikeExportNameFromDeclaration(symbol) || moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, !!preferCapitalized);
   }
   return symbol.name;
 }
@@ -137278,6 +137454,36 @@ function getSymbolParentOrFail(symbol) {
     }).join(", ")}.`
   );
 }
+function moduleSymbolToValidIdentifier(moduleSymbol, target, forceCapitalize) {
+  return moduleSpecifierToValidIdentifier(removeFileExtension(stripQuotes(moduleSymbol.name)), target, forceCapitalize);
+}
+function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitalize) {
+  const baseName = getBaseFileName(removeSuffix(moduleSpecifier, "/index"));
+  let res = "";
+  let lastCharWasValid = true;
+  const firstCharCode = baseName.charCodeAt(0);
+  if (isIdentifierStart(firstCharCode, target)) {
+    res += String.fromCharCode(firstCharCode);
+    if (forceCapitalize) {
+      res = res.toUpperCase();
+    }
+  } else {
+    lastCharWasValid = false;
+  }
+  for (let i = 1; i < baseName.length; i++) {
+    const ch = baseName.charCodeAt(i);
+    const isValid = isIdentifierPart(ch, target);
+    if (isValid) {
+      let char = String.fromCharCode(ch);
+      if (!lastCharWasValid) {
+        char = char.toUpperCase();
+      }
+      res += char;
+    }
+    lastCharWasValid = isValid;
+  }
+  return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
+}
 function stringContainsAt(haystack, needle, startIndex) {
   const needleLength = needle.length;
   if (needleLength + startIndex > haystack.length) {
@@ -137781,7 +137987,6 @@ function getExportInfoMap(importingFile, host, program, preferences, cancellatio
     return cache;
   }
   (_d = host.log) == null ? void 0 : _d.call(host, "getExportInfoMap: cache miss or empty; calculating new results");
-  const compilerOptions = program.getCompilerOptions();
   let moduleCount = 0;
   try {
     forEachExternalModuleToImportFrom(
@@ -137794,7 +137999,7 @@ function getExportInfoMap(importingFile, host, program, preferences, cancellatio
         if (++moduleCount % 100 === 0) cancellationToken == null ? void 0 : cancellationToken.throwIfCancellationRequested();
         const seenExports = /* @__PURE__ */ new Map();
         const checker = program2.getTypeChecker();
-        const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
+        const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker);
         if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) {
           cache.add(
             importingFile.path,
@@ -137830,48 +138035,37 @@ function getExportInfoMap(importingFile, host, program, preferences, cancellatio
   (_e = host.log) == null ? void 0 : _e.call(host, `getExportInfoMap: done in ${timestamp() - start} ms`);
   return cache;
 }
-function getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions) {
-  const exported = getDefaultLikeExportWorker(moduleSymbol, checker);
-  if (!exported) return void 0;
-  const { symbol, exportKind } = exported;
-  const info = getDefaultExportInfoWorker(symbol, checker, compilerOptions);
-  return info && { symbol, exportKind, ...info };
-}
-function isImportableSymbol(symbol, checker) {
-  return !checker.isUndefinedSymbol(symbol) && !checker.isUnknownSymbol(symbol) && !isKnownSymbol(symbol) && !isPrivateIdentifierSymbol(symbol);
-}
-function getDefaultLikeExportWorker(moduleSymbol, checker) {
+function getDefaultLikeExportInfo(moduleSymbol, checker) {
   const exportEquals = checker.resolveExternalModuleSymbol(moduleSymbol);
   if (exportEquals !== moduleSymbol) return { symbol: exportEquals, exportKind: 2 /* ExportEquals */ };
   const defaultExport = checker.tryGetMemberInModuleExports("default" /* Default */, moduleSymbol);
   if (defaultExport) return { symbol: defaultExport, exportKind: 1 /* Default */ };
 }
-function getDefaultExportInfoWorker(defaultExport, checker, compilerOptions) {
-  const localSymbol = getLocalSymbolForExportDefault(defaultExport);
-  if (localSymbol) return { resolvedSymbol: localSymbol, name: localSymbol.name };
-  const name = getNameForExportDefault(defaultExport);
-  if (name !== void 0) return { resolvedSymbol: defaultExport, name };
-  if (defaultExport.flags & 2097152 /* Alias */) {
-    const aliased = checker.getImmediateAliasedSymbol(defaultExport);
-    if (aliased && aliased.parent) {
-      return getDefaultExportInfoWorker(aliased, checker, compilerOptions);
+function isImportableSymbol(symbol, checker) {
+  return !checker.isUndefinedSymbol(symbol) && !checker.isUnknownSymbol(symbol) && !isKnownSymbol(symbol) && !isPrivateIdentifierSymbol(symbol);
+}
+function forEachNameOfDefaultExport(defaultExport, checker, compilerOptions, preferCapitalizedNames, cb) {
+  let chain;
+  let current = defaultExport;
+  while (current) {
+    const fromDeclaration = getDefaultLikeExportNameFromDeclaration(current);
+    if (fromDeclaration) {
+      const final = cb(fromDeclaration);
+      if (final) return final;
     }
+    if (current.escapedName !== "default" /* Default */ && current.escapedName !== "export=" /* ExportEquals */) {
+      const final = cb(current.name);
+      if (final) return final;
+    }
+    chain = append(chain, current);
+    current = current.flags & 2097152 /* Alias */ ? checker.getImmediateAliasedSymbol(current) : void 0;
   }
-  if (defaultExport.escapedName !== "default" /* Default */ && defaultExport.escapedName !== "export=" /* ExportEquals */) {
-    return { resolvedSymbol: defaultExport, name: defaultExport.getName() };
-  }
-  return { resolvedSymbol: defaultExport, name: getNameForExportedSymbol(defaultExport, compilerOptions.target) };
-}
-function getNameForExportDefault(symbol) {
-  return symbol.declarations && firstDefined(symbol.declarations, (declaration) => {
-    var _a;
-    if (isExportAssignment(declaration)) {
-      return (_a = tryCast(skipOuterExpressions(declaration.expression), isIdentifier)) == null ? void 0 : _a.text;
-    } else if (isExportSpecifier(declaration)) {
-      Debug.assert(declaration.name.text === "default" /* Default */, "Expected the specifier to be a default export");
-      return declaration.propertyName && declaration.propertyName.text;
+  for (const symbol of chain ?? emptyArray) {
+    if (symbol.parent && isExternalModuleSymbol(symbol.parent)) {
+      const final = cb(moduleSymbolToValidIdentifier(symbol.parent, getEmitScriptTarget(compilerOptions), preferCapitalizedNames));
+      if (final) return final;
     }
-  });
+  }
 }
 
 // src/services/classifier.ts
@@ -141643,6 +141837,7 @@ function cleanText(text) {
 var ts_refactor_exports = {};
 __export(ts_refactor_exports, {
   addExportToChanges: () => addExportToChanges,
+  addExportsInOldFile: () => addExportsInOldFile,
   addImportsForMovedSymbols: () => addImportsForMovedSymbols,
   addNewFileToTsconfig: () => addNewFileToTsconfig,
   addOrRemoveBracesToArrowFunction: () => ts_refactor_addOrRemoveBracesToArrowFunction_exports,
@@ -141663,6 +141858,7 @@ __export(ts_refactor_exports, {
   generateGetAccessorAndSetAccessor: () => ts_refactor_generateGetAccessorAndSetAccessor_exports,
   getApplicableRefactors: () => getApplicableRefactors,
   getEditsForRefactor: () => getEditsForRefactor,
+  getExistingLocals: () => getExistingLocals,
   getIdentifierForNode: () => getIdentifierForNode,
   getNewStatementsAndRemoveFromOldFile: () => getNewStatementsAndRemoveFromOldFile,
   getStatementsToMove: () => getStatementsToMove,
@@ -142086,7 +142282,7 @@ function doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, toConve
       toConvertSymbols.add(symbol);
     }
   });
-  const preferredName = moduleSpecifier && isStringLiteral(moduleSpecifier) ? ts_codefix_exports.moduleSpecifierToValidIdentifier(moduleSpecifier.text, 99 /* ESNext */) : "module";
+  const preferredName = moduleSpecifier && isStringLiteral(moduleSpecifier) ? moduleSpecifierToValidIdentifier(moduleSpecifier.text, 99 /* ESNext */) : "module";
   function hasNamespaceNameConflict(namedImport) {
     return !!ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(namedImport.name, checker, sourceFile, (id) => {
       const symbol = checker.resolveName(
@@ -142700,7 +142896,7 @@ function getNamespaceLikeImport(node) {
   }
 }
 function updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleSpecifier, oldImportId, oldImportNode, quotePreference) {
-  const preferredNewNamespaceName = ts_codefix_exports.moduleSpecifierToValidIdentifier(newModuleSpecifier, 99 /* ESNext */);
+  const preferredNewNamespaceName = moduleSpecifierToValidIdentifier(newModuleSpecifier, 99 /* ESNext */);
   let needUniqueName = false;
   const toChange = [];
   ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(oldImportId, checker, sourceFile, (ref) => {
@@ -147915,7 +148111,8 @@ var invalidOperationsInPartialSemanticMode = [
   "provideCallHierarchyIncomingCalls",
   "provideCallHierarchyOutgoingCalls",
   "provideInlayHints",
-  "getSupportedCodeFixes"
+  "getSupportedCodeFixes",
+  "getPasteEdits"
 ];
 var invalidOperationsInSyntacticMode = [
   ...invalidOperationsInPartialSemanticMode,
@@ -148319,6 +148516,19 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
       tags
     };
   }
+  function getPasteEdits(args, formatOptions) {
+    synchronizeHostData();
+    return ts_PasteEdits_exports.pasteEditsProvider(
+      getValidSourceFile(args.targetFile),
+      args.pastedText,
+      args.pasteLocations,
+      args.copiedFrom ? { file: getValidSourceFile(args.copiedFrom.file), range: args.copiedFrom.range } : void 0,
+      host,
+      args.preferences,
+      ts_formatting_exports.getFormatContext(formatOptions, host),
+      cancellationToken
+    );
+  }
   function getNodeForQuickInfo(node) {
     if (isNewExpression(node.parent) && node.pos === node.parent.pos) {
       return node.parent.expression;
@@ -148569,12 +148779,12 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
       return ts_codefix_exports.getFixes({ errorCode, sourceFile, span, program, host, cancellationToken, formatContext, preferences });
     });
   }
-  function getCombinedCodeFix(scope, fixId54, formatOptions, preferences = emptyOptions) {
+  function getCombinedCodeFix(scope, fixId55, formatOptions, preferences = emptyOptions) {
     synchronizeHostData();
     Debug.assert(scope.type === "file");
     const sourceFile = getValidSourceFile(scope.fileName);
     const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
-    return ts_codefix_exports.getAllFixes({ fixId: fixId54, sourceFile, program, host, cancellationToken, formatContext, preferences });
+    return ts_codefix_exports.getAllFixes({ fixId: fixId55, sourceFile, program, host, cancellationToken, formatContext, preferences });
   }
   function organizeImports2(args, formatOptions, preferences = emptyOptions) {
     synchronizeHostData();
@@ -149094,7 +149304,8 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     commentSelection,
     uncommentSelection,
     provideInlayHints: provideInlayHints2,
-    getSupportedCodeFixes
+    getSupportedCodeFixes,
+    getPasteEdits
   };
   switch (languageServiceMode) {
     case 0 /* Semantic */:
@@ -150212,8 +150423,6 @@ __export(ts_codefix_exports, {
   getSupportedErrorCodes: () => getSupportedErrorCodes,
   importFixName: () => importFixName,
   importSymbols: () => importSymbols,
-  moduleSpecifierToValidIdentifier: () => moduleSpecifierToValidIdentifier,
-  moduleSymbolToValidIdentifier: () => moduleSymbolToValidIdentifier,
   parameterShouldGetTypeFromJSDoc: () => parameterShouldGetTypeFromJSDoc,
   registerCodeFix: () => registerCodeFix,
   setJsonCompilerOptionValue: () => setJsonCompilerOptionValue,
@@ -150236,14 +150445,14 @@ function createCodeFixActionWithoutFixAll(fixName8, changes, description3) {
     void 0
   );
 }
-function createCodeFixAction(fixName8, changes, description3, fixId54, fixAllDescription, command) {
-  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId54, diagnosticToString(fixAllDescription), command);
+function createCodeFixAction(fixName8, changes, description3, fixId55, fixAllDescription, command) {
+  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId55, diagnosticToString(fixAllDescription), command);
 }
-function createCodeFixActionMaybeFixAll(fixName8, changes, description3, fixId54, fixAllDescription, command) {
-  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId54, fixAllDescription && diagnosticToString(fixAllDescription), command);
+function createCodeFixActionMaybeFixAll(fixName8, changes, description3, fixId55, fixAllDescription, command) {
+  return createCodeFixActionWorker(fixName8, diagnosticToString(description3), changes, fixId55, fixAllDescription && diagnosticToString(fixAllDescription), command);
 }
-function createCodeFixActionWorker(fixName8, description3, changes, fixId54, fixAllDescription, command) {
-  return { fixName: fixName8, description: description3, changes, fixId: fixId54, fixAllDescription, commands: command ? [command] : void 0 };
+function createCodeFixActionWorker(fixName8, description3, changes, fixId55, fixAllDescription, command) {
+  return { fixName: fixName8, description: description3, changes, fixId: fixId55, fixAllDescription, commands: command ? [command] : void 0 };
 }
 function registerCodeFix(reg) {
   for (const error2 of reg.errorCodes) {
@@ -150251,9 +150460,9 @@ function registerCodeFix(reg) {
     errorCodeToFixes.add(String(error2), reg);
   }
   if (reg.fixIds) {
-    for (const fixId54 of reg.fixIds) {
-      Debug.assert(!fixIdToRegistration.has(fixId54));
-      fixIdToRegistration.set(fixId54, reg);
+    for (const fixId55 of reg.fixIds) {
+      Debug.assert(!fixIdToRegistration.has(fixId55));
+      fixIdToRegistration.set(fixId55, reg);
     }
   }
 }
@@ -150269,8 +150478,8 @@ function removeFixIdIfFixAllUnavailable(registration, diagnostics) {
     if (maybeFixableDiagnostics > 1) break;
   }
   const fixAllUnavailable = maybeFixableDiagnostics < 2;
-  return ({ fixId: fixId54, fixAllDescription, ...action }) => {
-    return fixAllUnavailable ? action : { ...action, fixId: fixId54, fixAllDescription };
+  return ({ fixId: fixId55, fixAllDescription, ...action }) => {
+    return fixAllUnavailable ? action : { ...action, fixId: fixId55, fixAllDescription };
   };
 }
 function getFixes(context) {
@@ -153774,7 +153983,6 @@ function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, moduleSym
 }
 function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program, host) {
   var _a, _b;
-  const compilerOptions = program.getCompilerOptions();
   const mainProgramInfo = getInfoWithChecker(
     program.getTypeChecker(),
     /*isFromPackageJson*/
@@ -153790,7 +153998,7 @@ function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program
     true
   ), `Could not find symbol in specified module for code actions`);
   function getInfoWithChecker(checker, isFromPackageJson) {
-    const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
+    const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker);
     if (defaultInfo && skipAlias(defaultInfo.symbol, checker) === symbol) {
       return { symbol: defaultInfo.symbol, moduleSymbol, moduleFileName: void 0, exportKind: defaultInfo.exportKind, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
     }
@@ -153800,12 +154008,9 @@ function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program
     }
   }
 }
-function isFutureSymbolExportInfoArray(info) {
-  return info[0].symbol === void 0;
-}
 function getImportFixes(exportInfos, usagePosition, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences, importMap = isFullSourceFile(sourceFile) ? createExistingImportMap(sourceFile, program) : void 0, fromCacheOnly) {
   const checker = program.getTypeChecker();
-  const existingImports = importMap && !isFutureSymbolExportInfoArray(exportInfos) ? flatMap(exportInfos, importMap.getImportsForExportInfo) : emptyArray;
+  const existingImports = importMap ? flatMap(exportInfos, importMap.getImportsForExportInfo) : emptyArray;
   const useNamespace = usagePosition !== void 0 && tryUseExistingNamespaceImport(existingImports, usagePosition);
   const addToExisting = tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, program.getCompilerOptions());
   if (addToExisting) {
@@ -154001,7 +154206,6 @@ function getNewImportFixes(program, sourceFile, usagePosition, isValidTypeOnlyUs
     );
     computedWithoutCacheCount += computedWithoutCache ? 1 : 0;
     return mapDefined(moduleSpecifiers, (moduleSpecifier) => {
-      var _a;
       if (rejectNodeModulesRelativePaths && pathContainsNodeModules(moduleSpecifier)) {
         return void 0;
       }
@@ -154014,7 +154218,14 @@ function getNewImportFixes(program, sourceFile, usagePosition, isValidTypeOnlyUs
         const exportEquals = checker.resolveExternalModuleSymbol(exportInfo2.moduleSymbol);
         let namespacePrefix;
         if (exportEquals !== exportInfo2.moduleSymbol) {
-          namespacePrefix = (_a = getDefaultExportInfoWorker(exportEquals, checker, compilerOptions)) == null ? void 0 : _a.name;
+          namespacePrefix = forEachNameOfDefaultExport(
+            exportEquals,
+            checker,
+            compilerOptions,
+            /*preferCapitalizedNames*/
+            false,
+            identity
+          );
         }
         namespacePrefix || (namespacePrefix = moduleSymbolToValidIdentifier(
           exportInfo2.moduleSymbol,
@@ -154298,12 +154509,12 @@ function getExportInfos(symbolName2, isJsxTagName, currentTokenMeaning, cancella
     const checker = program2.getTypeChecker();
     cancellationToken.throwIfCancellationRequested();
     const compilerOptions = program2.getCompilerOptions();
-    const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
-    if (defaultInfo && (defaultInfo.name === symbolName2 || moduleSymbolToValidIdentifier(moduleSymbol, getEmitScriptTarget(compilerOptions), isJsxTagName) === symbolName2) && symbolHasMeaning(defaultInfo.resolvedSymbol, currentTokenMeaning)) {
+    const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker);
+    if (defaultInfo && symbolFlagsHaveMeaning(checker.getSymbolFlags(defaultInfo.symbol), currentTokenMeaning) && forEachNameOfDefaultExport(defaultInfo.symbol, checker, compilerOptions, isJsxTagName, (name) => name === symbolName2)) {
       addSymbol(moduleSymbol, sourceFile, defaultInfo.symbol, defaultInfo.exportKind, program2, isFromPackageJson);
     }
     const exportSymbolWithIdenticalName = checker.tryGetMemberInModuleExportsAndProperties(symbolName2, moduleSymbol);
-    if (exportSymbolWithIdenticalName && symbolHasMeaning(exportSymbolWithIdenticalName, currentTokenMeaning)) {
+    if (exportSymbolWithIdenticalName && symbolFlagsHaveMeaning(checker.getSymbolFlags(exportSymbolWithIdenticalName), currentTokenMeaning)) {
       addSymbol(moduleSymbol, sourceFile, exportSymbolWithIdenticalName, 0 /* Named */, program2, isFromPackageJson);
     }
   });
@@ -154697,38 +154908,8 @@ function createConstEqualsRequireDeclaration(name, quotedModuleSpecifier) {
     ], 2 /* Const */)
   );
 }
-function symbolHasMeaning({ declarations }, meaning) {
-  return some(declarations, (decl) => !!(getMeaningFromDeclaration(decl) & meaning));
-}
-function moduleSymbolToValidIdentifier(moduleSymbol, target, forceCapitalize) {
-  return moduleSpecifierToValidIdentifier(removeFileExtension(stripQuotes(moduleSymbol.name)), target, forceCapitalize);
-}
-function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitalize) {
-  const baseName = getBaseFileName(removeSuffix(moduleSpecifier, "/index"));
-  let res = "";
-  let lastCharWasValid = true;
-  const firstCharCode = baseName.charCodeAt(0);
-  if (isIdentifierStart(firstCharCode, target)) {
-    res += String.fromCharCode(firstCharCode);
-    if (forceCapitalize) {
-      res = res.toUpperCase();
-    }
-  } else {
-    lastCharWasValid = false;
-  }
-  for (let i = 1; i < baseName.length; i++) {
-    const ch = baseName.charCodeAt(i);
-    const isValid = isIdentifierPart(ch, target);
-    if (isValid) {
-      let char = String.fromCharCode(ch);
-      if (!lastCharWasValid) {
-        char = char.toUpperCase();
-      }
-      res += char;
-    }
-    lastCharWasValid = isValid;
-  }
-  return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
+function symbolFlagsHaveMeaning(flags, meaning) {
+  return meaning === 7 /* All */ ? true : meaning & 1 /* Value */ ? !!(flags & 111551 /* Value */) : meaning & 2 /* Type */ ? !!(flags & 788968 /* Type */) : meaning & 4 /* Namespace */ ? !!(flags & 1920 /* Namespace */) : false;
 }
 function getImpliedNodeFormatForEmit(file, program) {
   return isFullSourceFile(file) ? program.getImpliedNodeFormatForEmit(file) : getImpliedNodeFormatForEmitWorker(file, program.getCompilerOptions());
@@ -154914,10 +155095,10 @@ registerCodeFix({
     const { errorCode, span } = context;
     const info = errorCodeFixIdMap[errorCode];
     if (!info) return emptyArray;
-    const { descriptions, fixId: fixId54, fixAllDescriptions } = info;
+    const { descriptions, fixId: fixId55, fixAllDescriptions } = info;
     const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => dispatchChanges(changes2, context, errorCode, span.start));
     return [
-      createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId54, fixAllDescriptions)
+      createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId55, fixAllDescriptions)
     ];
   },
   fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId],
@@ -155693,7 +155874,7 @@ registerCodeFix({
   },
   fixIds: [fixMissingMember, fixMissingFunctionDeclaration, fixMissingProperties, fixMissingAttributes],
   getAllCodeActions: (context) => {
-    const { program, fixId: fixId54 } = context;
+    const { program, fixId: fixId55 } = context;
     const checker = program.getTypeChecker();
     const seen = /* @__PURE__ */ new Map();
     const typeDeclToMembers = /* @__PURE__ */ new Map();
@@ -155703,11 +155884,11 @@ registerCodeFix({
         if (!info || !addToSeen(seen, getNodeId(info.parentDeclaration) + "#" + (info.kind === 3 /* ObjectLiteral */ ? info.identifier : info.token.text))) {
           return;
         }
-        if (fixId54 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
+        if (fixId55 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
           addFunctionDeclaration(changes, context, info);
-        } else if (fixId54 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
+        } else if (fixId55 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
           addObjectLiteralProperties(changes, context, info);
-        } else if (fixId54 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
+        } else if (fixId55 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
           addJsxAttributes(changes, context, info);
         } else {
           if (info.kind === 1 /* Enum */) {
@@ -157578,20 +157759,20 @@ registerCodeFix({
       actions2.push(fix(type, fixIdNullable, Diagnostics.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types));
     }
     return actions2;
-    function fix(type2, fixId54, fixAllDescription) {
+    function fix(type2, fixId55, fixAllDescription) {
       const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, typeNode, type2, checker));
-      return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId54, fixAllDescription);
+      return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId55, fixAllDescription);
     }
   },
   fixIds: [fixIdPlain, fixIdNullable],
   getAllCodeActions(context) {
-    const { fixId: fixId54, program, sourceFile } = context;
+    const { fixId: fixId55, program, sourceFile } = context;
     const checker = program.getTypeChecker();
     return codeFixAll(context, errorCodes45, (changes, err) => {
       const info = getInfo15(err.file, err.start, checker);
       if (!info) return;
       const { typeNode, type } = info;
-      const fixedType = typeNode.kind === 314 /* JSDocNullableType */ && fixId54 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
+      const fixedType = typeNode.kind === 314 /* JSDocNullableType */ && fixId55 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
       doChange29(changes, sourceFile, typeNode, fixedType, checker);
     });
   }
@@ -177031,6 +177212,79 @@ var SmartIndenter;
   }
 })(SmartIndenter || (SmartIndenter = {}));
 
+// src/services/_namespaces/ts.PasteEdits.ts
+var ts_PasteEdits_exports = {};
+__export(ts_PasteEdits_exports, {
+  pasteEditsProvider: () => pasteEditsProvider
+});
+
+// src/services/pasteEdits.ts
+var fixId54 = "providePostPasteEdits";
+function pasteEditsProvider(targetFile, pastedText, pasteLocations, copiedFrom, host, preferences, formatContext, cancellationToken) {
+  const changes = ts_textChanges_exports.ChangeTracker.with({ host, formatContext, preferences }, (changeTracker) => pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, preferences, formatContext, cancellationToken, changeTracker));
+  return { edits: changes, fixId: fixId54 };
+}
+function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, preferences, formatContext, cancellationToken, changes) {
+  let actualPastedText;
+  if (pastedText.length !== pasteLocations.length) {
+    actualPastedText = pastedText.length === 1 ? pastedText : [pastedText.join("\n")];
+  }
+  pasteLocations.forEach((paste, i) => {
+    changes.replaceRangeWithText(
+      targetFile,
+      { pos: paste.pos, end: paste.end },
+      actualPastedText ? actualPastedText[0] : pastedText[i]
+    );
+  });
+  const statements = [];
+  let newText = targetFile.text;
+  for (let i = pasteLocations.length - 1; i >= 0; i--) {
+    const { pos, end } = pasteLocations[i];
+    newText = actualPastedText ? newText.slice(0, pos) + actualPastedText[0] + newText.slice(end) : newText.slice(0, pos) + pastedText[i] + newText.slice(end);
+  }
+  Debug.checkDefined(host.runWithTemporaryFileUpdate).call(host, targetFile.fileName, newText, (updatedProgram, originalProgram, updatedFile) => {
+    const importAdder = ts_codefix_exports.createImportAdder(updatedFile, updatedProgram, preferences, host);
+    if (copiedFrom == null ? void 0 : copiedFrom.range) {
+      Debug.assert(copiedFrom.range.length === pastedText.length);
+      copiedFrom.range.forEach((copy) => {
+        addRange(statements, copiedFrom.file.statements, getLineOfLocalPosition(copiedFrom.file, copy.pos), getLineOfLocalPosition(copiedFrom.file, copy.end) + 1);
+      });
+      const usage = getUsageInfo(copiedFrom.file, statements, originalProgram.getTypeChecker(), getExistingLocals(updatedFile, statements, originalProgram.getTypeChecker()));
+      Debug.assertIsDefined(originalProgram);
+      const useEsModuleSyntax = !fileShouldUseJavaScriptRequire(targetFile.fileName, originalProgram, host, !!copiedFrom.file.commonJsModuleIndicator);
+      addExportsInOldFile(copiedFrom.file, usage.targetFileImportsFromOldFile, changes, useEsModuleSyntax);
+      addTargetFileImports(copiedFrom.file, usage.oldImportsNeededByTargetFile, usage.targetFileImportsFromOldFile, originalProgram.getTypeChecker(), updatedProgram, importAdder);
+    } else {
+      const context = {
+        sourceFile: updatedFile,
+        program: originalProgram,
+        cancellationToken,
+        host,
+        preferences,
+        formatContext
+      };
+      forEachChild(updatedFile, function cb(node) {
+        if (isIdentifier(node) && !(originalProgram == null ? void 0 : originalProgram.getTypeChecker().resolveName(
+          node.text,
+          node,
+          -1 /* All */,
+          /*excludeGlobals*/
+          false
+        ))) {
+          importAdder.addImportForUnresolvedIdentifier(
+            context,
+            node,
+            /*useAutoImportProvider*/
+            true
+          );
+        }
+        node.forEachChild(cb);
+      });
+    }
+    importAdder.writeFixes(changes, getQuotePreference(copiedFrom ? copiedFrom.file : targetFile, preferences));
+  });
+}
+
 // src/server/_namespaces/ts.ts
 var ts_exports2 = {};
 __export(ts_exports2, {
@@ -177093,7 +177347,7 @@ __export(ts_exports2, {
   IndexKind: () => IndexKind,
   InferenceFlags: () => InferenceFlags,
   InferencePriority: () => InferencePriority,
-  InlayHintKind: () => InlayHintKind,
+  InlayHintKind: () => InlayHintKind2,
   InlayHints: () => ts_InlayHints_exports,
   InternalEmitFlags: () => InternalEmitFlags,
   InternalSymbolName: () => InternalSymbolName,
@@ -177630,6 +177884,7 @@ __export(ts_exports2, {
   forEachKey: () => forEachKey,
   forEachLeadingCommentRange: () => forEachLeadingCommentRange,
   forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
+  forEachNameOfDefaultExport: () => forEachNameOfDefaultExport,
   forEachPropertyAssignment: () => forEachPropertyAssignment,
   forEachResolvedProjectReference: () => forEachResolvedProjectReference,
   forEachReturnStatement: () => forEachReturnStatement,
@@ -177726,11 +177981,11 @@ __export(ts_exports2, {
   getDeclaredExpandoInitializer: () => getDeclaredExpandoInitializer,
   getDecorators: () => getDecorators,
   getDefaultCompilerOptions: () => getDefaultCompilerOptions2,
-  getDefaultExportInfoWorker: () => getDefaultExportInfoWorker,
   getDefaultFormatCodeSettings: () => getDefaultFormatCodeSettings,
   getDefaultLibFileName: () => getDefaultLibFileName,
   getDefaultLibFilePath: () => getDefaultLibFilePath,
   getDefaultLikeExportInfo: () => getDefaultLikeExportInfo,
+  getDefaultLikeExportNameFromDeclaration: () => getDefaultLikeExportNameFromDeclaration,
   getDefaultResolutionModeForFileWorker: () => getDefaultResolutionModeForFileWorker,
   getDiagnosticText: () => getDiagnosticText,
   getDiagnosticsWithinSpan: () => getDiagnosticsWithinSpan,
@@ -178065,6 +178320,7 @@ __export(ts_exports2, {
   getSwitchedType: () => getSwitchedType,
   getSymbolId: () => getSymbolId,
   getSymbolNameForPrivateIdentifier: () => getSymbolNameForPrivateIdentifier,
+  getSymbolParentOrFail: () => getSymbolParentOrFail,
   getSymbolTarget: () => getSymbolTarget,
   getSyntacticClassifications: () => getSyntacticClassifications,
   getSyntacticModifierFlags: () => getSyntacticModifierFlags,
@@ -178929,7 +179185,9 @@ __export(ts_exports2, {
   moduleResolutionOptionDeclarations: () => moduleResolutionOptionDeclarations,
   moduleResolutionSupportsPackageJsonExportsAndImports: () => moduleResolutionSupportsPackageJsonExportsAndImports,
   moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
+  moduleSpecifierToValidIdentifier: () => moduleSpecifierToValidIdentifier,
   moduleSpecifiers: () => ts_moduleSpecifiers_exports,
+  moduleSymbolToValidIdentifier: () => moduleSymbolToValidIdentifier,
   moveEmitHelpers: () => moveEmitHelpers,
   moveRangeEnd: () => moveRangeEnd,
   moveRangePastDecorators: () => moveRangePastDecorators,
@@ -179009,6 +179267,7 @@ __export(ts_exports2, {
   parsePackageName: () => parsePackageName,
   parsePseudoBigInt: () => parsePseudoBigInt,
   parseValidBigInt: () => parseValidBigInt,
+  pasteEdits: () => ts_PasteEdits_exports,
   patchWriteFileEnsuringDirectory: () => patchWriteFileEnsuringDirectory,
   pathContainsNodeModules: () => pathContainsNodeModules,
   pathIsAbsolute: () => pathIsAbsolute,
@@ -180168,7 +180427,7 @@ __export(ts_server_protocol_exports, {
   NewLineKind: () => NewLineKind2,
   OrganizeImportsMode: () => OrganizeImportsMode,
   PollingWatchKind: () => PollingWatchKind2,
-  ScriptTarget: () => ScriptTarget11,
+  ScriptTarget: () => ScriptTarget10,
   SemicolonPreference: () => SemicolonPreference,
   WatchDirectoryKind: () => WatchDirectoryKind2,
   WatchFileKind: () => WatchFileKind2
@@ -180265,6 +180524,7 @@ var CommandTypes = /* @__PURE__ */ ((CommandTypes2) => {
   CommandTypes2["GetApplicableRefactors"] = "getApplicableRefactors";
   CommandTypes2["GetEditsForRefactor"] = "getEditsForRefactor";
   CommandTypes2["GetMoveToRefactoringFileSuggestions"] = "getMoveToRefactoringFileSuggestions";
+  CommandTypes2["GetPasteEdits"] = "getPasteEdits";
   CommandTypes2["GetEditsForRefactorFull"] = "getEditsForRefactor-full";
   CommandTypes2["OrganizeImports"] = "organizeImports";
   CommandTypes2["OrganizeImportsFull"] = "organizeImports-full";
@@ -180357,24 +180617,24 @@ var NewLineKind2 = /* @__PURE__ */ ((NewLineKind3) => {
   NewLineKind3["Lf"] = "Lf";
   return NewLineKind3;
 })(NewLineKind2 || {});
-var ScriptTarget11 = /* @__PURE__ */ ((ScriptTarget12) => {
-  ScriptTarget12["ES3"] = "es3";
-  ScriptTarget12["ES5"] = "es5";
-  ScriptTarget12["ES6"] = "es6";
-  ScriptTarget12["ES2015"] = "es2015";
-  ScriptTarget12["ES2016"] = "es2016";
-  ScriptTarget12["ES2017"] = "es2017";
-  ScriptTarget12["ES2018"] = "es2018";
-  ScriptTarget12["ES2019"] = "es2019";
-  ScriptTarget12["ES2020"] = "es2020";
-  ScriptTarget12["ES2021"] = "es2021";
-  ScriptTarget12["ES2022"] = "es2022";
-  ScriptTarget12["ES2023"] = "es2023";
-  ScriptTarget12["ESNext"] = "esnext";
-  ScriptTarget12["JSON"] = "json";
-  ScriptTarget12["Latest"] = "esnext" /* ESNext */;
-  return ScriptTarget12;
-})(ScriptTarget11 || {});
+var ScriptTarget10 = /* @__PURE__ */ ((ScriptTarget11) => {
+  ScriptTarget11["ES3"] = "es3";
+  ScriptTarget11["ES5"] = "es5";
+  ScriptTarget11["ES6"] = "es6";
+  ScriptTarget11["ES2015"] = "es2015";
+  ScriptTarget11["ES2016"] = "es2016";
+  ScriptTarget11["ES2017"] = "es2017";
+  ScriptTarget11["ES2018"] = "es2018";
+  ScriptTarget11["ES2019"] = "es2019";
+  ScriptTarget11["ES2020"] = "es2020";
+  ScriptTarget11["ES2021"] = "es2021";
+  ScriptTarget11["ES2022"] = "es2022";
+  ScriptTarget11["ES2023"] = "es2023";
+  ScriptTarget11["ESNext"] = "esnext";
+  ScriptTarget11["JSON"] = "json";
+  ScriptTarget11["Latest"] = "esnext" /* ESNext */;
+  return ScriptTarget11;
+})(ScriptTarget10 || {});
 {
 }
 
@@ -182633,6 +182893,17 @@ var Project3 = class _Project {
     return this.noDtsResolutionProject;
   }
   /** @internal */
+  runWithTemporaryFileUpdate(rootFile, updatedText, cb) {
+    var _a, _b, _c, _d, _e;
+    const originalProgram = this.program;
+    const originalText = (_b = (_a = this.program) == null ? void 0 : _a.getSourceFile(rootFile)) == null ? void 0 : _b.getText();
+    Debug.assert(this.program && this.program.getSourceFile(rootFile) && originalText);
+    (_c = this.getScriptInfo(rootFile)) == null ? void 0 : _c.editContent(0, this.program.getSourceFile(rootFile).getText().length, updatedText);
+    this.updateGraph();
+    cb(this.program, originalProgram, (_d = this.program) == null ? void 0 : _d.getSourceFile(rootFile));
+    (_e = this.getScriptInfo(rootFile)) == null ? void 0 : _e.editContent(0, this.program.getSourceFile(rootFile).getText().length, originalText);
+  }
+  /** @internal */
   getCompilerOptionsForNoDtsResolutionProject() {
     return {
       ...this.getCompilerOptions(),
@@ -187468,7 +187739,8 @@ var invalidPartialSemanticModeCommands = [
   "getEditsForFileRename-full" /* GetEditsForFileRenameFull */,
   "prepareCallHierarchy" /* PrepareCallHierarchy */,
   "provideCallHierarchyIncomingCalls" /* ProvideCallHierarchyIncomingCalls */,
-  "provideCallHierarchyOutgoingCalls" /* ProvideCallHierarchyOutgoingCalls */
+  "provideCallHierarchyOutgoingCalls" /* ProvideCallHierarchyOutgoingCalls */,
+  "getPasteEdits" /* GetPasteEdits */
 ];
 var invalidSyntacticModeCommands = [
   ...invalidPartialSemanticModeCommands,
@@ -188016,6 +188288,9 @@ var Session3 = class _Session {
       ["getMoveToRefactoringFileSuggestions" /* GetMoveToRefactoringFileSuggestions */]: (request) => {
         return this.requiredResponse(this.getMoveToRefactoringFileSuggestions(request.arguments));
       },
+      ["getPasteEdits" /* GetPasteEdits */]: (request) => {
+        return this.requiredResponse(this.getPasteEdits(request.arguments));
+      },
       ["getEditsForRefactor-full" /* GetEditsForRefactorFull */]: (request) => {
         return this.requiredResponse(this.getEditsForRefactor(
           request.arguments,
@@ -189799,6 +190074,21 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
     const scriptInfo = project.getScriptInfoForNormalizedPath(file);
     return project.getLanguageService().getMoveToRefactoringFileSuggestions(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file));
   }
+  getPasteEdits(args) {
+    const { file, project } = this.getFileAndProject(args);
+    const copiedFrom = args.copiedFrom ? { file: args.copiedFrom.file, range: args.copiedFrom.spans.map((copies) => this.getRange({ file: args.copiedFrom.file, startLine: copies.start.line, startOffset: copies.start.offset, endLine: copies.end.line, endOffset: copies.end.offset }, project.getScriptInfoForNormalizedPath(toNormalizedPath(args.copiedFrom.file)))) } : void 0;
+    const result = project.getLanguageService().getPasteEdits(
+      {
+        targetFile: file,
+        pastedText: args.pastedText,
+        pasteLocations: args.pasteLocations.map((paste) => this.getRange({ file, startLine: paste.start.line, startOffset: paste.start.offset, endLine: paste.end.line, endOffset: paste.end.offset }, project.getScriptInfoForNormalizedPath(file))),
+        copiedFrom,
+        preferences: this.getPreferences(file)
+      },
+      this.getFormatOptions(file)
+    );
+    return result && this.mapPasteEditsAction(result);
+  }
   organizeImports(args, simplifiedResult) {
     Debug.assert(args.scope.type === "file");
     const { file, project } = this.getFileAndProject(args.scope.args);
@@ -189865,10 +190155,10 @@ ${e.message}`;
     }
     return simplifiedResult ? codeActions.map((codeAction) => this.mapCodeFixAction(codeAction)) : codeActions;
   }
-  getCombinedCodeFix({ scope, fixId: fixId54 }, simplifiedResult) {
+  getCombinedCodeFix({ scope, fixId: fixId55 }, simplifiedResult) {
     Debug.assert(scope.type === "file");
     const { file, project } = this.getFileAndProject(scope.args);
-    const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId54, this.getFormatOptions(file), this.getPreferences(file));
+    const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId55, this.getFormatOptions(file), this.getPreferences(file));
     if (simplifiedResult) {
       return { changes: this.mapTextChangesToCodeEdits(res.changes), commands: res.commands };
     } else {
@@ -189907,8 +190197,11 @@ ${e.message}`;
   mapCodeAction({ description: description3, changes, commands }) {
     return { description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands };
   }
-  mapCodeFixAction({ fixName: fixName8, description: description3, changes, commands, fixId: fixId54, fixAllDescription }) {
-    return { fixName: fixName8, description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId54, fixAllDescription };
+  mapCodeFixAction({ fixName: fixName8, description: description3, changes, commands, fixId: fixId55, fixAllDescription }) {
+    return { fixName: fixName8, description: description3, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId55, fixAllDescription };
+  }
+  mapPasteEditsAction({ edits, fixId: fixId55 }) {
+    return { edits: this.mapTextChangesToCodeEdits(edits), fixId: fixId55 };
   }
   mapTextChangesToCodeEdits(textChanges2) {
     return textChanges2.map((change) => this.mapTextChangeToCodeEdit(change));
@@ -191933,6 +192226,7 @@ if (typeof console !== "undefined") {
   forEachKey,
   forEachLeadingCommentRange,
   forEachNameInAccessChainWalkingLeft,
+  forEachNameOfDefaultExport,
   forEachPropertyAssignment,
   forEachResolvedProjectReference,
   forEachReturnStatement,
@@ -192029,11 +192323,11 @@ if (typeof console !== "undefined") {
   getDeclaredExpandoInitializer,
   getDecorators,
   getDefaultCompilerOptions,
-  getDefaultExportInfoWorker,
   getDefaultFormatCodeSettings,
   getDefaultLibFileName,
   getDefaultLibFilePath,
   getDefaultLikeExportInfo,
+  getDefaultLikeExportNameFromDeclaration,
   getDefaultResolutionModeForFileWorker,
   getDiagnosticText,
   getDiagnosticsWithinSpan,
@@ -192368,6 +192662,7 @@ if (typeof console !== "undefined") {
   getSwitchedType,
   getSymbolId,
   getSymbolNameForPrivateIdentifier,
+  getSymbolParentOrFail,
   getSymbolTarget,
   getSyntacticClassifications,
   getSyntacticModifierFlags,
@@ -193232,7 +193527,9 @@ if (typeof console !== "undefined") {
   moduleResolutionOptionDeclarations,
   moduleResolutionSupportsPackageJsonExportsAndImports,
   moduleResolutionUsesNodeModules,
+  moduleSpecifierToValidIdentifier,
   moduleSpecifiers,
+  moduleSymbolToValidIdentifier,
   moveEmitHelpers,
   moveRangeEnd,
   moveRangePastDecorators,
@@ -193312,6 +193609,7 @@ if (typeof console !== "undefined") {
   parsePackageName,
   parsePseudoBigInt,
   parseValidBigInt,
+  pasteEdits,
   patchWriteFileEnsuringDirectory,
   pathContainsNodeModules,
   pathIsAbsolute,