@typescript-deploys/pr-build 5.3.0-pr-55714-7 → 5.3.0-pr-55696-3

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.
package/lib/lib.es5.d.ts CHANGED
@@ -1621,17 +1621,17 @@ type NonNullable<T> = T & {};
1621
1621
  /**
1622
1622
  * Obtain the parameters of a function type in a tuple
1623
1623
  */
1624
- type Parameters<T extends (...args: never) => any> = T extends (...args: infer P) => any ? P : never;
1624
+ type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
1625
1625
 
1626
1626
  /**
1627
1627
  * Obtain the parameters of a constructor function type in a tuple
1628
1628
  */
1629
- type ConstructorParameters<T extends abstract new (...args: never) => any> = T extends abstract new (...args: infer P) => any ? P : never;
1629
+ type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;
1630
1630
 
1631
1631
  /**
1632
1632
  * Obtain the return type of a function type
1633
1633
  */
1634
- type ReturnType<T extends (...args: never) => any> = T extends (...args: never) => infer R ? R : any;
1634
+ type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
1635
1635
 
1636
1636
  /**
1637
1637
  * Obtain the return type of a constructor function type
package/lib/tsc.js CHANGED
@@ -3704,6 +3704,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
3704
3704
  ObjectFlags3[ObjectFlags3["ClassOrInterface"] = 3] = "ClassOrInterface";
3705
3705
  ObjectFlags3[ObjectFlags3["RequiresWidening"] = 196608] = "RequiresWidening";
3706
3706
  ObjectFlags3[ObjectFlags3["PropagatingFlags"] = 458752] = "PropagatingFlags";
3707
+ ObjectFlags3[ObjectFlags3["InstantiatedMapped"] = 96] = "InstantiatedMapped";
3707
3708
  ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 1343] = "ObjectTypeKindMask";
3708
3709
  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
3709
3710
  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
@@ -62406,8 +62407,13 @@ function createTypeChecker(host) {
62406
62407
  if (getObjectFlags(type) & 4 /* Reference */ && type.node) {
62407
62408
  return type.node;
62408
62409
  }
62409
- if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
62410
- return type.symbol;
62410
+ if (type.symbol) {
62411
+ if (getObjectFlags(type) & 32 /* Mapped */) {
62412
+ type = getMappedTargetWithSymbol(type);
62413
+ }
62414
+ if (!(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
62415
+ return type.symbol;
62416
+ }
62411
62417
  }
62412
62418
  if (isTupleType(type)) {
62413
62419
  return type.target;
@@ -62427,6 +62433,13 @@ function createTypeChecker(host) {
62427
62433
  }
62428
62434
  return type;
62429
62435
  }
62436
+ function getMappedTargetWithSymbol(type) {
62437
+ let target = type;
62438
+ while ((getObjectFlags(target) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && isMappedTypeWithKeyofConstraintDeclaration(target)) {
62439
+ target = getModifiersTypeFromMappedType(target);
62440
+ }
62441
+ return target.symbol ? target : type;
62442
+ }
62430
62443
  function isPropertyIdenticalTo(sourceProp, targetProp) {
62431
62444
  return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
62432
62445
  }
@@ -79186,14 +79199,19 @@ function createTypeChecker(host) {
79186
79199
  function computeConstantValue(member) {
79187
79200
  const isConstEnum = isEnumConst(member.parent);
79188
79201
  const initializer = member.initializer;
79189
- const value = evaluate(initializer, member);
79190
- if (value !== void 0) {
79202
+ const evaluated = evaluate(initializer, member);
79203
+ if (evaluated) {
79204
+ const { value } = evaluated;
79191
79205
  if (isConstEnum && typeof value === "number" && !isFinite(value)) {
79192
79206
  error(
79193
79207
  initializer,
79194
79208
  isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value
79195
79209
  );
79210
+ } else if (typeof value !== "string" && typeof value !== "number") {
79211
+ checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
79212
+ return void 0;
79196
79213
  }
79214
+ return value;
79197
79215
  } else if (isConstEnum) {
79198
79216
  error(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
79199
79217
  } else if (member.parent.flags & 33554432 /* Ambient */) {
@@ -79201,65 +79219,113 @@ function createTypeChecker(host) {
79201
79219
  } else {
79202
79220
  checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
79203
79221
  }
79204
- return value;
79222
+ return void 0;
79205
79223
  }
79206
79224
  function evaluate(expr, location) {
79207
79225
  switch (expr.kind) {
79208
- case 224 /* PrefixUnaryExpression */:
79209
- const value = evaluate(expr.operand, location);
79226
+ case 224 /* PrefixUnaryExpression */: {
79227
+ const evaluated = evaluate(expr.operand, location);
79228
+ if (!evaluated) {
79229
+ break;
79230
+ }
79231
+ const { value } = evaluated;
79210
79232
  if (typeof value === "number") {
79211
79233
  switch (expr.operator) {
79212
79234
  case 40 /* PlusToken */:
79213
- return value;
79235
+ return { value };
79214
79236
  case 41 /* MinusToken */:
79215
- return -value;
79237
+ return { value: -value };
79216
79238
  case 55 /* TildeToken */:
79217
- return ~value;
79239
+ return { value: ~value };
79218
79240
  }
79219
79241
  }
79242
+ if (typeof value === "boolean" && expr.operator === 54 /* ExclamationToken */) {
79243
+ return { value: !value };
79244
+ }
79220
79245
  break;
79221
- case 226 /* BinaryExpression */:
79222
- const left = evaluate(expr.left, location);
79223
- const right = evaluate(expr.right, location);
79246
+ }
79247
+ case 226 /* BinaryExpression */: {
79248
+ const evaluatedLeft = evaluate(expr.left, location);
79249
+ if (!evaluatedLeft) {
79250
+ break;
79251
+ }
79252
+ const evaluatedRight = evaluate(expr.right, location);
79253
+ if (!evaluatedRight) {
79254
+ break;
79255
+ }
79256
+ const left = evaluatedLeft.value;
79257
+ const right = evaluatedRight.value;
79224
79258
  if (typeof left === "number" && typeof right === "number") {
79225
79259
  switch (expr.operatorToken.kind) {
79226
79260
  case 52 /* BarToken */:
79227
- return left | right;
79261
+ return { value: left | right };
79228
79262
  case 51 /* AmpersandToken */:
79229
- return left & right;
79263
+ return { value: left & right };
79230
79264
  case 49 /* GreaterThanGreaterThanToken */:
79231
- return left >> right;
79265
+ return { value: left >> right };
79232
79266
  case 50 /* GreaterThanGreaterThanGreaterThanToken */:
79233
- return left >>> right;
79267
+ return { value: left >>> right };
79234
79268
  case 48 /* LessThanLessThanToken */:
79235
- return left << right;
79269
+ return { value: left << right };
79236
79270
  case 53 /* CaretToken */:
79237
- return left ^ right;
79271
+ return { value: left ^ right };
79238
79272
  case 42 /* AsteriskToken */:
79239
- return left * right;
79273
+ return { value: left * right };
79240
79274
  case 44 /* SlashToken */:
79241
- return left / right;
79275
+ return { value: left / right };
79242
79276
  case 40 /* PlusToken */:
79243
- return left + right;
79277
+ return { value: left + right };
79244
79278
  case 41 /* MinusToken */:
79245
- return left - right;
79279
+ return { value: left - right };
79246
79280
  case 45 /* PercentToken */:
79247
- return left % right;
79281
+ return { value: left % right };
79248
79282
  case 43 /* AsteriskAsteriskToken */:
79249
- return left ** right;
79283
+ return { value: left ** right };
79250
79284
  }
79251
- } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
79252
- return "" + left + right;
79285
+ } else if (typeof left === "bigint" && typeof right === "bigint") {
79286
+ switch (expr.operatorToken.kind) {
79287
+ case 52 /* BarToken */:
79288
+ return { value: left | right };
79289
+ case 51 /* AmpersandToken */:
79290
+ return { value: left & right };
79291
+ case 49 /* GreaterThanGreaterThanToken */:
79292
+ return { value: left >> right };
79293
+ case 48 /* LessThanLessThanToken */:
79294
+ return { value: left << right };
79295
+ case 53 /* CaretToken */:
79296
+ return { value: left ^ right };
79297
+ case 42 /* AsteriskToken */:
79298
+ return { value: left * right };
79299
+ case 44 /* SlashToken */:
79300
+ return { value: left / right };
79301
+ case 40 /* PlusToken */:
79302
+ return { value: left + right };
79303
+ case 41 /* MinusToken */:
79304
+ return { value: left - right };
79305
+ case 45 /* PercentToken */:
79306
+ return { value: left % right };
79307
+ case 43 /* AsteriskAsteriskToken */:
79308
+ return { value: left ** right };
79309
+ }
79310
+ } else if ((typeof left === "string" || typeof right === "string") && expr.operatorToken.kind === 40 /* PlusToken */) {
79311
+ return { value: "" + left + right };
79253
79312
  }
79254
79313
  break;
79314
+ }
79255
79315
  case 11 /* StringLiteral */:
79256
79316
  case 15 /* NoSubstitutionTemplateLiteral */:
79257
- return expr.text;
79258
- case 228 /* TemplateExpression */:
79259
- return evaluateTemplateExpression(expr, location);
79317
+ return { value: expr.text };
79318
+ case 228 /* TemplateExpression */: {
79319
+ const value = evaluateTemplateExpression(expr, location);
79320
+ if (typeof value === "undefined") {
79321
+ break;
79322
+ }
79323
+ return { value };
79324
+ }
79260
79325
  case 9 /* NumericLiteral */:
79261
- checkGrammarNumericLiteral(expr);
79262
- return +expr.text;
79326
+ return { value: +expr.text };
79327
+ case 10 /* BigIntLiteral */:
79328
+ return { value: BigInt(expr.text) };
79263
79329
  case 217 /* ParenthesizedExpression */:
79264
79330
  return evaluate(expr.expression, location);
79265
79331
  case 80 /* Identifier */: {
@@ -79275,7 +79341,7 @@ function createTypeChecker(host) {
79275
79341
  /*diagnostic*/
79276
79342
  void 0
79277
79343
  )) {
79278
- return +identifier.escapedText;
79344
+ return { value: +identifier.escapedText };
79279
79345
  }
79280
79346
  }
79281
79347
  case 211 /* PropertyAccessExpression */:
@@ -79288,7 +79354,11 @@ function createTypeChecker(host) {
79288
79354
  );
79289
79355
  if (symbol) {
79290
79356
  if (symbol.flags & 8 /* EnumMember */) {
79291
- return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
79357
+ const value = location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
79358
+ if (typeof value === "undefined") {
79359
+ break;
79360
+ }
79361
+ return { value };
79292
79362
  }
79293
79363
  if (isConstantVariable(symbol)) {
79294
79364
  const declaration = symbol.valueDeclaration;
@@ -79312,11 +79382,23 @@ function createTypeChecker(host) {
79312
79382
  const name = escapeLeadingUnderscores(expr.argumentExpression.text);
79313
79383
  const member = rootSymbol.exports.get(name);
79314
79384
  if (member) {
79315
- return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
79385
+ const value = location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
79386
+ if (typeof value === "undefined") {
79387
+ break;
79388
+ }
79389
+ return { value };
79316
79390
  }
79317
79391
  }
79318
79392
  }
79319
79393
  break;
79394
+ case 112 /* TrueKeyword */:
79395
+ return { value: true };
79396
+ case 97 /* FalseKeyword */:
79397
+ return { value: false };
79398
+ case 106 /* NullKeyword */:
79399
+ return { value: null };
79400
+ case 157 /* UndefinedKeyword */:
79401
+ return { value: void 0 };
79320
79402
  }
79321
79403
  return void 0;
79322
79404
  }
@@ -79335,11 +79417,11 @@ function createTypeChecker(host) {
79335
79417
  function evaluateTemplateExpression(expr, location) {
79336
79418
  let result = expr.head.text;
79337
79419
  for (const span of expr.templateSpans) {
79338
- const value = evaluate(span.expression, location);
79339
- if (value === void 0) {
79420
+ const evaluated = evaluate(span.expression, location);
79421
+ if (!evaluated) {
79340
79422
  return void 0;
79341
79423
  }
79342
- result += value;
79424
+ result += evaluated.value;
79343
79425
  result += span.literal.text;
79344
79426
  }
79345
79427
  return result;
package/lib/tsserver.js CHANGED
@@ -6695,6 +6695,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
6695
6695
  ObjectFlags3[ObjectFlags3["ClassOrInterface"] = 3] = "ClassOrInterface";
6696
6696
  ObjectFlags3[ObjectFlags3["RequiresWidening"] = 196608] = "RequiresWidening";
6697
6697
  ObjectFlags3[ObjectFlags3["PropagatingFlags"] = 458752] = "PropagatingFlags";
6698
+ ObjectFlags3[ObjectFlags3["InstantiatedMapped"] = 96] = "InstantiatedMapped";
6698
6699
  ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 1343] = "ObjectTypeKindMask";
6699
6700
  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
6700
6701
  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
@@ -67108,8 +67109,13 @@ function createTypeChecker(host) {
67108
67109
  if (getObjectFlags(type) & 4 /* Reference */ && type.node) {
67109
67110
  return type.node;
67110
67111
  }
67111
- if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
67112
- return type.symbol;
67112
+ if (type.symbol) {
67113
+ if (getObjectFlags(type) & 32 /* Mapped */) {
67114
+ type = getMappedTargetWithSymbol(type);
67115
+ }
67116
+ if (!(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
67117
+ return type.symbol;
67118
+ }
67113
67119
  }
67114
67120
  if (isTupleType(type)) {
67115
67121
  return type.target;
@@ -67129,6 +67135,13 @@ function createTypeChecker(host) {
67129
67135
  }
67130
67136
  return type;
67131
67137
  }
67138
+ function getMappedTargetWithSymbol(type) {
67139
+ let target = type;
67140
+ while ((getObjectFlags(target) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && isMappedTypeWithKeyofConstraintDeclaration(target)) {
67141
+ target = getModifiersTypeFromMappedType(target);
67142
+ }
67143
+ return target.symbol ? target : type;
67144
+ }
67132
67145
  function isPropertyIdenticalTo(sourceProp, targetProp) {
67133
67146
  return compareProperties2(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
67134
67147
  }
@@ -83888,14 +83901,19 @@ function createTypeChecker(host) {
83888
83901
  function computeConstantValue(member) {
83889
83902
  const isConstEnum = isEnumConst(member.parent);
83890
83903
  const initializer = member.initializer;
83891
- const value = evaluate(initializer, member);
83892
- if (value !== void 0) {
83904
+ const evaluated = evaluate(initializer, member);
83905
+ if (evaluated) {
83906
+ const { value } = evaluated;
83893
83907
  if (isConstEnum && typeof value === "number" && !isFinite(value)) {
83894
83908
  error2(
83895
83909
  initializer,
83896
83910
  isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value
83897
83911
  );
83912
+ } else if (typeof value !== "string" && typeof value !== "number") {
83913
+ checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
83914
+ return void 0;
83898
83915
  }
83916
+ return value;
83899
83917
  } else if (isConstEnum) {
83900
83918
  error2(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
83901
83919
  } else if (member.parent.flags & 33554432 /* Ambient */) {
@@ -83903,65 +83921,113 @@ function createTypeChecker(host) {
83903
83921
  } else {
83904
83922
  checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
83905
83923
  }
83906
- return value;
83924
+ return void 0;
83907
83925
  }
83908
83926
  function evaluate(expr, location) {
83909
83927
  switch (expr.kind) {
83910
- case 224 /* PrefixUnaryExpression */:
83911
- const value = evaluate(expr.operand, location);
83928
+ case 224 /* PrefixUnaryExpression */: {
83929
+ const evaluated = evaluate(expr.operand, location);
83930
+ if (!evaluated) {
83931
+ break;
83932
+ }
83933
+ const { value } = evaluated;
83912
83934
  if (typeof value === "number") {
83913
83935
  switch (expr.operator) {
83914
83936
  case 40 /* PlusToken */:
83915
- return value;
83937
+ return { value };
83916
83938
  case 41 /* MinusToken */:
83917
- return -value;
83939
+ return { value: -value };
83918
83940
  case 55 /* TildeToken */:
83919
- return ~value;
83941
+ return { value: ~value };
83920
83942
  }
83921
83943
  }
83944
+ if (typeof value === "boolean" && expr.operator === 54 /* ExclamationToken */) {
83945
+ return { value: !value };
83946
+ }
83922
83947
  break;
83923
- case 226 /* BinaryExpression */:
83924
- const left = evaluate(expr.left, location);
83925
- const right = evaluate(expr.right, location);
83948
+ }
83949
+ case 226 /* BinaryExpression */: {
83950
+ const evaluatedLeft = evaluate(expr.left, location);
83951
+ if (!evaluatedLeft) {
83952
+ break;
83953
+ }
83954
+ const evaluatedRight = evaluate(expr.right, location);
83955
+ if (!evaluatedRight) {
83956
+ break;
83957
+ }
83958
+ const left = evaluatedLeft.value;
83959
+ const right = evaluatedRight.value;
83926
83960
  if (typeof left === "number" && typeof right === "number") {
83927
83961
  switch (expr.operatorToken.kind) {
83928
83962
  case 52 /* BarToken */:
83929
- return left | right;
83963
+ return { value: left | right };
83930
83964
  case 51 /* AmpersandToken */:
83931
- return left & right;
83965
+ return { value: left & right };
83932
83966
  case 49 /* GreaterThanGreaterThanToken */:
83933
- return left >> right;
83967
+ return { value: left >> right };
83934
83968
  case 50 /* GreaterThanGreaterThanGreaterThanToken */:
83935
- return left >>> right;
83969
+ return { value: left >>> right };
83936
83970
  case 48 /* LessThanLessThanToken */:
83937
- return left << right;
83971
+ return { value: left << right };
83938
83972
  case 53 /* CaretToken */:
83939
- return left ^ right;
83973
+ return { value: left ^ right };
83940
83974
  case 42 /* AsteriskToken */:
83941
- return left * right;
83975
+ return { value: left * right };
83942
83976
  case 44 /* SlashToken */:
83943
- return left / right;
83977
+ return { value: left / right };
83944
83978
  case 40 /* PlusToken */:
83945
- return left + right;
83979
+ return { value: left + right };
83946
83980
  case 41 /* MinusToken */:
83947
- return left - right;
83981
+ return { value: left - right };
83948
83982
  case 45 /* PercentToken */:
83949
- return left % right;
83983
+ return { value: left % right };
83950
83984
  case 43 /* AsteriskAsteriskToken */:
83951
- return left ** right;
83985
+ return { value: left ** right };
83952
83986
  }
83953
- } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
83954
- return "" + left + right;
83987
+ } else if (typeof left === "bigint" && typeof right === "bigint") {
83988
+ switch (expr.operatorToken.kind) {
83989
+ case 52 /* BarToken */:
83990
+ return { value: left | right };
83991
+ case 51 /* AmpersandToken */:
83992
+ return { value: left & right };
83993
+ case 49 /* GreaterThanGreaterThanToken */:
83994
+ return { value: left >> right };
83995
+ case 48 /* LessThanLessThanToken */:
83996
+ return { value: left << right };
83997
+ case 53 /* CaretToken */:
83998
+ return { value: left ^ right };
83999
+ case 42 /* AsteriskToken */:
84000
+ return { value: left * right };
84001
+ case 44 /* SlashToken */:
84002
+ return { value: left / right };
84003
+ case 40 /* PlusToken */:
84004
+ return { value: left + right };
84005
+ case 41 /* MinusToken */:
84006
+ return { value: left - right };
84007
+ case 45 /* PercentToken */:
84008
+ return { value: left % right };
84009
+ case 43 /* AsteriskAsteriskToken */:
84010
+ return { value: left ** right };
84011
+ }
84012
+ } else if ((typeof left === "string" || typeof right === "string") && expr.operatorToken.kind === 40 /* PlusToken */) {
84013
+ return { value: "" + left + right };
83955
84014
  }
83956
84015
  break;
84016
+ }
83957
84017
  case 11 /* StringLiteral */:
83958
84018
  case 15 /* NoSubstitutionTemplateLiteral */:
83959
- return expr.text;
83960
- case 228 /* TemplateExpression */:
83961
- return evaluateTemplateExpression(expr, location);
84019
+ return { value: expr.text };
84020
+ case 228 /* TemplateExpression */: {
84021
+ const value = evaluateTemplateExpression(expr, location);
84022
+ if (typeof value === "undefined") {
84023
+ break;
84024
+ }
84025
+ return { value };
84026
+ }
83962
84027
  case 9 /* NumericLiteral */:
83963
- checkGrammarNumericLiteral(expr);
83964
- return +expr.text;
84028
+ return { value: +expr.text };
84029
+ case 10 /* BigIntLiteral */:
84030
+ return { value: BigInt(expr.text) };
83965
84031
  case 217 /* ParenthesizedExpression */:
83966
84032
  return evaluate(expr.expression, location);
83967
84033
  case 80 /* Identifier */: {
@@ -83977,7 +84043,7 @@ function createTypeChecker(host) {
83977
84043
  /*diagnostic*/
83978
84044
  void 0
83979
84045
  )) {
83980
- return +identifier.escapedText;
84046
+ return { value: +identifier.escapedText };
83981
84047
  }
83982
84048
  }
83983
84049
  case 211 /* PropertyAccessExpression */:
@@ -83990,7 +84056,11 @@ function createTypeChecker(host) {
83990
84056
  );
83991
84057
  if (symbol) {
83992
84058
  if (symbol.flags & 8 /* EnumMember */) {
83993
- return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
84059
+ const value = location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
84060
+ if (typeof value === "undefined") {
84061
+ break;
84062
+ }
84063
+ return { value };
83994
84064
  }
83995
84065
  if (isConstantVariable(symbol)) {
83996
84066
  const declaration = symbol.valueDeclaration;
@@ -84014,11 +84084,23 @@ function createTypeChecker(host) {
84014
84084
  const name = escapeLeadingUnderscores(expr.argumentExpression.text);
84015
84085
  const member = rootSymbol.exports.get(name);
84016
84086
  if (member) {
84017
- return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
84087
+ const value = location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
84088
+ if (typeof value === "undefined") {
84089
+ break;
84090
+ }
84091
+ return { value };
84018
84092
  }
84019
84093
  }
84020
84094
  }
84021
84095
  break;
84096
+ case 112 /* TrueKeyword */:
84097
+ return { value: true };
84098
+ case 97 /* FalseKeyword */:
84099
+ return { value: false };
84100
+ case 106 /* NullKeyword */:
84101
+ return { value: null };
84102
+ case 157 /* UndefinedKeyword */:
84103
+ return { value: void 0 };
84022
84104
  }
84023
84105
  return void 0;
84024
84106
  }
@@ -84037,11 +84119,11 @@ function createTypeChecker(host) {
84037
84119
  function evaluateTemplateExpression(expr, location) {
84038
84120
  let result = expr.head.text;
84039
84121
  for (const span of expr.templateSpans) {
84040
- const value = evaluate(span.expression, location);
84041
- if (value === void 0) {
84122
+ const evaluated = evaluate(span.expression, location);
84123
+ if (!evaluated) {
84042
84124
  return void 0;
84043
84125
  }
84044
- result += value;
84126
+ result += evaluated.value;
84045
84127
  result += span.literal.text;
84046
84128
  }
84047
84129
  return result;
package/lib/typescript.js CHANGED
@@ -4461,6 +4461,7 @@ ${lanes.join("\n")}
4461
4461
  ObjectFlags3[ObjectFlags3["ClassOrInterface"] = 3] = "ClassOrInterface";
4462
4462
  ObjectFlags3[ObjectFlags3["RequiresWidening"] = 196608] = "RequiresWidening";
4463
4463
  ObjectFlags3[ObjectFlags3["PropagatingFlags"] = 458752] = "PropagatingFlags";
4464
+ ObjectFlags3[ObjectFlags3["InstantiatedMapped"] = 96] = "InstantiatedMapped";
4464
4465
  ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 1343] = "ObjectTypeKindMask";
4465
4466
  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
4466
4467
  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
@@ -64875,8 +64876,13 @@ ${lanes.join("\n")}
64875
64876
  if (getObjectFlags(type) & 4 /* Reference */ && type.node) {
64876
64877
  return type.node;
64877
64878
  }
64878
- if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
64879
- return type.symbol;
64879
+ if (type.symbol) {
64880
+ if (getObjectFlags(type) & 32 /* Mapped */) {
64881
+ type = getMappedTargetWithSymbol(type);
64882
+ }
64883
+ if (!(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
64884
+ return type.symbol;
64885
+ }
64880
64886
  }
64881
64887
  if (isTupleType(type)) {
64882
64888
  return type.target;
@@ -64896,6 +64902,13 @@ ${lanes.join("\n")}
64896
64902
  }
64897
64903
  return type;
64898
64904
  }
64905
+ function getMappedTargetWithSymbol(type) {
64906
+ let target = type;
64907
+ while ((getObjectFlags(target) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && isMappedTypeWithKeyofConstraintDeclaration(target)) {
64908
+ target = getModifiersTypeFromMappedType(target);
64909
+ }
64910
+ return target.symbol ? target : type;
64911
+ }
64899
64912
  function isPropertyIdenticalTo(sourceProp, targetProp) {
64900
64913
  return compareProperties2(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
64901
64914
  }
@@ -81655,14 +81668,19 @@ ${lanes.join("\n")}
81655
81668
  function computeConstantValue(member) {
81656
81669
  const isConstEnum = isEnumConst(member.parent);
81657
81670
  const initializer = member.initializer;
81658
- const value = evaluate(initializer, member);
81659
- if (value !== void 0) {
81671
+ const evaluated = evaluate(initializer, member);
81672
+ if (evaluated) {
81673
+ const { value } = evaluated;
81660
81674
  if (isConstEnum && typeof value === "number" && !isFinite(value)) {
81661
81675
  error2(
81662
81676
  initializer,
81663
81677
  isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value
81664
81678
  );
81679
+ } else if (typeof value !== "string" && typeof value !== "number") {
81680
+ checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
81681
+ return void 0;
81665
81682
  }
81683
+ return value;
81666
81684
  } else if (isConstEnum) {
81667
81685
  error2(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
81668
81686
  } else if (member.parent.flags & 33554432 /* Ambient */) {
@@ -81670,65 +81688,113 @@ ${lanes.join("\n")}
81670
81688
  } else {
81671
81689
  checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
81672
81690
  }
81673
- return value;
81691
+ return void 0;
81674
81692
  }
81675
81693
  function evaluate(expr, location) {
81676
81694
  switch (expr.kind) {
81677
- case 224 /* PrefixUnaryExpression */:
81678
- const value = evaluate(expr.operand, location);
81695
+ case 224 /* PrefixUnaryExpression */: {
81696
+ const evaluated = evaluate(expr.operand, location);
81697
+ if (!evaluated) {
81698
+ break;
81699
+ }
81700
+ const { value } = evaluated;
81679
81701
  if (typeof value === "number") {
81680
81702
  switch (expr.operator) {
81681
81703
  case 40 /* PlusToken */:
81682
- return value;
81704
+ return { value };
81683
81705
  case 41 /* MinusToken */:
81684
- return -value;
81706
+ return { value: -value };
81685
81707
  case 55 /* TildeToken */:
81686
- return ~value;
81708
+ return { value: ~value };
81687
81709
  }
81688
81710
  }
81711
+ if (typeof value === "boolean" && expr.operator === 54 /* ExclamationToken */) {
81712
+ return { value: !value };
81713
+ }
81689
81714
  break;
81690
- case 226 /* BinaryExpression */:
81691
- const left = evaluate(expr.left, location);
81692
- const right = evaluate(expr.right, location);
81715
+ }
81716
+ case 226 /* BinaryExpression */: {
81717
+ const evaluatedLeft = evaluate(expr.left, location);
81718
+ if (!evaluatedLeft) {
81719
+ break;
81720
+ }
81721
+ const evaluatedRight = evaluate(expr.right, location);
81722
+ if (!evaluatedRight) {
81723
+ break;
81724
+ }
81725
+ const left = evaluatedLeft.value;
81726
+ const right = evaluatedRight.value;
81693
81727
  if (typeof left === "number" && typeof right === "number") {
81694
81728
  switch (expr.operatorToken.kind) {
81695
81729
  case 52 /* BarToken */:
81696
- return left | right;
81730
+ return { value: left | right };
81697
81731
  case 51 /* AmpersandToken */:
81698
- return left & right;
81732
+ return { value: left & right };
81699
81733
  case 49 /* GreaterThanGreaterThanToken */:
81700
- return left >> right;
81734
+ return { value: left >> right };
81701
81735
  case 50 /* GreaterThanGreaterThanGreaterThanToken */:
81702
- return left >>> right;
81736
+ return { value: left >>> right };
81703
81737
  case 48 /* LessThanLessThanToken */:
81704
- return left << right;
81738
+ return { value: left << right };
81705
81739
  case 53 /* CaretToken */:
81706
- return left ^ right;
81740
+ return { value: left ^ right };
81707
81741
  case 42 /* AsteriskToken */:
81708
- return left * right;
81742
+ return { value: left * right };
81709
81743
  case 44 /* SlashToken */:
81710
- return left / right;
81744
+ return { value: left / right };
81711
81745
  case 40 /* PlusToken */:
81712
- return left + right;
81746
+ return { value: left + right };
81713
81747
  case 41 /* MinusToken */:
81714
- return left - right;
81748
+ return { value: left - right };
81715
81749
  case 45 /* PercentToken */:
81716
- return left % right;
81750
+ return { value: left % right };
81717
81751
  case 43 /* AsteriskAsteriskToken */:
81718
- return left ** right;
81752
+ return { value: left ** right };
81719
81753
  }
81720
- } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
81721
- return "" + left + right;
81754
+ } else if (typeof left === "bigint" && typeof right === "bigint") {
81755
+ switch (expr.operatorToken.kind) {
81756
+ case 52 /* BarToken */:
81757
+ return { value: left | right };
81758
+ case 51 /* AmpersandToken */:
81759
+ return { value: left & right };
81760
+ case 49 /* GreaterThanGreaterThanToken */:
81761
+ return { value: left >> right };
81762
+ case 48 /* LessThanLessThanToken */:
81763
+ return { value: left << right };
81764
+ case 53 /* CaretToken */:
81765
+ return { value: left ^ right };
81766
+ case 42 /* AsteriskToken */:
81767
+ return { value: left * right };
81768
+ case 44 /* SlashToken */:
81769
+ return { value: left / right };
81770
+ case 40 /* PlusToken */:
81771
+ return { value: left + right };
81772
+ case 41 /* MinusToken */:
81773
+ return { value: left - right };
81774
+ case 45 /* PercentToken */:
81775
+ return { value: left % right };
81776
+ case 43 /* AsteriskAsteriskToken */:
81777
+ return { value: left ** right };
81778
+ }
81779
+ } else if ((typeof left === "string" || typeof right === "string") && expr.operatorToken.kind === 40 /* PlusToken */) {
81780
+ return { value: "" + left + right };
81722
81781
  }
81723
81782
  break;
81783
+ }
81724
81784
  case 11 /* StringLiteral */:
81725
81785
  case 15 /* NoSubstitutionTemplateLiteral */:
81726
- return expr.text;
81727
- case 228 /* TemplateExpression */:
81728
- return evaluateTemplateExpression(expr, location);
81786
+ return { value: expr.text };
81787
+ case 228 /* TemplateExpression */: {
81788
+ const value = evaluateTemplateExpression(expr, location);
81789
+ if (typeof value === "undefined") {
81790
+ break;
81791
+ }
81792
+ return { value };
81793
+ }
81729
81794
  case 9 /* NumericLiteral */:
81730
- checkGrammarNumericLiteral(expr);
81731
- return +expr.text;
81795
+ return { value: +expr.text };
81796
+ case 10 /* BigIntLiteral */:
81797
+ return { value: BigInt(expr.text) };
81732
81798
  case 217 /* ParenthesizedExpression */:
81733
81799
  return evaluate(expr.expression, location);
81734
81800
  case 80 /* Identifier */: {
@@ -81744,7 +81810,7 @@ ${lanes.join("\n")}
81744
81810
  /*diagnostic*/
81745
81811
  void 0
81746
81812
  )) {
81747
- return +identifier.escapedText;
81813
+ return { value: +identifier.escapedText };
81748
81814
  }
81749
81815
  }
81750
81816
  case 211 /* PropertyAccessExpression */:
@@ -81757,7 +81823,11 @@ ${lanes.join("\n")}
81757
81823
  );
81758
81824
  if (symbol) {
81759
81825
  if (symbol.flags & 8 /* EnumMember */) {
81760
- return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
81826
+ const value = location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
81827
+ if (typeof value === "undefined") {
81828
+ break;
81829
+ }
81830
+ return { value };
81761
81831
  }
81762
81832
  if (isConstantVariable(symbol)) {
81763
81833
  const declaration = symbol.valueDeclaration;
@@ -81781,11 +81851,23 @@ ${lanes.join("\n")}
81781
81851
  const name = escapeLeadingUnderscores(expr.argumentExpression.text);
81782
81852
  const member = rootSymbol.exports.get(name);
81783
81853
  if (member) {
81784
- return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
81854
+ const value = location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
81855
+ if (typeof value === "undefined") {
81856
+ break;
81857
+ }
81858
+ return { value };
81785
81859
  }
81786
81860
  }
81787
81861
  }
81788
81862
  break;
81863
+ case 112 /* TrueKeyword */:
81864
+ return { value: true };
81865
+ case 97 /* FalseKeyword */:
81866
+ return { value: false };
81867
+ case 106 /* NullKeyword */:
81868
+ return { value: null };
81869
+ case 157 /* UndefinedKeyword */:
81870
+ return { value: void 0 };
81789
81871
  }
81790
81872
  return void 0;
81791
81873
  }
@@ -81804,11 +81886,11 @@ ${lanes.join("\n")}
81804
81886
  function evaluateTemplateExpression(expr, location) {
81805
81887
  let result = expr.head.text;
81806
81888
  for (const span of expr.templateSpans) {
81807
- const value = evaluate(span.expression, location);
81808
- if (value === void 0) {
81889
+ const evaluated = evaluate(span.expression, location);
81890
+ if (!evaluated) {
81809
81891
  return void 0;
81810
81892
  }
81811
- result += value;
81893
+ result += evaluated.value;
81812
81894
  result += span.literal.text;
81813
81895
  }
81814
81896
  return result;
@@ -3138,6 +3138,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
3138
3138
  ObjectFlags3[ObjectFlags3["ClassOrInterface"] = 3] = "ClassOrInterface";
3139
3139
  ObjectFlags3[ObjectFlags3["RequiresWidening"] = 196608] = "RequiresWidening";
3140
3140
  ObjectFlags3[ObjectFlags3["PropagatingFlags"] = 458752] = "PropagatingFlags";
3141
+ ObjectFlags3[ObjectFlags3["InstantiatedMapped"] = 96] = "InstantiatedMapped";
3141
3142
  ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 1343] = "ObjectTypeKindMask";
3142
3143
  ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
3143
3144
  ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "@typescript-deploys/pr-build",
3
3
  "author": "Microsoft Corp.",
4
4
  "homepage": "https://www.typescriptlang.org/",
5
- "version": "5.3.0-pr-55714-7",
5
+ "version": "5.3.0-pr-55696-3",
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": "d1add8a7d0a772897a49938cd3ce8e5ee1361773"
116
+ "gitHead": "d855889d5e0e370ff7cf13b358a7dbbae5ad92ce"
117
117
  }