hermes-transform 0.25.1 → 0.27.0

package/dist/generated/TransformCloneSignatures.js.flow

@@ -134,6 +134,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,
@@ -167,6 +183,7 @@ import type {
   ReturnStatement,
   SequenceExpression,
   SpreadElement,
+  StaticBlock,
   StringLiteral,
   StringLiteralTypeAnnotation,
   StringTypeAnnotation,
@@ -317,6 +334,22 @@ import type {
   KeyofTypeAnnotationProps,
   LabeledStatementProps,
   LogicalExpressionProps,
+  MatchArrayPatternProps,
+  MatchAsPatternProps,
+  MatchBindingPatternProps,
+  MatchExpressionProps,
+  MatchExpressionCaseProps,
+  MatchIdentifierPatternProps,
+  MatchLiteralPatternProps,
+  MatchMemberPatternProps,
+  MatchObjectPatternProps,
+  MatchObjectPatternPropertyProps,
+  MatchOrPatternProps,
+  MatchRestPatternProps,
+  MatchStatementProps,
+  MatchStatementCaseProps,
+  MatchUnaryPatternProps,
+  MatchWildcardPatternProps,
   MemberExpressionProps,
   MetaPropertyProps,
   MethodDefinitionProps,
@@ -350,6 +383,7 @@ import type {
   ReturnStatementProps,
   SequenceExpressionProps,
   SpreadElementProps,
+  StaticBlockProps,
   StringLiteralProps,
   StringLiteralTypeAnnotationProps,
   StringTypeAnnotationProps,
@@ -1285,6 +1319,134 @@ type LogicalExpressionCloneSignature = ((
     node: ?LogicalExpression,
     newProps: Partial<LogicalExpressionProps>,
   ) => DetachedNode<LogicalExpression> | null);
+type MatchArrayPatternCloneSignature = ((
+  node: MatchArrayPattern,
+  newProps: Partial<MatchArrayPatternProps>,
+) => DetachedNode<MatchArrayPattern>) &
+  ((
+    node: ?MatchArrayPattern,
+    newProps: Partial<MatchArrayPatternProps>,
+  ) => DetachedNode<MatchArrayPattern> | null);
+type MatchAsPatternCloneSignature = ((
+  node: MatchAsPattern,
+  newProps: Partial<MatchAsPatternProps>,
+) => DetachedNode<MatchAsPattern>) &
+  ((
+    node: ?MatchAsPattern,
+    newProps: Partial<MatchAsPatternProps>,
+  ) => DetachedNode<MatchAsPattern> | null);
+type MatchBindingPatternCloneSignature = ((
+  node: MatchBindingPattern,
+  newProps: Partial<MatchBindingPatternProps>,
+) => DetachedNode<MatchBindingPattern>) &
+  ((
+    node: ?MatchBindingPattern,
+    newProps: Partial<MatchBindingPatternProps>,
+  ) => DetachedNode<MatchBindingPattern> | null);
+type MatchExpressionCloneSignature = ((
+  node: MatchExpression,
+  newProps: Partial<MatchExpressionProps>,
+) => DetachedNode<MatchExpression>) &
+  ((
+    node: ?MatchExpression,
+    newProps: Partial<MatchExpressionProps>,
+  ) => DetachedNode<MatchExpression> | null);
+type MatchExpressionCaseCloneSignature = ((
+  node: MatchExpressionCase,
+  newProps: Partial<MatchExpressionCaseProps>,
+) => DetachedNode<MatchExpressionCase>) &
+  ((
+    node: ?MatchExpressionCase,
+    newProps: Partial<MatchExpressionCaseProps>,
+  ) => DetachedNode<MatchExpressionCase> | null);
+type MatchIdentifierPatternCloneSignature = ((
+  node: MatchIdentifierPattern,
+  newProps: Partial<MatchIdentifierPatternProps>,
+) => DetachedNode<MatchIdentifierPattern>) &
+  ((
+    node: ?MatchIdentifierPattern,
+    newProps: Partial<MatchIdentifierPatternProps>,
+  ) => DetachedNode<MatchIdentifierPattern> | null);
+type MatchLiteralPatternCloneSignature = ((
+  node: MatchLiteralPattern,
+  newProps: Partial<MatchLiteralPatternProps>,
+) => DetachedNode<MatchLiteralPattern>) &
+  ((
+    node: ?MatchLiteralPattern,
+    newProps: Partial<MatchLiteralPatternProps>,
+  ) => DetachedNode<MatchLiteralPattern> | null);
+type MatchMemberPatternCloneSignature = ((
+  node: MatchMemberPattern,
+  newProps: Partial<MatchMemberPatternProps>,
+) => DetachedNode<MatchMemberPattern>) &
+  ((
+    node: ?MatchMemberPattern,
+    newProps: Partial<MatchMemberPatternProps>,
+  ) => DetachedNode<MatchMemberPattern> | null);
+type MatchObjectPatternCloneSignature = ((
+  node: MatchObjectPattern,
+  newProps: Partial<MatchObjectPatternProps>,
+) => DetachedNode<MatchObjectPattern>) &
+  ((
+    node: ?MatchObjectPattern,
+    newProps: Partial<MatchObjectPatternProps>,
+  ) => DetachedNode<MatchObjectPattern> | null);
+type MatchObjectPatternPropertyCloneSignature = ((
+  node: MatchObjectPatternProperty,
+  newProps: Partial<MatchObjectPatternPropertyProps>,
+) => DetachedNode<MatchObjectPatternProperty>) &
+  ((
+    node: ?MatchObjectPatternProperty,
+    newProps: Partial<MatchObjectPatternPropertyProps>,
+  ) => DetachedNode<MatchObjectPatternProperty> | null);
+type MatchOrPatternCloneSignature = ((
+  node: MatchOrPattern,
+  newProps: Partial<MatchOrPatternProps>,
+) => DetachedNode<MatchOrPattern>) &
+  ((
+    node: ?MatchOrPattern,
+    newProps: Partial<MatchOrPatternProps>,
+  ) => DetachedNode<MatchOrPattern> | null);
+type MatchRestPatternCloneSignature = ((
+  node: MatchRestPattern,
+  newProps: Partial<MatchRestPatternProps>,
+) => DetachedNode<MatchRestPattern>) &
+  ((
+    node: ?MatchRestPattern,
+    newProps: Partial<MatchRestPatternProps>,
+  ) => DetachedNode<MatchRestPattern> | null);
+type MatchStatementCloneSignature = ((
+  node: MatchStatement,
+  newProps: Partial<MatchStatementProps>,
+) => DetachedNode<MatchStatement>) &
+  ((
+    node: ?MatchStatement,
+    newProps: Partial<MatchStatementProps>,
+  ) => DetachedNode<MatchStatement> | null);
+type MatchStatementCaseCloneSignature = ((
+  node: MatchStatementCase,
+  newProps: Partial<MatchStatementCaseProps>,
+) => DetachedNode<MatchStatementCase>) &
+  ((
+    node: ?MatchStatementCase,
+    newProps: Partial<MatchStatementCaseProps>,
+  ) => DetachedNode<MatchStatementCase> | null);
+type MatchUnaryPatternCloneSignature = ((
+  node: MatchUnaryPattern,
+  newProps: Partial<MatchUnaryPatternProps>,
+) => DetachedNode<MatchUnaryPattern>) &
+  ((
+    node: ?MatchUnaryPattern,
+    newProps: Partial<MatchUnaryPatternProps>,
+  ) => DetachedNode<MatchUnaryPattern> | null);
+type MatchWildcardPatternCloneSignature = ((
+  node: MatchWildcardPattern,
+  newProps: Partial<MatchWildcardPatternProps>,
+) => DetachedNode<MatchWildcardPattern>) &
+  ((
+    node: ?MatchWildcardPattern,
+    newProps: Partial<MatchWildcardPatternProps>,
+  ) => DetachedNode<MatchWildcardPattern> | null);
 type MemberExpressionCloneSignature = ((
   node: MemberExpression,
   newProps: Partial<MemberExpressionProps>,
@@ -1549,6 +1711,14 @@ type SpreadElementCloneSignature = ((
     node: ?SpreadElement,
     newProps: Partial<SpreadElementProps>,
   ) => DetachedNode<SpreadElement> | null);
+type StaticBlockCloneSignature = ((
+  node: StaticBlock,
+  newProps: Partial<StaticBlockProps>,
+) => DetachedNode<StaticBlock>) &
+  ((
+    node: ?StaticBlock,
+    newProps: Partial<StaticBlockProps>,
+  ) => DetachedNode<StaticBlock> | null);
 type StringLiteralCloneSignature = ((
   node: StringLiteral,
   newProps: Partial<StringLiteralProps>,
@@ -1946,6 +2116,22 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   KeyofTypeAnnotationCloneSignature &
   LabeledStatementCloneSignature &
   LogicalExpressionCloneSignature &
+  MatchArrayPatternCloneSignature &
+  MatchAsPatternCloneSignature &
+  MatchBindingPatternCloneSignature &
+  MatchExpressionCloneSignature &
+  MatchExpressionCaseCloneSignature &
+  MatchIdentifierPatternCloneSignature &
+  MatchLiteralPatternCloneSignature &
+  MatchMemberPatternCloneSignature &
+  MatchObjectPatternCloneSignature &
+  MatchObjectPatternPropertyCloneSignature &
+  MatchOrPatternCloneSignature &
+  MatchRestPatternCloneSignature &
+  MatchStatementCloneSignature &
+  MatchStatementCaseCloneSignature &
+  MatchUnaryPatternCloneSignature &
+  MatchWildcardPatternCloneSignature &
   MemberExpressionCloneSignature &
   MetaPropertyCloneSignature &
   MethodDefinitionCloneSignature &
@@ -1979,6 +2165,7 @@ export type TransformCloneSignatures = AnyTypeAnnotationCloneSignature &
   ReturnStatementCloneSignature &
   SequenceExpressionCloneSignature &
   SpreadElementCloneSignature &
+  StaticBlockCloneSignature &
   StringLiteralCloneSignature &
   StringLiteralTypeAnnotationCloneSignature &
   StringTypeAnnotationCloneSignature &

package/dist/generated/TransformModifySignatures.js.flow

@@ -134,6 +134,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,
@@ -167,6 +183,7 @@ import type {
   ReturnStatement,
   SequenceExpression,
   SpreadElement,
+  StaticBlock,
   StringLiteral,
   StringLiteralTypeAnnotation,
   StringTypeAnnotation,
@@ -317,6 +334,22 @@ import type {
   KeyofTypeAnnotationProps,
   LabeledStatementProps,
   LogicalExpressionProps,
+  MatchArrayPatternProps,
+  MatchAsPatternProps,
+  MatchBindingPatternProps,
+  MatchExpressionProps,
+  MatchExpressionCaseProps,
+  MatchIdentifierPatternProps,
+  MatchLiteralPatternProps,
+  MatchMemberPatternProps,
+  MatchObjectPatternProps,
+  MatchObjectPatternPropertyProps,
+  MatchOrPatternProps,
+  MatchRestPatternProps,
+  MatchStatementProps,
+  MatchStatementCaseProps,
+  MatchUnaryPatternProps,
+  MatchWildcardPatternProps,
   MemberExpressionProps,
   MetaPropertyProps,
   MethodDefinitionProps,
@@ -350,6 +383,7 @@ import type {
   ReturnStatementProps,
   SequenceExpressionProps,
   SpreadElementProps,
+  StaticBlockProps,
   StringLiteralProps,
   StringLiteralTypeAnnotationProps,
   StringTypeAnnotationProps,
@@ -836,6 +870,70 @@ type LogicalExpressionModifySignature = (
   node: ?LogicalExpression,
   newProps: Partial<LogicalExpressionProps>,
 ) => void;
+type MatchArrayPatternModifySignature = (
+  node: ?MatchArrayPattern,
+  newProps: Partial<MatchArrayPatternProps>,
+) => void;
+type MatchAsPatternModifySignature = (
+  node: ?MatchAsPattern,
+  newProps: Partial<MatchAsPatternProps>,
+) => void;
+type MatchBindingPatternModifySignature = (
+  node: ?MatchBindingPattern,
+  newProps: Partial<MatchBindingPatternProps>,
+) => void;
+type MatchExpressionModifySignature = (
+  node: ?MatchExpression,
+  newProps: Partial<MatchExpressionProps>,
+) => void;
+type MatchExpressionCaseModifySignature = (
+  node: ?MatchExpressionCase,
+  newProps: Partial<MatchExpressionCaseProps>,
+) => void;
+type MatchIdentifierPatternModifySignature = (
+  node: ?MatchIdentifierPattern,
+  newProps: Partial<MatchIdentifierPatternProps>,
+) => void;
+type MatchLiteralPatternModifySignature = (
+  node: ?MatchLiteralPattern,
+  newProps: Partial<MatchLiteralPatternProps>,
+) => void;
+type MatchMemberPatternModifySignature = (
+  node: ?MatchMemberPattern,
+  newProps: Partial<MatchMemberPatternProps>,
+) => void;
+type MatchObjectPatternModifySignature = (
+  node: ?MatchObjectPattern,
+  newProps: Partial<MatchObjectPatternProps>,
+) => void;
+type MatchObjectPatternPropertyModifySignature = (
+  node: ?MatchObjectPatternProperty,
+  newProps: Partial<MatchObjectPatternPropertyProps>,
+) => void;
+type MatchOrPatternModifySignature = (
+  node: ?MatchOrPattern,
+  newProps: Partial<MatchOrPatternProps>,
+) => void;
+type MatchRestPatternModifySignature = (
+  node: ?MatchRestPattern,
+  newProps: Partial<MatchRestPatternProps>,
+) => void;
+type MatchStatementModifySignature = (
+  node: ?MatchStatement,
+  newProps: Partial<MatchStatementProps>,
+) => void;
+type MatchStatementCaseModifySignature = (
+  node: ?MatchStatementCase,
+  newProps: Partial<MatchStatementCaseProps>,
+) => void;
+type MatchUnaryPatternModifySignature = (
+  node: ?MatchUnaryPattern,
+  newProps: Partial<MatchUnaryPatternProps>,
+) => void;
+type MatchWildcardPatternModifySignature = (
+  node: ?MatchWildcardPattern,
+  newProps: Partial<MatchWildcardPatternProps>,
+) => void;
 type MemberExpressionModifySignature = (
   node: ?MemberExpression,
   newProps: Partial<MemberExpressionProps>,
@@ -968,6 +1066,10 @@ type SpreadElementModifySignature = (
   node: ?SpreadElement,
   newProps: Partial<SpreadElementProps>,
 ) => void;
+type StaticBlockModifySignature = (
+  node: ?StaticBlock,
+  newProps: Partial<StaticBlockProps>,
+) => void;
 type StringLiteralModifySignature = (
   node: ?StringLiteral,
   newProps: Partial<StringLiteralProps>,
@@ -1224,6 +1326,22 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   KeyofTypeAnnotationModifySignature &
   LabeledStatementModifySignature &
   LogicalExpressionModifySignature &
+  MatchArrayPatternModifySignature &
+  MatchAsPatternModifySignature &
+  MatchBindingPatternModifySignature &
+  MatchExpressionModifySignature &
+  MatchExpressionCaseModifySignature &
+  MatchIdentifierPatternModifySignature &
+  MatchLiteralPatternModifySignature &
+  MatchMemberPatternModifySignature &
+  MatchObjectPatternModifySignature &
+  MatchObjectPatternPropertyModifySignature &
+  MatchOrPatternModifySignature &
+  MatchRestPatternModifySignature &
+  MatchStatementModifySignature &
+  MatchStatementCaseModifySignature &
+  MatchUnaryPatternModifySignature &
+  MatchWildcardPatternModifySignature &
   MemberExpressionModifySignature &
   MetaPropertyModifySignature &
   MethodDefinitionModifySignature &
@@ -1257,6 +1375,7 @@ export type TransformModifySignatures = AnyTypeAnnotationModifySignature &
   ReturnStatementModifySignature &
   SequenceExpressionModifySignature &
   SpreadElementModifySignature &
+  StaticBlockModifySignature &
   StringLiteralModifySignature &
   StringLiteralTypeAnnotationModifySignature &
   StringTypeAnnotationModifySignature &

package/dist/generated/TransformReplaceSignatures.js.flow

@@ -132,6 +132,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,
@@ -162,6 +178,7 @@ import type {
   ReturnStatement,
   SequenceExpression,
   SpreadElement,
+  StaticBlock,
   StringLiteralTypeAnnotation,
   StringTypeAnnotation,
   Super,
@@ -751,6 +768,86 @@ type LogicalExpressionReplaceSignature = (
   nodeToReplaceWith: DetachedNode<LogicalExpression>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type MatchArrayPatternReplaceSignature = (
+  target: MatchArrayPattern,
+  nodeToReplaceWith: DetachedNode<MatchArrayPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchAsPatternReplaceSignature = (
+  target: MatchAsPattern,
+  nodeToReplaceWith: DetachedNode<MatchAsPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchBindingPatternReplaceSignature = (
+  target: MatchBindingPattern,
+  nodeToReplaceWith: DetachedNode<MatchBindingPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchExpressionReplaceSignature = (
+  target: MatchExpression,
+  nodeToReplaceWith: DetachedNode<MatchExpression>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchExpressionCaseReplaceSignature = (
+  target: MatchExpressionCase,
+  nodeToReplaceWith: DetachedNode<MatchExpressionCase>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchIdentifierPatternReplaceSignature = (
+  target: MatchIdentifierPattern,
+  nodeToReplaceWith: DetachedNode<MatchIdentifierPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchLiteralPatternReplaceSignature = (
+  target: MatchLiteralPattern,
+  nodeToReplaceWith: DetachedNode<MatchLiteralPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchMemberPatternReplaceSignature = (
+  target: MatchMemberPattern,
+  nodeToReplaceWith: DetachedNode<MatchMemberPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchObjectPatternReplaceSignature = (
+  target: MatchObjectPattern,
+  nodeToReplaceWith: DetachedNode<MatchObjectPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchObjectPatternPropertyReplaceSignature = (
+  target: MatchObjectPatternProperty,
+  nodeToReplaceWith: DetachedNode<MatchObjectPatternProperty>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchOrPatternReplaceSignature = (
+  target: MatchOrPattern,
+  nodeToReplaceWith: DetachedNode<MatchOrPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchRestPatternReplaceSignature = (
+  target: MatchRestPattern,
+  nodeToReplaceWith: DetachedNode<MatchRestPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchStatementReplaceSignature = (
+  target: MatchStatement,
+  nodeToReplaceWith: DetachedNode<MatchStatement>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchStatementCaseReplaceSignature = (
+  target: MatchStatementCase,
+  nodeToReplaceWith: DetachedNode<MatchStatementCase>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchUnaryPatternReplaceSignature = (
+  target: MatchUnaryPattern,
+  nodeToReplaceWith: DetachedNode<MatchUnaryPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
+type MatchWildcardPatternReplaceSignature = (
+  target: MatchWildcardPattern,
+  nodeToReplaceWith: DetachedNode<MatchWildcardPattern>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type MemberExpressionReplaceSignature = (
   target: MemberExpression,
   nodeToReplaceWith: DetachedNode<MemberExpression>,
@@ -901,6 +998,11 @@ type SpreadElementReplaceSignature = (
   nodeToReplaceWith: DetachedNode<SpreadElement>,
   options?: $ReadOnly<{keepComments?: boolean}>,
 ) => void;
+type StaticBlockReplaceSignature = (
+  target: StaticBlock,
+  nodeToReplaceWith: DetachedNode<StaticBlock>,
+  options?: $ReadOnly<{keepComments?: boolean}>,
+) => void;
 type StringLiteralTypeAnnotationReplaceSignature = (
   target: StringLiteralTypeAnnotation,
   nodeToReplaceWith: DetachedNode<StringLiteralTypeAnnotation>,
@@ -1191,6 +1293,22 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   KeyofTypeAnnotationReplaceSignature &
   LabeledStatementReplaceSignature &
   LogicalExpressionReplaceSignature &
+  MatchArrayPatternReplaceSignature &
+  MatchAsPatternReplaceSignature &
+  MatchBindingPatternReplaceSignature &
+  MatchExpressionReplaceSignature &
+  MatchExpressionCaseReplaceSignature &
+  MatchIdentifierPatternReplaceSignature &
+  MatchLiteralPatternReplaceSignature &
+  MatchMemberPatternReplaceSignature &
+  MatchObjectPatternReplaceSignature &
+  MatchObjectPatternPropertyReplaceSignature &
+  MatchOrPatternReplaceSignature &
+  MatchRestPatternReplaceSignature &
+  MatchStatementReplaceSignature &
+  MatchStatementCaseReplaceSignature &
+  MatchUnaryPatternReplaceSignature &
+  MatchWildcardPatternReplaceSignature &
   MemberExpressionReplaceSignature &
   MetaPropertyReplaceSignature &
   MethodDefinitionReplaceSignature &
@@ -1221,6 +1339,7 @@ export type TransformReplaceSignatures = AnyTypeAnnotationReplaceSignature &
   ReturnStatementReplaceSignature &
   SequenceExpressionReplaceSignature &
   SpreadElementReplaceSignature &
+  StaticBlockReplaceSignature &
   StringLiteralTypeAnnotationReplaceSignature &
   StringTypeAnnotationReplaceSignature &
   SuperReplaceSignature &

package/dist/generated/node-types.js

@@ -128,6 +128,22 @@ var _exportNames = {
   KeyofTypeAnnotation: true,
   LabeledStatement: true,
   LogicalExpression: true,
+  MatchArrayPattern: true,
+  MatchAsPattern: true,
+  MatchBindingPattern: true,
+  MatchExpression: true,
+  MatchExpressionCase: true,
+  MatchIdentifierPattern: true,
+  MatchLiteralPattern: true,
+  MatchMemberPattern: true,
+  MatchObjectPattern: true,
+  MatchObjectPatternProperty: true,
+  MatchOrPattern: true,
+  MatchRestPattern: true,
+  MatchStatement: true,
+  MatchStatementCase: true,
+  MatchUnaryPattern: true,
+  MatchWildcardPattern: true,
   MetaProperty: true,
   MethodDefinition: true,
   MixedTypeAnnotation: true,
@@ -155,6 +171,7 @@ var _exportNames = {
   ReturnStatement: true,
   SequenceExpression: true,
   SpreadElement: true,
+  StaticBlock: true,
   StringLiteralTypeAnnotation: true,
   StringTypeAnnotation: true,
   Super: true,
@@ -293,6 +310,22 @@ exports.JSXText = JSXText;
 exports.KeyofTypeAnnotation = KeyofTypeAnnotation;
 exports.LabeledStatement = LabeledStatement;
 exports.LogicalExpression = LogicalExpression;
+exports.MatchArrayPattern = MatchArrayPattern;
+exports.MatchAsPattern = MatchAsPattern;
+exports.MatchBindingPattern = MatchBindingPattern;
+exports.MatchExpression = MatchExpression;
+exports.MatchExpressionCase = MatchExpressionCase;
+exports.MatchIdentifierPattern = MatchIdentifierPattern;
+exports.MatchLiteralPattern = MatchLiteralPattern;
+exports.MatchMemberPattern = MatchMemberPattern;
+exports.MatchObjectPattern = MatchObjectPattern;
+exports.MatchObjectPatternProperty = MatchObjectPatternProperty;
+exports.MatchOrPattern = MatchOrPattern;
+exports.MatchRestPattern = MatchRestPattern;
+exports.MatchStatement = MatchStatement;
+exports.MatchStatementCase = MatchStatementCase;
+exports.MatchUnaryPattern = MatchUnaryPattern;
+exports.MatchWildcardPattern = MatchWildcardPattern;
 exports.MetaProperty = MetaProperty;
 exports.MethodDefinition = MethodDefinition;
 exports.MixedTypeAnnotation = MixedTypeAnnotation;
@@ -320,6 +353,7 @@ exports.RestElement = RestElement;
 exports.ReturnStatement = ReturnStatement;
 exports.SequenceExpression = SequenceExpression;
 exports.SpreadElement = SpreadElement;
+exports.StaticBlock = StaticBlock;
 exports.StringLiteralTypeAnnotation = StringLiteralTypeAnnotation;
 exports.StringTypeAnnotation = StringTypeAnnotation;
 exports.Super = Super;
@@ -1413,6 +1447,162 @@ function LogicalExpression(props) {
   return node;
 }
 
+function MatchArrayPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchArrayPattern',
+    elements: props.elements.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
+    rest: (0, _detachedNode.asDetachedNodeForCodeGen)(props.rest)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchAsPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchAsPattern',
+    pattern: (0, _detachedNode.asDetachedNodeForCodeGen)(props.pattern),
+    target: (0, _detachedNode.asDetachedNodeForCodeGen)(props.target)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchBindingPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchBindingPattern',
+    id: (0, _detachedNode.asDetachedNodeForCodeGen)(props.id),
+    kind: props.kind
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchExpression(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchExpression',
+    argument: (0, _detachedNode.asDetachedNodeForCodeGen)(props.argument),
+    cases: props.cases.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n))
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchExpressionCase(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchExpressionCase',
+    pattern: (0, _detachedNode.asDetachedNodeForCodeGen)(props.pattern),
+    body: (0, _detachedNode.asDetachedNodeForCodeGen)(props.body),
+    guard: (0, _detachedNode.asDetachedNodeForCodeGen)(props.guard)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchIdentifierPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchIdentifierPattern',
+    id: (0, _detachedNode.asDetachedNodeForCodeGen)(props.id)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchLiteralPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchLiteralPattern',
+    literal: (0, _detachedNode.asDetachedNodeForCodeGen)(props.literal)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchMemberPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchMemberPattern',
+    base: (0, _detachedNode.asDetachedNodeForCodeGen)(props.base),
+    property: (0, _detachedNode.asDetachedNodeForCodeGen)(props.property)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchObjectPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchObjectPattern',
+    properties: props.properties.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n)),
+    rest: (0, _detachedNode.asDetachedNodeForCodeGen)(props.rest)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchObjectPatternProperty(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchObjectPatternProperty',
+    key: (0, _detachedNode.asDetachedNodeForCodeGen)(props.key),
+    pattern: (0, _detachedNode.asDetachedNodeForCodeGen)(props.pattern),
+    shorthand: props.shorthand
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchOrPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchOrPattern',
+    patterns: props.patterns.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n))
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchRestPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchRestPattern',
+    argument: (0, _detachedNode.asDetachedNodeForCodeGen)(props.argument)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchStatement(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchStatement',
+    argument: (0, _detachedNode.asDetachedNodeForCodeGen)(props.argument),
+    cases: props.cases.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n))
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchStatementCase(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchStatementCase',
+    pattern: (0, _detachedNode.asDetachedNodeForCodeGen)(props.pattern),
+    body: (0, _detachedNode.asDetachedNodeForCodeGen)(props.body),
+    guard: (0, _detachedNode.asDetachedNodeForCodeGen)(props.guard)
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchUnaryPattern(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchUnaryPattern',
+    argument: (0, _detachedNode.asDetachedNodeForCodeGen)(props.argument),
+    operator: props.operator
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
+function MatchWildcardPattern(props = { ...null
+}) {
+  return (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'MatchWildcardPattern'
+  });
+}
+
 function MetaProperty(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'MetaProperty',
@@ -1696,6 +1886,15 @@ function SpreadElement(props) {
   return node;
 }
 
+function StaticBlock(props) {
+  const node = (0, _detachedNode.detachedProps)(props.parent, {
+    type: 'StaticBlock',
+    body: props.body.map(n => (0, _detachedNode.asDetachedNodeForCodeGen)(n))
+  });
+  (0, _detachedNode.setParentPointersInDirectChildren)(node);
+  return node;
+}
+
 function StringLiteralTypeAnnotation(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'StringLiteralTypeAnnotation',
@@ -1887,6 +2086,7 @@ function TypeParameter(props) {
   const node = (0, _detachedNode.detachedProps)(props.parent, {
     type: 'TypeParameter',
     name: props.name,
+    const: props.const,
     bound: (0, _detachedNode.asDetachedNodeForCodeGen)(props.bound),
     variance: (0, _detachedNode.asDetachedNodeForCodeGen)(props.variance),
     default: (0, _detachedNode.asDetachedNodeForCodeGen)(props.default),

package/dist/generated/node-types.js.flow

@@ -126,6 +126,22 @@ import type {
   KeyofTypeAnnotation as KeyofTypeAnnotationType,
   LabeledStatement as LabeledStatementType,
   LogicalExpression as LogicalExpressionType,
+  MatchArrayPattern as MatchArrayPatternType,
+  MatchAsPattern as MatchAsPatternType,
+  MatchBindingPattern as MatchBindingPatternType,
+  MatchExpression as MatchExpressionType,
+  MatchExpressionCase as MatchExpressionCaseType,
+  MatchIdentifierPattern as MatchIdentifierPatternType,
+  MatchLiteralPattern as MatchLiteralPatternType,
+  MatchMemberPattern as MatchMemberPatternType,
+  MatchObjectPattern as MatchObjectPatternType,
+  MatchObjectPatternProperty as MatchObjectPatternPropertyType,
+  MatchOrPattern as MatchOrPatternType,
+  MatchRestPattern as MatchRestPatternType,
+  MatchStatement as MatchStatementType,
+  MatchStatementCase as MatchStatementCaseType,
+  MatchUnaryPattern as MatchUnaryPatternType,
+  MatchWildcardPattern as MatchWildcardPatternType,
   MetaProperty as MetaPropertyType,
   MethodDefinition as MethodDefinitionType,
   MixedTypeAnnotation as MixedTypeAnnotationType,
@@ -153,6 +169,7 @@ import type {
   ReturnStatement as ReturnStatementType,
   SequenceExpression as SequenceExpressionType,
   SpreadElement as SpreadElementType,
+  StaticBlock as StaticBlockType,
   StringLiteralTypeAnnotation as StringLiteralTypeAnnotationType,
   StringTypeAnnotation as StringTypeAnnotationType,
   Super as SuperType,
@@ -808,6 +825,92 @@ export type LogicalExpressionProps = {
   +operator: LogicalExpressionType['operator'],
 };
 
+export type MatchArrayPatternProps = {
+  +elements: $ReadOnlyArray<
+    MaybeDetachedNode<MatchArrayPatternType['elements'][number]>,
+  >,
+  +rest?: ?MaybeDetachedNode<MatchArrayPatternType['rest']>,
+};
+
+export type MatchAsPatternProps = {
+  +pattern: MaybeDetachedNode<MatchAsPatternType['pattern']>,
+  +target: MaybeDetachedNode<MatchAsPatternType['target']>,
+};
+
+export type MatchBindingPatternProps = {
+  +id: MaybeDetachedNode<MatchBindingPatternType['id']>,
+  +kind: MatchBindingPatternType['kind'],
+};
+
+export type MatchExpressionProps = {
+  +argument: MaybeDetachedNode<MatchExpressionType['argument']>,
+  +cases: $ReadOnlyArray<
+    MaybeDetachedNode<MatchExpressionType['cases'][number]>,
+  >,
+};
+
+export type MatchExpressionCaseProps = {
+  +pattern: MaybeDetachedNode<MatchExpressionCaseType['pattern']>,
+  +body: MaybeDetachedNode<MatchExpressionCaseType['body']>,
+  +guard?: ?MaybeDetachedNode<MatchExpressionCaseType['guard']>,
+};
+
+export type MatchIdentifierPatternProps = {
+  +id: MaybeDetachedNode<MatchIdentifierPatternType['id']>,
+};
+
+export type MatchLiteralPatternProps = {
+  +literal: MaybeDetachedNode<MatchLiteralPatternType['literal']>,
+};
+
+export type MatchMemberPatternProps = {
+  +base: MaybeDetachedNode<MatchMemberPatternType['base']>,
+  +property: MaybeDetachedNode<MatchMemberPatternType['property']>,
+};
+
+export type MatchObjectPatternProps = {
+  +properties: $ReadOnlyArray<
+    MaybeDetachedNode<MatchObjectPatternType['properties'][number]>,
+  >,
+  +rest?: ?MaybeDetachedNode<MatchObjectPatternType['rest']>,
+};
+
+export type MatchObjectPatternPropertyProps = {
+  +key: MaybeDetachedNode<MatchObjectPatternPropertyType['key']>,
+  +pattern: MaybeDetachedNode<MatchObjectPatternPropertyType['pattern']>,
+  +shorthand: MatchObjectPatternPropertyType['shorthand'],
+};
+
+export type MatchOrPatternProps = {
+  +patterns: $ReadOnlyArray<
+    MaybeDetachedNode<MatchOrPatternType['patterns'][number]>,
+  >,
+};
+
+export type MatchRestPatternProps = {
+  +argument?: ?MaybeDetachedNode<MatchRestPatternType['argument']>,
+};
+
+export type MatchStatementProps = {
+  +argument: MaybeDetachedNode<MatchStatementType['argument']>,
+  +cases: $ReadOnlyArray<
+    MaybeDetachedNode<MatchStatementType['cases'][number]>,
+  >,
+};
+
+export type MatchStatementCaseProps = {
+  +pattern: MaybeDetachedNode<MatchStatementCaseType['pattern']>,
+  +body: MaybeDetachedNode<MatchStatementCaseType['body']>,
+  +guard?: ?MaybeDetachedNode<MatchStatementCaseType['guard']>,
+};
+
+export type MatchUnaryPatternProps = {
+  +argument: MaybeDetachedNode<MatchUnaryPatternType['argument']>,
+  +operator: MatchUnaryPatternType['operator'],
+};
+
+export type MatchWildcardPatternProps = {};
+
 export type MetaPropertyProps = {
   +meta: MaybeDetachedNode<MetaPropertyType['meta']>,
   +property: MaybeDetachedNode<MetaPropertyType['property']>,
@@ -982,6 +1085,10 @@ export type SpreadElementProps = {
   +argument: MaybeDetachedNode<SpreadElementType['argument']>,
 };
 
+export type StaticBlockProps = {
+  +body: $ReadOnlyArray<MaybeDetachedNode<StaticBlockType['body'][number]>>,
+};
+
 export type StringLiteralTypeAnnotationProps = {
   +value: StringLiteralTypeAnnotationType['value'],
   +raw: StringLiteralTypeAnnotationType['raw'],
@@ -1085,6 +1192,7 @@ export type TypeOperatorProps = {
 
 export type TypeParameterProps = {
   +name: TypeParameterType['name'],
+  +const: TypeParameterType['const'],
   +bound?: ?MaybeDetachedNode<TypeParameterType['bound']>,
   +variance?: ?MaybeDetachedNode<TypeParameterType['variance']>,
   +default?: ?MaybeDetachedNode<TypeParameterType['default']>,
@@ -2646,6 +2754,240 @@ export function LogicalExpression(props: {
   return node;
 }
 
+export function MatchArrayPattern(props: {
+  ...MatchArrayPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchArrayPatternType> {
+  const node = detachedProps<MatchArrayPatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchArrayPattern',
+      elements: props.elements.map(n => asDetachedNodeForCodeGen(n)),
+      rest: asDetachedNodeForCodeGen(props.rest),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchAsPattern(props: {
+  ...MatchAsPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchAsPatternType> {
+  const node = detachedProps<MatchAsPatternType>((props.parent: $FlowFixMe), {
+    type: 'MatchAsPattern',
+    pattern: asDetachedNodeForCodeGen(props.pattern),
+    target: asDetachedNodeForCodeGen(props.target),
+  });
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchBindingPattern(props: {
+  ...MatchBindingPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchBindingPatternType> {
+  const node = detachedProps<MatchBindingPatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchBindingPattern',
+      id: asDetachedNodeForCodeGen(props.id),
+      kind: props.kind,
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchExpression(props: {
+  ...MatchExpressionProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchExpressionType> {
+  const node = detachedProps<MatchExpressionType>((props.parent: $FlowFixMe), {
+    type: 'MatchExpression',
+    argument: asDetachedNodeForCodeGen(props.argument),
+    cases: props.cases.map(n => asDetachedNodeForCodeGen(n)),
+  });
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchExpressionCase(props: {
+  ...MatchExpressionCaseProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchExpressionCaseType> {
+  const node = detachedProps<MatchExpressionCaseType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchExpressionCase',
+      pattern: asDetachedNodeForCodeGen(props.pattern),
+      body: asDetachedNodeForCodeGen(props.body),
+      guard: asDetachedNodeForCodeGen(props.guard),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchIdentifierPattern(props: {
+  ...MatchIdentifierPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchIdentifierPatternType> {
+  const node = detachedProps<MatchIdentifierPatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchIdentifierPattern',
+      id: asDetachedNodeForCodeGen(props.id),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchLiteralPattern(props: {
+  ...MatchLiteralPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchLiteralPatternType> {
+  const node = detachedProps<MatchLiteralPatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchLiteralPattern',
+      literal: asDetachedNodeForCodeGen(props.literal),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchMemberPattern(props: {
+  ...MatchMemberPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchMemberPatternType> {
+  const node = detachedProps<MatchMemberPatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchMemberPattern',
+      base: asDetachedNodeForCodeGen(props.base),
+      property: asDetachedNodeForCodeGen(props.property),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchObjectPattern(props: {
+  ...MatchObjectPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchObjectPatternType> {
+  const node = detachedProps<MatchObjectPatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchObjectPattern',
+      properties: props.properties.map(n => asDetachedNodeForCodeGen(n)),
+      rest: asDetachedNodeForCodeGen(props.rest),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchObjectPatternProperty(props: {
+  ...MatchObjectPatternPropertyProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchObjectPatternPropertyType> {
+  const node = detachedProps<MatchObjectPatternPropertyType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchObjectPatternProperty',
+      key: asDetachedNodeForCodeGen(props.key),
+      pattern: asDetachedNodeForCodeGen(props.pattern),
+      shorthand: props.shorthand,
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchOrPattern(props: {
+  ...MatchOrPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchOrPatternType> {
+  const node = detachedProps<MatchOrPatternType>((props.parent: $FlowFixMe), {
+    type: 'MatchOrPattern',
+    patterns: props.patterns.map(n => asDetachedNodeForCodeGen(n)),
+  });
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchRestPattern(props: {
+  ...MatchRestPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchRestPatternType> {
+  const node = detachedProps<MatchRestPatternType>((props.parent: $FlowFixMe), {
+    type: 'MatchRestPattern',
+    argument: asDetachedNodeForCodeGen(props.argument),
+  });
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchStatement(props: {
+  ...MatchStatementProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchStatementType> {
+  const node = detachedProps<MatchStatementType>((props.parent: $FlowFixMe), {
+    type: 'MatchStatement',
+    argument: asDetachedNodeForCodeGen(props.argument),
+    cases: props.cases.map(n => asDetachedNodeForCodeGen(n)),
+  });
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchStatementCase(props: {
+  ...MatchStatementCaseProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchStatementCaseType> {
+  const node = detachedProps<MatchStatementCaseType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchStatementCase',
+      pattern: asDetachedNodeForCodeGen(props.pattern),
+      body: asDetachedNodeForCodeGen(props.body),
+      guard: asDetachedNodeForCodeGen(props.guard),
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchUnaryPattern(props: {
+  ...MatchUnaryPatternProps,
+  +parent?: ESNode,
+}): DetachedNode<MatchUnaryPatternType> {
+  const node = detachedProps<MatchUnaryPatternType>(
+    (props.parent: $FlowFixMe),
+    {
+      type: 'MatchUnaryPattern',
+      argument: asDetachedNodeForCodeGen(props.argument),
+      operator: props.operator,
+    },
+  );
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
+export function MatchWildcardPattern(
+  props: {
+    +parent?: ESNode,
+  } = {...null},
+): DetachedNode<MatchWildcardPatternType> {
+  return detachedProps<MatchWildcardPatternType>((props.parent: $FlowFixMe), {
+    type: 'MatchWildcardPattern',
+  });
+}
+
 export function MetaProperty(props: {
   ...MetaPropertyProps,
   +parent?: ESNode,
@@ -3057,6 +3399,18 @@ export function SpreadElement(props: {
   return node;
 }
 
+export function StaticBlock(props: {
+  ...StaticBlockProps,
+  +parent?: ESNode,
+}): DetachedNode<StaticBlockType> {
+  const node = detachedProps<StaticBlockType>((props.parent: $FlowFixMe), {
+    type: 'StaticBlock',
+    body: props.body.map(n => asDetachedNodeForCodeGen(n)),
+  });
+  setParentPointersInDirectChildren((node: $FlowFixMe));
+  return node;
+}
+
 export function StringLiteralTypeAnnotation(props: {
   ...StringLiteralTypeAnnotationProps,
   +parent?: ESNode,
@@ -3332,6 +3686,7 @@ export function TypeParameter(props: {
   const node = detachedProps<TypeParameterType>((props.parent: $FlowFixMe), {
     type: 'TypeParameter',
     name: props.name,
+    const: props.const,
     bound: asDetachedNodeForCodeGen(props.bound),
     variance: asDetachedNodeForCodeGen(props.variance),
     default: asDetachedNodeForCodeGen(props.default),

package/dist/transform/comments/comments.js

@@ -82,7 +82,7 @@ function mutateESTreeASTCommentsForPrettier(program, text) {
       docblockComment.leading = true; // $FlowExpectedError[prop-missing]
 
       docblockComment.trailing = false;
-    } // If we have a first node in the program body, attache the comment to that
+    } // If we have a first node in the program body, attach the comment to that
     // otherwise set it on the program.
 
 

package/dist/transform/comments/comments.js.flow

@@ -77,7 +77,7 @@ export function mutateESTreeASTCommentsForPrettier(
       docblockComment.trailing = false;
     }
 
-    // If we have a first node in the program body, attache the comment to that
+    // If we have a first node in the program body, attach the comment to that
     // otherwise set it on the program.
     if (program.body.length > 0) {
       const firstStatement = program.body[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-transform",
-  "version": "0.25.1",
+  "version": "0.27.0",
   "description": "Tools built on top of Hermes-ESTree to enable codebase transformation",
   "main": "dist/index.js",
   "license": "MIT",
@@ -12,14 +12,14 @@
     "@babel/code-frame": "^7.16.0",
     "esquery": "^1.4.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-eslint": "0.25.1",
-    "hermes-estree": "0.25.1",
-    "hermes-parser": "0.25.1",
+    "hermes-eslint": "0.27.0",
+    "hermes-estree": "0.27.0",
+    "hermes-parser": "0.27.0",
     "string-width": "4.2.3"
   },
   "peerDependencies": {
     "prettier": "^3.0.0 || ^2.7.1",
-    "prettier-plugin-hermes-parser": "0.25.1"
+    "prettier-plugin-hermes-parser": "0.27.0"
   },
   "files": [
     "dist",