-- Language definition for TypeScript, generated by ast-generate. Do not edit!
{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}

module Language.TypeScript.AST (module Language.TypeScript.AST, getTestCorpusDir) where

import qualified AST.Parse
import qualified AST.Token
import qualified AST.Traversable1.Class
import qualified AST.Unmarshal
import qualified Data.Foldable
import qualified Data.List as Data.OldList
import qualified Data.Maybe as GHC.Maybe
import qualified Data.Text.Internal
import qualified Data.Traversable
import qualified GHC.Base
import qualified GHC.Generics
import qualified GHC.Records
import qualified GHC.Show
import qualified TreeSitter.Node
import TreeSitter.TypeScript (getTestCorpusDir)
import qualified Prelude as GHC.Classes

debugSymbolNames :: [GHC.Base.String]
debugSymbolNames = debugSymbolNames_0

debugSymbolNames_0 :: [GHC.Base.String]
debugSymbolNames_0 =
  [ "end",
    "identifier",
    "hash_bang_line",
    "_export",
    "_*",
    "_default",
    "_=",
    "_as",
    "_namespace",
    "_{",
    "_,",
    "_}",
    "_type",
    "_typeof",
    "_import",
    "_from",
    "_var",
    "_let",
    "_const",
    "_if",
    "_else",
    "_switch",
    "_for",
    "_(",
    "_)",
    "_await",
    "_in",
    "_of",
    "_while",
    "_do",
    "_try",
    "_with",
    "_break",
    "_continue",
    "_debugger",
    "_return",
    "_throw",
    "_;",
    "_:",
    "_case",
    "_catch",
    "_finally",
    "_yield",
    "_[",
    "_]",
    "_<",
    "_>",
    "_/",
    "_.",
    "_class",
    "_async",
    "_function",
    "_=>",
    "_new",
    "_+=",
    "_-=",
    "_*=",
    "_/=",
    "_%=",
    "_^=",
    "_&=",
    "_|=",
    "_>>=",
    "_>>>=",
    "_<<=",
    "_**=",
    "_...",
    "_?",
    "_&&",
    "_||",
    "_>>",
    "_>>>",
    "_<<",
    "_&",
    "_^",
    "_|",
    "_+",
    "_-",
    "_%",
    "_**",
    "_<=",
    "_==",
    "_===",
    "_!=",
    "_!==",
    "_>=",
    "_??",
    "_instanceof",
    "_!",
    "_~",
    "_void",
    "_delete",
    "_++",
    "_--",
    "_\"",
    "_string_token1",
    "_'",
    "_string_token2",
    "escape_sequence",
    "comment",
    "_`",
    "_${",
    "_/",
    "regex_pattern",
    "regex_flags",
    "number",
    "_target",
    "this",
    "super",
    "true",
    "false",
    "null",
    "undefined",
    "_@",
    "_static",
    "_abstract",
    "_get",
    "_set",
    "_declare",
    "_public",
    "_private",
    "_protected",
    "_module",
    "_any",
    "_number",
    "_boolean",
    "_string",
    "_symbol",
    "_require",
    "_implements",
    "_global",
    "_interface",
    "_extends",
    "_enum",
    "readonly",
    "_is",
    "_keyof",
    "_{|",
    "_|}",
    "_automatic_semicolon",
    "_template_chars",
    "program",
    "export_statement",
    "export_clause",
    "_import_export_specifier",
    "_declaration",
    "import",
    "import_statement",
    "import_clause",
    "_from_clause",
    "namespace_import",
    "named_imports",
    "expression_statement",
    "variable_declaration",
    "lexical_declaration",
    "variable_declarator",
    "statement_block",
    "if_statement",
    "switch_statement",
    "for_statement",
    "for_in_statement",
    "_for_header",
    "while_statement",
    "do_statement",
    "try_statement",
    "with_statement",
    "break_statement",
    "continue_statement",
    "debugger_statement",
    "return_statement",
    "throw_statement",
    "empty_statement",
    "labeled_statement",
    "switch_body",
    "switch_case",
    "switch_default",
    "catch_clause",
    "finally_clause",
    "parenthesized_expression",
    "_expression",
    "yield_expression",
    "object",
    "assignment_pattern",
    "array",
    "nested_identifier",
    "class",
    "class_declaration",
    "class_heritage",
    "function",
    "function_declaration",
    "generator_function",
    "generator_function_declaration",
    "arrow_function",
    "_call_signature",
    "call_expression",
    "new_expression",
    "await_expression",
    "member_expression",
    "subscript_expression",
    "assignment_expression",
    "augmented_assignment_expression",
    "_initializer",
    "spread_element",
    "ternary_expression",
    "binary_expression",
    "unary_expression",
    "update_expression",
    "sequence_expression",
    "string",
    "template_string",
    "template_substitution",
    "regex",
    "meta_property",
    "arguments",
    "decorator",
    "member_expression",
    "call_expression",
    "class_body",
    "public_field_definition",
    "formal_parameters",
    "rest_parameter",
    "method_definition",
    "pair",
    "_property_name",
    "computed_property_name",
    "non_null_expression",
    "method_signature",
    "abstract_method_signature",
    "function_signature",
    "type_assertion",
    "as_expression",
    "import_require_clause",
    "implements_clause",
    "ambient_declaration",
    "abstract_class_declaration",
    "module",
    "internal_module",
    "_module",
    "import_alias",
    "nested_type_identifier",
    "interface_declaration",
    "extends_clause",
    "enum_declaration",
    "enum_body",
    "enum_assignment",
    "type_alias_declaration",
    "accessibility_modifier",
    "required_parameter",
    "optional_parameter",
    "_parameter_name",
    "type_annotation",
    "_type",
    "constructor_type",
    "_primary_type",
    "generic_type",
    "type_predicate",
    "type_query",
    "index_type_query",
    "lookup_type",
    "mapped_type_clause",
    "literal_type",
    "unary_expression",
    "existential_type",
    "flow_maybe_type",
    "parenthesized_type",
    "predefined_type",
    "type_arguments",
    "object_type",
    "call_signature",
    "property_signature",
    "type_parameters",
    "type_parameter",
    "default_type",
    "constraint",
    "construct_signature",
    "index_signature",
    "array_type",
    "tuple_type",
    "union_type",
    "intersection_type",
    "function_type",
    "_program_repeat1",
    "_export_statement_repeat1",
    "_export_clause_repeat1",
    "_named_imports_repeat1",
    "_variable_declaration_repeat1",
    "_switch_body_repeat1",
    "_object_repeat1",
    "_array_repeat1",
    "_string_repeat1",
    "_string_repeat2",
    "_template_string_repeat1",
    "_class_body_repeat1",
    "_formal_parameters_repeat1",
    "_implements_clause_repeat1",
    "_extends_clause_repeat1",
    "_enum_body_repeat1",
    "_object_type_repeat1",
    "_type_parameters_repeat1",
    "array_pattern",
    "export_specifier",
    "import_specifier",
    "object_pattern",
    "property_identifier",
    "shorthand_property_identifier",
    "statement_identifier",
    "type_identifier"
  ]

newtype Declaration a = Declaration {getDeclaration :: ((AbstractClassDeclaration GHC.Generics.:+: AmbientDeclaration GHC.Generics.:+: ClassDeclaration GHC.Generics.:+: EnumDeclaration GHC.Generics.:+: FunctionDeclaration GHC.Generics.:+: FunctionSignature GHC.Generics.:+: GeneratorFunctionDeclaration GHC.Generics.:+: ImportAlias GHC.Generics.:+: InterfaceDeclaration GHC.Generics.:+: InternalModule GHC.Generics.:+: LexicalDeclaration GHC.Generics.:+: Module GHC.Generics.:+: TypeAliasDeclaration GHC.Generics.:+: VariableDeclaration) a)}
  deriving newtype (AST.Unmarshal.SymbolMatching)
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1.
      AST.Traversable1.Class.Traversable1 a_1
    )

instance GHC.Records.HasField "ann" (Declaration a_2) a_2 where
  getField = AST.Unmarshal.gann GHC.Base.. getDeclaration

deriving instance GHC.Classes.Eq a_3 => GHC.Classes.Eq (Declaration a_3)

deriving instance GHC.Classes.Ord a_4 => GHC.Classes.Ord (Declaration a_4)

deriving instance GHC.Show.Show a_5 => GHC.Show.Show (Declaration a_5)

instance AST.Unmarshal.Unmarshal Declaration

instance Data.Foldable.Foldable Declaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Declaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Declaration where
  traverse = AST.Traversable1.Class.traverseDefault1

newtype DestructuringPattern a = DestructuringPattern {getDestructuringPattern :: ((ArrayPattern GHC.Generics.:+: ObjectPattern) a)}
  deriving newtype (AST.Unmarshal.SymbolMatching)
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_6.
      AST.Traversable1.Class.Traversable1 a_6
    )

instance GHC.Records.HasField "ann" (DestructuringPattern a_7) a_7 where
  getField = AST.Unmarshal.gann GHC.Base.. getDestructuringPattern

deriving instance GHC.Classes.Eq a_8 => GHC.Classes.Eq (DestructuringPattern a_8)

deriving instance GHC.Classes.Ord a_9 => GHC.Classes.Ord (DestructuringPattern a_9)

deriving instance GHC.Show.Show a_10 => GHC.Show.Show (DestructuringPattern a_10)

instance AST.Unmarshal.Unmarshal DestructuringPattern

instance Data.Foldable.Foldable DestructuringPattern where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor DestructuringPattern where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable DestructuringPattern where
  traverse = AST.Traversable1.Class.traverseDefault1

newtype Expression a = Expression {getExpression :: ((Array GHC.Generics.:+: ArrowFunction GHC.Generics.:+: AsExpression GHC.Generics.:+: AssignmentExpression GHC.Generics.:+: AugmentedAssignmentExpression GHC.Generics.:+: AwaitExpression GHC.Generics.:+: BinaryExpression GHC.Generics.:+: CallExpression GHC.Generics.:+: Class GHC.Generics.:+: False GHC.Generics.:+: Function GHC.Generics.:+: GeneratorFunction GHC.Generics.:+: Identifier GHC.Generics.:+: Import GHC.Generics.:+: InternalModule GHC.Generics.:+: MemberExpression GHC.Generics.:+: MetaProperty GHC.Generics.:+: NewExpression GHC.Generics.:+: NonNullExpression GHC.Generics.:+: Null GHC.Generics.:+: Number GHC.Generics.:+: Object GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: Regex GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: Super GHC.Generics.:+: TemplateString GHC.Generics.:+: TernaryExpression GHC.Generics.:+: This GHC.Generics.:+: True GHC.Generics.:+: TypeAssertion GHC.Generics.:+: UnaryExpression GHC.Generics.:+: Undefined GHC.Generics.:+: UpdateExpression GHC.Generics.:+: YieldExpression) a)}
  deriving newtype (AST.Unmarshal.SymbolMatching)
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_11.
      AST.Traversable1.Class.Traversable1 a_11
    )

instance GHC.Records.HasField "ann" (Expression a_12) a_12 where
  getField = AST.Unmarshal.gann GHC.Base.. getExpression

deriving instance GHC.Classes.Eq a_13 => GHC.Classes.Eq (Expression a_13)

deriving instance GHC.Classes.Ord a_14 => GHC.Classes.Ord (Expression a_14)

deriving instance GHC.Show.Show a_15 => GHC.Show.Show (Expression a_15)

instance AST.Unmarshal.Unmarshal Expression

instance Data.Foldable.Foldable Expression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Expression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Expression where
  traverse = AST.Traversable1.Class.traverseDefault1

newtype Statement a = Statement {getStatement :: ((Declaration GHC.Generics.:+: BreakStatement GHC.Generics.:+: ContinueStatement GHC.Generics.:+: DebuggerStatement GHC.Generics.:+: DoStatement GHC.Generics.:+: EmptyStatement GHC.Generics.:+: ExportStatement GHC.Generics.:+: ExpressionStatement GHC.Generics.:+: ForInStatement GHC.Generics.:+: ForStatement GHC.Generics.:+: IfStatement GHC.Generics.:+: ImportStatement GHC.Generics.:+: LabeledStatement GHC.Generics.:+: ReturnStatement GHC.Generics.:+: StatementBlock GHC.Generics.:+: SwitchStatement GHC.Generics.:+: ThrowStatement GHC.Generics.:+: TryStatement GHC.Generics.:+: WhileStatement GHC.Generics.:+: WithStatement) a)}
  deriving newtype (AST.Unmarshal.SymbolMatching)
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_16.
      AST.Traversable1.Class.Traversable1 a_16
    )

instance GHC.Records.HasField "ann" (Statement a_17) a_17 where
  getField = AST.Unmarshal.gann GHC.Base.. getStatement

deriving instance GHC.Classes.Eq a_18 => GHC.Classes.Eq (Statement a_18)

deriving instance GHC.Classes.Ord a_19 => GHC.Classes.Ord (Statement a_19)

deriving instance GHC.Show.Show a_20 => GHC.Show.Show (Statement a_20)

instance AST.Unmarshal.Unmarshal Statement

instance Data.Foldable.Foldable Statement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Statement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Statement where
  traverse = AST.Traversable1.Class.traverseDefault1

data AbstractClassDeclaration a = AbstractClassDeclaration
  { ann :: a,
    body :: (AST.Parse.Err (ClassBody a)),
    name :: (AST.Parse.Err (TypeIdentifier a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ClassHeritage a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_21.
      AST.Traversable1.Class.Traversable1 a_21
    )

instance AST.Unmarshal.SymbolMatching AbstractClassDeclaration where
  matchedSymbols _ = [234]
  showFailure _ node_22 =
    "expected "
      GHC.Base.<> ( "abstract_class_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_22 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_22) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_23 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_24 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_25 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_26 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_23
        c1_24 = TreeSitter.Node.nodeStartPoint node_22
      TreeSitter.Node.TSPoint
        r2_25
        c2_26 = TreeSitter.Node.nodeEndPoint node_22

deriving instance GHC.Classes.Eq a_27 => GHC.Classes.Eq (AbstractClassDeclaration a_27)

deriving instance GHC.Classes.Ord a_28 => GHC.Classes.Ord (AbstractClassDeclaration a_28)

deriving instance GHC.Show.Show a_29 => GHC.Show.Show (AbstractClassDeclaration a_29)

instance AST.Unmarshal.Unmarshal AbstractClassDeclaration

instance Data.Foldable.Foldable AbstractClassDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AbstractClassDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AbstractClassDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data AbstractMethodSignature a = AbstractMethodSignature
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    name :: (AST.Parse.Err ((ComputedPropertyName GHC.Generics.:+: Number GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a)),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (AccessibilityModifier a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_30.
      AST.Traversable1.Class.Traversable1 a_30
    )

instance AST.Unmarshal.SymbolMatching AbstractMethodSignature where
  matchedSymbols _ = [227]
  showFailure _ node_31 =
    "expected "
      GHC.Base.<> ( "abstract_method_signature"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_31 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_31) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_32 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_33 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_34 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_35 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_32
        c1_33 = TreeSitter.Node.nodeStartPoint node_31
      TreeSitter.Node.TSPoint
        r2_34
        c2_35 = TreeSitter.Node.nodeEndPoint node_31

deriving instance GHC.Classes.Eq a_36 => GHC.Classes.Eq (AbstractMethodSignature a_36)

deriving instance GHC.Classes.Ord a_37 => GHC.Classes.Ord (AbstractMethodSignature a_37)

deriving instance GHC.Show.Show a_38 => GHC.Show.Show (AbstractMethodSignature a_38)

instance AST.Unmarshal.Unmarshal AbstractMethodSignature

instance Data.Foldable.Foldable AbstractMethodSignature where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AbstractMethodSignature where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AbstractMethodSignature where
  traverse = AST.Traversable1.Class.traverseDefault1

data AccessibilityModifier a = AccessibilityModifier {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_39.
      AST.Traversable1.Class.Traversable1 a_39
    )

instance AST.Unmarshal.SymbolMatching AccessibilityModifier where
  matchedSymbols _ = [246]
  showFailure _ node_40 =
    "expected "
      GHC.Base.<> ( "accessibility_modifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_40 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_40) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_41 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_42 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_43 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_44 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_41
        c1_42 = TreeSitter.Node.nodeStartPoint node_40
      TreeSitter.Node.TSPoint
        r2_43
        c2_44 = TreeSitter.Node.nodeEndPoint node_40

deriving instance GHC.Classes.Eq a_45 => GHC.Classes.Eq (AccessibilityModifier a_45)

deriving instance GHC.Classes.Ord a_46 => GHC.Classes.Ord (AccessibilityModifier a_46)

deriving instance GHC.Show.Show a_47 => GHC.Show.Show (AccessibilityModifier a_47)

instance AST.Unmarshal.Unmarshal AccessibilityModifier

instance Data.Foldable.Foldable AccessibilityModifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AccessibilityModifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AccessibilityModifier where
  traverse = AST.Traversable1.Class.traverseDefault1

data AmbientDeclaration a = AmbientDeclaration
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Declaration GHC.Generics.:+: ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: StatementBlock GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_48.
      AST.Traversable1.Class.Traversable1 a_48
    )

instance AST.Unmarshal.SymbolMatching AmbientDeclaration where
  matchedSymbols _ = [233]
  showFailure _ node_49 =
    "expected "
      GHC.Base.<> ( "ambient_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_49 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_49) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_50 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_51 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_52 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_53 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_50
        c1_51 = TreeSitter.Node.nodeStartPoint node_49
      TreeSitter.Node.TSPoint
        r2_52
        c2_53 = TreeSitter.Node.nodeEndPoint node_49

deriving instance GHC.Classes.Eq a_54 => GHC.Classes.Eq (AmbientDeclaration a_54)

deriving instance GHC.Classes.Ord a_55 => GHC.Classes.Ord (AmbientDeclaration a_55)

deriving instance GHC.Show.Show a_56 => GHC.Show.Show (AmbientDeclaration a_56)

instance AST.Unmarshal.Unmarshal AmbientDeclaration

instance Data.Foldable.Foldable AmbientDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AmbientDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AmbientDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data Arguments a = Arguments
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: SpreadElement) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_57.
      AST.Traversable1.Class.Traversable1 a_57
    )

instance AST.Unmarshal.SymbolMatching Arguments where
  matchedSymbols _ = [213]
  showFailure _ node_58 =
    "expected "
      GHC.Base.<> ( "arguments"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_58 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_58) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_59 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_60 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_61 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_62 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_59
        c1_60 = TreeSitter.Node.nodeStartPoint node_58
      TreeSitter.Node.TSPoint
        r2_61
        c2_62 = TreeSitter.Node.nodeEndPoint node_58

deriving instance GHC.Classes.Eq a_63 => GHC.Classes.Eq (Arguments a_63)

deriving instance GHC.Classes.Ord a_64 => GHC.Classes.Ord (Arguments a_64)

deriving instance GHC.Show.Show a_65 => GHC.Show.Show (Arguments a_65)

instance AST.Unmarshal.Unmarshal Arguments

instance Data.Foldable.Foldable Arguments where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Arguments where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Arguments where
  traverse = AST.Traversable1.Class.traverseDefault1

data Array a = Array
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: SpreadElement) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_66.
      AST.Traversable1.Class.Traversable1 a_66
    )

instance AST.Unmarshal.SymbolMatching Array where
  matchedSymbols _ = [183]
  showFailure _ node_67 =
    "expected "
      GHC.Base.<> ( "array"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_67 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_67) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_68 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_69 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_70 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_71 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_68
        c1_69 = TreeSitter.Node.nodeStartPoint node_67
      TreeSitter.Node.TSPoint
        r2_70
        c2_71 = TreeSitter.Node.nodeEndPoint node_67

deriving instance GHC.Classes.Eq a_72 => GHC.Classes.Eq (Array a_72)

deriving instance GHC.Classes.Ord a_73 => GHC.Classes.Ord (Array a_73)

deriving instance GHC.Show.Show a_74 => GHC.Show.Show (Array a_74)

instance AST.Unmarshal.Unmarshal Array

instance Data.Foldable.Foldable Array where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Array where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Array where
  traverse = AST.Traversable1.Class.traverseDefault1

data ArrayPattern a = ArrayPattern
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((Expression GHC.Generics.:+: SpreadElement) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_75.
      AST.Traversable1.Class.Traversable1 a_75
    )

instance AST.Unmarshal.SymbolMatching ArrayPattern where
  matchedSymbols _ = [299]
  showFailure _ node_76 =
    "expected "
      GHC.Base.<> ( "array_pattern"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_76 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_76) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_77 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_78 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_79 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_80 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_77
        c1_78 = TreeSitter.Node.nodeStartPoint node_76
      TreeSitter.Node.TSPoint
        r2_79
        c2_80 = TreeSitter.Node.nodeEndPoint node_76

deriving instance GHC.Classes.Eq a_81 => GHC.Classes.Eq (ArrayPattern a_81)

deriving instance GHC.Classes.Ord a_82 => GHC.Classes.Ord (ArrayPattern a_82)

deriving instance GHC.Show.Show a_83 => GHC.Show.Show (ArrayPattern a_83)

instance AST.Unmarshal.Unmarshal ArrayPattern

instance Data.Foldable.Foldable ArrayPattern where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ArrayPattern where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ArrayPattern where
  traverse = AST.Traversable1.Class.traverseDefault1

data ArrayType a = ArrayType
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((ArrayType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_84.
      AST.Traversable1.Class.Traversable1 a_84
    )

instance AST.Unmarshal.SymbolMatching ArrayType where
  matchedSymbols _ = [276]
  showFailure _ node_85 =
    "expected "
      GHC.Base.<> ( "array_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_85 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_85) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_86 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_87 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_88 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_89 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_86
        c1_87 = TreeSitter.Node.nodeStartPoint node_85
      TreeSitter.Node.TSPoint
        r2_88
        c2_89 = TreeSitter.Node.nodeEndPoint node_85

deriving instance GHC.Classes.Eq a_90 => GHC.Classes.Eq (ArrayType a_90)

deriving instance GHC.Classes.Ord a_91 => GHC.Classes.Ord (ArrayType a_91)

deriving instance GHC.Show.Show a_92 => GHC.Show.Show (ArrayType a_92)

instance AST.Unmarshal.Unmarshal ArrayType

instance Data.Foldable.Foldable ArrayType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ArrayType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ArrayType where
  traverse = AST.Traversable1.Class.traverseDefault1

data ArrowFunction a = ArrowFunction
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    body :: (AST.Parse.Err ((Expression GHC.Generics.:+: StatementBlock) a)),
    parameters :: (GHC.Maybe.Maybe (AST.Parse.Err (FormalParameters a))),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
    parameter :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_93.
      AST.Traversable1.Class.Traversable1 a_93
    )

instance AST.Unmarshal.SymbolMatching ArrowFunction where
  matchedSymbols _ = [192]
  showFailure _ node_94 =
    "expected "
      GHC.Base.<> ( "arrow_function"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_94 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_94) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_95 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_96 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_97 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_98 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_95
        c1_96 = TreeSitter.Node.nodeStartPoint node_94
      TreeSitter.Node.TSPoint
        r2_97
        c2_98 = TreeSitter.Node.nodeEndPoint node_94

deriving instance GHC.Classes.Eq a_99 => GHC.Classes.Eq (ArrowFunction a_99)

deriving instance GHC.Classes.Ord a_100 => GHC.Classes.Ord (ArrowFunction a_100)

deriving instance GHC.Show.Show a_101 => GHC.Show.Show (ArrowFunction a_101)

instance AST.Unmarshal.Unmarshal ArrowFunction

instance Data.Foldable.Foldable ArrowFunction where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ArrowFunction where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ArrowFunction where
  traverse = AST.Traversable1.Class.traverseDefault1

data AsExpression a = AsExpression
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_102.
      AST.Traversable1.Class.Traversable1 a_102
    )

instance AST.Unmarshal.SymbolMatching AsExpression where
  matchedSymbols _ = [230]
  showFailure _ node_103 =
    "expected "
      GHC.Base.<> ( "as_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_103 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_103) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_104 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_105 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_106 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_107 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_104
        c1_105 = TreeSitter.Node.nodeStartPoint node_103
      TreeSitter.Node.TSPoint
        r2_106
        c2_107 = TreeSitter.Node.nodeEndPoint node_103

deriving instance GHC.Classes.Eq a_108 => GHC.Classes.Eq (AsExpression a_108)

deriving instance GHC.Classes.Ord a_109 => GHC.Classes.Ord (AsExpression a_109)

deriving instance GHC.Show.Show a_110 => GHC.Show.Show (AsExpression a_110)

instance AST.Unmarshal.Unmarshal AsExpression

instance Data.Foldable.Foldable AsExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AsExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AsExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data AssignmentExpression a = AssignmentExpression
  { ann :: a,
    left :: (AST.Parse.Err ((DestructuringPattern GHC.Generics.:+: Identifier GHC.Generics.:+: MemberExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: SubscriptExpression) a)),
    right :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_111.
      AST.Traversable1.Class.Traversable1 a_111
    )

instance AST.Unmarshal.SymbolMatching AssignmentExpression where
  matchedSymbols _ = [199]
  showFailure _ node_112 =
    "expected "
      GHC.Base.<> ( "assignment_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_112 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_112) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_113 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_114 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_115 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_116 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_113
        c1_114 = TreeSitter.Node.nodeStartPoint node_112
      TreeSitter.Node.TSPoint
        r2_115
        c2_116 = TreeSitter.Node.nodeEndPoint node_112

deriving instance GHC.Classes.Eq a_117 => GHC.Classes.Eq (AssignmentExpression a_117)

deriving instance GHC.Classes.Ord a_118 => GHC.Classes.Ord (AssignmentExpression a_118)

deriving instance GHC.Show.Show a_119 => GHC.Show.Show (AssignmentExpression a_119)

instance AST.Unmarshal.Unmarshal AssignmentExpression

instance Data.Foldable.Foldable AssignmentExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AssignmentExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AssignmentExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data AssignmentPattern a = AssignmentPattern
  { ann :: a,
    left :: (AST.Parse.Err ((DestructuringPattern GHC.Generics.:+: ShorthandPropertyIdentifier) a)),
    right :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_120.
      AST.Traversable1.Class.Traversable1 a_120
    )

instance AST.Unmarshal.SymbolMatching AssignmentPattern where
  matchedSymbols _ = [182]
  showFailure _ node_121 =
    "expected "
      GHC.Base.<> ( "assignment_pattern"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_121 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_121) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_122 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_123 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_124 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_125 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_122
        c1_123 = TreeSitter.Node.nodeStartPoint node_121
      TreeSitter.Node.TSPoint
        r2_124
        c2_125 = TreeSitter.Node.nodeEndPoint node_121

deriving instance GHC.Classes.Eq a_126 => GHC.Classes.Eq (AssignmentPattern a_126)

deriving instance GHC.Classes.Ord a_127 => GHC.Classes.Ord (AssignmentPattern a_127)

deriving instance GHC.Show.Show a_128 => GHC.Show.Show (AssignmentPattern a_128)

instance AST.Unmarshal.Unmarshal AssignmentPattern

instance Data.Foldable.Foldable AssignmentPattern where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AssignmentPattern where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AssignmentPattern where
  traverse = AST.Traversable1.Class.traverseDefault1

data AugmentedAssignmentExpression a = AugmentedAssignmentExpression
  { ann :: a,
    left :: (AST.Parse.Err ((Identifier GHC.Generics.:+: MemberExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: SubscriptExpression) a)),
    right :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_129.
      AST.Traversable1.Class.Traversable1 a_129
    )

instance AST.Unmarshal.SymbolMatching AugmentedAssignmentExpression where
  matchedSymbols _ = [200]
  showFailure _ node_130 =
    "expected "
      GHC.Base.<> ( "augmented_assignment_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_130 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_130) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_131 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_132 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_133 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_134 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_131
        c1_132 = TreeSitter.Node.nodeStartPoint node_130
      TreeSitter.Node.TSPoint
        r2_133
        c2_134 = TreeSitter.Node.nodeEndPoint node_130

deriving instance GHC.Classes.Eq a_135 => GHC.Classes.Eq (AugmentedAssignmentExpression a_135)

deriving instance GHC.Classes.Ord a_136 => GHC.Classes.Ord (AugmentedAssignmentExpression a_136)

deriving instance GHC.Show.Show a_137 => GHC.Show.Show (AugmentedAssignmentExpression a_137)

instance AST.Unmarshal.Unmarshal AugmentedAssignmentExpression

instance Data.Foldable.Foldable AugmentedAssignmentExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AugmentedAssignmentExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AugmentedAssignmentExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data AwaitExpression a = AwaitExpression
  { ann :: a,
    extraChildren :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_138.
      AST.Traversable1.Class.Traversable1 a_138
    )

instance AST.Unmarshal.SymbolMatching AwaitExpression where
  matchedSymbols _ = [196]
  showFailure _ node_139 =
    "expected "
      GHC.Base.<> ( "await_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_139 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_139) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_140 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_141 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_142 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_143 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_140
        c1_141 = TreeSitter.Node.nodeStartPoint node_139
      TreeSitter.Node.TSPoint
        r2_142
        c2_143 = TreeSitter.Node.nodeEndPoint node_139

deriving instance GHC.Classes.Eq a_144 => GHC.Classes.Eq (AwaitExpression a_144)

deriving instance GHC.Classes.Ord a_145 => GHC.Classes.Ord (AwaitExpression a_145)

deriving instance GHC.Show.Show a_146 => GHC.Show.Show (AwaitExpression a_146)

instance AST.Unmarshal.Unmarshal AwaitExpression

instance Data.Foldable.Foldable AwaitExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor AwaitExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable AwaitExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data BinaryExpression a = BinaryExpression
  { ann :: a,
    operator :: (AST.Parse.Err ((AnonymousBangEqual GHC.Generics.:+: AnonymousBangEqualEqual GHC.Generics.:+: AnonymousPercent GHC.Generics.:+: AnonymousAmpersand GHC.Generics.:+: AnonymousAmpersandAmpersand GHC.Generics.:+: AnonymousStar GHC.Generics.:+: AnonymousStarStar GHC.Generics.:+: AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousSlash GHC.Generics.:+: AnonymousLAngle GHC.Generics.:+: AnonymousLAngleLAngle GHC.Generics.:+: AnonymousLAngleEqual GHC.Generics.:+: AnonymousEqualEqual GHC.Generics.:+: AnonymousEqualEqualEqual GHC.Generics.:+: AnonymousRAngle GHC.Generics.:+: AnonymousRAngleEqual GHC.Generics.:+: AnonymousRAngleRAngle GHC.Generics.:+: AnonymousRAngleRAngleRAngle GHC.Generics.:+: AnonymousQuestionQuestion GHC.Generics.:+: AnonymousCaret GHC.Generics.:+: AnonymousIn GHC.Generics.:+: AnonymousInstanceof GHC.Generics.:+: AnonymousPipe GHC.Generics.:+: AnonymousPipePipe) a)),
    left :: (AST.Parse.Err (Expression a)),
    right :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_147.
      AST.Traversable1.Class.Traversable1 a_147
    )

instance AST.Unmarshal.SymbolMatching BinaryExpression where
  matchedSymbols _ = [204]
  showFailure _ node_148 =
    "expected "
      GHC.Base.<> ( "binary_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_148 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_148) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_149 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_150 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_151 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_152 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_149
        c1_150 = TreeSitter.Node.nodeStartPoint node_148
      TreeSitter.Node.TSPoint
        r2_151
        c2_152 = TreeSitter.Node.nodeEndPoint node_148

deriving instance GHC.Classes.Eq a_153 => GHC.Classes.Eq (BinaryExpression a_153)

deriving instance GHC.Classes.Ord a_154 => GHC.Classes.Ord (BinaryExpression a_154)

deriving instance GHC.Show.Show a_155 => GHC.Show.Show (BinaryExpression a_155)

instance AST.Unmarshal.Unmarshal BinaryExpression

instance Data.Foldable.Foldable BinaryExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor BinaryExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable BinaryExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data BreakStatement a = BreakStatement
  { ann :: a,
    label :: (GHC.Maybe.Maybe (AST.Parse.Err (StatementIdentifier a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_156.
      AST.Traversable1.Class.Traversable1 a_156
    )

instance AST.Unmarshal.SymbolMatching BreakStatement where
  matchedSymbols _ = [166]
  showFailure _ node_157 =
    "expected "
      GHC.Base.<> ( "break_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_157 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_157) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_158 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_159 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_160 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_161 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_158
        c1_159 = TreeSitter.Node.nodeStartPoint node_157
      TreeSitter.Node.TSPoint
        r2_160
        c2_161 = TreeSitter.Node.nodeEndPoint node_157

deriving instance GHC.Classes.Eq a_162 => GHC.Classes.Eq (BreakStatement a_162)

deriving instance GHC.Classes.Ord a_163 => GHC.Classes.Ord (BreakStatement a_163)

deriving instance GHC.Show.Show a_164 => GHC.Show.Show (BreakStatement a_164)

instance AST.Unmarshal.Unmarshal BreakStatement

instance Data.Foldable.Foldable BreakStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor BreakStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable BreakStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data CallExpression a = CallExpression
  { ann :: a,
    function :: (AST.Parse.Err (Expression a)),
    arguments :: (AST.Parse.Err ((Arguments GHC.Generics.:+: TemplateString) a)),
    typeArguments :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeArguments a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_165.
      AST.Traversable1.Class.Traversable1 a_165
    )

instance AST.Unmarshal.SymbolMatching CallExpression where
  matchedSymbols _ = [194, 216]
  showFailure _ node_166 =
    "expected "
      GHC.Base.<> ( "call_expression, call_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_166 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_166) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_167 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_168 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_169 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_170 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_167
        c1_168 = TreeSitter.Node.nodeStartPoint node_166
      TreeSitter.Node.TSPoint
        r2_169
        c2_170 = TreeSitter.Node.nodeEndPoint node_166

deriving instance GHC.Classes.Eq a_171 => GHC.Classes.Eq (CallExpression a_171)

deriving instance GHC.Classes.Ord a_172 => GHC.Classes.Ord (CallExpression a_172)

deriving instance GHC.Show.Show a_173 => GHC.Show.Show (CallExpression a_173)

instance AST.Unmarshal.Unmarshal CallExpression

instance Data.Foldable.Foldable CallExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor CallExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable CallExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data CallSignature a = CallSignature
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_174.
      AST.Traversable1.Class.Traversable1 a_174
    )

instance AST.Unmarshal.SymbolMatching CallSignature where
  matchedSymbols _ = [268]
  showFailure _ node_175 =
    "expected "
      GHC.Base.<> ( "call_signature"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_175 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_175) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_176 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_177 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_178 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_179 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_176
        c1_177 = TreeSitter.Node.nodeStartPoint node_175
      TreeSitter.Node.TSPoint
        r2_178
        c2_179 = TreeSitter.Node.nodeEndPoint node_175

deriving instance GHC.Classes.Eq a_180 => GHC.Classes.Eq (CallSignature a_180)

deriving instance GHC.Classes.Ord a_181 => GHC.Classes.Ord (CallSignature a_181)

deriving instance GHC.Show.Show a_182 => GHC.Show.Show (CallSignature a_182)

instance AST.Unmarshal.Unmarshal CallSignature

instance Data.Foldable.Foldable CallSignature where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor CallSignature where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable CallSignature where
  traverse = AST.Traversable1.Class.traverseDefault1

data CatchClause a = CatchClause
  { ann :: a,
    body :: (AST.Parse.Err (StatementBlock a)),
    parameter :: (GHC.Maybe.Maybe (AST.Parse.Err ((DestructuringPattern GHC.Generics.:+: Identifier) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_183.
      AST.Traversable1.Class.Traversable1 a_183
    )

instance AST.Unmarshal.SymbolMatching CatchClause where
  matchedSymbols _ = [176]
  showFailure _ node_184 =
    "expected "
      GHC.Base.<> ( "catch_clause"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_184 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_184) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_185 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_186 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_187 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_188 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_185
        c1_186 = TreeSitter.Node.nodeStartPoint node_184
      TreeSitter.Node.TSPoint
        r2_187
        c2_188 = TreeSitter.Node.nodeEndPoint node_184

deriving instance GHC.Classes.Eq a_189 => GHC.Classes.Eq (CatchClause a_189)

deriving instance GHC.Classes.Ord a_190 => GHC.Classes.Ord (CatchClause a_190)

deriving instance GHC.Show.Show a_191 => GHC.Show.Show (CatchClause a_191)

instance AST.Unmarshal.Unmarshal CatchClause

instance Data.Foldable.Foldable CatchClause where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor CatchClause where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable CatchClause where
  traverse = AST.Traversable1.Class.traverseDefault1

data Class a = Class
  { ann :: a,
    decorator :: ([AST.Parse.Err (Decorator a)]),
    body :: (AST.Parse.Err (ClassBody a)),
    name :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeIdentifier a))),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ClassHeritage a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_192.
      AST.Traversable1.Class.Traversable1 a_192
    )

instance AST.Unmarshal.SymbolMatching Class where
  matchedSymbols _ = [185]
  showFailure _ node_193 =
    "expected "
      GHC.Base.<> ( "class"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_193 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_193) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_194 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_195 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_196 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_197 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_194
        c1_195 = TreeSitter.Node.nodeStartPoint node_193
      TreeSitter.Node.TSPoint
        r2_196
        c2_197 = TreeSitter.Node.nodeEndPoint node_193

deriving instance GHC.Classes.Eq a_198 => GHC.Classes.Eq (Class a_198)

deriving instance GHC.Classes.Ord a_199 => GHC.Classes.Ord (Class a_199)

deriving instance GHC.Show.Show a_200 => GHC.Show.Show (Class a_200)

instance AST.Unmarshal.Unmarshal Class

instance Data.Foldable.Foldable Class where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Class where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Class where
  traverse = AST.Traversable1.Class.traverseDefault1

data ClassBody a = ClassBody
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((AbstractMethodSignature GHC.Generics.:+: Decorator GHC.Generics.:+: IndexSignature GHC.Generics.:+: MethodDefinition GHC.Generics.:+: MethodSignature GHC.Generics.:+: PublicFieldDefinition) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_201.
      AST.Traversable1.Class.Traversable1 a_201
    )

instance AST.Unmarshal.SymbolMatching ClassBody where
  matchedSymbols _ = [217]
  showFailure _ node_202 =
    "expected "
      GHC.Base.<> ( "class_body"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_202 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_202) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_203 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_204 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_205 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_206 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_203
        c1_204 = TreeSitter.Node.nodeStartPoint node_202
      TreeSitter.Node.TSPoint
        r2_205
        c2_206 = TreeSitter.Node.nodeEndPoint node_202

deriving instance GHC.Classes.Eq a_207 => GHC.Classes.Eq (ClassBody a_207)

deriving instance GHC.Classes.Ord a_208 => GHC.Classes.Ord (ClassBody a_208)

deriving instance GHC.Show.Show a_209 => GHC.Show.Show (ClassBody a_209)

instance AST.Unmarshal.Unmarshal ClassBody

instance Data.Foldable.Foldable ClassBody where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ClassBody where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ClassBody where
  traverse = AST.Traversable1.Class.traverseDefault1

data ClassDeclaration a = ClassDeclaration
  { ann :: a,
    decorator :: ([AST.Parse.Err (Decorator a)]),
    body :: (AST.Parse.Err (ClassBody a)),
    name :: (AST.Parse.Err (TypeIdentifier a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ClassHeritage a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_210.
      AST.Traversable1.Class.Traversable1 a_210
    )

instance AST.Unmarshal.SymbolMatching ClassDeclaration where
  matchedSymbols _ = [186]
  showFailure _ node_211 =
    "expected "
      GHC.Base.<> ( "class_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_211 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_211) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_212 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_213 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_214 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_215 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_212
        c1_213 = TreeSitter.Node.nodeStartPoint node_211
      TreeSitter.Node.TSPoint
        r2_214
        c2_215 = TreeSitter.Node.nodeEndPoint node_211

deriving instance GHC.Classes.Eq a_216 => GHC.Classes.Eq (ClassDeclaration a_216)

deriving instance GHC.Classes.Ord a_217 => GHC.Classes.Ord (ClassDeclaration a_217)

deriving instance GHC.Show.Show a_218 => GHC.Show.Show (ClassDeclaration a_218)

instance AST.Unmarshal.Unmarshal ClassDeclaration

instance Data.Foldable.Foldable ClassDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ClassDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ClassDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data ClassHeritage a = ClassHeritage
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ExtendsClause GHC.Generics.:+: ImplementsClause) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_219.
      AST.Traversable1.Class.Traversable1 a_219
    )

instance AST.Unmarshal.SymbolMatching ClassHeritage where
  matchedSymbols _ = [187]
  showFailure _ node_220 =
    "expected "
      GHC.Base.<> ( "class_heritage"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_220 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_220) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_221 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_222 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_223 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_224 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_221
        c1_222 = TreeSitter.Node.nodeStartPoint node_220
      TreeSitter.Node.TSPoint
        r2_223
        c2_224 = TreeSitter.Node.nodeEndPoint node_220

deriving instance GHC.Classes.Eq a_225 => GHC.Classes.Eq (ClassHeritage a_225)

deriving instance GHC.Classes.Ord a_226 => GHC.Classes.Ord (ClassHeritage a_226)

deriving instance GHC.Show.Show a_227 => GHC.Show.Show (ClassHeritage a_227)

instance AST.Unmarshal.Unmarshal ClassHeritage

instance Data.Foldable.Foldable ClassHeritage where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ClassHeritage where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ClassHeritage where
  traverse = AST.Traversable1.Class.traverseDefault1

data ComputedPropertyName a = ComputedPropertyName
  { ann :: a,
    extraChildren :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_228.
      AST.Traversable1.Class.Traversable1 a_228
    )

instance AST.Unmarshal.SymbolMatching ComputedPropertyName where
  matchedSymbols _ = [224]
  showFailure _ node_229 =
    "expected "
      GHC.Base.<> ( "computed_property_name"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_229 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_229) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_230 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_231 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_232 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_233 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_230
        c1_231 = TreeSitter.Node.nodeStartPoint node_229
      TreeSitter.Node.TSPoint
        r2_232
        c2_233 = TreeSitter.Node.nodeEndPoint node_229

deriving instance GHC.Classes.Eq a_234 => GHC.Classes.Eq (ComputedPropertyName a_234)

deriving instance GHC.Classes.Ord a_235 => GHC.Classes.Ord (ComputedPropertyName a_235)

deriving instance GHC.Show.Show a_236 => GHC.Show.Show (ComputedPropertyName a_236)

instance AST.Unmarshal.Unmarshal ComputedPropertyName

instance Data.Foldable.Foldable ComputedPropertyName where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ComputedPropertyName where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ComputedPropertyName where
  traverse = AST.Traversable1.Class.traverseDefault1

data Constraint a = Constraint
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_237.
      AST.Traversable1.Class.Traversable1 a_237
    )

instance AST.Unmarshal.SymbolMatching Constraint where
  matchedSymbols _ = [273]
  showFailure _ node_238 =
    "expected "
      GHC.Base.<> ( "constraint"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_238 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_238) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_239 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_240 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_241 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_242 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_239
        c1_240 = TreeSitter.Node.nodeStartPoint node_238
      TreeSitter.Node.TSPoint
        r2_241
        c2_242 = TreeSitter.Node.nodeEndPoint node_238

deriving instance GHC.Classes.Eq a_243 => GHC.Classes.Eq (Constraint a_243)

deriving instance GHC.Classes.Ord a_244 => GHC.Classes.Ord (Constraint a_244)

deriving instance GHC.Show.Show a_245 => GHC.Show.Show (Constraint a_245)

instance AST.Unmarshal.Unmarshal Constraint

instance Data.Foldable.Foldable Constraint where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Constraint where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Constraint where
  traverse = AST.Traversable1.Class.traverseDefault1

data ConstructSignature a = ConstructSignature
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((FormalParameters GHC.Generics.:+: TypeAnnotation GHC.Generics.:+: TypeParameters) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_246.
      AST.Traversable1.Class.Traversable1 a_246
    )

instance AST.Unmarshal.SymbolMatching ConstructSignature where
  matchedSymbols _ = [274]
  showFailure _ node_247 =
    "expected "
      GHC.Base.<> ( "construct_signature"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_247 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_247) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_248 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_249 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_250 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_251 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_248
        c1_249 = TreeSitter.Node.nodeStartPoint node_247
      TreeSitter.Node.TSPoint
        r2_250
        c2_251 = TreeSitter.Node.nodeEndPoint node_247

deriving instance GHC.Classes.Eq a_252 => GHC.Classes.Eq (ConstructSignature a_252)

deriving instance GHC.Classes.Ord a_253 => GHC.Classes.Ord (ConstructSignature a_253)

deriving instance GHC.Show.Show a_254 => GHC.Show.Show (ConstructSignature a_254)

instance AST.Unmarshal.Unmarshal ConstructSignature

instance Data.Foldable.Foldable ConstructSignature where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ConstructSignature where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ConstructSignature where
  traverse = AST.Traversable1.Class.traverseDefault1

data ConstructorType a = ConstructorType
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FormalParameters GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypeParameters GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_255.
      AST.Traversable1.Class.Traversable1 a_255
    )

instance AST.Unmarshal.SymbolMatching ConstructorType where
  matchedSymbols _ = [252]
  showFailure _ node_256 =
    "expected "
      GHC.Base.<> ( "constructor_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_256 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_256) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_257 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_258 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_259 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_260 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_257
        c1_258 = TreeSitter.Node.nodeStartPoint node_256
      TreeSitter.Node.TSPoint
        r2_259
        c2_260 = TreeSitter.Node.nodeEndPoint node_256

deriving instance GHC.Classes.Eq a_261 => GHC.Classes.Eq (ConstructorType a_261)

deriving instance GHC.Classes.Ord a_262 => GHC.Classes.Ord (ConstructorType a_262)

deriving instance GHC.Show.Show a_263 => GHC.Show.Show (ConstructorType a_263)

instance AST.Unmarshal.Unmarshal ConstructorType

instance Data.Foldable.Foldable ConstructorType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ConstructorType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ConstructorType where
  traverse = AST.Traversable1.Class.traverseDefault1

data ContinueStatement a = ContinueStatement
  { ann :: a,
    label :: (GHC.Maybe.Maybe (AST.Parse.Err (StatementIdentifier a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_264.
      AST.Traversable1.Class.Traversable1 a_264
    )

instance AST.Unmarshal.SymbolMatching ContinueStatement where
  matchedSymbols _ = [167]
  showFailure _ node_265 =
    "expected "
      GHC.Base.<> ( "continue_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_265 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_265) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_266 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_267 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_268 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_269 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_266
        c1_267 = TreeSitter.Node.nodeStartPoint node_265
      TreeSitter.Node.TSPoint
        r2_268
        c2_269 = TreeSitter.Node.nodeEndPoint node_265

deriving instance GHC.Classes.Eq a_270 => GHC.Classes.Eq (ContinueStatement a_270)

deriving instance GHC.Classes.Ord a_271 => GHC.Classes.Ord (ContinueStatement a_271)

deriving instance GHC.Show.Show a_272 => GHC.Show.Show (ContinueStatement a_272)

instance AST.Unmarshal.Unmarshal ContinueStatement

instance Data.Foldable.Foldable ContinueStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ContinueStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ContinueStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data DebuggerStatement a = DebuggerStatement {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_273.
      AST.Traversable1.Class.Traversable1 a_273
    )

instance AST.Unmarshal.SymbolMatching DebuggerStatement where
  matchedSymbols _ = [168]
  showFailure _ node_274 =
    "expected "
      GHC.Base.<> ( "debugger_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_274 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_274) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_275 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_276 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_277 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_278 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_275
        c1_276 = TreeSitter.Node.nodeStartPoint node_274
      TreeSitter.Node.TSPoint
        r2_277
        c2_278 = TreeSitter.Node.nodeEndPoint node_274

deriving instance GHC.Classes.Eq a_279 => GHC.Classes.Eq (DebuggerStatement a_279)

deriving instance GHC.Classes.Ord a_280 => GHC.Classes.Ord (DebuggerStatement a_280)

deriving instance GHC.Show.Show a_281 => GHC.Show.Show (DebuggerStatement a_281)

instance AST.Unmarshal.Unmarshal DebuggerStatement

instance Data.Foldable.Foldable DebuggerStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor DebuggerStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable DebuggerStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data Decorator a = Decorator
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((CallExpression GHC.Generics.:+: Identifier GHC.Generics.:+: MemberExpression) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_282.
      AST.Traversable1.Class.Traversable1 a_282
    )

instance AST.Unmarshal.SymbolMatching Decorator where
  matchedSymbols _ = [214]
  showFailure _ node_283 =
    "expected "
      GHC.Base.<> ( "decorator"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_283 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_283) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_284 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_285 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_286 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_287 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_284
        c1_285 = TreeSitter.Node.nodeStartPoint node_283
      TreeSitter.Node.TSPoint
        r2_286
        c2_287 = TreeSitter.Node.nodeEndPoint node_283

deriving instance GHC.Classes.Eq a_288 => GHC.Classes.Eq (Decorator a_288)

deriving instance GHC.Classes.Ord a_289 => GHC.Classes.Ord (Decorator a_289)

deriving instance GHC.Show.Show a_290 => GHC.Show.Show (Decorator a_290)

instance AST.Unmarshal.Unmarshal Decorator

instance Data.Foldable.Foldable Decorator where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Decorator where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Decorator where
  traverse = AST.Traversable1.Class.traverseDefault1

data DefaultType a = DefaultType
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_291.
      AST.Traversable1.Class.Traversable1 a_291
    )

instance AST.Unmarshal.SymbolMatching DefaultType where
  matchedSymbols _ = [272]
  showFailure _ node_292 =
    "expected "
      GHC.Base.<> ( "default_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_292 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_292) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_293 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_294 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_295 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_296 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_293
        c1_294 = TreeSitter.Node.nodeStartPoint node_292
      TreeSitter.Node.TSPoint
        r2_295
        c2_296 = TreeSitter.Node.nodeEndPoint node_292

deriving instance GHC.Classes.Eq a_297 => GHC.Classes.Eq (DefaultType a_297)

deriving instance GHC.Classes.Ord a_298 => GHC.Classes.Ord (DefaultType a_298)

deriving instance GHC.Show.Show a_299 => GHC.Show.Show (DefaultType a_299)

instance AST.Unmarshal.Unmarshal DefaultType

instance Data.Foldable.Foldable DefaultType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor DefaultType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable DefaultType where
  traverse = AST.Traversable1.Class.traverseDefault1

data DoStatement a = DoStatement
  { ann :: a,
    body :: (AST.Parse.Err (Statement a)),
    condition :: (AST.Parse.Err (ParenthesizedExpression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_300.
      AST.Traversable1.Class.Traversable1 a_300
    )

instance AST.Unmarshal.SymbolMatching DoStatement where
  matchedSymbols _ = [163]
  showFailure _ node_301 =
    "expected "
      GHC.Base.<> ( "do_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_301 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_301) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_302 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_303 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_304 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_305 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_302
        c1_303 = TreeSitter.Node.nodeStartPoint node_301
      TreeSitter.Node.TSPoint
        r2_304
        c2_305 = TreeSitter.Node.nodeEndPoint node_301

deriving instance GHC.Classes.Eq a_306 => GHC.Classes.Eq (DoStatement a_306)

deriving instance GHC.Classes.Ord a_307 => GHC.Classes.Ord (DoStatement a_307)

deriving instance GHC.Show.Show a_308 => GHC.Show.Show (DoStatement a_308)

instance AST.Unmarshal.Unmarshal DoStatement

instance Data.Foldable.Foldable DoStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor DoStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable DoStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data EmptyStatement a = EmptyStatement {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_309.
      AST.Traversable1.Class.Traversable1 a_309
    )

instance AST.Unmarshal.SymbolMatching EmptyStatement where
  matchedSymbols _ = [171]
  showFailure _ node_310 =
    "expected "
      GHC.Base.<> ( "empty_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_310 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_310) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_311 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_312 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_313 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_314 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_311
        c1_312 = TreeSitter.Node.nodeStartPoint node_310
      TreeSitter.Node.TSPoint
        r2_313
        c2_314 = TreeSitter.Node.nodeEndPoint node_310

deriving instance GHC.Classes.Eq a_315 => GHC.Classes.Eq (EmptyStatement a_315)

deriving instance GHC.Classes.Ord a_316 => GHC.Classes.Ord (EmptyStatement a_316)

deriving instance GHC.Show.Show a_317 => GHC.Show.Show (EmptyStatement a_317)

instance AST.Unmarshal.Unmarshal EmptyStatement

instance Data.Foldable.Foldable EmptyStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor EmptyStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable EmptyStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data EnumAssignment a = EnumAssignment
  { ann :: a,
    value :: (AST.Parse.Err (Expression a)),
    extraChildren :: (AST.Parse.Err ((ComputedPropertyName GHC.Generics.:+: Number GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_318.
      AST.Traversable1.Class.Traversable1 a_318
    )

instance AST.Unmarshal.SymbolMatching EnumAssignment where
  matchedSymbols _ = [244]
  showFailure _ node_319 =
    "expected "
      GHC.Base.<> ( "enum_assignment"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_319 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_319) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_320 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_321 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_322 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_323 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_320
        c1_321 = TreeSitter.Node.nodeStartPoint node_319
      TreeSitter.Node.TSPoint
        r2_322
        c2_323 = TreeSitter.Node.nodeEndPoint node_319

deriving instance GHC.Classes.Eq a_324 => GHC.Classes.Eq (EnumAssignment a_324)

deriving instance GHC.Classes.Ord a_325 => GHC.Classes.Ord (EnumAssignment a_325)

deriving instance GHC.Show.Show a_326 => GHC.Show.Show (EnumAssignment a_326)

instance AST.Unmarshal.Unmarshal EnumAssignment

instance Data.Foldable.Foldable EnumAssignment where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor EnumAssignment where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable EnumAssignment where
  traverse = AST.Traversable1.Class.traverseDefault1

data EnumBody a = EnumBody
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((ComputedPropertyName GHC.Generics.:+: EnumAssignment GHC.Generics.:+: Number GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_327.
      AST.Traversable1.Class.Traversable1 a_327
    )

instance AST.Unmarshal.SymbolMatching EnumBody where
  matchedSymbols _ = [243]
  showFailure _ node_328 =
    "expected "
      GHC.Base.<> ( "enum_body"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_328 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_328) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_329 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_330 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_331 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_332 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_329
        c1_330 = TreeSitter.Node.nodeStartPoint node_328
      TreeSitter.Node.TSPoint
        r2_331
        c2_332 = TreeSitter.Node.nodeEndPoint node_328

deriving instance GHC.Classes.Eq a_333 => GHC.Classes.Eq (EnumBody a_333)

deriving instance GHC.Classes.Ord a_334 => GHC.Classes.Ord (EnumBody a_334)

deriving instance GHC.Show.Show a_335 => GHC.Show.Show (EnumBody a_335)

instance AST.Unmarshal.Unmarshal EnumBody

instance Data.Foldable.Foldable EnumBody where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor EnumBody where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable EnumBody where
  traverse = AST.Traversable1.Class.traverseDefault1

data EnumDeclaration a = EnumDeclaration
  { ann :: a,
    body :: (AST.Parse.Err (EnumBody a)),
    name :: (AST.Parse.Err (Identifier a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_336.
      AST.Traversable1.Class.Traversable1 a_336
    )

instance AST.Unmarshal.SymbolMatching EnumDeclaration where
  matchedSymbols _ = [242]
  showFailure _ node_337 =
    "expected "
      GHC.Base.<> ( "enum_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_337 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_337) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_338 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_339 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_340 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_341 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_338
        c1_339 = TreeSitter.Node.nodeStartPoint node_337
      TreeSitter.Node.TSPoint
        r2_340
        c2_341 = TreeSitter.Node.nodeEndPoint node_337

deriving instance GHC.Classes.Eq a_342 => GHC.Classes.Eq (EnumDeclaration a_342)

deriving instance GHC.Classes.Ord a_343 => GHC.Classes.Ord (EnumDeclaration a_343)

deriving instance GHC.Show.Show a_344 => GHC.Show.Show (EnumDeclaration a_344)

instance AST.Unmarshal.Unmarshal EnumDeclaration

instance Data.Foldable.Foldable EnumDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor EnumDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable EnumDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data ExistentialType a = ExistentialType {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_345.
      AST.Traversable1.Class.Traversable1 a_345
    )

instance AST.Unmarshal.SymbolMatching ExistentialType where
  matchedSymbols _ = [262]
  showFailure _ node_346 =
    "expected "
      GHC.Base.<> ( "existential_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_346 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_346) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_347 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_348 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_349 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_350 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_347
        c1_348 = TreeSitter.Node.nodeStartPoint node_346
      TreeSitter.Node.TSPoint
        r2_349
        c2_350 = TreeSitter.Node.nodeEndPoint node_346

deriving instance GHC.Classes.Eq a_351 => GHC.Classes.Eq (ExistentialType a_351)

deriving instance GHC.Classes.Ord a_352 => GHC.Classes.Ord (ExistentialType a_352)

deriving instance GHC.Show.Show a_353 => GHC.Show.Show (ExistentialType a_353)

instance AST.Unmarshal.Unmarshal ExistentialType

instance Data.Foldable.Foldable ExistentialType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ExistentialType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ExistentialType where
  traverse = AST.Traversable1.Class.traverseDefault1

data ExportClause a = ExportClause
  { ann :: a,
    extraChildren :: ([AST.Parse.Err (ExportSpecifier a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_354.
      AST.Traversable1.Class.Traversable1 a_354
    )

instance AST.Unmarshal.SymbolMatching ExportClause where
  matchedSymbols _ = [143]
  showFailure _ node_355 =
    "expected "
      GHC.Base.<> ( "export_clause"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_355 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_355) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_356 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_357 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_358 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_359 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_356
        c1_357 = TreeSitter.Node.nodeStartPoint node_355
      TreeSitter.Node.TSPoint
        r2_358
        c2_359 = TreeSitter.Node.nodeEndPoint node_355

deriving instance GHC.Classes.Eq a_360 => GHC.Classes.Eq (ExportClause a_360)

deriving instance GHC.Classes.Ord a_361 => GHC.Classes.Ord (ExportClause a_361)

deriving instance GHC.Show.Show a_362 => GHC.Show.Show (ExportClause a_362)

instance AST.Unmarshal.Unmarshal ExportClause

instance Data.Foldable.Foldable ExportClause where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ExportClause where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ExportClause where
  traverse = AST.Traversable1.Class.traverseDefault1

data ExportSpecifier a = ExportSpecifier
  { ann :: a,
    alias :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a))),
    name :: (AST.Parse.Err (Identifier a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_363.
      AST.Traversable1.Class.Traversable1 a_363
    )

instance AST.Unmarshal.SymbolMatching ExportSpecifier where
  matchedSymbols _ = [300]
  showFailure _ node_364 =
    "expected "
      GHC.Base.<> ( "export_specifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_364 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_364) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_365 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_366 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_367 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_368 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_365
        c1_366 = TreeSitter.Node.nodeStartPoint node_364
      TreeSitter.Node.TSPoint
        r2_367
        c2_368 = TreeSitter.Node.nodeEndPoint node_364

deriving instance GHC.Classes.Eq a_369 => GHC.Classes.Eq (ExportSpecifier a_369)

deriving instance GHC.Classes.Ord a_370 => GHC.Classes.Ord (ExportSpecifier a_370)

deriving instance GHC.Show.Show a_371 => GHC.Show.Show (ExportSpecifier a_371)

instance AST.Unmarshal.Unmarshal ExportSpecifier

instance Data.Foldable.Foldable ExportSpecifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ExportSpecifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ExportSpecifier where
  traverse = AST.Traversable1.Class.traverseDefault1

data ExportStatement a = ExportStatement
  { ann :: a,
    decorator :: ([AST.Parse.Err (Decorator a)]),
    declaration :: (GHC.Maybe.Maybe (AST.Parse.Err (Declaration a))),
    value :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
    source :: (GHC.Maybe.Maybe (AST.Parse.Err (String a))),
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err ((ExportClause GHC.Generics.:+: Identifier) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_372.
      AST.Traversable1.Class.Traversable1 a_372
    )

instance AST.Unmarshal.SymbolMatching ExportStatement where
  matchedSymbols _ = [142]
  showFailure _ node_373 =
    "expected "
      GHC.Base.<> ( "export_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_373 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_373) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_374 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_375 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_376 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_377 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_374
        c1_375 = TreeSitter.Node.nodeStartPoint node_373
      TreeSitter.Node.TSPoint
        r2_376
        c2_377 = TreeSitter.Node.nodeEndPoint node_373

deriving instance GHC.Classes.Eq a_378 => GHC.Classes.Eq (ExportStatement a_378)

deriving instance GHC.Classes.Ord a_379 => GHC.Classes.Ord (ExportStatement a_379)

deriving instance GHC.Show.Show a_380 => GHC.Show.Show (ExportStatement a_380)

instance AST.Unmarshal.Unmarshal ExportStatement

instance Data.Foldable.Foldable ExportStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ExportStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ExportStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data ExpressionStatement a = ExpressionStatement
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_381.
      AST.Traversable1.Class.Traversable1 a_381
    )

instance AST.Unmarshal.SymbolMatching ExpressionStatement where
  matchedSymbols _ = [152]
  showFailure _ node_382 =
    "expected "
      GHC.Base.<> ( "expression_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_382 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_382) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_383 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_384 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_385 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_386 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_383
        c1_384 = TreeSitter.Node.nodeStartPoint node_382
      TreeSitter.Node.TSPoint
        r2_385
        c2_386 = TreeSitter.Node.nodeEndPoint node_382

deriving instance GHC.Classes.Eq a_387 => GHC.Classes.Eq (ExpressionStatement a_387)

deriving instance GHC.Classes.Ord a_388 => GHC.Classes.Ord (ExpressionStatement a_388)

deriving instance GHC.Show.Show a_389 => GHC.Show.Show (ExpressionStatement a_389)

instance AST.Unmarshal.Unmarshal ExpressionStatement

instance Data.Foldable.Foldable ExpressionStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ExpressionStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ExpressionStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data ExtendsClause a = ExtendsClause
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: GenericType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: TypeIdentifier) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_390.
      AST.Traversable1.Class.Traversable1 a_390
    )

instance AST.Unmarshal.SymbolMatching ExtendsClause where
  matchedSymbols _ = [241]
  showFailure _ node_391 =
    "expected "
      GHC.Base.<> ( "extends_clause"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_391 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_391) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_392 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_393 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_394 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_395 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_392
        c1_393 = TreeSitter.Node.nodeStartPoint node_391
      TreeSitter.Node.TSPoint
        r2_394
        c2_395 = TreeSitter.Node.nodeEndPoint node_391

deriving instance GHC.Classes.Eq a_396 => GHC.Classes.Eq (ExtendsClause a_396)

deriving instance GHC.Classes.Ord a_397 => GHC.Classes.Ord (ExtendsClause a_397)

deriving instance GHC.Show.Show a_398 => GHC.Show.Show (ExtendsClause a_398)

instance AST.Unmarshal.Unmarshal ExtendsClause

instance Data.Foldable.Foldable ExtendsClause where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ExtendsClause where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ExtendsClause where
  traverse = AST.Traversable1.Class.traverseDefault1

data FinallyClause a = FinallyClause
  { ann :: a,
    body :: (AST.Parse.Err (StatementBlock a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_399.
      AST.Traversable1.Class.Traversable1 a_399
    )

instance AST.Unmarshal.SymbolMatching FinallyClause where
  matchedSymbols _ = [177]
  showFailure _ node_400 =
    "expected "
      GHC.Base.<> ( "finally_clause"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_400 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_400) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_401 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_402 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_403 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_404 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_401
        c1_402 = TreeSitter.Node.nodeStartPoint node_400
      TreeSitter.Node.TSPoint
        r2_403
        c2_404 = TreeSitter.Node.nodeEndPoint node_400

deriving instance GHC.Classes.Eq a_405 => GHC.Classes.Eq (FinallyClause a_405)

deriving instance GHC.Classes.Ord a_406 => GHC.Classes.Ord (FinallyClause a_406)

deriving instance GHC.Show.Show a_407 => GHC.Show.Show (FinallyClause a_407)

instance AST.Unmarshal.Unmarshal FinallyClause

instance Data.Foldable.Foldable FinallyClause where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor FinallyClause where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable FinallyClause where
  traverse = AST.Traversable1.Class.traverseDefault1

data FlowMaybeType a = FlowMaybeType
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((ArrayType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_408.
      AST.Traversable1.Class.Traversable1 a_408
    )

instance AST.Unmarshal.SymbolMatching FlowMaybeType where
  matchedSymbols _ = [263]
  showFailure _ node_409 =
    "expected "
      GHC.Base.<> ( "flow_maybe_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_409 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_409) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_410 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_411 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_412 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_413 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_410
        c1_411 = TreeSitter.Node.nodeStartPoint node_409
      TreeSitter.Node.TSPoint
        r2_412
        c2_413 = TreeSitter.Node.nodeEndPoint node_409

deriving instance GHC.Classes.Eq a_414 => GHC.Classes.Eq (FlowMaybeType a_414)

deriving instance GHC.Classes.Ord a_415 => GHC.Classes.Ord (FlowMaybeType a_415)

deriving instance GHC.Show.Show a_416 => GHC.Show.Show (FlowMaybeType a_416)

instance AST.Unmarshal.Unmarshal FlowMaybeType

instance Data.Foldable.Foldable FlowMaybeType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor FlowMaybeType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable FlowMaybeType where
  traverse = AST.Traversable1.Class.traverseDefault1

data ForInStatement a = ForInStatement
  { ann :: a,
    body :: (AST.Parse.Err (Statement a)),
    left :: (AST.Parse.Err ((DestructuringPattern GHC.Generics.:+: Identifier GHC.Generics.:+: MemberExpression GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: SubscriptExpression) a)),
    right :: (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_417.
      AST.Traversable1.Class.Traversable1 a_417
    )

instance AST.Unmarshal.SymbolMatching ForInStatement where
  matchedSymbols _ = [160]
  showFailure _ node_418 =
    "expected "
      GHC.Base.<> ( "for_in_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_418 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_418) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_419 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_420 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_421 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_422 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_419
        c1_420 = TreeSitter.Node.nodeStartPoint node_418
      TreeSitter.Node.TSPoint
        r2_421
        c2_422 = TreeSitter.Node.nodeEndPoint node_418

deriving instance GHC.Classes.Eq a_423 => GHC.Classes.Eq (ForInStatement a_423)

deriving instance GHC.Classes.Ord a_424 => GHC.Classes.Ord (ForInStatement a_424)

deriving instance GHC.Show.Show a_425 => GHC.Show.Show (ForInStatement a_425)

instance AST.Unmarshal.Unmarshal ForInStatement

instance Data.Foldable.Foldable ForInStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ForInStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ForInStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data ForStatement a = ForStatement
  { ann :: a,
    body :: (AST.Parse.Err (Statement a)),
    initializer :: (AST.Parse.Err ((EmptyStatement GHC.Generics.:+: ExpressionStatement GHC.Generics.:+: LexicalDeclaration GHC.Generics.:+: VariableDeclaration) a)),
    condition :: (AST.Parse.Err ((EmptyStatement GHC.Generics.:+: ExpressionStatement) a)),
    increment :: (GHC.Maybe.Maybe (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_426.
      AST.Traversable1.Class.Traversable1 a_426
    )

instance AST.Unmarshal.SymbolMatching ForStatement where
  matchedSymbols _ = [159]
  showFailure _ node_427 =
    "expected "
      GHC.Base.<> ( "for_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_427 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_427) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_428 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_429 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_430 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_431 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_428
        c1_429 = TreeSitter.Node.nodeStartPoint node_427
      TreeSitter.Node.TSPoint
        r2_430
        c2_431 = TreeSitter.Node.nodeEndPoint node_427

deriving instance GHC.Classes.Eq a_432 => GHC.Classes.Eq (ForStatement a_432)

deriving instance GHC.Classes.Ord a_433 => GHC.Classes.Ord (ForStatement a_433)

deriving instance GHC.Show.Show a_434 => GHC.Show.Show (ForStatement a_434)

instance AST.Unmarshal.Unmarshal ForStatement

instance Data.Foldable.Foldable ForStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ForStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ForStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data FormalParameters a = FormalParameters
  { ann :: a,
    decorator :: ([AST.Parse.Err (Decorator a)]),
    extraChildren :: ([AST.Parse.Err ((OptionalParameter GHC.Generics.:+: RequiredParameter GHC.Generics.:+: RestParameter) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_435.
      AST.Traversable1.Class.Traversable1 a_435
    )

instance AST.Unmarshal.SymbolMatching FormalParameters where
  matchedSymbols _ = [219]
  showFailure _ node_436 =
    "expected "
      GHC.Base.<> ( "formal_parameters"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_436 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_436) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_437 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_438 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_439 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_440 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_437
        c1_438 = TreeSitter.Node.nodeStartPoint node_436
      TreeSitter.Node.TSPoint
        r2_439
        c2_440 = TreeSitter.Node.nodeEndPoint node_436

deriving instance GHC.Classes.Eq a_441 => GHC.Classes.Eq (FormalParameters a_441)

deriving instance GHC.Classes.Ord a_442 => GHC.Classes.Ord (FormalParameters a_442)

deriving instance GHC.Show.Show a_443 => GHC.Show.Show (FormalParameters a_443)

instance AST.Unmarshal.Unmarshal FormalParameters

instance Data.Foldable.Foldable FormalParameters where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor FormalParameters where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable FormalParameters where
  traverse = AST.Traversable1.Class.traverseDefault1

data Function a = Function
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    body :: (AST.Parse.Err (StatementBlock a)),
    name :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a))),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_444.
      AST.Traversable1.Class.Traversable1 a_444
    )

instance AST.Unmarshal.SymbolMatching Function where
  matchedSymbols _ = [188]
  showFailure _ node_445 =
    "expected "
      GHC.Base.<> ( "function"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_445 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_445) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_446 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_447 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_448 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_449 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_446
        c1_447 = TreeSitter.Node.nodeStartPoint node_445
      TreeSitter.Node.TSPoint
        r2_448
        c2_449 = TreeSitter.Node.nodeEndPoint node_445

deriving instance GHC.Classes.Eq a_450 => GHC.Classes.Eq (Function a_450)

deriving instance GHC.Classes.Ord a_451 => GHC.Classes.Ord (Function a_451)

deriving instance GHC.Show.Show a_452 => GHC.Show.Show (Function a_452)

instance AST.Unmarshal.Unmarshal Function

instance Data.Foldable.Foldable Function where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Function where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Function where
  traverse = AST.Traversable1.Class.traverseDefault1

data FunctionDeclaration a = FunctionDeclaration
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    body :: (AST.Parse.Err (StatementBlock a)),
    name :: (AST.Parse.Err (Identifier a)),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_453.
      AST.Traversable1.Class.Traversable1 a_453
    )

instance AST.Unmarshal.SymbolMatching FunctionDeclaration where
  matchedSymbols _ = [189]
  showFailure _ node_454 =
    "expected "
      GHC.Base.<> ( "function_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_454 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_454) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_455 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_456 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_457 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_458 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_455
        c1_456 = TreeSitter.Node.nodeStartPoint node_454
      TreeSitter.Node.TSPoint
        r2_457
        c2_458 = TreeSitter.Node.nodeEndPoint node_454

deriving instance GHC.Classes.Eq a_459 => GHC.Classes.Eq (FunctionDeclaration a_459)

deriving instance GHC.Classes.Ord a_460 => GHC.Classes.Ord (FunctionDeclaration a_460)

deriving instance GHC.Show.Show a_461 => GHC.Show.Show (FunctionDeclaration a_461)

instance AST.Unmarshal.Unmarshal FunctionDeclaration

instance Data.Foldable.Foldable FunctionDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor FunctionDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable FunctionDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data FunctionSignature a = FunctionSignature
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    name :: (AST.Parse.Err (Identifier a)),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_462.
      AST.Traversable1.Class.Traversable1 a_462
    )

instance AST.Unmarshal.SymbolMatching FunctionSignature where
  matchedSymbols _ = [228]
  showFailure _ node_463 =
    "expected "
      GHC.Base.<> ( "function_signature"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_463 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_463) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_464 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_465 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_466 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_467 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_464
        c1_465 = TreeSitter.Node.nodeStartPoint node_463
      TreeSitter.Node.TSPoint
        r2_466
        c2_467 = TreeSitter.Node.nodeEndPoint node_463

deriving instance GHC.Classes.Eq a_468 => GHC.Classes.Eq (FunctionSignature a_468)

deriving instance GHC.Classes.Ord a_469 => GHC.Classes.Ord (FunctionSignature a_469)

deriving instance GHC.Show.Show a_470 => GHC.Show.Show (FunctionSignature a_470)

instance AST.Unmarshal.Unmarshal FunctionSignature

instance Data.Foldable.Foldable FunctionSignature where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor FunctionSignature where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable FunctionSignature where
  traverse = AST.Traversable1.Class.traverseDefault1

data FunctionType a = FunctionType
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FormalParameters GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypeParameters GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_471.
      AST.Traversable1.Class.Traversable1 a_471
    )

instance AST.Unmarshal.SymbolMatching FunctionType where
  matchedSymbols _ = [280]
  showFailure _ node_472 =
    "expected "
      GHC.Base.<> ( "function_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_472 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_472) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_473 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_474 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_475 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_476 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_473
        c1_474 = TreeSitter.Node.nodeStartPoint node_472
      TreeSitter.Node.TSPoint
        r2_475
        c2_476 = TreeSitter.Node.nodeEndPoint node_472

deriving instance GHC.Classes.Eq a_477 => GHC.Classes.Eq (FunctionType a_477)

deriving instance GHC.Classes.Ord a_478 => GHC.Classes.Ord (FunctionType a_478)

deriving instance GHC.Show.Show a_479 => GHC.Show.Show (FunctionType a_479)

instance AST.Unmarshal.Unmarshal FunctionType

instance Data.Foldable.Foldable FunctionType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor FunctionType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable FunctionType where
  traverse = AST.Traversable1.Class.traverseDefault1

data GeneratorFunction a = GeneratorFunction
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    body :: (AST.Parse.Err (StatementBlock a)),
    name :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a))),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_480.
      AST.Traversable1.Class.Traversable1 a_480
    )

instance AST.Unmarshal.SymbolMatching GeneratorFunction where
  matchedSymbols _ = [190]
  showFailure _ node_481 =
    "expected "
      GHC.Base.<> ( "generator_function"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_481 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_481) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_482 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_483 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_484 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_485 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_482
        c1_483 = TreeSitter.Node.nodeStartPoint node_481
      TreeSitter.Node.TSPoint
        r2_484
        c2_485 = TreeSitter.Node.nodeEndPoint node_481

deriving instance GHC.Classes.Eq a_486 => GHC.Classes.Eq (GeneratorFunction a_486)

deriving instance GHC.Classes.Ord a_487 => GHC.Classes.Ord (GeneratorFunction a_487)

deriving instance GHC.Show.Show a_488 => GHC.Show.Show (GeneratorFunction a_488)

instance AST.Unmarshal.Unmarshal GeneratorFunction

instance Data.Foldable.Foldable GeneratorFunction where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor GeneratorFunction where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable GeneratorFunction where
  traverse = AST.Traversable1.Class.traverseDefault1

data GeneratorFunctionDeclaration a = GeneratorFunctionDeclaration
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    body :: (AST.Parse.Err (StatementBlock a)),
    name :: (AST.Parse.Err (Identifier a)),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_489.
      AST.Traversable1.Class.Traversable1 a_489
    )

instance AST.Unmarshal.SymbolMatching GeneratorFunctionDeclaration where
  matchedSymbols _ = [191]
  showFailure _ node_490 =
    "expected "
      GHC.Base.<> ( "generator_function_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_490 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_490) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_491 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_492 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_493 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_494 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_491
        c1_492 = TreeSitter.Node.nodeStartPoint node_490
      TreeSitter.Node.TSPoint
        r2_493
        c2_494 = TreeSitter.Node.nodeEndPoint node_490

deriving instance GHC.Classes.Eq a_495 => GHC.Classes.Eq (GeneratorFunctionDeclaration a_495)

deriving instance GHC.Classes.Ord a_496 => GHC.Classes.Ord (GeneratorFunctionDeclaration a_496)

deriving instance GHC.Show.Show a_497 => GHC.Show.Show (GeneratorFunctionDeclaration a_497)

instance AST.Unmarshal.Unmarshal GeneratorFunctionDeclaration

instance Data.Foldable.Foldable GeneratorFunctionDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor GeneratorFunctionDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable GeneratorFunctionDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data GenericType a = GenericType
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((NestedTypeIdentifier GHC.Generics.:+: TypeArguments GHC.Generics.:+: TypeIdentifier) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_498.
      AST.Traversable1.Class.Traversable1 a_498
    )

instance AST.Unmarshal.SymbolMatching GenericType where
  matchedSymbols _ = [254]
  showFailure _ node_499 =
    "expected "
      GHC.Base.<> ( "generic_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_499 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_499) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_500 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_501 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_502 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_503 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_500
        c1_501 = TreeSitter.Node.nodeStartPoint node_499
      TreeSitter.Node.TSPoint
        r2_502
        c2_503 = TreeSitter.Node.nodeEndPoint node_499

deriving instance GHC.Classes.Eq a_504 => GHC.Classes.Eq (GenericType a_504)

deriving instance GHC.Classes.Ord a_505 => GHC.Classes.Ord (GenericType a_505)

deriving instance GHC.Show.Show a_506 => GHC.Show.Show (GenericType a_506)

instance AST.Unmarshal.Unmarshal GenericType

instance Data.Foldable.Foldable GenericType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor GenericType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable GenericType where
  traverse = AST.Traversable1.Class.traverseDefault1

data IfStatement a = IfStatement
  { ann :: a,
    alternative :: (GHC.Maybe.Maybe (AST.Parse.Err (Statement a))),
    consequence :: (AST.Parse.Err (Statement a)),
    condition :: (AST.Parse.Err (ParenthesizedExpression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_507.
      AST.Traversable1.Class.Traversable1 a_507
    )

instance AST.Unmarshal.SymbolMatching IfStatement where
  matchedSymbols _ = [157]
  showFailure _ node_508 =
    "expected "
      GHC.Base.<> ( "if_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_508 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_508) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_509 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_510 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_511 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_512 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_509
        c1_510 = TreeSitter.Node.nodeStartPoint node_508
      TreeSitter.Node.TSPoint
        r2_511
        c2_512 = TreeSitter.Node.nodeEndPoint node_508

deriving instance GHC.Classes.Eq a_513 => GHC.Classes.Eq (IfStatement a_513)

deriving instance GHC.Classes.Ord a_514 => GHC.Classes.Ord (IfStatement a_514)

deriving instance GHC.Show.Show a_515 => GHC.Show.Show (IfStatement a_515)

instance AST.Unmarshal.Unmarshal IfStatement

instance Data.Foldable.Foldable IfStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor IfStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable IfStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data ImplementsClause a = ImplementsClause
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_516.
      AST.Traversable1.Class.Traversable1 a_516
    )

instance AST.Unmarshal.SymbolMatching ImplementsClause where
  matchedSymbols _ = [232]
  showFailure _ node_517 =
    "expected "
      GHC.Base.<> ( "implements_clause"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_517 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_517) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_518 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_519 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_520 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_521 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_518
        c1_519 = TreeSitter.Node.nodeStartPoint node_517
      TreeSitter.Node.TSPoint
        r2_520
        c2_521 = TreeSitter.Node.nodeEndPoint node_517

deriving instance GHC.Classes.Eq a_522 => GHC.Classes.Eq (ImplementsClause a_522)

deriving instance GHC.Classes.Ord a_523 => GHC.Classes.Ord (ImplementsClause a_523)

deriving instance GHC.Show.Show a_524 => GHC.Show.Show (ImplementsClause a_524)

instance AST.Unmarshal.Unmarshal ImplementsClause

instance Data.Foldable.Foldable ImplementsClause where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ImplementsClause where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ImplementsClause where
  traverse = AST.Traversable1.Class.traverseDefault1

data Import a = Import {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_525.
      AST.Traversable1.Class.Traversable1 a_525
    )

instance AST.Unmarshal.SymbolMatching Import where
  matchedSymbols _ = [146]
  showFailure _ node_526 =
    "expected "
      GHC.Base.<> ( "import"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_526 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_526) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_527 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_528 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_529 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_530 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_527
        c1_528 = TreeSitter.Node.nodeStartPoint node_526
      TreeSitter.Node.TSPoint
        r2_529
        c2_530 = TreeSitter.Node.nodeEndPoint node_526

deriving instance GHC.Classes.Eq a_531 => GHC.Classes.Eq (Import a_531)

deriving instance GHC.Classes.Ord a_532 => GHC.Classes.Ord (Import a_532)

deriving instance GHC.Show.Show a_533 => GHC.Show.Show (Import a_533)

instance AST.Unmarshal.Unmarshal Import

instance Data.Foldable.Foldable Import where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Import where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Import where
  traverse = AST.Traversable1.Class.traverseDefault1

data ImportAlias a = ImportAlias
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: NestedIdentifier) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_534.
      AST.Traversable1.Class.Traversable1 a_534
    )

instance AST.Unmarshal.SymbolMatching ImportAlias where
  matchedSymbols _ = [238]
  showFailure _ node_535 =
    "expected "
      GHC.Base.<> ( "import_alias"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_535 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_535) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_536 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_537 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_538 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_539 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_536
        c1_537 = TreeSitter.Node.nodeStartPoint node_535
      TreeSitter.Node.TSPoint
        r2_538
        c2_539 = TreeSitter.Node.nodeEndPoint node_535

deriving instance GHC.Classes.Eq a_540 => GHC.Classes.Eq (ImportAlias a_540)

deriving instance GHC.Classes.Ord a_541 => GHC.Classes.Ord (ImportAlias a_541)

deriving instance GHC.Show.Show a_542 => GHC.Show.Show (ImportAlias a_542)

instance AST.Unmarshal.Unmarshal ImportAlias

instance Data.Foldable.Foldable ImportAlias where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ImportAlias where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ImportAlias where
  traverse = AST.Traversable1.Class.traverseDefault1

data ImportClause a = ImportClause
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: NamedImports GHC.Generics.:+: NamespaceImport) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_543.
      AST.Traversable1.Class.Traversable1 a_543
    )

instance AST.Unmarshal.SymbolMatching ImportClause where
  matchedSymbols _ = [148]
  showFailure _ node_544 =
    "expected "
      GHC.Base.<> ( "import_clause"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_544 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_544) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_545 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_546 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_547 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_548 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_545
        c1_546 = TreeSitter.Node.nodeStartPoint node_544
      TreeSitter.Node.TSPoint
        r2_547
        c2_548 = TreeSitter.Node.nodeEndPoint node_544

deriving instance GHC.Classes.Eq a_549 => GHC.Classes.Eq (ImportClause a_549)

deriving instance GHC.Classes.Ord a_550 => GHC.Classes.Ord (ImportClause a_550)

deriving instance GHC.Show.Show a_551 => GHC.Show.Show (ImportClause a_551)

instance AST.Unmarshal.Unmarshal ImportClause

instance Data.Foldable.Foldable ImportClause where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ImportClause where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ImportClause where
  traverse = AST.Traversable1.Class.traverseDefault1

data ImportRequireClause a = ImportRequireClause
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: String) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_552.
      AST.Traversable1.Class.Traversable1 a_552
    )

instance AST.Unmarshal.SymbolMatching ImportRequireClause where
  matchedSymbols _ = [231]
  showFailure _ node_553 =
    "expected "
      GHC.Base.<> ( "import_require_clause"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_553 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_553) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_554 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_555 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_556 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_557 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_554
        c1_555 = TreeSitter.Node.nodeStartPoint node_553
      TreeSitter.Node.TSPoint
        r2_556
        c2_557 = TreeSitter.Node.nodeEndPoint node_553

deriving instance GHC.Classes.Eq a_558 => GHC.Classes.Eq (ImportRequireClause a_558)

deriving instance GHC.Classes.Ord a_559 => GHC.Classes.Ord (ImportRequireClause a_559)

deriving instance GHC.Show.Show a_560 => GHC.Show.Show (ImportRequireClause a_560)

instance AST.Unmarshal.Unmarshal ImportRequireClause

instance Data.Foldable.Foldable ImportRequireClause where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ImportRequireClause where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ImportRequireClause where
  traverse = AST.Traversable1.Class.traverseDefault1

data ImportSpecifier a = ImportSpecifier
  { ann :: a,
    alias :: (GHC.Maybe.Maybe (AST.Parse.Err (Identifier a))),
    name :: (AST.Parse.Err (Identifier a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_561.
      AST.Traversable1.Class.Traversable1 a_561
    )

instance AST.Unmarshal.SymbolMatching ImportSpecifier where
  matchedSymbols _ = [301]
  showFailure _ node_562 =
    "expected "
      GHC.Base.<> ( "import_specifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_562 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_562) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_563 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_564 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_565 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_566 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_563
        c1_564 = TreeSitter.Node.nodeStartPoint node_562
      TreeSitter.Node.TSPoint
        r2_565
        c2_566 = TreeSitter.Node.nodeEndPoint node_562

deriving instance GHC.Classes.Eq a_567 => GHC.Classes.Eq (ImportSpecifier a_567)

deriving instance GHC.Classes.Ord a_568 => GHC.Classes.Ord (ImportSpecifier a_568)

deriving instance GHC.Show.Show a_569 => GHC.Show.Show (ImportSpecifier a_569)

instance AST.Unmarshal.Unmarshal ImportSpecifier

instance Data.Foldable.Foldable ImportSpecifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ImportSpecifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ImportSpecifier where
  traverse = AST.Traversable1.Class.traverseDefault1

data ImportStatement a = ImportStatement
  { ann :: a,
    source :: (GHC.Maybe.Maybe (AST.Parse.Err (String a))),
    extraChildren :: (AST.Parse.Err ((ImportClause GHC.Generics.:+: ImportRequireClause GHC.Generics.:+: String) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_570.
      AST.Traversable1.Class.Traversable1 a_570
    )

instance AST.Unmarshal.SymbolMatching ImportStatement where
  matchedSymbols _ = [147]
  showFailure _ node_571 =
    "expected "
      GHC.Base.<> ( "import_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_571 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_571) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_572 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_573 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_574 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_575 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_572
        c1_573 = TreeSitter.Node.nodeStartPoint node_571
      TreeSitter.Node.TSPoint
        r2_574
        c2_575 = TreeSitter.Node.nodeEndPoint node_571

deriving instance GHC.Classes.Eq a_576 => GHC.Classes.Eq (ImportStatement a_576)

deriving instance GHC.Classes.Ord a_577 => GHC.Classes.Ord (ImportStatement a_577)

deriving instance GHC.Show.Show a_578 => GHC.Show.Show (ImportStatement a_578)

instance AST.Unmarshal.Unmarshal ImportStatement

instance Data.Foldable.Foldable ImportStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ImportStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ImportStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data IndexSignature a = IndexSignature
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: MappedTypeClause GHC.Generics.:+: PredefinedType GHC.Generics.:+: TypeAnnotation) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_579.
      AST.Traversable1.Class.Traversable1 a_579
    )

instance AST.Unmarshal.SymbolMatching IndexSignature where
  matchedSymbols _ = [275]
  showFailure _ node_580 =
    "expected "
      GHC.Base.<> ( "index_signature"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_580 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_580) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_581 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_582 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_583 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_584 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_581
        c1_582 = TreeSitter.Node.nodeStartPoint node_580
      TreeSitter.Node.TSPoint
        r2_583
        c2_584 = TreeSitter.Node.nodeEndPoint node_580

deriving instance GHC.Classes.Eq a_585 => GHC.Classes.Eq (IndexSignature a_585)

deriving instance GHC.Classes.Ord a_586 => GHC.Classes.Ord (IndexSignature a_586)

deriving instance GHC.Show.Show a_587 => GHC.Show.Show (IndexSignature a_587)

instance AST.Unmarshal.Unmarshal IndexSignature

instance Data.Foldable.Foldable IndexSignature where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor IndexSignature where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable IndexSignature where
  traverse = AST.Traversable1.Class.traverseDefault1

data IndexTypeQuery a = IndexTypeQuery
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((NestedTypeIdentifier GHC.Generics.:+: TypeIdentifier) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_588.
      AST.Traversable1.Class.Traversable1 a_588
    )

instance AST.Unmarshal.SymbolMatching IndexTypeQuery where
  matchedSymbols _ = [257]
  showFailure _ node_589 =
    "expected "
      GHC.Base.<> ( "index_type_query"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_589 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_589) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_590 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_591 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_592 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_593 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_590
        c1_591 = TreeSitter.Node.nodeStartPoint node_589
      TreeSitter.Node.TSPoint
        r2_592
        c2_593 = TreeSitter.Node.nodeEndPoint node_589

deriving instance GHC.Classes.Eq a_594 => GHC.Classes.Eq (IndexTypeQuery a_594)

deriving instance GHC.Classes.Ord a_595 => GHC.Classes.Ord (IndexTypeQuery a_595)

deriving instance GHC.Show.Show a_596 => GHC.Show.Show (IndexTypeQuery a_596)

instance AST.Unmarshal.Unmarshal IndexTypeQuery

instance Data.Foldable.Foldable IndexTypeQuery where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor IndexTypeQuery where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable IndexTypeQuery where
  traverse = AST.Traversable1.Class.traverseDefault1

data InterfaceDeclaration a = InterfaceDeclaration
  { ann :: a,
    body :: (AST.Parse.Err (ObjectType a)),
    name :: (AST.Parse.Err (TypeIdentifier a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (ExtendsClause a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_597.
      AST.Traversable1.Class.Traversable1 a_597
    )

instance AST.Unmarshal.SymbolMatching InterfaceDeclaration where
  matchedSymbols _ = [240]
  showFailure _ node_598 =
    "expected "
      GHC.Base.<> ( "interface_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_598 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_598) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_599 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_600 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_601 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_602 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_599
        c1_600 = TreeSitter.Node.nodeStartPoint node_598
      TreeSitter.Node.TSPoint
        r2_601
        c2_602 = TreeSitter.Node.nodeEndPoint node_598

deriving instance GHC.Classes.Eq a_603 => GHC.Classes.Eq (InterfaceDeclaration a_603)

deriving instance GHC.Classes.Ord a_604 => GHC.Classes.Ord (InterfaceDeclaration a_604)

deriving instance GHC.Show.Show a_605 => GHC.Show.Show (InterfaceDeclaration a_605)

instance AST.Unmarshal.Unmarshal InterfaceDeclaration

instance Data.Foldable.Foldable InterfaceDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor InterfaceDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable InterfaceDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data InternalModule a = InternalModule
  { ann :: a,
    body :: (GHC.Maybe.Maybe (AST.Parse.Err (StatementBlock a))),
    name :: (AST.Parse.Err ((Identifier GHC.Generics.:+: NestedIdentifier GHC.Generics.:+: String) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_606.
      AST.Traversable1.Class.Traversable1 a_606
    )

instance AST.Unmarshal.SymbolMatching InternalModule where
  matchedSymbols _ = [236]
  showFailure _ node_607 =
    "expected "
      GHC.Base.<> ( "internal_module"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_607 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_607) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_608 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_609 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_610 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_611 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_608
        c1_609 = TreeSitter.Node.nodeStartPoint node_607
      TreeSitter.Node.TSPoint
        r2_610
        c2_611 = TreeSitter.Node.nodeEndPoint node_607

deriving instance GHC.Classes.Eq a_612 => GHC.Classes.Eq (InternalModule a_612)

deriving instance GHC.Classes.Ord a_613 => GHC.Classes.Ord (InternalModule a_613)

deriving instance GHC.Show.Show a_614 => GHC.Show.Show (InternalModule a_614)

instance AST.Unmarshal.Unmarshal InternalModule

instance Data.Foldable.Foldable InternalModule where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor InternalModule where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable InternalModule where
  traverse = AST.Traversable1.Class.traverseDefault1

data IntersectionType a = IntersectionType
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_615.
      AST.Traversable1.Class.Traversable1 a_615
    )

instance AST.Unmarshal.SymbolMatching IntersectionType where
  matchedSymbols _ = [279]
  showFailure _ node_616 =
    "expected "
      GHC.Base.<> ( "intersection_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_616 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_616) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_617 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_618 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_619 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_620 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_617
        c1_618 = TreeSitter.Node.nodeStartPoint node_616
      TreeSitter.Node.TSPoint
        r2_619
        c2_620 = TreeSitter.Node.nodeEndPoint node_616

deriving instance GHC.Classes.Eq a_621 => GHC.Classes.Eq (IntersectionType a_621)

deriving instance GHC.Classes.Ord a_622 => GHC.Classes.Ord (IntersectionType a_622)

deriving instance GHC.Show.Show a_623 => GHC.Show.Show (IntersectionType a_623)

instance AST.Unmarshal.Unmarshal IntersectionType

instance Data.Foldable.Foldable IntersectionType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor IntersectionType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable IntersectionType where
  traverse = AST.Traversable1.Class.traverseDefault1

data JsxAttribute a = JsxAttribute
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((JsxElement GHC.Generics.:+: JsxExpression GHC.Generics.:+: JsxFragment GHC.Generics.:+: JsxNamespaceName GHC.Generics.:+: JsxSelfClosingElement GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_624.
      AST.Traversable1.Class.Traversable1 a_624
    )

instance AST.Unmarshal.SymbolMatching JsxAttribute where
  matchedSymbols _ = []
  showFailure _ node_625 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_625 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_625) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_626 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_627 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_628 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_629 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_626
        c1_627 = TreeSitter.Node.nodeStartPoint node_625
      TreeSitter.Node.TSPoint
        r2_628
        c2_629 = TreeSitter.Node.nodeEndPoint node_625

deriving instance GHC.Classes.Eq a_630 => GHC.Classes.Eq (JsxAttribute a_630)

deriving instance GHC.Classes.Ord a_631 => GHC.Classes.Ord (JsxAttribute a_631)

deriving instance GHC.Show.Show a_632 => GHC.Show.Show (JsxAttribute a_632)

instance AST.Unmarshal.Unmarshal JsxAttribute

instance Data.Foldable.Foldable JsxAttribute where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxAttribute where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxAttribute where
  traverse = AST.Traversable1.Class.traverseDefault1

data JsxClosingElement a = JsxClosingElement
  { ann :: a,
    name :: (AST.Parse.Err ((Identifier GHC.Generics.:+: JsxNamespaceName GHC.Generics.:+: NestedIdentifier) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_633.
      AST.Traversable1.Class.Traversable1 a_633
    )

instance AST.Unmarshal.SymbolMatching JsxClosingElement where
  matchedSymbols _ = []
  showFailure _ node_634 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_634 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_634) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_635 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_636 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_637 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_638 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_635
        c1_636 = TreeSitter.Node.nodeStartPoint node_634
      TreeSitter.Node.TSPoint
        r2_637
        c2_638 = TreeSitter.Node.nodeEndPoint node_634

deriving instance GHC.Classes.Eq a_639 => GHC.Classes.Eq (JsxClosingElement a_639)

deriving instance GHC.Classes.Ord a_640 => GHC.Classes.Ord (JsxClosingElement a_640)

deriving instance GHC.Show.Show a_641 => GHC.Show.Show (JsxClosingElement a_641)

instance AST.Unmarshal.Unmarshal JsxClosingElement

instance Data.Foldable.Foldable JsxClosingElement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxClosingElement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxClosingElement where
  traverse = AST.Traversable1.Class.traverseDefault1

data JsxElement a = JsxElement
  { ann :: a,
    closeTag :: (AST.Parse.Err (JsxClosingElement a)),
    openTag :: (AST.Parse.Err (JsxOpeningElement a)),
    extraChildren :: ([AST.Parse.Err ((JsxElement GHC.Generics.:+: JsxExpression GHC.Generics.:+: JsxSelfClosingElement GHC.Generics.:+: JsxText) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_642.
      AST.Traversable1.Class.Traversable1 a_642
    )

instance AST.Unmarshal.SymbolMatching JsxElement where
  matchedSymbols _ = []
  showFailure _ node_643 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_643 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_643) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_644 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_645 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_646 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_647 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_644
        c1_645 = TreeSitter.Node.nodeStartPoint node_643
      TreeSitter.Node.TSPoint
        r2_646
        c2_647 = TreeSitter.Node.nodeEndPoint node_643

deriving instance GHC.Classes.Eq a_648 => GHC.Classes.Eq (JsxElement a_648)

deriving instance GHC.Classes.Ord a_649 => GHC.Classes.Ord (JsxElement a_649)

deriving instance GHC.Show.Show a_650 => GHC.Show.Show (JsxElement a_650)

instance AST.Unmarshal.Unmarshal JsxElement

instance Data.Foldable.Foldable JsxElement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxElement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxElement where
  traverse = AST.Traversable1.Class.traverseDefault1

data JsxExpression a = JsxExpression
  { ann :: a,
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression GHC.Generics.:+: SpreadElement) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_651.
      AST.Traversable1.Class.Traversable1 a_651
    )

instance AST.Unmarshal.SymbolMatching JsxExpression where
  matchedSymbols _ = []
  showFailure _ node_652 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_652 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_652) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_653 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_654 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_655 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_656 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_653
        c1_654 = TreeSitter.Node.nodeStartPoint node_652
      TreeSitter.Node.TSPoint
        r2_655
        c2_656 = TreeSitter.Node.nodeEndPoint node_652

deriving instance GHC.Classes.Eq a_657 => GHC.Classes.Eq (JsxExpression a_657)

deriving instance GHC.Classes.Ord a_658 => GHC.Classes.Ord (JsxExpression a_658)

deriving instance GHC.Show.Show a_659 => GHC.Show.Show (JsxExpression a_659)

instance AST.Unmarshal.Unmarshal JsxExpression

instance Data.Foldable.Foldable JsxExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data JsxFragment a = JsxFragment
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((JsxElement GHC.Generics.:+: JsxExpression GHC.Generics.:+: JsxSelfClosingElement GHC.Generics.:+: JsxText) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_660.
      AST.Traversable1.Class.Traversable1 a_660
    )

instance AST.Unmarshal.SymbolMatching JsxFragment where
  matchedSymbols _ = []
  showFailure _ node_661 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_661 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_661) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_662 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_663 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_664 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_665 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_662
        c1_663 = TreeSitter.Node.nodeStartPoint node_661
      TreeSitter.Node.TSPoint
        r2_664
        c2_665 = TreeSitter.Node.nodeEndPoint node_661

deriving instance GHC.Classes.Eq a_666 => GHC.Classes.Eq (JsxFragment a_666)

deriving instance GHC.Classes.Ord a_667 => GHC.Classes.Ord (JsxFragment a_667)

deriving instance GHC.Show.Show a_668 => GHC.Show.Show (JsxFragment a_668)

instance AST.Unmarshal.Unmarshal JsxFragment

instance Data.Foldable.Foldable JsxFragment where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxFragment where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxFragment where
  traverse = AST.Traversable1.Class.traverseDefault1

data JsxNamespaceName a = JsxNamespaceName
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (Identifier a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_669.
      AST.Traversable1.Class.Traversable1 a_669
    )

instance AST.Unmarshal.SymbolMatching JsxNamespaceName where
  matchedSymbols _ = []
  showFailure _ node_670 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_670 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_670) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_671 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_672 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_673 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_674 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_671
        c1_672 = TreeSitter.Node.nodeStartPoint node_670
      TreeSitter.Node.TSPoint
        r2_673
        c2_674 = TreeSitter.Node.nodeEndPoint node_670

deriving instance GHC.Classes.Eq a_675 => GHC.Classes.Eq (JsxNamespaceName a_675)

deriving instance GHC.Classes.Ord a_676 => GHC.Classes.Ord (JsxNamespaceName a_676)

deriving instance GHC.Show.Show a_677 => GHC.Show.Show (JsxNamespaceName a_677)

instance AST.Unmarshal.Unmarshal JsxNamespaceName

instance Data.Foldable.Foldable JsxNamespaceName where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxNamespaceName where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxNamespaceName where
  traverse = AST.Traversable1.Class.traverseDefault1

data JsxOpeningElement a = JsxOpeningElement
  { ann :: a,
    attribute :: ([AST.Parse.Err ((JsxAttribute GHC.Generics.:+: JsxExpression) a)]),
    name :: (AST.Parse.Err ((Identifier GHC.Generics.:+: JsxNamespaceName GHC.Generics.:+: NestedIdentifier) a)),
    typeArguments :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeArguments a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_678.
      AST.Traversable1.Class.Traversable1 a_678
    )

instance AST.Unmarshal.SymbolMatching JsxOpeningElement where
  matchedSymbols _ = []
  showFailure _ node_679 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_679 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_679) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_680 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_681 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_682 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_683 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_680
        c1_681 = TreeSitter.Node.nodeStartPoint node_679
      TreeSitter.Node.TSPoint
        r2_682
        c2_683 = TreeSitter.Node.nodeEndPoint node_679

deriving instance GHC.Classes.Eq a_684 => GHC.Classes.Eq (JsxOpeningElement a_684)

deriving instance GHC.Classes.Ord a_685 => GHC.Classes.Ord (JsxOpeningElement a_685)

deriving instance GHC.Show.Show a_686 => GHC.Show.Show (JsxOpeningElement a_686)

instance AST.Unmarshal.Unmarshal JsxOpeningElement

instance Data.Foldable.Foldable JsxOpeningElement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxOpeningElement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxOpeningElement where
  traverse = AST.Traversable1.Class.traverseDefault1

data JsxSelfClosingElement a = JsxSelfClosingElement
  { ann :: a,
    attribute :: ([AST.Parse.Err ((JsxAttribute GHC.Generics.:+: JsxExpression) a)]),
    name :: (AST.Parse.Err ((Identifier GHC.Generics.:+: JsxNamespaceName GHC.Generics.:+: NestedIdentifier) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_687.
      AST.Traversable1.Class.Traversable1 a_687
    )

instance AST.Unmarshal.SymbolMatching JsxSelfClosingElement where
  matchedSymbols _ = []
  showFailure _ node_688 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_688 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_688) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_689 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_690 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_691 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_692 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_689
        c1_690 = TreeSitter.Node.nodeStartPoint node_688
      TreeSitter.Node.TSPoint
        r2_691
        c2_692 = TreeSitter.Node.nodeEndPoint node_688

deriving instance GHC.Classes.Eq a_693 => GHC.Classes.Eq (JsxSelfClosingElement a_693)

deriving instance GHC.Classes.Ord a_694 => GHC.Classes.Ord (JsxSelfClosingElement a_694)

deriving instance GHC.Show.Show a_695 => GHC.Show.Show (JsxSelfClosingElement a_695)

instance AST.Unmarshal.Unmarshal JsxSelfClosingElement

instance Data.Foldable.Foldable JsxSelfClosingElement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxSelfClosingElement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxSelfClosingElement where
  traverse = AST.Traversable1.Class.traverseDefault1

data LabeledStatement a = LabeledStatement
  { ann :: a,
    label :: (AST.Parse.Err (StatementIdentifier a)),
    extraChildren :: (AST.Parse.Err (Statement a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_696.
      AST.Traversable1.Class.Traversable1 a_696
    )

instance AST.Unmarshal.SymbolMatching LabeledStatement where
  matchedSymbols _ = [172]
  showFailure _ node_697 =
    "expected "
      GHC.Base.<> ( "labeled_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_697 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_697) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_698 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_699 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_700 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_701 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_698
        c1_699 = TreeSitter.Node.nodeStartPoint node_697
      TreeSitter.Node.TSPoint
        r2_700
        c2_701 = TreeSitter.Node.nodeEndPoint node_697

deriving instance GHC.Classes.Eq a_702 => GHC.Classes.Eq (LabeledStatement a_702)

deriving instance GHC.Classes.Ord a_703 => GHC.Classes.Ord (LabeledStatement a_703)

deriving instance GHC.Show.Show a_704 => GHC.Show.Show (LabeledStatement a_704)

instance AST.Unmarshal.Unmarshal LabeledStatement

instance Data.Foldable.Foldable LabeledStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor LabeledStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable LabeledStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data LexicalDeclaration a = LexicalDeclaration
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (VariableDeclarator a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_705.
      AST.Traversable1.Class.Traversable1 a_705
    )

instance AST.Unmarshal.SymbolMatching LexicalDeclaration where
  matchedSymbols _ = [154]
  showFailure _ node_706 =
    "expected "
      GHC.Base.<> ( "lexical_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_706 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_706) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_707 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_708 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_709 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_710 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_707
        c1_708 = TreeSitter.Node.nodeStartPoint node_706
      TreeSitter.Node.TSPoint
        r2_709
        c2_710 = TreeSitter.Node.nodeEndPoint node_706

deriving instance GHC.Classes.Eq a_711 => GHC.Classes.Eq (LexicalDeclaration a_711)

deriving instance GHC.Classes.Ord a_712 => GHC.Classes.Ord (LexicalDeclaration a_712)

deriving instance GHC.Show.Show a_713 => GHC.Show.Show (LexicalDeclaration a_713)

instance AST.Unmarshal.Unmarshal LexicalDeclaration

instance Data.Foldable.Foldable LexicalDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor LexicalDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable LexicalDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data LiteralType a = LiteralType
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((False GHC.Generics.:+: Number GHC.Generics.:+: String GHC.Generics.:+: True GHC.Generics.:+: UnaryExpression) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_714.
      AST.Traversable1.Class.Traversable1 a_714
    )

instance AST.Unmarshal.SymbolMatching LiteralType where
  matchedSymbols _ = [260]
  showFailure _ node_715 =
    "expected "
      GHC.Base.<> ( "literal_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_715 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_715) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_716 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_717 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_718 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_719 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_716
        c1_717 = TreeSitter.Node.nodeStartPoint node_715
      TreeSitter.Node.TSPoint
        r2_718
        c2_719 = TreeSitter.Node.nodeEndPoint node_715

deriving instance GHC.Classes.Eq a_720 => GHC.Classes.Eq (LiteralType a_720)

deriving instance GHC.Classes.Ord a_721 => GHC.Classes.Ord (LiteralType a_721)

deriving instance GHC.Show.Show a_722 => GHC.Show.Show (LiteralType a_722)

instance AST.Unmarshal.Unmarshal LiteralType

instance Data.Foldable.Foldable LiteralType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor LiteralType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable LiteralType where
  traverse = AST.Traversable1.Class.traverseDefault1

data LookupType a = LookupType
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_723.
      AST.Traversable1.Class.Traversable1 a_723
    )

instance AST.Unmarshal.SymbolMatching LookupType where
  matchedSymbols _ = [258]
  showFailure _ node_724 =
    "expected "
      GHC.Base.<> ( "lookup_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_724 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_724) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_725 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_726 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_727 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_728 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_725
        c1_726 = TreeSitter.Node.nodeStartPoint node_724
      TreeSitter.Node.TSPoint
        r2_727
        c2_728 = TreeSitter.Node.nodeEndPoint node_724

deriving instance GHC.Classes.Eq a_729 => GHC.Classes.Eq (LookupType a_729)

deriving instance GHC.Classes.Ord a_730 => GHC.Classes.Ord (LookupType a_730)

deriving instance GHC.Show.Show a_731 => GHC.Show.Show (LookupType a_731)

instance AST.Unmarshal.Unmarshal LookupType

instance Data.Foldable.Foldable LookupType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor LookupType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable LookupType where
  traverse = AST.Traversable1.Class.traverseDefault1

data MappedTypeClause a = MappedTypeClause
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_732.
      AST.Traversable1.Class.Traversable1 a_732
    )

instance AST.Unmarshal.SymbolMatching MappedTypeClause where
  matchedSymbols _ = [259]
  showFailure _ node_733 =
    "expected "
      GHC.Base.<> ( "mapped_type_clause"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_733 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_733) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_734 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_735 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_736 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_737 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_734
        c1_735 = TreeSitter.Node.nodeStartPoint node_733
      TreeSitter.Node.TSPoint
        r2_736
        c2_737 = TreeSitter.Node.nodeEndPoint node_733

deriving instance GHC.Classes.Eq a_738 => GHC.Classes.Eq (MappedTypeClause a_738)

deriving instance GHC.Classes.Ord a_739 => GHC.Classes.Ord (MappedTypeClause a_739)

deriving instance GHC.Show.Show a_740 => GHC.Show.Show (MappedTypeClause a_740)

instance AST.Unmarshal.Unmarshal MappedTypeClause

instance Data.Foldable.Foldable MappedTypeClause where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor MappedTypeClause where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable MappedTypeClause where
  traverse = AST.Traversable1.Class.traverseDefault1

data MemberExpression a = MemberExpression
  { ann :: a,
    property :: (AST.Parse.Err (PropertyIdentifier a)),
    object :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_741.
      AST.Traversable1.Class.Traversable1 a_741
    )

instance AST.Unmarshal.SymbolMatching MemberExpression where
  matchedSymbols _ = [197, 215]
  showFailure _ node_742 =
    "expected "
      GHC.Base.<> ( "member_expression, member_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_742 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_742) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_743 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_744 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_745 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_746 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_743
        c1_744 = TreeSitter.Node.nodeStartPoint node_742
      TreeSitter.Node.TSPoint
        r2_745
        c2_746 = TreeSitter.Node.nodeEndPoint node_742

deriving instance GHC.Classes.Eq a_747 => GHC.Classes.Eq (MemberExpression a_747)

deriving instance GHC.Classes.Ord a_748 => GHC.Classes.Ord (MemberExpression a_748)

deriving instance GHC.Show.Show a_749 => GHC.Show.Show (MemberExpression a_749)

instance AST.Unmarshal.Unmarshal MemberExpression

instance Data.Foldable.Foldable MemberExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor MemberExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable MemberExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data MetaProperty a = MetaProperty {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_750.
      AST.Traversable1.Class.Traversable1 a_750
    )

instance AST.Unmarshal.SymbolMatching MetaProperty where
  matchedSymbols _ = [212]
  showFailure _ node_751 =
    "expected "
      GHC.Base.<> ( "meta_property"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_751 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_751) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_752 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_753 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_754 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_755 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_752
        c1_753 = TreeSitter.Node.nodeStartPoint node_751
      TreeSitter.Node.TSPoint
        r2_754
        c2_755 = TreeSitter.Node.nodeEndPoint node_751

deriving instance GHC.Classes.Eq a_756 => GHC.Classes.Eq (MetaProperty a_756)

deriving instance GHC.Classes.Ord a_757 => GHC.Classes.Ord (MetaProperty a_757)

deriving instance GHC.Show.Show a_758 => GHC.Show.Show (MetaProperty a_758)

instance AST.Unmarshal.Unmarshal MetaProperty

instance Data.Foldable.Foldable MetaProperty where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor MetaProperty where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable MetaProperty where
  traverse = AST.Traversable1.Class.traverseDefault1

data MethodDefinition a = MethodDefinition
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    body :: (AST.Parse.Err (StatementBlock a)),
    name :: (AST.Parse.Err ((ComputedPropertyName GHC.Generics.:+: Number GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a)),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
    extraChildren :: ([AST.Parse.Err ((AccessibilityModifier GHC.Generics.:+: Readonly) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_759.
      AST.Traversable1.Class.Traversable1 a_759
    )

instance AST.Unmarshal.SymbolMatching MethodDefinition where
  matchedSymbols _ = [221]
  showFailure _ node_760 =
    "expected "
      GHC.Base.<> ( "method_definition"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_760 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_760) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_761 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_762 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_763 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_764 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_761
        c1_762 = TreeSitter.Node.nodeStartPoint node_760
      TreeSitter.Node.TSPoint
        r2_763
        c2_764 = TreeSitter.Node.nodeEndPoint node_760

deriving instance GHC.Classes.Eq a_765 => GHC.Classes.Eq (MethodDefinition a_765)

deriving instance GHC.Classes.Ord a_766 => GHC.Classes.Ord (MethodDefinition a_766)

deriving instance GHC.Show.Show a_767 => GHC.Show.Show (MethodDefinition a_767)

instance AST.Unmarshal.Unmarshal MethodDefinition

instance Data.Foldable.Foldable MethodDefinition where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor MethodDefinition where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable MethodDefinition where
  traverse = AST.Traversable1.Class.traverseDefault1

data MethodSignature a = MethodSignature
  { ann :: a,
    returnType :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    name :: (AST.Parse.Err ((ComputedPropertyName GHC.Generics.:+: Number GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a)),
    parameters :: (AST.Parse.Err (FormalParameters a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a))),
    extraChildren :: ([AST.Parse.Err ((AccessibilityModifier GHC.Generics.:+: Readonly) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_768.
      AST.Traversable1.Class.Traversable1 a_768
    )

instance AST.Unmarshal.SymbolMatching MethodSignature where
  matchedSymbols _ = [226]
  showFailure _ node_769 =
    "expected "
      GHC.Base.<> ( "method_signature"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_769 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_769) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_770 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_771 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_772 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_773 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_770
        c1_771 = TreeSitter.Node.nodeStartPoint node_769
      TreeSitter.Node.TSPoint
        r2_772
        c2_773 = TreeSitter.Node.nodeEndPoint node_769

deriving instance GHC.Classes.Eq a_774 => GHC.Classes.Eq (MethodSignature a_774)

deriving instance GHC.Classes.Ord a_775 => GHC.Classes.Ord (MethodSignature a_775)

deriving instance GHC.Show.Show a_776 => GHC.Show.Show (MethodSignature a_776)

instance AST.Unmarshal.Unmarshal MethodSignature

instance Data.Foldable.Foldable MethodSignature where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor MethodSignature where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable MethodSignature where
  traverse = AST.Traversable1.Class.traverseDefault1

data Module a = Module
  { ann :: a,
    body :: (GHC.Maybe.Maybe (AST.Parse.Err (StatementBlock a))),
    name :: (AST.Parse.Err ((Identifier GHC.Generics.:+: NestedIdentifier GHC.Generics.:+: String) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_777.
      AST.Traversable1.Class.Traversable1 a_777
    )

instance AST.Unmarshal.SymbolMatching Module where
  matchedSymbols _ = [235]
  showFailure _ node_778 =
    "expected "
      GHC.Base.<> ( "module"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_778 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_778) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_779 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_780 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_781 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_782 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_779
        c1_780 = TreeSitter.Node.nodeStartPoint node_778
      TreeSitter.Node.TSPoint
        r2_781
        c2_782 = TreeSitter.Node.nodeEndPoint node_778

deriving instance GHC.Classes.Eq a_783 => GHC.Classes.Eq (Module a_783)

deriving instance GHC.Classes.Ord a_784 => GHC.Classes.Ord (Module a_784)

deriving instance GHC.Show.Show a_785 => GHC.Show.Show (Module a_785)

instance AST.Unmarshal.Unmarshal Module

instance Data.Foldable.Foldable Module where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Module where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Module where
  traverse = AST.Traversable1.Class.traverseDefault1

data NamedImports a = NamedImports
  { ann :: a,
    extraChildren :: ([AST.Parse.Err (ImportSpecifier a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_786.
      AST.Traversable1.Class.Traversable1 a_786
    )

instance AST.Unmarshal.SymbolMatching NamedImports where
  matchedSymbols _ = [151]
  showFailure _ node_787 =
    "expected "
      GHC.Base.<> ( "named_imports"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_787 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_787) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_788 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_789 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_790 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_791 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_788
        c1_789 = TreeSitter.Node.nodeStartPoint node_787
      TreeSitter.Node.TSPoint
        r2_790
        c2_791 = TreeSitter.Node.nodeEndPoint node_787

deriving instance GHC.Classes.Eq a_792 => GHC.Classes.Eq (NamedImports a_792)

deriving instance GHC.Classes.Ord a_793 => GHC.Classes.Ord (NamedImports a_793)

deriving instance GHC.Show.Show a_794 => GHC.Show.Show (NamedImports a_794)

instance AST.Unmarshal.Unmarshal NamedImports

instance Data.Foldable.Foldable NamedImports where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor NamedImports where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable NamedImports where
  traverse = AST.Traversable1.Class.traverseDefault1

data NamespaceImport a = NamespaceImport
  { ann :: a,
    extraChildren :: (AST.Parse.Err (Identifier a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_795.
      AST.Traversable1.Class.Traversable1 a_795
    )

instance AST.Unmarshal.SymbolMatching NamespaceImport where
  matchedSymbols _ = [150]
  showFailure _ node_796 =
    "expected "
      GHC.Base.<> ( "namespace_import"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_796 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_796) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_797 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_798 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_799 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_800 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_797
        c1_798 = TreeSitter.Node.nodeStartPoint node_796
      TreeSitter.Node.TSPoint
        r2_799
        c2_800 = TreeSitter.Node.nodeEndPoint node_796

deriving instance GHC.Classes.Eq a_801 => GHC.Classes.Eq (NamespaceImport a_801)

deriving instance GHC.Classes.Ord a_802 => GHC.Classes.Ord (NamespaceImport a_802)

deriving instance GHC.Show.Show a_803 => GHC.Show.Show (NamespaceImport a_803)

instance AST.Unmarshal.Unmarshal NamespaceImport

instance Data.Foldable.Foldable NamespaceImport where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor NamespaceImport where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable NamespaceImport where
  traverse = AST.Traversable1.Class.traverseDefault1

data NestedIdentifier a = NestedIdentifier
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: NestedIdentifier) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_804.
      AST.Traversable1.Class.Traversable1 a_804
    )

instance AST.Unmarshal.SymbolMatching NestedIdentifier where
  matchedSymbols _ = [184]
  showFailure _ node_805 =
    "expected "
      GHC.Base.<> ( "nested_identifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_805 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_805) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_806 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_807 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_808 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_809 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_806
        c1_807 = TreeSitter.Node.nodeStartPoint node_805
      TreeSitter.Node.TSPoint
        r2_808
        c2_809 = TreeSitter.Node.nodeEndPoint node_805

deriving instance GHC.Classes.Eq a_810 => GHC.Classes.Eq (NestedIdentifier a_810)

deriving instance GHC.Classes.Ord a_811 => GHC.Classes.Ord (NestedIdentifier a_811)

deriving instance GHC.Show.Show a_812 => GHC.Show.Show (NestedIdentifier a_812)

instance AST.Unmarshal.Unmarshal NestedIdentifier

instance Data.Foldable.Foldable NestedIdentifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor NestedIdentifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable NestedIdentifier where
  traverse = AST.Traversable1.Class.traverseDefault1

data NestedTypeIdentifier a = NestedTypeIdentifier
  { ann :: a,
    name :: (AST.Parse.Err (TypeIdentifier a)),
    module' :: (AST.Parse.Err ((Identifier GHC.Generics.:+: NestedIdentifier) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_813.
      AST.Traversable1.Class.Traversable1 a_813
    )

instance AST.Unmarshal.SymbolMatching NestedTypeIdentifier where
  matchedSymbols _ = [239]
  showFailure _ node_814 =
    "expected "
      GHC.Base.<> ( "nested_type_identifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_814 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_814) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_815 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_816 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_817 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_818 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_815
        c1_816 = TreeSitter.Node.nodeStartPoint node_814
      TreeSitter.Node.TSPoint
        r2_817
        c2_818 = TreeSitter.Node.nodeEndPoint node_814

deriving instance GHC.Classes.Eq a_819 => GHC.Classes.Eq (NestedTypeIdentifier a_819)

deriving instance GHC.Classes.Ord a_820 => GHC.Classes.Ord (NestedTypeIdentifier a_820)

deriving instance GHC.Show.Show a_821 => GHC.Show.Show (NestedTypeIdentifier a_821)

instance AST.Unmarshal.Unmarshal NestedTypeIdentifier

instance Data.Foldable.Foldable NestedTypeIdentifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor NestedTypeIdentifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable NestedTypeIdentifier where
  traverse = AST.Traversable1.Class.traverseDefault1

data NewExpression a = NewExpression
  { ann :: a,
    arguments :: (GHC.Maybe.Maybe (AST.Parse.Err (Arguments a))),
    constructor :: (AST.Parse.Err ((Array GHC.Generics.:+: ArrowFunction GHC.Generics.:+: Class GHC.Generics.:+: False GHC.Generics.:+: Function GHC.Generics.:+: GeneratorFunction GHC.Generics.:+: Identifier GHC.Generics.:+: Import GHC.Generics.:+: MemberExpression GHC.Generics.:+: MetaProperty GHC.Generics.:+: NewExpression GHC.Generics.:+: Null GHC.Generics.:+: Number GHC.Generics.:+: Object GHC.Generics.:+: ParenthesizedExpression GHC.Generics.:+: Regex GHC.Generics.:+: String GHC.Generics.:+: SubscriptExpression GHC.Generics.:+: TemplateString GHC.Generics.:+: This GHC.Generics.:+: True GHC.Generics.:+: Undefined) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_822.
      AST.Traversable1.Class.Traversable1 a_822
    )

instance AST.Unmarshal.SymbolMatching NewExpression where
  matchedSymbols _ = [195]
  showFailure _ node_823 =
    "expected "
      GHC.Base.<> ( "new_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_823 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_823) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_824 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_825 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_826 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_827 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_824
        c1_825 = TreeSitter.Node.nodeStartPoint node_823
      TreeSitter.Node.TSPoint
        r2_826
        c2_827 = TreeSitter.Node.nodeEndPoint node_823

deriving instance GHC.Classes.Eq a_828 => GHC.Classes.Eq (NewExpression a_828)

deriving instance GHC.Classes.Ord a_829 => GHC.Classes.Ord (NewExpression a_829)

deriving instance GHC.Show.Show a_830 => GHC.Show.Show (NewExpression a_830)

instance AST.Unmarshal.Unmarshal NewExpression

instance Data.Foldable.Foldable NewExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor NewExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable NewExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data NonNullExpression a = NonNullExpression
  { ann :: a,
    extraChildren :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_831.
      AST.Traversable1.Class.Traversable1 a_831
    )

instance AST.Unmarshal.SymbolMatching NonNullExpression where
  matchedSymbols _ = [225]
  showFailure _ node_832 =
    "expected "
      GHC.Base.<> ( "non_null_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_832 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_832) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_833 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_834 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_835 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_836 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_833
        c1_834 = TreeSitter.Node.nodeStartPoint node_832
      TreeSitter.Node.TSPoint
        r2_835
        c2_836 = TreeSitter.Node.nodeEndPoint node_832

deriving instance GHC.Classes.Eq a_837 => GHC.Classes.Eq (NonNullExpression a_837)

deriving instance GHC.Classes.Ord a_838 => GHC.Classes.Ord (NonNullExpression a_838)

deriving instance GHC.Show.Show a_839 => GHC.Show.Show (NonNullExpression a_839)

instance AST.Unmarshal.Unmarshal NonNullExpression

instance Data.Foldable.Foldable NonNullExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor NonNullExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable NonNullExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data Object a = Object
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((AssignmentPattern GHC.Generics.:+: MethodDefinition GHC.Generics.:+: Pair GHC.Generics.:+: ShorthandPropertyIdentifier GHC.Generics.:+: SpreadElement) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_840.
      AST.Traversable1.Class.Traversable1 a_840
    )

instance AST.Unmarshal.SymbolMatching Object where
  matchedSymbols _ = [181]
  showFailure _ node_841 =
    "expected "
      GHC.Base.<> ( "object"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_841 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_841) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_842 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_843 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_844 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_845 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_842
        c1_843 = TreeSitter.Node.nodeStartPoint node_841
      TreeSitter.Node.TSPoint
        r2_844
        c2_845 = TreeSitter.Node.nodeEndPoint node_841

deriving instance GHC.Classes.Eq a_846 => GHC.Classes.Eq (Object a_846)

deriving instance GHC.Classes.Ord a_847 => GHC.Classes.Ord (Object a_847)

deriving instance GHC.Show.Show a_848 => GHC.Show.Show (Object a_848)

instance AST.Unmarshal.Unmarshal Object

instance Data.Foldable.Foldable Object where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Object where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Object where
  traverse = AST.Traversable1.Class.traverseDefault1

data ObjectPattern a = ObjectPattern
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((AssignmentPattern GHC.Generics.:+: MethodDefinition GHC.Generics.:+: Pair GHC.Generics.:+: ShorthandPropertyIdentifier GHC.Generics.:+: SpreadElement) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_849.
      AST.Traversable1.Class.Traversable1 a_849
    )

instance AST.Unmarshal.SymbolMatching ObjectPattern where
  matchedSymbols _ = [302]
  showFailure _ node_850 =
    "expected "
      GHC.Base.<> ( "object_pattern"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_850 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_850) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_851 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_852 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_853 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_854 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_851
        c1_852 = TreeSitter.Node.nodeStartPoint node_850
      TreeSitter.Node.TSPoint
        r2_853
        c2_854 = TreeSitter.Node.nodeEndPoint node_850

deriving instance GHC.Classes.Eq a_855 => GHC.Classes.Eq (ObjectPattern a_855)

deriving instance GHC.Classes.Ord a_856 => GHC.Classes.Ord (ObjectPattern a_856)

deriving instance GHC.Show.Show a_857 => GHC.Show.Show (ObjectPattern a_857)

instance AST.Unmarshal.Unmarshal ObjectPattern

instance Data.Foldable.Foldable ObjectPattern where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ObjectPattern where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ObjectPattern where
  traverse = AST.Traversable1.Class.traverseDefault1

data ObjectType a = ObjectType
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((CallSignature GHC.Generics.:+: ConstructSignature GHC.Generics.:+: ExportStatement GHC.Generics.:+: IndexSignature GHC.Generics.:+: MethodSignature GHC.Generics.:+: PropertySignature) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_858.
      AST.Traversable1.Class.Traversable1 a_858
    )

instance AST.Unmarshal.SymbolMatching ObjectType where
  matchedSymbols _ = [267]
  showFailure _ node_859 =
    "expected "
      GHC.Base.<> ( "object_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_859 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_859) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_860 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_861 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_862 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_863 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_860
        c1_861 = TreeSitter.Node.nodeStartPoint node_859
      TreeSitter.Node.TSPoint
        r2_862
        c2_863 = TreeSitter.Node.nodeEndPoint node_859

deriving instance GHC.Classes.Eq a_864 => GHC.Classes.Eq (ObjectType a_864)

deriving instance GHC.Classes.Ord a_865 => GHC.Classes.Ord (ObjectType a_865)

deriving instance GHC.Show.Show a_866 => GHC.Show.Show (ObjectType a_866)

instance AST.Unmarshal.Unmarshal ObjectType

instance Data.Foldable.Foldable ObjectType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ObjectType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ObjectType where
  traverse = AST.Traversable1.Class.traverseDefault1

data OptionalParameter a = OptionalParameter
  { ann :: a,
    value :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((DestructuringPattern GHC.Generics.:+: AccessibilityModifier GHC.Generics.:+: Identifier GHC.Generics.:+: Readonly GHC.Generics.:+: This GHC.Generics.:+: TypeAnnotation) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_867.
      AST.Traversable1.Class.Traversable1 a_867
    )

instance AST.Unmarshal.SymbolMatching OptionalParameter where
  matchedSymbols _ = [248]
  showFailure _ node_868 =
    "expected "
      GHC.Base.<> ( "optional_parameter"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_868 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_868) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_869 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_870 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_871 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_872 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_869
        c1_870 = TreeSitter.Node.nodeStartPoint node_868
      TreeSitter.Node.TSPoint
        r2_871
        c2_872 = TreeSitter.Node.nodeEndPoint node_868

deriving instance GHC.Classes.Eq a_873 => GHC.Classes.Eq (OptionalParameter a_873)

deriving instance GHC.Classes.Ord a_874 => GHC.Classes.Ord (OptionalParameter a_874)

deriving instance GHC.Show.Show a_875 => GHC.Show.Show (OptionalParameter a_875)

instance AST.Unmarshal.Unmarshal OptionalParameter

instance Data.Foldable.Foldable OptionalParameter where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor OptionalParameter where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable OptionalParameter where
  traverse = AST.Traversable1.Class.traverseDefault1

data Pair a = Pair
  { ann :: a,
    value :: (AST.Parse.Err (Expression a)),
    key :: (AST.Parse.Err ((ComputedPropertyName GHC.Generics.:+: Number GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_876.
      AST.Traversable1.Class.Traversable1 a_876
    )

instance AST.Unmarshal.SymbolMatching Pair where
  matchedSymbols _ = [222]
  showFailure _ node_877 =
    "expected "
      GHC.Base.<> ( "pair"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_877 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_877) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_878 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_879 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_880 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_881 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_878
        c1_879 = TreeSitter.Node.nodeStartPoint node_877
      TreeSitter.Node.TSPoint
        r2_880
        c2_881 = TreeSitter.Node.nodeEndPoint node_877

deriving instance GHC.Classes.Eq a_882 => GHC.Classes.Eq (Pair a_882)

deriving instance GHC.Classes.Ord a_883 => GHC.Classes.Ord (Pair a_883)

deriving instance GHC.Show.Show a_884 => GHC.Show.Show (Pair a_884)

instance AST.Unmarshal.Unmarshal Pair

instance Data.Foldable.Foldable Pair where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Pair where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Pair where
  traverse = AST.Traversable1.Class.traverseDefault1

data ParenthesizedExpression a = ParenthesizedExpression
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression GHC.Generics.:+: TypeAnnotation) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_885.
      AST.Traversable1.Class.Traversable1 a_885
    )

instance AST.Unmarshal.SymbolMatching ParenthesizedExpression where
  matchedSymbols _ = [178]
  showFailure _ node_886 =
    "expected "
      GHC.Base.<> ( "parenthesized_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_886 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_886) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_887 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_888 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_889 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_890 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_887
        c1_888 = TreeSitter.Node.nodeStartPoint node_886
      TreeSitter.Node.TSPoint
        r2_889
        c2_890 = TreeSitter.Node.nodeEndPoint node_886

deriving instance GHC.Classes.Eq a_891 => GHC.Classes.Eq (ParenthesizedExpression a_891)

deriving instance GHC.Classes.Ord a_892 => GHC.Classes.Ord (ParenthesizedExpression a_892)

deriving instance GHC.Show.Show a_893 => GHC.Show.Show (ParenthesizedExpression a_893)

instance AST.Unmarshal.Unmarshal ParenthesizedExpression

instance Data.Foldable.Foldable ParenthesizedExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ParenthesizedExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ParenthesizedExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data ParenthesizedType a = ParenthesizedType
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_894.
      AST.Traversable1.Class.Traversable1 a_894
    )

instance AST.Unmarshal.SymbolMatching ParenthesizedType where
  matchedSymbols _ = [264]
  showFailure _ node_895 =
    "expected "
      GHC.Base.<> ( "parenthesized_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_895 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_895) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_896 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_897 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_898 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_899 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_896
        c1_897 = TreeSitter.Node.nodeStartPoint node_895
      TreeSitter.Node.TSPoint
        r2_898
        c2_899 = TreeSitter.Node.nodeEndPoint node_895

deriving instance GHC.Classes.Eq a_900 => GHC.Classes.Eq (ParenthesizedType a_900)

deriving instance GHC.Classes.Ord a_901 => GHC.Classes.Ord (ParenthesizedType a_901)

deriving instance GHC.Show.Show a_902 => GHC.Show.Show (ParenthesizedType a_902)

instance AST.Unmarshal.Unmarshal ParenthesizedType

instance Data.Foldable.Foldable ParenthesizedType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ParenthesizedType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ParenthesizedType where
  traverse = AST.Traversable1.Class.traverseDefault1

data PredefinedType a = PredefinedType {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_903.
      AST.Traversable1.Class.Traversable1 a_903
    )

instance AST.Unmarshal.SymbolMatching PredefinedType where
  matchedSymbols _ = [265]
  showFailure _ node_904 =
    "expected "
      GHC.Base.<> ( "predefined_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_904 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_904) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_905 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_906 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_907 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_908 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_905
        c1_906 = TreeSitter.Node.nodeStartPoint node_904
      TreeSitter.Node.TSPoint
        r2_907
        c2_908 = TreeSitter.Node.nodeEndPoint node_904

deriving instance GHC.Classes.Eq a_909 => GHC.Classes.Eq (PredefinedType a_909)

deriving instance GHC.Classes.Ord a_910 => GHC.Classes.Ord (PredefinedType a_910)

deriving instance GHC.Show.Show a_911 => GHC.Show.Show (PredefinedType a_911)

instance AST.Unmarshal.Unmarshal PredefinedType

instance Data.Foldable.Foldable PredefinedType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor PredefinedType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable PredefinedType where
  traverse = AST.Traversable1.Class.traverseDefault1

data Program a = Program
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((Statement GHC.Generics.:+: HashBangLine) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_912.
      AST.Traversable1.Class.Traversable1 a_912
    )

instance AST.Unmarshal.SymbolMatching Program where
  matchedSymbols _ = [141]
  showFailure _ node_913 =
    "expected "
      GHC.Base.<> ( "program"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_913 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_913) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_914 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_915 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_916 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_917 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_914
        c1_915 = TreeSitter.Node.nodeStartPoint node_913
      TreeSitter.Node.TSPoint
        r2_916
        c2_917 = TreeSitter.Node.nodeEndPoint node_913

deriving instance GHC.Classes.Eq a_918 => GHC.Classes.Eq (Program a_918)

deriving instance GHC.Classes.Ord a_919 => GHC.Classes.Ord (Program a_919)

deriving instance GHC.Show.Show a_920 => GHC.Show.Show (Program a_920)

instance AST.Unmarshal.Unmarshal Program

instance Data.Foldable.Foldable Program where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Program where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Program where
  traverse = AST.Traversable1.Class.traverseDefault1

data PropertySignature a = PropertySignature
  { ann :: a,
    name :: (AST.Parse.Err ((ComputedPropertyName GHC.Generics.:+: Number GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a)),
    type' :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    extraChildren :: ([AST.Parse.Err ((AccessibilityModifier GHC.Generics.:+: Readonly) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_921.
      AST.Traversable1.Class.Traversable1 a_921
    )

instance AST.Unmarshal.SymbolMatching PropertySignature where
  matchedSymbols _ = [269]
  showFailure _ node_922 =
    "expected "
      GHC.Base.<> ( "property_signature"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_922 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_922) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_923 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_924 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_925 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_926 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_923
        c1_924 = TreeSitter.Node.nodeStartPoint node_922
      TreeSitter.Node.TSPoint
        r2_925
        c2_926 = TreeSitter.Node.nodeEndPoint node_922

deriving instance GHC.Classes.Eq a_927 => GHC.Classes.Eq (PropertySignature a_927)

deriving instance GHC.Classes.Ord a_928 => GHC.Classes.Ord (PropertySignature a_928)

deriving instance GHC.Show.Show a_929 => GHC.Show.Show (PropertySignature a_929)

instance AST.Unmarshal.Unmarshal PropertySignature

instance Data.Foldable.Foldable PropertySignature where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor PropertySignature where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable PropertySignature where
  traverse = AST.Traversable1.Class.traverseDefault1

data PublicFieldDefinition a = PublicFieldDefinition
  { ann :: a,
    value :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
    name :: (AST.Parse.Err ((ComputedPropertyName GHC.Generics.:+: Number GHC.Generics.:+: PropertyIdentifier GHC.Generics.:+: String) a)),
    type' :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a))),
    extraChildren :: ([AST.Parse.Err ((AccessibilityModifier GHC.Generics.:+: Readonly) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_930.
      AST.Traversable1.Class.Traversable1 a_930
    )

instance AST.Unmarshal.SymbolMatching PublicFieldDefinition where
  matchedSymbols _ = [218]
  showFailure _ node_931 =
    "expected "
      GHC.Base.<> ( "public_field_definition"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_931 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_931) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_932 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_933 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_934 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_935 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_932
        c1_933 = TreeSitter.Node.nodeStartPoint node_931
      TreeSitter.Node.TSPoint
        r2_934
        c2_935 = TreeSitter.Node.nodeEndPoint node_931

deriving instance GHC.Classes.Eq a_936 => GHC.Classes.Eq (PublicFieldDefinition a_936)

deriving instance GHC.Classes.Ord a_937 => GHC.Classes.Ord (PublicFieldDefinition a_937)

deriving instance GHC.Show.Show a_938 => GHC.Show.Show (PublicFieldDefinition a_938)

instance AST.Unmarshal.Unmarshal PublicFieldDefinition

instance Data.Foldable.Foldable PublicFieldDefinition where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor PublicFieldDefinition where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable PublicFieldDefinition where
  traverse = AST.Traversable1.Class.traverseDefault1

data Regex a = Regex
  { ann :: a,
    flags :: (GHC.Maybe.Maybe (AST.Parse.Err (RegexFlags a))),
    pattern :: (AST.Parse.Err (RegexPattern a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_939.
      AST.Traversable1.Class.Traversable1 a_939
    )

instance AST.Unmarshal.SymbolMatching Regex where
  matchedSymbols _ = [211]
  showFailure _ node_940 =
    "expected "
      GHC.Base.<> ( "regex"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_940 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_940) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_941 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_942 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_943 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_944 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_941
        c1_942 = TreeSitter.Node.nodeStartPoint node_940
      TreeSitter.Node.TSPoint
        r2_943
        c2_944 = TreeSitter.Node.nodeEndPoint node_940

deriving instance GHC.Classes.Eq a_945 => GHC.Classes.Eq (Regex a_945)

deriving instance GHC.Classes.Ord a_946 => GHC.Classes.Ord (Regex a_946)

deriving instance GHC.Show.Show a_947 => GHC.Show.Show (Regex a_947)

instance AST.Unmarshal.Unmarshal Regex

instance Data.Foldable.Foldable Regex where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Regex where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Regex where
  traverse = AST.Traversable1.Class.traverseDefault1

data RequiredParameter a = RequiredParameter
  { ann :: a,
    value :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((DestructuringPattern GHC.Generics.:+: AccessibilityModifier GHC.Generics.:+: Identifier GHC.Generics.:+: Readonly GHC.Generics.:+: This GHC.Generics.:+: TypeAnnotation) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_948.
      AST.Traversable1.Class.Traversable1 a_948
    )

instance AST.Unmarshal.SymbolMatching RequiredParameter where
  matchedSymbols _ = [247]
  showFailure _ node_949 =
    "expected "
      GHC.Base.<> ( "required_parameter"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_949 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_949) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_950 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_951 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_952 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_953 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_950
        c1_951 = TreeSitter.Node.nodeStartPoint node_949
      TreeSitter.Node.TSPoint
        r2_952
        c2_953 = TreeSitter.Node.nodeEndPoint node_949

deriving instance GHC.Classes.Eq a_954 => GHC.Classes.Eq (RequiredParameter a_954)

deriving instance GHC.Classes.Ord a_955 => GHC.Classes.Ord (RequiredParameter a_955)

deriving instance GHC.Show.Show a_956 => GHC.Show.Show (RequiredParameter a_956)

instance AST.Unmarshal.Unmarshal RequiredParameter

instance Data.Foldable.Foldable RequiredParameter where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor RequiredParameter where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable RequiredParameter where
  traverse = AST.Traversable1.Class.traverseDefault1

data RestParameter a = RestParameter
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Identifier GHC.Generics.:+: TypeAnnotation) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_957.
      AST.Traversable1.Class.Traversable1 a_957
    )

instance AST.Unmarshal.SymbolMatching RestParameter where
  matchedSymbols _ = [220]
  showFailure _ node_958 =
    "expected "
      GHC.Base.<> ( "rest_parameter"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_958 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_958) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_959 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_960 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_961 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_962 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_959
        c1_960 = TreeSitter.Node.nodeStartPoint node_958
      TreeSitter.Node.TSPoint
        r2_961
        c2_962 = TreeSitter.Node.nodeEndPoint node_958

deriving instance GHC.Classes.Eq a_963 => GHC.Classes.Eq (RestParameter a_963)

deriving instance GHC.Classes.Ord a_964 => GHC.Classes.Ord (RestParameter a_964)

deriving instance GHC.Show.Show a_965 => GHC.Show.Show (RestParameter a_965)

instance AST.Unmarshal.Unmarshal RestParameter

instance Data.Foldable.Foldable RestParameter where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor RestParameter where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable RestParameter where
  traverse = AST.Traversable1.Class.traverseDefault1

data ReturnStatement a = ReturnStatement
  { ann :: a,
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_966.
      AST.Traversable1.Class.Traversable1 a_966
    )

instance AST.Unmarshal.SymbolMatching ReturnStatement where
  matchedSymbols _ = [169]
  showFailure _ node_967 =
    "expected "
      GHC.Base.<> ( "return_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_967 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_967) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_968 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_969 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_970 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_971 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_968
        c1_969 = TreeSitter.Node.nodeStartPoint node_967
      TreeSitter.Node.TSPoint
        r2_970
        c2_971 = TreeSitter.Node.nodeEndPoint node_967

deriving instance GHC.Classes.Eq a_972 => GHC.Classes.Eq (ReturnStatement a_972)

deriving instance GHC.Classes.Ord a_973 => GHC.Classes.Ord (ReturnStatement a_973)

deriving instance GHC.Show.Show a_974 => GHC.Show.Show (ReturnStatement a_974)

instance AST.Unmarshal.Unmarshal ReturnStatement

instance Data.Foldable.Foldable ReturnStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ReturnStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ReturnStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data SequenceExpression a = SequenceExpression
  { ann :: a,
    left :: (AST.Parse.Err (Expression a)),
    right :: (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_975.
      AST.Traversable1.Class.Traversable1 a_975
    )

instance AST.Unmarshal.SymbolMatching SequenceExpression where
  matchedSymbols _ = [207]
  showFailure _ node_976 =
    "expected "
      GHC.Base.<> ( "sequence_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_976 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_976) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_977 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_978 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_979 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_980 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_977
        c1_978 = TreeSitter.Node.nodeStartPoint node_976
      TreeSitter.Node.TSPoint
        r2_979
        c2_980 = TreeSitter.Node.nodeEndPoint node_976

deriving instance GHC.Classes.Eq a_981 => GHC.Classes.Eq (SequenceExpression a_981)

deriving instance GHC.Classes.Ord a_982 => GHC.Classes.Ord (SequenceExpression a_982)

deriving instance GHC.Show.Show a_983 => GHC.Show.Show (SequenceExpression a_983)

instance AST.Unmarshal.Unmarshal SequenceExpression

instance Data.Foldable.Foldable SequenceExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor SequenceExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable SequenceExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data SpreadElement a = SpreadElement
  { ann :: a,
    extraChildren :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_984.
      AST.Traversable1.Class.Traversable1 a_984
    )

instance AST.Unmarshal.SymbolMatching SpreadElement where
  matchedSymbols _ = [202]
  showFailure _ node_985 =
    "expected "
      GHC.Base.<> ( "spread_element"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_985 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_985) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_986 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_987 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_988 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_989 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_986
        c1_987 = TreeSitter.Node.nodeStartPoint node_985
      TreeSitter.Node.TSPoint
        r2_988
        c2_989 = TreeSitter.Node.nodeEndPoint node_985

deriving instance GHC.Classes.Eq a_990 => GHC.Classes.Eq (SpreadElement a_990)

deriving instance GHC.Classes.Ord a_991 => GHC.Classes.Ord (SpreadElement a_991)

deriving instance GHC.Show.Show a_992 => GHC.Show.Show (SpreadElement a_992)

instance AST.Unmarshal.Unmarshal SpreadElement

instance Data.Foldable.Foldable SpreadElement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor SpreadElement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable SpreadElement where
  traverse = AST.Traversable1.Class.traverseDefault1

data StatementBlock a = StatementBlock
  { ann :: a,
    extraChildren :: ([AST.Parse.Err (Statement a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_993.
      AST.Traversable1.Class.Traversable1 a_993
    )

instance AST.Unmarshal.SymbolMatching StatementBlock where
  matchedSymbols _ = [156]
  showFailure _ node_994 =
    "expected "
      GHC.Base.<> ( "statement_block"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_994 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_994) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_995 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_996 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_997 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_998 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_995
        c1_996 = TreeSitter.Node.nodeStartPoint node_994
      TreeSitter.Node.TSPoint
        r2_997
        c2_998 = TreeSitter.Node.nodeEndPoint node_994

deriving instance GHC.Classes.Eq a_999 => GHC.Classes.Eq (StatementBlock a_999)

deriving instance GHC.Classes.Ord a_1000 => GHC.Classes.Ord (StatementBlock a_1000)

deriving instance GHC.Show.Show a_1001 => GHC.Show.Show (StatementBlock a_1001)

instance AST.Unmarshal.Unmarshal StatementBlock

instance Data.Foldable.Foldable StatementBlock where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor StatementBlock where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable StatementBlock where
  traverse = AST.Traversable1.Class.traverseDefault1

data String a = String
  { ann :: a,
    extraChildren :: ([AST.Parse.Err (EscapeSequence a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1002.
      AST.Traversable1.Class.Traversable1 a_1002
    )

instance AST.Unmarshal.SymbolMatching String where
  matchedSymbols _ = [208]
  showFailure _ node_1003 =
    "expected "
      GHC.Base.<> ( "string"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1003 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1003) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1004 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1005 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1006 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1007 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1004
        c1_1005 = TreeSitter.Node.nodeStartPoint node_1003
      TreeSitter.Node.TSPoint
        r2_1006
        c2_1007 = TreeSitter.Node.nodeEndPoint node_1003

deriving instance GHC.Classes.Eq a_1008 => GHC.Classes.Eq (String a_1008)

deriving instance GHC.Classes.Ord a_1009 => GHC.Classes.Ord (String a_1009)

deriving instance GHC.Show.Show a_1010 => GHC.Show.Show (String a_1010)

instance AST.Unmarshal.Unmarshal String

instance Data.Foldable.Foldable String where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor String where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable String where
  traverse = AST.Traversable1.Class.traverseDefault1

data SubscriptExpression a = SubscriptExpression
  { ann :: a,
    object :: (AST.Parse.Err (Expression a)),
    index :: (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1011.
      AST.Traversable1.Class.Traversable1 a_1011
    )

instance AST.Unmarshal.SymbolMatching SubscriptExpression where
  matchedSymbols _ = [198]
  showFailure _ node_1012 =
    "expected "
      GHC.Base.<> ( "subscript_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1012 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1012) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1013 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1014 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1015 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1016 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1013
        c1_1014 = TreeSitter.Node.nodeStartPoint node_1012
      TreeSitter.Node.TSPoint
        r2_1015
        c2_1016 = TreeSitter.Node.nodeEndPoint node_1012

deriving instance GHC.Classes.Eq a_1017 => GHC.Classes.Eq (SubscriptExpression a_1017)

deriving instance GHC.Classes.Ord a_1018 => GHC.Classes.Ord (SubscriptExpression a_1018)

deriving instance GHC.Show.Show a_1019 => GHC.Show.Show (SubscriptExpression a_1019)

instance AST.Unmarshal.Unmarshal SubscriptExpression

instance Data.Foldable.Foldable SubscriptExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor SubscriptExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable SubscriptExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data SwitchBody a = SwitchBody
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((SwitchCase GHC.Generics.:+: SwitchDefault) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1020.
      AST.Traversable1.Class.Traversable1 a_1020
    )

instance AST.Unmarshal.SymbolMatching SwitchBody where
  matchedSymbols _ = [173]
  showFailure _ node_1021 =
    "expected "
      GHC.Base.<> ( "switch_body"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1021 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1021) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1022 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1023 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1024 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1025 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1022
        c1_1023 = TreeSitter.Node.nodeStartPoint node_1021
      TreeSitter.Node.TSPoint
        r2_1024
        c2_1025 = TreeSitter.Node.nodeEndPoint node_1021

deriving instance GHC.Classes.Eq a_1026 => GHC.Classes.Eq (SwitchBody a_1026)

deriving instance GHC.Classes.Ord a_1027 => GHC.Classes.Ord (SwitchBody a_1027)

deriving instance GHC.Show.Show a_1028 => GHC.Show.Show (SwitchBody a_1028)

instance AST.Unmarshal.Unmarshal SwitchBody

instance Data.Foldable.Foldable SwitchBody where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor SwitchBody where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable SwitchBody where
  traverse = AST.Traversable1.Class.traverseDefault1

data SwitchCase a = SwitchCase
  { ann :: a,
    value :: (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a)),
    extraChildren :: ([AST.Parse.Err (Statement a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1029.
      AST.Traversable1.Class.Traversable1 a_1029
    )

instance AST.Unmarshal.SymbolMatching SwitchCase where
  matchedSymbols _ = [174]
  showFailure _ node_1030 =
    "expected "
      GHC.Base.<> ( "switch_case"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1030 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1030) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1031 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1032 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1033 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1034 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1031
        c1_1032 = TreeSitter.Node.nodeStartPoint node_1030
      TreeSitter.Node.TSPoint
        r2_1033
        c2_1034 = TreeSitter.Node.nodeEndPoint node_1030

deriving instance GHC.Classes.Eq a_1035 => GHC.Classes.Eq (SwitchCase a_1035)

deriving instance GHC.Classes.Ord a_1036 => GHC.Classes.Ord (SwitchCase a_1036)

deriving instance GHC.Show.Show a_1037 => GHC.Show.Show (SwitchCase a_1037)

instance AST.Unmarshal.Unmarshal SwitchCase

instance Data.Foldable.Foldable SwitchCase where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor SwitchCase where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable SwitchCase where
  traverse = AST.Traversable1.Class.traverseDefault1

data SwitchDefault a = SwitchDefault
  { ann :: a,
    extraChildren :: ([AST.Parse.Err (Statement a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1038.
      AST.Traversable1.Class.Traversable1 a_1038
    )

instance AST.Unmarshal.SymbolMatching SwitchDefault where
  matchedSymbols _ = [175]
  showFailure _ node_1039 =
    "expected "
      GHC.Base.<> ( "switch_default"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1039 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1039) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1040 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1041 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1042 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1043 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1040
        c1_1041 = TreeSitter.Node.nodeStartPoint node_1039
      TreeSitter.Node.TSPoint
        r2_1042
        c2_1043 = TreeSitter.Node.nodeEndPoint node_1039

deriving instance GHC.Classes.Eq a_1044 => GHC.Classes.Eq (SwitchDefault a_1044)

deriving instance GHC.Classes.Ord a_1045 => GHC.Classes.Ord (SwitchDefault a_1045)

deriving instance GHC.Show.Show a_1046 => GHC.Show.Show (SwitchDefault a_1046)

instance AST.Unmarshal.Unmarshal SwitchDefault

instance Data.Foldable.Foldable SwitchDefault where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor SwitchDefault where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable SwitchDefault where
  traverse = AST.Traversable1.Class.traverseDefault1

data SwitchStatement a = SwitchStatement
  { ann :: a,
    body :: (AST.Parse.Err (SwitchBody a)),
    value :: (AST.Parse.Err (ParenthesizedExpression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1047.
      AST.Traversable1.Class.Traversable1 a_1047
    )

instance AST.Unmarshal.SymbolMatching SwitchStatement where
  matchedSymbols _ = [158]
  showFailure _ node_1048 =
    "expected "
      GHC.Base.<> ( "switch_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1048 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1048) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1049 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1050 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1051 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1052 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1049
        c1_1050 = TreeSitter.Node.nodeStartPoint node_1048
      TreeSitter.Node.TSPoint
        r2_1051
        c2_1052 = TreeSitter.Node.nodeEndPoint node_1048

deriving instance GHC.Classes.Eq a_1053 => GHC.Classes.Eq (SwitchStatement a_1053)

deriving instance GHC.Classes.Ord a_1054 => GHC.Classes.Ord (SwitchStatement a_1054)

deriving instance GHC.Show.Show a_1055 => GHC.Show.Show (SwitchStatement a_1055)

instance AST.Unmarshal.Unmarshal SwitchStatement

instance Data.Foldable.Foldable SwitchStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor SwitchStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable SwitchStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data TemplateString a = TemplateString
  { ann :: a,
    extraChildren :: ([AST.Parse.Err ((EscapeSequence GHC.Generics.:+: TemplateSubstitution) a)])
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1056.
      AST.Traversable1.Class.Traversable1 a_1056
    )

instance AST.Unmarshal.SymbolMatching TemplateString where
  matchedSymbols _ = [209]
  showFailure _ node_1057 =
    "expected "
      GHC.Base.<> ( "template_string"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1057 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1057) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1058 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1059 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1060 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1061 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1058
        c1_1059 = TreeSitter.Node.nodeStartPoint node_1057
      TreeSitter.Node.TSPoint
        r2_1060
        c2_1061 = TreeSitter.Node.nodeEndPoint node_1057

deriving instance GHC.Classes.Eq a_1062 => GHC.Classes.Eq (TemplateString a_1062)

deriving instance GHC.Classes.Ord a_1063 => GHC.Classes.Ord (TemplateString a_1063)

deriving instance GHC.Show.Show a_1064 => GHC.Show.Show (TemplateString a_1064)

instance AST.Unmarshal.Unmarshal TemplateString

instance Data.Foldable.Foldable TemplateString where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TemplateString where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TemplateString where
  traverse = AST.Traversable1.Class.traverseDefault1

data TemplateSubstitution a = TemplateSubstitution
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1065.
      AST.Traversable1.Class.Traversable1 a_1065
    )

instance AST.Unmarshal.SymbolMatching TemplateSubstitution where
  matchedSymbols _ = [210]
  showFailure _ node_1066 =
    "expected "
      GHC.Base.<> ( "template_substitution"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1066 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1066) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1067 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1068 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1069 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1070 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1067
        c1_1068 = TreeSitter.Node.nodeStartPoint node_1066
      TreeSitter.Node.TSPoint
        r2_1069
        c2_1070 = TreeSitter.Node.nodeEndPoint node_1066

deriving instance GHC.Classes.Eq a_1071 => GHC.Classes.Eq (TemplateSubstitution a_1071)

deriving instance GHC.Classes.Ord a_1072 => GHC.Classes.Ord (TemplateSubstitution a_1072)

deriving instance GHC.Show.Show a_1073 => GHC.Show.Show (TemplateSubstitution a_1073)

instance AST.Unmarshal.Unmarshal TemplateSubstitution

instance Data.Foldable.Foldable TemplateSubstitution where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TemplateSubstitution where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TemplateSubstitution where
  traverse = AST.Traversable1.Class.traverseDefault1

data TernaryExpression a = TernaryExpression
  { ann :: a,
    alternative :: (AST.Parse.Err (Expression a)),
    consequence :: (AST.Parse.Err (Expression a)),
    condition :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1074.
      AST.Traversable1.Class.Traversable1 a_1074
    )

instance AST.Unmarshal.SymbolMatching TernaryExpression where
  matchedSymbols _ = [203]
  showFailure _ node_1075 =
    "expected "
      GHC.Base.<> ( "ternary_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1075 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1075) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1076 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1077 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1078 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1079 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1076
        c1_1077 = TreeSitter.Node.nodeStartPoint node_1075
      TreeSitter.Node.TSPoint
        r2_1078
        c2_1079 = TreeSitter.Node.nodeEndPoint node_1075

deriving instance GHC.Classes.Eq a_1080 => GHC.Classes.Eq (TernaryExpression a_1080)

deriving instance GHC.Classes.Ord a_1081 => GHC.Classes.Ord (TernaryExpression a_1081)

deriving instance GHC.Show.Show a_1082 => GHC.Show.Show (TernaryExpression a_1082)

instance AST.Unmarshal.Unmarshal TernaryExpression

instance Data.Foldable.Foldable TernaryExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TernaryExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TernaryExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data ThrowStatement a = ThrowStatement
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((Expression GHC.Generics.:+: SequenceExpression) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1083.
      AST.Traversable1.Class.Traversable1 a_1083
    )

instance AST.Unmarshal.SymbolMatching ThrowStatement where
  matchedSymbols _ = [170]
  showFailure _ node_1084 =
    "expected "
      GHC.Base.<> ( "throw_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1084 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1084) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1085 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1086 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1087 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1088 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1085
        c1_1086 = TreeSitter.Node.nodeStartPoint node_1084
      TreeSitter.Node.TSPoint
        r2_1087
        c2_1088 = TreeSitter.Node.nodeEndPoint node_1084

deriving instance GHC.Classes.Eq a_1089 => GHC.Classes.Eq (ThrowStatement a_1089)

deriving instance GHC.Classes.Ord a_1090 => GHC.Classes.Ord (ThrowStatement a_1090)

deriving instance GHC.Show.Show a_1091 => GHC.Show.Show (ThrowStatement a_1091)

instance AST.Unmarshal.Unmarshal ThrowStatement

instance Data.Foldable.Foldable ThrowStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ThrowStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ThrowStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data TryStatement a = TryStatement
  { ann :: a,
    body :: (AST.Parse.Err (StatementBlock a)),
    handler :: (GHC.Maybe.Maybe (AST.Parse.Err (CatchClause a))),
    finalizer :: (GHC.Maybe.Maybe (AST.Parse.Err (FinallyClause a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1092.
      AST.Traversable1.Class.Traversable1 a_1092
    )

instance AST.Unmarshal.SymbolMatching TryStatement where
  matchedSymbols _ = [164]
  showFailure _ node_1093 =
    "expected "
      GHC.Base.<> ( "try_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1093 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1093) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1094 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1095 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1096 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1097 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1094
        c1_1095 = TreeSitter.Node.nodeStartPoint node_1093
      TreeSitter.Node.TSPoint
        r2_1096
        c2_1097 = TreeSitter.Node.nodeEndPoint node_1093

deriving instance GHC.Classes.Eq a_1098 => GHC.Classes.Eq (TryStatement a_1098)

deriving instance GHC.Classes.Ord a_1099 => GHC.Classes.Ord (TryStatement a_1099)

deriving instance GHC.Show.Show a_1100 => GHC.Show.Show (TryStatement a_1100)

instance AST.Unmarshal.Unmarshal TryStatement

instance Data.Foldable.Foldable TryStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TryStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TryStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data TupleType a = TupleType
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1101.
      AST.Traversable1.Class.Traversable1 a_1101
    )

instance AST.Unmarshal.SymbolMatching TupleType where
  matchedSymbols _ = [277]
  showFailure _ node_1102 =
    "expected "
      GHC.Base.<> ( "tuple_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1102 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1102) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1103 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1104 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1105 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1106 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1103
        c1_1104 = TreeSitter.Node.nodeStartPoint node_1102
      TreeSitter.Node.TSPoint
        r2_1105
        c2_1106 = TreeSitter.Node.nodeEndPoint node_1102

deriving instance GHC.Classes.Eq a_1107 => GHC.Classes.Eq (TupleType a_1107)

deriving instance GHC.Classes.Ord a_1108 => GHC.Classes.Ord (TupleType a_1108)

deriving instance GHC.Show.Show a_1109 => GHC.Show.Show (TupleType a_1109)

instance AST.Unmarshal.Unmarshal TupleType

instance Data.Foldable.Foldable TupleType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TupleType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TupleType where
  traverse = AST.Traversable1.Class.traverseDefault1

data TypeAliasDeclaration a = TypeAliasDeclaration
  { ann :: a,
    value :: (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)),
    name :: (AST.Parse.Err (TypeIdentifier a)),
    typeParameters :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeParameters a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1110.
      AST.Traversable1.Class.Traversable1 a_1110
    )

instance AST.Unmarshal.SymbolMatching TypeAliasDeclaration where
  matchedSymbols _ = [245]
  showFailure _ node_1111 =
    "expected "
      GHC.Base.<> ( "type_alias_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1111 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1111) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1112 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1113 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1114 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1115 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1112
        c1_1113 = TreeSitter.Node.nodeStartPoint node_1111
      TreeSitter.Node.TSPoint
        r2_1114
        c2_1115 = TreeSitter.Node.nodeEndPoint node_1111

deriving instance GHC.Classes.Eq a_1116 => GHC.Classes.Eq (TypeAliasDeclaration a_1116)

deriving instance GHC.Classes.Ord a_1117 => GHC.Classes.Ord (TypeAliasDeclaration a_1117)

deriving instance GHC.Show.Show a_1118 => GHC.Show.Show (TypeAliasDeclaration a_1118)

instance AST.Unmarshal.Unmarshal TypeAliasDeclaration

instance Data.Foldable.Foldable TypeAliasDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypeAliasDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypeAliasDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data TypeAnnotation a = TypeAnnotation
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1119.
      AST.Traversable1.Class.Traversable1 a_1119
    )

instance AST.Unmarshal.SymbolMatching TypeAnnotation where
  matchedSymbols _ = [250]
  showFailure _ node_1120 =
    "expected "
      GHC.Base.<> ( "type_annotation"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1120 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1120) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1121 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1122 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1123 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1124 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1121
        c1_1122 = TreeSitter.Node.nodeStartPoint node_1120
      TreeSitter.Node.TSPoint
        r2_1123
        c2_1124 = TreeSitter.Node.nodeEndPoint node_1120

deriving instance GHC.Classes.Eq a_1125 => GHC.Classes.Eq (TypeAnnotation a_1125)

deriving instance GHC.Classes.Ord a_1126 => GHC.Classes.Ord (TypeAnnotation a_1126)

deriving instance GHC.Show.Show a_1127 => GHC.Show.Show (TypeAnnotation a_1127)

instance AST.Unmarshal.Unmarshal TypeAnnotation

instance Data.Foldable.Foldable TypeAnnotation where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypeAnnotation where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypeAnnotation where
  traverse = AST.Traversable1.Class.traverseDefault1

data TypeArguments a = TypeArguments
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1128.
      AST.Traversable1.Class.Traversable1 a_1128
    )

instance AST.Unmarshal.SymbolMatching TypeArguments where
  matchedSymbols _ = [266]
  showFailure _ node_1129 =
    "expected "
      GHC.Base.<> ( "type_arguments"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1129 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1129) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1130 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1131 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1132 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1133 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1130
        c1_1131 = TreeSitter.Node.nodeStartPoint node_1129
      TreeSitter.Node.TSPoint
        r2_1132
        c2_1133 = TreeSitter.Node.nodeEndPoint node_1129

deriving instance GHC.Classes.Eq a_1134 => GHC.Classes.Eq (TypeArguments a_1134)

deriving instance GHC.Classes.Ord a_1135 => GHC.Classes.Ord (TypeArguments a_1135)

deriving instance GHC.Show.Show a_1136 => GHC.Show.Show (TypeArguments a_1136)

instance AST.Unmarshal.Unmarshal TypeArguments

instance Data.Foldable.Foldable TypeArguments where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypeArguments where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypeArguments where
  traverse = AST.Traversable1.Class.traverseDefault1

data TypeAssertion a = TypeAssertion
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Expression GHC.Generics.:+: TypeArguments) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1137.
      AST.Traversable1.Class.Traversable1 a_1137
    )

instance AST.Unmarshal.SymbolMatching TypeAssertion where
  matchedSymbols _ = [229]
  showFailure _ node_1138 =
    "expected "
      GHC.Base.<> ( "type_assertion"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1138 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1138) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1139 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1140 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1141 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1142 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1139
        c1_1140 = TreeSitter.Node.nodeStartPoint node_1138
      TreeSitter.Node.TSPoint
        r2_1141
        c2_1142 = TreeSitter.Node.nodeEndPoint node_1138

deriving instance GHC.Classes.Eq a_1143 => GHC.Classes.Eq (TypeAssertion a_1143)

deriving instance GHC.Classes.Ord a_1144 => GHC.Classes.Ord (TypeAssertion a_1144)

deriving instance GHC.Show.Show a_1145 => GHC.Show.Show (TypeAssertion a_1145)

instance AST.Unmarshal.Unmarshal TypeAssertion

instance Data.Foldable.Foldable TypeAssertion where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypeAssertion where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypeAssertion where
  traverse = AST.Traversable1.Class.traverseDefault1

data TypeParameter a = TypeParameter
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((Constraint GHC.Generics.:+: DefaultType GHC.Generics.:+: TypeIdentifier) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1146.
      AST.Traversable1.Class.Traversable1 a_1146
    )

instance AST.Unmarshal.SymbolMatching TypeParameter where
  matchedSymbols _ = [271]
  showFailure _ node_1147 =
    "expected "
      GHC.Base.<> ( "type_parameter"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1147 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1147) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1148 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1149 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1150 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1151 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1148
        c1_1149 = TreeSitter.Node.nodeStartPoint node_1147
      TreeSitter.Node.TSPoint
        r2_1150
        c2_1151 = TreeSitter.Node.nodeEndPoint node_1147

deriving instance GHC.Classes.Eq a_1152 => GHC.Classes.Eq (TypeParameter a_1152)

deriving instance GHC.Classes.Ord a_1153 => GHC.Classes.Ord (TypeParameter a_1153)

deriving instance GHC.Show.Show a_1154 => GHC.Show.Show (TypeParameter a_1154)

instance AST.Unmarshal.Unmarshal TypeParameter

instance Data.Foldable.Foldable TypeParameter where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypeParameter where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypeParameter where
  traverse = AST.Traversable1.Class.traverseDefault1

data TypeParameters a = TypeParameters
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (TypeParameter a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1155.
      AST.Traversable1.Class.Traversable1 a_1155
    )

instance AST.Unmarshal.SymbolMatching TypeParameters where
  matchedSymbols _ = [270]
  showFailure _ node_1156 =
    "expected "
      GHC.Base.<> ( "type_parameters"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1156 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1156) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1157 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1158 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1159 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1160 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1157
        c1_1158 = TreeSitter.Node.nodeStartPoint node_1156
      TreeSitter.Node.TSPoint
        r2_1159
        c2_1160 = TreeSitter.Node.nodeEndPoint node_1156

deriving instance GHC.Classes.Eq a_1161 => GHC.Classes.Eq (TypeParameters a_1161)

deriving instance GHC.Classes.Ord a_1162 => GHC.Classes.Ord (TypeParameters a_1162)

deriving instance GHC.Show.Show a_1163 => GHC.Show.Show (TypeParameters a_1163)

instance AST.Unmarshal.Unmarshal TypeParameters

instance Data.Foldable.Foldable TypeParameters where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypeParameters where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypeParameters where
  traverse = AST.Traversable1.Class.traverseDefault1

data TypePredicate a = TypePredicate
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: Identifier GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1164.
      AST.Traversable1.Class.Traversable1 a_1164
    )

instance AST.Unmarshal.SymbolMatching TypePredicate where
  matchedSymbols _ = [255]
  showFailure _ node_1165 =
    "expected "
      GHC.Base.<> ( "type_predicate"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1165 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1165) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1166 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1167 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1168 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1169 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1166
        c1_1167 = TreeSitter.Node.nodeStartPoint node_1165
      TreeSitter.Node.TSPoint
        r2_1168
        c2_1169 = TreeSitter.Node.nodeEndPoint node_1165

deriving instance GHC.Classes.Eq a_1170 => GHC.Classes.Eq (TypePredicate a_1170)

deriving instance GHC.Classes.Ord a_1171 => GHC.Classes.Ord (TypePredicate a_1171)

deriving instance GHC.Show.Show a_1172 => GHC.Show.Show (TypePredicate a_1172)

instance AST.Unmarshal.Unmarshal TypePredicate

instance Data.Foldable.Foldable TypePredicate where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypePredicate where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypePredicate where
  traverse = AST.Traversable1.Class.traverseDefault1

data TypeQuery a = TypeQuery
  { ann :: a,
    extraChildren :: (AST.Parse.Err ((Identifier GHC.Generics.:+: NestedIdentifier) a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1173.
      AST.Traversable1.Class.Traversable1 a_1173
    )

instance AST.Unmarshal.SymbolMatching TypeQuery where
  matchedSymbols _ = [256]
  showFailure _ node_1174 =
    "expected "
      GHC.Base.<> ( "type_query"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1174 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1174) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1175 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1176 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1177 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1178 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1175
        c1_1176 = TreeSitter.Node.nodeStartPoint node_1174
      TreeSitter.Node.TSPoint
        r2_1177
        c2_1178 = TreeSitter.Node.nodeEndPoint node_1174

deriving instance GHC.Classes.Eq a_1179 => GHC.Classes.Eq (TypeQuery a_1179)

deriving instance GHC.Classes.Ord a_1180 => GHC.Classes.Ord (TypeQuery a_1180)

deriving instance GHC.Show.Show a_1181 => GHC.Show.Show (TypeQuery a_1181)

instance AST.Unmarshal.Unmarshal TypeQuery

instance Data.Foldable.Foldable TypeQuery where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypeQuery where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypeQuery where
  traverse = AST.Traversable1.Class.traverseDefault1

data UnaryExpression a = UnaryExpression
  { ann :: a,
    operator :: (AST.Parse.Err ((AnonymousBang GHC.Generics.:+: AnonymousPlus GHC.Generics.:+: AnonymousMinus GHC.Generics.:+: AnonymousDelete GHC.Generics.:+: AnonymousTypeof GHC.Generics.:+: AnonymousVoid GHC.Generics.:+: AnonymousTilde) a)),
    argument :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1182.
      AST.Traversable1.Class.Traversable1 a_1182
    )

instance AST.Unmarshal.SymbolMatching UnaryExpression where
  matchedSymbols _ = [205, 261]
  showFailure _ node_1183 =
    "expected "
      GHC.Base.<> ( "unary_expression, unary_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1183 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1183) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1184 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1185 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1186 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1187 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1184
        c1_1185 = TreeSitter.Node.nodeStartPoint node_1183
      TreeSitter.Node.TSPoint
        r2_1186
        c2_1187 = TreeSitter.Node.nodeEndPoint node_1183

deriving instance GHC.Classes.Eq a_1188 => GHC.Classes.Eq (UnaryExpression a_1188)

deriving instance GHC.Classes.Ord a_1189 => GHC.Classes.Ord (UnaryExpression a_1189)

deriving instance GHC.Show.Show a_1190 => GHC.Show.Show (UnaryExpression a_1190)

instance AST.Unmarshal.Unmarshal UnaryExpression

instance Data.Foldable.Foldable UnaryExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor UnaryExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable UnaryExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data UnionType a = UnionType
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err ((ArrayType GHC.Generics.:+: ConstructorType GHC.Generics.:+: ExistentialType GHC.Generics.:+: FlowMaybeType GHC.Generics.:+: FunctionType GHC.Generics.:+: GenericType GHC.Generics.:+: IndexTypeQuery GHC.Generics.:+: IntersectionType GHC.Generics.:+: LiteralType GHC.Generics.:+: LookupType GHC.Generics.:+: NestedTypeIdentifier GHC.Generics.:+: ObjectType GHC.Generics.:+: ParenthesizedType GHC.Generics.:+: PredefinedType GHC.Generics.:+: This GHC.Generics.:+: TupleType GHC.Generics.:+: TypeIdentifier GHC.Generics.:+: TypePredicate GHC.Generics.:+: TypeQuery GHC.Generics.:+: UnionType) a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1191.
      AST.Traversable1.Class.Traversable1 a_1191
    )

instance AST.Unmarshal.SymbolMatching UnionType where
  matchedSymbols _ = [278]
  showFailure _ node_1192 =
    "expected "
      GHC.Base.<> ( "union_type"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1192 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1192) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1193 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1194 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1195 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1196 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1193
        c1_1194 = TreeSitter.Node.nodeStartPoint node_1192
      TreeSitter.Node.TSPoint
        r2_1195
        c2_1196 = TreeSitter.Node.nodeEndPoint node_1192

deriving instance GHC.Classes.Eq a_1197 => GHC.Classes.Eq (UnionType a_1197)

deriving instance GHC.Classes.Ord a_1198 => GHC.Classes.Ord (UnionType a_1198)

deriving instance GHC.Show.Show a_1199 => GHC.Show.Show (UnionType a_1199)

instance AST.Unmarshal.Unmarshal UnionType

instance Data.Foldable.Foldable UnionType where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor UnionType where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable UnionType where
  traverse = AST.Traversable1.Class.traverseDefault1

data UpdateExpression a = UpdateExpression
  { ann :: a,
    operator :: (AST.Parse.Err ((AnonymousPlusPlus GHC.Generics.:+: AnonymousMinusMinus) a)),
    argument :: (AST.Parse.Err (Expression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1200.
      AST.Traversable1.Class.Traversable1 a_1200
    )

instance AST.Unmarshal.SymbolMatching UpdateExpression where
  matchedSymbols _ = [206]
  showFailure _ node_1201 =
    "expected "
      GHC.Base.<> ( "update_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1201 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1201) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1202 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1203 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1204 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1205 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1202
        c1_1203 = TreeSitter.Node.nodeStartPoint node_1201
      TreeSitter.Node.TSPoint
        r2_1204
        c2_1205 = TreeSitter.Node.nodeEndPoint node_1201

deriving instance GHC.Classes.Eq a_1206 => GHC.Classes.Eq (UpdateExpression a_1206)

deriving instance GHC.Classes.Ord a_1207 => GHC.Classes.Ord (UpdateExpression a_1207)

deriving instance GHC.Show.Show a_1208 => GHC.Show.Show (UpdateExpression a_1208)

instance AST.Unmarshal.Unmarshal UpdateExpression

instance Data.Foldable.Foldable UpdateExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor UpdateExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable UpdateExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

data VariableDeclaration a = VariableDeclaration
  { ann :: a,
    extraChildren :: (GHC.Base.NonEmpty (AST.Parse.Err (VariableDeclarator a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1209.
      AST.Traversable1.Class.Traversable1 a_1209
    )

instance AST.Unmarshal.SymbolMatching VariableDeclaration where
  matchedSymbols _ = [153]
  showFailure _ node_1210 =
    "expected "
      GHC.Base.<> ( "variable_declaration"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1210 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1210) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1211 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1212 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1213 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1214 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1211
        c1_1212 = TreeSitter.Node.nodeStartPoint node_1210
      TreeSitter.Node.TSPoint
        r2_1213
        c2_1214 = TreeSitter.Node.nodeEndPoint node_1210

deriving instance GHC.Classes.Eq a_1215 => GHC.Classes.Eq (VariableDeclaration a_1215)

deriving instance GHC.Classes.Ord a_1216 => GHC.Classes.Ord (VariableDeclaration a_1216)

deriving instance GHC.Show.Show a_1217 => GHC.Show.Show (VariableDeclaration a_1217)

instance AST.Unmarshal.Unmarshal VariableDeclaration

instance Data.Foldable.Foldable VariableDeclaration where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor VariableDeclaration where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable VariableDeclaration where
  traverse = AST.Traversable1.Class.traverseDefault1

data VariableDeclarator a = VariableDeclarator
  { ann :: a,
    value :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a))),
    name :: (AST.Parse.Err ((DestructuringPattern GHC.Generics.:+: Identifier) a)),
    type' :: (GHC.Maybe.Maybe (AST.Parse.Err (TypeAnnotation a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1218.
      AST.Traversable1.Class.Traversable1 a_1218
    )

instance AST.Unmarshal.SymbolMatching VariableDeclarator where
  matchedSymbols _ = [155]
  showFailure _ node_1219 =
    "expected "
      GHC.Base.<> ( "variable_declarator"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1219 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1219) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1220 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1221 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1222 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1223 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1220
        c1_1221 = TreeSitter.Node.nodeStartPoint node_1219
      TreeSitter.Node.TSPoint
        r2_1222
        c2_1223 = TreeSitter.Node.nodeEndPoint node_1219

deriving instance GHC.Classes.Eq a_1224 => GHC.Classes.Eq (VariableDeclarator a_1224)

deriving instance GHC.Classes.Ord a_1225 => GHC.Classes.Ord (VariableDeclarator a_1225)

deriving instance GHC.Show.Show a_1226 => GHC.Show.Show (VariableDeclarator a_1226)

instance AST.Unmarshal.Unmarshal VariableDeclarator

instance Data.Foldable.Foldable VariableDeclarator where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor VariableDeclarator where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable VariableDeclarator where
  traverse = AST.Traversable1.Class.traverseDefault1

data WhileStatement a = WhileStatement
  { ann :: a,
    body :: (AST.Parse.Err (Statement a)),
    condition :: (AST.Parse.Err (ParenthesizedExpression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1227.
      AST.Traversable1.Class.Traversable1 a_1227
    )

instance AST.Unmarshal.SymbolMatching WhileStatement where
  matchedSymbols _ = [162]
  showFailure _ node_1228 =
    "expected "
      GHC.Base.<> ( "while_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1228 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1228) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1229 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1230 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1231 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1232 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1229
        c1_1230 = TreeSitter.Node.nodeStartPoint node_1228
      TreeSitter.Node.TSPoint
        r2_1231
        c2_1232 = TreeSitter.Node.nodeEndPoint node_1228

deriving instance GHC.Classes.Eq a_1233 => GHC.Classes.Eq (WhileStatement a_1233)

deriving instance GHC.Classes.Ord a_1234 => GHC.Classes.Ord (WhileStatement a_1234)

deriving instance GHC.Show.Show a_1235 => GHC.Show.Show (WhileStatement a_1235)

instance AST.Unmarshal.Unmarshal WhileStatement

instance Data.Foldable.Foldable WhileStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor WhileStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable WhileStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data WithStatement a = WithStatement
  { ann :: a,
    body :: (AST.Parse.Err (Statement a)),
    object :: (AST.Parse.Err (ParenthesizedExpression a))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1236.
      AST.Traversable1.Class.Traversable1 a_1236
    )

instance AST.Unmarshal.SymbolMatching WithStatement where
  matchedSymbols _ = [165]
  showFailure _ node_1237 =
    "expected "
      GHC.Base.<> ( "with_statement"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1237 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1237) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1238 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1239 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1240 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1241 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1238
        c1_1239 = TreeSitter.Node.nodeStartPoint node_1237
      TreeSitter.Node.TSPoint
        r2_1240
        c2_1241 = TreeSitter.Node.nodeEndPoint node_1237

deriving instance GHC.Classes.Eq a_1242 => GHC.Classes.Eq (WithStatement a_1242)

deriving instance GHC.Classes.Ord a_1243 => GHC.Classes.Ord (WithStatement a_1243)

deriving instance GHC.Show.Show a_1244 => GHC.Show.Show (WithStatement a_1244)

instance AST.Unmarshal.Unmarshal WithStatement

instance Data.Foldable.Foldable WithStatement where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor WithStatement where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable WithStatement where
  traverse = AST.Traversable1.Class.traverseDefault1

data YieldExpression a = YieldExpression
  { ann :: a,
    extraChildren :: (GHC.Maybe.Maybe (AST.Parse.Err (Expression a)))
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1245.
      AST.Traversable1.Class.Traversable1 a_1245
    )

instance AST.Unmarshal.SymbolMatching YieldExpression where
  matchedSymbols _ = [180]
  showFailure _ node_1246 =
    "expected "
      GHC.Base.<> ( "yield_expression"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1246 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1246) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1247 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1248 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1249 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1250 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1247
        c1_1248 = TreeSitter.Node.nodeStartPoint node_1246
      TreeSitter.Node.TSPoint
        r2_1249
        c2_1250 = TreeSitter.Node.nodeEndPoint node_1246

deriving instance GHC.Classes.Eq a_1251 => GHC.Classes.Eq (YieldExpression a_1251)

deriving instance GHC.Classes.Ord a_1252 => GHC.Classes.Ord (YieldExpression a_1252)

deriving instance GHC.Show.Show a_1253 => GHC.Show.Show (YieldExpression a_1253)

instance AST.Unmarshal.Unmarshal YieldExpression

instance Data.Foldable.Foldable YieldExpression where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor YieldExpression where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable YieldExpression where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousBang = AST.Token.Token "!" 88

type AnonymousBangEqual = AST.Token.Token "!=" 83

type AnonymousBangEqualEqual = AST.Token.Token "!==" 84

type AnonymousDQuote = AST.Token.Token "\"" 94

type AnonymousDollarLBrace = AST.Token.Token "${" 101

type AnonymousPercent = AST.Token.Token "%" 78

type AnonymousPercentEqual = AST.Token.Token "%=" 58

type AnonymousAmpersand = AST.Token.Token "&" 73

type AnonymousAmpersandAmpersand = AST.Token.Token "&&" 68

type AnonymousAmpersandEqual = AST.Token.Token "&=" 60

type AnonymousSQuote = AST.Token.Token "'" 96

type AnonymousLParen = AST.Token.Token "(" 23

type AnonymousRParen = AST.Token.Token ")" 24

type AnonymousStar = AST.Token.Token "*" 4

type AnonymousStarStar = AST.Token.Token "**" 79

type AnonymousStarStarEqual = AST.Token.Token "**=" 65

type AnonymousStarEqual = AST.Token.Token "*=" 56

type AnonymousPlus = AST.Token.Token "+" 76

type AnonymousPlusPlus = AST.Token.Token "++" 92

type AnonymousPlusEqual = AST.Token.Token "+=" 54

type AnonymousComma = AST.Token.Token "," 10

type AnonymousMinus = AST.Token.Token "-" 77

type AnonymousMinusMinus = AST.Token.Token "--" 93

type AnonymousMinusEqual = AST.Token.Token "-=" 55

type AnonymousDot = AST.Token.Token "." 48

type AnonymousDotDotDot = AST.Token.Token "..." 66

type AnonymousSlash = AST.Token.Token "/" 47

type AnonymousSlashEqual = AST.Token.Token "/=" 57

type AnonymousColon = AST.Token.Token ":" 38

type AnonymousSemicolon = AST.Token.Token ";" 37

type AnonymousLAngle = AST.Token.Token "<" 45

type AnonymousLAngleLAngle = AST.Token.Token "<<" 72

type AnonymousLAngleLAngleEqual = AST.Token.Token "<<=" 64

type AnonymousLAngleEqual = AST.Token.Token "<=" 80

type AnonymousEqual = AST.Token.Token "=" 6

type AnonymousEqualEqual = AST.Token.Token "==" 81

type AnonymousEqualEqualEqual = AST.Token.Token "===" 82

type AnonymousEqualRAngle = AST.Token.Token "=>" 52

type AnonymousRAngle = AST.Token.Token ">" 46

type AnonymousRAngleEqual = AST.Token.Token ">=" 85

type AnonymousRAngleRAngle = AST.Token.Token ">>" 70

type AnonymousRAngleRAngleEqual = AST.Token.Token ">>=" 62

type AnonymousRAngleRAngleRAngle = AST.Token.Token ">>>" 71

type AnonymousRAngleRAngleRAngleEqual = AST.Token.Token ">>>=" 63

type AnonymousQuestion = AST.Token.Token "?" 67

type AnonymousQuestionQuestion = AST.Token.Token "??" 86

type AnonymousAt = AST.Token.Token "@" 113

type AnonymousLBracket = AST.Token.Token "[" 43

type AnonymousRBracket = AST.Token.Token "]" 44

type AnonymousCaret = AST.Token.Token "^" 74

type AnonymousCaretEqual = AST.Token.Token "^=" 59

type AnonymousBacktick = AST.Token.Token "`" 100

type AnonymousAbstract = AST.Token.Token "abstract" 115

type AnonymousAny = AST.Token.Token "any" 123

type AnonymousAs = AST.Token.Token "as" 7

type AnonymousAsync = AST.Token.Token "async" 50

type AnonymousAwait = AST.Token.Token "await" 25

type AnonymousBoolean = AST.Token.Token "boolean" 125

type AnonymousBreak = AST.Token.Token "break" 32

type AnonymousCase = AST.Token.Token "case" 39

type AnonymousCatch = AST.Token.Token "catch" 40

type AnonymousClass = AST.Token.Token "class" 49

type AnonymousConst = AST.Token.Token "const" 18

type AnonymousContinue = AST.Token.Token "continue" 33

type AnonymousDebugger = AST.Token.Token "debugger" 34

type AnonymousDeclare = AST.Token.Token "declare" 118

type AnonymousDefault = AST.Token.Token "default" 5

type AnonymousDelete = AST.Token.Token "delete" 91

type AnonymousDo = AST.Token.Token "do" 29

type AnonymousElse = AST.Token.Token "else" 20

type AnonymousEnum = AST.Token.Token "enum" 133

data EscapeSequence a = EscapeSequence {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1254.
      AST.Traversable1.Class.Traversable1 a_1254
    )

instance AST.Unmarshal.SymbolMatching EscapeSequence where
  matchedSymbols _ = [98]
  showFailure _ node_1255 =
    "expected "
      GHC.Base.<> ( "escape_sequence"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1255 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1255) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1256 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1257 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1258 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1259 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1256
        c1_1257 = TreeSitter.Node.nodeStartPoint node_1255
      TreeSitter.Node.TSPoint
        r2_1258
        c2_1259 = TreeSitter.Node.nodeEndPoint node_1255

deriving instance GHC.Classes.Eq a_1260 => GHC.Classes.Eq (EscapeSequence a_1260)

deriving instance GHC.Classes.Ord a_1261 => GHC.Classes.Ord (EscapeSequence a_1261)

deriving instance GHC.Show.Show a_1262 => GHC.Show.Show (EscapeSequence a_1262)

instance AST.Unmarshal.Unmarshal EscapeSequence

instance Data.Foldable.Foldable EscapeSequence where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor EscapeSequence where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable EscapeSequence where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousExport = AST.Token.Token "export" 3

type AnonymousExtends = AST.Token.Token "extends" 132

data False a = False {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1263.
      AST.Traversable1.Class.Traversable1 a_1263
    )

instance AST.Unmarshal.SymbolMatching False where
  matchedSymbols _ = [110]
  showFailure _ node_1264 =
    "expected "
      GHC.Base.<> ( "false"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1264 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1264) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1265 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1266 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1267 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1268 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1265
        c1_1266 = TreeSitter.Node.nodeStartPoint node_1264
      TreeSitter.Node.TSPoint
        r2_1267
        c2_1268 = TreeSitter.Node.nodeEndPoint node_1264

deriving instance GHC.Classes.Eq a_1269 => GHC.Classes.Eq (False a_1269)

deriving instance GHC.Classes.Ord a_1270 => GHC.Classes.Ord (False a_1270)

deriving instance GHC.Show.Show a_1271 => GHC.Show.Show (False a_1271)

instance AST.Unmarshal.Unmarshal False

instance Data.Foldable.Foldable False where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor False where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable False where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousFinally = AST.Token.Token "finally" 41

type AnonymousFor = AST.Token.Token "for" 22

type AnonymousFrom = AST.Token.Token "from" 15

type AnonymousFunction = AST.Token.Token "function" 51

type AnonymousGet = AST.Token.Token "get" 116

type AnonymousGlobal = AST.Token.Token "global" 130

data HashBangLine a = HashBangLine {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1272.
      AST.Traversable1.Class.Traversable1 a_1272
    )

instance AST.Unmarshal.SymbolMatching HashBangLine where
  matchedSymbols _ = [2]
  showFailure _ node_1273 =
    "expected "
      GHC.Base.<> ( "hash_bang_line"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1273 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1273) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1274 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1275 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1276 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1277 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1274
        c1_1275 = TreeSitter.Node.nodeStartPoint node_1273
      TreeSitter.Node.TSPoint
        r2_1276
        c2_1277 = TreeSitter.Node.nodeEndPoint node_1273

deriving instance GHC.Classes.Eq a_1278 => GHC.Classes.Eq (HashBangLine a_1278)

deriving instance GHC.Classes.Ord a_1279 => GHC.Classes.Ord (HashBangLine a_1279)

deriving instance GHC.Show.Show a_1280 => GHC.Show.Show (HashBangLine a_1280)

instance AST.Unmarshal.Unmarshal HashBangLine

instance Data.Foldable.Foldable HashBangLine where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor HashBangLine where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable HashBangLine where
  traverse = AST.Traversable1.Class.traverseDefault1

data Identifier a = Identifier {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1281.
      AST.Traversable1.Class.Traversable1 a_1281
    )

instance AST.Unmarshal.SymbolMatching Identifier where
  matchedSymbols _ = [1]
  showFailure _ node_1282 =
    "expected "
      GHC.Base.<> ( "identifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1282 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1282) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1283 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1284 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1285 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1286 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1283
        c1_1284 = TreeSitter.Node.nodeStartPoint node_1282
      TreeSitter.Node.TSPoint
        r2_1285
        c2_1286 = TreeSitter.Node.nodeEndPoint node_1282

deriving instance GHC.Classes.Eq a_1287 => GHC.Classes.Eq (Identifier a_1287)

deriving instance GHC.Classes.Ord a_1288 => GHC.Classes.Ord (Identifier a_1288)

deriving instance GHC.Show.Show a_1289 => GHC.Show.Show (Identifier a_1289)

instance AST.Unmarshal.Unmarshal Identifier

instance Data.Foldable.Foldable Identifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Identifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Identifier where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousIf = AST.Token.Token "if" 19

type AnonymousImplements = AST.Token.Token "implements" 129

type AnonymousImport = AST.Token.Token "import" 14

type AnonymousIn = AST.Token.Token "in" 26

type AnonymousInstanceof = AST.Token.Token "instanceof" 87

type AnonymousInterface = AST.Token.Token "interface" 131

type AnonymousIs = AST.Token.Token "is" 135

data JsxText a = JsxText {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1290.
      AST.Traversable1.Class.Traversable1 a_1290
    )

instance AST.Unmarshal.SymbolMatching JsxText where
  matchedSymbols _ = []
  showFailure _ node_1291 =
    "expected "
      GHC.Base.<> ( ""
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1291 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1291) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1292 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1293 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1294 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1295 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1292
        c1_1293 = TreeSitter.Node.nodeStartPoint node_1291
      TreeSitter.Node.TSPoint
        r2_1294
        c2_1295 = TreeSitter.Node.nodeEndPoint node_1291

deriving instance GHC.Classes.Eq a_1296 => GHC.Classes.Eq (JsxText a_1296)

deriving instance GHC.Classes.Ord a_1297 => GHC.Classes.Ord (JsxText a_1297)

deriving instance GHC.Show.Show a_1298 => GHC.Show.Show (JsxText a_1298)

instance AST.Unmarshal.Unmarshal JsxText

instance Data.Foldable.Foldable JsxText where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor JsxText where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable JsxText where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousKeyof = AST.Token.Token "keyof" 136

type AnonymousLet = AST.Token.Token "let" 17

type AnonymousModule = AST.Token.Token "module" 122

type AnonymousNamespace = AST.Token.Token "namespace" 8

type AnonymousNew = AST.Token.Token "new" 53

data Null a = Null {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1299.
      AST.Traversable1.Class.Traversable1 a_1299
    )

instance AST.Unmarshal.SymbolMatching Null where
  matchedSymbols _ = [111]
  showFailure _ node_1300 =
    "expected "
      GHC.Base.<> ( "null"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1300 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1300) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1301 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1302 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1303 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1304 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1301
        c1_1302 = TreeSitter.Node.nodeStartPoint node_1300
      TreeSitter.Node.TSPoint
        r2_1303
        c2_1304 = TreeSitter.Node.nodeEndPoint node_1300

deriving instance GHC.Classes.Eq a_1305 => GHC.Classes.Eq (Null a_1305)

deriving instance GHC.Classes.Ord a_1306 => GHC.Classes.Ord (Null a_1306)

deriving instance GHC.Show.Show a_1307 => GHC.Show.Show (Null a_1307)

instance AST.Unmarshal.Unmarshal Null

instance Data.Foldable.Foldable Null where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Null where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Null where
  traverse = AST.Traversable1.Class.traverseDefault1

data Number a = Number {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1308.
      AST.Traversable1.Class.Traversable1 a_1308
    )

instance AST.Unmarshal.SymbolMatching Number where
  matchedSymbols _ = [105]
  showFailure _ node_1309 =
    "expected "
      GHC.Base.<> ( "number"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1309 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1309) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1310 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1311 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1312 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1313 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1310
        c1_1311 = TreeSitter.Node.nodeStartPoint node_1309
      TreeSitter.Node.TSPoint
        r2_1312
        c2_1313 = TreeSitter.Node.nodeEndPoint node_1309

deriving instance GHC.Classes.Eq a_1314 => GHC.Classes.Eq (Number a_1314)

deriving instance GHC.Classes.Ord a_1315 => GHC.Classes.Ord (Number a_1315)

deriving instance GHC.Show.Show a_1316 => GHC.Show.Show (Number a_1316)

instance AST.Unmarshal.Unmarshal Number

instance Data.Foldable.Foldable Number where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Number where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Number where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousNumber = AST.Token.Token "number" 124

type AnonymousOf = AST.Token.Token "of" 27

type AnonymousPrivate = AST.Token.Token "private" 120

data PropertyIdentifier a = PropertyIdentifier {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1317.
      AST.Traversable1.Class.Traversable1 a_1317
    )

instance AST.Unmarshal.SymbolMatching PropertyIdentifier where
  matchedSymbols _ = [303]
  showFailure _ node_1318 =
    "expected "
      GHC.Base.<> ( "property_identifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1318 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1318) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1319 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1320 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1321 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1322 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1319
        c1_1320 = TreeSitter.Node.nodeStartPoint node_1318
      TreeSitter.Node.TSPoint
        r2_1321
        c2_1322 = TreeSitter.Node.nodeEndPoint node_1318

deriving instance GHC.Classes.Eq a_1323 => GHC.Classes.Eq (PropertyIdentifier a_1323)

deriving instance GHC.Classes.Ord a_1324 => GHC.Classes.Ord (PropertyIdentifier a_1324)

deriving instance GHC.Show.Show a_1325 => GHC.Show.Show (PropertyIdentifier a_1325)

instance AST.Unmarshal.Unmarshal PropertyIdentifier

instance Data.Foldable.Foldable PropertyIdentifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor PropertyIdentifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable PropertyIdentifier where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousProtected = AST.Token.Token "protected" 121

type AnonymousPublic = AST.Token.Token "public" 119

data Readonly a = Readonly {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1326.
      AST.Traversable1.Class.Traversable1 a_1326
    )

instance AST.Unmarshal.SymbolMatching Readonly where
  matchedSymbols _ = [134]
  showFailure _ node_1327 =
    "expected "
      GHC.Base.<> ( "readonly"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1327 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1327) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1328 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1329 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1330 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1331 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1328
        c1_1329 = TreeSitter.Node.nodeStartPoint node_1327
      TreeSitter.Node.TSPoint
        r2_1330
        c2_1331 = TreeSitter.Node.nodeEndPoint node_1327

deriving instance GHC.Classes.Eq a_1332 => GHC.Classes.Eq (Readonly a_1332)

deriving instance GHC.Classes.Ord a_1333 => GHC.Classes.Ord (Readonly a_1333)

deriving instance GHC.Show.Show a_1334 => GHC.Show.Show (Readonly a_1334)

instance AST.Unmarshal.Unmarshal Readonly

instance Data.Foldable.Foldable Readonly where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Readonly where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Readonly where
  traverse = AST.Traversable1.Class.traverseDefault1

data RegexFlags a = RegexFlags {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1335.
      AST.Traversable1.Class.Traversable1 a_1335
    )

instance AST.Unmarshal.SymbolMatching RegexFlags where
  matchedSymbols _ = [104]
  showFailure _ node_1336 =
    "expected "
      GHC.Base.<> ( "regex_flags"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1336 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1336) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1337 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1338 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1339 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1340 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1337
        c1_1338 = TreeSitter.Node.nodeStartPoint node_1336
      TreeSitter.Node.TSPoint
        r2_1339
        c2_1340 = TreeSitter.Node.nodeEndPoint node_1336

deriving instance GHC.Classes.Eq a_1341 => GHC.Classes.Eq (RegexFlags a_1341)

deriving instance GHC.Classes.Ord a_1342 => GHC.Classes.Ord (RegexFlags a_1342)

deriving instance GHC.Show.Show a_1343 => GHC.Show.Show (RegexFlags a_1343)

instance AST.Unmarshal.Unmarshal RegexFlags

instance Data.Foldable.Foldable RegexFlags where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor RegexFlags where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable RegexFlags where
  traverse = AST.Traversable1.Class.traverseDefault1

data RegexPattern a = RegexPattern {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1344.
      AST.Traversable1.Class.Traversable1 a_1344
    )

instance AST.Unmarshal.SymbolMatching RegexPattern where
  matchedSymbols _ = [103]
  showFailure _ node_1345 =
    "expected "
      GHC.Base.<> ( "regex_pattern"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1345 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1345) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1346 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1347 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1348 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1349 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1346
        c1_1347 = TreeSitter.Node.nodeStartPoint node_1345
      TreeSitter.Node.TSPoint
        r2_1348
        c2_1349 = TreeSitter.Node.nodeEndPoint node_1345

deriving instance GHC.Classes.Eq a_1350 => GHC.Classes.Eq (RegexPattern a_1350)

deriving instance GHC.Classes.Ord a_1351 => GHC.Classes.Ord (RegexPattern a_1351)

deriving instance GHC.Show.Show a_1352 => GHC.Show.Show (RegexPattern a_1352)

instance AST.Unmarshal.Unmarshal RegexPattern

instance Data.Foldable.Foldable RegexPattern where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor RegexPattern where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable RegexPattern where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousRequire = AST.Token.Token "require" 128

type AnonymousReturn = AST.Token.Token "return" 35

type AnonymousSet = AST.Token.Token "set" 117

data ShorthandPropertyIdentifier a = ShorthandPropertyIdentifier
  { ann :: a,
    text :: Data.Text.Internal.Text
  }
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1353.
      AST.Traversable1.Class.Traversable1 a_1353
    )

instance AST.Unmarshal.SymbolMatching ShorthandPropertyIdentifier where
  matchedSymbols _ = [304]
  showFailure _ node_1354 =
    "expected "
      GHC.Base.<> ( "shorthand_property_identifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1354 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1354) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1355 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1356 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1357 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1358 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1355
        c1_1356 = TreeSitter.Node.nodeStartPoint node_1354
      TreeSitter.Node.TSPoint
        r2_1357
        c2_1358 = TreeSitter.Node.nodeEndPoint node_1354

deriving instance GHC.Classes.Eq a_1359 => GHC.Classes.Eq (ShorthandPropertyIdentifier a_1359)

deriving instance GHC.Classes.Ord a_1360 => GHC.Classes.Ord (ShorthandPropertyIdentifier a_1360)

deriving instance GHC.Show.Show a_1361 => GHC.Show.Show (ShorthandPropertyIdentifier a_1361)

instance AST.Unmarshal.Unmarshal ShorthandPropertyIdentifier

instance Data.Foldable.Foldable ShorthandPropertyIdentifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor ShorthandPropertyIdentifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable ShorthandPropertyIdentifier where
  traverse = AST.Traversable1.Class.traverseDefault1

data StatementIdentifier a = StatementIdentifier {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1362.
      AST.Traversable1.Class.Traversable1 a_1362
    )

instance AST.Unmarshal.SymbolMatching StatementIdentifier where
  matchedSymbols _ = [305]
  showFailure _ node_1363 =
    "expected "
      GHC.Base.<> ( "statement_identifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1363 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1363) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1364 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1365 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1366 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1367 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1364
        c1_1365 = TreeSitter.Node.nodeStartPoint node_1363
      TreeSitter.Node.TSPoint
        r2_1366
        c2_1367 = TreeSitter.Node.nodeEndPoint node_1363

deriving instance GHC.Classes.Eq a_1368 => GHC.Classes.Eq (StatementIdentifier a_1368)

deriving instance GHC.Classes.Ord a_1369 => GHC.Classes.Ord (StatementIdentifier a_1369)

deriving instance GHC.Show.Show a_1370 => GHC.Show.Show (StatementIdentifier a_1370)

instance AST.Unmarshal.Unmarshal StatementIdentifier

instance Data.Foldable.Foldable StatementIdentifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor StatementIdentifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable StatementIdentifier where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousStatic = AST.Token.Token "static" 114

type AnonymousString = AST.Token.Token "string" 126

data Super a = Super {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1371.
      AST.Traversable1.Class.Traversable1 a_1371
    )

instance AST.Unmarshal.SymbolMatching Super where
  matchedSymbols _ = [108]
  showFailure _ node_1372 =
    "expected "
      GHC.Base.<> ( "super"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1372 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1372) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1373 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1374 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1375 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1376 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1373
        c1_1374 = TreeSitter.Node.nodeStartPoint node_1372
      TreeSitter.Node.TSPoint
        r2_1375
        c2_1376 = TreeSitter.Node.nodeEndPoint node_1372

deriving instance GHC.Classes.Eq a_1377 => GHC.Classes.Eq (Super a_1377)

deriving instance GHC.Classes.Ord a_1378 => GHC.Classes.Ord (Super a_1378)

deriving instance GHC.Show.Show a_1379 => GHC.Show.Show (Super a_1379)

instance AST.Unmarshal.Unmarshal Super

instance Data.Foldable.Foldable Super where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Super where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Super where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousSwitch = AST.Token.Token "switch" 21

type AnonymousSymbol = AST.Token.Token "symbol" 127

type AnonymousTarget = AST.Token.Token "target" 106

data This a = This {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1380.
      AST.Traversable1.Class.Traversable1 a_1380
    )

instance AST.Unmarshal.SymbolMatching This where
  matchedSymbols _ = [107]
  showFailure _ node_1381 =
    "expected "
      GHC.Base.<> ( "this"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1381 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1381) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1382 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1383 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1384 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1385 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1382
        c1_1383 = TreeSitter.Node.nodeStartPoint node_1381
      TreeSitter.Node.TSPoint
        r2_1384
        c2_1385 = TreeSitter.Node.nodeEndPoint node_1381

deriving instance GHC.Classes.Eq a_1386 => GHC.Classes.Eq (This a_1386)

deriving instance GHC.Classes.Ord a_1387 => GHC.Classes.Ord (This a_1387)

deriving instance GHC.Show.Show a_1388 => GHC.Show.Show (This a_1388)

instance AST.Unmarshal.Unmarshal This

instance Data.Foldable.Foldable This where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor This where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable This where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousThrow = AST.Token.Token "throw" 36

data True a = True {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1389.
      AST.Traversable1.Class.Traversable1 a_1389
    )

instance AST.Unmarshal.SymbolMatching True where
  matchedSymbols _ = [109]
  showFailure _ node_1390 =
    "expected "
      GHC.Base.<> ( "true"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1390 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1390) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1391 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1392 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1393 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1394 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1391
        c1_1392 = TreeSitter.Node.nodeStartPoint node_1390
      TreeSitter.Node.TSPoint
        r2_1393
        c2_1394 = TreeSitter.Node.nodeEndPoint node_1390

deriving instance GHC.Classes.Eq a_1395 => GHC.Classes.Eq (True a_1395)

deriving instance GHC.Classes.Ord a_1396 => GHC.Classes.Ord (True a_1396)

deriving instance GHC.Show.Show a_1397 => GHC.Show.Show (True a_1397)

instance AST.Unmarshal.Unmarshal True

instance Data.Foldable.Foldable True where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor True where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable True where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousTry = AST.Token.Token "try" 30

type AnonymousType = AST.Token.Token "type" 12

data TypeIdentifier a = TypeIdentifier {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1398.
      AST.Traversable1.Class.Traversable1 a_1398
    )

instance AST.Unmarshal.SymbolMatching TypeIdentifier where
  matchedSymbols _ = [306]
  showFailure _ node_1399 =
    "expected "
      GHC.Base.<> ( "type_identifier"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1399 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1399) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1400 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1401 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1402 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1403 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1400
        c1_1401 = TreeSitter.Node.nodeStartPoint node_1399
      TreeSitter.Node.TSPoint
        r2_1402
        c2_1403 = TreeSitter.Node.nodeEndPoint node_1399

deriving instance GHC.Classes.Eq a_1404 => GHC.Classes.Eq (TypeIdentifier a_1404)

deriving instance GHC.Classes.Ord a_1405 => GHC.Classes.Ord (TypeIdentifier a_1405)

deriving instance GHC.Show.Show a_1406 => GHC.Show.Show (TypeIdentifier a_1406)

instance AST.Unmarshal.Unmarshal TypeIdentifier

instance Data.Foldable.Foldable TypeIdentifier where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor TypeIdentifier where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable TypeIdentifier where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousTypeof = AST.Token.Token "typeof" 13

data Undefined a = Undefined {ann :: a, text :: Data.Text.Internal.Text}
  deriving stock (GHC.Generics.Generic, GHC.Generics.Generic1)
  deriving anyclass
    ( forall a_1407.
      AST.Traversable1.Class.Traversable1 a_1407
    )

instance AST.Unmarshal.SymbolMatching Undefined where
  matchedSymbols _ = [112]
  showFailure _ node_1408 =
    "expected "
      GHC.Base.<> ( "undefined"
                      GHC.Base.<> ( " but got "
                                      GHC.Base.<> ( if TreeSitter.Node.nodeSymbol node_1408 GHC.Classes.== 65535
                                                      then "ERROR"
                                                      else Data.OldList.genericIndex debugSymbolNames (TreeSitter.Node.nodeSymbol node_1408) GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r1_1409 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c1_1410 GHC.Base.<> ("] -" GHC.Base.<> (" [" GHC.Base.<> (GHC.Show.show r2_1411 GHC.Base.<> (", " GHC.Base.<> (GHC.Show.show c2_1412 GHC.Base.<> "]")))))))))
                                                  )
                                  )
                  )
    where
      TreeSitter.Node.TSPoint
        r1_1409
        c1_1410 = TreeSitter.Node.nodeStartPoint node_1408
      TreeSitter.Node.TSPoint
        r2_1411
        c2_1412 = TreeSitter.Node.nodeEndPoint node_1408

deriving instance GHC.Classes.Eq a_1413 => GHC.Classes.Eq (Undefined a_1413)

deriving instance GHC.Classes.Ord a_1414 => GHC.Classes.Ord (Undefined a_1414)

deriving instance GHC.Show.Show a_1415 => GHC.Show.Show (Undefined a_1415)

instance AST.Unmarshal.Unmarshal Undefined

instance Data.Foldable.Foldable Undefined where
  foldMap = AST.Traversable1.Class.foldMapDefault1

instance GHC.Base.Functor Undefined where
  fmap = AST.Traversable1.Class.fmapDefault1

instance Data.Traversable.Traversable Undefined where
  traverse = AST.Traversable1.Class.traverseDefault1

type AnonymousVar = AST.Token.Token "var" 16

type AnonymousVoid = AST.Token.Token "void" 90

type AnonymousWhile = AST.Token.Token "while" 28

type AnonymousWith = AST.Token.Token "with" 31

type AnonymousYield = AST.Token.Token "yield" 42

type AnonymousLBrace = AST.Token.Token "{" 9

type AnonymousLBracePipe = AST.Token.Token "{|" 137

type AnonymousPipe = AST.Token.Token "|" 75

type AnonymousPipeEqual = AST.Token.Token "|=" 61

type AnonymousPipePipe = AST.Token.Token "||" 69

type AnonymousPipeRBrace = AST.Token.Token "|}" 138

type AnonymousRBrace = AST.Token.Token "}" 11

type AnonymousTilde = AST.Token.Token "~" 89
