@typescript-deploys/pr-build 4.9.0-pr-50831-12 → 4.9.0-pr-50759-10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/lib/tsc.js +4 -4
  2. package/lib/tsserver.js +4 -4
  3. package/lib/tsserverlibrary.js +4 -4
  4. package/lib/typescript.js +4 -4
  5. package/lib/typescriptServices.js +4 -4
  6. package/lib/typingsInstaller.js +4 -4
  7. package/package.json +1 -1
package/lib/tsc.js CHANGED
@@ -51677,7 +51677,7 @@ var ts;
51677
51677
  if (flags & (2 | 4)) {
51678
51678
  lastOptionalOrRestIndex = expandedFlags.length;
51679
51679
  }
51680
- expandedTypes.push(flags & 2 ? addOptionality(type, true) : type);
51680
+ expandedTypes.push(type);
51681
51681
  expandedFlags.push(flags);
51682
51682
  if (expandedDeclarations && declaration) {
51683
51683
  expandedDeclarations.push(declaration);
@@ -57478,8 +57478,7 @@ var ts;
57478
57478
  function getOptionalType(type, isProperty) {
57479
57479
  if (isProperty === void 0) { isProperty = false; }
57480
57480
  ts.Debug.assert(strictNullChecks);
57481
- var missingOrUndefined = isProperty ? missingType : undefinedType;
57482
- return type.flags & 32768 || type.flags & 1048576 && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
57481
+ return type.flags & 32768 ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
57483
57482
  }
57484
57483
  function getGlobalNonNullableTypeInstantiation(type) {
57485
57484
  if (!deferredGlobalNonNullableTypeAlias) {
@@ -67890,7 +67889,8 @@ var ts;
67890
67889
  if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
67891
67890
  inferenceContext.intraExpressionInferenceSites = undefined;
67892
67891
  }
67893
- var result = maybeTypeOfKind(type, 2944) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, undefined)) ?
67892
+ var result = maybeTypeOfKind(type, 2944) && (isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, undefined)) ||
67893
+ isLiteralOfContextualType(type, contextualType)) ?
67894
67894
  getRegularTypeOfLiteralType(type) : type;
67895
67895
  return result;
67896
67896
  }
package/lib/tsserver.js CHANGED
@@ -62171,7 +62171,7 @@ var ts;
62171
62171
  if (flags & (2 /* ElementFlags.Optional */ | 4 /* ElementFlags.Rest */)) {
62172
62172
  lastOptionalOrRestIndex = expandedFlags.length;
62173
62173
  }
62174
- expandedTypes.push(flags & 2 /* ElementFlags.Optional */ ? addOptionality(type, /*isProperty*/ true) : type);
62174
+ expandedTypes.push(type);
62175
62175
  expandedFlags.push(flags);
62176
62176
  if (expandedDeclarations && declaration) {
62177
62177
  expandedDeclarations.push(declaration);
@@ -68825,8 +68825,7 @@ var ts;
68825
68825
  function getOptionalType(type, isProperty) {
68826
68826
  if (isProperty === void 0) { isProperty = false; }
68827
68827
  ts.Debug.assert(strictNullChecks);
68828
- var missingOrUndefined = isProperty ? missingType : undefinedType;
68829
- return type.flags & 32768 /* TypeFlags.Undefined */ || type.flags & 1048576 /* TypeFlags.Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
68828
+ return type.flags & 32768 /* TypeFlags.Undefined */ ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
68830
68829
  }
68831
68830
  function getGlobalNonNullableTypeInstantiation(type) {
68832
68831
  if (!deferredGlobalNonNullableTypeAlias) {
@@ -80906,7 +80905,8 @@ var ts;
80906
80905
  // We strip literal freshness when an appropriate contextual type is present such that contextually typed
80907
80906
  // literals always preserve their literal types (otherwise they might widen during type inference). An alternative
80908
80907
  // here would be to not mark contextually typed literals as fresh in the first place.
80909
- var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ?
80908
+ var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && (isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ||
80909
+ isLiteralOfContextualType(type, contextualType)) ?
80910
80910
  getRegularTypeOfLiteralType(type) : type;
80911
80911
  return result;
80912
80912
  }
package/lib/tsserverlibrary.js CHANGED
@@ -62170,7 +62170,7 @@ var ts;
62170
62170
  if (flags & (2 /* ElementFlags.Optional */ | 4 /* ElementFlags.Rest */)) {
62171
62171
  lastOptionalOrRestIndex = expandedFlags.length;
62172
62172
  }
62173
- expandedTypes.push(flags & 2 /* ElementFlags.Optional */ ? addOptionality(type, /*isProperty*/ true) : type);
62173
+ expandedTypes.push(type);
62174
62174
  expandedFlags.push(flags);
62175
62175
  if (expandedDeclarations && declaration) {
62176
62176
  expandedDeclarations.push(declaration);
@@ -68824,8 +68824,7 @@ var ts;
68824
68824
  function getOptionalType(type, isProperty) {
68825
68825
  if (isProperty === void 0) { isProperty = false; }
68826
68826
  ts.Debug.assert(strictNullChecks);
68827
- var missingOrUndefined = isProperty ? missingType : undefinedType;
68828
- return type.flags & 32768 /* TypeFlags.Undefined */ || type.flags & 1048576 /* TypeFlags.Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
68827
+ return type.flags & 32768 /* TypeFlags.Undefined */ ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
68829
68828
  }
68830
68829
  function getGlobalNonNullableTypeInstantiation(type) {
68831
68830
  if (!deferredGlobalNonNullableTypeAlias) {
@@ -80905,7 +80904,8 @@ var ts;
80905
80904
  // We strip literal freshness when an appropriate contextual type is present such that contextually typed
80906
80905
  // literals always preserve their literal types (otherwise they might widen during type inference). An alternative
80907
80906
  // here would be to not mark contextually typed literals as fresh in the first place.
80908
- var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ?
80907
+ var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && (isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ||
80908
+ isLiteralOfContextualType(type, contextualType)) ?
80909
80909
  getRegularTypeOfLiteralType(type) : type;
80910
80910
  return result;
80911
80911
  }
package/lib/typescript.js CHANGED
@@ -62161,7 +62161,7 @@ var ts;
62161
62161
  if (flags & (2 /* ElementFlags.Optional */ | 4 /* ElementFlags.Rest */)) {
62162
62162
  lastOptionalOrRestIndex = expandedFlags.length;
62163
62163
  }
62164
- expandedTypes.push(flags & 2 /* ElementFlags.Optional */ ? addOptionality(type, /*isProperty*/ true) : type);
62164
+ expandedTypes.push(type);
62165
62165
  expandedFlags.push(flags);
62166
62166
  if (expandedDeclarations && declaration) {
62167
62167
  expandedDeclarations.push(declaration);
@@ -68815,8 +68815,7 @@ var ts;
68815
68815
  function getOptionalType(type, isProperty) {
68816
68816
  if (isProperty === void 0) { isProperty = false; }
68817
68817
  ts.Debug.assert(strictNullChecks);
68818
- var missingOrUndefined = isProperty ? missingType : undefinedType;
68819
- return type.flags & 32768 /* TypeFlags.Undefined */ || type.flags & 1048576 /* TypeFlags.Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
68818
+ return type.flags & 32768 /* TypeFlags.Undefined */ ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
68820
68819
  }
68821
68820
  function getGlobalNonNullableTypeInstantiation(type) {
68822
68821
  if (!deferredGlobalNonNullableTypeAlias) {
@@ -80896,7 +80895,8 @@ var ts;
80896
80895
  // We strip literal freshness when an appropriate contextual type is present such that contextually typed
80897
80896
  // literals always preserve their literal types (otherwise they might widen during type inference). An alternative
80898
80897
  // here would be to not mark contextually typed literals as fresh in the first place.
80899
- var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ?
80898
+ var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && (isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ||
80899
+ isLiteralOfContextualType(type, contextualType)) ?
80900
80900
  getRegularTypeOfLiteralType(type) : type;
80901
80901
  return result;
80902
80902
  }
package/lib/typescriptServices.js CHANGED
@@ -62161,7 +62161,7 @@ var ts;
62161
62161
  if (flags & (2 /* ElementFlags.Optional */ | 4 /* ElementFlags.Rest */)) {
62162
62162
  lastOptionalOrRestIndex = expandedFlags.length;
62163
62163
  }
62164
- expandedTypes.push(flags & 2 /* ElementFlags.Optional */ ? addOptionality(type, /*isProperty*/ true) : type);
62164
+ expandedTypes.push(type);
62165
62165
  expandedFlags.push(flags);
62166
62166
  if (expandedDeclarations && declaration) {
62167
62167
  expandedDeclarations.push(declaration);
@@ -68815,8 +68815,7 @@ var ts;
68815
68815
  function getOptionalType(type, isProperty) {
68816
68816
  if (isProperty === void 0) { isProperty = false; }
68817
68817
  ts.Debug.assert(strictNullChecks);
68818
- var missingOrUndefined = isProperty ? missingType : undefinedType;
68819
- return type.flags & 32768 /* TypeFlags.Undefined */ || type.flags & 1048576 /* TypeFlags.Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
68818
+ return type.flags & 32768 /* TypeFlags.Undefined */ ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
68820
68819
  }
68821
68820
  function getGlobalNonNullableTypeInstantiation(type) {
68822
68821
  if (!deferredGlobalNonNullableTypeAlias) {
@@ -80896,7 +80895,8 @@ var ts;
80896
80895
  // We strip literal freshness when an appropriate contextual type is present such that contextually typed
80897
80896
  // literals always preserve their literal types (otherwise they might widen during type inference). An alternative
80898
80897
  // here would be to not mark contextually typed literals as fresh in the first place.
80899
- var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ?
80898
+ var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && (isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ||
80899
+ isLiteralOfContextualType(type, contextualType)) ?
80900
80900
  getRegularTypeOfLiteralType(type) : type;
80901
80901
  return result;
80902
80902
  }
package/lib/typingsInstaller.js CHANGED
@@ -62151,7 +62151,7 @@ var ts;
62151
62151
  if (flags & (2 /* ElementFlags.Optional */ | 4 /* ElementFlags.Rest */)) {
62152
62152
  lastOptionalOrRestIndex = expandedFlags.length;
62153
62153
  }
62154
- expandedTypes.push(flags & 2 /* ElementFlags.Optional */ ? addOptionality(type, /*isProperty*/ true) : type);
62154
+ expandedTypes.push(type);
62155
62155
  expandedFlags.push(flags);
62156
62156
  if (expandedDeclarations && declaration) {
62157
62157
  expandedDeclarations.push(declaration);
@@ -68805,8 +68805,7 @@ var ts;
68805
68805
  function getOptionalType(type, isProperty) {
68806
68806
  if (isProperty === void 0) { isProperty = false; }
68807
68807
  ts.Debug.assert(strictNullChecks);
68808
- var missingOrUndefined = isProperty ? missingType : undefinedType;
68809
- return type.flags & 32768 /* TypeFlags.Undefined */ || type.flags & 1048576 /* TypeFlags.Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
68808
+ return type.flags & 32768 /* TypeFlags.Undefined */ ? type : getUnionType([type, isProperty ? missingType : undefinedType]);
68810
68809
  }
68811
68810
  function getGlobalNonNullableTypeInstantiation(type) {
68812
68811
  if (!deferredGlobalNonNullableTypeAlias) {
@@ -80886,7 +80885,8 @@ var ts;
80886
80885
  // We strip literal freshness when an appropriate contextual type is present such that contextually typed
80887
80886
  // literals always preserve their literal types (otherwise they might widen during type inference). An alternative
80888
80887
  // here would be to not mark contextually typed literals as fresh in the first place.
80889
- var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ?
80888
+ var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && (isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ||
80889
+ isLiteralOfContextualType(type, contextualType)) ?
80890
80890
  getRegularTypeOfLiteralType(type) : type;
80891
80891
  return result;
80892
80892
  }
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.9.0-pr-50831-12",
5
+ "version": "4.9.0-pr-50759-10",
6
6
  "license": "Apache-2.0",
7
7
  "description": "TypeScript is a language for application scale JavaScript development",
8
8
  "keywords": [