@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 +3 -3
- package/lib/tsc.js +120 -38
- package/lib/tsserver.js +120 -38
- package/lib/typescript.js +120 -38
- package/lib/typingsInstaller.js +1 -0
- package/package.json +2 -2
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:
|
|
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:
|
|
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:
|
|
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
|
|
62410
|
-
|
|
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
|
|
79190
|
-
if (
|
|
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
|
|
79222
|
+
return void 0;
|
|
79205
79223
|
}
|
|
79206
79224
|
function evaluate(expr, location) {
|
|
79207
79225
|
switch (expr.kind) {
|
|
79208
|
-
case 224 /* PrefixUnaryExpression */:
|
|
79209
|
-
const
|
|
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
|
-
|
|
79222
|
-
|
|
79223
|
-
const
|
|
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 (
|
|
79252
|
-
|
|
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
|
-
|
|
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
|
-
|
|
79262
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
79339
|
-
if (
|
|
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
|
|
67112
|
-
|
|
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
|
|
83892
|
-
if (
|
|
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
|
|
83924
|
+
return void 0;
|
|
83907
83925
|
}
|
|
83908
83926
|
function evaluate(expr, location) {
|
|
83909
83927
|
switch (expr.kind) {
|
|
83910
|
-
case 224 /* PrefixUnaryExpression */:
|
|
83911
|
-
const
|
|
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
|
-
|
|
83924
|
-
|
|
83925
|
-
const
|
|
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 (
|
|
83954
|
-
|
|
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
|
-
|
|
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
|
-
|
|
83964
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
84041
|
-
if (
|
|
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
|
|
64879
|
-
|
|
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
|
|
81659
|
-
if (
|
|
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
|
|
81691
|
+
return void 0;
|
|
81674
81692
|
}
|
|
81675
81693
|
function evaluate(expr, location) {
|
|
81676
81694
|
switch (expr.kind) {
|
|
81677
|
-
case 224 /* PrefixUnaryExpression */:
|
|
81678
|
-
const
|
|
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
|
-
|
|
81691
|
-
|
|
81692
|
-
const
|
|
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 (
|
|
81721
|
-
|
|
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
|
-
|
|
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
|
-
|
|
81731
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
|
81808
|
-
if (
|
|
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;
|
package/lib/typingsInstaller.js
CHANGED
|
@@ -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-
|
|
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": "
|
|
116
|
+
"gitHead": "d855889d5e0e370ff7cf13b358a7dbbae5ad92ce"
|
|
117
117
|
}
|