@typescript-deploys/pr-build 5.4.0-pr-56902-8 → 5.4.0-pr-56911-7

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

@@ -55,22 +55,10 @@ declare namespace Intl {
 
     const PluralRules: PluralRulesConstructor;
 
-    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;
+    // 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 NumberFormatPart {
         type: NumberFormatPartTypes;

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

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

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

@@ -241,49 +241,24 @@ 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?: NumberFormatOptionsSignDisplay | undefined;
+        signDisplay?: "auto" | "never" | "always" | "exceptZero" | undefined;
         unit?: string | undefined;
         unitDisplay?: "short" | "long" | "narrow" | undefined;
-        currencySign?: "standard" | "accounting" | undefined;
+        currencyDisplay?: string | undefined;
+        currencySign?: string | undefined;
     }
 
     interface ResolvedNumberFormatOptions {
         compactDisplay?: "short" | "long";
-        notation: "standard" | "scientific" | "engineering" | "compact";
-        signDisplay: NumberFormatOptionsSignDisplay;
+        notation?: "standard" | "scientific" | "engineering" | "compact";
+        signDisplay?: "auto" | "never" | "always" | "exceptZero";
         unit?: string;
         unitDisplay?: "short" | "long" | "narrow";
-        currencySign?: "standard" | "accounting";
-    }
-
-    interface NumberFormatPartTypeRegistry {
-        compact: any;
-        exponentInteger: any;
-        exponentMinusSign: any;
-        exponentSeparator: any;
-        unit: any;
-        unknown: any;
+        currencyDisplay?: string;
+        currencySign?: string;
     }
 
     interface DateTimeFormatOptions {

package/lib/lib.es2023.d.ts

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

package/lib/lib.es5.d.ts

@@ -4427,33 +4427,12 @@ 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?: "lookup" | "best fit" | undefined;
-        style?: NumberFormatOptionsStyle | undefined;
+        localeMatcher?: string | undefined;
+        style?: string | undefined;
         currency?: string | undefined;
-        currencyDisplay?: NumberFormatOptionsCurrencyDisplay | undefined;
-        useGrouping?: NumberFormatOptionsUseGrouping | undefined;
+        currencySign?: string | undefined;
+        useGrouping?: boolean | undefined;
         minimumIntegerDigits?: number | undefined;
         minimumFractionDigits?: number | undefined;
         maximumFractionDigits?: number | undefined;
@@ -4464,15 +4443,14 @@ declare namespace Intl {
     interface ResolvedNumberFormatOptions {
         locale: string;
         numberingSystem: string;
-        style: NumberFormatOptionsStyle;
+        style: string;
         currency?: string;
-        currencyDisplay?: NumberFormatOptionsCurrencyDisplay;
         minimumIntegerDigits: number;
         minimumFractionDigits: number;
         maximumFractionDigits: number;
         minimumSignificantDigits?: number;
         maximumSignificantDigits?: number;
-        useGrouping: ResolvedNumberFormatOptionsUseGrouping;
+        useGrouping: boolean;
     }
 
     interface NumberFormat {

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

@@ -17,5 +17,12 @@ and limitations under the License.
 /// <reference no-default-lib="true"/>
 
 declare namespace Intl {
-    // Empty
+    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/tsc.js

@@ -34076,7 +34076,6 @@ 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"],
@@ -44255,6 +44254,19 @@ function createTypeChecker(host) {
     emptyArray
   );
   var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
+  var keyofConstraintObjectType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    [stringType, numberType, esSymbolType].map((t) => createIndexInfo(
+      t,
+      unknownType,
+      /*isReadonly*/
+      false
+    ))
+  );
   var emptyGenericType = createAnonymousType(
     /*symbol*/
     void 0,
@@ -54531,17 +54543,13 @@ function createTypeChecker(host) {
   function replaceIndexedAccess(instantiable, type, replacement) {
     return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
   }
-  function getLimitedConstraint(type) {
+  function getReverseMappedTypeMembersLimitingConstraint(type) {
     const constraint = getConstraintTypeFromMappedType(type.mappedType);
-    if (!(constraint.flags & 1048576 /* Union */ || constraint.flags & 2097152 /* Intersection */)) {
-      return;
-    }
-    const origin = constraint.flags & 1048576 /* Union */ ? constraint.origin : constraint;
-    if (!origin || !(origin.flags & 2097152 /* Intersection */)) {
+    if (constraint === type.constraintType) {
       return;
     }
-    const limitedConstraint = getIntersectionType(origin.types.filter((t) => t !== type.constraintType));
-    return limitedConstraint !== neverType ? limitedConstraint : void 0;
+    const mapper = appendTypeMapping(type.mappedType.mapper, type.constraintType.type, keyofConstraintObjectType);
+    return getBaseConstraintOrType(instantiateType(constraint, mapper));
   }
   function resolveReverseMappedTypeMembers(type) {
     const indexInfo = getIndexInfoOfType(type.source, stringType);
@@ -54550,11 +54558,11 @@ function createTypeChecker(host) {
     const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
     const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
     const members = createSymbolTable();
-    const limitedConstraint = getLimitedConstraint(type);
+    const membersLimitingConstraint = getReverseMappedTypeMembersLimitingConstraint(type);
     for (const prop of getPropertiesOfType(type.source)) {
-      if (limitedConstraint) {
+      if (membersLimitingConstraint) {
         const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
-        if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
+        if (!isTypeAssignableTo(propertyNameType, membersLimitingConstraint)) {
           continue;
         }
       }
@@ -64832,7 +64840,7 @@ function createTypeChecker(host) {
       }
     }
     function inferToMappedType(source, target, constraintType) {
-      if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
+      if (constraintType.flags & 3145728 /* UnionOrIntersection */) {
         let result = false;
         for (const type of constraintType.types) {
           result = inferToMappedType(source, target, type) || result;

package/lib/tsserver.js

@@ -38504,7 +38504,6 @@ 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"],
@@ -48983,6 +48982,19 @@ function createTypeChecker(host) {
     emptyArray
   );
   var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
+  var keyofConstraintObjectType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    [stringType, numberType, esSymbolType].map((t) => createIndexInfo(
+      t,
+      unknownType,
+      /*isReadonly*/
+      false
+    ))
+  );
   var emptyGenericType = createAnonymousType(
     /*symbol*/
     void 0,
@@ -59259,17 +59271,13 @@ function createTypeChecker(host) {
   function replaceIndexedAccess(instantiable, type, replacement) {
     return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
   }
-  function getLimitedConstraint(type) {
+  function getReverseMappedTypeMembersLimitingConstraint(type) {
     const constraint = getConstraintTypeFromMappedType(type.mappedType);
-    if (!(constraint.flags & 1048576 /* Union */ || constraint.flags & 2097152 /* Intersection */)) {
-      return;
-    }
-    const origin = constraint.flags & 1048576 /* Union */ ? constraint.origin : constraint;
-    if (!origin || !(origin.flags & 2097152 /* Intersection */)) {
+    if (constraint === type.constraintType) {
       return;
     }
-    const limitedConstraint = getIntersectionType(origin.types.filter((t) => t !== type.constraintType));
-    return limitedConstraint !== neverType ? limitedConstraint : void 0;
+    const mapper = appendTypeMapping(type.mappedType.mapper, type.constraintType.type, keyofConstraintObjectType);
+    return getBaseConstraintOrType(instantiateType(constraint, mapper));
   }
   function resolveReverseMappedTypeMembers(type) {
     const indexInfo = getIndexInfoOfType(type.source, stringType);
@@ -59278,11 +59286,11 @@ function createTypeChecker(host) {
     const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
     const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
     const members = createSymbolTable();
-    const limitedConstraint = getLimitedConstraint(type);
+    const membersLimitingConstraint = getReverseMappedTypeMembersLimitingConstraint(type);
     for (const prop of getPropertiesOfType(type.source)) {
-      if (limitedConstraint) {
+      if (membersLimitingConstraint) {
         const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
-        if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
+        if (!isTypeAssignableTo(propertyNameType, membersLimitingConstraint)) {
           continue;
         }
       }
@@ -69560,7 +69568,7 @@ function createTypeChecker(host) {
       }
     }
     function inferToMappedType(source, target, constraintType) {
-      if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
+      if (constraintType.flags & 3145728 /* UnionOrIntersection */) {
         let result = false;
         for (const type of constraintType.types) {
           result = inferToMappedType(source, target, type) || result;

package/lib/typescript.js

@@ -37998,7 +37998,6 @@ ${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"],
@@ -46737,6 +46736,19 @@ ${lanes.join("\n")}
       emptyArray
     );
     var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
+    var keyofConstraintObjectType = createAnonymousType(
+      /*symbol*/
+      void 0,
+      emptySymbols,
+      emptyArray,
+      emptyArray,
+      [stringType, numberType, esSymbolType].map((t) => createIndexInfo(
+        t,
+        unknownType,
+        /*isReadonly*/
+        false
+      ))
+    );
     var emptyGenericType = createAnonymousType(
       /*symbol*/
       void 0,
@@ -57013,17 +57025,13 @@ ${lanes.join("\n")}
     function replaceIndexedAccess(instantiable, type, replacement) {
       return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
     }
-    function getLimitedConstraint(type) {
+    function getReverseMappedTypeMembersLimitingConstraint(type) {
       const constraint = getConstraintTypeFromMappedType(type.mappedType);
-      if (!(constraint.flags & 1048576 /* Union */ || constraint.flags & 2097152 /* Intersection */)) {
-        return;
-      }
-      const origin = constraint.flags & 1048576 /* Union */ ? constraint.origin : constraint;
-      if (!origin || !(origin.flags & 2097152 /* Intersection */)) {
+      if (constraint === type.constraintType) {
         return;
       }
-      const limitedConstraint = getIntersectionType(origin.types.filter((t) => t !== type.constraintType));
-      return limitedConstraint !== neverType ? limitedConstraint : void 0;
+      const mapper = appendTypeMapping(type.mappedType.mapper, type.constraintType.type, keyofConstraintObjectType);
+      return getBaseConstraintOrType(instantiateType(constraint, mapper));
     }
     function resolveReverseMappedTypeMembers(type) {
       const indexInfo = getIndexInfoOfType(type.source, stringType);
@@ -57032,11 +57040,11 @@ ${lanes.join("\n")}
       const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
       const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
       const members = createSymbolTable();
-      const limitedConstraint = getLimitedConstraint(type);
+      const membersLimitingConstraint = getReverseMappedTypeMembersLimitingConstraint(type);
       for (const prop of getPropertiesOfType(type.source)) {
-        if (limitedConstraint) {
+        if (membersLimitingConstraint) {
           const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
-          if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
+          if (!isTypeAssignableTo(propertyNameType, membersLimitingConstraint)) {
             continue;
           }
         }
@@ -67314,7 +67322,7 @@ ${lanes.join("\n")}
         }
       }
       function inferToMappedType(source, target, constraintType) {
-        if (constraintType.flags & 1048576 /* Union */ || constraintType.flags & 2097152 /* Intersection */) {
+        if (constraintType.flags & 3145728 /* UnionOrIntersection */) {
           let result = false;
           for (const type of constraintType.types) {
             result = inferToMappedType(source, target, type) || result;

package/lib/typingsInstaller.js

@@ -25932,7 +25932,6 @@ 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-56902-8",
+  "version": "5.4.0-pr-56911-7",
   "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": "c379e13d533fa68cb366a822ad8455adfaf63ba7"
+  "gitHead": "3baf3b4e1804f2f32ace0d49b294bcf08f3ee314"
 }

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

@@ -1,52 +0,0 @@
-/*! *****************************************************************************
-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[];
-    }
-}