@typescript-deploys/pr-build 4.8.0-pr-49884-15 → 4.8.0-pr-49981-17

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/tsc.js CHANGED
@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
69
69
  var ts;
70
70
  (function (ts) {
71
71
  ts.versionMajorMinor = "4.8";
72
- ts.version = ts.versionMajorMinor + ".0-insiders.20220720";
72
+ ts.version = ts.versionMajorMinor + ".0-insiders.20220721";
73
73
  var NativeCollections;
74
74
  (function (NativeCollections) {
75
75
  var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -56693,18 +56693,26 @@ var ts;
56693
56693
  }
56694
56694
  return literalTypesWithSameBaseType(types) ?
56695
56695
  getUnionType(types) :
56696
- ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
56696
+ ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(getNonNullableTypeIfNeeded(s), getNonNullableTypeIfNeeded(t)) ? t : s; });
56697
56697
  }
56698
56698
  function getCommonSupertype(types) {
56699
56699
  if (!strictNullChecks) {
56700
56700
  return getSupertypeOrUnion(types);
56701
56701
  }
56702
- var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304); });
56703
- if (primaryTypes.length) {
56704
- var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
56705
- return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304); }), true));
56702
+ var supertypeOrUnion = getSupertypeOrUnion(types);
56703
+ var shouldHaveNull = ts.some(types, function (t) { return someHas(t, 65536); });
56704
+ var shouldHaveUndefined = ts.some(types, function (t) { return someHas(t, 32768); });
56705
+ var missingNullableFlags = 0;
56706
+ if (shouldHaveNull && !someHas(supertypeOrUnion, 65536)) {
56707
+ missingNullableFlags |= 65536;
56708
+ }
56709
+ if (shouldHaveUndefined && !someHas(supertypeOrUnion, 32768)) {
56710
+ missingNullableFlags |= 32768;
56711
+ }
56712
+ return getNullableType(supertypeOrUnion, missingNullableFlags);
56713
+ function someHas(type, flags) {
56714
+ return someType(type, function (t) { return !!(t.flags & flags); });
56706
56715
  }
56707
- return getUnionType(types, 2);
56708
56716
  }
56709
56717
  function getCommonSubtype(types) {
56710
56718
  return ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(t, s) ? t : s; });
@@ -56829,7 +56837,7 @@ var ts;
56829
56837
  if (!isLiteralOfContextualType(type, contextualType)) {
56830
56838
  type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
56831
56839
  }
56832
- return getRegularTypeOfLiteralType(type);
56840
+ return type;
56833
56841
  }
56834
56842
  function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
56835
56843
  if (type && isUnitType(type)) {
@@ -78644,7 +78652,8 @@ var ts;
78644
78652
  else {
78645
78653
  statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
78646
78654
  }
78647
- ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
78655
+ var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
78656
+ ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
78648
78657
  statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
78649
78658
  var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), true);
78650
78659
  ts.setTextRange(block, body);
package/lib/tsserver.js CHANGED
@@ -109,7 +109,7 @@ var ts;
109
109
  // The following is baselined as a literal template type without intervention
110
110
  /** The version of the TypeScript compiler release */
111
111
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
112
- ts.version = ts.versionMajorMinor + ".0-insiders.20220720";
112
+ ts.version = ts.versionMajorMinor + ".0-insiders.20220721";
113
113
  /* @internal */
114
114
  var Comparison;
115
115
  (function (Comparison) {
@@ -67965,18 +67965,26 @@ var ts;
67965
67965
  }
67966
67966
  return literalTypesWithSameBaseType(types) ?
67967
67967
  getUnionType(types) :
67968
- ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
67968
+ ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(getNonNullableTypeIfNeeded(s), getNonNullableTypeIfNeeded(t)) ? t : s; });
67969
67969
  }
67970
67970
  function getCommonSupertype(types) {
67971
67971
  if (!strictNullChecks) {
67972
67972
  return getSupertypeOrUnion(types);
67973
67973
  }
67974
- var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
67975
- if (primaryTypes.length) {
67976
- var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
67977
- return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
67974
+ var supertypeOrUnion = getSupertypeOrUnion(types);
67975
+ var shouldHaveNull = ts.some(types, function (t) { return someHas(t, 65536 /* Null */); });
67976
+ var shouldHaveUndefined = ts.some(types, function (t) { return someHas(t, 32768 /* Undefined */); });
67977
+ var missingNullableFlags = 0;
67978
+ if (shouldHaveNull && !someHas(supertypeOrUnion, 65536 /* Null */)) {
67979
+ missingNullableFlags |= 65536 /* Null */;
67980
+ }
67981
+ if (shouldHaveUndefined && !someHas(supertypeOrUnion, 32768 /* Undefined */)) {
67982
+ missingNullableFlags |= 32768 /* Undefined */;
67983
+ }
67984
+ return getNullableType(supertypeOrUnion, missingNullableFlags);
67985
+ function someHas(type, flags) {
67986
+ return someType(type, function (t) { return !!(t.flags & flags); });
67978
67987
  }
67979
- return getUnionType(types, 2 /* Subtype */);
67980
67988
  }
67981
67989
  // Return the leftmost type for which no type to the right is a subtype.
67982
67990
  function getCommonSubtype(types) {
@@ -68106,7 +68114,7 @@ var ts;
68106
68114
  if (!isLiteralOfContextualType(type, contextualType)) {
68107
68115
  type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
68108
68116
  }
68109
- return getRegularTypeOfLiteralType(type);
68117
+ return type;
68110
68118
  }
68111
68119
  function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
68112
68120
  if (type && isUnitType(type)) {
@@ -93512,7 +93520,8 @@ var ts;
93512
93520
  statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
93513
93521
  }
93514
93522
  // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
93515
- ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
93523
+ var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
93524
+ ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
93516
93525
  // End the lexical environment.
93517
93526
  statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
93518
93527
  var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -303,7 +303,7 @@ var ts;
303
303
  // The following is baselined as a literal template type without intervention
304
304
  /** The version of the TypeScript compiler release */
305
305
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
306
- ts.version = ts.versionMajorMinor + ".0-insiders.20220720";
306
+ ts.version = ts.versionMajorMinor + ".0-insiders.20220721";
307
307
  /* @internal */
308
308
  var Comparison;
309
309
  (function (Comparison) {
@@ -68159,18 +68159,26 @@ var ts;
68159
68159
  }
68160
68160
  return literalTypesWithSameBaseType(types) ?
68161
68161
  getUnionType(types) :
68162
- ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
68162
+ ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(getNonNullableTypeIfNeeded(s), getNonNullableTypeIfNeeded(t)) ? t : s; });
68163
68163
  }
68164
68164
  function getCommonSupertype(types) {
68165
68165
  if (!strictNullChecks) {
68166
68166
  return getSupertypeOrUnion(types);
68167
68167
  }
68168
- var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
68169
- if (primaryTypes.length) {
68170
- var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
68171
- return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
68168
+ var supertypeOrUnion = getSupertypeOrUnion(types);
68169
+ var shouldHaveNull = ts.some(types, function (t) { return someHas(t, 65536 /* Null */); });
68170
+ var shouldHaveUndefined = ts.some(types, function (t) { return someHas(t, 32768 /* Undefined */); });
68171
+ var missingNullableFlags = 0;
68172
+ if (shouldHaveNull && !someHas(supertypeOrUnion, 65536 /* Null */)) {
68173
+ missingNullableFlags |= 65536 /* Null */;
68174
+ }
68175
+ if (shouldHaveUndefined && !someHas(supertypeOrUnion, 32768 /* Undefined */)) {
68176
+ missingNullableFlags |= 32768 /* Undefined */;
68177
+ }
68178
+ return getNullableType(supertypeOrUnion, missingNullableFlags);
68179
+ function someHas(type, flags) {
68180
+ return someType(type, function (t) { return !!(t.flags & flags); });
68172
68181
  }
68173
- return getUnionType(types, 2 /* Subtype */);
68174
68182
  }
68175
68183
  // Return the leftmost type for which no type to the right is a subtype.
68176
68184
  function getCommonSubtype(types) {
@@ -68300,7 +68308,7 @@ var ts;
68300
68308
  if (!isLiteralOfContextualType(type, contextualType)) {
68301
68309
  type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
68302
68310
  }
68303
- return getRegularTypeOfLiteralType(type);
68311
+ return type;
68304
68312
  }
68305
68313
  function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
68306
68314
  if (type && isUnitType(type)) {
@@ -93706,7 +93714,8 @@ var ts;
93706
93714
  statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
93707
93715
  }
93708
93716
  // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
93709
- ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
93717
+ var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
93718
+ ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
93710
93719
  // End the lexical environment.
93711
93720
  statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
93712
93721
  var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
package/lib/typescript.js CHANGED
@@ -294,7 +294,7 @@ var ts;
294
294
  // The following is baselined as a literal template type without intervention
295
295
  /** The version of the TypeScript compiler release */
296
296
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
297
- ts.version = ts.versionMajorMinor + ".0-insiders.20220720";
297
+ ts.version = ts.versionMajorMinor + ".0-insiders.20220721";
298
298
  /* @internal */
299
299
  var Comparison;
300
300
  (function (Comparison) {
@@ -68150,18 +68150,26 @@ var ts;
68150
68150
  }
68151
68151
  return literalTypesWithSameBaseType(types) ?
68152
68152
  getUnionType(types) :
68153
- ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
68153
+ ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(getNonNullableTypeIfNeeded(s), getNonNullableTypeIfNeeded(t)) ? t : s; });
68154
68154
  }
68155
68155
  function getCommonSupertype(types) {
68156
68156
  if (!strictNullChecks) {
68157
68157
  return getSupertypeOrUnion(types);
68158
68158
  }
68159
- var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
68160
- if (primaryTypes.length) {
68161
- var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
68162
- return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
68159
+ var supertypeOrUnion = getSupertypeOrUnion(types);
68160
+ var shouldHaveNull = ts.some(types, function (t) { return someHas(t, 65536 /* Null */); });
68161
+ var shouldHaveUndefined = ts.some(types, function (t) { return someHas(t, 32768 /* Undefined */); });
68162
+ var missingNullableFlags = 0;
68163
+ if (shouldHaveNull && !someHas(supertypeOrUnion, 65536 /* Null */)) {
68164
+ missingNullableFlags |= 65536 /* Null */;
68165
+ }
68166
+ if (shouldHaveUndefined && !someHas(supertypeOrUnion, 32768 /* Undefined */)) {
68167
+ missingNullableFlags |= 32768 /* Undefined */;
68168
+ }
68169
+ return getNullableType(supertypeOrUnion, missingNullableFlags);
68170
+ function someHas(type, flags) {
68171
+ return someType(type, function (t) { return !!(t.flags & flags); });
68163
68172
  }
68164
- return getUnionType(types, 2 /* Subtype */);
68165
68173
  }
68166
68174
  // Return the leftmost type for which no type to the right is a subtype.
68167
68175
  function getCommonSubtype(types) {
@@ -68291,7 +68299,7 @@ var ts;
68291
68299
  if (!isLiteralOfContextualType(type, contextualType)) {
68292
68300
  type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
68293
68301
  }
68294
- return getRegularTypeOfLiteralType(type);
68302
+ return type;
68295
68303
  }
68296
68304
  function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
68297
68305
  if (type && isUnitType(type)) {
@@ -93697,7 +93705,8 @@ var ts;
93697
93705
  statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
93698
93706
  }
93699
93707
  // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
93700
- ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
93708
+ var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
93709
+ ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
93701
93710
  // End the lexical environment.
93702
93711
  statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
93703
93712
  var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -294,7 +294,7 @@ var ts;
294
294
  // The following is baselined as a literal template type without intervention
295
295
  /** The version of the TypeScript compiler release */
296
296
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
297
- ts.version = ts.versionMajorMinor + ".0-insiders.20220720";
297
+ ts.version = ts.versionMajorMinor + ".0-insiders.20220721";
298
298
  /* @internal */
299
299
  var Comparison;
300
300
  (function (Comparison) {
@@ -68150,18 +68150,26 @@ var ts;
68150
68150
  }
68151
68151
  return literalTypesWithSameBaseType(types) ?
68152
68152
  getUnionType(types) :
68153
- ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
68153
+ ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(getNonNullableTypeIfNeeded(s), getNonNullableTypeIfNeeded(t)) ? t : s; });
68154
68154
  }
68155
68155
  function getCommonSupertype(types) {
68156
68156
  if (!strictNullChecks) {
68157
68157
  return getSupertypeOrUnion(types);
68158
68158
  }
68159
- var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
68160
- if (primaryTypes.length) {
68161
- var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
68162
- return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
68159
+ var supertypeOrUnion = getSupertypeOrUnion(types);
68160
+ var shouldHaveNull = ts.some(types, function (t) { return someHas(t, 65536 /* Null */); });
68161
+ var shouldHaveUndefined = ts.some(types, function (t) { return someHas(t, 32768 /* Undefined */); });
68162
+ var missingNullableFlags = 0;
68163
+ if (shouldHaveNull && !someHas(supertypeOrUnion, 65536 /* Null */)) {
68164
+ missingNullableFlags |= 65536 /* Null */;
68165
+ }
68166
+ if (shouldHaveUndefined && !someHas(supertypeOrUnion, 32768 /* Undefined */)) {
68167
+ missingNullableFlags |= 32768 /* Undefined */;
68168
+ }
68169
+ return getNullableType(supertypeOrUnion, missingNullableFlags);
68170
+ function someHas(type, flags) {
68171
+ return someType(type, function (t) { return !!(t.flags & flags); });
68163
68172
  }
68164
- return getUnionType(types, 2 /* Subtype */);
68165
68173
  }
68166
68174
  // Return the leftmost type for which no type to the right is a subtype.
68167
68175
  function getCommonSubtype(types) {
@@ -68291,7 +68299,7 @@ var ts;
68291
68299
  if (!isLiteralOfContextualType(type, contextualType)) {
68292
68300
  type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
68293
68301
  }
68294
- return getRegularTypeOfLiteralType(type);
68302
+ return type;
68295
68303
  }
68296
68304
  function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
68297
68305
  if (type && isUnitType(type)) {
@@ -93697,7 +93705,8 @@ var ts;
93697
93705
  statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
93698
93706
  }
93699
93707
  // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
93700
- ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
93708
+ var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
93709
+ ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
93701
93710
  // End the lexical environment.
93702
93711
  statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
93703
93712
  var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
@@ -89,7 +89,7 @@ var ts;
89
89
  // The following is baselined as a literal template type without intervention
90
90
  /** The version of the TypeScript compiler release */
91
91
  // eslint-disable-next-line @typescript-eslint/no-inferrable-types
92
- ts.version = ts.versionMajorMinor + ".0-insiders.20220720";
92
+ ts.version = ts.versionMajorMinor + ".0-insiders.20220721";
93
93
  /* @internal */
94
94
  var Comparison;
95
95
  (function (Comparison) {
@@ -67945,18 +67945,26 @@ var ts;
67945
67945
  }
67946
67946
  return literalTypesWithSameBaseType(types) ?
67947
67947
  getUnionType(types) :
67948
- ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
67948
+ ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(getNonNullableTypeIfNeeded(s), getNonNullableTypeIfNeeded(t)) ? t : s; });
67949
67949
  }
67950
67950
  function getCommonSupertype(types) {
67951
67951
  if (!strictNullChecks) {
67952
67952
  return getSupertypeOrUnion(types);
67953
67953
  }
67954
- var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
67955
- if (primaryTypes.length) {
67956
- var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
67957
- return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
67954
+ var supertypeOrUnion = getSupertypeOrUnion(types);
67955
+ var shouldHaveNull = ts.some(types, function (t) { return someHas(t, 65536 /* Null */); });
67956
+ var shouldHaveUndefined = ts.some(types, function (t) { return someHas(t, 32768 /* Undefined */); });
67957
+ var missingNullableFlags = 0;
67958
+ if (shouldHaveNull && !someHas(supertypeOrUnion, 65536 /* Null */)) {
67959
+ missingNullableFlags |= 65536 /* Null */;
67960
+ }
67961
+ if (shouldHaveUndefined && !someHas(supertypeOrUnion, 32768 /* Undefined */)) {
67962
+ missingNullableFlags |= 32768 /* Undefined */;
67963
+ }
67964
+ return getNullableType(supertypeOrUnion, missingNullableFlags);
67965
+ function someHas(type, flags) {
67966
+ return someType(type, function (t) { return !!(t.flags & flags); });
67958
67967
  }
67959
- return getUnionType(types, 2 /* Subtype */);
67960
67968
  }
67961
67969
  // Return the leftmost type for which no type to the right is a subtype.
67962
67970
  function getCommonSubtype(types) {
@@ -68086,7 +68094,7 @@ var ts;
68086
68094
  if (!isLiteralOfContextualType(type, contextualType)) {
68087
68095
  type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
68088
68096
  }
68089
- return getRegularTypeOfLiteralType(type);
68097
+ return type;
68090
68098
  }
68091
68099
  function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
68092
68100
  if (type && isUnitType(type)) {
@@ -93492,7 +93500,8 @@ var ts;
93492
93500
  statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true);
93493
93501
  }
93494
93502
  // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements
93495
- ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, superStatementIndex + 1 + prologueStatementCount));
93503
+ var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
93504
+ ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start));
93496
93505
  // End the lexical environment.
93497
93506
  statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment());
93498
93507
  var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true);
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": "4.8.0-pr-49884-15",
5
+ "version": "4.8.0-pr-49981-17",
6
6
  "license": "Apache-2.0",
7
7
  "description": "TypeScript is a language for application scale JavaScript development",
8
8
  "keywords": [