typescript 5.4.0-dev.20240104 → 5.4.0-dev.20240106

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20240104`;
+      version = `${versionMajorMinor}.0-dev.20240106`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -96262,22 +96262,49 @@ ${lanes.join("\n")}
     }
     function createClassInfo(node) {
       const metadataReference = factory2.createUniqueName("_metadata", 16 /* Optimistic */ | 32 /* FileLevel */);
-      let instanceExtraInitializersName;
-      let staticExtraInitializersName;
+      let instanceMethodExtraInitializersName;
+      let staticMethodExtraInitializersName;
       let hasStaticInitializers = false;
       let hasNonAmbientInstanceFields = false;
       let hasStaticPrivateClassElements = false;
+      let classThis2;
+      let pendingStaticInitializers;
+      let pendingInstanceInitializers;
+      if (nodeIsDecorated(
+        /*useLegacyDecorators*/
+        false,
+        node
+      )) {
+        const needsUniqueClassThis = some(node.members, (member) => (isPrivateIdentifierClassElementDeclaration(member) || isAutoAccessorPropertyDeclaration(member)) && hasStaticModifier(member));
+        classThis2 = factory2.createUniqueName(
+          "_classThis",
+          needsUniqueClassThis ? 16 /* Optimistic */ | 8 /* ReservedInNestedScopes */ : 16 /* Optimistic */ | 32 /* FileLevel */
+        );
+      }
       for (const member of node.members) {
-        if (isNamedClassElement(member) && nodeOrChildIsDecorated(
+        if (isMethodOrAccessor(member) && nodeOrChildIsDecorated(
           /*useLegacyDecorators*/
           false,
           member,
           node
         )) {
           if (hasStaticModifier(member)) {
-            staticExtraInitializersName ?? (staticExtraInitializersName = factory2.createUniqueName("_staticExtraInitializers", 16 /* Optimistic */ | 32 /* FileLevel */));
+            if (!staticMethodExtraInitializersName) {
+              staticMethodExtraInitializersName = factory2.createUniqueName("_staticExtraInitializers", 16 /* Optimistic */ | 32 /* FileLevel */);
+              const initializer = emitHelpers().createRunInitializersHelper(classThis2 ?? factory2.createThis(), staticMethodExtraInitializersName);
+              setSourceMapRange(initializer, node.name ?? moveRangePastDecorators(node));
+              pendingStaticInitializers ?? (pendingStaticInitializers = []);
+              pendingStaticInitializers.push(initializer);
+            }
           } else {
-            instanceExtraInitializersName ?? (instanceExtraInitializersName = factory2.createUniqueName("_instanceExtraInitializers", 16 /* Optimistic */ | 32 /* FileLevel */));
+            if (!instanceMethodExtraInitializersName) {
+              instanceMethodExtraInitializersName = factory2.createUniqueName("_instanceExtraInitializers", 16 /* Optimistic */ | 32 /* FileLevel */);
+              const initializer = emitHelpers().createRunInitializersHelper(factory2.createThis(), instanceMethodExtraInitializersName);
+              setSourceMapRange(initializer, node.name ?? moveRangePastDecorators(node));
+              pendingInstanceInitializers ?? (pendingInstanceInitializers = []);
+              pendingInstanceInitializers.push(initializer);
+            }
+            instanceMethodExtraInitializersName ?? (instanceMethodExtraInitializersName = factory2.createUniqueName("_instanceExtraInitializers", 16 /* Optimistic */ | 32 /* FileLevel */));
           }
         }
         if (isClassStaticBlockDeclaration(member)) {
@@ -96294,18 +96321,21 @@ ${lanes.join("\n")}
         if ((isPrivateIdentifierClassElementDeclaration(member) || isAutoAccessorPropertyDeclaration(member)) && hasStaticModifier(member)) {
           hasStaticPrivateClassElements = true;
         }
-        if (staticExtraInitializersName && instanceExtraInitializersName && hasStaticInitializers && hasNonAmbientInstanceFields && hasStaticPrivateClassElements) {
+        if (staticMethodExtraInitializersName && instanceMethodExtraInitializersName && hasStaticInitializers && hasNonAmbientInstanceFields && hasStaticPrivateClassElements) {
           break;
         }
       }
       return {
         class: node,
+        classThis: classThis2,
         metadataReference,
-        instanceExtraInitializersName,
-        staticExtraInitializersName,
+        instanceMethodExtraInitializersName,
+        staticMethodExtraInitializersName,
         hasStaticInitializers,
         hasNonAmbientInstanceFields,
-        hasStaticPrivateClassElements
+        hasStaticPrivateClassElements,
+        pendingStaticInitializers,
+        pendingInstanceInitializers
       };
     }
     function transformClassLike(node) {
@@ -96338,11 +96368,7 @@ ${lanes.join("\n")}
         classInfo2.classDecoratorsName = factory2.createUniqueName("_classDecorators", 16 /* Optimistic */ | 32 /* FileLevel */);
         classInfo2.classDescriptorName = factory2.createUniqueName("_classDescriptor", 16 /* Optimistic */ | 32 /* FileLevel */);
         classInfo2.classExtraInitializersName = factory2.createUniqueName("_classExtraInitializers", 16 /* Optimistic */ | 32 /* FileLevel */);
-        const needsUniqueClassThis = some(node.members, (member) => (isPrivateIdentifierClassElementDeclaration(member) || isAutoAccessorPropertyDeclaration(member)) && hasStaticModifier(member));
-        classInfo2.classThis = factory2.createUniqueName(
-          "_classThis",
-          needsUniqueClassThis ? 16 /* Optimistic */ | 8 /* ReservedInNestedScopes */ : 16 /* Optimistic */ | 32 /* FileLevel */
-        );
+        Debug.assertIsDefined(classInfo2.classThis);
         classDefinitionStatements.push(
           createLet(classInfo2.classDecoratorsName, factory2.createArrayLiteralExpression(classDecorators)),
           createLet(classInfo2.classDescriptorName),
@@ -96374,7 +96400,9 @@ ${lanes.join("\n")}
       const renamedClassThis = classInfo2.classThis ?? factory2.createThis();
       enterClass(classInfo2);
       leadingBlockStatements = append(leadingBlockStatements, createMetadata(classInfo2.metadataReference, classInfo2.classSuper));
-      let members = visitNodes2(node.members, classElementVisitor, isClassElement);
+      let members = node.members;
+      members = visitNodes2(members, (node2) => isConstructorDeclaration(node2) ? node2 : classElementVisitor(node2), isClassElement);
+      members = visitNodes2(members, (node2) => isConstructorDeclaration(node2) ? classElementVisitor(node2) : node2, isClassElement);
       if (pendingExpressions) {
         let outerThis;
         for (let expression of pendingExpressions) {
@@ -96399,7 +96427,7 @@ ${lanes.join("\n")}
         pendingExpressions = void 0;
       }
       exitClass();
-      if (classInfo2.instanceExtraInitializersName && !getFirstConstructorWithBody(node)) {
+      if (some(classInfo2.pendingInstanceInitializers) && !getFirstConstructorWithBody(node)) {
         const initializerStatements = prepareConstructor(node, classInfo2);
         if (initializerStatements) {
           const extendsClauseElement = getEffectiveBaseTypeNode(node);
@@ -96429,14 +96457,14 @@ ${lanes.join("\n")}
           );
         }
       }
-      if (classInfo2.staticExtraInitializersName) {
+      if (classInfo2.staticMethodExtraInitializersName) {
         classDefinitionStatements.push(
-          createLet(classInfo2.staticExtraInitializersName, factory2.createArrayLiteralExpression())
+          createLet(classInfo2.staticMethodExtraInitializersName, factory2.createArrayLiteralExpression())
         );
       }
-      if (classInfo2.instanceExtraInitializersName) {
+      if (classInfo2.instanceMethodExtraInitializersName) {
         classDefinitionStatements.push(
-          createLet(classInfo2.instanceExtraInitializersName, factory2.createArrayLiteralExpression())
+          createLet(classInfo2.instanceMethodExtraInitializersName, factory2.createArrayLiteralExpression())
         );
       }
       if (classInfo2.memberInfos) {
@@ -96446,6 +96474,9 @@ ${lanes.join("\n")}
             if (memberInfo.memberInitializersName) {
               classDefinitionStatements.push(createLet(memberInfo.memberInitializersName, factory2.createArrayLiteralExpression()));
             }
+            if (memberInfo.memberExtraInitializersName) {
+              classDefinitionStatements.push(createLet(memberInfo.memberExtraInitializersName, factory2.createArrayLiteralExpression()));
+            }
             if (memberInfo.memberDescriptorName) {
               classDefinitionStatements.push(createLet(memberInfo.memberDescriptorName));
             }
@@ -96459,6 +96490,9 @@ ${lanes.join("\n")}
             if (memberInfo.memberInitializersName) {
               classDefinitionStatements.push(createLet(memberInfo.memberInitializersName, factory2.createArrayLiteralExpression()));
             }
+            if (memberInfo.memberExtraInitializersName) {
+              classDefinitionStatements.push(createLet(memberInfo.memberExtraInitializersName, factory2.createArrayLiteralExpression()));
+            }
             if (memberInfo.memberDescriptorName) {
               classDefinitionStatements.push(createLet(memberInfo.memberDescriptorName));
             }
@@ -96492,11 +96526,13 @@ ${lanes.join("\n")}
         leadingBlockStatements.push(factory2.createExpressionStatement(classReferenceAssignment));
       }
       leadingBlockStatements.push(createSymbolMetadata(renamedClassThis, classInfo2.metadataReference));
-      if (classInfo2.staticExtraInitializersName) {
-        const runStaticInitializersHelper = emitHelpers().createRunInitializersHelper(renamedClassThis, classInfo2.staticExtraInitializersName);
-        const runStaticInitializersStatement = factory2.createExpressionStatement(runStaticInitializersHelper);
-        setSourceMapRange(runStaticInitializersStatement, node.name ?? moveRangePastDecorators(node));
-        leadingBlockStatements = append(leadingBlockStatements, runStaticInitializersStatement);
+      if (some(classInfo2.pendingStaticInitializers)) {
+        for (const initializer of classInfo2.pendingStaticInitializers) {
+          const initializerStatement = factory2.createExpressionStatement(initializer);
+          setSourceMapRange(initializerStatement, getSourceMapRange(initializer));
+          trailingBlockStatements = append(trailingBlockStatements, initializerStatement);
+        }
+        classInfo2.pendingStaticInitializers = void 0;
       }
       if (classInfo2.classExtraInitializersName) {
         const runClassInitializersHelper = emitHelpers().createRunInitializersHelper(renamedClassThis, classInfo2.classExtraInitializersName);
@@ -96727,16 +96763,14 @@ ${lanes.join("\n")}
       }
     }
     function prepareConstructor(_parent, classInfo2) {
-      if (classInfo2.instanceExtraInitializersName && !classInfo2.hasNonAmbientInstanceFields) {
+      if (some(classInfo2.pendingInstanceInitializers)) {
         const statements = [];
         statements.push(
           factory2.createExpressionStatement(
-            emitHelpers().createRunInitializersHelper(
-              factory2.createThis(),
-              classInfo2.instanceExtraInitializersName
-            )
+            factory2.inlineExpressions(classInfo2.pendingInstanceInitializers)
           )
         );
+        classInfo2.pendingInstanceInitializers = void 0;
         return statements;
       }
     }
@@ -96816,6 +96850,7 @@ ${lanes.join("\n")}
       let referencedName;
       let name;
       let initializersName;
+      let extraInitializersName;
       let thisArg;
       let descriptorName;
       if (!classInfo2) {
@@ -96873,20 +96908,22 @@ ${lanes.join("\n")}
           },
           metadata: classInfo2.metadataReference
         };
-        const extraInitializers = isStatic(member) ? classInfo2.staticExtraInitializersName ?? (classInfo2.staticExtraInitializersName = factory2.createUniqueName("_staticExtraInitializers", 16 /* Optimistic */ | 32 /* FileLevel */)) : classInfo2.instanceExtraInitializersName ?? (classInfo2.instanceExtraInitializersName = factory2.createUniqueName("_instanceExtraInitializers", 16 /* Optimistic */ | 32 /* FileLevel */));
         if (isMethodOrAccessor(member)) {
+          const methodExtraInitializersName = isStatic(member) ? classInfo2.staticMethodExtraInitializersName : classInfo2.instanceMethodExtraInitializersName;
+          Debug.assertIsDefined(methodExtraInitializersName);
           let descriptor;
           if (isPrivateIdentifierClassElementDeclaration(member) && createDescriptor) {
             descriptor = createDescriptor(member, visitNodes2(modifiers, (node) => tryCast(node, isAsyncModifier), isModifier));
             memberInfo.memberDescriptorName = descriptorName = createHelperVariable(member, "descriptor");
             descriptor = factory2.createAssignment(descriptorName, descriptor);
           }
-          const esDecorateExpression = emitHelpers().createESDecorateHelper(factory2.createThis(), descriptor ?? factory2.createNull(), memberDecoratorsName, context2, factory2.createNull(), extraInitializers);
+          const esDecorateExpression = emitHelpers().createESDecorateHelper(factory2.createThis(), descriptor ?? factory2.createNull(), memberDecoratorsName, context2, factory2.createNull(), methodExtraInitializersName);
           const esDecorateStatement = factory2.createExpressionStatement(esDecorateExpression);
           setSourceMapRange(esDecorateStatement, moveRangePastDecorators(member));
           statements.push(esDecorateStatement);
         } else if (isPropertyDeclaration(member)) {
           initializersName = memberInfo.memberInitializersName ?? (memberInfo.memberInitializersName = createHelperVariable(member, "initializers"));
+          extraInitializersName = memberInfo.memberExtraInitializersName ?? (memberInfo.memberExtraInitializersName = createHelperVariable(member, "extraInitializers"));
           if (isStatic(member)) {
             thisArg = classInfo2.classThis;
           }
@@ -96906,7 +96943,7 @@ ${lanes.join("\n")}
             memberDecoratorsName,
             context2,
             initializersName,
-            extraInitializers
+            extraInitializersName
           );
           const esDecorateStatement = factory2.createExpressionStatement(esDecorateExpression);
           setSourceMapRange(esDecorateStatement, moveRangePastDecorators(member));
@@ -96921,7 +96958,7 @@ ${lanes.join("\n")}
       if (!some(modifiers) && (isMethodDeclaration(member) || isPropertyDeclaration(member))) {
         setEmitFlags(name, 1024 /* NoLeadingComments */);
       }
-      return { modifiers, referencedName, name, initializersName, descriptorName, thisArg };
+      return { modifiers, referencedName, name, initializersName, extraInitializersName, descriptorName, thisArg };
     }
     function visitMethodDeclaration(node) {
       enterClassElement(node);
@@ -96994,9 +97031,27 @@ ${lanes.join("\n")}
         result = visitEachChild(node, visitor, context);
         classThis = savedClassThis;
       } else {
-        if (classInfo)
+        node = visitEachChild(node, visitor, context);
+        result = node;
+        if (classInfo) {
           classInfo.hasStaticInitializers = true;
-        result = visitEachChild(node, visitor, context);
+          if (some(classInfo.pendingStaticInitializers)) {
+            const statements = [];
+            for (const initializer of classInfo.pendingStaticInitializers) {
+              const initializerStatement = factory2.createExpressionStatement(initializer);
+              setSourceMapRange(initializerStatement, getSourceMapRange(initializer));
+              statements.push(initializerStatement);
+            }
+            const body = factory2.createBlock(
+              statements,
+              /*multiLine*/
+              true
+            );
+            const staticBlock = factory2.createClassStaticBlockDeclaration(body);
+            result = [staticBlock, result];
+            classInfo.pendingStaticInitializers = void 0;
+          }
+        }
       }
       exitClassElement();
       return result;
@@ -97007,7 +97062,7 @@ ${lanes.join("\n")}
       }
       enterClassElement(node);
       Debug.assert(!isAmbientPropertyDeclaration(node), "Not yet implemented.");
-      const { modifiers, name, initializersName, descriptorName, thisArg } = partialTransformClassElement(node, classInfo, hasAccessorModifier(node) ? createAccessorPropertyDescriptorObject : void 0);
+      const { modifiers, name, initializersName, extraInitializersName, descriptorName, thisArg } = partialTransformClassElement(node, classInfo, hasAccessorModifier(node) ? createAccessorPropertyDescriptorObject : void 0);
       startLexicalEnvironment();
       let initializer = visitNode(node.initializer, visitor, isExpression);
       if (initializersName) {
@@ -97017,17 +97072,6 @@ ${lanes.join("\n")}
           initializer ?? factory2.createVoidZero()
         );
       }
-      if (!isStatic(node) && (classInfo == null ? void 0 : classInfo.instanceExtraInitializersName) && !(classInfo == null ? void 0 : classInfo.hasInjectedInstanceInitializers)) {
-        classInfo.hasInjectedInstanceInitializers = true;
-        initializer ?? (initializer = factory2.createVoidZero());
-        initializer = factory2.createParenthesizedExpression(factory2.createComma(
-          emitHelpers().createRunInitializersHelper(
-            factory2.createThis(),
-            classInfo.instanceExtraInitializersName
-          ),
-          initializer
-        ));
-      }
       if (isStatic(node) && classInfo && initializer) {
         classInfo.hasStaticInitializers = true;
       }
@@ -97038,6 +97082,41 @@ ${lanes.join("\n")}
           factory2.createReturnStatement(initializer)
         ]);
       }
+      if (classInfo) {
+        if (isStatic(node)) {
+          initializer = injectPendingInitializers(
+            classInfo,
+            /*isStatic*/
+            true,
+            initializer
+          );
+          if (extraInitializersName) {
+            classInfo.pendingStaticInitializers ?? (classInfo.pendingStaticInitializers = []);
+            classInfo.pendingStaticInitializers.push(
+              emitHelpers().createRunInitializersHelper(
+                classInfo.classThis ?? factory2.createThis(),
+                extraInitializersName
+              )
+            );
+          }
+        } else {
+          initializer = injectPendingInitializers(
+            classInfo,
+            /*isStatic*/
+            false,
+            initializer
+          );
+          if (extraInitializersName) {
+            classInfo.pendingInstanceInitializers ?? (classInfo.pendingInstanceInitializers = []);
+            classInfo.pendingInstanceInitializers.push(
+              emitHelpers().createRunInitializersHelper(
+                factory2.createThis(),
+                extraInitializersName
+              )
+            );
+          }
+        }
+      }
       exitClassElement();
       if (hasAccessorModifier(node) && descriptorName) {
         const commentRange = getCommentRange(node);
@@ -97452,19 +97531,41 @@ ${lanes.join("\n")}
       const expression = visitNode(node.expression, visitorFunc, isExpression);
       return factory2.updatePartiallyEmittedExpression(node, expression);
     }
-    function injectPendingExpressions(expression) {
-      if (some(pendingExpressions)) {
-        if (isParenthesizedExpression(expression)) {
-          pendingExpressions.push(expression.expression);
-          expression = factory2.updateParenthesizedExpression(expression, factory2.inlineExpressions(pendingExpressions));
+    function injectPendingExpressionsCommon(pendingExpressions2, expression) {
+      if (some(pendingExpressions2)) {
+        if (expression) {
+          if (isParenthesizedExpression(expression)) {
+            pendingExpressions2.push(expression.expression);
+            expression = factory2.updateParenthesizedExpression(expression, factory2.inlineExpressions(pendingExpressions2));
+          } else {
+            pendingExpressions2.push(expression);
+            expression = factory2.inlineExpressions(pendingExpressions2);
+          }
         } else {
-          pendingExpressions.push(expression);
-          expression = factory2.inlineExpressions(pendingExpressions);
+          expression = factory2.inlineExpressions(pendingExpressions2);
         }
-        pendingExpressions = void 0;
       }
       return expression;
     }
+    function injectPendingExpressions(expression) {
+      const result = injectPendingExpressionsCommon(pendingExpressions, expression);
+      Debug.assertIsDefined(result);
+      if (result !== expression) {
+        pendingExpressions = void 0;
+      }
+      return result;
+    }
+    function injectPendingInitializers(classInfo2, isStatic2, expression) {
+      const result = injectPendingExpressionsCommon(isStatic2 ? classInfo2.pendingStaticInitializers : classInfo2.pendingInstanceInitializers, expression);
+      if (result !== expression) {
+        if (isStatic2) {
+          classInfo2.pendingStaticInitializers = void 0;
+        } else {
+          classInfo2.pendingInstanceInitializers = void 0;
+        }
+      }
+      return result;
+    }
     function transformAllDecoratorsOfDeclaration(allDecorators) {
       if (!allDecorators) {
         return void 0;
@@ -138260,11 +138361,9 @@ ${lanes.join("\n")}
   function getRangeToExtract(context, considerEmptySpans = true) {
     const { file, startPosition } = context;
     const isJS = isSourceFileJS(file);
-    const current = getTokenAtPosition(file, startPosition);
     const range = createTextRangeFromSpan(getRefactorContextSpan(context));
-    const cursorRequest = range.pos === range.end && considerEmptySpans;
-    const overlappingRange = nodeOverlapsWithStartEnd(current, file, range.pos, range.end);
-    const firstType = findAncestor(current, (node) => node.parent && isTypeNode(node) && !rangeContainsSkipTrivia(range, node.parent, file) && (cursorRequest || overlappingRange));
+    const isCursorRequest = range.pos === range.end && considerEmptySpans;
+    const firstType = getFirstTypeAt(file, startPosition, range, isCursorRequest);
     if (!firstType || !isTypeNode(firstType))
       return { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) };
     const checker = context.program.getTypeChecker();
@@ -138290,6 +138389,21 @@ ${lanes.join("\n")}
     const typeElements = flattenTypeLiteralNodeReference(checker, selection);
     return { isJS, selection, enclosingNode, typeParameters, typeElements };
   }
+  function getFirstTypeAt(file, startPosition, range, isCursorRequest) {
+    const currentNodes = [
+      () => getTokenAtPosition(file, startPosition),
+      () => getTouchingToken(file, startPosition, () => true)
+    ];
+    for (const f of currentNodes) {
+      const current = f();
+      const overlappingRange = nodeOverlapsWithStartEnd(current, file, range.pos, range.end);
+      const firstType = findAncestor(current, (node) => node.parent && isTypeNode(node) && !rangeContainsSkipTrivia(range, node.parent, file) && (isCursorRequest || overlappingRange));
+      if (firstType) {
+        return firstType;
+      }
+    }
+    return void 0;
+  }
   function flattenTypeLiteralNodeReference(checker, selection) {
     if (!selection)
       return void 0;
@@ -145058,13 +145172,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-dev.20240104`;
+var version = `${versionMajorMinor}.0-dev.20240106`;
 
 // 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.4.0-dev.20240104",
+    "version": "5.4.0-dev.20240106",
     "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": "0ea57f6ca19c23e0bc690bd2706f6b6e11a97e02"
+    "gitHead": "01a51d2d017dd50d487835282b7e4a2a4f7300ab"
 }