@next-core/brick-utils 2.37.15 → 2.37.18

package/dist/index.bundle.js

@@ -836,6 +836,7 @@
       customTemplates.forEach(tpl => {
         selfDefined.add(tpl.name);
         collectBricksInBrickConfs(tpl.bricks, collection);
+        collectBricksInContext(tpl.state, collection);
       });
     }
   }
@@ -3612,8 +3613,8 @@
   });
 
   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;
   }
 
@@ -3887,10 +3888,9 @@
         }
 
         this.toAssignable(value, isLHS);
-        return node;
+      } else {
+        super.toAssignable(node, isLHS);
       }
-
-      return super.toAssignable(node, isLHS);
     }
 
     toAssignableObjectExpressionProp(prop) {
@@ -3903,11 +3903,7 @@
           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);
       }
     }
 
@@ -4004,6 +4000,11 @@
       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);
@@ -4151,9 +4152,7 @@
       beforeExpr,
       startsExpr
     }),
-    braceR: createToken("}", {
-      beforeExpr
-    }),
+    braceR: createToken("}"),
     braceBarR: createToken("|}"),
     parenL: createToken("(", {
       beforeExpr,
@@ -4578,6 +4577,10 @@
     return tokenBinops[token];
   }
 
+  function tokenIsBinaryOperator(token) {
+    return tokenBinops[token] !== -1;
+  }
+
   function tokenIsRightAssociative(token) {
     return token === 57;
   }
@@ -5043,6 +5046,7 @@
       this.hasFlowComment = false;
       this.isAmbientContext = false;
       this.inAbstractClass = false;
+      this.inDisallowConditionalTypesContext = false;
       this.topicContext = {
         maxNumOfResolvableTopics: 0,
         maxTopicIndex: null
@@ -7055,7 +7059,7 @@
       this.parser.raise(toParseError, origin);
     }
 
-    recordParenthesizedIdentifierError(_ref45) {
+    recordArrowParemeterBindingError(error, _ref45) {
       var {
         at: node
       } = _ref45;
@@ -7068,9 +7072,9 @@
       };
 
       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;
       }
@@ -9521,11 +9525,11 @@
     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) {
@@ -9537,7 +9541,7 @@
         }
       }
 
-      return super.toAssignableList(exprList, trailingCommaLoc, isLHS);
+      super.toAssignableList(exprList, trailingCommaLoc, isLHS);
     }
 
     toReferencedList(exprList, isParenthesizedExpr) {
@@ -9567,8 +9571,8 @@
     }
 
     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);
@@ -10117,7 +10121,8 @@
       return super.parseSubscript(base, startPos, startLoc, noCalls, subscriptState);
     }
 
-    parseNewArguments(node) {
+    parseNewCallee(node) {
+      super.parseNewCallee(node);
       var targs = null;
 
       if (this.shouldParseTypes() && this.match(47)) {
@@ -10125,7 +10130,6 @@
       }
 
       node.typeArguments = targs;
-      super.parseNewArguments(node);
     }
 
     parseAsyncArrowWithTypeParameters(startPos, startLoc) {
@@ -11198,6 +11202,7 @@
       this.next();
       node.expression = this.parseExpression();
       this.setContext(types.j_oTag);
+      this.state.canStartJSXElement = true;
       this.expect(8);
       return this.finishNode(node, "JSXSpreadChild");
     }
@@ -11211,6 +11216,7 @@
       }
 
       this.setContext(previousContext);
+      this.state.canStartJSXElement = true;
       this.expect(8);
       return this.finishNode(node, "JSXExpressionContainer");
     }
@@ -11224,6 +11230,7 @@
         this.expect(21);
         node.argument = this.parseMaybeAssignAllowIn();
         this.setContext(types.j_oTag);
+        this.state.canStartJSXElement = true;
         this.expect(8);
         return this.finishNode(node, "JSXSpreadAttribute");
       }
@@ -11236,8 +11243,7 @@
     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");
       }
 
@@ -11261,8 +11267,7 @@
     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");
       }
 
@@ -11543,6 +11548,10 @@
     }
   }
 
+  function tsTokenCanStartExpression(token) {
+    return tokenCanStartExpression(token) || tokenIsBinaryOperator(token);
+  }
+
   var TSErrors = ParseErrorEnum(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral__default["default"](["typescript"])))(_ => ({
     AbstractMethodHasImplementation: _(_ref71 => {
       var {
@@ -11618,10 +11627,22 @@
       } = _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."),
@@ -11633,10 +11654,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: _(_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."),
@@ -11645,10 +11666,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: _(_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."),
@@ -11662,10 +11683,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: _(_ref84 => {
+    UnsupportedSignatureParameterKind: _(_ref86 => {
       var {
         type
-      } = _ref84;
+      } = _ref86;
       return "Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ".concat(type, ".");
     })
   }));
@@ -11711,6 +11732,10 @@
     return modifier === "private" || modifier === "public" || modifier === "protected";
   }
 
+  function tsIsVarianceAnnotations(modifier) {
+    return modifier === "in" || modifier === "out";
+  }
+
   var typescript = superClass => class extends superClass {
     getScopeHandler() {
       return TypeScriptScopeHandler;
@@ -11730,7 +11755,7 @@
     }
 
     tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
-      if (!tokenIsIdentifier(this.state.type)) {
+      if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58) {
         return undefined;
       }
 
@@ -11749,13 +11774,14 @@
       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]) {
@@ -11794,6 +11820,16 @@
             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, {
@@ -11813,7 +11849,7 @@
         }
 
         if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
-          this.raise(TSErrors.InvalidModifierOnTypeMember, {
+          this.raise(errorTemplate, {
             at: startLoc,
             modifier
           });
@@ -11990,24 +12026,48 @@
         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)) {
@@ -12019,7 +12079,7 @@
       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, {
@@ -12410,7 +12470,7 @@
         this.next();
       }
 
-      this.tsFillSignature(19, node);
+      this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
       return this.finishNode(node, type);
     }
 
@@ -12579,13 +12639,24 @@
       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) {
@@ -12787,17 +12858,17 @@
       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");
     }
 
@@ -12838,7 +12909,16 @@
 
     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, {
@@ -12850,17 +12930,6 @@
       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;
@@ -12877,7 +12946,7 @@
         });
       }
 
-      node.typeParameters = this.tsTryParseTypeParameters();
+      node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers.bind(this));
 
       if (this.eat(81)) {
         node.extends = this.tsParseHeritageClause("extends");
@@ -12893,7 +12962,7 @@
       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) {
@@ -12931,6 +13000,28 @@
       }
     }
 
+    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();
     }
@@ -13450,35 +13541,44 @@
             }
           }
 
-          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) {
@@ -13491,20 +13591,18 @@
       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) {
@@ -13692,7 +13790,9 @@
       this.tsParseModifiers({
         modified: member,
         allowedModifiers: modifiers,
-        stopOnStartOfClassStaticBlock: true
+        disallowedModifiers: ["in", "out"],
+        stopOnStartOfClassStaticBlock: true,
+        errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
       });
 
       var callParseClassMemberWithIsStatic = () => {
@@ -13871,7 +13971,7 @@
       }
 
       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;
     }
 
@@ -13977,8 +14077,8 @@
       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);
@@ -14014,8 +14114,8 @@
     }
 
     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;
@@ -14042,10 +14142,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, _expr$typeParameters$;
+        var _expr$extra, _typeParameters;
 
         typeParameters = this.tsParseTypeParameters();
         var expr = super.parseMaybeAssign(...args);
@@ -14059,12 +14159,6 @@
         }
 
         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);
 
@@ -14171,23 +14265,33 @@
       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);
       }
     }
 
@@ -14197,22 +14301,35 @@
         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() {
@@ -14315,28 +14432,13 @@
     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) {
@@ -14406,8 +14508,8 @@
       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);
@@ -14531,7 +14633,16 @@
         }
       } 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) {
@@ -14630,8 +14741,8 @@
     }
 
     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);
@@ -14640,10 +14751,9 @@
     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) {
@@ -14955,9 +15065,9 @@
           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'.");
         }
       }
@@ -15031,7 +15141,7 @@
 
         if (isLHS) {
           if (parenthesized.type === "Identifier") {
-            this.expressionScope.recordParenthesizedIdentifierError({
+            this.expressionScope.recordArrowParemeterBindingError(Errors.InvalidParenthesizedAssignment, {
               at: node
             });
           } else if (parenthesized.type !== "MemberExpression") {
@@ -15090,11 +15200,7 @@
 
         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":
@@ -15118,8 +15224,6 @@
           this.toAssignable(parenthesized, isLHS);
           break;
       }
-
-      return node;
     }
 
     toAssignableObjectExpressionProp(prop, isLast, isLHS) {
@@ -15127,58 +15231,50 @@
         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) {
@@ -15368,7 +15464,7 @@
       return this.finishNode(node, "AssignmentPattern");
     }
 
-    isValidLVal(type, isParenthesized, binding) {
+    isValidLVal(type, isUnparenthesizedInAssign, binding) {
       return getOwn({
         AssignmentPattern: "left",
         RestElement: "argument",
@@ -15379,7 +15475,7 @@
       }, type);
     }
 
-    checkLVal(expression, _ref86) {
+    checkLVal(expression, _ref88) {
       var {
         in: ancestor,
         binding = BIND_NONE,
@@ -15387,7 +15483,7 @@
         strictModeChanged = false,
         allowingSloppyLetBinding = !(binding & BIND_SCOPE_LEXICAL),
         hasParenthesizedAncestor = false
-      } = _ref86;
+      } = _ref88;
 
       var _expression$extra;
 
@@ -15423,7 +15519,7 @@
         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) {
@@ -15490,11 +15586,24 @@
       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
+          });
       }
     }
 
@@ -15655,7 +15764,8 @@
         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;
@@ -15955,14 +16065,14 @@
       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")
         });
       }
 
@@ -16822,6 +16932,20 @@
     }
 
     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") {
@@ -16837,19 +16961,6 @@
           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) {
@@ -17256,7 +17367,8 @@
     }
 
     setArrowFunctionParameters(node, params, trailingCommaLoc) {
-      node.params = this.toAssignableList(params, trailingCommaLoc, false);
+      this.toAssignableList(params, trailingCommaLoc, false);
+      node.params = params;
     }
 
     parseFunctionBodyAndFinish(node, type) {
@@ -18197,12 +18309,12 @@
           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");
           }
         }