@next-core/brick-utils 2.37.18 → 2.37.21

package/dist/index.bundle.js

@@ -3613,8 +3613,8 @@
   });
 
   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;
   }
 
@@ -3888,9 +3888,10 @@
         }
 
         this.toAssignable(value, isLHS);
-      } else {
-        super.toAssignable(node, isLHS);
+        return node;
       }
+
+      return super.toAssignable(node, isLHS);
     }
 
     toAssignableObjectExpressionProp(prop) {
@@ -3903,7 +3904,11 @@
           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);
       }
     }
 
@@ -4000,11 +4005,6 @@
       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);
@@ -4152,7 +4152,9 @@
       beforeExpr,
       startsExpr
     }),
-    braceR: createToken("}"),
+    braceR: createToken("}", {
+      beforeExpr
+    }),
     braceBarR: createToken("|}"),
     parenL: createToken("(", {
       beforeExpr,
@@ -4577,10 +4579,6 @@
     return tokenBinops[token];
   }
 
-  function tokenIsBinaryOperator(token) {
-    return tokenBinops[token] !== -1;
-  }
-
   function tokenIsRightAssociative(token) {
     return token === 57;
   }
@@ -5046,7 +5044,6 @@
       this.hasFlowComment = false;
       this.isAmbientContext = false;
       this.inAbstractClass = false;
-      this.inDisallowConditionalTypesContext = false;
       this.topicContext = {
         maxNumOfResolvableTopics: 0,
         maxTopicIndex: null
@@ -7059,7 +7056,7 @@
       this.parser.raise(toParseError, origin);
     }
 
-    recordArrowParemeterBindingError(error, _ref45) {
+    recordParenthesizedIdentifierError(_ref45) {
       var {
         at: node
       } = _ref45;
@@ -7072,9 +7069,9 @@
       };
 
       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;
       }
@@ -9525,11 +9522,11 @@
     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) {
@@ -9541,7 +9538,7 @@
         }
       }
 
-      super.toAssignableList(exprList, trailingCommaLoc, isLHS);
+      return super.toAssignableList(exprList, trailingCommaLoc, isLHS);
     }
 
     toReferencedList(exprList, isParenthesizedExpr) {
@@ -9571,8 +9568,8 @@
     }
 
     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);
@@ -10121,8 +10118,7 @@
       return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState);
     }
 
-    parseNewCallee(node) {
-      super.parseNewCallee(node);
+    parseNewArguments(node) {
       var targs = null;
 
       if (this.shouldParseTypes() && this.match(47)) {
@@ -10130,6 +10126,7 @@
       }
 
       node.typeArguments = targs;
+      super.parseNewArguments(node);
     }
 
     parseAsyncArrowWithTypeParameters(startPos, startLoc) {
@@ -11202,7 +11199,6 @@
       this.next();
       node.expression = this.parseExpression();
       this.setContext(types.j_oTag);
-      this.state.canStartJSXElement = true;
       this.expect(8);
       return this.finishNode(node, "JSXSpreadChild");
     }
@@ -11216,7 +11212,6 @@
       }
 
       this.setContext(previousContext);
-      this.state.canStartJSXElement = true;
       this.expect(8);
       return this.finishNode(node, "JSXExpressionContainer");
     }
@@ -11230,7 +11225,6 @@
         this.expect(21);
         node.argument = this.parseMaybeAssignAllowIn();
         this.setContext(types.j_oTag);
-        this.state.canStartJSXElement = true;
         this.expect(8);
         return this.finishNode(node, "JSXSpreadAttribute");
       }
@@ -11243,7 +11237,8 @@
     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");
       }
 
@@ -11267,7 +11262,8 @@
     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");
       }
 
@@ -11548,10 +11544,6 @@
     }
   }
 
-  function tsTokenCanStartExpression(token) {
-    return tokenCanStartExpression(token) || tokenIsBinaryOperator(token);
-  }
-
   var TSErrors = ParseErrorEnum(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral__default["default"](["typescript"])))(_ => ({
     AbstractMethodHasImplementation: _(_ref71 => {
       var {
@@ -11627,22 +11619,10 @@
       } = _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."),
@@ -11654,10 +11634,10 @@
     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."),
@@ -11666,10 +11646,10 @@
     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."),
@@ -11683,10 +11663,10 @@
     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, ".");
     })
   }));
@@ -11732,10 +11712,6 @@
     return modifier === "private" || modifier === "public" || modifier === "protected";
   }
 
-  function tsIsVarianceAnnotations(modifier) {
-    return modifier === "in" || modifier === "out";
-  }
-
   var typescript = superClass => class extends superClass {
     getScopeHandler() {
       return TypeScriptScopeHandler;
@@ -11755,7 +11731,7 @@
     }
 
     tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
-      if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58) {
+      if (!tokenIsIdentifier(this.state.type)) {
         return undefined;
       }
 
@@ -11774,14 +11750,13 @@
       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]) {
@@ -11820,16 +11795,6 @@
             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, {
@@ -11849,7 +11814,7 @@
         }
 
         if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-          this.raise(errorTemplate, {
+          this.raise(TSErrors.InvalidModifierOnTypeMember, {
             at: startLoc,
             modifier
           });
@@ -12026,48 +11991,24 @@
         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)) {
@@ -12079,7 +12020,7 @@
       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, {
@@ -12470,7 +12411,7 @@
         this.next();
       }
 
-      this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
+      this.tsFillSignature(19, node);
       return this.finishNode(node, type);
     }
 
@@ -12639,24 +12580,13 @@
       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) {
@@ -12858,17 +12788,17 @@
       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");
     }
 
@@ -12909,16 +12839,7 @@
 
     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, {
@@ -12930,6 +12851,17 @@
       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;
@@ -12946,7 +12878,7 @@
         });
       }
 
-      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
+      node.typeParameters = this.tsTryParseTypeParameters();
 
       if (this.eat(81)) {
         node.extends = this.tsParseHeritageClause("extends");
@@ -12962,7 +12894,7 @@
       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) {
@@ -13000,28 +12932,6 @@
       }
     }
 
-    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();
     }
@@ -13541,44 +13451,35 @@
             }
           }
 
+          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) {
@@ -13591,18 +13492,20 @@
       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) {
@@ -13790,9 +13693,7 @@
       this.tsParseModifiers({
         modified: member,
         allowedModifiers: modifiers,
-        disallowedModifiers: ["in", "out"],
-        stopOnStartOfClassStaticBlock: true,
-        errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
+        stopOnStartOfClassStaticBlock: true
       });
 
       var callParseClassMemberWithIsStatic = () => {
@@ -13971,7 +13872,7 @@
       }
 
       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;
     }
 
@@ -14077,8 +13978,8 @@
       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);
@@ -14114,8 +14015,8 @@
     }
 
     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;
@@ -14142,10 +14043,10 @@
         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);
@@ -14159,6 +14060,12 @@
         }
 
         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);
 
@@ -14265,33 +14172,23 @@
       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);
       }
     }
 
@@ -14301,35 +14198,22 @@
         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() {
@@ -14432,13 +14316,28 @@
     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) {
@@ -14508,8 +14407,8 @@
       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);
@@ -14633,16 +14532,7 @@
         }
       } 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) {
@@ -14741,8 +14631,8 @@
     }
 
     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);
@@ -14751,9 +14641,10 @@
     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) {
@@ -15065,9 +14956,9 @@
           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'.");
         }
       }
@@ -15141,7 +15032,7 @@
 
         if (isLHS) {
           if (parenthesized.type === "Identifier") {
-            this.expressionScope.recordArrowParemeterBindingError(Errors.InvalidParenthesizedAssignment, {
+            this.expressionScope.recordParenthesizedIdentifierError({
               at: node
             });
           } else if (parenthesized.type !== "MemberExpression") {
@@ -15200,7 +15091,11 @@
 
         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":
@@ -15224,6 +15119,8 @@
           this.toAssignable(parenthesized, isLHS);
           break;
       }
+
+      return node;
     }
 
     toAssignableObjectExpressionProp(prop, isLast, isLHS) {
@@ -15231,50 +15128,58 @@
         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) {
@@ -15464,7 +15369,7 @@
       return this.finishNode(node, "AssignmentPattern");
     }
 
-    isValidLVal(type, isUnparenthesizedInAssign, binding) {
+    isValidLVal(type, isParenthesized, binding) {
       return getOwn({
         AssignmentPattern: "left",
         RestElement: "argument",
@@ -15475,7 +15380,7 @@
       }, type);
     }
 
-    checkLVal(expression, _ref88) {
+    checkLVal(expression, _ref86) {
       var {
         in: ancestor,
         binding = BIND_NONE,
@@ -15483,7 +15388,7 @@
         strictModeChanged = false,
         allowingSloppyLetBinding = !(binding & BIND_SCOPE_LEXICAL),
         hasParenthesizedAncestor = false
-      } = _ref88;
+      } = _ref86;
 
       var _expression$extra;
 
@@ -15519,7 +15424,7 @@
         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) {
@@ -15586,24 +15491,11 @@
       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
+        });
       }
     }
 
@@ -15764,8 +15656,7 @@
         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;
@@ -16065,14 +15956,14 @@
       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")
         });
       }
 
@@ -16932,20 +16823,6 @@
     }
 
     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") {
@@ -16961,6 +16838,19 @@
           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) {
@@ -17367,8 +17257,7 @@
     }
 
     setArrowFunctionParameters(node, params, trailingCommaLoc) {
-      this.toAssignableList(params, trailingCommaLoc, false);
-      node.params = params;
+      node.params = this.toAssignableList(params, trailingCommaLoc, false);
     }
 
     parseFunctionBodyAndFinish(node, type) {
@@ -18309,12 +18198,12 @@
           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");
           }
         }