typescript 5.5.0-dev.20240229 → 5.5.0-dev.20240301

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/lib/tsc.js +40 -28
  2. package/lib/tsserver.js +40 -28
  3. package/lib/typescript.js +40 -28
  4. package/lib/typingsInstaller.js +1 -1
  5. package/package.json +2 -2
package/lib/tsc.js CHANGED
@@ -18,7 +18,7 @@ and limitations under the License.
18
18
 
19
19
  // src/compiler/corePublic.ts
20
20
  var versionMajorMinor = "5.5";
21
- var version = `${versionMajorMinor}.0-dev.20240229`;
21
+ var version = `${versionMajorMinor}.0-dev.20240301`;
22
22
 
23
23
  // src/compiler/core.ts
24
24
  var emptyArray = [];
@@ -78621,7 +78621,9 @@ function createTypeChecker(host) {
78621
78621
  function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
78622
78622
  const allowAsyncIterables = (use & 2 /* AllowsAsyncIterablesFlag */) !== 0;
78623
78623
  if (inputType === neverType) {
78624
- reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
78624
+ if (errorNode) {
78625
+ reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
78626
+ }
78625
78627
  return void 0;
78626
78628
  }
78627
78629
  const uplevelIteration = languageVersion >= 2 /* ES2015 */;
@@ -82555,6 +82557,15 @@ function createTypeChecker(host) {
82555
82557
  }
82556
82558
  return false;
82557
82559
  }
82560
+ function declaredParameterTypeContainsUndefined(parameter) {
82561
+ if (!parameter.type)
82562
+ return false;
82563
+ const type = getTypeFromTypeNode(parameter.type);
82564
+ return containsUndefinedType(type);
82565
+ }
82566
+ function requiresAddingImplicitUndefined(parameter) {
82567
+ return (isRequiredInitializedParameter(parameter) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
82568
+ }
82558
82569
  function isRequiredInitializedParameter(parameter) {
82559
82570
  return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
82560
82571
  }
@@ -82914,8 +82925,7 @@ function createTypeChecker(host) {
82914
82925
  isTopLevelValueImportEqualsWithEntityName,
82915
82926
  isDeclarationVisible,
82916
82927
  isImplementationOfOverload,
82917
- isRequiredInitializedParameter,
82918
- isOptionalUninitializedParameterProperty,
82928
+ requiresAddingImplicitUndefined,
82919
82929
  isExpandoFunctionDeclaration,
82920
82930
  getPropertiesOfContainerFunction,
82921
82931
  createTypeOfDeclaration,
@@ -108473,38 +108483,41 @@ function transformDeclarations(context) {
108473
108483
  if (shouldPrintWithInitializer(node)) {
108474
108484
  return;
108475
108485
  }
108476
- const shouldUseResolverType = node.kind === 169 /* Parameter */ && (resolver.isRequiredInitializedParameter(node) || resolver.isOptionalUninitializedParameterProperty(node));
108477
- if (type && !shouldUseResolverType) {
108486
+ const shouldAddImplicitUndefined = node.kind === 169 /* Parameter */ && resolver.requiresAddingImplicitUndefined(node);
108487
+ if (type && !shouldAddImplicitUndefined) {
108478
108488
  return visitNode(type, visitDeclarationSubtree, isTypeNode);
108479
108489
  }
108480
- if (!getParseTreeNode(node)) {
108481
- return type ? visitNode(type, visitDeclarationSubtree, isTypeNode) : factory2.createKeywordTypeNode(133 /* AnyKeyword */);
108482
- }
108483
- if (node.kind === 178 /* SetAccessor */) {
108484
- return factory2.createKeywordTypeNode(133 /* AnyKeyword */);
108485
- }
108486
108490
  errorNameNode = node.name;
108487
108491
  let oldDiag;
108488
108492
  if (!suppressNewDiagnosticContexts) {
108489
108493
  oldDiag = getSymbolAccessibilityDiagnostic;
108490
108494
  getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
108491
108495
  }
108492
- if (node.kind === 260 /* VariableDeclaration */ || node.kind === 208 /* BindingElement */) {
108493
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
108494
- }
108495
- if (node.kind === 169 /* Parameter */ || node.kind === 172 /* PropertyDeclaration */ || node.kind === 171 /* PropertySignature */) {
108496
- if (isPropertySignature(node) || !node.initializer)
108497
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType));
108498
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
108496
+ let typeNode;
108497
+ switch (node.kind) {
108498
+ case 169 /* Parameter */:
108499
+ case 171 /* PropertySignature */:
108500
+ case 172 /* PropertyDeclaration */:
108501
+ case 208 /* BindingElement */:
108502
+ case 260 /* VariableDeclaration */:
108503
+ typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
108504
+ break;
108505
+ case 262 /* FunctionDeclaration */:
108506
+ case 180 /* ConstructSignature */:
108507
+ case 173 /* MethodSignature */:
108508
+ case 174 /* MethodDeclaration */:
108509
+ case 177 /* GetAccessor */:
108510
+ case 179 /* CallSignature */:
108511
+ typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
108512
+ break;
108513
+ default:
108514
+ Debug.assertNever(node);
108499
108515
  }
108500
- return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
108501
- function cleanup(returnValue) {
108502
- errorNameNode = void 0;
108503
- if (!suppressNewDiagnosticContexts) {
108504
- getSymbolAccessibilityDiagnostic = oldDiag;
108505
- }
108506
- return returnValue || factory2.createKeywordTypeNode(133 /* AnyKeyword */);
108516
+ errorNameNode = void 0;
108517
+ if (!suppressNewDiagnosticContexts) {
108518
+ getSymbolAccessibilityDiagnostic = oldDiag;
108507
108519
  }
108520
+ return typeNode ?? factory2.createKeywordTypeNode(133 /* AnyKeyword */);
108508
108521
  }
108509
108522
  function isDeclarationAndNotVisible(node) {
108510
108523
  node = getParseTreeNode(node);
@@ -110697,8 +110710,7 @@ var notImplementedResolver = {
110697
110710
  isLateBound: (_node) => false,
110698
110711
  collectLinkedAliases: notImplemented,
110699
110712
  isImplementationOfOverload: notImplemented,
110700
- isRequiredInitializedParameter: notImplemented,
110701
- isOptionalUninitializedParameterProperty: notImplemented,
110713
+ requiresAddingImplicitUndefined: notImplemented,
110702
110714
  isExpandoFunctionDeclaration: notImplemented,
110703
110715
  getPropertiesOfContainerFunction: notImplemented,
110704
110716
  createTypeOfDeclaration: notImplemented,
package/lib/tsserver.js CHANGED
@@ -2325,7 +2325,7 @@ module.exports = __toCommonJS(server_exports);
2325
2325
 
2326
2326
  // src/compiler/corePublic.ts
2327
2327
  var versionMajorMinor = "5.5";
2328
- var version = `${versionMajorMinor}.0-dev.20240229`;
2328
+ var version = `${versionMajorMinor}.0-dev.20240301`;
2329
2329
  var Comparison = /* @__PURE__ */ ((Comparison3) => {
2330
2330
  Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
2331
2331
  Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -83340,7 +83340,9 @@ function createTypeChecker(host) {
83340
83340
  function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
83341
83341
  const allowAsyncIterables = (use & 2 /* AllowsAsyncIterablesFlag */) !== 0;
83342
83342
  if (inputType === neverType) {
83343
- reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
83343
+ if (errorNode) {
83344
+ reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
83345
+ }
83344
83346
  return void 0;
83345
83347
  }
83346
83348
  const uplevelIteration = languageVersion >= 2 /* ES2015 */;
@@ -87274,6 +87276,15 @@ function createTypeChecker(host) {
87274
87276
  }
87275
87277
  return false;
87276
87278
  }
87279
+ function declaredParameterTypeContainsUndefined(parameter) {
87280
+ if (!parameter.type)
87281
+ return false;
87282
+ const type = getTypeFromTypeNode(parameter.type);
87283
+ return containsUndefinedType(type);
87284
+ }
87285
+ function requiresAddingImplicitUndefined(parameter) {
87286
+ return (isRequiredInitializedParameter(parameter) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
87287
+ }
87277
87288
  function isRequiredInitializedParameter(parameter) {
87278
87289
  return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
87279
87290
  }
@@ -87633,8 +87644,7 @@ function createTypeChecker(host) {
87633
87644
  isTopLevelValueImportEqualsWithEntityName,
87634
87645
  isDeclarationVisible,
87635
87646
  isImplementationOfOverload,
87636
- isRequiredInitializedParameter,
87637
- isOptionalUninitializedParameterProperty,
87647
+ requiresAddingImplicitUndefined,
87638
87648
  isExpandoFunctionDeclaration,
87639
87649
  getPropertiesOfContainerFunction,
87640
87650
  createTypeOfDeclaration,
@@ -113379,38 +113389,41 @@ function transformDeclarations(context) {
113379
113389
  if (shouldPrintWithInitializer(node)) {
113380
113390
  return;
113381
113391
  }
113382
- const shouldUseResolverType = node.kind === 169 /* Parameter */ && (resolver.isRequiredInitializedParameter(node) || resolver.isOptionalUninitializedParameterProperty(node));
113383
- if (type && !shouldUseResolverType) {
113392
+ const shouldAddImplicitUndefined = node.kind === 169 /* Parameter */ && resolver.requiresAddingImplicitUndefined(node);
113393
+ if (type && !shouldAddImplicitUndefined) {
113384
113394
  return visitNode(type, visitDeclarationSubtree, isTypeNode);
113385
113395
  }
113386
- if (!getParseTreeNode(node)) {
113387
- return type ? visitNode(type, visitDeclarationSubtree, isTypeNode) : factory2.createKeywordTypeNode(133 /* AnyKeyword */);
113388
- }
113389
- if (node.kind === 178 /* SetAccessor */) {
113390
- return factory2.createKeywordTypeNode(133 /* AnyKeyword */);
113391
- }
113392
113396
  errorNameNode = node.name;
113393
113397
  let oldDiag;
113394
113398
  if (!suppressNewDiagnosticContexts) {
113395
113399
  oldDiag = getSymbolAccessibilityDiagnostic;
113396
113400
  getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
113397
113401
  }
113398
- if (node.kind === 260 /* VariableDeclaration */ || node.kind === 208 /* BindingElement */) {
113399
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
113400
- }
113401
- if (node.kind === 169 /* Parameter */ || node.kind === 172 /* PropertyDeclaration */ || node.kind === 171 /* PropertySignature */) {
113402
- if (isPropertySignature(node) || !node.initializer)
113403
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType));
113404
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
113402
+ let typeNode;
113403
+ switch (node.kind) {
113404
+ case 169 /* Parameter */:
113405
+ case 171 /* PropertySignature */:
113406
+ case 172 /* PropertyDeclaration */:
113407
+ case 208 /* BindingElement */:
113408
+ case 260 /* VariableDeclaration */:
113409
+ typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
113410
+ break;
113411
+ case 262 /* FunctionDeclaration */:
113412
+ case 180 /* ConstructSignature */:
113413
+ case 173 /* MethodSignature */:
113414
+ case 174 /* MethodDeclaration */:
113415
+ case 177 /* GetAccessor */:
113416
+ case 179 /* CallSignature */:
113417
+ typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
113418
+ break;
113419
+ default:
113420
+ Debug.assertNever(node);
113405
113421
  }
113406
- return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
113407
- function cleanup(returnValue) {
113408
- errorNameNode = void 0;
113409
- if (!suppressNewDiagnosticContexts) {
113410
- getSymbolAccessibilityDiagnostic = oldDiag;
113411
- }
113412
- return returnValue || factory2.createKeywordTypeNode(133 /* AnyKeyword */);
113422
+ errorNameNode = void 0;
113423
+ if (!suppressNewDiagnosticContexts) {
113424
+ getSymbolAccessibilityDiagnostic = oldDiag;
113413
113425
  }
113426
+ return typeNode ?? factory2.createKeywordTypeNode(133 /* AnyKeyword */);
113414
113427
  }
113415
113428
  function isDeclarationAndNotVisible(node) {
113416
113429
  node = getParseTreeNode(node);
@@ -115614,8 +115627,7 @@ var notImplementedResolver = {
115614
115627
  isLateBound: (_node) => false,
115615
115628
  collectLinkedAliases: notImplemented,
115616
115629
  isImplementationOfOverload: notImplemented,
115617
- isRequiredInitializedParameter: notImplemented,
115618
- isOptionalUninitializedParameterProperty: notImplemented,
115630
+ requiresAddingImplicitUndefined: notImplemented,
115619
115631
  isExpandoFunctionDeclaration: notImplemented,
115620
115632
  getPropertiesOfContainerFunction: notImplemented,
115621
115633
  createTypeOfDeclaration: notImplemented,
package/lib/typescript.js CHANGED
@@ -35,7 +35,7 @@ var ts = (() => {
35
35
  "src/compiler/corePublic.ts"() {
36
36
  "use strict";
37
37
  versionMajorMinor = "5.5";
38
- version = `${versionMajorMinor}.0-dev.20240229`;
38
+ version = `${versionMajorMinor}.0-dev.20240301`;
39
39
  Comparison = /* @__PURE__ */ ((Comparison3) => {
40
40
  Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
41
41
  Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -81111,7 +81111,9 @@ ${lanes.join("\n")}
81111
81111
  function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
81112
81112
  const allowAsyncIterables = (use & 2 /* AllowsAsyncIterablesFlag */) !== 0;
81113
81113
  if (inputType === neverType) {
81114
- reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
81114
+ if (errorNode) {
81115
+ reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
81116
+ }
81115
81117
  return void 0;
81116
81118
  }
81117
81119
  const uplevelIteration = languageVersion >= 2 /* ES2015 */;
@@ -85045,6 +85047,15 @@ ${lanes.join("\n")}
85045
85047
  }
85046
85048
  return false;
85047
85049
  }
85050
+ function declaredParameterTypeContainsUndefined(parameter) {
85051
+ if (!parameter.type)
85052
+ return false;
85053
+ const type = getTypeFromTypeNode(parameter.type);
85054
+ return containsUndefinedType(type);
85055
+ }
85056
+ function requiresAddingImplicitUndefined(parameter) {
85057
+ return (isRequiredInitializedParameter(parameter) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
85058
+ }
85048
85059
  function isRequiredInitializedParameter(parameter) {
85049
85060
  return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 31 /* ParameterPropertyModifier */);
85050
85061
  }
@@ -85404,8 +85415,7 @@ ${lanes.join("\n")}
85404
85415
  isTopLevelValueImportEqualsWithEntityName,
85405
85416
  isDeclarationVisible,
85406
85417
  isImplementationOfOverload,
85407
- isRequiredInitializedParameter,
85408
- isOptionalUninitializedParameterProperty,
85418
+ requiresAddingImplicitUndefined,
85409
85419
  isExpandoFunctionDeclaration,
85410
85420
  getPropertiesOfContainerFunction,
85411
85421
  createTypeOfDeclaration,
@@ -111454,38 +111464,41 @@ ${lanes.join("\n")}
111454
111464
  if (shouldPrintWithInitializer(node)) {
111455
111465
  return;
111456
111466
  }
111457
- const shouldUseResolverType = node.kind === 169 /* Parameter */ && (resolver.isRequiredInitializedParameter(node) || resolver.isOptionalUninitializedParameterProperty(node));
111458
- if (type && !shouldUseResolverType) {
111467
+ const shouldAddImplicitUndefined = node.kind === 169 /* Parameter */ && resolver.requiresAddingImplicitUndefined(node);
111468
+ if (type && !shouldAddImplicitUndefined) {
111459
111469
  return visitNode(type, visitDeclarationSubtree, isTypeNode);
111460
111470
  }
111461
- if (!getParseTreeNode(node)) {
111462
- return type ? visitNode(type, visitDeclarationSubtree, isTypeNode) : factory2.createKeywordTypeNode(133 /* AnyKeyword */);
111463
- }
111464
- if (node.kind === 178 /* SetAccessor */) {
111465
- return factory2.createKeywordTypeNode(133 /* AnyKeyword */);
111466
- }
111467
111471
  errorNameNode = node.name;
111468
111472
  let oldDiag;
111469
111473
  if (!suppressNewDiagnosticContexts) {
111470
111474
  oldDiag = getSymbolAccessibilityDiagnostic;
111471
111475
  getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
111472
111476
  }
111473
- if (node.kind === 260 /* VariableDeclaration */ || node.kind === 208 /* BindingElement */) {
111474
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
111475
- }
111476
- if (node.kind === 169 /* Parameter */ || node.kind === 172 /* PropertyDeclaration */ || node.kind === 171 /* PropertySignature */) {
111477
- if (isPropertySignature(node) || !node.initializer)
111478
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType));
111479
- return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
111477
+ let typeNode;
111478
+ switch (node.kind) {
111479
+ case 169 /* Parameter */:
111480
+ case 171 /* PropertySignature */:
111481
+ case 172 /* PropertyDeclaration */:
111482
+ case 208 /* BindingElement */:
111483
+ case 260 /* VariableDeclaration */:
111484
+ typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
111485
+ break;
111486
+ case 262 /* FunctionDeclaration */:
111487
+ case 180 /* ConstructSignature */:
111488
+ case 173 /* MethodSignature */:
111489
+ case 174 /* MethodDeclaration */:
111490
+ case 177 /* GetAccessor */:
111491
+ case 179 /* CallSignature */:
111492
+ typeNode = resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
111493
+ break;
111494
+ default:
111495
+ Debug.assertNever(node);
111480
111496
  }
111481
- return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
111482
- function cleanup(returnValue) {
111483
- errorNameNode = void 0;
111484
- if (!suppressNewDiagnosticContexts) {
111485
- getSymbolAccessibilityDiagnostic = oldDiag;
111486
- }
111487
- return returnValue || factory2.createKeywordTypeNode(133 /* AnyKeyword */);
111497
+ errorNameNode = void 0;
111498
+ if (!suppressNewDiagnosticContexts) {
111499
+ getSymbolAccessibilityDiagnostic = oldDiag;
111488
111500
  }
111501
+ return typeNode ?? factory2.createKeywordTypeNode(133 /* AnyKeyword */);
111489
111502
  }
111490
111503
  function isDeclarationAndNotVisible(node) {
111491
111504
  node = getParseTreeNode(node);
@@ -118122,8 +118135,7 @@ ${lanes.join("\n")}
118122
118135
  isLateBound: (_node) => false,
118123
118136
  collectLinkedAliases: notImplemented,
118124
118137
  isImplementationOfOverload: notImplemented,
118125
- isRequiredInitializedParameter: notImplemented,
118126
- isOptionalUninitializedParameterProperty: notImplemented,
118138
+ requiresAddingImplicitUndefined: notImplemented,
118127
118139
  isExpandoFunctionDeclaration: notImplemented,
118128
118140
  getPropertiesOfContainerFunction: notImplemented,
118129
118141
  createTypeOfDeclaration: notImplemented,
package/lib/typingsInstaller.js CHANGED
@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
54
54
 
55
55
  // src/compiler/corePublic.ts
56
56
  var versionMajorMinor = "5.5";
57
- var version = `${versionMajorMinor}.0-dev.20240229`;
57
+ var version = `${versionMajorMinor}.0-dev.20240301`;
58
58
 
59
59
  // src/compiler/core.ts
60
60
  var emptyArray = [];
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "typescript",
3
3
  "author": "Microsoft Corp.",
4
4
  "homepage": "https://www.typescriptlang.org/",
5
- "version": "5.5.0-dev.20240229",
5
+ "version": "5.5.0-dev.20240301",
6
6
  "license": "Apache-2.0",
7
7
  "description": "TypeScript is a language for application scale JavaScript development",
8
8
  "keywords": [
@@ -113,5 +113,5 @@
113
113
  "node": "20.1.0",
114
114
  "npm": "8.19.4"
115
115
  },
116
- "gitHead": "2d70b57df4b64a3daef252abb014562e6ccc8f3c"
116
+ "gitHead": "3964aa183eb66e3e853ffbe26be1125b5d22e5fd"
117
117
  }