hermes-estree 0.25.0 → 0.26.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -133,6 +133,22 @@ import type {
   KeyofTypeAnnotation,
   LabeledStatement,
   LogicalExpression,
+  MatchArrayPattern,
+  MatchAsPattern,
+  MatchBindingPattern,
+  MatchExpression,
+  MatchExpressionCase,
+  MatchIdentifierPattern,
+  MatchLiteralPattern,
+  MatchMemberPattern,
+  MatchObjectPattern,
+  MatchObjectPatternProperty,
+  MatchOrPattern,
+  MatchRestPattern,
+  MatchStatement,
+  MatchStatementCase,
+  MatchUnaryPattern,
+  MatchWildcardPattern,
   MemberExpression,
   MetaProperty,
   MethodDefinition,
@@ -163,6 +179,7 @@ import type {
   ReturnStatement,
   SequenceExpression,
   SpreadElement,
+  StaticBlock,
   StringLiteralTypeAnnotation,
   StringTypeAnnotation,
   Super,
@@ -1015,6 +1032,96 @@ interface LogicalExpression_With_right extends LogicalExpression {
 interface LogicalExpression_With_operator extends LogicalExpression {
   +operator: $NonMaybeType<LogicalExpression['operator']>;
 }
+interface MatchArrayPattern_With_elements extends MatchArrayPattern {
+  +elements: $NonMaybeType<MatchArrayPattern['elements']>;
+}
+interface MatchArrayPattern_With_rest extends MatchArrayPattern {
+  +rest: $NonMaybeType<MatchArrayPattern['rest']>;
+}
+interface MatchAsPattern_With_pattern extends MatchAsPattern {
+  +pattern: $NonMaybeType<MatchAsPattern['pattern']>;
+}
+interface MatchAsPattern_With_target extends MatchAsPattern {
+  +target: $NonMaybeType<MatchAsPattern['target']>;
+}
+interface MatchBindingPattern_With_id extends MatchBindingPattern {
+  +id: $NonMaybeType<MatchBindingPattern['id']>;
+}
+interface MatchBindingPattern_With_kind extends MatchBindingPattern {
+  +kind: $NonMaybeType<MatchBindingPattern['kind']>;
+}
+interface MatchExpression_With_argument extends MatchExpression {
+  +argument: $NonMaybeType<MatchExpression['argument']>;
+}
+interface MatchExpression_With_cases extends MatchExpression {
+  +cases: $NonMaybeType<MatchExpression['cases']>;
+}
+interface MatchExpressionCase_With_pattern extends MatchExpressionCase {
+  +pattern: $NonMaybeType<MatchExpressionCase['pattern']>;
+}
+interface MatchExpressionCase_With_body extends MatchExpressionCase {
+  +body: $NonMaybeType<MatchExpressionCase['body']>;
+}
+interface MatchExpressionCase_With_guard extends MatchExpressionCase {
+  +guard: $NonMaybeType<MatchExpressionCase['guard']>;
+}
+interface MatchIdentifierPattern_With_id extends MatchIdentifierPattern {
+  +id: $NonMaybeType<MatchIdentifierPattern['id']>;
+}
+interface MatchLiteralPattern_With_literal extends MatchLiteralPattern {
+  +literal: $NonMaybeType<MatchLiteralPattern['literal']>;
+}
+interface MatchMemberPattern_With_base extends MatchMemberPattern {
+  +base: $NonMaybeType<MatchMemberPattern['base']>;
+}
+interface MatchMemberPattern_With_property extends MatchMemberPattern {
+  +property: $NonMaybeType<MatchMemberPattern['property']>;
+}
+interface MatchObjectPattern_With_properties extends MatchObjectPattern {
+  +properties: $NonMaybeType<MatchObjectPattern['properties']>;
+}
+interface MatchObjectPattern_With_rest extends MatchObjectPattern {
+  +rest: $NonMaybeType<MatchObjectPattern['rest']>;
+}
+interface MatchObjectPatternProperty_With_key
+  extends MatchObjectPatternProperty {
+  +key: $NonMaybeType<MatchObjectPatternProperty['key']>;
+}
+interface MatchObjectPatternProperty_With_pattern
+  extends MatchObjectPatternProperty {
+  +pattern: $NonMaybeType<MatchObjectPatternProperty['pattern']>;
+}
+interface MatchObjectPatternProperty_With_shorthand
+  extends MatchObjectPatternProperty {
+  +shorthand: $NonMaybeType<MatchObjectPatternProperty['shorthand']>;
+}
+interface MatchOrPattern_With_patterns extends MatchOrPattern {
+  +patterns: $NonMaybeType<MatchOrPattern['patterns']>;
+}
+interface MatchRestPattern_With_argument extends MatchRestPattern {
+  +argument: $NonMaybeType<MatchRestPattern['argument']>;
+}
+interface MatchStatement_With_argument extends MatchStatement {
+  +argument: $NonMaybeType<MatchStatement['argument']>;
+}
+interface MatchStatement_With_cases extends MatchStatement {
+  +cases: $NonMaybeType<MatchStatement['cases']>;
+}
+interface MatchStatementCase_With_pattern extends MatchStatementCase {
+  +pattern: $NonMaybeType<MatchStatementCase['pattern']>;
+}
+interface MatchStatementCase_With_body extends MatchStatementCase {
+  +body: $NonMaybeType<MatchStatementCase['body']>;
+}
+interface MatchStatementCase_With_guard extends MatchStatementCase {
+  +guard: $NonMaybeType<MatchStatementCase['guard']>;
+}
+interface MatchUnaryPattern_With_argument extends MatchUnaryPattern {
+  +argument: $NonMaybeType<MatchUnaryPattern['argument']>;
+}
+interface MatchUnaryPattern_With_operator extends MatchUnaryPattern {
+  +operator: $NonMaybeType<MatchUnaryPattern['operator']>;
+}
 interface MemberExpression_With_object extends MemberExpression {
   +object: $NonMaybeType<MemberExpression['object']>;
 }
@@ -1279,6 +1386,9 @@ interface SequenceExpression_With_expressions extends SequenceExpression {
 interface SpreadElement_With_argument extends SpreadElement {
   +argument: $NonMaybeType<SpreadElement['argument']>;
 }
+interface StaticBlock_With_body extends StaticBlock {
+  +body: $NonMaybeType<StaticBlock['body']>;
+}
 interface StringLiteralTypeAnnotation_With_value
   extends StringLiteralTypeAnnotation {
   +value: $NonMaybeType<StringLiteralTypeAnnotation['value']>;
@@ -1393,6 +1503,9 @@ interface TypeOperator_With_typeAnnotation extends TypeOperator {
 interface TypeParameter_With_name extends TypeParameter {
   +name: $NonMaybeType<TypeParameter['name']>;
 }
+interface TypeParameter_With_const extends TypeParameter {
+  +const: $NonMaybeType<TypeParameter['const']>;
+}
 interface TypeParameter_With_bound extends TypeParameter {
   +bound: $NonMaybeType<TypeParameter['bound']>;
 }
@@ -1490,6 +1603,7 @@ type StatementSpecialSelector =
   | ForStatement
   | IfStatement
   | LabeledStatement
+  | MatchStatement
   | ReturnStatement
   | SwitchStatement
   | ThrowStatement
@@ -1511,7 +1625,21 @@ type DeclarationSpecialSelector =
   | InterfaceDeclaration
   | TypeParameterDeclaration
   | VariableDeclaration;
-type PatternSpecialSelector = ArrayPattern | AssignmentPattern | ObjectPattern;
+type PatternSpecialSelector =
+  | ArrayPattern
+  | AssignmentPattern
+  | MatchArrayPattern
+  | MatchAsPattern
+  | MatchBindingPattern
+  | MatchIdentifierPattern
+  | MatchLiteralPattern
+  | MatchMemberPattern
+  | MatchObjectPattern
+  | MatchOrPattern
+  | MatchRestPattern
+  | MatchUnaryPattern
+  | MatchWildcardPattern
+  | ObjectPattern;
 type ExpressionSpecialSelector =
   | Identifier
   | MetaProperty
@@ -1531,6 +1659,7 @@ type ExpressionSpecialSelector =
   | JSXEmptyExpression
   | JSXMemberExpression
   | LogicalExpression
+  | MatchExpression
   | MemberExpression
   | NewExpression
   | ObjectExpression
@@ -2205,6 +2334,79 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'LogicalExpression[operator]'?: (
     node: LogicalExpression_With_operator,
   ) => void,
+  +MatchArrayPattern?: (node: MatchArrayPattern) => void,
+  +'MatchArrayPattern[elements]'?: (
+    node: MatchArrayPattern_With_elements,
+  ) => void,
+  +'MatchArrayPattern[rest]'?: (node: MatchArrayPattern_With_rest) => void,
+  +MatchAsPattern?: (node: MatchAsPattern) => void,
+  +'MatchAsPattern[pattern]'?: (node: MatchAsPattern_With_pattern) => void,
+  +'MatchAsPattern[target]'?: (node: MatchAsPattern_With_target) => void,
+  +MatchBindingPattern?: (node: MatchBindingPattern) => void,
+  +'MatchBindingPattern[id]'?: (node: MatchBindingPattern_With_id) => void,
+  +'MatchBindingPattern[kind]'?: (node: MatchBindingPattern_With_kind) => void,
+  +MatchExpression?: (node: MatchExpression) => void,
+  +'MatchExpression[argument]'?: (node: MatchExpression_With_argument) => void,
+  +'MatchExpression[cases]'?: (node: MatchExpression_With_cases) => void,
+  +MatchExpressionCase?: (node: MatchExpressionCase) => void,
+  +'MatchExpressionCase[pattern]'?: (
+    node: MatchExpressionCase_With_pattern,
+  ) => void,
+  +'MatchExpressionCase[body]'?: (node: MatchExpressionCase_With_body) => void,
+  +'MatchExpressionCase[guard]'?: (
+    node: MatchExpressionCase_With_guard,
+  ) => void,
+  +MatchIdentifierPattern?: (node: MatchIdentifierPattern) => void,
+  +'MatchIdentifierPattern[id]'?: (
+    node: MatchIdentifierPattern_With_id,
+  ) => void,
+  +MatchLiteralPattern?: (node: MatchLiteralPattern) => void,
+  +'MatchLiteralPattern[literal]'?: (
+    node: MatchLiteralPattern_With_literal,
+  ) => void,
+  +MatchMemberPattern?: (node: MatchMemberPattern) => void,
+  +'MatchMemberPattern[base]'?: (node: MatchMemberPattern_With_base) => void,
+  +'MatchMemberPattern[property]'?: (
+    node: MatchMemberPattern_With_property,
+  ) => void,
+  +MatchObjectPattern?: (node: MatchObjectPattern) => void,
+  +'MatchObjectPattern[properties]'?: (
+    node: MatchObjectPattern_With_properties,
+  ) => void,
+  +'MatchObjectPattern[rest]'?: (node: MatchObjectPattern_With_rest) => void,
+  +MatchObjectPatternProperty?: (node: MatchObjectPatternProperty) => void,
+  +'MatchObjectPatternProperty[key]'?: (
+    node: MatchObjectPatternProperty_With_key,
+  ) => void,
+  +'MatchObjectPatternProperty[pattern]'?: (
+    node: MatchObjectPatternProperty_With_pattern,
+  ) => void,
+  +'MatchObjectPatternProperty[shorthand]'?: (
+    node: MatchObjectPatternProperty_With_shorthand,
+  ) => void,
+  +MatchOrPattern?: (node: MatchOrPattern) => void,
+  +'MatchOrPattern[patterns]'?: (node: MatchOrPattern_With_patterns) => void,
+  +MatchRestPattern?: (node: MatchRestPattern) => void,
+  +'MatchRestPattern[argument]'?: (
+    node: MatchRestPattern_With_argument,
+  ) => void,
+  +MatchStatement?: (node: MatchStatement) => void,
+  +'MatchStatement[argument]'?: (node: MatchStatement_With_argument) => void,
+  +'MatchStatement[cases]'?: (node: MatchStatement_With_cases) => void,
+  +MatchStatementCase?: (node: MatchStatementCase) => void,
+  +'MatchStatementCase[pattern]'?: (
+    node: MatchStatementCase_With_pattern,
+  ) => void,
+  +'MatchStatementCase[body]'?: (node: MatchStatementCase_With_body) => void,
+  +'MatchStatementCase[guard]'?: (node: MatchStatementCase_With_guard) => void,
+  +MatchUnaryPattern?: (node: MatchUnaryPattern) => void,
+  +'MatchUnaryPattern[argument]'?: (
+    node: MatchUnaryPattern_With_argument,
+  ) => void,
+  +'MatchUnaryPattern[operator]'?: (
+    node: MatchUnaryPattern_With_operator,
+  ) => void,
+  +MatchWildcardPattern?: (node: MatchWildcardPattern) => void,
   +MemberExpression?: (node: MemberExpression) => void,
   +'MemberExpression[object]'?: (node: MemberExpression_With_object) => void,
   +'MemberExpression[property]'?: (
@@ -2416,6 +2618,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +SpreadElement?: (node: SpreadElement) => void,
   +'SpreadElement[argument]'?: (node: SpreadElement_With_argument) => void,
+  +StaticBlock?: (node: StaticBlock) => void,
+  +'StaticBlock[body]'?: (node: StaticBlock_With_body) => void,
   +StringLiteralTypeAnnotation?: (node: StringLiteralTypeAnnotation) => void,
   +'StringLiteralTypeAnnotation[value]'?: (
     node: StringLiteralTypeAnnotation_With_value,
@@ -2514,6 +2718,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +TypeParameter?: (node: TypeParameter) => void,
   +'TypeParameter[name]'?: (node: TypeParameter_With_name) => void,
+  +'TypeParameter[const]'?: (node: TypeParameter_With_const) => void,
   +'TypeParameter[bound]'?: (node: TypeParameter_With_bound) => void,
   +'TypeParameter[variance]'?: (node: TypeParameter_With_variance) => void,
   +'TypeParameter[default]'?: (node: TypeParameter_With_default) => void,
@@ -3294,6 +3499,99 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   +'LogicalExpression[operator]:exit'?: (
     node: LogicalExpression_With_operator,
   ) => void,
+  +'MatchArrayPattern:exit'?: (node: MatchArrayPattern) => void,
+  +'MatchArrayPattern[elements]:exit'?: (
+    node: MatchArrayPattern_With_elements,
+  ) => void,
+  +'MatchArrayPattern[rest]:exit'?: (node: MatchArrayPattern_With_rest) => void,
+  +'MatchAsPattern:exit'?: (node: MatchAsPattern) => void,
+  +'MatchAsPattern[pattern]:exit'?: (node: MatchAsPattern_With_pattern) => void,
+  +'MatchAsPattern[target]:exit'?: (node: MatchAsPattern_With_target) => void,
+  +'MatchBindingPattern:exit'?: (node: MatchBindingPattern) => void,
+  +'MatchBindingPattern[id]:exit'?: (node: MatchBindingPattern_With_id) => void,
+  +'MatchBindingPattern[kind]:exit'?: (
+    node: MatchBindingPattern_With_kind,
+  ) => void,
+  +'MatchExpression:exit'?: (node: MatchExpression) => void,
+  +'MatchExpression[argument]:exit'?: (
+    node: MatchExpression_With_argument,
+  ) => void,
+  +'MatchExpression[cases]:exit'?: (node: MatchExpression_With_cases) => void,
+  +'MatchExpressionCase:exit'?: (node: MatchExpressionCase) => void,
+  +'MatchExpressionCase[pattern]:exit'?: (
+    node: MatchExpressionCase_With_pattern,
+  ) => void,
+  +'MatchExpressionCase[body]:exit'?: (
+    node: MatchExpressionCase_With_body,
+  ) => void,
+  +'MatchExpressionCase[guard]:exit'?: (
+    node: MatchExpressionCase_With_guard,
+  ) => void,
+  +'MatchIdentifierPattern:exit'?: (node: MatchIdentifierPattern) => void,
+  +'MatchIdentifierPattern[id]:exit'?: (
+    node: MatchIdentifierPattern_With_id,
+  ) => void,
+  +'MatchLiteralPattern:exit'?: (node: MatchLiteralPattern) => void,
+  +'MatchLiteralPattern[literal]:exit'?: (
+    node: MatchLiteralPattern_With_literal,
+  ) => void,
+  +'MatchMemberPattern:exit'?: (node: MatchMemberPattern) => void,
+  +'MatchMemberPattern[base]:exit'?: (
+    node: MatchMemberPattern_With_base,
+  ) => void,
+  +'MatchMemberPattern[property]:exit'?: (
+    node: MatchMemberPattern_With_property,
+  ) => void,
+  +'MatchObjectPattern:exit'?: (node: MatchObjectPattern) => void,
+  +'MatchObjectPattern[properties]:exit'?: (
+    node: MatchObjectPattern_With_properties,
+  ) => void,
+  +'MatchObjectPattern[rest]:exit'?: (
+    node: MatchObjectPattern_With_rest,
+  ) => void,
+  +'MatchObjectPatternProperty:exit'?: (
+    node: MatchObjectPatternProperty,
+  ) => void,
+  +'MatchObjectPatternProperty[key]:exit'?: (
+    node: MatchObjectPatternProperty_With_key,
+  ) => void,
+  +'MatchObjectPatternProperty[pattern]:exit'?: (
+    node: MatchObjectPatternProperty_With_pattern,
+  ) => void,
+  +'MatchObjectPatternProperty[shorthand]:exit'?: (
+    node: MatchObjectPatternProperty_With_shorthand,
+  ) => void,
+  +'MatchOrPattern:exit'?: (node: MatchOrPattern) => void,
+  +'MatchOrPattern[patterns]:exit'?: (
+    node: MatchOrPattern_With_patterns,
+  ) => void,
+  +'MatchRestPattern:exit'?: (node: MatchRestPattern) => void,
+  +'MatchRestPattern[argument]:exit'?: (
+    node: MatchRestPattern_With_argument,
+  ) => void,
+  +'MatchStatement:exit'?: (node: MatchStatement) => void,
+  +'MatchStatement[argument]:exit'?: (
+    node: MatchStatement_With_argument,
+  ) => void,
+  +'MatchStatement[cases]:exit'?: (node: MatchStatement_With_cases) => void,
+  +'MatchStatementCase:exit'?: (node: MatchStatementCase) => void,
+  +'MatchStatementCase[pattern]:exit'?: (
+    node: MatchStatementCase_With_pattern,
+  ) => void,
+  +'MatchStatementCase[body]:exit'?: (
+    node: MatchStatementCase_With_body,
+  ) => void,
+  +'MatchStatementCase[guard]:exit'?: (
+    node: MatchStatementCase_With_guard,
+  ) => void,
+  +'MatchUnaryPattern:exit'?: (node: MatchUnaryPattern) => void,
+  +'MatchUnaryPattern[argument]:exit'?: (
+    node: MatchUnaryPattern_With_argument,
+  ) => void,
+  +'MatchUnaryPattern[operator]:exit'?: (
+    node: MatchUnaryPattern_With_operator,
+  ) => void,
+  +'MatchWildcardPattern:exit'?: (node: MatchWildcardPattern) => void,
   +'MemberExpression:exit'?: (node: MemberExpression) => void,
   +'MemberExpression[object]:exit'?: (
     node: MemberExpression_With_object,
@@ -3531,6 +3829,8 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +'SpreadElement:exit'?: (node: SpreadElement) => void,
   +'SpreadElement[argument]:exit'?: (node: SpreadElement_With_argument) => void,
+  +'StaticBlock:exit'?: (node: StaticBlock) => void,
+  +'StaticBlock[body]:exit'?: (node: StaticBlock_With_body) => void,
   +'StringLiteralTypeAnnotation:exit'?: (
     node: StringLiteralTypeAnnotation,
   ) => void,
@@ -3635,6 +3935,7 @@ export type ESQueryNodeSelectorsWithoutFallback = {
   ) => void,
   +'TypeParameter:exit'?: (node: TypeParameter) => void,
   +'TypeParameter[name]:exit'?: (node: TypeParameter_With_name) => void,
+  +'TypeParameter[const]:exit'?: (node: TypeParameter_With_const) => void,
   +'TypeParameter[bound]:exit'?: (node: TypeParameter_With_bound) => void,
   +'TypeParameter[variance]:exit'?: (node: TypeParameter_With_variance) => void,
   +'TypeParameter[default]:exit'?: (node: TypeParameter_With_default) => void,

package/dist/generated/predicates.js

@@ -141,6 +141,22 @@ import type {
   KeyofTypeAnnotation,
   LabeledStatement,
   LogicalExpression,
+  MatchArrayPattern,
+  MatchAsPattern,
+  MatchBindingPattern,
+  MatchExpression,
+  MatchExpressionCase,
+  MatchIdentifierPattern,
+  MatchLiteralPattern,
+  MatchMemberPattern,
+  MatchObjectPattern,
+  MatchObjectPatternProperty,
+  MatchOrPattern,
+  MatchRestPattern,
+  MatchStatement,
+  MatchStatementCase,
+  MatchUnaryPattern,
+  MatchWildcardPattern,
   MemberExpression,
   MetaProperty,
   MethodDefinition,
@@ -171,6 +187,7 @@ import type {
   ReturnStatement,
   SequenceExpression,
   SpreadElement,
+  StaticBlock,
   StringLiteralTypeAnnotation,
   StringTypeAnnotation,
   Super,
@@ -398,6 +415,22 @@ exports.isLogicalOREqualToken = isLogicalOREqualToken;
 exports.isLogicalORToken = isLogicalORToken;
 exports.isLooseEqualToken = isLooseEqualToken;
 exports.isLooseNotEqualToken = isLooseNotEqualToken;
+exports.isMatchArrayPattern = isMatchArrayPattern;
+exports.isMatchAsPattern = isMatchAsPattern;
+exports.isMatchBindingPattern = isMatchBindingPattern;
+exports.isMatchExpression = isMatchExpression;
+exports.isMatchExpressionCase = isMatchExpressionCase;
+exports.isMatchIdentifierPattern = isMatchIdentifierPattern;
+exports.isMatchLiteralPattern = isMatchLiteralPattern;
+exports.isMatchMemberPattern = isMatchMemberPattern;
+exports.isMatchObjectPattern = isMatchObjectPattern;
+exports.isMatchObjectPatternProperty = isMatchObjectPatternProperty;
+exports.isMatchOrPattern = isMatchOrPattern;
+exports.isMatchRestPattern = isMatchRestPattern;
+exports.isMatchStatement = isMatchStatement;
+exports.isMatchStatementCase = isMatchStatementCase;
+exports.isMatchUnaryPattern = isMatchUnaryPattern;
+exports.isMatchWildcardPattern = isMatchWildcardPattern;
 exports.isMemberExpression = isMemberExpression;
 exports.isMetaProperty = isMetaProperty;
 exports.isMethodDefinition = isMethodDefinition;
@@ -448,6 +481,7 @@ exports.isSemicolonToken = isSemicolonToken;
 exports.isSequenceExpression = isSequenceExpression;
 exports.isSetKeyword = isSetKeyword;
 exports.isSpreadElement = isSpreadElement;
+exports.isStaticBlock = isStaticBlock;
 exports.isStaticToken = isStaticToken;
 exports.isStrictEqualToken = isStrictEqualToken;
 exports.isStrictNotEqualToken = isStrictNotEqualToken;
@@ -1381,6 +1415,134 @@ function isLogicalExpression(node
   return node.type === 'LogicalExpression';
 }
 
+function isMatchArrayPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchArrayPattern */
+{
+  return node.type === 'MatchArrayPattern';
+}
+
+function isMatchAsPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchAsPattern */
+{
+  return node.type === 'MatchAsPattern';
+}
+
+function isMatchBindingPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchBindingPattern */
+{
+  return node.type === 'MatchBindingPattern';
+}
+
+function isMatchExpression(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchExpression */
+{
+  return node.type === 'MatchExpression';
+}
+
+function isMatchExpressionCase(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchExpressionCase */
+{
+  return node.type === 'MatchExpressionCase';
+}
+
+function isMatchIdentifierPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchIdentifierPattern */
+{
+  return node.type === 'MatchIdentifierPattern';
+}
+
+function isMatchLiteralPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchLiteralPattern */
+{
+  return node.type === 'MatchLiteralPattern';
+}
+
+function isMatchMemberPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchMemberPattern */
+{
+  return node.type === 'MatchMemberPattern';
+}
+
+function isMatchObjectPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchObjectPattern */
+{
+  return node.type === 'MatchObjectPattern';
+}
+
+function isMatchObjectPatternProperty(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchObjectPatternProperty */
+{
+  return node.type === 'MatchObjectPatternProperty';
+}
+
+function isMatchOrPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchOrPattern */
+{
+  return node.type === 'MatchOrPattern';
+}
+
+function isMatchRestPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchRestPattern */
+{
+  return node.type === 'MatchRestPattern';
+}
+
+function isMatchStatement(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchStatement */
+{
+  return node.type === 'MatchStatement';
+}
+
+function isMatchStatementCase(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchStatementCase */
+{
+  return node.type === 'MatchStatementCase';
+}
+
+function isMatchUnaryPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchUnaryPattern */
+{
+  return node.type === 'MatchUnaryPattern';
+}
+
+function isMatchWildcardPattern(node
+/*: ESNode | Token */
+)
+/*: implies node is MatchWildcardPattern */
+{
+  return node.type === 'MatchWildcardPattern';
+}
+
 function isMemberExpression(node
 /*: ESNode | Token */
 )
@@ -1621,6 +1783,14 @@ function isSpreadElement(node
   return node.type === 'SpreadElement';
 }
 
+function isStaticBlock(node
+/*: ESNode | Token */
+)
+/*: implies node is StaticBlock */
+{
+  return node.type === 'StaticBlock';
+}
+
 function isStringLiteralTypeAnnotation(node
 /*: ESNode | Token */
 )

package/dist/generated/predicates.js.flow

@@ -142,6 +142,22 @@ import type {
   KeyofTypeAnnotation,
   LabeledStatement,
   LogicalExpression,
+  MatchArrayPattern,
+  MatchAsPattern,
+  MatchBindingPattern,
+  MatchExpression,
+  MatchExpressionCase,
+  MatchIdentifierPattern,
+  MatchLiteralPattern,
+  MatchMemberPattern,
+  MatchObjectPattern,
+  MatchObjectPatternProperty,
+  MatchOrPattern,
+  MatchRestPattern,
+  MatchStatement,
+  MatchStatementCase,
+  MatchUnaryPattern,
+  MatchWildcardPattern,
   MemberExpression,
   MetaProperty,
   MethodDefinition,
@@ -172,6 +188,7 @@ import type {
   ReturnStatement,
   SequenceExpression,
   SpreadElement,
+  StaticBlock,
   StringLiteralTypeAnnotation,
   StringTypeAnnotation,
   Super,
@@ -765,6 +782,86 @@ export function isLogicalExpression(node /*: ESNode | Token */) /*: implies node
 }
     
 
+export function isMatchArrayPattern(node /*: ESNode | Token */) /*: implies node is MatchArrayPattern */ {
+  return node.type === 'MatchArrayPattern';
+}
+    
+
+export function isMatchAsPattern(node /*: ESNode | Token */) /*: implies node is MatchAsPattern */ {
+  return node.type === 'MatchAsPattern';
+}
+    
+
+export function isMatchBindingPattern(node /*: ESNode | Token */) /*: implies node is MatchBindingPattern */ {
+  return node.type === 'MatchBindingPattern';
+}
+    
+
+export function isMatchExpression(node /*: ESNode | Token */) /*: implies node is MatchExpression */ {
+  return node.type === 'MatchExpression';
+}
+    
+
+export function isMatchExpressionCase(node /*: ESNode | Token */) /*: implies node is MatchExpressionCase */ {
+  return node.type === 'MatchExpressionCase';
+}
+    
+
+export function isMatchIdentifierPattern(node /*: ESNode | Token */) /*: implies node is MatchIdentifierPattern */ {
+  return node.type === 'MatchIdentifierPattern';
+}
+    
+
+export function isMatchLiteralPattern(node /*: ESNode | Token */) /*: implies node is MatchLiteralPattern */ {
+  return node.type === 'MatchLiteralPattern';
+}
+    
+
+export function isMatchMemberPattern(node /*: ESNode | Token */) /*: implies node is MatchMemberPattern */ {
+  return node.type === 'MatchMemberPattern';
+}
+    
+
+export function isMatchObjectPattern(node /*: ESNode | Token */) /*: implies node is MatchObjectPattern */ {
+  return node.type === 'MatchObjectPattern';
+}
+    
+
+export function isMatchObjectPatternProperty(node /*: ESNode | Token */) /*: implies node is MatchObjectPatternProperty */ {
+  return node.type === 'MatchObjectPatternProperty';
+}
+    
+
+export function isMatchOrPattern(node /*: ESNode | Token */) /*: implies node is MatchOrPattern */ {
+  return node.type === 'MatchOrPattern';
+}
+    
+
+export function isMatchRestPattern(node /*: ESNode | Token */) /*: implies node is MatchRestPattern */ {
+  return node.type === 'MatchRestPattern';
+}
+    
+
+export function isMatchStatement(node /*: ESNode | Token */) /*: implies node is MatchStatement */ {
+  return node.type === 'MatchStatement';
+}
+    
+
+export function isMatchStatementCase(node /*: ESNode | Token */) /*: implies node is MatchStatementCase */ {
+  return node.type === 'MatchStatementCase';
+}
+    
+
+export function isMatchUnaryPattern(node /*: ESNode | Token */) /*: implies node is MatchUnaryPattern */ {
+  return node.type === 'MatchUnaryPattern';
+}
+    
+
+export function isMatchWildcardPattern(node /*: ESNode | Token */) /*: implies node is MatchWildcardPattern */ {
+  return node.type === 'MatchWildcardPattern';
+}
+    
+
 export function isMemberExpression(node /*: ESNode | Token */) /*: implies node is MemberExpression */ {
   return node.type === 'MemberExpression';
 }
@@ -915,6 +1012,11 @@ export function isSpreadElement(node /*: ESNode | Token */) /*: implies node is
 }
     
 
+export function isStaticBlock(node /*: ESNode | Token */) /*: implies node is StaticBlock */ {
+  return node.type === 'StaticBlock';
+}
+    
+
 export function isStringLiteralTypeAnnotation(node /*: ESNode | Token */) /*: implies node is StringLiteralTypeAnnotation */ {
   return node.type === 'StringLiteralTypeAnnotation';
 }

package/dist/types.js.flow

@@ -203,6 +203,12 @@ export type ESNode =
   | EnumSymbolBody
   | DeclaredNode
   | ObjectTypeInternalSlot
+  // Match
+  | MatchPattern
+  | MatchRestPattern
+  | MatchObjectPatternProperty
+  | MatchExpressionCase
+  | MatchStatementCase
   // JSX
   | JSXNode;
 
@@ -262,13 +268,15 @@ export type Statement =
   | LabeledStatement
   | OpaqueType
   | ReturnStatement
+  | StaticBlock
   | SwitchStatement
   | ThrowStatement
   | TryStatement
   | TypeAlias
   | VariableDeclaration
   | WhileStatement
-  | WithStatement;
+  | WithStatement
+  | MatchStatement;
 
 // nodes that can be the direct parent of a statement
 export type StatementParentSingle =
@@ -281,7 +289,11 @@ export type StatementParentSingle =
   | ForInStatement
   | ForOfStatement;
 // nodes that can be the parent of a statement that store the statements in an array
-export type StatementParentArray = SwitchCase | Program | BlockStatement;
+export type StatementParentArray =
+  | SwitchCase
+  | Program
+  | BlockStatement
+  | StaticBlock;
 export type StatementParent = StatementParentSingle | StatementParentArray;
 
 export interface EmptyStatement extends BaseNode {
@@ -293,6 +305,11 @@ export interface BlockStatement extends BaseNode {
   +body: $ReadOnlyArray<Statement>;
 }
 
+export interface StaticBlock extends BaseNode {
+  +type: 'StaticBlock';
+  +body: $ReadOnlyArray<Statement>;
+}
+
 export interface ExpressionStatement extends BaseNode {
   +type: 'ExpressionStatement';
   +expression: Expression;
@@ -468,6 +485,7 @@ export type Expression =
   | TypeCastExpression
   | AsExpression
   | AsConstExpression
+  | MatchExpression
   | JSXFragment
   | JSXElement;
 
@@ -910,7 +928,7 @@ export type ClassPropertyNameNonComputed =
   | Identifier
   | StringLiteral;
 
-export type ClassMember = PropertyDefinition | MethodDefinition;
+export type ClassMember = PropertyDefinition | MethodDefinition | StaticBlock;
 export type ClassMemberWithNonComputedName =
   | PropertyDefinitionWithNonComputedName
   | MethodDefinitionConstructor
@@ -1588,6 +1606,7 @@ export interface TypeParameterDeclaration extends BaseNode {
 export interface TypeParameter extends BaseNode {
   +type: 'TypeParameter';
   +name: string;
+  +const: boolean;
   +bound: null | TypeAnnotation;
   +variance: null | Variance;
   +default: null | TypeAnnotationType;
@@ -1991,6 +2010,106 @@ export interface JSXSpreadChild extends BaseNode {
   +expression: Expression;
 }
 
+/************************************
+ * Match expressions and statements *
+ ************************************/
+
+export interface MatchExpression extends BaseNode {
+  +type: 'MatchExpression';
+  +argument: Expression;
+  +cases: $ReadOnlyArray<MatchExpressionCase>;
+}
+export interface MatchExpressionCase extends BaseNode {
+  +type: 'MatchExpressionCase';
+  +pattern: MatchPattern;
+  +body: Expression;
+  +guard: Expression | null;
+}
+
+export interface MatchStatement extends BaseNode {
+  +type: 'MatchStatement';
+  +argument: Expression;
+  +cases: $ReadOnlyArray<MatchStatementCase>;
+}
+export interface MatchStatementCase extends BaseNode {
+  +type: 'MatchStatementCase';
+  +pattern: MatchPattern;
+  +body: BlockStatement;
+  +guard: Expression | null;
+}
+
+/******************
+ * Match patterns *
+ ******************/
+
+export type MatchPattern =
+  | MatchOrPattern
+  | MatchAsPattern
+  | MatchWildcardPattern
+  | MatchLiteralPattern
+  | MatchUnaryPattern
+  | MatchIdentifierPattern
+  | MatchMemberPattern
+  | MatchBindingPattern
+  | MatchObjectPattern
+  | MatchArrayPattern;
+
+export interface MatchOrPattern extends BaseNode {
+  +type: 'MatchOrPattern';
+  +patterns: $ReadOnlyArray<MatchPattern>;
+}
+export interface MatchAsPattern extends BaseNode {
+  +type: 'MatchAsPattern';
+  +pattern: MatchPattern;
+  +target: Identifier | MatchBindingPattern;
+}
+export interface MatchWildcardPattern extends BaseNode {
+  +type: 'MatchWildcardPattern';
+}
+export interface MatchLiteralPattern extends BaseNode {
+  +type: 'MatchLiteralPattern';
+  +literal: Literal;
+}
+export interface MatchUnaryPattern extends BaseNode {
+  +type: 'MatchUnaryPattern';
+  +argument: Literal;
+  +operator: '-' | '+';
+}
+export interface MatchIdentifierPattern extends BaseNode {
+  +type: 'MatchIdentifierPattern';
+  +id: Identifier;
+}
+export interface MatchMemberPattern extends BaseNode {
+  +type: 'MatchMemberPattern';
+  +base: MatchIdentifierPattern | MatchMemberPattern;
+  +property: Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
+}
+export interface MatchBindingPattern extends BaseNode {
+  +type: 'MatchBindingPattern';
+  +id: Identifier;
+  +kind: 'let' | 'const' | 'var';
+}
+export interface MatchObjectPattern extends BaseNode {
+  +type: 'MatchObjectPattern';
+  +properties: $ReadOnlyArray<MatchObjectPatternProperty>;
+  +rest: MatchRestPattern | null;
+}
+export interface MatchObjectPatternProperty extends BaseNode {
+  +type: 'MatchObjectPatternProperty';
+  +key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
+  +pattern: MatchPattern;
+  +shorthand: boolean;
+}
+export interface MatchArrayPattern extends BaseNode {
+  +type: 'MatchArrayPattern';
+  +elements: $ReadOnlyArray<MatchPattern>;
+  +rest: MatchRestPattern | null;
+}
+export interface MatchRestPattern extends BaseNode {
+  +type: 'MatchRestPattern';
+  +argument: MatchBindingPattern | null;
+}
+
 /******************************************************
  * Deprecated spec nodes awaiting migration by Hermes *
  ******************************************************/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-estree",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "Flow types for the Flow-ESTree spec produced by the hermes parser",
   "main": "dist/index.js",
   "license": "MIT",