@typescript-deploys/pr-build 5.4.0-pr-56939-8 → 5.4.0-pr-56902-8

package/lib/lib.es2018.intl.d.ts

@@ -55,10 +55,22 @@ declare namespace Intl {
 
     const PluralRules: PluralRulesConstructor;
 
-    // We can only have one definition for 'type' in TypeScript, and so you can learn where the keys come from here:
-    type ES2018NumberFormatPartType = "literal" | "nan" | "infinity" | "percent" | "integer" | "group" | "decimal" | "fraction" | "plusSign" | "minusSign" | "percentSign" | "currency" | "code" | "symbol" | "name";
-    type ES2020NumberFormatPartType = "compact" | "exponentInteger" | "exponentMinusSign" | "exponentSeparator" | "unit" | "unknown";
-    type NumberFormatPartTypes = ES2018NumberFormatPartType | ES2020NumberFormatPartType;
+    interface NumberFormatPartTypeRegistry {
+        literal: any;
+        nan: any;
+        infinity: any;
+        percent: any;
+        integer: any;
+        group: any;
+        decimal: any;
+        fraction: any;
+        plusSign: any;
+        minusSign: any;
+        percentSign: any;
+        currency: any;
+    }
+
+    type NumberFormatPartTypes = keyof NumberFormatPartTypeRegistry;
 
     interface NumberFormatPart {
         type: NumberFormatPartTypes;

package/lib/lib.es2020.bigint.d.ts

@@ -723,6 +723,5 @@ interface DataView {
 declare namespace Intl {
     interface NumberFormat {
         format(value: number | bigint): string;
-        resolvedOptions(): ResolvedNumberFormatOptions;
     }
 }

package/lib/lib.es2020.intl.d.ts

@@ -241,24 +241,49 @@ declare namespace Intl {
         ): UnicodeBCP47LocaleIdentifier[];
     };
 
+    interface NumberFormatOptionsStyleRegistry {
+        unit: any;
+    }
+
+    interface NumberFormatOptionsCurrencyDisplayRegistry {
+        narrowSymbol: any;
+    }
+
+    interface NumberFormatOptionsSignDisplayRegistry {
+        auto: any;
+        never: any;
+        always: any;
+        exceptZero: any;
+    }
+
+    type NumberFormatOptionsSignDisplay = keyof NumberFormatOptionsSignDisplayRegistry;
+
     interface NumberFormatOptions {
+        numberingSystem?: string | undefined;
         compactDisplay?: "short" | "long" | undefined;
         notation?: "standard" | "scientific" | "engineering" | "compact" | undefined;
-        signDisplay?: "auto" | "never" | "always" | "exceptZero" | undefined;
+        signDisplay?: NumberFormatOptionsSignDisplay | undefined;
         unit?: string | undefined;
         unitDisplay?: "short" | "long" | "narrow" | undefined;
-        currencyDisplay?: string | undefined;
-        currencySign?: string | undefined;
+        currencySign?: "standard" | "accounting" | undefined;
     }
 
     interface ResolvedNumberFormatOptions {
         compactDisplay?: "short" | "long";
-        notation?: "standard" | "scientific" | "engineering" | "compact";
-        signDisplay?: "auto" | "never" | "always" | "exceptZero";
+        notation: "standard" | "scientific" | "engineering" | "compact";
+        signDisplay: NumberFormatOptionsSignDisplay;
         unit?: string;
         unitDisplay?: "short" | "long" | "narrow";
-        currencyDisplay?: string;
-        currencySign?: string;
+        currencySign?: "standard" | "accounting";
+    }
+
+    interface NumberFormatPartTypeRegistry {
+        compact: any;
+        exponentInteger: any;
+        exponentMinusSign: any;
+        exponentSeparator: any;
+        unit: any;
+        unknown: any;
     }
 
     interface DateTimeFormatOptions {

package/lib/lib.es2023.d.ts

@@ -19,3 +19,4 @@ and limitations under the License.
 /// <reference lib="es2022" />
 /// <reference lib="es2023.array" />
 /// <reference lib="es2023.collection" />
+/// <reference lib="es2023.intl" />

package/lib/lib.es2023.intl.d.ts

@@ -0,0 +1,52 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+    interface NumberFormatOptionsUseGroupingRegistry {
+        min2: any;
+        auto: any;
+        always: any;
+    }
+
+    interface NumberFormatOptionsSignDisplayRegistry {
+        negative: any;
+    }
+
+    interface NumberFormatOptions {
+        roundingPriority?: "auto" | "morePrecision" | "lessPrecision" | undefined;
+        roundingIncrement?: 1 | 2 | 5 | 10 | 20 | 25 | 50 | 100 | 200 | 250 | 500 | 1000 | 2000 | 2500 | 5000 | undefined;
+        roundingMode?: "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven" | undefined;
+        trailingZeroDisplay?: "auto" | "stripIfInteger" | undefined;
+    }
+
+    interface ResolvedNumberFormatOptions {
+        roundingPriority: "auto" | "morePrecision" | "lessPrecision";
+        roundingMode: "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven";
+        roundingIncrement: 1 | 2 | 5 | 10 | 20 | 25 | 50 | 100 | 200 | 250 | 500 | 1000 | 2000 | 2500 | 5000;
+        trailingZeroDisplay: "auto" | "stripIfInteger";
+    }
+
+    interface NumberRangeFormatPart extends NumberFormatPart {
+        source: "startRange" | "endRange" | "shared";
+    }
+
+    interface NumberFormat {
+        formatRange(start: number | bigint, end: number | bigint): string;
+        formatRangeToParts(start: number | bigint, end: number | bigint): NumberRangeFormatPart[];
+    }
+}

package/lib/lib.es5.d.ts

@@ -4427,12 +4427,33 @@ declare namespace Intl {
 
     var Collator: CollatorConstructor;
 
+    interface NumberFormatOptionsStyleRegistry {
+        decimal: any;
+        percent: any;
+        currency: any;
+    }
+
+    type NumberFormatOptionsStyle = keyof NumberFormatOptionsStyleRegistry;
+
+    interface NumberFormatOptionsCurrencyDisplayRegistry {
+        code: any;
+        symbol: any;
+        name: any;
+    }
+
+    type NumberFormatOptionsCurrencyDisplay = keyof NumberFormatOptionsCurrencyDisplayRegistry;
+
+    interface NumberFormatOptionsUseGroupingRegistry {}
+
+    type NumberFormatOptionsUseGrouping = {} extends NumberFormatOptionsUseGroupingRegistry ? boolean : keyof NumberFormatOptionsUseGroupingRegistry | "true" | "false" | boolean;
+    type ResolvedNumberFormatOptionsUseGrouping = {} extends NumberFormatOptionsUseGroupingRegistry ? boolean : keyof NumberFormatOptionsUseGroupingRegistry | false;
+
     interface NumberFormatOptions {
-        localeMatcher?: string | undefined;
-        style?: string | undefined;
+        localeMatcher?: "lookup" | "best fit" | undefined;
+        style?: NumberFormatOptionsStyle | undefined;
         currency?: string | undefined;
-        currencySign?: string | undefined;
-        useGrouping?: boolean | undefined;
+        currencyDisplay?: NumberFormatOptionsCurrencyDisplay | undefined;
+        useGrouping?: NumberFormatOptionsUseGrouping | undefined;
         minimumIntegerDigits?: number | undefined;
         minimumFractionDigits?: number | undefined;
         maximumFractionDigits?: number | undefined;
@@ -4443,14 +4464,15 @@ declare namespace Intl {
     interface ResolvedNumberFormatOptions {
         locale: string;
         numberingSystem: string;
-        style: string;
+        style: NumberFormatOptionsStyle;
         currency?: string;
+        currencyDisplay?: NumberFormatOptionsCurrencyDisplay;
         minimumIntegerDigits: number;
         minimumFractionDigits: number;
         maximumFractionDigits: number;
         minimumSignificantDigits?: number;
         maximumSignificantDigits?: number;
-        useGrouping: boolean;
+        useGrouping: ResolvedNumberFormatOptionsUseGrouping;
     }
 
     interface NumberFormat {

package/lib/lib.esnext.intl.d.ts

@@ -17,12 +17,5 @@ and limitations under the License.
 /// <reference no-default-lib="true"/>
 
 declare namespace Intl {
-    interface NumberRangeFormatPart extends NumberFormatPart {
-        source: "startRange" | "endRange" | "shared";
-    }
-
-    interface NumberFormat {
-        formatRange(start: number | bigint, end: number | bigint): string;
-        formatRangeToParts(start: number | bigint, end: number | bigint): NumberRangeFormatPart[];
-    }
+    // Empty
 }

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20240103`;
+var version = `${versionMajorMinor}.0-insiders.20240104`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -34076,6 +34076,7 @@ var libEntries = [
   ["es2022.regexp", "lib.es2022.regexp.d.ts"],
   ["es2023.array", "lib.es2023.array.d.ts"],
   ["es2023.collection", "lib.es2023.collection.d.ts"],
+  ["es2023.intl", "lib.es2023.intl.d.ts"],
   ["esnext.array", "lib.es2023.array.d.ts"],
   ["esnext.collection", "lib.es2023.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -75732,7 +75733,7 @@ function createTypeChecker(host) {
             const context = getInferenceContext(node);
             const returnType = context.signature && getReturnTypeOfSignature(context.signature);
             const returnSignature = returnType && getSingleCallOrConstructSignature(returnType);
-            if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, (info) => hasInferenceCandidates(info) && info.priority === 0 /* None */)) {
+            if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, hasInferenceCandidates)) {
               const uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
               const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
               const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
@@ -75751,8 +75752,8 @@ function createTypeChecker(host) {
                 applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
                   inferTypes(inferences, source, target);
                 });
-                const merged = tryInferencesMerge(context.inferences, inferences);
-                if (merged) {
+                if (!hasOverlappingInferences(context.inferences, inferences)) {
+                  mergeInferences(context.inferences, inferences);
                   context.inferredTypeParameters = concatenate(context.inferredTypeParameters, uniqueTypeParameters);
                   return getOrCreateTypeFromSignature(instantiatedSignature);
                 }
@@ -75785,17 +75786,12 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function tryInferencesMerge(target, source) {
-    let merged = false;
-    const areOverlapping = hasOverlappingInferences(target, source);
+  function mergeInferences(target, source) {
     for (let i = 0; i < target.length; i++) {
-      if (areOverlapping ? hasInferenceCandidates(source[i]) && hasInferenceCandidates(target[i]) && source[i].priority < (target[i].priority & ~128 /* ReturnType */) : hasInferenceCandidates(source[i])) {
+      if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
         target[i] = source[i];
-        target[i].priority = 0 /* None */;
-        merged = true;
       }
     }
-    return merged;
   }
   function getUniqueTypeParameters(context, typeParameters) {
     const result = [];

package/lib/tsserver.js

@@ -2341,7 +2341,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20240103`;
+var version = `${versionMajorMinor}.0-insiders.20240104`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -38504,6 +38504,7 @@ var libEntries = [
   ["es2022.regexp", "lib.es2022.regexp.d.ts"],
   ["es2023.array", "lib.es2023.array.d.ts"],
   ["es2023.collection", "lib.es2023.collection.d.ts"],
+  ["es2023.intl", "lib.es2023.intl.d.ts"],
   ["esnext.array", "lib.es2023.array.d.ts"],
   ["esnext.collection", "lib.es2023.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -80460,7 +80461,7 @@ function createTypeChecker(host) {
             const context = getInferenceContext(node);
             const returnType = context.signature && getReturnTypeOfSignature(context.signature);
             const returnSignature = returnType && getSingleCallOrConstructSignature(returnType);
-            if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, (info) => hasInferenceCandidates(info) && info.priority === 0 /* None */)) {
+            if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, hasInferenceCandidates)) {
               const uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
               const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
               const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
@@ -80479,8 +80480,8 @@ function createTypeChecker(host) {
                 applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
                   inferTypes(inferences, source, target);
                 });
-                const merged = tryInferencesMerge(context.inferences, inferences);
-                if (merged) {
+                if (!hasOverlappingInferences(context.inferences, inferences)) {
+                  mergeInferences(context.inferences, inferences);
                   context.inferredTypeParameters = concatenate(context.inferredTypeParameters, uniqueTypeParameters);
                   return getOrCreateTypeFromSignature(instantiatedSignature);
                 }
@@ -80513,17 +80514,12 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function tryInferencesMerge(target, source) {
-    let merged = false;
-    const areOverlapping = hasOverlappingInferences(target, source);
+  function mergeInferences(target, source) {
     for (let i = 0; i < target.length; i++) {
-      if (areOverlapping ? hasInferenceCandidates(source[i]) && hasInferenceCandidates(target[i]) && source[i].priority < (target[i].priority & ~128 /* ReturnType */) : hasInferenceCandidates(source[i])) {
+      if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
         target[i] = source[i];
-        target[i].priority = 0 /* None */;
-        merged = true;
       }
     }
-    return merged;
   }
   function getUniqueTypeParameters(context, typeParameters) {
     const result = [];
@@ -147133,13 +147129,14 @@ function getPropertySymbolsFromContextualType(node, checker, contextualType, uni
     const symbol = contextualType.getProperty(name);
     return symbol ? [symbol] : emptyArray;
   }
-  const discriminatedPropertySymbols = mapDefined(contextualType.types, (t) => (isObjectLiteralExpression(node.parent) || isJsxAttributes(node.parent)) && checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent) ? void 0 : t.getProperty(name));
+  const filteredTypes = isObjectLiteralExpression(node.parent) || isJsxAttributes(node.parent) ? filter(contextualType.types, (t) => !checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent)) : contextualType.types;
+  const discriminatedPropertySymbols = mapDefined(filteredTypes, (t) => t.getProperty(name));
   if (unionSymbolOk && (discriminatedPropertySymbols.length === 0 || discriminatedPropertySymbols.length === contextualType.types.length)) {
     const symbol = contextualType.getProperty(name);
     if (symbol)
       return [symbol];
   }
-  if (discriminatedPropertySymbols.length === 0) {
+  if (!filteredTypes.length && !discriminatedPropertySymbols.length) {
     return mapDefined(contextualType.types, (t) => t.getProperty(name));
   }
   return deduplicate(discriminatedPropertySymbols, equateValues);

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-insiders.20240103`;
+      version = `${versionMajorMinor}.0-insiders.20240104`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -37998,6 +37998,7 @@ ${lanes.join("\n")}
         ["es2022.regexp", "lib.es2022.regexp.d.ts"],
         ["es2023.array", "lib.es2023.array.d.ts"],
         ["es2023.collection", "lib.es2023.collection.d.ts"],
+        ["es2023.intl", "lib.es2023.intl.d.ts"],
         ["esnext.array", "lib.es2023.array.d.ts"],
         ["esnext.collection", "lib.es2023.collection.d.ts"],
         ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -78214,7 +78215,7 @@ ${lanes.join("\n")}
               const context = getInferenceContext(node);
               const returnType = context.signature && getReturnTypeOfSignature(context.signature);
               const returnSignature = returnType && getSingleCallOrConstructSignature(returnType);
-              if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, (info) => hasInferenceCandidates(info) && info.priority === 0 /* None */)) {
+              if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, hasInferenceCandidates)) {
                 const uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
                 const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
                 const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
@@ -78233,8 +78234,8 @@ ${lanes.join("\n")}
                   applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
                     inferTypes(inferences, source, target);
                   });
-                  const merged = tryInferencesMerge(context.inferences, inferences);
-                  if (merged) {
+                  if (!hasOverlappingInferences(context.inferences, inferences)) {
+                    mergeInferences(context.inferences, inferences);
                     context.inferredTypeParameters = concatenate(context.inferredTypeParameters, uniqueTypeParameters);
                     return getOrCreateTypeFromSignature(instantiatedSignature);
                   }
@@ -78267,17 +78268,12 @@ ${lanes.join("\n")}
       }
       return false;
     }
-    function tryInferencesMerge(target, source) {
-      let merged = false;
-      const areOverlapping = hasOverlappingInferences(target, source);
+    function mergeInferences(target, source) {
       for (let i = 0; i < target.length; i++) {
-        if (areOverlapping ? hasInferenceCandidates(source[i]) && hasInferenceCandidates(target[i]) && source[i].priority < (target[i].priority & ~128 /* ReturnType */) : hasInferenceCandidates(source[i])) {
+        if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
           target[i] = source[i];
-          target[i].priority = 0 /* None */;
-          merged = true;
         }
       }
-      return merged;
     }
     function getUniqueTypeParameters(context, typeParameters) {
       const result = [];
@@ -145063,13 +145059,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       const symbol = contextualType.getProperty(name);
       return symbol ? [symbol] : emptyArray;
     }
-    const discriminatedPropertySymbols = mapDefined(contextualType.types, (t) => (isObjectLiteralExpression(node.parent) || isJsxAttributes(node.parent)) && checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent) ? void 0 : t.getProperty(name));
+    const filteredTypes = isObjectLiteralExpression(node.parent) || isJsxAttributes(node.parent) ? filter(contextualType.types, (t) => !checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent)) : contextualType.types;
+    const discriminatedPropertySymbols = mapDefined(filteredTypes, (t) => t.getProperty(name));
     if (unionSymbolOk && (discriminatedPropertySymbols.length === 0 || discriminatedPropertySymbols.length === contextualType.types.length)) {
       const symbol = contextualType.getProperty(name);
       if (symbol)
         return [symbol];
     }
-    if (discriminatedPropertySymbols.length === 0) {
+    if (!filteredTypes.length && !discriminatedPropertySymbols.length) {
       return mapDefined(contextualType.types, (t) => t.getProperty(name));
     }
     return deduplicate(discriminatedPropertySymbols, equateValues);

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20240103`;
+var version = `${versionMajorMinor}.0-insiders.20240104`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -25932,6 +25932,7 @@ var libEntries = [
   ["es2022.regexp", "lib.es2022.regexp.d.ts"],
   ["es2023.array", "lib.es2023.array.d.ts"],
   ["es2023.collection", "lib.es2023.collection.d.ts"],
+  ["es2023.intl", "lib.es2023.intl.d.ts"],
   ["esnext.array", "lib.es2023.array.d.ts"],
   ["esnext.collection", "lib.es2023.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.4.0-pr-56939-8",
+  "version": "5.4.0-pr-56902-8",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -114,5 +114,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "04c80422db846a111808f99b29888f1ee1f5a6f7"
+  "gitHead": "c379e13d533fa68cb366a822ad8455adfaf63ba7"
 }