@typescript-deploys/pr-build 5.1.0-pr-53980-14 → 5.1.0-pr-54052-7

package/lib/lib.es5.d.ts

@@ -4329,12 +4329,21 @@ interface Float64Array {
     sort(compareFn?: (a: number, b: number) => number): this;
 
     /**
+     * Gets a new Float64Array view of the ArrayBuffer store for this array, referencing the elements
      * at begin, inclusive, up to end, exclusive.
      * @param begin The index of the beginning of the array.
      * @param end The index of the end of the array.
      */
     subarray(begin?: number, end?: number): Float64Array;
 
+    /**
+     * Converts a number to a string by using the current locale.
+     */
+    toLocaleString(): string;
+
+    /**
+     * Returns a string representation of an array.
+     */
     toString(): string;
 
     /** Returns the primitive value of the specified object. */
@@ -4383,11 +4392,12 @@ declare var Float64Array: Float64ArrayConstructor;
 
 declare namespace Intl {
     interface CollatorOptions {
-        usage?: string | undefined;
-        localeMatcher?: string | undefined;
+        usage?: "sort" | "search" | undefined;
+        localeMatcher?: "lookup" | "best fit" | undefined;
         numeric?: boolean | undefined;
-        caseFirst?: string | undefined;
-        sensitivity?: string | undefined;
+        caseFirst?: "upper" | "lower" | "false" | undefined;
+        sensitivity?: "base" | "accent" | "case" | "variant" | undefined;
+        collation?: "big5han" | "compat" | "dict" | "direct" | "ducet" | "emoji" | "eor" | "gb2312" | "phonebk" | "phonetic" | "pinyin" | "reformed" | "searchjl" | "stroke" | "trad" | "unihan" | "zhuyin" | undefined;
         ignorePunctuation?: boolean | undefined;
     }
 

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230424`;
+var version = `${versionMajorMinor}.0-insiders.20230428`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -13734,6 +13734,7 @@ function canHaveJSDoc(node) {
     case 171 /* PropertyDeclaration */:
     case 170 /* PropertySignature */:
     case 252 /* ReturnStatement */:
+    case 239 /* SemicolonClassElement */:
     case 177 /* SetAccessor */:
     case 303 /* ShorthandPropertyAssignment */:
     case 304 /* SpreadAssignment */:
@@ -31102,11 +31103,11 @@ var Parser;
   }
   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,
@@ -43641,13 +43642,14 @@ function createTypeChecker(host) {
     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, isDeprecatedDeclaration) : every(symbol.declarations, isDeprecatedDeclaration);
     }
-    return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
+    return !!symbol.valueDeclaration && isDeprecatedDeclaration(symbol.valueDeclaration) || length(symbol.declarations) && every(symbol.declarations, isDeprecatedDeclaration);
+  }
+  function isDeprecatedDeclaration(declaration) {
+    return !!(getCombinedNodeFlags(declaration) & 268435456 /* Deprecated */);
   }
   function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
     const diagnostic = createDiagnosticForNode(location, Diagnostics._0_is_deprecated, deprecatedEntity);
@@ -49273,7 +49275,7 @@ function createTypeChecker(host) {
         if (symbol.flags & 524288 /* TypeAlias */) {
           serializeTypeAlias(symbol, symbolName2, modifierFlags);
         }
-        if (symbol.flags & (2 /* BlockScopedVariable */ | 1 /* FunctionScopedVariable */ | 4 /* Property */) && symbol.escapedName !== "export=" /* ExportEquals */ && !(symbol.flags & 4194304 /* Prototype */) && !(symbol.flags & 32 /* Class */) && !(symbol.flags & 8192 /* Method */) && !isConstMergedWithNSPrintableAsSignatureMerge) {
+        if (symbol.flags & (2 /* BlockScopedVariable */ | 1 /* FunctionScopedVariable */ | 4 /* Property */ | 98304 /* Accessor */) && symbol.escapedName !== "export=" /* ExportEquals */ && !(symbol.flags & 4194304 /* Prototype */) && !(symbol.flags & 32 /* Class */) && !(symbol.flags & 8192 /* Method */) && !isConstMergedWithNSPrintableAsSignatureMerge) {
           if (propertyAsAlias) {
             const createdExport = serializeMaybeAliasAssignment(symbol);
             if (createdExport) {
@@ -54540,16 +54542,16 @@ function createTypeChecker(host) {
     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);
     }
@@ -61669,7 +61671,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i])) : target;
+    const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i]), 0 /* None */) : target;
     return filtered.flags & 131072 /* Never */ ? target : filtered;
   }
   function isWeakType(type) {
@@ -65807,7 +65809,7 @@ function createTypeChecker(host) {
       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);
     }
@@ -67236,18 +67238,10 @@ function createTypeChecker(host) {
   function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) {
     const managedSym = getJsxLibraryManagedAttributes(ns);
     if (managedSym) {
-      const declaredManagedType = getDeclaredTypeOfSymbol(managedSym);
       const ctorType = getStaticTypeOfReferencedJsxConstructor(context);
-      if (managedSym.flags & 524288 /* TypeAlias */) {
-        const params = getSymbolLinks(managedSym).typeParameters;
-        if (length(params) >= 2) {
-          const args = fillMissingTypeArguments([ctorType, attributesType], params, 2, isInJSFile(context));
-          return getTypeAliasInstantiation(managedSym, args);
-        }
-      }
-      if (length(declaredManagedType.typeParameters) >= 2) {
-        const args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, isInJSFile(context));
-        return createTypeReference(declaredManagedType, args);
+      const result = instantiateAliasOrInterfaceWithDefaults(managedSym, isInJSFile(context), ctorType, attributesType);
+      if (result) {
+        return result;
       }
     }
     return attributesType;
@@ -68134,6 +68128,9 @@ function createTypeChecker(host) {
   function getJsxLibraryManagedAttributes(jsxNamespace) {
     return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968 /* Type */);
   }
+  function getJsxElementTypeSymbol(jsxNamespace) {
+    return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.ElementType, 788968 /* Type */);
+  }
   function getJsxElementPropertiesName(jsxNamespace) {
     return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
   }
@@ -68240,11 +68237,32 @@ function createTypeChecker(host) {
     }
   }
   function getJsxElementTypeTypeAt(location) {
-    const type = getJsxType(JsxNames.ElementType, location);
-    if (isErrorType(type))
+    const ns = getJsxNamespaceAt(location);
+    if (!ns)
+      return void 0;
+    const sym = getJsxElementTypeSymbol(ns);
+    if (!sym)
+      return void 0;
+    const type = instantiateAliasOrInterfaceWithDefaults(sym, isInJSFile(location));
+    if (!type || isErrorType(type))
       return void 0;
     return type;
   }
+  function instantiateAliasOrInterfaceWithDefaults(managedSym, inJs, ...typeArguments) {
+    const declaredManagedType = getDeclaredTypeOfSymbol(managedSym);
+    if (managedSym.flags & 524288 /* TypeAlias */) {
+      const params = getSymbolLinks(managedSym).typeParameters;
+      if (length(params) >= typeArguments.length) {
+        const args = fillMissingTypeArguments(typeArguments, params, typeArguments.length, inJs);
+        return length(args) === 0 ? declaredManagedType : getTypeAliasInstantiation(managedSym, args);
+      }
+    }
+    if (length(declaredManagedType.typeParameters) >= typeArguments.length) {
+      const args = fillMissingTypeArguments(typeArguments, declaredManagedType.typeParameters, typeArguments.length, inJs);
+      return createTypeReference(declaredManagedType, args);
+    }
+    return void 0;
+  }
   function getJsxIntrinsicTagNamesAt(location) {
     const intrinsics = getJsxType(JsxNames.IntrinsicElements, location);
     return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray;
@@ -68795,8 +68813,9 @@ function createTypeChecker(host) {
         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));
@@ -79072,19 +79091,17 @@ function createTypeChecker(host) {
         }
       }
       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;
@@ -79094,7 +79111,7 @@ function createTypeChecker(host) {
         if (target === targetSymbol)
           break;
         if (target.declarations && length(target.declarations)) {
-          if (isDeprecatedAliasedSymbol(target)) {
+          if (isDeprecatedSymbol(target)) {
             addDeprecatedSuggestion(location, target.declarations, target.escapedName);
             break;
           } else {
@@ -101396,12 +101413,56 @@ function transformModule(context) {
         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);
     }
@@ -101412,7 +101473,11 @@ function transformModule(context) {
     }
     switch (node.kind) {
       case 247 /* ForStatement */:
-        return visitForStatement(node);
+        return visitForStatement(
+          node,
+          /*isTopLevel*/
+          false
+        );
       case 243 /* ExpressionStatement */:
         return visitExpressionStatement(node);
       case 216 /* ParenthesizedExpression */:
@@ -101497,15 +101562,177 @@ function transformModule(context) {
     }
     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,
@@ -102298,25 +102525,33 @@ function transformModule(context) {
     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;
@@ -103425,6 +103660,8 @@ function transformSystemModule(context) {
         return visitLabeledStatement(node);
       case 253 /* WithStatement */:
         return visitWithStatement(node);
+      case 244 /* IfStatement */:
+        return visitIfStatement(node);
       case 254 /* SwitchStatement */:
         return visitSwitchStatement(node);
       case 268 /* CaseBlock */:
@@ -103530,6 +103767,14 @@ function transformSystemModule(context) {
       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,
@@ -119615,7 +119860,9 @@ var WatchType = {
   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"
 };
 function createWatchFactory(host, options) {
   const watchLogLevel = host.trace ? options.extendedDiagnostics ? 2 /* Verbose */ : options.diagnostics ? 1 /* TriggerOnly */ : 0 /* None */ : 0 /* None */;