typescript 5.1.0-dev.20230424 → 5.1.0-dev.20230426

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-dev.20230424`;
+var version = `${versionMajorMinor}.0-dev.20230426`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -49273,7 +49273,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) {
@@ -67228,18 +67228,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;
@@ -68126,6 +68118,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);
   }
@@ -68232,11 +68227,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;
@@ -103417,6 +103433,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 */:
@@ -103522,6 +103540,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,

package/lib/tsserver.js

@@ -2303,7 +2303,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230424`;
+var version = `${versionMajorMinor}.0-dev.20230426`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -53923,7 +53923,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) {
@@ -71878,18 +71878,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;
@@ -72776,6 +72768,9 @@ function createTypeChecker(host) {
   function getJsxLibraryManagedAttributes(jsxNamespace) {
     return jsxNamespace && getSymbol2(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968 /* Type */);
   }
+  function getJsxElementTypeSymbol(jsxNamespace) {
+    return jsxNamespace && getSymbol2(jsxNamespace.exports, JsxNames.ElementType, 788968 /* Type */);
+  }
   function getJsxElementPropertiesName(jsxNamespace) {
     return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
   }
@@ -72882,11 +72877,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;
@@ -108238,6 +108254,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 */:
@@ -108343,6 +108361,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,

package/lib/tsserverlibrary.d.ts

@@ -8817,6 +8817,26 @@ declare namespace ts {
         parent: ConstructorDeclaration;
         name: Identifier;
     };
+    /**
+     * This function checks multiple locations for JSDoc comments that apply to a host node.
+     * At each location, the whole comment may apply to the node, or only a specific tag in
+     * the comment. In the first case, location adds the entire {@link JSDoc} object. In the
+     * second case, it adds the applicable {@link JSDocTag}.
+     *
+     * For example, a JSDoc comment before a parameter adds the entire {@link JSDoc}. But a
+     * `@param` tag on the parent function only adds the {@link JSDocTag} for the `@param`.
+     *
+     * ```ts
+     * /** JSDoc will be returned for `a` *\/
+     * const a = 0
+     * /**
+     *  * Entire JSDoc will be returned for `b`
+     *  * @param c JSDocTag will be returned for `c`
+     *  *\/
+     * function b(/** JSDoc will be returned for `c` *\/ c) {}
+     * ```
+     */
+    function getJSDocCommentsAndTags(hostNode: Node): readonly (JSDoc | JSDocTag)[];
     /** @deprecated */
     function createUnparsedSourceFile(text: string): UnparsedSource;
     /** @deprecated */

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230424`;
+      version = `${versionMajorMinor}.0-dev.20230426`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -51715,7 +51715,7 @@ ${lanes.join("\n")}
           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) {
@@ -69670,18 +69670,10 @@ ${lanes.join("\n")}
     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;
@@ -70568,6 +70560,9 @@ ${lanes.join("\n")}
     function getJsxLibraryManagedAttributes(jsxNamespace) {
       return jsxNamespace && getSymbol2(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968 /* Type */);
     }
+    function getJsxElementTypeSymbol(jsxNamespace) {
+      return jsxNamespace && getSymbol2(jsxNamespace.exports, JsxNames.ElementType, 788968 /* Type */);
+    }
     function getJsxElementPropertiesName(jsxNamespace) {
       return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
     }
@@ -70674,11 +70669,32 @@ ${lanes.join("\n")}
       }
     }
     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;
@@ -106303,6 +106319,8 @@ ${lanes.join("\n")}
           return visitLabeledStatement(node);
         case 253 /* WithStatement */:
           return visitWithStatement(node);
+        case 244 /* IfStatement */:
+          return visitIfStatement(node);
         case 254 /* SwitchStatement */:
           return visitSwitchStatement(node);
         case 268 /* CaseBlock */:
@@ -106408,6 +106426,14 @@ ${lanes.join("\n")}
         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,

package/lib/typescript.d.ts

@@ -4771,6 +4771,26 @@ declare namespace ts {
         parent: ConstructorDeclaration;
         name: Identifier;
     };
+    /**
+     * This function checks multiple locations for JSDoc comments that apply to a host node.
+     * At each location, the whole comment may apply to the node, or only a specific tag in
+     * the comment. In the first case, location adds the entire {@link JSDoc} object. In the
+     * second case, it adds the applicable {@link JSDocTag}.
+     *
+     * For example, a JSDoc comment before a parameter adds the entire {@link JSDoc}. But a
+     * `@param` tag on the parent function only adds the {@link JSDocTag} for the `@param`.
+     *
+     * ```ts
+     * /** JSDoc will be returned for `a` *\/
+     * const a = 0
+     * /**
+     *  * Entire JSDoc will be returned for `b`
+     *  * @param c JSDocTag will be returned for `c`
+     *  *\/
+     * function b(/** JSDoc will be returned for `c` *\/ c) {}
+     * ```
+     */
+    function getJSDocCommentsAndTags(hostNode: Node): readonly (JSDoc | JSDocTag)[];
     /** @deprecated */
     function createUnparsedSourceFile(text: string): UnparsedSource;
     /** @deprecated */

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230424`;
+      version = `${versionMajorMinor}.0-dev.20230426`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -51715,7 +51715,7 @@ ${lanes.join("\n")}
           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) {
@@ -69670,18 +69670,10 @@ ${lanes.join("\n")}
     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;
@@ -70568,6 +70560,9 @@ ${lanes.join("\n")}
     function getJsxLibraryManagedAttributes(jsxNamespace) {
       return jsxNamespace && getSymbol2(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968 /* Type */);
     }
+    function getJsxElementTypeSymbol(jsxNamespace) {
+      return jsxNamespace && getSymbol2(jsxNamespace.exports, JsxNames.ElementType, 788968 /* Type */);
+    }
     function getJsxElementPropertiesName(jsxNamespace) {
       return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
     }
@@ -70674,11 +70669,32 @@ ${lanes.join("\n")}
       }
     }
     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;
@@ -106303,6 +106319,8 @@ ${lanes.join("\n")}
           return visitLabeledStatement(node);
         case 253 /* WithStatement */:
           return visitWithStatement(node);
+        case 244 /* IfStatement */:
+          return visitIfStatement(node);
         case 254 /* SwitchStatement */:
           return visitSwitchStatement(node);
         case 268 /* CaseBlock */:
@@ -106408,6 +106426,14 @@ ${lanes.join("\n")}
         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,

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230424`;
+var version = `${versionMajorMinor}.0-dev.20230426`;
 
 // src/compiler/core.ts
 var emptyArray = [];

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.1.0-dev.20230424",
+    "version": "5.1.0-dev.20230426",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -115,5 +115,5 @@
         "node": "14.21.1",
         "npm": "8.19.3"
     },
-    "gitHead": "8749fb5c0a4a0e3407eb099322c85b850cc642aa"
+    "gitHead": "eb014a26522dd809ae4d0e85634a62eabda2755a"
 }