typescript 5.1.0-dev.20230412 → 5.1.0-dev.20230413

package/lib/lib.es2022.intl.d.ts

@@ -106,4 +106,13 @@ declare namespace Intl {
          */
         supportedLocalesOf(locales: BCP47LanguageTag | BCP47LanguageTag[], options?: Pick<SegmenterOptions, "localeMatcher">): BCP47LanguageTag[];
     };
+
+    /**
+     * Returns a sorted array of the supported collation, calendar, currency, numbering system, timezones, and units by the implementation.
+     * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf)
+     *
+     * @param key A string indicating the category of values to return.
+     * @returns A sorted array of the supported values.
+     */
+    function supportedValuesOf(key: "calendar" | "collation" | "currency" | "numberingSystem" | "timeZone" | "unit"): string[];
 }

package/lib/lib.es5.d.ts

@@ -332,9 +332,14 @@ interface CallableFunction extends Function {
     /**
      * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
      * @param thisArg The object to be used as the this object.
-     * @param args An array of argument values to be passed to the function.
      */
     apply<T, R>(this: (this: T) => R, thisArg: T): R;
+
+    /**
+     * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
+     * @param thisArg The object to be used as the this object.
+     * @param args An array of argument values to be passed to the function.
+     */
     apply<T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg: T, args: A): R;
 
     /**
@@ -348,23 +353,29 @@ interface CallableFunction extends Function {
      * For a given function, creates a bound function that has the same body as the original function.
      * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
      * @param thisArg The object to be used as the this object.
-     * @param args Arguments to bind to the parameters of the function.
      */
     bind<T>(this: T, thisArg: ThisParameterType<T>): OmitThisParameter<T>;
-    bind<T, A0, A extends any[], R>(this: (this: T, arg0: A0, ...args: A) => R, thisArg: T, arg0: A0): (...args: A) => R;
-    bind<T, A0, A1, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1): (...args: A) => R;
-    bind<T, A0, A1, A2, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2): (...args: A) => R;
-    bind<T, A0, A1, A2, A3, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3): (...args: A) => R;
-    bind<T, AX, R>(this: (this: T, ...args: AX[]) => R, thisArg: T, ...args: AX[]): (...args: AX[]) => R;
+
+    /**
+     * For a given function, creates a bound function that has the same body as the original function.
+     * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
+     * @param thisArg The object to be used as the this object.
+     * @param args Arguments to bind to the parameters of the function.
+     */
+    bind<T, A extends any[], B extends any[], R>(this: (this: T, ...args: [...A, ...B]) => R, thisArg: T, ...args: A): (...args: B) => R;
 }
 
 interface NewableFunction extends Function {
     /**
      * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
      * @param thisArg The object to be used as the this object.
-     * @param args An array of argument values to be passed to the function.
      */
     apply<T>(this: new () => T, thisArg: T): void;
+    /**
+     * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
+     * @param thisArg The object to be used as the this object.
+     * @param args An array of argument values to be passed to the function.
+     */
     apply<T, A extends any[]>(this: new (...args: A) => T, thisArg: T, args: A): void;
 
     /**
@@ -378,14 +389,16 @@ interface NewableFunction extends Function {
      * For a given function, creates a bound function that has the same body as the original function.
      * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
      * @param thisArg The object to be used as the this object.
-     * @param args Arguments to bind to the parameters of the function.
      */
     bind<T>(this: T, thisArg: any): T;
-    bind<A0, A extends any[], R>(this: new (arg0: A0, ...args: A) => R, thisArg: any, arg0: A0): new (...args: A) => R;
-    bind<A0, A1, A extends any[], R>(this: new (arg0: A0, arg1: A1, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1): new (...args: A) => R;
-    bind<A0, A1, A2, A extends any[], R>(this: new (arg0: A0, arg1: A1, arg2: A2, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1, arg2: A2): new (...args: A) => R;
-    bind<A0, A1, A2, A3, A extends any[], R>(this: new (arg0: A0, arg1: A1, arg2: A2, arg3: A3, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1, arg2: A2, arg3: A3): new (...args: A) => R;
-    bind<AX, R>(this: new (...args: AX[]) => R, thisArg: any, ...args: AX[]): new (...args: AX[]) => R;
+
+    /**
+     * For a given function, creates a bound function that has the same body as the original function.
+     * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
+     * @param thisArg The object to be used as the this object.
+     * @param args Arguments to bind to the parameters of the function.
+     */
+    bind<A extends any[], B extends any[], R>(this: new (...args: [...A, ...B]) => R, thisArg: any, ...args: A): new (...args: B) => R;
 }
 
 interface IArguments {

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.20230412`;
+var version = `${versionMajorMinor}.0-dev.20230413`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -44749,11 +44749,6 @@ function createTypeChecker(host) {
         diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);
       } else if (result.flags & 256 /* RegularEnum */) {
         diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-      } else {
-        Debug.assert(!!(result.flags & 128 /* ConstEnum */));
-        if (shouldPreserveConstEnums(compilerOptions)) {
-          diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-        }
       }
       if (diagnosticMessage) {
         addRelatedInfo(
@@ -61581,40 +61576,31 @@ function createTypeChecker(host) {
     return getPropertiesOfType(type).filter((targetProp) => containsMissingType(getTypeOfSymbol(targetProp)));
   }
   function getBestMatchingType(source, target, isRelatedTo = compareTypesAssignable) {
-    return findMatchingDiscriminantType(
-      source,
-      target,
-      isRelatedTo,
-      /*skipPartial*/
-      true
-    ) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
+    return findMatchingDiscriminantType(source, target, isRelatedTo) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
   }
-  function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) {
-    const discriminable = target.types.map((_) => void 0);
+  function discriminateTypeByDiscriminableItems(target, discriminators, related) {
+    const types = target.types;
+    const include = types.map((t) => t.flags & 402784252 /* Primitive */ ? 0 /* False */ : -1 /* True */);
     for (const [getDiscriminatingType, propertyName] of discriminators) {
-      const targetProp = getUnionOrIntersectionProperty(target, propertyName);
-      if (skipPartial && targetProp && getCheckFlags(targetProp) & 16 /* ReadPartial */) {
-        continue;
+      let matched = false;
+      for (let i = 0; i < types.length; i++) {
+        if (include[i]) {
+          const targetType = getTypeOfPropertyOfType(types[i], propertyName);
+          if (targetType && related(getDiscriminatingType(), targetType)) {
+            matched = true;
+          } else {
+            include[i] = 3 /* Maybe */;
+          }
+        }
       }
-      let i = 0;
-      for (const type of target.types) {
-        const targetType = getTypeOfPropertyOfType(type, propertyName);
-        if (targetType && related(getDiscriminatingType(), targetType)) {
-          discriminable[i] = discriminable[i] === void 0 ? true : discriminable[i];
-        } else {
-          discriminable[i] = false;
+      for (let i = 0; i < types.length; i++) {
+        if (include[i] === 3 /* Maybe */) {
+          include[i] = matched ? 0 /* False */ : -1 /* True */;
         }
-        i++;
       }
     }
-    const match = discriminable.indexOf(
-      /*searchElement*/
-      true
-    );
-    if (match === -1) {
-      return defaultValue;
-    }
-    return getUnionType(target.types.filter((_, index) => discriminable[index]));
+    const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i])) : target;
+    return filtered.flags & 131072 /* Never */ ? target : filtered;
   }
   function isWeakType(type) {
     if (type.flags & 524288 /* Object */) {
@@ -66918,8 +66904,7 @@ function createTypeChecker(host) {
           (s) => [() => undefinedType, s.escapedName]
         )
       ),
-      isTypeAssignableTo,
-      contextualType
+      isTypeAssignableTo
     );
   }
   function discriminateContextualTypeByJSXAttributes(node, contextualType) {
@@ -66938,8 +66923,7 @@ function createTypeChecker(host) {
           (s) => [() => undefinedType, s.escapedName]
         )
       ),
-      isTypeAssignableTo,
-      contextualType
+      isTypeAssignableTo
     );
   }
   function getApparentTypeOfContextualType(node, contextFlags) {
@@ -82953,7 +82937,7 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
+  function findMatchingDiscriminantType(source, target, isRelatedTo) {
     if (target.flags & 1048576 /* Union */ && source.flags & (2097152 /* Intersection */ | 524288 /* Object */)) {
       const match = getMatchingUnionConstituentForType(target, source);
       if (match) {
@@ -82963,14 +82947,10 @@ function createTypeChecker(host) {
       if (sourceProperties) {
         const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
         if (sourcePropertiesFiltered) {
-          return discriminateTypeByDiscriminableItems(
-            target,
-            map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]),
-            isRelatedTo,
-            /*defaultValue*/
-            void 0,
-            skipPartial
-          );
+          const discriminated = discriminateTypeByDiscriminableItems(target, map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]), isRelatedTo);
+          if (discriminated !== target) {
+            return discriminated;
+          }
         }
       }
     }

package/lib/tsserver.js

@@ -2293,7 +2293,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230412`;
+var version = `${versionMajorMinor}.0-dev.20230413`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -49399,11 +49399,6 @@ function createTypeChecker(host) {
         diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);
       } else if (result.flags & 256 /* RegularEnum */) {
         diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-      } else {
-        Debug.assert(!!(result.flags & 128 /* ConstEnum */));
-        if (shouldPreserveConstEnums(compilerOptions)) {
-          diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-        }
       }
       if (diagnosticMessage) {
         addRelatedInfo(
@@ -66231,40 +66226,31 @@ function createTypeChecker(host) {
     return getPropertiesOfType(type).filter((targetProp) => containsMissingType(getTypeOfSymbol(targetProp)));
   }
   function getBestMatchingType(source, target, isRelatedTo = compareTypesAssignable) {
-    return findMatchingDiscriminantType(
-      source,
-      target,
-      isRelatedTo,
-      /*skipPartial*/
-      true
-    ) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
+    return findMatchingDiscriminantType(source, target, isRelatedTo) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
   }
-  function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) {
-    const discriminable = target.types.map((_) => void 0);
+  function discriminateTypeByDiscriminableItems(target, discriminators, related) {
+    const types = target.types;
+    const include = types.map((t) => t.flags & 402784252 /* Primitive */ ? 0 /* False */ : -1 /* True */);
     for (const [getDiscriminatingType, propertyName] of discriminators) {
-      const targetProp = getUnionOrIntersectionProperty(target, propertyName);
-      if (skipPartial && targetProp && getCheckFlags(targetProp) & 16 /* ReadPartial */) {
-        continue;
+      let matched = false;
+      for (let i = 0; i < types.length; i++) {
+        if (include[i]) {
+          const targetType = getTypeOfPropertyOfType(types[i], propertyName);
+          if (targetType && related(getDiscriminatingType(), targetType)) {
+            matched = true;
+          } else {
+            include[i] = 3 /* Maybe */;
+          }
+        }
       }
-      let i = 0;
-      for (const type of target.types) {
-        const targetType = getTypeOfPropertyOfType(type, propertyName);
-        if (targetType && related(getDiscriminatingType(), targetType)) {
-          discriminable[i] = discriminable[i] === void 0 ? true : discriminable[i];
-        } else {
-          discriminable[i] = false;
+      for (let i = 0; i < types.length; i++) {
+        if (include[i] === 3 /* Maybe */) {
+          include[i] = matched ? 0 /* False */ : -1 /* True */;
         }
-        i++;
       }
     }
-    const match = discriminable.indexOf(
-      /*searchElement*/
-      true
-    );
-    if (match === -1) {
-      return defaultValue;
-    }
-    return getUnionType(target.types.filter((_, index) => discriminable[index]));
+    const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i])) : target;
+    return filtered.flags & 131072 /* Never */ ? target : filtered;
   }
   function isWeakType(type) {
     if (type.flags & 524288 /* Object */) {
@@ -71568,8 +71554,7 @@ function createTypeChecker(host) {
           (s) => [() => undefinedType, s.escapedName]
         )
       ),
-      isTypeAssignableTo,
-      contextualType
+      isTypeAssignableTo
     );
   }
   function discriminateContextualTypeByJSXAttributes(node, contextualType) {
@@ -71588,8 +71573,7 @@ function createTypeChecker(host) {
           (s) => [() => undefinedType, s.escapedName]
         )
       ),
-      isTypeAssignableTo,
-      contextualType
+      isTypeAssignableTo
     );
   }
   function getApparentTypeOfContextualType(node, contextFlags) {
@@ -87603,7 +87587,7 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
+  function findMatchingDiscriminantType(source, target, isRelatedTo) {
     if (target.flags & 1048576 /* Union */ && source.flags & (2097152 /* Intersection */ | 524288 /* Object */)) {
       const match = getMatchingUnionConstituentForType(target, source);
       if (match) {
@@ -87613,14 +87597,10 @@ function createTypeChecker(host) {
       if (sourceProperties) {
         const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
         if (sourcePropertiesFiltered) {
-          return discriminateTypeByDiscriminableItems(
-            target,
-            map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]),
-            isRelatedTo,
-            /*defaultValue*/
-            void 0,
-            skipPartial
-          );
+          const discriminated = discriminateTypeByDiscriminableItems(target, map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]), isRelatedTo);
+          if (discriminated !== target) {
+            return discriminated;
+          }
         }
       }
     }
@@ -128924,7 +128904,13 @@ function findPrecedingToken(position, sourceFile, startNode2, excludeJsdoc) {
             sourceFile,
             n.kind
           );
-          return candidate2 && findRightmostToken(candidate2, sourceFile);
+          if (candidate2) {
+            if (!excludeJsdoc && isJSDocCommentContainingNode(candidate2) && candidate2.getChildren(sourceFile).length) {
+              return find2(candidate2);
+            }
+            return findRightmostToken(candidate2, sourceFile);
+          }
+          return void 0;
         } else {
           return find2(child);
         }

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230412`;
+      version = `${versionMajorMinor}.0-dev.20230413`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -47200,11 +47200,6 @@ ${lanes.join("\n")}
           diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);
         } else if (result.flags & 256 /* RegularEnum */) {
           diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-        } else {
-          Debug.assert(!!(result.flags & 128 /* ConstEnum */));
-          if (shouldPreserveConstEnums(compilerOptions)) {
-            diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-          }
         }
         if (diagnosticMessage) {
           addRelatedInfo(
@@ -64032,40 +64027,31 @@ ${lanes.join("\n")}
       return getPropertiesOfType(type).filter((targetProp) => containsMissingType(getTypeOfSymbol(targetProp)));
     }
     function getBestMatchingType(source, target, isRelatedTo = compareTypesAssignable) {
-      return findMatchingDiscriminantType(
-        source,
-        target,
-        isRelatedTo,
-        /*skipPartial*/
-        true
-      ) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
+      return findMatchingDiscriminantType(source, target, isRelatedTo) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
     }
-    function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) {
-      const discriminable = target.types.map((_) => void 0);
+    function discriminateTypeByDiscriminableItems(target, discriminators, related) {
+      const types = target.types;
+      const include = types.map((t) => t.flags & 402784252 /* Primitive */ ? 0 /* False */ : -1 /* True */);
       for (const [getDiscriminatingType, propertyName] of discriminators) {
-        const targetProp = getUnionOrIntersectionProperty(target, propertyName);
-        if (skipPartial && targetProp && getCheckFlags(targetProp) & 16 /* ReadPartial */) {
-          continue;
+        let matched = false;
+        for (let i = 0; i < types.length; i++) {
+          if (include[i]) {
+            const targetType = getTypeOfPropertyOfType(types[i], propertyName);
+            if (targetType && related(getDiscriminatingType(), targetType)) {
+              matched = true;
+            } else {
+              include[i] = 3 /* Maybe */;
+            }
+          }
         }
-        let i = 0;
-        for (const type of target.types) {
-          const targetType = getTypeOfPropertyOfType(type, propertyName);
-          if (targetType && related(getDiscriminatingType(), targetType)) {
-            discriminable[i] = discriminable[i] === void 0 ? true : discriminable[i];
-          } else {
-            discriminable[i] = false;
+        for (let i = 0; i < types.length; i++) {
+          if (include[i] === 3 /* Maybe */) {
+            include[i] = matched ? 0 /* False */ : -1 /* True */;
           }
-          i++;
         }
       }
-      const match = discriminable.indexOf(
-        /*searchElement*/
-        true
-      );
-      if (match === -1) {
-        return defaultValue;
-      }
-      return getUnionType(target.types.filter((_, index) => discriminable[index]));
+      const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i])) : target;
+      return filtered.flags & 131072 /* Never */ ? target : filtered;
     }
     function isWeakType(type) {
       if (type.flags & 524288 /* Object */) {
@@ -69369,8 +69355,7 @@ ${lanes.join("\n")}
             (s) => [() => undefinedType, s.escapedName]
           )
         ),
-        isTypeAssignableTo,
-        contextualType
+        isTypeAssignableTo
       );
     }
     function discriminateContextualTypeByJSXAttributes(node, contextualType) {
@@ -69389,8 +69374,7 @@ ${lanes.join("\n")}
             (s) => [() => undefinedType, s.escapedName]
           )
         ),
-        isTypeAssignableTo,
-        contextualType
+        isTypeAssignableTo
       );
     }
     function getApparentTypeOfContextualType(node, contextFlags) {
@@ -85404,7 +85388,7 @@ ${lanes.join("\n")}
       }
       return type;
     }
-    function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
+    function findMatchingDiscriminantType(source, target, isRelatedTo) {
       if (target.flags & 1048576 /* Union */ && source.flags & (2097152 /* Intersection */ | 524288 /* Object */)) {
         const match = getMatchingUnionConstituentForType(target, source);
         if (match) {
@@ -85414,14 +85398,10 @@ ${lanes.join("\n")}
         if (sourceProperties) {
           const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
           if (sourcePropertiesFiltered) {
-            return discriminateTypeByDiscriminableItems(
-              target,
-              map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]),
-              isRelatedTo,
-              /*defaultValue*/
-              void 0,
-              skipPartial
-            );
+            const discriminated = discriminateTypeByDiscriminableItems(target, map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]), isRelatedTo);
+            if (discriminated !== target) {
+              return discriminated;
+            }
           }
         }
       }
@@ -127236,7 +127216,13 @@ ${lanes.join("\n")}
               sourceFile,
               n.kind
             );
-            return candidate2 && findRightmostToken(candidate2, sourceFile);
+            if (candidate2) {
+              if (!excludeJsdoc && isJSDocCommentContainingNode(candidate2) && candidate2.getChildren(sourceFile).length) {
+                return find2(candidate2);
+              }
+              return findRightmostToken(candidate2, sourceFile);
+            }
+            return void 0;
           } else {
             return find2(child);
           }

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230412`;
+      version = `${versionMajorMinor}.0-dev.20230413`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -47200,11 +47200,6 @@ ${lanes.join("\n")}
           diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);
         } else if (result.flags & 256 /* RegularEnum */) {
           diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-        } else {
-          Debug.assert(!!(result.flags & 128 /* ConstEnum */));
-          if (shouldPreserveConstEnums(compilerOptions)) {
-            diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-          }
         }
         if (diagnosticMessage) {
           addRelatedInfo(
@@ -64032,40 +64027,31 @@ ${lanes.join("\n")}
       return getPropertiesOfType(type).filter((targetProp) => containsMissingType(getTypeOfSymbol(targetProp)));
     }
     function getBestMatchingType(source, target, isRelatedTo = compareTypesAssignable) {
-      return findMatchingDiscriminantType(
-        source,
-        target,
-        isRelatedTo,
-        /*skipPartial*/
-        true
-      ) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
+      return findMatchingDiscriminantType(source, target, isRelatedTo) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
     }
-    function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) {
-      const discriminable = target.types.map((_) => void 0);
+    function discriminateTypeByDiscriminableItems(target, discriminators, related) {
+      const types = target.types;
+      const include = types.map((t) => t.flags & 402784252 /* Primitive */ ? 0 /* False */ : -1 /* True */);
       for (const [getDiscriminatingType, propertyName] of discriminators) {
-        const targetProp = getUnionOrIntersectionProperty(target, propertyName);
-        if (skipPartial && targetProp && getCheckFlags(targetProp) & 16 /* ReadPartial */) {
-          continue;
+        let matched = false;
+        for (let i = 0; i < types.length; i++) {
+          if (include[i]) {
+            const targetType = getTypeOfPropertyOfType(types[i], propertyName);
+            if (targetType && related(getDiscriminatingType(), targetType)) {
+              matched = true;
+            } else {
+              include[i] = 3 /* Maybe */;
+            }
+          }
         }
-        let i = 0;
-        for (const type of target.types) {
-          const targetType = getTypeOfPropertyOfType(type, propertyName);
-          if (targetType && related(getDiscriminatingType(), targetType)) {
-            discriminable[i] = discriminable[i] === void 0 ? true : discriminable[i];
-          } else {
-            discriminable[i] = false;
+        for (let i = 0; i < types.length; i++) {
+          if (include[i] === 3 /* Maybe */) {
+            include[i] = matched ? 0 /* False */ : -1 /* True */;
           }
-          i++;
         }
       }
-      const match = discriminable.indexOf(
-        /*searchElement*/
-        true
-      );
-      if (match === -1) {
-        return defaultValue;
-      }
-      return getUnionType(target.types.filter((_, index) => discriminable[index]));
+      const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i])) : target;
+      return filtered.flags & 131072 /* Never */ ? target : filtered;
     }
     function isWeakType(type) {
       if (type.flags & 524288 /* Object */) {
@@ -69369,8 +69355,7 @@ ${lanes.join("\n")}
             (s) => [() => undefinedType, s.escapedName]
           )
         ),
-        isTypeAssignableTo,
-        contextualType
+        isTypeAssignableTo
       );
     }
     function discriminateContextualTypeByJSXAttributes(node, contextualType) {
@@ -69389,8 +69374,7 @@ ${lanes.join("\n")}
             (s) => [() => undefinedType, s.escapedName]
           )
         ),
-        isTypeAssignableTo,
-        contextualType
+        isTypeAssignableTo
       );
     }
     function getApparentTypeOfContextualType(node, contextFlags) {
@@ -85404,7 +85388,7 @@ ${lanes.join("\n")}
       }
       return type;
     }
-    function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
+    function findMatchingDiscriminantType(source, target, isRelatedTo) {
       if (target.flags & 1048576 /* Union */ && source.flags & (2097152 /* Intersection */ | 524288 /* Object */)) {
         const match = getMatchingUnionConstituentForType(target, source);
         if (match) {
@@ -85414,14 +85398,10 @@ ${lanes.join("\n")}
         if (sourceProperties) {
           const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
           if (sourcePropertiesFiltered) {
-            return discriminateTypeByDiscriminableItems(
-              target,
-              map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]),
-              isRelatedTo,
-              /*defaultValue*/
-              void 0,
-              skipPartial
-            );
+            const discriminated = discriminateTypeByDiscriminableItems(target, map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]), isRelatedTo);
+            if (discriminated !== target) {
+              return discriminated;
+            }
           }
         }
       }
@@ -127250,7 +127230,13 @@ ${lanes.join("\n")}
               sourceFile,
               n.kind
             );
-            return candidate2 && findRightmostToken(candidate2, sourceFile);
+            if (candidate2) {
+              if (!excludeJsdoc && isJSDocCommentContainingNode(candidate2) && candidate2.getChildren(sourceFile).length) {
+                return find2(candidate2);
+              }
+              return findRightmostToken(candidate2, sourceFile);
+            }
+            return void 0;
           } else {
             return find2(child);
           }

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.20230412`;
+var version = `${versionMajorMinor}.0-dev.20230413`;
 
 // 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.20230412",
+    "version": "5.1.0-dev.20230413",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -113,5 +113,5 @@
         "node": "14.21.1",
         "npm": "8.19.3"
     },
-    "gitHead": "2db688e36ff57ee1d4f730e124ac340379eae4f0"
+    "gitHead": "33ab6fd0d5eceb7715000398382b60d64dde1c67"
 }