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

package/lib/typescript.d.ts

@@ -550,7 +550,7 @@ declare namespace ts {
     interface FlowContainer extends Node {
         _flowContainerBrand: any;
     }
-    type HasJSDoc = AccessorDeclaration | ArrowFunction | BinaryExpression | Block | BreakStatement | CallSignatureDeclaration | CaseClause | ClassLikeDeclaration | ClassStaticBlockDeclaration | ConstructorDeclaration | ConstructorTypeNode | ConstructSignatureDeclaration | ContinueStatement | DebuggerStatement | DoStatement | ElementAccessExpression | EmptyStatement | EndOfFileToken | EnumDeclaration | EnumMember | ExportAssignment | ExportDeclaration | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeNode | Identifier | IfStatement | ImportDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | InterfaceDeclaration | JSDocFunctionType | JSDocSignature | LabeledStatement | MethodDeclaration | MethodSignature | ModuleDeclaration | NamedTupleMember | NamespaceExportDeclaration | ObjectLiteralExpression | ParameterDeclaration | ParenthesizedExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | PropertySignature | ReturnStatement | ShorthandPropertyAssignment | SpreadAssignment | SwitchStatement | ThrowStatement | TryStatement | TypeAliasDeclaration | TypeParameterDeclaration | VariableDeclaration | VariableStatement | WhileStatement | WithStatement;
+    type HasJSDoc = AccessorDeclaration | ArrowFunction | BinaryExpression | Block | BreakStatement | CallSignatureDeclaration | CaseClause | ClassLikeDeclaration | ClassStaticBlockDeclaration | ConstructorDeclaration | ConstructorTypeNode | ConstructSignatureDeclaration | ContinueStatement | DebuggerStatement | DoStatement | ElementAccessExpression | EmptyStatement | EndOfFileToken | EnumDeclaration | EnumMember | ExportAssignment | ExportDeclaration | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeNode | Identifier | IfStatement | ImportDeclaration | ImportEqualsDeclaration | IndexSignatureDeclaration | InterfaceDeclaration | JSDocFunctionType | JSDocSignature | LabeledStatement | MethodDeclaration | MethodSignature | ModuleDeclaration | NamedTupleMember | NamespaceExportDeclaration | ObjectLiteralExpression | ParameterDeclaration | ParenthesizedExpression | PropertyAccessExpression | PropertyAssignment | PropertyDeclaration | PropertySignature | ReturnStatement | SemicolonClassElement | ShorthandPropertyAssignment | SpreadAssignment | SwitchStatement | ThrowStatement | TryStatement | TypeAliasDeclaration | TypeParameterDeclaration | VariableDeclaration | VariableStatement | WhileStatement | WithStatement;
     type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType;
     type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement;
     type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;
@@ -829,7 +829,7 @@ declare namespace ts {
         readonly body?: FunctionBody | undefined;
     }
     /** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */
-    interface SemicolonClassElement extends ClassElement {
+    interface SemicolonClassElement extends ClassElement, JSDocContainer {
         readonly kind: SyntaxKind.SemicolonClassElement;
         readonly parent: ClassLikeDeclaration;
     }
@@ -5893,8 +5893,9 @@ declare namespace ts {
         type EventBeginInstallTypes = "event::beginInstallTypes";
         type EventEndInstallTypes = "event::endInstallTypes";
         type EventInitializationFailed = "event::initializationFailed";
+        type ActionWatchTypingLocations = "action::watchTypingLocations";
         interface TypingInstallerResponse {
-            readonly kind: ActionSet | ActionInvalidate | EventTypesRegistry | ActionPackageInstalled | EventBeginInstallTypes | EventEndInstallTypes | EventInitializationFailed;
+            readonly kind: ActionSet | ActionInvalidate | EventTypesRegistry | ActionPackageInstalled | EventBeginInstallTypes | EventEndInstallTypes | EventInitializationFailed | ActionWatchTypingLocations;
         }
         interface TypingInstallerRequestWithProjectName {
             readonly projectName: string;
@@ -5903,7 +5904,6 @@ declare namespace ts {
             readonly fileNames: string[];
             readonly projectRootPath: Path;
             readonly compilerOptions: CompilerOptions;
-            readonly watchOptions?: WatchOptions;
             readonly typeAcquisition: TypeAcquisition;
             readonly unresolvedImports: SortedReadonlyArray<string>;
             readonly cachePath?: string;
@@ -5955,8 +5955,6 @@ declare namespace ts {
             writeFile(path: string, content: string): void;
             createDirectory(path: string): void;
             getCurrentDirectory?(): string;
-            watchFile?(path: string, callback: FileWatcherCallback, pollingInterval?: number, options?: WatchOptions): FileWatcher;
-            watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean, options?: WatchOptions): FileWatcher;
         }
         interface SetTypings extends ProjectResponse {
             readonly typeAcquisition: TypeAcquisition;
@@ -5965,6 +5963,11 @@ declare namespace ts {
             readonly unresolvedImports: SortedReadonlyArray<string>;
             readonly kind: ActionSet;
         }
+        interface WatchTypingLocations extends ProjectResponse {
+            /** if files is undefined, retain same set of watchers */
+            readonly files: readonly string[] | undefined;
+            readonly kind: ActionWatchTypingLocations;
+        }
     }
     function getDefaultFormatCodeSettings(newLineCharacter?: string): FormatCodeSettings;
     /**

package/lib/typescript.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";
@@ -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;
@@ -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";
@@ -126155,6 +126385,7 @@ ${lanes.join("\n")}
     ActionInvalidate: () => ActionInvalidate,
     ActionPackageInstalled: () => ActionPackageInstalled,
     ActionSet: () => ActionSet,
+    ActionWatchTypingLocations: () => ActionWatchTypingLocations,
     Arguments: () => Arguments,
     EventBeginInstallTypes: () => EventBeginInstallTypes,
     EventEndInstallTypes: () => EventEndInstallTypes,