content: -- 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
  