@next-core/brick-utils 2.37.17 → 2.37.18

package/dist/index.esm.js

@@ -3608,8 +3608,8 @@ var toUnenumerable = (object, key) => defineProperty(object, key, {
 });
 
 function toESTreeLocation(node) {
-  toUnenumerable(node.loc.start, "index");
-  toUnenumerable(node.loc.end, "index");
+  node.loc.start && toUnenumerable(node.loc.start, "index");
+  node.loc.end && toUnenumerable(node.loc.end, "index");
   return node;
 }
 
@@ -3883,10 +3883,9 @@ var estree = superClass => class extends superClass {
       }
 
       this.toAssignable(value, isLHS);
-      return node;
+    } else {
+      super.toAssignable(node, isLHS);
     }
-
-    return super.toAssignable(node, isLHS);
   }
 
   toAssignableObjectExpressionProp(prop) {
@@ -3899,11 +3898,7 @@ var estree = superClass => class extends superClass {
         at: prop.key
       });
     } else {
-      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
-        args[_key3 - 1] = arguments[_key3];
-      }
-
-      super.toAssignableObjectExpressionProp(prop, ...args);
+      super.toAssignableObjectExpressionProp(...arguments);
     }
   }
 
@@ -4000,6 +3995,11 @@ var estree = superClass => class extends superClass {
     return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
   }
 
+  resetStartLocation(node, start, startLoc) {
+    super.resetStartLocation(node, start, startLoc);
+    toESTreeLocation(node);
+  }
+
   resetEndLocation(node) {
     var endLoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.state.lastTokEndLoc;
     super.resetEndLocation(node, endLoc);
@@ -4147,9 +4147,7 @@ var tt = {
     beforeExpr,
     startsExpr
   }),
-  braceR: createToken("}", {
-    beforeExpr
-  }),
+  braceR: createToken("}"),
   braceBarR: createToken("|}"),
   parenL: createToken("(", {
     beforeExpr,
@@ -4574,6 +4572,10 @@ function tokenOperatorPrecedence(token) {
   return tokenBinops[token];
 }
 
+function tokenIsBinaryOperator(token) {
+  return tokenBinops[token] !== -1;
+}
+
 function tokenIsRightAssociative(token) {
   return token === 57;
 }
@@ -5039,6 +5041,7 @@ class State {
     this.hasFlowComment = false;
     this.isAmbientContext = false;
     this.inAbstractClass = false;
+    this.inDisallowConditionalTypesContext = false;
     this.topicContext = {
       maxNumOfResolvableTopics: 0,
       maxTopicIndex: null
@@ -7051,7 +7054,7 @@ class ExpressionScopeHandler {
     this.parser.raise(toParseError, origin);
   }
 
-  recordParenthesizedIdentifierError(_ref45) {
+  recordArrowParemeterBindingError(error, _ref45) {
     var {
       at: node
     } = _ref45;
@@ -7064,9 +7067,9 @@ class ExpressionScopeHandler {
     };
 
     if (scope.isCertainlyParameterDeclaration()) {
-      this.parser.raise(Errors.InvalidParenthesizedAssignment, origin);
+      this.parser.raise(error, origin);
     } else if (scope.canBeArrowParameterDeclaration()) {
-      scope.recordDeclarationError(Errors.InvalidParenthesizedAssignment, origin);
+      scope.recordDeclarationError(error, origin);
     } else {
       return;
     }
@@ -9517,11 +9520,11 @@ var flow = superClass => class extends superClass {
   toAssignable(node) {
     var isLHS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
-    if (node.type === "TypeCastExpression") {
-      return super.toAssignable(this.typeCastToParameter(node), isLHS);
-    } else {
-      return super.toAssignable(node, isLHS);
+    if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") {
+      node.left = this.typeCastToParameter(node.left);
     }
+
+    super.toAssignable(...arguments);
   }
 
   toAssignableList(exprList, trailingCommaLoc, isLHS) {
@@ -9533,7 +9536,7 @@ var flow = superClass => class extends superClass {
       }
     }
 
-    return super.toAssignableList(exprList, trailingCommaLoc, isLHS);
+    super.toAssignableList(exprList, trailingCommaLoc, isLHS);
   }
 
   toReferencedList(exprList, isParenthesizedExpr) {
@@ -9563,8 +9566,8 @@ var flow = superClass => class extends superClass {
   }
 
   isValidLVal(type) {
-    for (var _len4 = arguments.length, rest = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
-      rest[_key4 - 1] = arguments[_key4];
+    for (var _len3 = arguments.length, rest = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      rest[_key3 - 1] = arguments[_key3];
     }
 
     return type === "TypeCastExpression" || super.isValidLVal(type, ...rest);
@@ -10113,7 +10116,8 @@ var flow = superClass => class extends superClass {
     return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState);
   }
 
-  parseNewArguments(node) {
+  parseNewCallee(node) {
+    super.parseNewCallee(node);
     var targs = null;
 
     if (this.shouldParseTypes() && this.match(47)) {
@@ -10121,7 +10125,6 @@ var flow = superClass => class extends superClass {
     }
 
     node.typeArguments = targs;
-    super.parseNewArguments(node);
   }
 
   parseAsyncArrowWithTypeParameters(startPos, startLoc) {
@@ -11194,6 +11197,7 @@ var jsx = superClass => class extends superClass {
     this.next();
     node.expression = this.parseExpression();
     this.setContext(types.j_oTag);
+    this.state.canStartJSXElement = true;
     this.expect(8);
     return this.finishNode(node, "JSXSpreadChild");
   }
@@ -11207,6 +11211,7 @@ var jsx = superClass => class extends superClass {
     }
 
     this.setContext(previousContext);
+    this.state.canStartJSXElement = true;
     this.expect(8);
     return this.finishNode(node, "JSXExpressionContainer");
   }
@@ -11220,6 +11225,7 @@ var jsx = superClass => class extends superClass {
       this.expect(21);
       node.argument = this.parseMaybeAssignAllowIn();
       this.setContext(types.j_oTag);
+      this.state.canStartJSXElement = true;
       this.expect(8);
       return this.finishNode(node, "JSXSpreadAttribute");
     }
@@ -11232,8 +11238,7 @@ var jsx = superClass => class extends superClass {
   jsxParseOpeningElementAt(startPos, startLoc) {
     var node = this.startNodeAt(startPos, startLoc);
 
-    if (this.match(139)) {
-      this.expect(139);
+    if (this.eat(139)) {
       return this.finishNode(node, "JSXOpeningFragment");
     }
 
@@ -11257,8 +11262,7 @@ var jsx = superClass => class extends superClass {
   jsxParseClosingElementAt(startPos, startLoc) {
     var node = this.startNodeAt(startPos, startLoc);
 
-    if (this.match(139)) {
-      this.expect(139);
+    if (this.eat(139)) {
       return this.finishNode(node, "JSXClosingFragment");
     }
 
@@ -11539,6 +11543,10 @@ function assert(x) {
   }
 }
 
+function tsTokenCanStartExpression(token) {
+  return tokenCanStartExpression(token) || tokenIsBinaryOperator(token);
+}
+
 var TSErrors = ParseErrorEnum(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["typescript"])))(_ => ({
   AbstractMethodHasImplementation: _(_ref71 => {
     var {
@@ -11614,10 +11622,22 @@ var TSErrors = ParseErrorEnum(_templateObject4 || (_templateObject4 = _taggedTem
     } = _ref80;
     return "'".concat(modifier, "' modifier cannot appear on a type member.");
   }),
-  InvalidModifiersOrder: _(_ref81 => {
+  InvalidModifierOnTypeParameter: _(_ref81 => {
     var {
-      orderedModifiers
+      modifier
     } = _ref81;
+    return "'".concat(modifier, "' modifier cannot appear on a type parameter.");
+  }),
+  InvalidModifierOnTypeParameterPositions: _(_ref82 => {
+    var {
+      modifier
+    } = _ref82;
+    return "'".concat(modifier, "' modifier can only appear on a type parameter of a class, interface or type alias.");
+  }),
+  InvalidModifiersOrder: _(_ref83 => {
+    var {
+      orderedModifiers
+    } = _ref83;
     return "'".concat(orderedModifiers[0], "' modifier must precede '").concat(orderedModifiers[1], "' modifier.");
   }),
   InvalidTupleMemberLabel: _("Tuple members must be labeled with a simple identifier."),
@@ -11629,10 +11649,10 @@ var TSErrors = ParseErrorEnum(_templateObject4 || (_templateObject4 = _taggedTem
   OverrideNotInSubClass: _("This member cannot have an 'override' modifier because its containing class does not extend another class."),
   PatternIsOptional: _("A binding pattern parameter cannot be optional in an implementation signature."),
   PrivateElementHasAbstract: _("Private elements cannot have the 'abstract' modifier."),
-  PrivateElementHasAccessibility: _(_ref82 => {
+  PrivateElementHasAccessibility: _(_ref84 => {
     var {
       modifier
-    } = _ref82;
+    } = _ref84;
     return "Private elements cannot have an accessibility modifier ('".concat(modifier, "').");
   }),
   ReadonlyForMethodSignature: _("'readonly' modifier can only appear on a property declaration or index signature."),
@@ -11641,10 +11661,10 @@ var TSErrors = ParseErrorEnum(_templateObject4 || (_templateObject4 = _taggedTem
   SetAccesorCannotHaveOptionalParameter: _("A 'set' accessor cannot have an optional parameter."),
   SetAccesorCannotHaveRestParameter: _("A 'set' accessor cannot have rest parameter."),
   SetAccesorCannotHaveReturnType: _("A 'set' accessor cannot have a return type annotation."),
-  SingleTypeParameterWithoutTrailingComma: _(_ref83 => {
+  SingleTypeParameterWithoutTrailingComma: _(_ref85 => {
     var {
       typeParameterName
-    } = _ref83;
+    } = _ref85;
     return "Single type parameter ".concat(typeParameterName, " should have a trailing comma. Example usage: <").concat(typeParameterName, ",>.");
   }),
   StaticBlockCannotHaveModifier: _("Static class blocks cannot have any modifier."),
@@ -11658,10 +11678,10 @@ var TSErrors = ParseErrorEnum(_templateObject4 || (_templateObject4 = _taggedTem
   UnexpectedTypeCastInParameter: _("Unexpected type cast in parameter position."),
   UnsupportedImportTypeArgument: _("Argument in a type import must be a string literal."),
   UnsupportedParameterPropertyKind: _("A parameter property may not be declared using a binding pattern."),
-  UnsupportedSignatureParameterKind: _(_ref84 => {
+  UnsupportedSignatureParameterKind: _(_ref86 => {
     var {
       type
-    } = _ref84;
+    } = _ref86;
     return "Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ".concat(type, ".");
   })
 }));
@@ -11707,6 +11727,10 @@ function tsIsAccessModifier(modifier) {
   return modifier === "private" || modifier === "public" || modifier === "protected";
 }
 
+function tsIsVarianceAnnotations(modifier) {
+  return modifier === "in" || modifier === "out";
+}
+
 var typescript = superClass => class extends superClass {
   getScopeHandler() {
     return TypeScriptScopeHandler;
@@ -11726,7 +11750,7 @@ var typescript = superClass => class extends superClass {
   }
 
   tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
-    if (!tokenIsIdentifier(this.state.type)) {
+    if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58) {
       return undefined;
     }
 
@@ -11745,13 +11769,14 @@ var typescript = superClass => class extends superClass {
     return undefined;
   }
 
-  tsParseModifiers(_ref85) {
+  tsParseModifiers(_ref87) {
     var {
       modified,
       allowedModifiers,
       disallowedModifiers,
-      stopOnStartOfClassStaticBlock
-    } = _ref85;
+      stopOnStartOfClassStaticBlock,
+      errorTemplate = TSErrors.InvalidModifierOnTypeMember
+    } = _ref87;
 
     var enforceOrder = (loc, modifier, before, after) => {
       if (modifier === before && modified[after]) {
@@ -11790,6 +11815,16 @@ var typescript = superClass => class extends superClass {
           enforceOrder(startLoc, modifier, modifier, "readonly");
           modified.accessibility = modifier;
         }
+      } else if (tsIsVarianceAnnotations(modifier)) {
+        if (modified[modifier]) {
+          this.raise(TSErrors.DuplicateModifier, {
+            at: startLoc,
+            modifier
+          });
+        }
+
+        modified[modifier] = true;
+        enforceOrder(startLoc, modifier, "in", "out");
       } else {
         if (Object.hasOwnProperty.call(modified, modifier)) {
           this.raise(TSErrors.DuplicateModifier, {
@@ -11809,7 +11844,7 @@ var typescript = superClass => class extends superClass {
       }
 
       if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-        this.raise(TSErrors.InvalidModifierOnTypeMember, {
+        this.raise(errorTemplate, {
           at: startLoc,
           modifier
         });
@@ -11986,24 +12021,48 @@ var typescript = superClass => class extends superClass {
       node.exprName = this.tsParseEntityName();
     }
 
+    if (!this.hasPrecedingLineBreak() && this.match(47)) {
+      node.typeParameters = this.tsParseTypeArguments();
+    }
+
     return this.finishNode(node, "TSTypeQuery");
   }
 
+  tsParseInOutModifiers(node) {
+    this.tsParseModifiers({
+      modified: node,
+      allowedModifiers: ["in", "out"],
+      disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
+      errorTemplate: TSErrors.InvalidModifierOnTypeParameter
+    });
+  }
+
+  tsParseNoneModifiers(node) {
+    this.tsParseModifiers({
+      modified: node,
+      allowedModifiers: [],
+      disallowedModifiers: ["in", "out"],
+      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
+    });
+  }
+
   tsParseTypeParameter() {
+    var parseModifiers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.tsParseNoneModifiers.bind(this);
     var node = this.startNode();
+    parseModifiers(node);
     node.name = this.tsParseTypeParameterName();
     node.constraint = this.tsEatThenParseType(81);
     node.default = this.tsEatThenParseType(29);
     return this.finishNode(node, "TSTypeParameter");
   }
 
-  tsTryParseTypeParameters() {
+  tsTryParseTypeParameters(parseModifiers) {
     if (this.match(47)) {
-      return this.tsParseTypeParameters();
+      return this.tsParseTypeParameters(parseModifiers);
     }
   }
 
-  tsParseTypeParameters() {
+  tsParseTypeParameters(parseModifiers) {
     var node = this.startNode();
 
     if (this.match(47) || this.match(138)) {
@@ -12015,7 +12074,7 @@ var typescript = superClass => class extends superClass {
     var refTrailingCommaPos = {
       value: -1
     };
-    node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this), false, true, refTrailingCommaPos);
+    node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
 
     if (node.params.length === 0) {
       this.raise(TSErrors.EmptyTypeParameters, {
@@ -12406,7 +12465,7 @@ var typescript = superClass => class extends superClass {
       this.next();
     }
 
-    this.tsFillSignature(19, node);
+    this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
     return this.finishNode(node, type);
   }
 
@@ -12575,13 +12634,24 @@ var typescript = superClass => class extends superClass {
     this.expectContextual(112);
     var typeParameter = this.startNode();
     typeParameter.name = this.tsParseTypeParameterName();
+    typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
     node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
     return this.finishNode(node, "TSInferType");
   }
 
+  tsParseConstraintForInferType() {
+    if (this.eat(81)) {
+      var constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
+
+      if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
+        return constraint;
+      }
+    }
+  }
+
   tsParseTypeOperatorOrHigher() {
     var isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
-    return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(112) ? this.tsParseInferType() : this.tsParseArrayTypeOrHigher();
+    return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(112) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
   }
 
   tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
@@ -12783,17 +12853,17 @@ var typescript = superClass => class extends superClass {
     assert(this.state.inType);
     var type = this.tsParseNonConditionalType();
 
-    if (this.hasPrecedingLineBreak() || !this.eat(81)) {
+    if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
       return type;
     }
 
     var node = this.startNodeAtNode(type);
     node.checkType = type;
-    node.extendsType = this.tsParseNonConditionalType();
+    node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
     this.expect(17);
-    node.trueType = this.tsParseType();
+    node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
     this.expect(14);
-    node.falseType = this.tsParseType();
+    node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
     return this.finishNode(node, "TSConditionalType");
   }
 
@@ -12834,7 +12904,16 @@ var typescript = superClass => class extends superClass {
 
   tsParseHeritageClause(token) {
     var originalStartLoc = this.state.startLoc;
-    var delimitedList = this.tsParseDelimitedList("HeritageClauseElement", this.tsParseExpressionWithTypeArguments.bind(this));
+    var delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
+      var node = this.startNode();
+      node.expression = this.tsParseEntityName();
+
+      if (this.match(47)) {
+        node.typeParameters = this.tsParseTypeArguments();
+      }
+
+      return this.finishNode(node, "TSExpressionWithTypeArguments");
+    });
 
     if (!delimitedList.length) {
       this.raise(TSErrors.EmptyHeritageClauseType, {
@@ -12846,17 +12925,6 @@ var typescript = superClass => class extends superClass {
     return delimitedList;
   }
 
-  tsParseExpressionWithTypeArguments() {
-    var node = this.startNode();
-    node.expression = this.tsParseEntityName();
-
-    if (this.match(47)) {
-      node.typeParameters = this.tsParseTypeArguments();
-    }
-
-    return this.finishNode(node, "TSExpressionWithTypeArguments");
-  }
-
   tsParseInterfaceDeclaration(node) {
     var properties = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     if (this.hasFollowingLineBreak()) return null;
@@ -12873,7 +12941,7 @@ var typescript = superClass => class extends superClass {
       });
     }
 
-    node.typeParameters = this.tsTryParseTypeParameters();
+    node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
 
     if (this.eat(81)) {
       node.extends = this.tsParseHeritageClause("extends");
@@ -12889,7 +12957,7 @@ var typescript = superClass => class extends superClass {
     node.id = this.parseIdentifier();
     this.checkIdentifier(node.id, BIND_TS_TYPE);
     node.typeAnnotation = this.tsInType(() => {
-      node.typeParameters = this.tsTryParseTypeParameters();
+      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
       this.expect(29);
 
       if (this.isContextual(111) && this.lookahead().type !== 16) {
@@ -12927,6 +12995,28 @@ var typescript = superClass => class extends superClass {
     }
   }
 
+  tsInDisallowConditionalTypesContext(cb) {
+    var oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
+    this.state.inDisallowConditionalTypesContext = true;
+
+    try {
+      return cb();
+    } finally {
+      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
+    }
+  }
+
+  tsInAllowConditionalTypesContext(cb) {
+    var oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
+    this.state.inDisallowConditionalTypesContext = false;
+
+    try {
+      return cb();
+    } finally {
+      this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
+    }
+  }
+
   tsEatThenParseType(token) {
     return !this.match(token) ? undefined : this.tsNextThenParseType();
   }
@@ -13446,35 +13536,44 @@ var typescript = superClass => class extends superClass {
           }
         }
 
-        var node = this.startNodeAt(startPos, startLoc);
-        node.callee = base;
         var typeArguments = this.tsParseTypeArgumentsInExpression();
+        if (!typeArguments) throw this.unexpected();
 
-        if (typeArguments) {
-          if (isOptionalCall && !this.match(10)) {
-            missingParenErrorLoc = this.state.curPosition();
-            this.unexpected();
-          }
+        if (isOptionalCall && !this.match(10)) {
+          missingParenErrorLoc = this.state.curPosition();
+          throw this.unexpected();
+        }
 
-          if (!noCalls && this.eat(10)) {
-            node.arguments = this.parseCallExpressionArguments(11, false);
-            this.tsCheckForInvalidTypeCasts(node.arguments);
-            node.typeParameters = typeArguments;
+        if (tokenIsTemplate(this.state.type)) {
+          var _result = this.parseTaggedTemplateExpression(base, startPos, startLoc, state);
 
-            if (state.optionalChainMember) {
-              node.optional = isOptionalCall;
-            }
+          _result.typeParameters = typeArguments;
+          return _result;
+        }
+
+        if (!noCalls && this.eat(10)) {
+          var _node9 = this.startNodeAt(startPos, startLoc);
 
-            return this.finishCallExpression(node, state.optionalChainMember);
-          } else if (tokenIsTemplate(this.state.type)) {
-            var _result = this.parseTaggedTemplateExpression(base, startPos, startLoc, state);
+          _node9.callee = base;
+          _node9.arguments = this.parseCallExpressionArguments(11, false);
+          this.tsCheckForInvalidTypeCasts(_node9.arguments);
+          _node9.typeParameters = typeArguments;
 
-            _result.typeParameters = typeArguments;
-            return _result;
+          if (state.optionalChainMember) {
+            _node9.optional = isOptionalCall;
           }
+
+          return this.finishCallExpression(_node9, state.optionalChainMember);
         }
 
-        this.unexpected();
+        if (tsTokenCanStartExpression(this.state.type) && this.state.type !== 10) {
+          throw this.unexpected();
+        }
+
+        var node = this.startNodeAt(startPos, startLoc);
+        node.expression = base;
+        node.typeParameters = typeArguments;
+        return this.finishNode(node, "TSInstantiationExpression");
       });
 
       if (missingParenErrorLoc) {
@@ -13487,20 +13586,18 @@ var typescript = superClass => class extends superClass {
     return super.parseSubscript(base, startPos, startLoc, noCalls, state);
   }
 
-  parseNewArguments(node) {
-    if (this.match(47) || this.match(51)) {
-      var typeParameters = this.tsTryParseAndCatch(() => {
-        var args = this.tsParseTypeArgumentsInExpression();
-        if (!this.match(10)) this.unexpected();
-        return args;
-      });
+  parseNewCallee(node) {
+    var _callee$extra;
 
-      if (typeParameters) {
-        node.typeParameters = typeParameters;
-      }
-    }
+    super.parseNewCallee(node);
+    var {
+      callee
+    } = node;
 
-    super.parseNewArguments(node);
+    if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
+      node.typeParameters = callee.typeParameters;
+      node.callee = callee.expression;
+    }
   }
 
   parseExprOp(left, leftStartPos, leftStartLoc, minPrec) {
@@ -13688,7 +13785,9 @@ var typescript = superClass => class extends superClass {
     this.tsParseModifiers({
       modified: member,
       allowedModifiers: modifiers,
-      stopOnStartOfClassStaticBlock: true
+      disallowedModifiers: ["in", "out"],
+      stopOnStartOfClassStaticBlock: true,
+      errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
     });
 
     var callParseClassMemberWithIsStatic = () => {
@@ -13867,7 +13966,7 @@ var typescript = superClass => class extends superClass {
     }
 
     super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);
-    var typeParameters = this.tsTryParseTypeParameters();
+    var typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
     if (typeParameters) node.typeParameters = typeParameters;
   }
 
@@ -13973,8 +14072,8 @@ var typescript = superClass => class extends superClass {
     var typeParameters = this.tsTryParseTypeParameters();
     if (typeParameters) prop.typeParameters = typeParameters;
 
-    for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
-      args[_key5 - 1] = arguments[_key5];
+    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      args[_key4 - 1] = arguments[_key4];
     }
 
     super.parseObjPropValue(prop, ...args);
@@ -14010,8 +14109,8 @@ var typescript = superClass => class extends superClass {
   }
 
   parseMaybeAssign() {
-    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
-      args[_key6] = arguments[_key6];
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
     }
 
     var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3;
@@ -14038,10 +14137,10 @@ var typescript = superClass => class extends superClass {
       return super.parseMaybeAssign(...args);
     }
 
+    if (!state || state === this.state) state = this.state.clone();
     var typeParameters;
-    state = state || this.state.clone();
     var arrow = this.tryParse(abort => {
-      var _expr$extra, _typeParameters, _expr$typeParameters$;
+      var _expr$extra, _typeParameters;
 
       typeParameters = this.tsParseTypeParameters();
       var expr = super.parseMaybeAssign(...args);
@@ -14055,12 +14154,6 @@ var typescript = superClass => class extends superClass {
       }
 
       expr.typeParameters = typeParameters;
-
-      if (this.hasPlugin("jsx") && expr.typeParameters.params.length === 1 && !((_expr$typeParameters$ = expr.typeParameters.extra) != null && _expr$typeParameters$.trailingComma)) {
-        var parameter = expr.typeParameters.params[0];
-        if (!parameter.constraint) ;
-      }
-
       return expr;
     }, state);
 
@@ -14167,23 +14260,33 @@ var typescript = superClass => class extends superClass {
     var isLHS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
     switch (node.type) {
-      case "TSTypeCastExpression":
-        return super.toAssignable(this.typeCastToParameter(node), isLHS);
-
-      case "TSParameterProperty":
-        return super.toAssignable(node, isLHS);
-
       case "ParenthesizedExpression":
-        return this.toAssignableParenthesizedExpression(node, isLHS);
+        this.toAssignableParenthesizedExpression(node, isLHS);
+        break;
 
       case "TSAsExpression":
       case "TSNonNullExpression":
       case "TSTypeAssertion":
-        node.expression = this.toAssignable(node.expression, isLHS);
-        return node;
+        if (isLHS) {
+          this.expressionScope.recordArrowParemeterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
+            at: node
+          });
+        } else {
+          this.raise(TSErrors.UnexpectedTypeCastInParameter, {
+            at: node
+          });
+        }
+
+        this.toAssignable(node.expression, isLHS);
+        break;
+
+      case "AssignmentExpression":
+        if (!isLHS && node.left.type === "TSTypeCastExpression") {
+          node.left = this.typeCastToParameter(node.left);
+        }
 
       default:
-        return super.toAssignable(node, isLHS);
+        super.toAssignable(node, isLHS);
     }
   }
 
@@ -14193,22 +14296,35 @@ var typescript = superClass => class extends superClass {
       case "TSNonNullExpression":
       case "TSTypeAssertion":
       case "ParenthesizedExpression":
-        node.expression = this.toAssignable(node.expression, isLHS);
-        return node;
+        this.toAssignable(node.expression, isLHS);
+        break;
+
+      default:
+        super.toAssignable(node, isLHS);
+    }
+  }
+
+  checkToRestConversion(node, allowPattern) {
+    switch (node.type) {
+      case "TSAsExpression":
+      case "TSTypeAssertion":
+      case "TSNonNullExpression":
+        this.checkToRestConversion(node.expression, false);
+        break;
 
       default:
-        return super.toAssignable(node, isLHS);
+        super.checkToRestConversion(node, allowPattern);
     }
   }
 
-  isValidLVal(type, isParenthesized, binding) {
+  isValidLVal(type, isUnparenthesizedInAssign, binding) {
     return getOwn$1({
       TSTypeCastExpression: true,
       TSParameterProperty: "parameter",
       TSNonNullExpression: "expression",
-      TSAsExpression: (binding !== BIND_NONE || isParenthesized) && ["expression", true],
-      TSTypeAssertion: (binding !== BIND_NONE || isParenthesized) && ["expression", true]
-    }, type) || super.isValidLVal(type, isParenthesized, binding);
+      TSAsExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
+      TSTypeAssertion: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true]
+    }, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
   }
 
   parseBindingAtom() {
@@ -14311,28 +14427,13 @@ var typescript = superClass => class extends superClass {
   toAssignableList(exprList) {
     for (var i = 0; i < exprList.length; i++) {
       var expr = exprList[i];
-      if (!expr) continue;
 
-      switch (expr.type) {
-        case "TSTypeCastExpression":
-          exprList[i] = this.typeCastToParameter(expr);
-          break;
-
-        case "TSAsExpression":
-        case "TSTypeAssertion":
-          if (!this.state.maybeInArrowParameters) {
-            exprList[i] = this.typeCastToParameter(expr);
-          } else {
-            this.raise(TSErrors.UnexpectedTypeCastInParameter, {
-              at: expr
-            });
-          }
-
-          break;
+      if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
+        exprList[i] = this.typeCastToParameter(expr);
       }
     }
 
-    return super.toAssignableList(...arguments);
+    super.toAssignableList(...arguments);
   }
 
   typeCastToParameter(node) {
@@ -14402,8 +14503,8 @@ var typescript = superClass => class extends superClass {
     this.state.inAbstractClass = !!node.abstract;
 
     try {
-      for (var _len7 = arguments.length, args = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
-        args[_key7 - 1] = arguments[_key7];
+      for (var _len6 = arguments.length, args = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
+        args[_key6 - 1] = arguments[_key6];
       }
 
       return super.parseClass(node, ...args);
@@ -14527,7 +14628,16 @@ var typescript = superClass => class extends superClass {
       }
     } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
       hasTypeSpecifier = true;
-      leftOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
+
+      if (isImport) {
+        leftOfAs = this.parseIdentifier(true);
+
+        if (!this.isContextual(93)) {
+          this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
+        }
+      } else {
+        leftOfAs = this.parseModuleExportName();
+      }
     }
 
     if (hasTypeSpecifier && isInTypeOnlyImportExport) {
@@ -14626,8 +14736,8 @@ var placeholders = superClass => class extends superClass {
   }
 
   isValidLVal(type) {
-    for (var _len8 = arguments.length, rest = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
-      rest[_key8 - 1] = arguments[_key8];
+    for (var _len7 = arguments.length, rest = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
+      rest[_key7 - 1] = arguments[_key7];
     }
 
     return type === "Placeholder" || super.isValidLVal(type, ...rest);
@@ -14636,10 +14746,9 @@ var placeholders = superClass => class extends superClass {
   toAssignable(node) {
     if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
       node.expectedNode = "Pattern";
-      return node;
+    } else {
+      super.toAssignable(...arguments);
     }
-
-    return super.toAssignable(...arguments);
   }
 
   isLet(context) {
@@ -14951,9 +15060,9 @@ function validatePlugins(plugins) {
         throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
       }
 
-      var moduleAttributesVerionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
+      var moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
 
-      if (moduleAttributesVerionPluginOption !== "may-2020") {
+      if (moduleAttributesVersionPluginOption !== "may-2020") {
         throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'.");
       }
     }
@@ -15027,7 +15136,7 @@ class LValParser extends NodeUtils {
 
       if (isLHS) {
         if (parenthesized.type === "Identifier") {
-          this.expressionScope.recordParenthesizedIdentifierError({
+          this.expressionScope.recordArrowParemeterBindingError(Errors.InvalidParenthesizedAssignment, {
             at: node
           });
         } else if (parenthesized.type !== "MemberExpression") {
@@ -15086,11 +15195,7 @@ class LValParser extends NodeUtils {
 
       case "SpreadElement":
         {
-          this.checkToRestConversion(node);
-          node.type = "RestElement";
-          var arg = node.argument;
-          this.toAssignable(arg, isLHS);
-          break;
+          throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller.");
         }
 
       case "ArrayExpression":
@@ -15114,8 +15219,6 @@ class LValParser extends NodeUtils {
         this.toAssignable(parenthesized, isLHS);
         break;
     }
-
-    return node;
   }
 
   toAssignableObjectExpressionProp(prop, isLast, isLHS) {
@@ -15123,58 +15226,50 @@ class LValParser extends NodeUtils {
       this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
         at: prop.key
       });
-    } else if (prop.type === "SpreadElement" && !isLast) {
-      this.raise(Errors.RestTrailingComma, {
-        at: prop
-      });
+    } else if (prop.type === "SpreadElement") {
+      prop.type = "RestElement";
+      var arg = prop.argument;
+      this.checkToRestConversion(arg, false);
+      this.toAssignable(arg, isLHS);
+
+      if (!isLast) {
+        this.raise(Errors.RestTrailingComma, {
+          at: prop
+        });
+      }
     } else {
       this.toAssignable(prop, isLHS);
     }
   }
 
   toAssignableList(exprList, trailingCommaLoc, isLHS) {
-    var end = exprList.length;
-
-    if (end) {
-      var last = exprList[end - 1];
-
-      if ((last == null ? void 0 : last.type) === "RestElement") {
-        --end;
-      } else if ((last == null ? void 0 : last.type) === "SpreadElement") {
-        last.type = "RestElement";
-        var arg = last.argument;
-        this.toAssignable(arg, isLHS);
-        arg = unwrapParenthesizedExpression(arg);
-
-        if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern" && arg.type !== "ObjectPattern") {
-          this.unexpected(arg.start);
-        }
+    var end = exprList.length - 1;
 
-        if (trailingCommaLoc) {
-          this.raise(Errors.RestTrailingComma, {
-            at: trailingCommaLoc
-          });
-        }
-
-        --end;
-      }
-    }
-
-    for (var i = 0; i < end; i++) {
+    for (var i = 0; i <= end; i++) {
       var elt = exprList[i];
+      if (!elt) continue;
 
-      if (elt) {
+      if (elt.type === "SpreadElement") {
+        elt.type = "RestElement";
+        var arg = elt.argument;
+        this.checkToRestConversion(arg, true);
+        this.toAssignable(arg, isLHS);
+      } else {
         this.toAssignable(elt, isLHS);
+      }
 
-        if (elt.type === "RestElement") {
+      if (elt.type === "RestElement") {
+        if (i < end) {
           this.raise(Errors.RestTrailingComma, {
             at: elt
           });
+        } else if (trailingCommaLoc) {
+          this.raise(Errors.RestTrailingComma, {
+            at: trailingCommaLoc
+          });
         }
       }
     }
-
-    return exprList;
   }
 
   isAssignable(node, isBinding) {
@@ -15364,7 +15459,7 @@ class LValParser extends NodeUtils {
     return this.finishNode(node, "AssignmentPattern");
   }
 
-  isValidLVal(type, isParenthesized, binding) {
+  isValidLVal(type, isUnparenthesizedInAssign, binding) {
     return getOwn({
       AssignmentPattern: "left",
       RestElement: "argument",
@@ -15375,7 +15470,7 @@ class LValParser extends NodeUtils {
     }, type);
   }
 
-  checkLVal(expression, _ref86) {
+  checkLVal(expression, _ref88) {
     var {
       in: ancestor,
       binding = BIND_NONE,
@@ -15383,7 +15478,7 @@ class LValParser extends NodeUtils {
       strictModeChanged = false,
       allowingSloppyLetBinding = !(binding & BIND_SCOPE_LEXICAL),
       hasParenthesizedAncestor = false
-    } = _ref86;
+    } = _ref88;
 
     var _expression$extra;
 
@@ -15419,7 +15514,7 @@ class LValParser extends NodeUtils {
       return;
     }
 
-    var validity = this.isValidLVal(expression.type, hasParenthesizedAncestor || ((_expression$extra = expression.extra) == null ? void 0 : _expression$extra.parenthesized), binding);
+    var validity = this.isValidLVal(expression.type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
     if (validity === true) return;
 
     if (validity === false) {
@@ -15486,11 +15581,24 @@ class LValParser extends NodeUtils {
     this.scope.declareName(identifier.name, binding, identifier.loc.start);
   }
 
-  checkToRestConversion(node) {
-    if (node.argument.type !== "Identifier" && node.argument.type !== "MemberExpression") {
-      this.raise(Errors.InvalidRestAssignmentPattern, {
-        at: node.argument
-      });
+  checkToRestConversion(node, allowPattern) {
+    switch (node.type) {
+      case "ParenthesizedExpression":
+        this.checkToRestConversion(node.expression, allowPattern);
+        break;
+
+      case "Identifier":
+      case "MemberExpression":
+        break;
+
+      case "ArrayExpression":
+      case "ObjectExpression":
+        if (allowPattern) break;
+
+      default:
+        this.raise(Errors.InvalidRestAssignmentPattern, {
+          at: node
+        });
     }
   }
 
@@ -15651,7 +15759,8 @@ class ExpressionParser extends LValParser {
       node.operator = operator;
 
       if (this.match(29)) {
-        node.left = this.toAssignable(left, true);
+        this.toAssignable(left, true);
+        node.left = left;
 
         if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startPos) {
           refExpressionErrors.doubleProtoLoc = null;
@@ -15951,14 +16060,14 @@ class ExpressionParser extends LValParser {
     if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;
 
     while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {
-      var _node9 = this.startNodeAt(startPos, startLoc);
+      var _node10 = this.startNodeAt(startPos, startLoc);
 
-      _node9.operator = this.state.value;
-      _node9.prefix = false;
-      _node9.argument = expr;
+      _node10.operator = this.state.value;
+      _node10.prefix = false;
+      _node10.argument = expr;
       this.next();
       this.checkLVal(expr, {
-        in: expr = this.finishNode(_node9, "UpdateExpression")
+        in: expr = this.finishNode(_node10, "UpdateExpression")
       });
     }
 
@@ -16818,6 +16927,20 @@ class ExpressionParser extends LValParser {
   }
 
   parseNew(node) {
+    this.parseNewCallee(node);
+
+    if (this.eat(10)) {
+      var args = this.parseExprList(11);
+      this.toReferencedList(args);
+      node.arguments = args;
+    } else {
+      node.arguments = [];
+    }
+
+    return this.finishNode(node, "NewExpression");
+  }
+
+  parseNewCallee(node) {
     node.callee = this.parseNoCallExpr();
 
     if (node.callee.type === "Import") {
@@ -16833,19 +16956,6 @@ class ExpressionParser extends LValParser {
         at: this.state.startLoc
       });
     }
-
-    this.parseNewArguments(node);
-    return this.finishNode(node, "NewExpression");
-  }
-
-  parseNewArguments(node) {
-    if (this.eat(10)) {
-      var args = this.parseExprList(11);
-      this.toReferencedList(args);
-      node.arguments = args;
-    } else {
-      node.arguments = [];
-    }
   }
 
   parseTemplateElement(isTagged) {
@@ -17252,7 +17362,8 @@ class ExpressionParser extends LValParser {
   }
 
   setArrowFunctionParameters(node, params, trailingCommaLoc) {
-    node.params = this.toAssignableList(params, trailingCommaLoc, false);
+    this.toAssignableList(params, trailingCommaLoc, false);
+    node.params = params;
   }
 
   parseFunctionBodyAndFinish(node, type) {
@@ -18193,12 +18304,12 @@ class StatementParser extends ExpressionParser {
         expr = this.parseIdentifier(false);
 
         while (this.eat(16)) {
-          var _node10 = this.startNodeAt(startPos, startLoc);
+          var _node11 = this.startNodeAt(startPos, startLoc);
 
-          _node10.object = expr;
-          _node10.property = this.parseIdentifier(true);
-          _node10.computed = false;
-          expr = this.finishNode(_node10, "MemberExpression");
+          _node11.object = expr;
+          _node11.property = this.parseIdentifier(true);
+          _node11.computed = false;
+          expr = this.finishNode(_node11, "MemberExpression");
         }
       }