typescript 5.1.0-dev.20230426 → 5.1.0-dev.20230428

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230426`;
+      version = `${versionMajorMinor}.0-dev.20230428`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4737,10 +4737,10 @@ ${lanes.join("\n")}
         LanguageVariant4[LanguageVariant4["JSX"] = 1] = "JSX";
         return LanguageVariant4;
       })(LanguageVariant || {});
-      WatchDirectoryFlags = /* @__PURE__ */ ((WatchDirectoryFlags4) => {
-        WatchDirectoryFlags4[WatchDirectoryFlags4["None"] = 0] = "None";
-        WatchDirectoryFlags4[WatchDirectoryFlags4["Recursive"] = 1] = "Recursive";
-        return WatchDirectoryFlags4;
+      WatchDirectoryFlags = /* @__PURE__ */ ((WatchDirectoryFlags3) => {
+        WatchDirectoryFlags3[WatchDirectoryFlags3["None"] = 0] = "None";
+        WatchDirectoryFlags3[WatchDirectoryFlags3["Recursive"] = 1] = "Recursive";
+        return WatchDirectoryFlags3;
       })(WatchDirectoryFlags || {});
       CharacterCodes = /* @__PURE__ */ ((CharacterCodes2) => {
         CharacterCodes2[CharacterCodes2["nullCharacter"] = 0] = "nullCharacter";
@@ -15388,6 +15388,7 @@ ${lanes.join("\n")}
       case 171 /* PropertyDeclaration */:
       case 170 /* PropertySignature */:
       case 252 /* ReturnStatement */:
+      case 239 /* SemicolonClassElement */:
       case 177 /* SetAccessor */:
       case 303 /* ShorthandPropertyAssignment */:
       case 304 /* SpreadAssignment */:
@@ -33583,11 +33584,11 @@ ${lanes.join("\n")}
         }
         function parseClassElement() {
           const pos = getNodePos();
+          const hasJSDoc = hasPrecedingJSDocComment();
           if (token() === 27 /* SemicolonToken */) {
             nextToken();
-            return finishNode(factory2.createSemicolonClassElement(), pos);
+            return withJSDoc(finishNode(factory2.createSemicolonClassElement(), pos), hasJSDoc);
           }
-          const hasJSDoc = hasPrecedingJSDocComment();
           const modifiers = parseModifiers(
             /*allowDecorators*/
             true,
@@ -46083,13 +46084,14 @@ ${lanes.join("\n")}
       return diagnostic;
     }
     function isDeprecatedSymbol(symbol) {
-      if (length(symbol.declarations) > 1) {
-        const parentSymbol = getParentOfSymbol(symbol);
-        if (parentSymbol && parentSymbol.flags & 64 /* Interface */) {
-          return some(symbol.declarations, (d) => !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
-        }
+      const parentSymbol = getParentOfSymbol(symbol);
+      if (parentSymbol && length(symbol.declarations) > 1) {
+        return parentSymbol.flags & 64 /* Interface */ ? some(symbol.declarations, isDeprecatedDeclaration2) : every(symbol.declarations, isDeprecatedDeclaration2);
       }
-      return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
+      return !!symbol.valueDeclaration && isDeprecatedDeclaration2(symbol.valueDeclaration) || length(symbol.declarations) && every(symbol.declarations, isDeprecatedDeclaration2);
+    }
+    function isDeprecatedDeclaration2(declaration) {
+      return !!(getCombinedNodeFlags(declaration) & 268435456 /* Deprecated */);
     }
     function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
       const diagnostic = createDiagnosticForNode(location, Diagnostics._0_is_deprecated, deprecatedEntity);
@@ -56982,16 +56984,16 @@ ${lanes.join("\n")}
       if (declaration.kind === 175 /* Constructor */) {
         return getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol));
       }
+      const typeNode = getEffectiveReturnTypeNode(declaration);
       if (isJSDocSignature(declaration)) {
         const root = getJSDocRoot(declaration);
-        if (root && isConstructorDeclaration(root.parent)) {
+        if (root && isConstructorDeclaration(root.parent) && !typeNode) {
           return getDeclaredTypeOfClassOrInterface(getMergedSymbol(root.parent.parent.symbol));
         }
       }
       if (isJSDocConstructSignature(declaration)) {
         return getTypeFromTypeNode(declaration.parameters[0].type);
       }
-      const typeNode = getEffectiveReturnTypeNode(declaration);
       if (typeNode) {
         return getTypeFromTypeNode(typeNode);
       }
@@ -68249,7 +68251,7 @@ ${lanes.join("\n")}
         markAliasReferenced(symbol, node);
       }
       const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
-      const targetSymbol = checkDeprecatedAliasedSymbol(localOrExportSymbol, node);
+      const targetSymbol = resolveAliasWithDeprecationCheck(localOrExportSymbol, node);
       if (isDeprecatedSymbol(targetSymbol) && isUncalledFunctionReference(node, targetSymbol) && targetSymbol.declarations) {
         addDeprecatedSuggestion(node, targetSymbol.declarations, node.escapedText);
       }
@@ -69418,6 +69420,7 @@ ${lanes.join("\n")}
       );
     }
     function discriminateContextualTypeByJSXAttributes(node, contextualType) {
+      const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
       return discriminateTypeByDiscriminableItems(
         contextualType,
         concatenate(
@@ -69428,7 +69431,14 @@ ${lanes.join("\n")}
           map(
             filter(getPropertiesOfType(contextualType), (s) => {
               var _a;
-              return !!(s.flags & 16777216 /* Optional */) && !!((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
+              if (!(s.flags & 16777216 /* Optional */) || !((_a = node == null ? void 0 : node.symbol) == null ? void 0 : _a.members)) {
+                return false;
+              }
+              const element = node.parent.parent;
+              if (s.escapedName === jsxChildrenPropertyName && isJsxElement(element) && getSemanticJsxChildren(element.children).length) {
+                return false;
+              }
+              return !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
             }),
             (s) => [() => undefinedType, s.escapedName]
           )
@@ -71245,8 +71255,9 @@ ${lanes.join("\n")}
           addDeprecatedSuggestion(right, [indexInfo.declaration], right.escapedText);
         }
       } else {
-        if (isDeprecatedSymbol(prop) && isUncalledFunctionReference(node, prop) && prop.declarations) {
-          addDeprecatedSuggestion(right, prop.declarations, right.escapedText);
+        const targetPropSymbol = resolveAliasWithDeprecationCheck(prop, right);
+        if (isDeprecatedSymbol(targetPropSymbol) && isUncalledFunctionReference(node, targetPropSymbol) && targetPropSymbol.declarations) {
+          addDeprecatedSuggestion(right, targetPropSymbol.declarations, right.escapedText);
         }
         checkPropertyNotUsedBeforeDeclaration(prop, node, right);
         markPropertyAsReferenced(prop, node, isSelfTypeAccess(left, parentSymbol));
@@ -81522,19 +81533,17 @@ ${lanes.join("\n")}
           }
         }
         if (isImportSpecifier(node)) {
-          const targetSymbol = checkDeprecatedAliasedSymbol(symbol, node);
-          if (isDeprecatedAliasedSymbol(targetSymbol) && targetSymbol.declarations) {
+          const targetSymbol = resolveAliasWithDeprecationCheck(symbol, node);
+          if (isDeprecatedSymbol(targetSymbol) && targetSymbol.declarations) {
             addDeprecatedSuggestion(node, targetSymbol.declarations, targetSymbol.escapedName);
           }
         }
       }
     }
-    function isDeprecatedAliasedSymbol(symbol) {
-      return !!symbol.declarations && every(symbol.declarations, (d) => !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
-    }
-    function checkDeprecatedAliasedSymbol(symbol, location) {
-      if (!(symbol.flags & 2097152 /* Alias */))
+    function resolveAliasWithDeprecationCheck(symbol, location) {
+      if (!(symbol.flags & 2097152 /* Alias */) || isDeprecatedSymbol(symbol) || !getDeclarationOfAliasSymbol(symbol)) {
         return symbol;
+      }
       const targetSymbol = resolveAlias(symbol);
       if (targetSymbol === unknownSymbol)
         return targetSymbol;
@@ -81544,7 +81553,7 @@ ${lanes.join("\n")}
           if (target === targetSymbol)
             break;
           if (target.declarations && length(target.declarations)) {
-            if (isDeprecatedAliasedSymbol(target)) {
+            if (isDeprecatedSymbol(target)) {
               addDeprecatedSuggestion(location, target.declarations, target.escapedName);
               break;
             } else {
@@ -104283,12 +104292,56 @@ ${lanes.join("\n")}
           return visitExportDeclaration(node);
         case 276 /* ExportAssignment */:
           return visitExportAssignment(node);
+        case 261 /* FunctionDeclaration */:
+          return visitFunctionDeclaration(node);
+        case 262 /* ClassDeclaration */:
+          return visitClassDeclaration(node);
+        default:
+          return topLevelNestedVisitor(node);
+      }
+    }
+    function topLevelNestedVisitor(node) {
+      switch (node.kind) {
         case 242 /* VariableStatement */:
           return visitVariableStatement(node);
         case 261 /* FunctionDeclaration */:
           return visitFunctionDeclaration(node);
         case 262 /* ClassDeclaration */:
           return visitClassDeclaration(node);
+        case 247 /* ForStatement */:
+          return visitForStatement(
+            node,
+            /*isTopLevel*/
+            true
+          );
+        case 248 /* ForInStatement */:
+          return visitForInStatement(node);
+        case 249 /* ForOfStatement */:
+          return visitForOfStatement(node);
+        case 245 /* DoStatement */:
+          return visitDoStatement(node);
+        case 246 /* WhileStatement */:
+          return visitWhileStatement(node);
+        case 255 /* LabeledStatement */:
+          return visitLabeledStatement(node);
+        case 253 /* WithStatement */:
+          return visitWithStatement(node);
+        case 244 /* IfStatement */:
+          return visitIfStatement(node);
+        case 254 /* SwitchStatement */:
+          return visitSwitchStatement(node);
+        case 268 /* CaseBlock */:
+          return visitCaseBlock(node);
+        case 295 /* CaseClause */:
+          return visitCaseClause(node);
+        case 296 /* DefaultClause */:
+          return visitDefaultClause(node);
+        case 257 /* TryStatement */:
+          return visitTryStatement(node);
+        case 298 /* CatchClause */:
+          return visitCatchClause(node);
+        case 240 /* Block */:
+          return visitBlock(node);
         default:
           return visitor(node);
       }
@@ -104299,7 +104352,11 @@ ${lanes.join("\n")}
       }
       switch (node.kind) {
         case 247 /* ForStatement */:
-          return visitForStatement(node);
+          return visitForStatement(
+            node,
+            /*isTopLevel*/
+            false
+          );
         case 243 /* ExpressionStatement */:
           return visitExpressionStatement(node);
         case 216 /* ParenthesizedExpression */:
@@ -104384,15 +104441,177 @@ ${lanes.join("\n")}
       }
       return visitEachChild(node, visitor, context);
     }
-    function visitForStatement(node) {
+    function visitForStatement(node, isTopLevel) {
+      if (isTopLevel && node.initializer && isVariableDeclarationList(node.initializer) && !(node.initializer.flags & 3 /* BlockScoped */)) {
+        const exportStatements = appendExportsOfVariableDeclarationList(
+          /*statements*/
+          void 0,
+          node.initializer,
+          /*isForInOrOfInitializer*/
+          false
+        );
+        if (exportStatements) {
+          const statements = [];
+          const varDeclList = visitNode(node.initializer, discardedValueVisitor, isVariableDeclarationList);
+          const varStatement = factory2.createVariableStatement(
+            /*modifiers*/
+            void 0,
+            varDeclList
+          );
+          statements.push(varStatement);
+          addRange(statements, exportStatements);
+          const condition = visitNode(node.condition, visitor, isExpression);
+          const incrementor = visitNode(node.incrementor, discardedValueVisitor, isExpression);
+          const body = visitIterationBody(node.statement, isTopLevel ? topLevelNestedVisitor : visitor, context);
+          statements.push(factory2.updateForStatement(
+            node,
+            /*initializer*/
+            void 0,
+            condition,
+            incrementor,
+            body
+          ));
+          return statements;
+        }
+      }
       return factory2.updateForStatement(
         node,
         visitNode(node.initializer, discardedValueVisitor, isForInitializer),
         visitNode(node.condition, visitor, isExpression),
         visitNode(node.incrementor, discardedValueVisitor, isExpression),
-        visitIterationBody(node.statement, visitor, context)
+        visitIterationBody(node.statement, isTopLevel ? topLevelNestedVisitor : visitor, context)
+      );
+    }
+    function visitForInStatement(node) {
+      if (isVariableDeclarationList(node.initializer) && !(node.initializer.flags & 3 /* BlockScoped */)) {
+        const exportStatements = appendExportsOfVariableDeclarationList(
+          /*statements*/
+          void 0,
+          node.initializer,
+          /*isForInOrOfInitializer*/
+          true
+        );
+        if (some(exportStatements)) {
+          const initializer = visitNode(node.initializer, discardedValueVisitor, isForInitializer);
+          const expression = visitNode(node.expression, visitor, isExpression);
+          const body = visitIterationBody(node.statement, topLevelNestedVisitor, context);
+          const mergedBody = isBlock(body) ? factory2.updateBlock(body, [...exportStatements, ...body.statements]) : factory2.createBlock(
+            [...exportStatements, body],
+            /*multiLine*/
+            true
+          );
+          return factory2.updateForInStatement(node, initializer, expression, mergedBody);
+        }
+      }
+      return factory2.updateForInStatement(
+        node,
+        visitNode(node.initializer, discardedValueVisitor, isForInitializer),
+        visitNode(node.expression, visitor, isExpression),
+        visitIterationBody(node.statement, topLevelNestedVisitor, context)
+      );
+    }
+    function visitForOfStatement(node) {
+      if (isVariableDeclarationList(node.initializer) && !(node.initializer.flags & 3 /* BlockScoped */)) {
+        const exportStatements = appendExportsOfVariableDeclarationList(
+          /*statements*/
+          void 0,
+          node.initializer,
+          /*isForInOrOfInitializer*/
+          true
+        );
+        const initializer = visitNode(node.initializer, discardedValueVisitor, isForInitializer);
+        const expression = visitNode(node.expression, visitor, isExpression);
+        let body = visitIterationBody(node.statement, topLevelNestedVisitor, context);
+        if (some(exportStatements)) {
+          body = isBlock(body) ? factory2.updateBlock(body, [...exportStatements, ...body.statements]) : factory2.createBlock(
+            [...exportStatements, body],
+            /*multiLine*/
+            true
+          );
+        }
+        return factory2.updateForOfStatement(node, node.awaitModifier, initializer, expression, body);
+      }
+      return factory2.updateForOfStatement(
+        node,
+        node.awaitModifier,
+        visitNode(node.initializer, discardedValueVisitor, isForInitializer),
+        visitNode(node.expression, visitor, isExpression),
+        visitIterationBody(node.statement, topLevelNestedVisitor, context)
+      );
+    }
+    function visitDoStatement(node) {
+      return factory2.updateDoStatement(
+        node,
+        visitIterationBody(node.statement, topLevelNestedVisitor, context),
+        visitNode(node.expression, visitor, isExpression)
+      );
+    }
+    function visitWhileStatement(node) {
+      return factory2.updateWhileStatement(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        visitIterationBody(node.statement, topLevelNestedVisitor, context)
+      );
+    }
+    function visitLabeledStatement(node) {
+      return factory2.updateLabeledStatement(
+        node,
+        node.label,
+        Debug.checkDefined(visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock))
+      );
+    }
+    function visitWithStatement(node) {
+      return factory2.updateWithStatement(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        Debug.checkDefined(visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock))
+      );
+    }
+    function visitIfStatement(node) {
+      return factory2.updateIfStatement(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        Debug.checkDefined(visitNode(node.thenStatement, topLevelNestedVisitor, isStatement, factory2.liftToBlock)),
+        visitNode(node.elseStatement, topLevelNestedVisitor, isStatement, factory2.liftToBlock)
+      );
+    }
+    function visitSwitchStatement(node) {
+      return factory2.updateSwitchStatement(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        Debug.checkDefined(visitNode(node.caseBlock, topLevelNestedVisitor, isCaseBlock))
+      );
+    }
+    function visitCaseBlock(node) {
+      return factory2.updateCaseBlock(
+        node,
+        visitNodes2(node.clauses, topLevelNestedVisitor, isCaseOrDefaultClause)
+      );
+    }
+    function visitCaseClause(node) {
+      return factory2.updateCaseClause(
+        node,
+        visitNode(node.expression, visitor, isExpression),
+        visitNodes2(node.statements, topLevelNestedVisitor, isStatement)
+      );
+    }
+    function visitDefaultClause(node) {
+      return visitEachChild(node, topLevelNestedVisitor, context);
+    }
+    function visitTryStatement(node) {
+      return visitEachChild(node, topLevelNestedVisitor, context);
+    }
+    function visitCatchClause(node) {
+      return factory2.updateCatchClause(
+        node,
+        node.variableDeclaration,
+        Debug.checkDefined(visitNode(node.block, topLevelNestedVisitor, isBlock))
       );
     }
+    function visitBlock(node) {
+      node = visitEachChild(node, topLevelNestedVisitor, context);
+      return node;
+    }
     function visitExpressionStatement(node) {
       return factory2.updateExpressionStatement(
         node,
@@ -105185,25 +105404,33 @@ ${lanes.join("\n")}
       return appendExportsOfDeclaration(statements, decl);
     }
     function appendExportsOfVariableStatement(statements, node) {
+      return appendExportsOfVariableDeclarationList(
+        statements,
+        node.declarationList,
+        /*isForInOrOfInitializer*/
+        false
+      );
+    }
+    function appendExportsOfVariableDeclarationList(statements, node, isForInOrOfInitializer) {
       if (currentModuleInfo.exportEquals) {
         return statements;
       }
-      for (const decl of node.declarationList.declarations) {
-        statements = appendExportsOfBindingElement(statements, decl);
+      for (const decl of node.declarations) {
+        statements = appendExportsOfBindingElement(statements, decl, isForInOrOfInitializer);
       }
       return statements;
     }
-    function appendExportsOfBindingElement(statements, decl) {
+    function appendExportsOfBindingElement(statements, decl, isForInOrOfInitializer) {
       if (currentModuleInfo.exportEquals) {
         return statements;
       }
       if (isBindingPattern(decl.name)) {
         for (const element of decl.name.elements) {
           if (!isOmittedExpression(element)) {
-            statements = appendExportsOfBindingElement(statements, element);
+            statements = appendExportsOfBindingElement(statements, element, isForInOrOfInitializer);
           }
         }
-      } else if (!isGeneratedIdentifier(decl.name) && (!isVariableDeclaration(decl) || decl.initializer)) {
+      } else if (!isGeneratedIdentifier(decl.name) && (!isVariableDeclaration(decl) || decl.initializer || isForInOrOfInitializer)) {
         statements = appendExportsOfDeclaration(statements, decl);
       }
       return statements;
@@ -115429,7 +115656,7 @@ ${lanes.join("\n")}
     }
     return program.isEmittedFile(file);
   }
-  function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo3) {
+  function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo2) {
     setSysLog(watchLogLevel === 2 /* Verbose */ ? log : noop);
     const plainInvokeFactory = {
       watchFile: (file, callback, pollingInterval, options) => host.watchFile(file, callback, pollingInterval, options),
@@ -115467,23 +115694,23 @@ ${lanes.join("\n")}
       return typeof host.useCaseSensitiveFileNames === "boolean" ? host.useCaseSensitiveFileNames : host.useCaseSensitiveFileNames();
     }
     function createExcludeWatcherWithLogging(file, flags, options, detailInfo1, detailInfo2) {
-      log(`ExcludeWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3)}`);
+      log(`ExcludeWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`);
       return {
-        close: () => log(`ExcludeWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3)}`)
+        close: () => log(`ExcludeWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`)
       };
     }
     function createFileWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) {
-      log(`FileWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3)}`);
+      log(`FileWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`);
       const watcher = triggerInvokingFactory.watchFile(file, cb, flags, options, detailInfo1, detailInfo2);
       return {
         close: () => {
-          log(`FileWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3)}`);
+          log(`FileWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`);
           watcher.close();
         }
       };
     }
     function createDirectoryWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) {
-      const watchInfo = `DirectoryWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3)}`;
+      const watchInfo = `DirectoryWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
       log(watchInfo);
       const start = timestamp();
       const watcher = triggerInvokingFactory.watchDirectory(file, cb, flags, options, detailInfo1, detailInfo2);
@@ -115491,7 +115718,7 @@ ${lanes.join("\n")}
       log(`Elapsed:: ${elapsed}ms ${watchInfo}`);
       return {
         close: () => {
-          const watchInfo2 = `DirectoryWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3)}`;
+          const watchInfo2 = `DirectoryWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
           log(watchInfo2);
           const start2 = timestamp();
           watcher.close();
@@ -115506,7 +115733,7 @@ ${lanes.join("\n")}
         void 0,
         file,
         (...args) => {
-          const triggerredInfo = `${key === "watchFile" ? "FileWatcher" : "DirectoryWatcher"}:: Triggered with ${args[0]} ${args[1] !== void 0 ? args[1] : ""}:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3)}`;
+          const triggerredInfo = `${key === "watchFile" ? "FileWatcher" : "DirectoryWatcher"}:: Triggered with ${args[0]} ${args[1] !== void 0 ? args[1] : ""}:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
           log(triggerredInfo);
           const start = timestamp();
           cb.call(
@@ -115523,8 +115750,8 @@ ${lanes.join("\n")}
         detailInfo2
       );
     }
-    function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo4) {
-      return `WatchInfo: ${file} ${flags} ${JSON.stringify(options)} ${getDetailWatchInfo4 ? getDetailWatchInfo4(detailInfo1, detailInfo2) : detailInfo2 === void 0 ? detailInfo1 : `${detailInfo1} ${detailInfo2}`}`;
+    function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3) {
+      return `WatchInfo: ${file} ${flags} ${JSON.stringify(options)} ${getDetailWatchInfo3 ? getDetailWatchInfo3(detailInfo1, detailInfo2) : detailInfo2 === void 0 ? detailInfo1 : `${detailInfo1} ${detailInfo2}`}`;
     }
   }
   function getFallbackOptions(options) {
@@ -122901,7 +123128,9 @@ ${lanes.join("\n")}
         MissingSourceMapFile: "Missing source map file",
         NoopConfigFileForInferredRoot: "Noop Config file for the inferred project root",
         MissingGeneratedFile: "Missing generated file",
-        NodeModulesForModuleSpecifierCache: "node_modules for module specifier cache invalidation"
+        NodeModulesForModuleSpecifierCache: "node_modules for module specifier cache invalidation",
+        TypingInstallerLocationFile: "File location for typing installer",
+        TypingInstallerLocationDirectory: "Directory location for typing installer"
       };
     }
   });
@@ -126118,7 +126347,7 @@ ${lanes.join("\n")}
     const d = /* @__PURE__ */ new Date();
     return `${padLeft(d.getHours().toString(), 2, "0")}:${padLeft(d.getMinutes().toString(), 2, "0")}:${padLeft(d.getSeconds().toString(), 2, "0")}.${padLeft(d.getMilliseconds().toString(), 3, "0")}`;
   }
-  var ActionSet, ActionInvalidate, ActionPackageInstalled, EventTypesRegistry, EventBeginInstallTypes, EventEndInstallTypes, EventInitializationFailed, Arguments;
+  var ActionSet, ActionInvalidate, ActionPackageInstalled, EventTypesRegistry, EventBeginInstallTypes, EventEndInstallTypes, EventInitializationFailed, ActionWatchTypingLocations, Arguments;
   var init_shared = __esm({
     "src/jsTyping/shared.ts"() {
       "use strict";
@@ -126130,6 +126359,7 @@ ${lanes.join("\n")}
       EventBeginInstallTypes = "event::beginInstallTypes";
       EventEndInstallTypes = "event::endInstallTypes";
       EventInitializationFailed = "event::initializationFailed";
+      ActionWatchTypingLocations = "action::watchTypingLocations";
       ((Arguments2) => {
         Arguments2.GlobalCacheLocation = "--globalTypingsCacheLocation";
         Arguments2.LogFile = "--logFile";
@@ -168972,19 +169202,6 @@ ${options.prefix}` : "\n" : options.prefix
     }
     return { command, remaining: remaining - toSlice };
   }
-  function endsWith2(str, suffix, caseSensitive) {
-    const expectedPos = str.length - suffix.length;
-    return expectedPos >= 0 && (str.indexOf(suffix, expectedPos) === expectedPos || !caseSensitive && compareStringsCaseInsensitive(str.substr(expectedPos), suffix) === 0 /* EqualTo */);
-  }
-  function isPackageOrBowerJson(fileName, caseSensitive) {
-    return endsWith2(fileName, "/package.json", caseSensitive) || endsWith2(fileName, "/bower.json", caseSensitive);
-  }
-  function sameFiles(a, b, caseSensitive) {
-    return a === b || !caseSensitive && compareStringsCaseInsensitive(a, b) === 0 /* EqualTo */;
-  }
-  function getDetailWatchInfo(projectName, watchers) {
-    return `Project: ${projectName} watcher already invoked: ${watchers == null ? void 0 : watchers.isInvoked}`;
-  }
   function typingsName(packageName) {
     return `@types/${packageName}@ts${versionMajorMinor}`;
   }
@@ -169015,13 +169232,10 @@ ${options.prefix}` : "\n" : options.prefix
           this.installRunCount = 1;
           this.inFlightRequestCount = 0;
           this.latestDistTag = "latest";
-          this.toCanonicalFileName = createGetCanonicalFileName(installTypingHost.useCaseSensitiveFileNames);
-          this.globalCachePackageJsonPath = combinePaths(globalCachePath, "package.json");
           const isLoggingEnabled = this.log.isEnabled();
           if (isLoggingEnabled) {
             this.log.writeLine(`Global cache location '${globalCachePath}', safe file path '${safeListPath}', types map path ${typesMapLocation}`);
           }
-          this.watchFactory = getWatchFactory(this.installTypingHost, isLoggingEnabled ? 2 /* Verbose */ : 0 /* None */, (s) => this.log.writeLine(s), getDetailWatchInfo);
           this.processCacheLocation(this.globalCachePath);
         }
         closeProject(req) {
@@ -169038,8 +169252,8 @@ ${options.prefix}` : "\n" : options.prefix
             }
             return;
           }
-          clearMap(watchers, closeFileWatcher);
           this.projectWatchers.delete(projectName);
+          this.sendResponse({ kind: ActionWatchTypingLocations, projectName, files: [] });
           if (this.log.isEnabled()) {
             this.log.writeLine(`Closing file watchers for project '${projectName}' - done.`);
           }
@@ -169072,7 +169286,7 @@ ${options.prefix}` : "\n" : options.prefix
           if (this.log.isEnabled()) {
             this.log.writeLine(`Finished typings discovery: ${JSON.stringify(discoverTypingsResult)}`);
           }
-          this.watchFiles(req.projectName, discoverTypingsResult.filesToWatch, req.projectRootPath, req.watchOptions);
+          this.watchFiles(req.projectName, discoverTypingsResult.filesToWatch);
           if (discoverTypingsResult.newTypingNames.length) {
             this.installTypings(req, req.cachePath || this.globalCachePath, discoverTypingsResult.cachedTypingPaths, discoverTypingsResult.newTypingNames);
           } else {
@@ -169273,75 +169487,19 @@ ${options.prefix}` : "\n" : options.prefix
             host.createDirectory(directory);
           }
         }
-        watchFiles(projectName, files, projectRootPath, options) {
+        watchFiles(projectName, files) {
           if (!files.length) {
             this.closeWatchers(projectName);
             return;
           }
-          let watchers = this.projectWatchers.get(projectName);
-          const toRemove = /* @__PURE__ */ new Map();
-          if (!watchers) {
-            watchers = /* @__PURE__ */ new Map();
-            this.projectWatchers.set(projectName, watchers);
+          const existing = this.projectWatchers.get(projectName);
+          const newSet = new Set(files);
+          if (!existing || forEachKey(newSet, (s) => !existing.has(s)) || forEachKey(existing, (s) => !newSet.has(s))) {
+            this.projectWatchers.set(projectName, newSet);
+            this.sendResponse({ kind: ActionWatchTypingLocations, projectName, files });
           } else {
-            copyEntries(watchers, toRemove);
+            this.sendResponse({ kind: ActionWatchTypingLocations, projectName, files: void 0 });
           }
-          watchers.isInvoked = false;
-          const isLoggingEnabled = this.log.isEnabled();
-          const createProjectWatcher = (path, projectWatcherType) => {
-            const canonicalPath = this.toCanonicalFileName(path);
-            toRemove.delete(canonicalPath);
-            if (watchers.has(canonicalPath)) {
-              return;
-            }
-            if (isLoggingEnabled) {
-              this.log.writeLine(`${projectWatcherType}:: Added:: WatchInfo: ${path}`);
-            }
-            const watcher = projectWatcherType === "FileWatcher" /* FileWatcher */ ? this.watchFactory.watchFile(path, () => {
-              if (!watchers.isInvoked) {
-                watchers.isInvoked = true;
-                this.sendResponse({ projectName, kind: ActionInvalidate });
-              }
-            }, 2e3 /* High */, options, projectName, watchers) : this.watchFactory.watchDirectory(path, (f) => {
-              if (watchers.isInvoked || !fileExtensionIs(f, ".json" /* Json */)) {
-                return;
-              }
-              if (isPackageOrBowerJson(f, this.installTypingHost.useCaseSensitiveFileNames) && !sameFiles(f, this.globalCachePackageJsonPath, this.installTypingHost.useCaseSensitiveFileNames)) {
-                watchers.isInvoked = true;
-                this.sendResponse({ projectName, kind: ActionInvalidate });
-              }
-            }, 1 /* Recursive */, options, projectName, watchers);
-            watchers.set(canonicalPath, isLoggingEnabled ? {
-              close: () => {
-                this.log.writeLine(`${projectWatcherType}:: Closed:: WatchInfo: ${path}`);
-                watcher.close();
-              }
-            } : watcher);
-          };
-          for (const file of files) {
-            if (file.endsWith("/package.json") || file.endsWith("/bower.json")) {
-              createProjectWatcher(file, "FileWatcher" /* FileWatcher */);
-              continue;
-            }
-            if (containsPath(projectRootPath, file, projectRootPath, !this.installTypingHost.useCaseSensitiveFileNames)) {
-              const subDirectory = file.indexOf(directorySeparator, projectRootPath.length + 1);
-              if (subDirectory !== -1) {
-                createProjectWatcher(file.substr(0, subDirectory), "DirectoryWatcher" /* DirectoryWatcher */);
-              } else {
-                createProjectWatcher(file, "DirectoryWatcher" /* DirectoryWatcher */);
-              }
-              continue;
-            }
-            if (containsPath(this.globalCachePath, file, projectRootPath, !this.installTypingHost.useCaseSensitiveFileNames)) {
-              createProjectWatcher(this.globalCachePath, "DirectoryWatcher" /* DirectoryWatcher */);
-              continue;
-            }
-            createProjectWatcher(file, "DirectoryWatcher" /* DirectoryWatcher */);
-          }
-          toRemove.forEach((watch, path) => {
-            watch.close();
-            watchers.delete(path);
-          });
         }
         createSetTypings(request, typings) {
           return {
@@ -169414,7 +169572,6 @@ ${options.prefix}` : "\n" : options.prefix
         true
       ).concat(project.getExcludedFiles()),
       compilerOptions: project.getCompilationSettings(),
-      watchOptions: project.projectService.getWatchOptions(project),
       typeAcquisition,
       unresolvedImports,
       projectRootPath: project.getCurrentDirectory(),
@@ -171126,6 +171283,8 @@ ${options.prefix}` : "\n" : options.prefix
           return path === options.configFilePath ? options.configFile : this.getSourceFile(path);
         }
         close() {
+          this.projectService.typingsCache.onProjectClosed(this);
+          this.closeWatchingTypingLocations();
           if (this.program) {
             for (const f of this.program.getSourceFiles()) {
               this.detachScriptInfoIfNotRoot(f.fileName);
@@ -171416,6 +171575,89 @@ ${options.prefix}` : "\n" : options.prefix
           }
         }
         /** @internal */
+        closeWatchingTypingLocations() {
+          if (this.typingWatchers)
+            clearMap(this.typingWatchers, closeFileWatcher);
+          this.typingWatchers = void 0;
+        }
+        /** @internal */
+        onTypingInstallerWatchInvoke() {
+          this.typingWatchers.isInvoked = true;
+          this.projectService.updateTypingsForProject({ projectName: this.getProjectName(), kind: ActionInvalidate });
+        }
+        /** @internal */
+        watchTypingLocations(files) {
+          if (!files) {
+            this.typingWatchers.isInvoked = false;
+            return;
+          }
+          if (!files.length) {
+            this.closeWatchingTypingLocations();
+            return;
+          }
+          const toRemove = new Map(this.typingWatchers);
+          if (!this.typingWatchers)
+            this.typingWatchers = /* @__PURE__ */ new Map();
+          this.typingWatchers.isInvoked = false;
+          const createProjectWatcher = (path, typingsWatcherType) => {
+            const canonicalPath = this.toPath(path);
+            toRemove.delete(canonicalPath);
+            if (!this.typingWatchers.has(canonicalPath)) {
+              this.typingWatchers.set(
+                canonicalPath,
+                typingsWatcherType === "FileWatcher" /* FileWatcher */ ? this.projectService.watchFactory.watchFile(
+                  path,
+                  () => !this.typingWatchers.isInvoked ? this.onTypingInstallerWatchInvoke() : this.writeLog(`TypingWatchers already invoked`),
+                  2e3 /* High */,
+                  this.projectService.getWatchOptions(this),
+                  WatchType.TypingInstallerLocationFile,
+                  this
+                ) : this.projectService.watchFactory.watchDirectory(
+                  path,
+                  (f) => {
+                    if (this.typingWatchers.isInvoked)
+                      return this.writeLog(`TypingWatchers already invoked`);
+                    if (!fileExtensionIs(f, ".json" /* Json */))
+                      return this.writeLog(`Ignoring files that are not *.json`);
+                    if (comparePaths(f, combinePaths(this.projectService.typingsInstaller.globalTypingsCacheLocation, "package.json"), !this.useCaseSensitiveFileNames()))
+                      return this.writeLog(`Ignoring package.json change at global typings location`);
+                    this.onTypingInstallerWatchInvoke();
+                  },
+                  1 /* Recursive */,
+                  this.projectService.getWatchOptions(this),
+                  WatchType.TypingInstallerLocationDirectory,
+                  this
+                )
+              );
+            }
+          };
+          for (const file of files) {
+            const basename = getBaseFileName(file);
+            if (basename === "package.json" || basename === "bower.json") {
+              createProjectWatcher(file, "FileWatcher" /* FileWatcher */);
+              continue;
+            }
+            if (containsPath(this.currentDirectory, file, this.currentDirectory, !this.useCaseSensitiveFileNames())) {
+              const subDirectory = file.indexOf(directorySeparator, this.currentDirectory.length + 1);
+              if (subDirectory !== -1) {
+                createProjectWatcher(file.substr(0, subDirectory), "DirectoryWatcher" /* DirectoryWatcher */);
+              } else {
+                createProjectWatcher(file, "DirectoryWatcher" /* DirectoryWatcher */);
+              }
+              continue;
+            }
+            if (containsPath(this.projectService.typingsInstaller.globalTypingsCacheLocation, file, this.currentDirectory, !this.useCaseSensitiveFileNames())) {
+              createProjectWatcher(this.projectService.typingsInstaller.globalTypingsCacheLocation, "DirectoryWatcher" /* DirectoryWatcher */);
+              continue;
+            }
+            createProjectWatcher(file, "DirectoryWatcher" /* DirectoryWatcher */);
+          }
+          toRemove.forEach((watch, path) => {
+            watch.close();
+            this.typingWatchers.delete(path);
+          });
+        }
+        /** @internal */
         getCurrentProgram() {
           return this.program;
         }
@@ -172865,7 +173107,7 @@ ${options.prefix}` : "\n" : options.prefix
       (potentialProjectRef) => callbackRefProject(project, cb, potentialProjectRef)
     );
   }
-  function getDetailWatchInfo2(watchType, project) {
+  function getDetailWatchInfo(watchType, project) {
     return `${isString(project) ? `Config: ${project} ` : project ? `Project: ${project.getProjectName()} ` : ""}WatchType: ${watchType}`;
   }
   function isScriptInfoWatchedFromNodeModules(info) {
@@ -173130,7 +173372,7 @@ ${options.prefix}` : "\n" : options.prefix
           this.watchFactory = this.serverMode !== 0 /* Semantic */ ? {
             watchFile: returnNoopFileWatcher,
             watchDirectory: returnNoopFileWatcher
-          } : getWatchFactory(this.host, watchLogLevel, log, getDetailWatchInfo2);
+          } : getWatchFactory(this.host, watchLogLevel, log, getDetailWatchInfo);
         }
         toPath(fileName) {
           return toPath(fileName, this.currentDirectory, this.toCanonicalFileName);
@@ -173216,6 +173458,11 @@ ${options.prefix}` : "\n" : options.prefix
           }
         }
         /** @internal */
+        watchTypingLocations(response) {
+          var _a;
+          (_a = this.findProject(response.projectName)) == null ? void 0 : _a.watchTypingLocations(response.files);
+        }
+        /** @internal */
         delayEnsureProjectForOpenFiles() {
           if (!this.openFiles.size)
             return;
@@ -178955,7 +179202,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         getApplicableRefactors(args) {
           const { file, project } = this.getFileAndProject(args);
           const scriptInfo = project.getScriptInfoForNormalizedPath(file);
-          return project.getLanguageService().getApplicableRefactors(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file), args.triggerReason, args.kind);
+          return project.getLanguageService().getApplicableRefactors(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file), args.triggerReason, args.kind, args.includeInteractiveActions);
         }
         getEditsForRefactor(args, simplifiedResult) {
           const { file, project } = this.getFileAndProject(args);
@@ -180179,6 +180426,7 @@ ${e.message}`;
     ActionInvalidate: () => ActionInvalidate,
     ActionPackageInstalled: () => ActionPackageInstalled,
     ActionSet: () => ActionSet,
+    ActionWatchTypingLocations: () => ActionWatchTypingLocations,
     Arguments: () => Arguments,
     AutoImportProviderProject: () => AutoImportProviderProject,
     CharRangeSection: () => CharRangeSection,
@@ -182568,6 +182816,7 @@ ${e.message}`;
     ActionInvalidate: () => ActionInvalidate,
     ActionPackageInstalled: () => ActionPackageInstalled,
     ActionSet: () => ActionSet,
+    ActionWatchTypingLocations: () => ActionWatchTypingLocations,
     Arguments: () => Arguments,
     AutoImportProviderProject: () => AutoImportProviderProject,
     CharRangeSection: () => CharRangeSection,