typescript 5.5.0-dev.20240229 → 5.5.0-dev.20240302

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: never;
+        nan: never;
+        infinity: never;
+        percent: never;
+        integer: never;
+        group: never;
+        decimal: never;
+        fraction: never;
+        plusSign: never;
+        minusSign: never;
+        percentSign: never;
+        currency: never;
+    }
+
+    type NumberFormatPartTypes = keyof NumberFormatPartTypeRegistry;
 
     interface NumberFormatPart {
         type: NumberFormatPartTypes;

package/lib/lib.es2019.intl.d.ts

@@ -18,6 +18,6 @@ and limitations under the License.
 
 declare namespace Intl {
     interface DateTimeFormatPartTypesRegistry {
-        unknown: any;
+        unknown: never;
     }
 }

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: never;
+    }
+
+    interface NumberFormatOptionsCurrencyDisplayRegistry {
+        narrowSymbol: never;
+    }
+
+    interface NumberFormatOptionsSignDisplayRegistry {
+        auto: never;
+        never: never;
+        always: never;
+        exceptZero: never;
+    }
+
+    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: never;
+        exponentInteger: never;
+        exponentMinusSign: never;
+        exponentSeparator: never;
+        unit: never;
+        unknown: never;
     }
 
     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: never;
+        auto: never;
+        always: never;
+    }
+
+    interface NumberFormatOptionsSignDisplayRegistry {
+        negative: never;
+    }
+
+    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

@@ -4433,12 +4433,33 @@ declare namespace Intl {
 
     var Collator: CollatorConstructor;
 
+    interface NumberFormatOptionsStyleRegistry {
+        decimal: never;
+        percent: never;
+        currency: never;
+    }
+
+    type NumberFormatOptionsStyle = keyof NumberFormatOptionsStyleRegistry;
+
+    interface NumberFormatOptionsCurrencyDisplayRegistry {
+        code: never;
+        symbol: never;
+        name: never;
+    }
+
+    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;
@@ -4449,14 +4470,15 @@ declare namespace Intl {
     interface ResolvedNumberFormatOptions {
         locale: string;
         numberingSystem: string;
-        style: string;
+        style: NumberFormatOptionsStyle;
         currency?: string;
+        currencyDisplay?: NumberFormatOptionsCurrencyDisplay;
         minimumIntegerDigits: number;
-        minimumFractionDigits: number;
-        maximumFractionDigits: 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.5";
-var version = `${versionMajorMinor}.0-dev.20240229`;
+var version = `${versionMajorMinor}.0-dev.20240302`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -33723,6 +33723,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.esnext.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -40995,7 +40996,7 @@ function createBinder() {
     return Diagnostics.Invalid_use_of_0_in_strict_mode;
   }
   function checkStrictModeFunctionName(node) {
-    if (inStrictMode) {
+    if (inStrictMode && !(node.flags & 33554432 /* Ambient */)) {
       checkStrictModeEvalOrArguments(node, node.name);
     }
   }
@@ -74505,11 +74506,13 @@ function createTypeChecker(host) {
   }
   function getSymbolHasInstanceMethodOfObjectType(type) {
     const hasInstancePropertyName = getPropertyNameForKnownSymbolName("hasInstance");
-    const hasInstanceProperty = getPropertyOfObjectType(type, hasInstancePropertyName);
-    if (hasInstanceProperty) {
-      const hasInstancePropertyType = getTypeOfSymbol(hasInstanceProperty);
-      if (hasInstancePropertyType && getSignaturesOfType(hasInstancePropertyType, 0 /* Call */).length !== 0) {
-        return hasInstancePropertyType;
+    if (allTypesAssignableToKind(type, 67108864 /* NonPrimitive */)) {
+      const hasInstanceProperty = getPropertyOfType(type, hasInstancePropertyName);
+      if (hasInstanceProperty) {
+        const hasInstancePropertyType = getTypeOfSymbol(hasInstanceProperty);
+        if (hasInstancePropertyType && getSignaturesOfType(hasInstancePropertyType, 0 /* Call */).length !== 0) {
+          return hasInstancePropertyType;
+        }
       }
     }
   }
@@ -78621,7 +78624,9 @@ function createTypeChecker(host) {
   function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
     const allowAsyncIterables = (use & 2 /* AllowsAsyncIterablesFlag */) !== 0;
     if (inputType === neverType) {
-      reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
+      if (errorNode) {
+        reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
+      }
       return void 0;
     }
     const uplevelIteration = languageVersion >= 2 /* ES2015 */;
@@ -82555,6 +82560,15 @@ function createTypeChecker(host) {
     }
     return false;
   }
+  function declaredParameterTypeContainsUndefined(parameter) {
+    if (!parameter.type)
+      return false;
+    const type = getTypeFromTypeNode(parameter.type);
+    return containsUndefinedType(type);
+  }
+  function requiresAddingImplicitUndefined(parameter) {
+    return (isRequiredInitializedParameter(parameter) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
+  }
   function isRequiredInitializedParameter(parameter) {
     return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
@@ -82914,8 +82928,7 @@ function createTypeChecker(host) {
       isTopLevelValueImportEqualsWithEntityName,
       isDeclarationVisible,
       isImplementationOfOverload,
-      isRequiredInitializedParameter,
-      isOptionalUninitializedParameterProperty,
+      requiresAddingImplicitUndefined,
       isExpandoFunctionDeclaration,
       getPropertiesOfContainerFunction,
       createTypeOfDeclaration,
@@ -108473,38 +108486,41 @@ function transformDeclarations(context) {
     if (shouldPrintWithInitializer(node)) {
       return;
     }
-    const shouldUseResolverType = node.kind === 169 /* Parameter */ && (resolver.isRequiredInitializedParameter(node) || resolver.isOptionalUninitializedParameterProperty(node));
-    if (type && !shouldUseResolverType) {
+    const shouldAddImplicitUndefined = node.kind === 169 /* Parameter */ && resolver.requiresAddingImplicitUndefined(node);
+    if (type && !shouldAddImplicitUndefined) {
       return visitNode(type, visitDeclarationSubtree, isTypeNode);
     }
-    if (!getParseTreeNode(node)) {
-      return type ? visitNode(type, visitDeclarationSubtree, isTypeNode) : factory2.createKeywordTypeNode(133 /* AnyKeyword */);
-    }
-    if (node.kind === 178 /* SetAccessor */) {
-      return factory2.createKeywordTypeNode(133 /* AnyKeyword */);
-    }
     errorNameNode = node.name;
     let oldDiag;
     if (!suppressNewDiagnosticContexts) {
       oldDiag = getSymbolAccessibilityDiagnostic;
       getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
     }
-    if (node.kind === 260 /* VariableDeclaration */ || node.kind === 208 /* BindingElement */) {
-      return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
-    }
-    if (node.kind === 169 /* Parameter */ || node.kind === 172 /* PropertyDeclaration */ || node.kind === 171 /* PropertySignature */) {
-      if (isPropertySignature(node) || !node.initializer)
-        return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType));
-      return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
+    let typeNode;
+    switch (node.kind) {
+      case 169 /* Parameter */:
+      case 171 /* PropertySignature */:
+      case 172 /* PropertyDeclaration */:
+      case 208 /* BindingElement */:
+      case 260 /* VariableDeclaration */:
+        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
+        break;
+      case 262 /* FunctionDeclaration */:
+      case 180 /* ConstructSignature */:
+      case 173 /* MethodSignature */:
+      case 174 /* MethodDeclaration */:
+      case 177 /* GetAccessor */:
+      case 179 /* CallSignature */:
+        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+        break;
+      default:
+        Debug.assertNever(node);
     }
-    return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
-    function cleanup(returnValue) {
-      errorNameNode = void 0;
-      if (!suppressNewDiagnosticContexts) {
-        getSymbolAccessibilityDiagnostic = oldDiag;
-      }
-      return returnValue || factory2.createKeywordTypeNode(133 /* AnyKeyword */);
+    errorNameNode = void 0;
+    if (!suppressNewDiagnosticContexts) {
+      getSymbolAccessibilityDiagnostic = oldDiag;
     }
+    return typeNode ?? factory2.createKeywordTypeNode(133 /* AnyKeyword */);
   }
   function isDeclarationAndNotVisible(node) {
     node = getParseTreeNode(node);
@@ -110697,8 +110713,7 @@ var notImplementedResolver = {
   isLateBound: (_node) => false,
   collectLinkedAliases: notImplemented,
   isImplementationOfOverload: notImplemented,
-  isRequiredInitializedParameter: notImplemented,
-  isOptionalUninitializedParameterProperty: notImplemented,
+  requiresAddingImplicitUndefined: notImplemented,
   isExpandoFunctionDeclaration: notImplemented,
   getPropertiesOfContainerFunction: notImplemented,
   createTypeOfDeclaration: notImplemented,

package/lib/tsserver.js

@@ -2325,7 +2325,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240229`;
+var version = `${versionMajorMinor}.0-dev.20240302`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -38133,6 +38133,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.esnext.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -45660,7 +45661,7 @@ function createBinder() {
     return Diagnostics.Invalid_use_of_0_in_strict_mode;
   }
   function checkStrictModeFunctionName(node) {
-    if (inStrictMode) {
+    if (inStrictMode && !(node.flags & 33554432 /* Ambient */)) {
       checkStrictModeEvalOrArguments(node, node.name);
     }
   }
@@ -79224,11 +79225,13 @@ function createTypeChecker(host) {
   }
   function getSymbolHasInstanceMethodOfObjectType(type) {
     const hasInstancePropertyName = getPropertyNameForKnownSymbolName("hasInstance");
-    const hasInstanceProperty = getPropertyOfObjectType(type, hasInstancePropertyName);
-    if (hasInstanceProperty) {
-      const hasInstancePropertyType = getTypeOfSymbol(hasInstanceProperty);
-      if (hasInstancePropertyType && getSignaturesOfType(hasInstancePropertyType, 0 /* Call */).length !== 0) {
-        return hasInstancePropertyType;
+    if (allTypesAssignableToKind(type, 67108864 /* NonPrimitive */)) {
+      const hasInstanceProperty = getPropertyOfType(type, hasInstancePropertyName);
+      if (hasInstanceProperty) {
+        const hasInstancePropertyType = getTypeOfSymbol(hasInstanceProperty);
+        if (hasInstancePropertyType && getSignaturesOfType(hasInstancePropertyType, 0 /* Call */).length !== 0) {
+          return hasInstancePropertyType;
+        }
       }
     }
   }
@@ -83340,7 +83343,9 @@ function createTypeChecker(host) {
   function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
     const allowAsyncIterables = (use & 2 /* AllowsAsyncIterablesFlag */) !== 0;
     if (inputType === neverType) {
-      reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
+      if (errorNode) {
+        reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
+      }
       return void 0;
     }
     const uplevelIteration = languageVersion >= 2 /* ES2015 */;
@@ -87274,6 +87279,15 @@ function createTypeChecker(host) {
     }
     return false;
   }
+  function declaredParameterTypeContainsUndefined(parameter) {
+    if (!parameter.type)
+      return false;
+    const type = getTypeFromTypeNode(parameter.type);
+    return containsUndefinedType(type);
+  }
+  function requiresAddingImplicitUndefined(parameter) {
+    return (isRequiredInitializedParameter(parameter) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
+  }
   function isRequiredInitializedParameter(parameter) {
     return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
   }
@@ -87633,8 +87647,7 @@ function createTypeChecker(host) {
       isTopLevelValueImportEqualsWithEntityName,
       isDeclarationVisible,
       isImplementationOfOverload,
-      isRequiredInitializedParameter,
-      isOptionalUninitializedParameterProperty,
+      requiresAddingImplicitUndefined,
       isExpandoFunctionDeclaration,
       getPropertiesOfContainerFunction,
       createTypeOfDeclaration,
@@ -113379,38 +113392,41 @@ function transformDeclarations(context) {
     if (shouldPrintWithInitializer(node)) {
       return;
     }
-    const shouldUseResolverType = node.kind === 169 /* Parameter */ && (resolver.isRequiredInitializedParameter(node) || resolver.isOptionalUninitializedParameterProperty(node));
-    if (type && !shouldUseResolverType) {
+    const shouldAddImplicitUndefined = node.kind === 169 /* Parameter */ && resolver.requiresAddingImplicitUndefined(node);
+    if (type && !shouldAddImplicitUndefined) {
       return visitNode(type, visitDeclarationSubtree, isTypeNode);
     }
-    if (!getParseTreeNode(node)) {
-      return type ? visitNode(type, visitDeclarationSubtree, isTypeNode) : factory2.createKeywordTypeNode(133 /* AnyKeyword */);
-    }
-    if (node.kind === 178 /* SetAccessor */) {
-      return factory2.createKeywordTypeNode(133 /* AnyKeyword */);
-    }
     errorNameNode = node.name;
     let oldDiag;
     if (!suppressNewDiagnosticContexts) {
       oldDiag = getSymbolAccessibilityDiagnostic;
       getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
     }
-    if (node.kind === 260 /* VariableDeclaration */ || node.kind === 208 /* BindingElement */) {
-      return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
-    }
-    if (node.kind === 169 /* Parameter */ || node.kind === 172 /* PropertyDeclaration */ || node.kind === 171 /* PropertySignature */) {
-      if (isPropertySignature(node) || !node.initializer)
-        return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType));
-      return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
+    let typeNode;
+    switch (node.kind) {
+      case 169 /* Parameter */:
+      case 171 /* PropertySignature */:
+      case 172 /* PropertyDeclaration */:
+      case 208 /* BindingElement */:
+      case 260 /* VariableDeclaration */:
+        typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
+        break;
+      case 262 /* FunctionDeclaration */:
+      case 180 /* ConstructSignature */:
+      case 173 /* MethodSignature */:
+      case 174 /* MethodDeclaration */:
+      case 177 /* GetAccessor */:
+      case 179 /* CallSignature */:
+        typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+        break;
+      default:
+        Debug.assertNever(node);
     }
-    return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
-    function cleanup(returnValue) {
-      errorNameNode = void 0;
-      if (!suppressNewDiagnosticContexts) {
-        getSymbolAccessibilityDiagnostic = oldDiag;
-      }
-      return returnValue || factory2.createKeywordTypeNode(133 /* AnyKeyword */);
+    errorNameNode = void 0;
+    if (!suppressNewDiagnosticContexts) {
+      getSymbolAccessibilityDiagnostic = oldDiag;
     }
+    return typeNode ?? factory2.createKeywordTypeNode(133 /* AnyKeyword */);
   }
   function isDeclarationAndNotVisible(node) {
     node = getParseTreeNode(node);
@@ -115614,8 +115630,7 @@ var notImplementedResolver = {
   isLateBound: (_node) => false,
   collectLinkedAliases: notImplemented,
   isImplementationOfOverload: notImplemented,
-  isRequiredInitializedParameter: notImplemented,
-  isOptionalUninitializedParameterProperty: notImplemented,
+  requiresAddingImplicitUndefined: notImplemented,
   isExpandoFunctionDeclaration: notImplemented,
   getPropertiesOfContainerFunction: notImplemented,
   createTypeOfDeclaration: notImplemented,

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.5";
-      version = `${versionMajorMinor}.0-dev.20240229`;
+      version = `${versionMajorMinor}.0-dev.20240302`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -37644,6 +37644,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.esnext.collection.d.ts"],
         ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -43511,7 +43512,7 @@ ${lanes.join("\n")}
       return Diagnostics.Invalid_use_of_0_in_strict_mode;
     }
     function checkStrictModeFunctionName(node) {
-      if (inStrictMode) {
+      if (inStrictMode && !(node.flags & 33554432 /* Ambient */)) {
         checkStrictModeEvalOrArguments(node, node.name);
       }
     }
@@ -76995,11 +76996,13 @@ ${lanes.join("\n")}
     }
     function getSymbolHasInstanceMethodOfObjectType(type) {
       const hasInstancePropertyName = getPropertyNameForKnownSymbolName("hasInstance");
-      const hasInstanceProperty = getPropertyOfObjectType(type, hasInstancePropertyName);
-      if (hasInstanceProperty) {
-        const hasInstancePropertyType = getTypeOfSymbol(hasInstanceProperty);
-        if (hasInstancePropertyType && getSignaturesOfType(hasInstancePropertyType, 0 /* Call */).length !== 0) {
-          return hasInstancePropertyType;
+      if (allTypesAssignableToKind(type, 67108864 /* NonPrimitive */)) {
+        const hasInstanceProperty = getPropertyOfType(type, hasInstancePropertyName);
+        if (hasInstanceProperty) {
+          const hasInstancePropertyType = getTypeOfSymbol(hasInstanceProperty);
+          if (hasInstancePropertyType && getSignaturesOfType(hasInstancePropertyType, 0 /* Call */).length !== 0) {
+            return hasInstancePropertyType;
+          }
         }
       }
     }
@@ -81111,7 +81114,9 @@ ${lanes.join("\n")}
     function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
       const allowAsyncIterables = (use & 2 /* AllowsAsyncIterablesFlag */) !== 0;
       if (inputType === neverType) {
-        reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
+        if (errorNode) {
+          reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
+        }
         return void 0;
       }
       const uplevelIteration = languageVersion >= 2 /* ES2015 */;
@@ -85045,6 +85050,15 @@ ${lanes.join("\n")}
       }
       return false;
     }
+    function declaredParameterTypeContainsUndefined(parameter) {
+      if (!parameter.type)
+        return false;
+      const type = getTypeFromTypeNode(parameter.type);
+      return containsUndefinedType(type);
+    }
+    function requiresAddingImplicitUndefined(parameter) {
+      return (isRequiredInitializedParameter(parameter) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
+    }
     function isRequiredInitializedParameter(parameter) {
       return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
     }
@@ -85404,8 +85418,7 @@ ${lanes.join("\n")}
         isTopLevelValueImportEqualsWithEntityName,
         isDeclarationVisible,
         isImplementationOfOverload,
-        isRequiredInitializedParameter,
-        isOptionalUninitializedParameterProperty,
+        requiresAddingImplicitUndefined,
         isExpandoFunctionDeclaration,
         getPropertiesOfContainerFunction,
         createTypeOfDeclaration,
@@ -111454,38 +111467,41 @@ ${lanes.join("\n")}
       if (shouldPrintWithInitializer(node)) {
         return;
       }
-      const shouldUseResolverType = node.kind === 169 /* Parameter */ && (resolver.isRequiredInitializedParameter(node) || resolver.isOptionalUninitializedParameterProperty(node));
-      if (type && !shouldUseResolverType) {
+      const shouldAddImplicitUndefined = node.kind === 169 /* Parameter */ && resolver.requiresAddingImplicitUndefined(node);
+      if (type && !shouldAddImplicitUndefined) {
         return visitNode(type, visitDeclarationSubtree, isTypeNode);
       }
-      if (!getParseTreeNode(node)) {
-        return type ? visitNode(type, visitDeclarationSubtree, isTypeNode) : factory2.createKeywordTypeNode(133 /* AnyKeyword */);
-      }
-      if (node.kind === 178 /* SetAccessor */) {
-        return factory2.createKeywordTypeNode(133 /* AnyKeyword */);
-      }
       errorNameNode = node.name;
       let oldDiag;
       if (!suppressNewDiagnosticContexts) {
         oldDiag = getSymbolAccessibilityDiagnostic;
         getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
       }
-      if (node.kind === 260 /* VariableDeclaration */ || node.kind === 208 /* BindingElement */) {
-        return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
-      }
-      if (node.kind === 169 /* Parameter */ || node.kind === 172 /* PropertyDeclaration */ || node.kind === 171 /* PropertySignature */) {
-        if (isPropertySignature(node) || !node.initializer)
-          return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType));
-        return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
+      let typeNode;
+      switch (node.kind) {
+        case 169 /* Parameter */:
+        case 171 /* PropertySignature */:
+        case 172 /* PropertyDeclaration */:
+        case 208 /* BindingElement */:
+        case 260 /* VariableDeclaration */:
+          typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
+          break;
+        case 262 /* FunctionDeclaration */:
+        case 180 /* ConstructSignature */:
+        case 173 /* MethodSignature */:
+        case 174 /* MethodDeclaration */:
+        case 177 /* GetAccessor */:
+        case 179 /* CallSignature */:
+          typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
+          break;
+        default:
+          Debug.assertNever(node);
       }
-      return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
-      function cleanup(returnValue) {
-        errorNameNode = void 0;
-        if (!suppressNewDiagnosticContexts) {
-          getSymbolAccessibilityDiagnostic = oldDiag;
-        }
-        return returnValue || factory2.createKeywordTypeNode(133 /* AnyKeyword */);
+      errorNameNode = void 0;
+      if (!suppressNewDiagnosticContexts) {
+        getSymbolAccessibilityDiagnostic = oldDiag;
       }
+      return typeNode ?? factory2.createKeywordTypeNode(133 /* AnyKeyword */);
     }
     function isDeclarationAndNotVisible(node) {
       node = getParseTreeNode(node);
@@ -118122,8 +118138,7 @@ ${lanes.join("\n")}
         isLateBound: (_node) => false,
         collectLinkedAliases: notImplemented,
         isImplementationOfOverload: notImplemented,
-        isRequiredInitializedParameter: notImplemented,
-        isOptionalUninitializedParameterProperty: notImplemented,
+        requiresAddingImplicitUndefined: notImplemented,
         isExpandoFunctionDeclaration: notImplemented,
         getPropertiesOfContainerFunction: notImplemented,
         createTypeOfDeclaration: notImplemented,

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240229`;
+var version = `${versionMajorMinor}.0-dev.20240302`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -25877,6 +25877,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.esnext.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.5.0-dev.20240229",
+    "version": "5.5.0-dev.20240302",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -113,5 +113,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "2d70b57df4b64a3daef252abb014562e6ccc8f3c"
+    "gitHead": "0d78152bd7947694cd3e3d8422e338bf03499096"
 }