@next-core/brick-utils 2.37.18 → 2.37.19

package/dist/index.esm.js

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