visitor.go

// Code generated by script/visitor_gen. DO NOT EDIT.

//go:generate go run github.com/hsiaosiyuan0/mole/script/visitor_gen -d=../parser

package walk

import (
	"errors"

	"github.com/hsiaosiyuan0/mole/ecma/parser"
	"github.com/hsiaosiyuan0/mole/util"
)

const (
	N_CATCH                 = parser.N_CATCH
	N_CLASS_BODY            = parser.N_CLASS_BODY
	N_DECORATOR             = parser.N_DECORATOR
	N_EXPORT_SPEC           = parser.N_EXPORT_SPEC
	N_EXPR_ARROW            = parser.N_EXPR_ARROW
	N_EXPR_ASSIGN           = parser.N_EXPR_ASSIGN
	N_EXPR_BIN              = parser.N_EXPR_BIN
	N_EXPR_CALL             = parser.N_EXPR_CALL
	N_EXPR_CHAIN            = parser.N_EXPR_CHAIN
	N_EXPR_CLASS            = parser.N_EXPR_CLASS
	N_EXPR_COND             = parser.N_EXPR_COND
	N_EXPR_FN               = parser.N_EXPR_FN
	N_EXPR_MEMBER           = parser.N_EXPR_MEMBER
	N_EXPR_NEW              = parser.N_EXPR_NEW
	N_EXPR_PAREN            = parser.N_EXPR_PAREN
	N_EXPR_SEQ              = parser.N_EXPR_SEQ
	N_EXPR_THIS             = parser.N_EXPR_THIS
	N_EXPR_TPL              = parser.N_EXPR_TPL
	N_EXPR_UNARY            = parser.N_EXPR_UNARY
	N_EXPR_UPDATE           = parser.N_EXPR_UPDATE
	N_EXPR_YIELD            = parser.N_EXPR_YIELD
	N_FIELD                 = parser.N_FIELD
	N_IMPORT_CALL           = parser.N_IMPORT_CALL
	N_IMPORT_SPEC           = parser.N_IMPORT_SPEC
	N_JSX_ATTR              = parser.N_JSX_ATTR
	N_JSX_ATTR_SPREAD       = parser.N_JSX_ATTR_SPREAD
	N_JSX_CHILD_SPREAD      = parser.N_JSX_CHILD_SPREAD
	N_JSX_CLOSE             = parser.N_JSX_CLOSE
	N_JSX_ELEM              = parser.N_JSX_ELEM
	N_JSX_EMPTY             = parser.N_JSX_EMPTY
	N_JSX_EXPR_SPAN         = parser.N_JSX_EXPR_SPAN
	N_JSX_ID                = parser.N_JSX_ID
	N_JSX_MEMBER            = parser.N_JSX_MEMBER
	N_JSX_NS                = parser.N_JSX_NS
	N_JSX_OPEN              = parser.N_JSX_OPEN
	N_JSX_TXT               = parser.N_JSX_TXT
	N_LIT_ARR               = parser.N_LIT_ARR
	N_LIT_BOOL              = parser.N_LIT_BOOL
	N_LIT_NULL              = parser.N_LIT_NULL
	N_LIT_NUM               = parser.N_LIT_NUM
	N_LIT_OBJ               = parser.N_LIT_OBJ
	N_LIT_REGEXP            = parser.N_LIT_REGEXP
	N_LIT_STR               = parser.N_LIT_STR
	N_META_PROP             = parser.N_META_PROP
	N_METHOD                = parser.N_METHOD
	N_NAME                  = parser.N_NAME
	N_PAT_ARRAY             = parser.N_PAT_ARRAY
	N_PAT_ASSIGN            = parser.N_PAT_ASSIGN
	N_PAT_OBJ               = parser.N_PAT_OBJ
	N_PAT_REST              = parser.N_PAT_REST
	N_PROG                  = parser.N_PROG
	N_PROP                  = parser.N_PROP
	N_SPREAD                = parser.N_SPREAD
	N_STATIC_BLOCK          = parser.N_STATIC_BLOCK
	N_STMT_BLOCK            = parser.N_STMT_BLOCK
	N_STMT_BRK              = parser.N_STMT_BRK
	N_STMT_CLASS            = parser.N_STMT_CLASS
	N_STMT_CONT             = parser.N_STMT_CONT
	N_STMT_DEBUG            = parser.N_STMT_DEBUG
	N_STMT_DO_WHILE         = parser.N_STMT_DO_WHILE
	N_STMT_EXPORT           = parser.N_STMT_EXPORT
	N_STMT_EXPR             = parser.N_STMT_EXPR
	N_STMT_FN               = parser.N_STMT_FN
	N_STMT_FOR              = parser.N_STMT_FOR
	N_STMT_FOR_IN_OF        = parser.N_STMT_FOR_IN_OF
	N_STMT_IF               = parser.N_STMT_IF
	N_STMT_IMPORT           = parser.N_STMT_IMPORT
	N_STMT_LABEL            = parser.N_STMT_LABEL
	N_STMT_RET              = parser.N_STMT_RET
	N_STMT_SWITCH           = parser.N_STMT_SWITCH
	N_STMT_THROW            = parser.N_STMT_THROW
	N_STMT_TRY              = parser.N_STMT_TRY
	N_STMT_VAR_DEC          = parser.N_STMT_VAR_DEC
	N_STMT_WHILE            = parser.N_STMT_WHILE
	N_STMT_WITH             = parser.N_STMT_WITH
	N_SUPER                 = parser.N_SUPER
	N_SWITCH_CASE           = parser.N_SWITCH_CASE
	N_TS_ANY                = parser.N_TS_ANY
	N_TS_ARR                = parser.N_TS_ARR
	N_TS_BIGINT             = parser.N_TS_BIGINT
	N_TS_BOOL               = parser.N_TS_BOOL
	N_TS_CALL_SIG           = parser.N_TS_CALL_SIG
	N_TS_COND               = parser.N_TS_COND
	N_TS_DEC_CLASS          = parser.N_TS_DEC_CLASS
	N_TS_DEC_ENUM           = parser.N_TS_DEC_ENUM
	N_TS_DEC_FN             = parser.N_TS_DEC_FN
	N_TS_DEC_GLOBAL         = parser.N_TS_DEC_GLOBAL
	N_TS_DEC_INTERFACE      = parser.N_TS_DEC_INTERFACE
	N_TS_DEC_MODULE         = parser.N_TS_DEC_MODULE
	N_TS_DEC_NS             = parser.N_TS_DEC_NS
	N_TS_DEC_TYP_DEC        = parser.N_TS_DEC_TYP_DEC
	N_TS_DEC_VAR_DEC        = parser.N_TS_DEC_VAR_DEC
	N_TS_ENUM               = parser.N_TS_ENUM
	N_TS_ENUM_MEMBER        = parser.N_TS_ENUM_MEMBER
	N_TS_EXPORT_ASSIGN      = parser.N_TS_EXPORT_ASSIGN
	N_TS_FN_TYP             = parser.N_TS_FN_TYP
	N_TS_IDX_ACCESS         = parser.N_TS_IDX_ACCESS
	N_TS_IDX_SIG            = parser.N_TS_IDX_SIG
	N_TS_IMPORT_ALIAS       = parser.N_TS_IMPORT_ALIAS
	N_TS_IMPORT_REQUIRE     = parser.N_TS_IMPORT_REQUIRE
	N_TS_IMPORT_TYP         = parser.N_TS_IMPORT_TYP
	N_TS_INTERFACE          = parser.N_TS_INTERFACE
	N_TS_INTERFACE_BODY     = parser.N_TS_INTERFACE_BODY
	N_TS_INTERSECT_TYP      = parser.N_TS_INTERSECT_TYP
	N_TS_INTRINSIC          = parser.N_TS_INTRINSIC
	N_TS_LIT                = parser.N_TS_LIT
	N_TS_LIT_OBJ            = parser.N_TS_LIT_OBJ
	N_TS_MAPPED             = parser.N_TS_MAPPED
	N_TS_NAMESPACE          = parser.N_TS_NAMESPACE
	N_TS_NEVER              = parser.N_TS_NEVER
	N_TS_NEW                = parser.N_TS_NEW
	N_TS_NEW_SIG            = parser.N_TS_NEW_SIG
	N_TS_NO_NULL            = parser.N_TS_NO_NULL
	N_TS_NS_NAME            = parser.N_TS_NS_NAME
	N_TS_NULL               = parser.N_TS_NULL
	N_TS_NUM                = parser.N_TS_NUM
	N_TS_OBJ                = parser.N_TS_OBJ
	N_TS_OPT                = parser.N_TS_OPT
	N_TS_PARAM              = parser.N_TS_PARAM
	N_TS_PARAM_DEC          = parser.N_TS_PARAM_DEC
	N_TS_PARAM_INST         = parser.N_TS_PARAM_INST
	N_TS_PAREN              = parser.N_TS_PAREN
	N_TS_PROP               = parser.N_TS_PROP
	N_TS_REF                = parser.N_TS_REF
	N_TS_REST               = parser.N_TS_REST
	N_TS_ROUGH_PARAM        = parser.N_TS_ROUGH_PARAM
	N_TS_STR                = parser.N_TS_STR
	N_TS_SYM                = parser.N_TS_SYM
	N_TS_THIS               = parser.N_TS_THIS
	N_TS_TUPLE              = parser.N_TS_TUPLE
	N_TS_TUPLE_NAMED_MEMBER = parser.N_TS_TUPLE_NAMED_MEMBER
	N_TS_TYP_ANNOT          = parser.N_TS_TYP_ANNOT
	N_TS_TYP_ASSERT         = parser.N_TS_TYP_ASSERT
	N_TS_TYP_DEC            = parser.N_TS_TYP_DEC
	N_TS_TYP_INFER          = parser.N_TS_TYP_INFER
	N_TS_TYP_OP             = parser.N_TS_TYP_OP
	N_TS_TYP_PREDICATE      = parser.N_TS_TYP_PREDICATE
	N_TS_TYP_QUERY          = parser.N_TS_TYP_QUERY
	N_TS_UNDEF              = parser.N_TS_UNDEF
	N_TS_UNION_TYP          = parser.N_TS_UNION_TYP
	N_TS_UNKNOWN            = parser.N_TS_UNKNOWN
	N_TS_VOID               = parser.N_TS_VOID
	N_VAR_DEC               = parser.N_VAR_DEC
)

const (
	N_BEFORE_AFTER_DEF_BEGIN       = parser.NodeType(parser.N_NODE_DEF_END + iota)
	N_CATCH_BEFORE                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CATCH)*2 - 1
	N_CATCH_AFTER                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CATCH)*2
	N_CLASS_BODY_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CLASS_BODY)*2 - 1
	N_CLASS_BODY_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CLASS_BODY)*2
	N_DECORATOR_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_DECORATOR)*2 - 1
	N_DECORATOR_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_DECORATOR)*2
	N_EXPORT_SPEC_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPORT_SPEC)*2 - 1
	N_EXPORT_SPEC_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPORT_SPEC)*2
	N_EXPR_ARROW_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ARROW)*2 - 1
	N_EXPR_ARROW_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ARROW)*2
	N_EXPR_ASSIGN_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ASSIGN)*2 - 1
	N_EXPR_ASSIGN_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ASSIGN)*2
	N_EXPR_BIN_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_BIN)*2 - 1
	N_EXPR_BIN_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_BIN)*2
	N_EXPR_CALL_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CALL)*2 - 1
	N_EXPR_CALL_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CALL)*2
	N_EXPR_CHAIN_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CHAIN)*2 - 1
	N_EXPR_CHAIN_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CHAIN)*2
	N_EXPR_CLASS_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CLASS)*2 - 1
	N_EXPR_CLASS_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CLASS)*2
	N_EXPR_COND_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_COND)*2 - 1
	N_EXPR_COND_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_COND)*2
	N_EXPR_FN_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_FN)*2 - 1
	N_EXPR_FN_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_FN)*2
	N_EXPR_MEMBER_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_MEMBER)*2 - 1
	N_EXPR_MEMBER_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_MEMBER)*2
	N_EXPR_NEW_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_NEW)*2 - 1
	N_EXPR_NEW_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_NEW)*2
	N_EXPR_PAREN_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_PAREN)*2 - 1
	N_EXPR_PAREN_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_PAREN)*2
	N_EXPR_SEQ_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_SEQ)*2 - 1
	N_EXPR_SEQ_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_SEQ)*2
	N_EXPR_THIS_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_THIS)*2 - 1
	N_EXPR_THIS_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_THIS)*2
	N_EXPR_TPL_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_TPL)*2 - 1
	N_EXPR_TPL_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_TPL)*2
	N_EXPR_UNARY_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UNARY)*2 - 1
	N_EXPR_UNARY_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UNARY)*2
	N_EXPR_UPDATE_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UPDATE)*2 - 1
	N_EXPR_UPDATE_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UPDATE)*2
	N_EXPR_YIELD_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_YIELD)*2 - 1
	N_EXPR_YIELD_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_YIELD)*2
	N_FIELD_BEFORE                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_FIELD)*2 - 1
	N_FIELD_AFTER                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_FIELD)*2
	N_IMPORT_CALL_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_CALL)*2 - 1
	N_IMPORT_CALL_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_CALL)*2
	N_IMPORT_SPEC_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_SPEC)*2 - 1
	N_IMPORT_SPEC_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_SPEC)*2
	N_JSX_ATTR_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR)*2 - 1
	N_JSX_ATTR_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR)*2
	N_JSX_ATTR_SPREAD_BEFORE       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR_SPREAD)*2 - 1
	N_JSX_ATTR_SPREAD_AFTER        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR_SPREAD)*2
	N_JSX_CHILD_SPREAD_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CHILD_SPREAD)*2 - 1
	N_JSX_CHILD_SPREAD_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CHILD_SPREAD)*2
	N_JSX_CLOSE_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CLOSE)*2 - 1
	N_JSX_CLOSE_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CLOSE)*2
	N_JSX_ELEM_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ELEM)*2 - 1
	N_JSX_ELEM_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ELEM)*2
	N_JSX_EMPTY_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EMPTY)*2 - 1
	N_JSX_EMPTY_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EMPTY)*2
	N_JSX_EXPR_SPAN_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EXPR_SPAN)*2 - 1
	N_JSX_EXPR_SPAN_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EXPR_SPAN)*2
	N_JSX_ID_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ID)*2 - 1
	N_JSX_ID_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ID)*2
	N_JSX_MEMBER_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_MEMBER)*2 - 1
	N_JSX_MEMBER_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_MEMBER)*2
	N_JSX_NS_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_NS)*2 - 1
	N_JSX_NS_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_NS)*2
	N_JSX_OPEN_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_OPEN)*2 - 1
	N_JSX_OPEN_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_OPEN)*2
	N_JSX_TXT_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_TXT)*2 - 1
	N_JSX_TXT_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_TXT)*2
	N_LIT_ARR_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_ARR)*2 - 1
	N_LIT_ARR_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_ARR)*2
	N_LIT_BOOL_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_BOOL)*2 - 1
	N_LIT_BOOL_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_BOOL)*2
	N_LIT_NULL_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NULL)*2 - 1
	N_LIT_NULL_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NULL)*2
	N_LIT_NUM_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NUM)*2 - 1
	N_LIT_NUM_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NUM)*2
	N_LIT_OBJ_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_OBJ)*2 - 1
	N_LIT_OBJ_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_OBJ)*2
	N_LIT_REGEXP_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_REGEXP)*2 - 1
	N_LIT_REGEXP_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_REGEXP)*2
	N_LIT_STR_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_STR)*2 - 1
	N_LIT_STR_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_STR)*2
	N_META_PROP_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_META_PROP)*2 - 1
	N_META_PROP_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_META_PROP)*2
	N_METHOD_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_METHOD)*2 - 1
	N_METHOD_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_METHOD)*2
	N_NAME_BEFORE                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_NAME)*2 - 1
	N_NAME_AFTER                   = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_NAME)*2
	N_PAT_ARRAY_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ARRAY)*2 - 1
	N_PAT_ARRAY_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ARRAY)*2
	N_PAT_ASSIGN_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ASSIGN)*2 - 1
	N_PAT_ASSIGN_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ASSIGN)*2
	N_PAT_OBJ_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_OBJ)*2 - 1
	N_PAT_OBJ_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_OBJ)*2
	N_PAT_REST_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_REST)*2 - 1
	N_PAT_REST_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_REST)*2
	N_PROG_BEFORE                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROG)*2 - 1
	N_PROG_AFTER                   = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROG)*2
	N_PROP_BEFORE                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROP)*2 - 1
	N_PROP_AFTER                   = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROP)*2
	N_SPREAD_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SPREAD)*2 - 1
	N_SPREAD_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SPREAD)*2
	N_STATIC_BLOCK_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STATIC_BLOCK)*2 - 1
	N_STATIC_BLOCK_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STATIC_BLOCK)*2
	N_STMT_BLOCK_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BLOCK)*2 - 1
	N_STMT_BLOCK_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BLOCK)*2
	N_STMT_BRK_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BRK)*2 - 1
	N_STMT_BRK_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BRK)*2
	N_STMT_CLASS_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CLASS)*2 - 1
	N_STMT_CLASS_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CLASS)*2
	N_STMT_CONT_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CONT)*2 - 1
	N_STMT_CONT_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CONT)*2
	N_STMT_DEBUG_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DEBUG)*2 - 1
	N_STMT_DEBUG_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DEBUG)*2
	N_STMT_DO_WHILE_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DO_WHILE)*2 - 1
	N_STMT_DO_WHILE_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DO_WHILE)*2
	N_STMT_EXPORT_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPORT)*2 - 1
	N_STMT_EXPORT_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPORT)*2
	N_STMT_EXPR_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPR)*2 - 1
	N_STMT_EXPR_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPR)*2
	N_STMT_FN_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FN)*2 - 1
	N_STMT_FN_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FN)*2
	N_STMT_FOR_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR)*2 - 1
	N_STMT_FOR_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR)*2
	N_STMT_FOR_IN_OF_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR_IN_OF)*2 - 1
	N_STMT_FOR_IN_OF_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR_IN_OF)*2
	N_STMT_IF_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IF)*2 - 1
	N_STMT_IF_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IF)*2
	N_STMT_IMPORT_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IMPORT)*2 - 1
	N_STMT_IMPORT_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IMPORT)*2
	N_STMT_LABEL_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_LABEL)*2 - 1
	N_STMT_LABEL_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_LABEL)*2
	N_STMT_RET_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_RET)*2 - 1
	N_STMT_RET_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_RET)*2
	N_STMT_SWITCH_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_SWITCH)*2 - 1
	N_STMT_SWITCH_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_SWITCH)*2
	N_STMT_THROW_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_THROW)*2 - 1
	N_STMT_THROW_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_THROW)*2
	N_STMT_TRY_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_TRY)*2 - 1
	N_STMT_TRY_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_TRY)*2
	N_STMT_VAR_DEC_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_VAR_DEC)*2 - 1
	N_STMT_VAR_DEC_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_VAR_DEC)*2
	N_STMT_WHILE_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WHILE)*2 - 1
	N_STMT_WHILE_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WHILE)*2
	N_STMT_WITH_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WITH)*2 - 1
	N_STMT_WITH_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WITH)*2
	N_SUPER_BEFORE                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SUPER)*2 - 1
	N_SUPER_AFTER                  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SUPER)*2
	N_SWITCH_CASE_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SWITCH_CASE)*2 - 1
	N_SWITCH_CASE_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SWITCH_CASE)*2
	N_TS_ANY_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ANY)*2 - 1
	N_TS_ANY_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ANY)*2
	N_TS_ARR_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ARR)*2 - 1
	N_TS_ARR_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ARR)*2
	N_TS_BIGINT_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BIGINT)*2 - 1
	N_TS_BIGINT_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BIGINT)*2
	N_TS_BOOL_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BOOL)*2 - 1
	N_TS_BOOL_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BOOL)*2
	N_TS_CALL_SIG_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_CALL_SIG)*2 - 1
	N_TS_CALL_SIG_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_CALL_SIG)*2
	N_TS_COND_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_COND)*2 - 1
	N_TS_COND_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_COND)*2
	N_TS_DEC_CLASS_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_CLASS)*2 - 1
	N_TS_DEC_CLASS_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_CLASS)*2
	N_TS_DEC_ENUM_BEFORE           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_ENUM)*2 - 1
	N_TS_DEC_ENUM_AFTER            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_ENUM)*2
	N_TS_DEC_FN_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_FN)*2 - 1
	N_TS_DEC_FN_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_FN)*2
	N_TS_DEC_GLOBAL_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_GLOBAL)*2 - 1
	N_TS_DEC_GLOBAL_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_GLOBAL)*2
	N_TS_DEC_INTERFACE_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_INTERFACE)*2 - 1
	N_TS_DEC_INTERFACE_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_INTERFACE)*2
	N_TS_DEC_MODULE_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_MODULE)*2 - 1
	N_TS_DEC_MODULE_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_MODULE)*2
	N_TS_DEC_NS_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_NS)*2 - 1
	N_TS_DEC_NS_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_NS)*2
	N_TS_DEC_TYP_DEC_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_TYP_DEC)*2 - 1
	N_TS_DEC_TYP_DEC_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_TYP_DEC)*2
	N_TS_DEC_VAR_DEC_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_VAR_DEC)*2 - 1
	N_TS_DEC_VAR_DEC_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_VAR_DEC)*2
	N_TS_ENUM_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM)*2 - 1
	N_TS_ENUM_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM)*2
	N_TS_ENUM_MEMBER_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM_MEMBER)*2 - 1
	N_TS_ENUM_MEMBER_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM_MEMBER)*2
	N_TS_EXPORT_ASSIGN_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_EXPORT_ASSIGN)*2 - 1
	N_TS_EXPORT_ASSIGN_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_EXPORT_ASSIGN)*2
	N_TS_FN_TYP_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_FN_TYP)*2 - 1
	N_TS_FN_TYP_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_FN_TYP)*2
	N_TS_IDX_ACCESS_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_ACCESS)*2 - 1
	N_TS_IDX_ACCESS_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_ACCESS)*2
	N_TS_IDX_SIG_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_SIG)*2 - 1
	N_TS_IDX_SIG_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_SIG)*2
	N_TS_IMPORT_ALIAS_BEFORE       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_ALIAS)*2 - 1
	N_TS_IMPORT_ALIAS_AFTER        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_ALIAS)*2
	N_TS_IMPORT_REQUIRE_BEFORE     = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_REQUIRE)*2 - 1
	N_TS_IMPORT_REQUIRE_AFTER      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_REQUIRE)*2
	N_TS_IMPORT_TYP_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_TYP)*2 - 1
	N_TS_IMPORT_TYP_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_TYP)*2
	N_TS_INTERFACE_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE)*2 - 1
	N_TS_INTERFACE_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE)*2
	N_TS_INTERFACE_BODY_BEFORE     = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE_BODY)*2 - 1
	N_TS_INTERFACE_BODY_AFTER      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE_BODY)*2
	N_TS_INTERSECT_TYP_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERSECT_TYP)*2 - 1
	N_TS_INTERSECT_TYP_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERSECT_TYP)*2
	N_TS_INTRINSIC_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTRINSIC)*2 - 1
	N_TS_INTRINSIC_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTRINSIC)*2
	N_TS_LIT_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT)*2 - 1
	N_TS_LIT_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT)*2
	N_TS_LIT_OBJ_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT_OBJ)*2 - 1
	N_TS_LIT_OBJ_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT_OBJ)*2
	N_TS_MAPPED_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_MAPPED)*2 - 1
	N_TS_MAPPED_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_MAPPED)*2
	N_TS_NAMESPACE_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NAMESPACE)*2 - 1
	N_TS_NAMESPACE_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NAMESPACE)*2
	N_TS_NEVER_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEVER)*2 - 1
	N_TS_NEVER_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEVER)*2
	N_TS_NEW_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW)*2 - 1
	N_TS_NEW_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW)*2
	N_TS_NEW_SIG_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW_SIG)*2 - 1
	N_TS_NEW_SIG_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW_SIG)*2
	N_TS_NO_NULL_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NO_NULL)*2 - 1
	N_TS_NO_NULL_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NO_NULL)*2
	N_TS_NS_NAME_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NS_NAME)*2 - 1
	N_TS_NS_NAME_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NS_NAME)*2
	N_TS_NULL_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NULL)*2 - 1
	N_TS_NULL_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NULL)*2
	N_TS_NUM_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NUM)*2 - 1
	N_TS_NUM_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NUM)*2
	N_TS_OBJ_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OBJ)*2 - 1
	N_TS_OBJ_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OBJ)*2
	N_TS_OPT_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OPT)*2 - 1
	N_TS_OPT_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OPT)*2
	N_TS_PARAM_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM)*2 - 1
	N_TS_PARAM_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM)*2
	N_TS_PARAM_DEC_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_DEC)*2 - 1
	N_TS_PARAM_DEC_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_DEC)*2
	N_TS_PARAM_INST_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_INST)*2 - 1
	N_TS_PARAM_INST_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_INST)*2
	N_TS_PAREN_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PAREN)*2 - 1
	N_TS_PAREN_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PAREN)*2
	N_TS_PROP_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PROP)*2 - 1
	N_TS_PROP_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PROP)*2
	N_TS_REF_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REF)*2 - 1
	N_TS_REF_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REF)*2
	N_TS_REST_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REST)*2 - 1
	N_TS_REST_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REST)*2
	N_TS_ROUGH_PARAM_BEFORE        = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ROUGH_PARAM)*2 - 1
	N_TS_ROUGH_PARAM_AFTER         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ROUGH_PARAM)*2
	N_TS_STR_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_STR)*2 - 1
	N_TS_STR_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_STR)*2
	N_TS_SYM_BEFORE                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_SYM)*2 - 1
	N_TS_SYM_AFTER                 = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_SYM)*2
	N_TS_THIS_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_THIS)*2 - 1
	N_TS_THIS_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_THIS)*2
	N_TS_TUPLE_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE)*2 - 1
	N_TS_TUPLE_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE)*2
	N_TS_TUPLE_NAMED_MEMBER_BEFORE = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE_NAMED_MEMBER)*2 - 1
	N_TS_TUPLE_NAMED_MEMBER_AFTER  = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE_NAMED_MEMBER)*2
	N_TS_TYP_ANNOT_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ANNOT)*2 - 1
	N_TS_TYP_ANNOT_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ANNOT)*2
	N_TS_TYP_ASSERT_BEFORE         = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ASSERT)*2 - 1
	N_TS_TYP_ASSERT_AFTER          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ASSERT)*2
	N_TS_TYP_DEC_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_DEC)*2 - 1
	N_TS_TYP_DEC_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_DEC)*2
	N_TS_TYP_INFER_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_INFER)*2 - 1
	N_TS_TYP_INFER_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_INFER)*2
	N_TS_TYP_OP_BEFORE             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_OP)*2 - 1
	N_TS_TYP_OP_AFTER              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_OP)*2
	N_TS_TYP_PREDICATE_BEFORE      = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_PREDICATE)*2 - 1
	N_TS_TYP_PREDICATE_AFTER       = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_PREDICATE)*2
	N_TS_TYP_QUERY_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_QUERY)*2 - 1
	N_TS_TYP_QUERY_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_QUERY)*2
	N_TS_UNDEF_BEFORE              = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNDEF)*2 - 1
	N_TS_UNDEF_AFTER               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNDEF)*2
	N_TS_UNION_TYP_BEFORE          = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNION_TYP)*2 - 1
	N_TS_UNION_TYP_AFTER           = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNION_TYP)*2
	N_TS_UNKNOWN_BEFORE            = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNKNOWN)*2 - 1
	N_TS_UNKNOWN_AFTER             = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNKNOWN)*2
	N_TS_VOID_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_VOID)*2 - 1
	N_TS_VOID_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_VOID)*2
	N_VAR_DEC_BEFORE               = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_VAR_DEC)*2 - 1
	N_VAR_DEC_AFTER                = N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_VAR_DEC)*2

	N_BEFORE_AFTER_DEF_END = N_BEFORE_AFTER_DEF_BEGIN + parser.N_NODE_DEF_END*2
)

var AtomNodeTypes = map[parser.NodeType]bool{
	N_EXPR_THIS:      true,
	N_JSX_EMPTY:      true,
	N_JSX_ID:         true,
	N_JSX_NS:         true,
	N_JSX_TXT:        true,
	N_LIT_BOOL:       true,
	N_LIT_NULL:       true,
	N_LIT_NUM:        true,
	N_LIT_REGEXP:     true,
	N_LIT_STR:        true,
	N_NAME:           true,
	N_STMT_DEBUG:     true,
	N_SUPER:          true,
	N_TS_ANY:         true,
	N_TS_BIGINT:      true,
	N_TS_BOOL:        true,
	N_TS_INTRINSIC:   true,
	N_TS_NEVER:       true,
	N_TS_NULL:        true,
	N_TS_NUM:         true,
	N_TS_OBJ:         true,
	N_TS_ROUGH_PARAM: true,
	N_TS_STR:         true,
	N_TS_SYM:         true,
	N_TS_THIS:        true,
	N_TS_UNDEF:       true,
	N_TS_UNKNOWN:     true,
	N_TS_VOID:        true,
}

var NodeTypes = map[parser.NodeType]bool{
	N_CATCH:                 true,
	N_CLASS_BODY:            true,
	N_DECORATOR:             true,
	N_EXPORT_SPEC:           true,
	N_EXPR_ARROW:            true,
	N_EXPR_ASSIGN:           true,
	N_EXPR_BIN:              true,
	N_EXPR_CALL:             true,
	N_EXPR_CHAIN:            true,
	N_EXPR_CLASS:            true,
	N_EXPR_COND:             true,
	N_EXPR_FN:               true,
	N_EXPR_MEMBER:           true,
	N_EXPR_NEW:              true,
	N_EXPR_PAREN:            true,
	N_EXPR_SEQ:              true,
	N_EXPR_THIS:             true,
	N_EXPR_TPL:              true,
	N_EXPR_UNARY:            true,
	N_EXPR_UPDATE:           true,
	N_EXPR_YIELD:            true,
	N_FIELD:                 true,
	N_IMPORT_CALL:           true,
	N_IMPORT_SPEC:           true,
	N_JSX_ATTR:              true,
	N_JSX_ATTR_SPREAD:       true,
	N_JSX_CHILD_SPREAD:      true,
	N_JSX_CLOSE:             true,
	N_JSX_ELEM:              true,
	N_JSX_EMPTY:             true,
	N_JSX_EXPR_SPAN:         true,
	N_JSX_ID:                true,
	N_JSX_MEMBER:            true,
	N_JSX_NS:                true,
	N_JSX_OPEN:              true,
	N_JSX_TXT:               true,
	N_LIT_ARR:               true,
	N_LIT_BOOL:              true,
	N_LIT_NULL:              true,
	N_LIT_NUM:               true,
	N_LIT_OBJ:               true,
	N_LIT_REGEXP:            true,
	N_LIT_STR:               true,
	N_META_PROP:             true,
	N_METHOD:                true,
	N_NAME:                  true,
	N_PAT_ARRAY:             true,
	N_PAT_ASSIGN:            true,
	N_PAT_OBJ:               true,
	N_PAT_REST:              true,
	N_PROG:                  true,
	N_PROP:                  true,
	N_SPREAD:                true,
	N_STATIC_BLOCK:          true,
	N_STMT_BLOCK:            true,
	N_STMT_BRK:              true,
	N_STMT_CLASS:            true,
	N_STMT_CONT:             true,
	N_STMT_DEBUG:            true,
	N_STMT_DO_WHILE:         true,
	N_STMT_EXPORT:           true,
	N_STMT_EXPR:             true,
	N_STMT_FN:               true,
	N_STMT_FOR:              true,
	N_STMT_FOR_IN_OF:        true,
	N_STMT_IF:               true,
	N_STMT_IMPORT:           true,
	N_STMT_LABEL:            true,
	N_STMT_RET:              true,
	N_STMT_SWITCH:           true,
	N_STMT_THROW:            true,
	N_STMT_TRY:              true,
	N_STMT_VAR_DEC:          true,
	N_STMT_WHILE:            true,
	N_STMT_WITH:             true,
	N_SUPER:                 true,
	N_SWITCH_CASE:           true,
	N_TS_ANY:                true,
	N_TS_ARR:                true,
	N_TS_BIGINT:             true,
	N_TS_BOOL:               true,
	N_TS_CALL_SIG:           true,
	N_TS_COND:               true,
	N_TS_DEC_CLASS:          true,
	N_TS_DEC_ENUM:           true,
	N_TS_DEC_FN:             true,
	N_TS_DEC_GLOBAL:         true,
	N_TS_DEC_INTERFACE:      true,
	N_TS_DEC_MODULE:         true,
	N_TS_DEC_NS:             true,
	N_TS_DEC_TYP_DEC:        true,
	N_TS_DEC_VAR_DEC:        true,
	N_TS_ENUM:               true,
	N_TS_ENUM_MEMBER:        true,
	N_TS_EXPORT_ASSIGN:      true,
	N_TS_FN_TYP:             true,
	N_TS_IDX_ACCESS:         true,
	N_TS_IDX_SIG:            true,
	N_TS_IMPORT_ALIAS:       true,
	N_TS_IMPORT_REQUIRE:     true,
	N_TS_IMPORT_TYP:         true,
	N_TS_INTERFACE:          true,
	N_TS_INTERFACE_BODY:     true,
	N_TS_INTERSECT_TYP:      true,
	N_TS_INTRINSIC:          true,
	N_TS_LIT:                true,
	N_TS_LIT_OBJ:            true,
	N_TS_MAPPED:             true,
	N_TS_NAMESPACE:          true,
	N_TS_NEVER:              true,
	N_TS_NEW:                true,
	N_TS_NEW_SIG:            true,
	N_TS_NO_NULL:            true,
	N_TS_NS_NAME:            true,
	N_TS_NULL:               true,
	N_TS_NUM:                true,
	N_TS_OBJ:                true,
	N_TS_OPT:                true,
	N_TS_PARAM:              true,
	N_TS_PARAM_DEC:          true,
	N_TS_PARAM_INST:         true,
	N_TS_PAREN:              true,
	N_TS_PROP:               true,
	N_TS_REF:                true,
	N_TS_REST:               true,
	N_TS_ROUGH_PARAM:        true,
	N_TS_STR:                true,
	N_TS_SYM:                true,
	N_TS_THIS:               true,
	N_TS_TUPLE:              true,
	N_TS_TUPLE_NAMED_MEMBER: true,
	N_TS_TYP_ANNOT:          true,
	N_TS_TYP_ASSERT:         true,
	N_TS_TYP_DEC:            true,
	N_TS_TYP_INFER:          true,
	N_TS_TYP_OP:             true,
	N_TS_TYP_PREDICATE:      true,
	N_TS_TYP_QUERY:          true,
	N_TS_UNDEF:              true,
	N_TS_UNION_TYP:          true,
	N_TS_UNKNOWN:            true,
	N_TS_VOID:               true,
	N_VAR_DEC:               true,
}

var StmtNodeTypes = map[parser.NodeType]bool{
	N_STMT_BLOCK:     true,
	N_STMT_BRK:       true,
	N_STMT_CONT:      true,
	N_STMT_DEBUG:     true,
	N_STMT_DO_WHILE:  true,
	N_STMT_EXPORT:    true,
	N_STMT_EXPR:      true,
	N_STMT_FOR:       true,
	N_STMT_FOR_IN_OF: true,
	N_STMT_IF:        true,
	N_STMT_IMPORT:    true,
	N_STMT_LABEL:     true,
	N_STMT_RET:       true,
	N_STMT_SWITCH:    true,
	N_STMT_THROW:     true,
	N_STMT_TRY:       true,
	N_STMT_VAR_DEC:   true,
	N_STMT_WHILE:     true,
	N_STMT_WITH:      true,
}

var NodeBeforeEvents = map[parser.NodeType]bool{
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CATCH)*2 - 1:                 true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CLASS_BODY)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_DECORATOR)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPORT_SPEC)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ARROW)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ASSIGN)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_BIN)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CALL)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CHAIN)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CLASS)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_COND)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_FN)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_MEMBER)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_NEW)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_PAREN)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_SEQ)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_THIS)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_TPL)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UNARY)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UPDATE)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_YIELD)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_FIELD)*2 - 1:                 true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_CALL)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_SPEC)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR_SPREAD)*2 - 1:       true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CHILD_SPREAD)*2 - 1:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CLOSE)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ELEM)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EMPTY)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EXPR_SPAN)*2 - 1:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ID)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_MEMBER)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_NS)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_OPEN)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_TXT)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_ARR)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_BOOL)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NULL)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NUM)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_OBJ)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_REGEXP)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_STR)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_META_PROP)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_METHOD)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_NAME)*2 - 1:                  true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ARRAY)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ASSIGN)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_OBJ)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_REST)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROG)*2 - 1:                  true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROP)*2 - 1:                  true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SPREAD)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STATIC_BLOCK)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BLOCK)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BRK)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CLASS)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CONT)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DEBUG)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DO_WHILE)*2 - 1:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPORT)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPR)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FN)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR_IN_OF)*2 - 1:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IF)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IMPORT)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_LABEL)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_RET)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_SWITCH)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_THROW)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_TRY)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_VAR_DEC)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WHILE)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WITH)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SUPER)*2 - 1:                 true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SWITCH_CASE)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ANY)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ARR)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BIGINT)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BOOL)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_CALL_SIG)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_COND)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_CLASS)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_ENUM)*2 - 1:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_FN)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_GLOBAL)*2 - 1:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_INTERFACE)*2 - 1:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_MODULE)*2 - 1:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_NS)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_TYP_DEC)*2 - 1:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_VAR_DEC)*2 - 1:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM_MEMBER)*2 - 1:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_EXPORT_ASSIGN)*2 - 1:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_FN_TYP)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_ACCESS)*2 - 1:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_SIG)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_ALIAS)*2 - 1:       true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_REQUIRE)*2 - 1:     true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_TYP)*2 - 1:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE_BODY)*2 - 1:     true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERSECT_TYP)*2 - 1:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTRINSIC)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT_OBJ)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_MAPPED)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NAMESPACE)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEVER)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW_SIG)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NO_NULL)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NS_NAME)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NULL)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NUM)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OBJ)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OPT)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_DEC)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_INST)*2 - 1:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PAREN)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PROP)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REF)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REST)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ROUGH_PARAM)*2 - 1:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_STR)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_SYM)*2 - 1:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_THIS)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE_NAMED_MEMBER)*2 - 1: true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ANNOT)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ASSERT)*2 - 1:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_DEC)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_INFER)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_OP)*2 - 1:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_PREDICATE)*2 - 1:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_QUERY)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNDEF)*2 - 1:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNION_TYP)*2 - 1:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNKNOWN)*2 - 1:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_VOID)*2 - 1:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_VAR_DEC)*2 - 1:               true,
}

var NodeAfterEvents = map[parser.NodeType]bool{
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CATCH)*2:                 true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_CLASS_BODY)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_DECORATOR)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPORT_SPEC)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ARROW)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_ASSIGN)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_BIN)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CALL)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CHAIN)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_CLASS)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_COND)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_FN)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_MEMBER)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_NEW)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_PAREN)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_SEQ)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_THIS)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_TPL)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UNARY)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_UPDATE)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_EXPR_YIELD)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_FIELD)*2:                 true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_CALL)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_IMPORT_SPEC)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ATTR_SPREAD)*2:       true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CHILD_SPREAD)*2:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_CLOSE)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ELEM)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EMPTY)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_EXPR_SPAN)*2:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_ID)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_MEMBER)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_NS)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_OPEN)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_JSX_TXT)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_ARR)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_BOOL)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NULL)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_NUM)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_OBJ)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_REGEXP)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_LIT_STR)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_META_PROP)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_METHOD)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_NAME)*2:                  true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ARRAY)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_ASSIGN)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_OBJ)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PAT_REST)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROG)*2:                  true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_PROP)*2:                  true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SPREAD)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STATIC_BLOCK)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BLOCK)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_BRK)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CLASS)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_CONT)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DEBUG)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_DO_WHILE)*2:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPORT)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_EXPR)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FN)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_FOR_IN_OF)*2:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IF)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_IMPORT)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_LABEL)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_RET)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_SWITCH)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_THROW)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_TRY)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_VAR_DEC)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WHILE)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_STMT_WITH)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SUPER)*2:                 true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_SWITCH_CASE)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ANY)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ARR)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BIGINT)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_BOOL)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_CALL_SIG)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_COND)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_CLASS)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_ENUM)*2:           true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_FN)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_GLOBAL)*2:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_INTERFACE)*2:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_MODULE)*2:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_NS)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_TYP_DEC)*2:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_DEC_VAR_DEC)*2:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ENUM_MEMBER)*2:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_EXPORT_ASSIGN)*2:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_FN_TYP)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_ACCESS)*2:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IDX_SIG)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_ALIAS)*2:       true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_REQUIRE)*2:     true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_IMPORT_TYP)*2:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERFACE_BODY)*2:     true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTERSECT_TYP)*2:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_INTRINSIC)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_LIT_OBJ)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_MAPPED)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NAMESPACE)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEVER)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NEW_SIG)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NO_NULL)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NS_NAME)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NULL)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_NUM)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OBJ)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_OPT)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_DEC)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PARAM_INST)*2:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PAREN)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_PROP)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REF)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_REST)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_ROUGH_PARAM)*2:        true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_STR)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_SYM)*2:                true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_THIS)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TUPLE_NAMED_MEMBER)*2: true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ANNOT)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_ASSERT)*2:         true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_DEC)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_INFER)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_OP)*2:             true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_PREDICATE)*2:      true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_TYP_QUERY)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNDEF)*2:              true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNION_TYP)*2:          true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_UNKNOWN)*2:            true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_TS_VOID)*2:               true,
	N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-N_VAR_DEC)*2:               true,
}

type Visitor = func(node parser.Node, key string, ctx *VisitorCtx)
type Visitors = [N_BEFORE_AFTER_DEF_END]Visitor

// replace the default visitor with the specified one
func SetVisitor(vs *Visitors, t parser.NodeType, impl Visitor) {
	vs[t] = impl
}

type ListenFn = func(node parser.Node, key string, ctx *VisitorCtx)

type Listener struct {
	Id     string
	Handle ListenFn
}
type Listeners = [N_BEFORE_AFTER_DEF_END]*util.OrderedMap[string, *Listener]

func AddListener(ls *Listeners, t parser.NodeType, impl *Listener) error {
	if ls[t] != nil && ls[t].HasKey(impl.Id) {
		return errors.New("duplicate listener with same id: " + impl.Id)
	}
	if ls[t] == nil {
		ls[t] = util.NewOrderedMap[string, *Listener]()
	}
	ls[t].Set(impl.Id, impl)
	return nil
}

func RemoveListener(ls *Listeners, t parser.NodeType, impl *Listener) {
	if ls[t] != nil {
		ls[t].Remove(impl.Id)
	}
}

func NodeBeforeEvent(t parser.NodeType) parser.NodeType {
	return N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-t)*2 - 1
}

func NodeAfterEvent(t parser.NodeType) parser.NodeType {
	return N_BEFORE_AFTER_DEF_BEGIN + (parser.N_NODE_DEF_END-t)*2
}

func AddNodeBeforeListener(ls *Listeners, t parser.NodeType, impl *Listener) {
	AddListener(ls, NodeBeforeEvent(t), impl)
}

func AddNodeAfterListener(ls *Listeners, t parser.NodeType, impl *Listener) {
	AddListener(ls, NodeAfterEvent(t), impl)
}

func AddBeforeListener(ls *Listeners, impl *Listener) {
	for t := range NodeTypes {
		AddNodeBeforeListener(ls, t, impl)
	}
}

func AddAfterListener(ls *Listeners, impl *Listener) {
	for t := range NodeTypes {
		AddNodeAfterListener(ls, t, impl)
	}
}

func AddAtomListener(ls *Listeners, impl *Listener) {
	for t := range AtomNodeTypes {
		AddListener(ls, t, impl)
	}
}

func VisitTsNsName(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsNsName)

	CallVisitor(N_TS_NS_NAME_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_NS_NAME_AFTER, n, key, ctx)

	VisitNode(n.Lhs(), "Lhs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Rhs(), "Rhs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsNsNameBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NS_NAME_BEFORE, node, key, ctx)
}

func VisitTsNsNameAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NS_NAME_AFTER, node, key, ctx)
}

func VisitTsIdxSig(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsIdxSig)

	CallVisitor(N_TS_IDX_SIG_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_IDX_SIG_AFTER, n, key, ctx)

	VisitNode(n.Key(), "Key", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.KeyType(), "KeyType", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsIdxSigBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IDX_SIG_BEFORE, node, key, ctx)
}

func VisitTsIdxSigAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IDX_SIG_AFTER, node, key, ctx)
}

func VisitTsInterfaceBody(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsInterfaceBody)

	CallVisitor(N_TS_INTERFACE_BODY_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_INTERFACE_BODY_AFTER, n, key, ctx)

	VisitNodes(n, n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsInterfaceBodyBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_INTERFACE_BODY_BEFORE, node, key, ctx)
}

func VisitTsInterfaceBodyAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_INTERFACE_BODY_AFTER, node, key, ctx)
}

func VisitTsDec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsDec)

	CallVisitor(N_TS_DEC_TYP_DEC_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_DEC_TYP_DEC_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Inner(), "Inner", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsDecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_DEC_TYP_DEC_BEFORE, node, key, ctx)
}

func VisitTsDecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_DEC_TYP_DEC_AFTER, node, key, ctx)
}

func VisitSuper(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_SUPER_BEFORE, node, key, ctx)
	CallListener(N_SUPER_AFTER, node, key, ctx)
}

func VisitJsxMember(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.JsxMember)

	CallVisitor(N_JSX_MEMBER_BEFORE, n, key, ctx)
	defer CallVisitor(N_JSX_MEMBER_AFTER, n, key, ctx)

	VisitNode(n.Obj(), "Obj", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Prop(), "Prop", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitJsxMemberBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_MEMBER_BEFORE, node, key, ctx)
}

func VisitJsxMemberAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_MEMBER_AFTER, node, key, ctx)
}

func VisitTsTuple(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTuple)

	CallVisitor(N_TS_TUPLE_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TUPLE_AFTER, n, key, ctx)

	VisitNodes(n, n.Args(), "Args", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTupleBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TUPLE_BEFORE, node, key, ctx)
}

func VisitTsTupleAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TUPLE_AFTER, node, key, ctx)
}

func VisitTsObj(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsObj)

	CallVisitor(N_TS_LIT_OBJ_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_LIT_OBJ_AFTER, n, key, ctx)

	VisitNodes(n, n.Props(), "Props", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsObjBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_LIT_OBJ_BEFORE, node, key, ctx)
}

func VisitTsObjAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_LIT_OBJ_AFTER, node, key, ctx)
}

func VisitTsArr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsArr)

	CallVisitor(N_TS_ARR_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_ARR_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsArrBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_ARR_BEFORE, node, key, ctx)
}

func VisitTsArrAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_ARR_AFTER, node, key, ctx)
}

func VisitProg(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.Prog)

	CallVisitor(N_PROG_BEFORE, n, key, ctx)
	defer CallVisitor(N_PROG_AFTER, n, key, ctx)

	VisitNodes(n, n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitProgBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PROG_BEFORE, node, key, ctx)
}

func VisitProgAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PROG_AFTER, node, key, ctx)
}

func VisitExportSpec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ExportSpec)

	CallVisitor(N_EXPORT_SPEC_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPORT_SPEC_AFTER, n, key, ctx)

	VisitNode(n.Local(), "Local", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitExportSpecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPORT_SPEC_BEFORE, node, key, ctx)
}

func VisitExportSpecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPORT_SPEC_AFTER, node, key, ctx)
}

func VisitTsPredef(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NULL_BEFORE, node, key, ctx)
	CallListener(N_TS_NULL_AFTER, node, key, ctx)
}

func VisitJsxEmpty(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_EMPTY_BEFORE, node, key, ctx)
	CallListener(N_JSX_EMPTY_AFTER, node, key, ctx)
}

func VisitTsNS(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsNS)

	CallVisitor(N_TS_NAMESPACE_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_NAMESPACE_AFTER, n, key, ctx)

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsNSBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NAMESPACE_BEFORE, node, key, ctx)
}

func VisitTsNSAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NAMESPACE_AFTER, node, key, ctx)
}

func VisitRetStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.RetStmt)

	CallVisitor(N_STMT_RET_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_RET_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitRetStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_RET_BEFORE, node, key, ctx)
}

func VisitRetStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_RET_AFTER, node, key, ctx)
}

func VisitDebugStmt(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_DEBUG_BEFORE, node, key, ctx)
	CallListener(N_STMT_DEBUG_AFTER, node, key, ctx)
}

func VisitObjPat(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ObjPat)

	CallVisitor(N_PAT_OBJ_BEFORE, n, key, ctx)
	defer CallVisitor(N_PAT_OBJ_AFTER, n, key, ctx)

	VisitNodes(n, n.Props(), "Props", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitObjPatBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PAT_OBJ_BEFORE, node, key, ctx)
}

func VisitObjPatAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PAT_OBJ_AFTER, node, key, ctx)
}

func VisitVarDec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.VarDec)

	CallVisitor(N_VAR_DEC_BEFORE, n, key, ctx)
	defer CallVisitor(N_VAR_DEC_AFTER, n, key, ctx)

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Init(), "Init", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitVarDecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_VAR_DEC_BEFORE, node, key, ctx)
}

func VisitVarDecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_VAR_DEC_AFTER, node, key, ctx)
}

func VisitJsxClose(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.JsxClose)

	CallVisitor(N_JSX_CLOSE_BEFORE, n, key, ctx)
	defer CallVisitor(N_JSX_CLOSE_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitJsxCloseBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_CLOSE_BEFORE, node, key, ctx)
}

func VisitJsxCloseAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_CLOSE_AFTER, node, key, ctx)
}

func VisitTsFnTyp(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsFnTyp)

	CallVisitor(N_TS_FN_TYP_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_FN_TYP_AFTER, n, key, ctx)

	VisitNode(n.TypParams(), "TypParams", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Params(), "Params", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.RetTyp(), "RetTyp", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsFnTypBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_FN_TYP_BEFORE, node, key, ctx)
}

func VisitTsFnTypAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_FN_TYP_AFTER, node, key, ctx)
}

func VisitDoWhileStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.DoWhileStmt)

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	CallVisitor(N_STMT_DO_WHILE_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_DO_WHILE_AFTER, n, key, ctx)

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Test(), "Test", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitDoWhileStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_DO_WHILE_BEFORE, node, key, ctx)
}

func VisitDoWhileStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_DO_WHILE_AFTER, node, key, ctx)
}

func VisitFnDec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.FnDec)

	CallVisitor(N_EXPR_FN_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_FN_AFTER, n, key, ctx)

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	VisitNodes(n, n.Params(), "Params", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitFnDecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_FN_BEFORE, node, key, ctx)
}

func VisitFnDecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_FN_AFTER, node, key, ctx)
}

func VisitIdent(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_NAME_BEFORE, node, key, ctx)
	CallListener(N_NAME_AFTER, node, key, ctx)
}

func VisitChainExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ChainExpr)

	CallVisitor(N_EXPR_CHAIN_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_CHAIN_AFTER, n, key, ctx)

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitChainExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_CHAIN_BEFORE, node, key, ctx)
}

func VisitChainExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_CHAIN_AFTER, node, key, ctx)
}

func VisitRestPat(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.RestPat)

	CallVisitor(N_PAT_REST_BEFORE, n, key, ctx)
	defer CallVisitor(N_PAT_REST_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitRestPatBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PAT_REST_BEFORE, node, key, ctx)
}

func VisitRestPatAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PAT_REST_AFTER, node, key, ctx)
}

func VisitJsxOpen(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.JsxOpen)

	CallVisitor(N_JSX_OPEN_BEFORE, n, key, ctx)
	defer CallVisitor(N_JSX_OPEN_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Attrs(), "Attrs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitJsxOpenBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_OPEN_BEFORE, node, key, ctx)
}

func VisitJsxOpenAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_OPEN_AFTER, node, key, ctx)
}

func VisitTsImportAlias(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsImportAlias)

	CallVisitor(N_TS_IMPORT_ALIAS_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_IMPORT_ALIAS_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsImportAliasBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IMPORT_ALIAS_BEFORE, node, key, ctx)
}

func VisitTsImportAliasAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IMPORT_ALIAS_AFTER, node, key, ctx)
}

func VisitCondExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.CondExpr)

	CallVisitor(N_EXPR_COND_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_COND_AFTER, n, key, ctx)

	VisitNode(n.Test(), "Test", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Cons(), "Cons", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Alt(), "Alt", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitCondExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_COND_BEFORE, node, key, ctx)
}

func VisitCondExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_COND_AFTER, node, key, ctx)
}

func VisitAssignExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.AssignExpr)

	CallVisitor(N_EXPR_ASSIGN_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_ASSIGN_AFTER, n, key, ctx)

	VisitNode(n.Lhs(), "Lhs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Rhs(), "Rhs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitAssignExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_ASSIGN_BEFORE, node, key, ctx)
}

func VisitAssignExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_ASSIGN_AFTER, node, key, ctx)
}

func VisitClassDec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ClassDec)

	CallVisitor(N_EXPR_CLASS_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_CLASS_AFTER, n, key, ctx)

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Super(), "Super", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitClassDecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_CLASS_BEFORE, node, key, ctx)
}

func VisitClassDecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_CLASS_AFTER, node, key, ctx)
}

func VisitJsxSpreadChild(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.JsxSpreadChild)

	CallVisitor(N_JSX_CHILD_SPREAD_BEFORE, n, key, ctx)
	defer CallVisitor(N_JSX_CHILD_SPREAD_AFTER, n, key, ctx)

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitJsxSpreadChildBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_CHILD_SPREAD_BEFORE, node, key, ctx)
}

func VisitJsxSpreadChildAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_CHILD_SPREAD_AFTER, node, key, ctx)
}

func VisitTsLit(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsLit)

	CallVisitor(N_TS_LIT_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_LIT_AFTER, n, key, ctx)

	VisitNode(n.Lit(), "Lit", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsLitBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_LIT_BEFORE, node, key, ctx)
}

func VisitTsLitAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_LIT_AFTER, node, key, ctx)
}

func VisitArrLit(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ArrLit)

	CallVisitor(N_LIT_ARR_BEFORE, n, key, ctx)
	defer CallVisitor(N_LIT_ARR_AFTER, n, key, ctx)

	VisitNodes(n, n.Elems(), "Elems", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitArrLitBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_ARR_BEFORE, node, key, ctx)
}

func VisitArrLitAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_ARR_AFTER, node, key, ctx)
}

func VisitUnaryExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.UnaryExpr)

	CallVisitor(N_EXPR_UNARY_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_UNARY_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitUnaryExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_UNARY_BEFORE, node, key, ctx)
}

func VisitUnaryExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_UNARY_AFTER, node, key, ctx)
}

func VisitSwitchCase(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.SwitchCase)

	CallVisitor(N_SWITCH_CASE_BEFORE, n, key, ctx)
	defer CallVisitor(N_SWITCH_CASE_AFTER, n, key, ctx)

	VisitNode(n.Test(), "Test", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Cons(), "Cons", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitSwitchCaseBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_SWITCH_CASE_BEFORE, node, key, ctx)
}

func VisitSwitchCaseAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_SWITCH_CASE_AFTER, node, key, ctx)
}

func VisitTsImportRequire(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsImportRequire)

	CallVisitor(N_TS_IMPORT_REQUIRE_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_IMPORT_REQUIRE_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsImportRequireBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IMPORT_REQUIRE_BEFORE, node, key, ctx)
}

func VisitTsImportRequireAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IMPORT_REQUIRE_AFTER, node, key, ctx)
}

func VisitJsxNsName(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_NS_BEFORE, node, key, ctx)
	CallListener(N_JSX_NS_AFTER, node, key, ctx)
}

func VisitTsTupleNamedMember(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTupleNamedMember)

	CallVisitor(N_TS_TUPLE_NAMED_MEMBER_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TUPLE_NAMED_MEMBER_AFTER, n, key, ctx)

	VisitNode(n.Label(), "Label", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTupleNamedMemberBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TUPLE_NAMED_MEMBER_BEFORE, node, key, ctx)
}

func VisitTsTupleNamedMemberAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TUPLE_NAMED_MEMBER_AFTER, node, key, ctx)
}

func VisitTsEnum(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsEnum)

	CallVisitor(N_TS_ENUM_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_ENUM_AFTER, n, key, ctx)

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Members(), "Members", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsEnumBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_ENUM_BEFORE, node, key, ctx)
}

func VisitTsEnumAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_ENUM_AFTER, node, key, ctx)
}

func VisitMemberExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.MemberExpr)

	CallVisitor(N_EXPR_MEMBER_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_MEMBER_AFTER, n, key, ctx)

	VisitNode(n.Obj(), "Obj", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Prop(), "Prop", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitMemberExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_MEMBER_BEFORE, node, key, ctx)
}

func VisitMemberExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_MEMBER_AFTER, node, key, ctx)
}

func VisitCallExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.CallExpr)

	CallVisitor(N_EXPR_CALL_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_CALL_AFTER, n, key, ctx)

	VisitNode(n.Callee(), "Callee", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Args(), "Args", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitCallExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_CALL_BEFORE, node, key, ctx)
}

func VisitCallExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_CALL_AFTER, node, key, ctx)
}

func VisitTsTypDec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTypDec)

	CallVisitor(N_TS_TYP_DEC_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TYP_DEC_AFTER, n, key, ctx)

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.TypParams(), "TypParams", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTypDecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_DEC_BEFORE, node, key, ctx)
}

func VisitTsTypDecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_DEC_AFTER, node, key, ctx)
}

func VisitTsTypPredicate(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTypPredicate)

	CallVisitor(N_TS_TYP_PREDICATE_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TYP_PREDICATE_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Typ(), "Typ", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTypPredicateBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_PREDICATE_BEFORE, node, key, ctx)
}

func VisitTsTypPredicateAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_PREDICATE_AFTER, node, key, ctx)
}

func VisitNumLit(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_NUM_BEFORE, node, key, ctx)
	CallListener(N_LIT_NUM_AFTER, node, key, ctx)
}

func VisitAssignPat(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.AssignPat)

	CallVisitor(N_PAT_ASSIGN_BEFORE, n, key, ctx)
	defer CallVisitor(N_PAT_ASSIGN_AFTER, n, key, ctx)

	VisitNode(n.Lhs(), "Lhs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Rhs(), "Rhs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitAssignPatBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PAT_ASSIGN_BEFORE, node, key, ctx)
}

func VisitAssignPatAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PAT_ASSIGN_AFTER, node, key, ctx)
}

func VisitStaticBlock(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.StaticBlock)

	CallVisitor(N_STATIC_BLOCK_BEFORE, n, key, ctx)
	defer CallVisitor(N_STATIC_BLOCK_AFTER, n, key, ctx)

	VisitNodes(n, n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitStaticBlockBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STATIC_BLOCK_BEFORE, node, key, ctx)
}

func VisitStaticBlockAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STATIC_BLOCK_AFTER, node, key, ctx)
}

func VisitMethod(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.Method)

	CallVisitor(N_METHOD_BEFORE, n, key, ctx)
	defer CallVisitor(N_METHOD_AFTER, n, key, ctx)

	VisitNode(n.Key(), "Key", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitMethodBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_METHOD_BEFORE, node, key, ctx)
}

func VisitMethodAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_METHOD_AFTER, node, key, ctx)
}

func VisitTplExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TplExpr)

	CallVisitor(N_EXPR_TPL_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_TPL_AFTER, n, key, ctx)

	VisitNode(n.Tag(), "Tag", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Elems(), "Elems", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTplExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_TPL_BEFORE, node, key, ctx)
}

func VisitTplExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_TPL_AFTER, node, key, ctx)
}

func VisitJsxIdent(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_ID_BEFORE, node, key, ctx)
	CallListener(N_JSX_ID_AFTER, node, key, ctx)
}

func VisitTsRest(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsRest)

	CallVisitor(N_TS_REST_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_REST_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsRestBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_REST_BEFORE, node, key, ctx)
}

func VisitTsRestAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_REST_AFTER, node, key, ctx)
}

func VisitTsTypOp(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTypOp)

	CallVisitor(N_TS_TYP_OP_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TYP_OP_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTypOpBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_OP_BEFORE, node, key, ctx)
}

func VisitTsTypOpAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_OP_AFTER, node, key, ctx)
}

func VisitForInOfStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ForInOfStmt)

	CallVisitor(N_STMT_FOR_IN_OF_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_FOR_IN_OF_AFTER, n, key, ctx)

	VisitNode(n.Left(), "Left", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Right(), "Right", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitForInOfStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_FOR_IN_OF_BEFORE, node, key, ctx)
}

func VisitForInOfStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_FOR_IN_OF_AFTER, node, key, ctx)
}

func VisitUpdateExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.UpdateExpr)

	CallVisitor(N_EXPR_UPDATE_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_UPDATE_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitUpdateExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_UPDATE_BEFORE, node, key, ctx)
}

func VisitUpdateExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_UPDATE_AFTER, node, key, ctx)
}

func VisitTsTypAnnot(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTypAnnot)

	CallVisitor(N_TS_TYP_ANNOT_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TYP_ANNOT_AFTER, n, key, ctx)

	VisitNode(n.TsTyp(), "TsTyp", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTypAnnotBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_ANNOT_BEFORE, node, key, ctx)
}

func VisitTsTypAnnotAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_ANNOT_AFTER, node, key, ctx)
}

func VisitJsxSpreadAttr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.JsxSpreadAttr)

	CallVisitor(N_JSX_ATTR_SPREAD_BEFORE, n, key, ctx)
	defer CallVisitor(N_JSX_ATTR_SPREAD_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitJsxSpreadAttrBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_ATTR_SPREAD_BEFORE, node, key, ctx)
}

func VisitJsxSpreadAttrAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_ATTR_SPREAD_AFTER, node, key, ctx)
}

func VisitImportCall(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ImportCall)

	CallVisitor(N_IMPORT_CALL_BEFORE, n, key, ctx)
	defer CallVisitor(N_IMPORT_CALL_AFTER, n, key, ctx)

	VisitNode(n.Src(), "Src", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitImportCallBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_IMPORT_CALL_BEFORE, node, key, ctx)
}

func VisitImportCallAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_IMPORT_CALL_AFTER, node, key, ctx)
}

func VisitProp(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.Prop)

	CallVisitor(N_PROP_BEFORE, n, key, ctx)
	defer CallVisitor(N_PROP_AFTER, n, key, ctx)

	VisitNode(n.Key(), "Key", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitPropBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PROP_BEFORE, node, key, ctx)
}

func VisitPropAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PROP_AFTER, node, key, ctx)
}

func VisitCatch(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.Catch)

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	CallVisitor(N_CATCH_BEFORE, n, key, ctx)
	defer CallVisitor(N_CATCH_AFTER, n, key, ctx)

	VisitNode(n.Param(), "Param", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitCatchBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_CATCH_BEFORE, node, key, ctx)
}

func VisitCatchAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_CATCH_AFTER, node, key, ctx)
}

func VisitDecorator(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.Decorator)

	CallVisitor(N_DECORATOR_BEFORE, n, key, ctx)
	defer CallVisitor(N_DECORATOR_AFTER, n, key, ctx)

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitDecoratorBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_DECORATOR_BEFORE, node, key, ctx)
}

func VisitDecoratorAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_DECORATOR_AFTER, node, key, ctx)
}

func VisitTsTypInfer(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTypInfer)

	CallVisitor(N_TS_TYP_INFER_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TYP_INFER_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTypInferBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_INFER_BEFORE, node, key, ctx)
}

func VisitTsTypInferAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_INFER_AFTER, node, key, ctx)
}

func VisitBinExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.BinExpr)

	CallVisitor(N_EXPR_BIN_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_BIN_AFTER, n, key, ctx)

	VisitNode(n.Lhs(), "Lhs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Rhs(), "Rhs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitBinExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_BIN_BEFORE, node, key, ctx)
}

func VisitBinExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_BIN_AFTER, node, key, ctx)
}

func VisitSeqExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.SeqExpr)

	CallVisitor(N_EXPR_SEQ_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_SEQ_AFTER, n, key, ctx)

	VisitNodes(n, n.Elems(), "Elems", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitSeqExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_SEQ_BEFORE, node, key, ctx)
}

func VisitSeqExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_SEQ_AFTER, node, key, ctx)
}

func VisitArrPat(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ArrPat)

	CallVisitor(N_PAT_ARRAY_BEFORE, n, key, ctx)
	defer CallVisitor(N_PAT_ARRAY_AFTER, n, key, ctx)

	VisitNodes(n, n.Elems(), "Elems", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitArrPatBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PAT_ARRAY_BEFORE, node, key, ctx)
}

func VisitArrPatAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_PAT_ARRAY_AFTER, node, key, ctx)
}

func VisitTsNoNull(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsNoNull)

	CallVisitor(N_TS_NO_NULL_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_NO_NULL_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsNoNullBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NO_NULL_BEFORE, node, key, ctx)
}

func VisitTsNoNullAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NO_NULL_AFTER, node, key, ctx)
}

func VisitExprStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ExprStmt)

	CallVisitor(N_STMT_EXPR_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_EXPR_AFTER, n, key, ctx)

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitExprStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_EXPR_BEFORE, node, key, ctx)
}

func VisitExprStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_EXPR_AFTER, node, key, ctx)
}

func VisitWhileStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.WhileStmt)

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	CallVisitor(N_STMT_WHILE_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_WHILE_AFTER, n, key, ctx)

	VisitNode(n.Test(), "Test", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitWhileStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_WHILE_BEFORE, node, key, ctx)
}

func VisitWhileStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_WHILE_AFTER, node, key, ctx)
}

func VisitImportSpec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ImportSpec)

	CallVisitor(N_IMPORT_SPEC_BEFORE, n, key, ctx)
	defer CallVisitor(N_IMPORT_SPEC_AFTER, n, key, ctx)

	VisitNode(n.Local(), "Local", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitImportSpecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_IMPORT_SPEC_BEFORE, node, key, ctx)
}

func VisitImportSpecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_IMPORT_SPEC_AFTER, node, key, ctx)
}

func VisitJsxAttr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.JsxAttr)

	CallVisitor(N_JSX_ATTR_BEFORE, n, key, ctx)
	defer CallVisitor(N_JSX_ATTR_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitJsxAttrBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_ATTR_BEFORE, node, key, ctx)
}

func VisitJsxAttrAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_ATTR_AFTER, node, key, ctx)
}

func VisitTsNewSig(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsNewSig)

	CallVisitor(N_TS_NEW_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_NEW_AFTER, n, key, ctx)

	VisitNode(n.TypParams(), "TypParams", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Params(), "Params", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.RetTyp(), "RetTyp", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsNewSigBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NEW_BEFORE, node, key, ctx)
}

func VisitTsNewSigAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_NEW_AFTER, node, key, ctx)
}

func VisitForStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ForStmt)

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	CallVisitor(N_STMT_FOR_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_FOR_AFTER, n, key, ctx)

	VisitNode(n.Init(), "Init", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Test(), "Test", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Update(), "Update", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitForStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_FOR_BEFORE, node, key, ctx)
}

func VisitForStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_FOR_AFTER, node, key, ctx)
}

func VisitNewExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.NewExpr)

	CallVisitor(N_EXPR_NEW_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_NEW_AFTER, n, key, ctx)

	VisitNode(n.Callee(), "Callee", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Args(), "Args", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitNewExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_NEW_BEFORE, node, key, ctx)
}

func VisitNewExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_NEW_AFTER, node, key, ctx)
}

func VisitJsxElem(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.JsxElem)

	CallVisitor(N_JSX_ELEM_BEFORE, n, key, ctx)
	defer CallVisitor(N_JSX_ELEM_AFTER, n, key, ctx)

	VisitNode(n.Open(), "Open", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Children(), "Children", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Close(), "Close", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitJsxElemBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_ELEM_BEFORE, node, key, ctx)
}

func VisitJsxElemAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_ELEM_AFTER, node, key, ctx)
}

func VisitTsMapped(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsMapped)

	CallVisitor(N_TS_MAPPED_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_MAPPED_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Key(), "Key", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsMappedBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_MAPPED_BEFORE, node, key, ctx)
}

func VisitTsMappedAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_MAPPED_AFTER, node, key, ctx)
}

func VisitTsParamsInst(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsParamsInst)

	CallVisitor(N_TS_PARAM_INST_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_PARAM_INST_AFTER, n, key, ctx)

	VisitNodes(n, n.Params(), "Params", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsParamsInstBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PARAM_INST_BEFORE, node, key, ctx)
}

func VisitTsParamsInstAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PARAM_INST_AFTER, node, key, ctx)
}

func VisitBoolLit(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_BOOL_BEFORE, node, key, ctx)
	CallListener(N_LIT_BOOL_AFTER, node, key, ctx)
}

func VisitField(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.Field)

	CallVisitor(N_FIELD_BEFORE, n, key, ctx)
	defer CallVisitor(N_FIELD_AFTER, n, key, ctx)

	VisitNode(n.Key(), "Key", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitFieldBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_FIELD_BEFORE, node, key, ctx)
}

func VisitFieldAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_FIELD_AFTER, node, key, ctx)
}

func VisitTsIdxAccess(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsIdxAccess)

	CallVisitor(N_TS_IDX_ACCESS_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_IDX_ACCESS_AFTER, n, key, ctx)

	VisitNode(n.Obj(), "Obj", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Idx(), "Idx", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsIdxAccessBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IDX_ACCESS_BEFORE, node, key, ctx)
}

func VisitTsIdxAccessAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IDX_ACCESS_AFTER, node, key, ctx)
}

func VisitContStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ContStmt)

	CallVisitor(N_STMT_CONT_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_CONT_AFTER, n, key, ctx)

	VisitNode(n.Label(), "Label", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitContStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_CONT_BEFORE, node, key, ctx)
}

func VisitContStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_CONT_AFTER, node, key, ctx)
}

func VisitMetaProp(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.MetaProp)

	CallVisitor(N_META_PROP_BEFORE, n, key, ctx)
	defer CallVisitor(N_META_PROP_AFTER, n, key, ctx)

	VisitNode(n.Meta(), "Meta", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Prop(), "Prop", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitMetaPropBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_META_PROP_BEFORE, node, key, ctx)
}

func VisitMetaPropAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_META_PROP_AFTER, node, key, ctx)
}

func VisitTsTypQuery(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTypQuery)

	CallVisitor(N_TS_TYP_QUERY_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TYP_QUERY_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTypQueryBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_QUERY_BEFORE, node, key, ctx)
}

func VisitTsTypQueryAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_QUERY_AFTER, node, key, ctx)
}

func VisitTsParamsDec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsParamsDec)

	CallVisitor(N_TS_PARAM_DEC_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_PARAM_DEC_AFTER, n, key, ctx)

	VisitNodes(n, n.Params(), "Params", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsParamsDecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PARAM_DEC_BEFORE, node, key, ctx)
}

func VisitTsParamsDecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PARAM_DEC_AFTER, node, key, ctx)
}

func VisitTsImportType(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsImportType)

	CallVisitor(N_TS_IMPORT_TYP_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_IMPORT_TYP_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Qualifier(), "Qualifier", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.TypArg(), "TypArg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsImportTypeBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IMPORT_TYP_BEFORE, node, key, ctx)
}

func VisitTsImportTypeAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_IMPORT_TYP_AFTER, node, key, ctx)
}

func VisitLabelStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.LabelStmt)

	CallVisitor(N_STMT_LABEL_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_LABEL_AFTER, n, key, ctx)

	VisitNode(n.Label(), "Label", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitLabelStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_LABEL_BEFORE, node, key, ctx)
}

func VisitLabelStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_LABEL_AFTER, node, key, ctx)
}

func VisitYieldExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.YieldExpr)

	CallVisitor(N_EXPR_YIELD_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_YIELD_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitYieldExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_YIELD_BEFORE, node, key, ctx)
}

func VisitYieldExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_YIELD_AFTER, node, key, ctx)
}

func VisitTsRef(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsRef)

	CallVisitor(N_TS_REF_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_REF_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Args(), "Args", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsRefBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_REF_BEFORE, node, key, ctx)
}

func VisitTsRefAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_REF_AFTER, node, key, ctx)
}

func VisitTsInterface(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsInterface)

	CallVisitor(N_TS_INTERFACE_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_INTERFACE_AFTER, n, key, ctx)

	VisitNode(n.Id(), "Id", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.TypParams(), "TypParams", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Supers(), "Supers", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsInterfaceBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_INTERFACE_BEFORE, node, key, ctx)
}

func VisitTsInterfaceAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_INTERFACE_AFTER, node, key, ctx)
}

func VisitThrowStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ThrowStmt)

	CallVisitor(N_STMT_THROW_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_THROW_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitThrowStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_THROW_BEFORE, node, key, ctx)
}

func VisitThrowStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_THROW_AFTER, node, key, ctx)
}

func VisitNullLit(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_NULL_BEFORE, node, key, ctx)
	CallListener(N_LIT_NULL_AFTER, node, key, ctx)
}

func VisitObjLit(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ObjLit)

	CallVisitor(N_LIT_OBJ_BEFORE, n, key, ctx)
	defer CallVisitor(N_LIT_OBJ_AFTER, n, key, ctx)

	VisitNodes(n, n.Props(), "Props", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitObjLitBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_OBJ_BEFORE, node, key, ctx)
}

func VisitObjLitAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_OBJ_AFTER, node, key, ctx)
}

func VisitSwitchStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.SwitchStmt)

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	CallVisitor(N_STMT_SWITCH_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_SWITCH_AFTER, n, key, ctx)

	VisitNode(n.Test(), "Test", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Cases(), "Cases", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitSwitchStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_SWITCH_BEFORE, node, key, ctx)
}

func VisitSwitchStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_SWITCH_AFTER, node, key, ctx)
}

func VisitTsThis(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_THIS_BEFORE, node, key, ctx)
	CallListener(N_TS_THIS_AFTER, node, key, ctx)
}

func VisitTsRoughParam(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_ROUGH_PARAM_BEFORE, node, key, ctx)
	CallListener(N_TS_ROUGH_PARAM_AFTER, node, key, ctx)
}

func VisitTsCallSig(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsCallSig)

	CallVisitor(N_TS_CALL_SIG_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_CALL_SIG_AFTER, n, key, ctx)

	VisitNode(n.TypParams(), "TypParams", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Params(), "Params", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.RetTyp(), "RetTyp", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsCallSigBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_CALL_SIG_BEFORE, node, key, ctx)
}

func VisitTsCallSigAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_CALL_SIG_AFTER, node, key, ctx)
}

func VisitTsEnumMember(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsEnumMember)

	CallVisitor(N_TS_ENUM_MEMBER_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_ENUM_MEMBER_AFTER, n, key, ctx)

	VisitNode(n.Key(), "Key", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsEnumMemberBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_ENUM_MEMBER_BEFORE, node, key, ctx)
}

func VisitTsEnumMemberAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_ENUM_MEMBER_AFTER, node, key, ctx)
}

func VisitTsParen(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsParen)

	CallVisitor(N_TS_PAREN_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_PAREN_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsParenBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PAREN_BEFORE, node, key, ctx)
}

func VisitTsParenAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PAREN_AFTER, node, key, ctx)
}

func VisitStrLit(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_STR_BEFORE, node, key, ctx)
	CallListener(N_LIT_STR_AFTER, node, key, ctx)
}

func VisitSpread(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.Spread)

	CallVisitor(N_SPREAD_BEFORE, n, key, ctx)
	defer CallVisitor(N_SPREAD_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitSpreadBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_SPREAD_BEFORE, node, key, ctx)
}

func VisitSpreadAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_SPREAD_AFTER, node, key, ctx)
}

func VisitJsxExprSpan(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.JsxExprSpan)

	CallVisitor(N_JSX_EXPR_SPAN_BEFORE, n, key, ctx)
	defer CallVisitor(N_JSX_EXPR_SPAN_AFTER, n, key, ctx)

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitJsxExprSpanBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_EXPR_SPAN_BEFORE, node, key, ctx)
}

func VisitJsxExprSpanAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_EXPR_SPAN_AFTER, node, key, ctx)
}

func VisitTsOpt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsOpt)

	CallVisitor(N_TS_OPT_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_OPT_AFTER, n, key, ctx)

	VisitNode(n.Arg(), "Arg", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsOptBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_OPT_BEFORE, node, key, ctx)
}

func VisitTsOptAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_OPT_AFTER, node, key, ctx)
}

func VisitTsCondType(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsCondType)

	CallVisitor(N_TS_COND_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_COND_AFTER, n, key, ctx)

	VisitNode(n.CheckTyp(), "CheckTyp", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.ExtTyp(), "ExtTyp", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.TrueTyp(), "TrueTyp", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.FalseTyp(), "FalseTyp", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsCondTypeBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_COND_BEFORE, node, key, ctx)
}

func VisitTsCondTypeAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_COND_AFTER, node, key, ctx)
}

func VisitTsParam(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsParam)

	CallVisitor(N_TS_PARAM_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_PARAM_AFTER, n, key, ctx)

	VisitNode(n.Name(), "Name", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Cons(), "Cons", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Default(), "Default", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsParamBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PARAM_BEFORE, node, key, ctx)
}

func VisitTsParamAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PARAM_AFTER, node, key, ctx)
}

func VisitTsUnionTyp(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsUnionTyp)

	CallVisitor(N_TS_UNION_TYP_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_UNION_TYP_AFTER, n, key, ctx)

	VisitNodes(n, n.Elems(), "Elems", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsUnionTypBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_UNION_TYP_BEFORE, node, key, ctx)
}

func VisitTsUnionTypAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_UNION_TYP_AFTER, node, key, ctx)
}

func VisitThisExpr(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_THIS_BEFORE, node, key, ctx)
	CallListener(N_EXPR_THIS_AFTER, node, key, ctx)
}

func VisitParenExpr(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ParenExpr)

	CallVisitor(N_EXPR_PAREN_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_PAREN_AFTER, n, key, ctx)

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitParenExprBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_PAREN_BEFORE, node, key, ctx)
}

func VisitParenExprAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_PAREN_AFTER, node, key, ctx)
}

func VisitArrowFn(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ArrowFn)

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	CallVisitor(N_EXPR_ARROW_BEFORE, n, key, ctx)
	defer CallVisitor(N_EXPR_ARROW_AFTER, n, key, ctx)

	VisitNodes(n, n.Params(), "Params", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitArrowFnBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_ARROW_BEFORE, node, key, ctx)
}

func VisitArrowFnAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_EXPR_ARROW_AFTER, node, key, ctx)
}

func VisitTsExportAssign(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsExportAssign)

	CallVisitor(N_TS_EXPORT_ASSIGN_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_EXPORT_ASSIGN_AFTER, n, key, ctx)

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsExportAssignBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_EXPORT_ASSIGN_BEFORE, node, key, ctx)
}

func VisitTsExportAssignAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_EXPORT_ASSIGN_AFTER, node, key, ctx)
}

func VisitImportDec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ImportDec)

	CallVisitor(N_STMT_IMPORT_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_IMPORT_AFTER, n, key, ctx)

	VisitNodes(n, n.Specs(), "Specs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Src(), "Src", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitImportDecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_IMPORT_BEFORE, node, key, ctx)
}

func VisitImportDecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_IMPORT_AFTER, node, key, ctx)
}

func VisitJsxText(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_JSX_TXT_BEFORE, node, key, ctx)
	CallListener(N_JSX_TXT_AFTER, node, key, ctx)
}

func VisitTsIntersectTyp(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsIntersectTyp)

	CallVisitor(N_TS_INTERSECT_TYP_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_INTERSECT_TYP_AFTER, n, key, ctx)

	VisitNodes(n, n.Elems(), "Elems", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsIntersectTypBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_INTERSECT_TYP_BEFORE, node, key, ctx)
}

func VisitTsIntersectTypAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_INTERSECT_TYP_AFTER, node, key, ctx)
}

func VisitClassBody(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ClassBody)

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	CallVisitor(N_CLASS_BODY_BEFORE, n, key, ctx)
	defer CallVisitor(N_CLASS_BODY_AFTER, n, key, ctx)

	VisitNodes(n, n.Elems(), "Elems", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitClassBodyBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_CLASS_BODY_BEFORE, node, key, ctx)
}

func VisitClassBodyAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_CLASS_BODY_AFTER, node, key, ctx)
}

func VisitTsTypAssert(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsTypAssert)

	CallVisitor(N_TS_TYP_ASSERT_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_TYP_ASSERT_AFTER, n, key, ctx)

	VisitNode(n.Typ(), "Typ", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsTypAssertBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_ASSERT_BEFORE, node, key, ctx)
}

func VisitTsTypAssertAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_TYP_ASSERT_AFTER, node, key, ctx)
}

func VisitBlockStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.BlockStmt)

	ctx.WalkCtx.PushScope()
	defer ctx.WalkCtx.PopScope()

	CallVisitor(N_STMT_BLOCK_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_BLOCK_AFTER, n, key, ctx)

	VisitNodes(n, n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitBlockStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_BLOCK_BEFORE, node, key, ctx)
}

func VisitBlockStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_BLOCK_AFTER, node, key, ctx)
}

func VisitBrkStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.BrkStmt)

	CallVisitor(N_STMT_BRK_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_BRK_AFTER, n, key, ctx)

	VisitNode(n.Label(), "Label", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitBrkStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_BRK_BEFORE, node, key, ctx)
}

func VisitBrkStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_BRK_AFTER, node, key, ctx)
}

func VisitExportDec(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.ExportDec)

	CallVisitor(N_STMT_EXPORT_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_EXPORT_AFTER, n, key, ctx)

	VisitNode(n.Dec(), "Dec", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNodes(n, n.Specs(), "Specs", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Src(), "Src", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitExportDecBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_EXPORT_BEFORE, node, key, ctx)
}

func VisitExportDecAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_EXPORT_AFTER, node, key, ctx)
}

func VisitRegLit(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_LIT_REGEXP_BEFORE, node, key, ctx)
	CallListener(N_LIT_REGEXP_AFTER, node, key, ctx)
}

func VisitVarDecStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.VarDecStmt)

	CallVisitor(N_STMT_VAR_DEC_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_VAR_DEC_AFTER, n, key, ctx)

	VisitNodes(n, n.DecList(), "DecList", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitVarDecStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_VAR_DEC_BEFORE, node, key, ctx)
}

func VisitVarDecStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_VAR_DEC_AFTER, node, key, ctx)
}

func VisitTsProp(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TsProp)

	CallVisitor(N_TS_PROP_BEFORE, n, key, ctx)
	defer CallVisitor(N_TS_PROP_AFTER, n, key, ctx)

	VisitNode(n.Key(), "Key", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Val(), "Val", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTsPropBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PROP_BEFORE, node, key, ctx)
}

func VisitTsPropAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_TS_PROP_AFTER, node, key, ctx)
}

func VisitIfStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.IfStmt)

	CallVisitor(N_STMT_IF_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_IF_AFTER, n, key, ctx)

	VisitNode(n.Test(), "Test", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Cons(), "Cons", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Alt(), "Alt", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitIfStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_IF_BEFORE, node, key, ctx)
}

func VisitIfStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_IF_AFTER, node, key, ctx)
}

func VisitTryStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.TryStmt)

	CallVisitor(N_STMT_TRY_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_TRY_AFTER, n, key, ctx)

	VisitNode(n.Try(), "Try", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Catch(), "Catch", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Fin(), "Fin", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitTryStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_TRY_BEFORE, node, key, ctx)
}

func VisitTryStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_TRY_AFTER, node, key, ctx)
}

func VisitWithStmt(node parser.Node, key string, ctx *VisitorCtx) {
	n := node.(*parser.WithStmt)

	CallVisitor(N_STMT_WITH_BEFORE, n, key, ctx)
	defer CallVisitor(N_STMT_WITH_AFTER, n, key, ctx)

	VisitNode(n.Expr(), "Expr", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}

	VisitNode(n.Body(), "Body", ctx)
	if ctx.WalkCtx.Stopped() {
		return
	}
}

func VisitWithStmtBefore(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_WITH_BEFORE, node, key, ctx)
}

func VisitWithStmtAfter(node parser.Node, key string, ctx *VisitorCtx) {
	CallListener(N_STMT_WITH_AFTER, node, key, ctx)
}

var DefaultVisitors Visitors = [N_BEFORE_AFTER_DEF_END]Visitor{}
var DefaultListeners Listeners = [N_BEFORE_AFTER_DEF_END]*util.OrderedMap[string, *Listener]{}

func init() {
	DefaultVisitors[N_CATCH] = VisitCatch
	DefaultVisitors[N_CATCH_BEFORE] = VisitCatchBefore
	DefaultVisitors[N_CATCH_AFTER] = VisitCatchAfter
	DefaultVisitors[N_CLASS_BODY] = VisitClassBody
	DefaultVisitors[N_CLASS_BODY_BEFORE] = VisitClassBodyBefore
	DefaultVisitors[N_CLASS_BODY_AFTER] = VisitClassBodyAfter
	DefaultVisitors[N_DECORATOR] = VisitDecorator
	DefaultVisitors[N_DECORATOR_BEFORE] = VisitDecoratorBefore
	DefaultVisitors[N_DECORATOR_AFTER] = VisitDecoratorAfter
	DefaultVisitors[N_EXPORT_SPEC] = VisitExportSpec
	DefaultVisitors[N_EXPORT_SPEC_BEFORE] = VisitExportSpecBefore
	DefaultVisitors[N_EXPORT_SPEC_AFTER] = VisitExportSpecAfter
	DefaultVisitors[N_EXPR_ARROW] = VisitArrowFn
	DefaultVisitors[N_EXPR_ARROW_BEFORE] = VisitArrowFnBefore
	DefaultVisitors[N_EXPR_ARROW_AFTER] = VisitArrowFnAfter
	DefaultVisitors[N_EXPR_ASSIGN] = VisitAssignExpr
	DefaultVisitors[N_EXPR_ASSIGN_BEFORE] = VisitAssignExprBefore
	DefaultVisitors[N_EXPR_ASSIGN_AFTER] = VisitAssignExprAfter
	DefaultVisitors[N_EXPR_BIN] = VisitBinExpr
	DefaultVisitors[N_EXPR_BIN_BEFORE] = VisitBinExprBefore
	DefaultVisitors[N_EXPR_BIN_AFTER] = VisitBinExprAfter
	DefaultVisitors[N_EXPR_CALL] = VisitCallExpr
	DefaultVisitors[N_EXPR_CALL_BEFORE] = VisitCallExprBefore
	DefaultVisitors[N_EXPR_CALL_AFTER] = VisitCallExprAfter
	DefaultVisitors[N_EXPR_CHAIN] = VisitChainExpr
	DefaultVisitors[N_EXPR_CHAIN_BEFORE] = VisitChainExprBefore
	DefaultVisitors[N_EXPR_CHAIN_AFTER] = VisitChainExprAfter
	DefaultVisitors[N_EXPR_CLASS] = VisitClassDec
	DefaultVisitors[N_EXPR_CLASS_BEFORE] = VisitClassDecBefore
	DefaultVisitors[N_EXPR_CLASS_AFTER] = VisitClassDecAfter
	DefaultVisitors[N_EXPR_COND] = VisitCondExpr
	DefaultVisitors[N_EXPR_COND_BEFORE] = VisitCondExprBefore
	DefaultVisitors[N_EXPR_COND_AFTER] = VisitCondExprAfter
	DefaultVisitors[N_EXPR_FN] = VisitFnDec
	DefaultVisitors[N_EXPR_FN_BEFORE] = VisitFnDecBefore
	DefaultVisitors[N_EXPR_FN_AFTER] = VisitFnDecAfter
	DefaultVisitors[N_EXPR_MEMBER] = VisitMemberExpr
	DefaultVisitors[N_EXPR_MEMBER_BEFORE] = VisitMemberExprBefore
	DefaultVisitors[N_EXPR_MEMBER_AFTER] = VisitMemberExprAfter
	DefaultVisitors[N_EXPR_NEW] = VisitNewExpr
	DefaultVisitors[N_EXPR_NEW_BEFORE] = VisitNewExprBefore
	DefaultVisitors[N_EXPR_NEW_AFTER] = VisitNewExprAfter
	DefaultVisitors[N_EXPR_PAREN] = VisitParenExpr
	DefaultVisitors[N_EXPR_PAREN_BEFORE] = VisitParenExprBefore
	DefaultVisitors[N_EXPR_PAREN_AFTER] = VisitParenExprAfter
	DefaultVisitors[N_EXPR_SEQ] = VisitSeqExpr
	DefaultVisitors[N_EXPR_SEQ_BEFORE] = VisitSeqExprBefore
	DefaultVisitors[N_EXPR_SEQ_AFTER] = VisitSeqExprAfter
	DefaultVisitors[N_EXPR_THIS] = VisitThisExpr
	DefaultVisitors[N_EXPR_TPL] = VisitTplExpr
	DefaultVisitors[N_EXPR_TPL_BEFORE] = VisitTplExprBefore
	DefaultVisitors[N_EXPR_TPL_AFTER] = VisitTplExprAfter
	DefaultVisitors[N_EXPR_UNARY] = VisitUnaryExpr
	DefaultVisitors[N_EXPR_UNARY_BEFORE] = VisitUnaryExprBefore
	DefaultVisitors[N_EXPR_UNARY_AFTER] = VisitUnaryExprAfter
	DefaultVisitors[N_EXPR_UPDATE] = VisitUpdateExpr
	DefaultVisitors[N_EXPR_UPDATE_BEFORE] = VisitUpdateExprBefore
	DefaultVisitors[N_EXPR_UPDATE_AFTER] = VisitUpdateExprAfter
	DefaultVisitors[N_EXPR_YIELD] = VisitYieldExpr
	DefaultVisitors[N_EXPR_YIELD_BEFORE] = VisitYieldExprBefore
	DefaultVisitors[N_EXPR_YIELD_AFTER] = VisitYieldExprAfter
	DefaultVisitors[N_FIELD] = VisitField
	DefaultVisitors[N_FIELD_BEFORE] = VisitFieldBefore
	DefaultVisitors[N_FIELD_AFTER] = VisitFieldAfter
	DefaultVisitors[N_IMPORT_CALL] = VisitImportCall
	DefaultVisitors[N_IMPORT_CALL_BEFORE] = VisitImportCallBefore
	DefaultVisitors[N_IMPORT_CALL_AFTER] = VisitImportCallAfter
	DefaultVisitors[N_IMPORT_SPEC] = VisitImportSpec
	DefaultVisitors[N_IMPORT_SPEC_BEFORE] = VisitImportSpecBefore
	DefaultVisitors[N_IMPORT_SPEC_AFTER] = VisitImportSpecAfter
	DefaultVisitors[N_JSX_ATTR] = VisitJsxAttr
	DefaultVisitors[N_JSX_ATTR_BEFORE] = VisitJsxAttrBefore
	DefaultVisitors[N_JSX_ATTR_AFTER] = VisitJsxAttrAfter
	DefaultVisitors[N_JSX_ATTR_SPREAD] = VisitJsxSpreadAttr
	DefaultVisitors[N_JSX_ATTR_SPREAD_BEFORE] = VisitJsxSpreadAttrBefore
	DefaultVisitors[N_JSX_ATTR_SPREAD_AFTER] = VisitJsxSpreadAttrAfter
	DefaultVisitors[N_JSX_CHILD_SPREAD] = VisitJsxSpreadChild
	DefaultVisitors[N_JSX_CHILD_SPREAD_BEFORE] = VisitJsxSpreadChildBefore
	DefaultVisitors[N_JSX_CHILD_SPREAD_AFTER] = VisitJsxSpreadChildAfter
	DefaultVisitors[N_JSX_CLOSE] = VisitJsxClose
	DefaultVisitors[N_JSX_CLOSE_BEFORE] = VisitJsxCloseBefore
	DefaultVisitors[N_JSX_CLOSE_AFTER] = VisitJsxCloseAfter
	DefaultVisitors[N_JSX_ELEM] = VisitJsxElem
	DefaultVisitors[N_JSX_ELEM_BEFORE] = VisitJsxElemBefore
	DefaultVisitors[N_JSX_ELEM_AFTER] = VisitJsxElemAfter
	DefaultVisitors[N_JSX_EMPTY] = VisitJsxEmpty
	DefaultVisitors[N_JSX_EXPR_SPAN] = VisitJsxExprSpan
	DefaultVisitors[N_JSX_EXPR_SPAN_BEFORE] = VisitJsxExprSpanBefore
	DefaultVisitors[N_JSX_EXPR_SPAN_AFTER] = VisitJsxExprSpanAfter
	DefaultVisitors[N_JSX_ID] = VisitJsxIdent
	DefaultVisitors[N_JSX_MEMBER] = VisitJsxMember
	DefaultVisitors[N_JSX_MEMBER_BEFORE] = VisitJsxMemberBefore
	DefaultVisitors[N_JSX_MEMBER_AFTER] = VisitJsxMemberAfter
	DefaultVisitors[N_JSX_NS] = VisitJsxNsName
	DefaultVisitors[N_JSX_OPEN] = VisitJsxOpen
	DefaultVisitors[N_JSX_OPEN_BEFORE] = VisitJsxOpenBefore
	DefaultVisitors[N_JSX_OPEN_AFTER] = VisitJsxOpenAfter
	DefaultVisitors[N_JSX_TXT] = VisitJsxText
	DefaultVisitors[N_LIT_ARR] = VisitArrLit
	DefaultVisitors[N_LIT_ARR_BEFORE] = VisitArrLitBefore
	DefaultVisitors[N_LIT_ARR_AFTER] = VisitArrLitAfter
	DefaultVisitors[N_LIT_BOOL] = VisitBoolLit
	DefaultVisitors[N_LIT_NULL] = VisitNullLit
	DefaultVisitors[N_LIT_NUM] = VisitNumLit
	DefaultVisitors[N_LIT_OBJ] = VisitObjLit
	DefaultVisitors[N_LIT_OBJ_BEFORE] = VisitObjLitBefore
	DefaultVisitors[N_LIT_OBJ_AFTER] = VisitObjLitAfter
	DefaultVisitors[N_LIT_REGEXP] = VisitRegLit
	DefaultVisitors[N_LIT_STR] = VisitStrLit
	DefaultVisitors[N_META_PROP] = VisitMetaProp
	DefaultVisitors[N_META_PROP_BEFORE] = VisitMetaPropBefore
	DefaultVisitors[N_META_PROP_AFTER] = VisitMetaPropAfter
	DefaultVisitors[N_METHOD] = VisitMethod
	DefaultVisitors[N_METHOD_BEFORE] = VisitMethodBefore
	DefaultVisitors[N_METHOD_AFTER] = VisitMethodAfter
	DefaultVisitors[N_NAME] = VisitIdent
	DefaultVisitors[N_PAT_ARRAY] = VisitArrPat
	DefaultVisitors[N_PAT_ARRAY_BEFORE] = VisitArrPatBefore
	DefaultVisitors[N_PAT_ARRAY_AFTER] = VisitArrPatAfter
	DefaultVisitors[N_PAT_ASSIGN] = VisitAssignPat
	DefaultVisitors[N_PAT_ASSIGN_BEFORE] = VisitAssignPatBefore
	DefaultVisitors[N_PAT_ASSIGN_AFTER] = VisitAssignPatAfter
	DefaultVisitors[N_PAT_OBJ] = VisitObjPat
	DefaultVisitors[N_PAT_OBJ_BEFORE] = VisitObjPatBefore
	DefaultVisitors[N_PAT_OBJ_AFTER] = VisitObjPatAfter
	DefaultVisitors[N_PAT_REST] = VisitRestPat
	DefaultVisitors[N_PAT_REST_BEFORE] = VisitRestPatBefore
	DefaultVisitors[N_PAT_REST_AFTER] = VisitRestPatAfter
	DefaultVisitors[N_PROG] = VisitProg
	DefaultVisitors[N_PROG_BEFORE] = VisitProgBefore
	DefaultVisitors[N_PROG_AFTER] = VisitProgAfter
	DefaultVisitors[N_PROP] = VisitProp
	DefaultVisitors[N_PROP_BEFORE] = VisitPropBefore
	DefaultVisitors[N_PROP_AFTER] = VisitPropAfter
	DefaultVisitors[N_SPREAD] = VisitSpread
	DefaultVisitors[N_SPREAD_BEFORE] = VisitSpreadBefore
	DefaultVisitors[N_SPREAD_AFTER] = VisitSpreadAfter
	DefaultVisitors[N_STATIC_BLOCK] = VisitStaticBlock
	DefaultVisitors[N_STATIC_BLOCK_BEFORE] = VisitStaticBlockBefore
	DefaultVisitors[N_STATIC_BLOCK_AFTER] = VisitStaticBlockAfter
	DefaultVisitors[N_STMT_BLOCK] = VisitBlockStmt
	DefaultVisitors[N_STMT_BLOCK_BEFORE] = VisitBlockStmtBefore
	DefaultVisitors[N_STMT_BLOCK_AFTER] = VisitBlockStmtAfter
	DefaultVisitors[N_STMT_BRK] = VisitBrkStmt
	DefaultVisitors[N_STMT_BRK_BEFORE] = VisitBrkStmtBefore
	DefaultVisitors[N_STMT_BRK_AFTER] = VisitBrkStmtAfter
	DefaultVisitors[N_STMT_CLASS] = VisitClassDec
	DefaultVisitors[N_STMT_CLASS_BEFORE] = VisitClassDecBefore
	DefaultVisitors[N_STMT_CLASS_AFTER] = VisitClassDecAfter
	DefaultVisitors[N_STMT_CONT] = VisitContStmt
	DefaultVisitors[N_STMT_CONT_BEFORE] = VisitContStmtBefore
	DefaultVisitors[N_STMT_CONT_AFTER] = VisitContStmtAfter
	DefaultVisitors[N_STMT_DEBUG] = VisitDebugStmt
	DefaultVisitors[N_STMT_DO_WHILE] = VisitDoWhileStmt
	DefaultVisitors[N_STMT_DO_WHILE_BEFORE] = VisitDoWhileStmtBefore
	DefaultVisitors[N_STMT_DO_WHILE_AFTER] = VisitDoWhileStmtAfter
	DefaultVisitors[N_STMT_EXPORT] = VisitExportDec
	DefaultVisitors[N_STMT_EXPORT_BEFORE] = VisitExportDecBefore
	DefaultVisitors[N_STMT_EXPORT_AFTER] = VisitExportDecAfter
	DefaultVisitors[N_STMT_EXPR] = VisitExprStmt
	DefaultVisitors[N_STMT_EXPR_BEFORE] = VisitExprStmtBefore
	DefaultVisitors[N_STMT_EXPR_AFTER] = VisitExprStmtAfter
	DefaultVisitors[N_STMT_FN] = VisitFnDec
	DefaultVisitors[N_STMT_FN_BEFORE] = VisitFnDecBefore
	DefaultVisitors[N_STMT_FN_AFTER] = VisitFnDecAfter
	DefaultVisitors[N_STMT_FOR] = VisitForStmt
	DefaultVisitors[N_STMT_FOR_BEFORE] = VisitForStmtBefore
	DefaultVisitors[N_STMT_FOR_AFTER] = VisitForStmtAfter
	DefaultVisitors[N_STMT_FOR_IN_OF] = VisitForInOfStmt
	DefaultVisitors[N_STMT_FOR_IN_OF_BEFORE] = VisitForInOfStmtBefore
	DefaultVisitors[N_STMT_FOR_IN_OF_AFTER] = VisitForInOfStmtAfter
	DefaultVisitors[N_STMT_IF] = VisitIfStmt
	DefaultVisitors[N_STMT_IF_BEFORE] = VisitIfStmtBefore
	DefaultVisitors[N_STMT_IF_AFTER] = VisitIfStmtAfter
	DefaultVisitors[N_STMT_IMPORT] = VisitImportDec
	DefaultVisitors[N_STMT_IMPORT_BEFORE] = VisitImportDecBefore
	DefaultVisitors[N_STMT_IMPORT_AFTER] = VisitImportDecAfter
	DefaultVisitors[N_STMT_LABEL] = VisitLabelStmt
	DefaultVisitors[N_STMT_LABEL_BEFORE] = VisitLabelStmtBefore
	DefaultVisitors[N_STMT_LABEL_AFTER] = VisitLabelStmtAfter
	DefaultVisitors[N_STMT_RET] = VisitRetStmt
	DefaultVisitors[N_STMT_RET_BEFORE] = VisitRetStmtBefore
	DefaultVisitors[N_STMT_RET_AFTER] = VisitRetStmtAfter
	DefaultVisitors[N_STMT_SWITCH] = VisitSwitchStmt
	DefaultVisitors[N_STMT_SWITCH_BEFORE] = VisitSwitchStmtBefore
	DefaultVisitors[N_STMT_SWITCH_AFTER] = VisitSwitchStmtAfter
	DefaultVisitors[N_STMT_THROW] = VisitThrowStmt
	DefaultVisitors[N_STMT_THROW_BEFORE] = VisitThrowStmtBefore
	DefaultVisitors[N_STMT_THROW_AFTER] = VisitThrowStmtAfter
	DefaultVisitors[N_STMT_TRY] = VisitTryStmt
	DefaultVisitors[N_STMT_TRY_BEFORE] = VisitTryStmtBefore
	DefaultVisitors[N_STMT_TRY_AFTER] = VisitTryStmtAfter
	DefaultVisitors[N_STMT_VAR_DEC] = VisitVarDecStmt
	DefaultVisitors[N_STMT_VAR_DEC_BEFORE] = VisitVarDecStmtBefore
	DefaultVisitors[N_STMT_VAR_DEC_AFTER] = VisitVarDecStmtAfter
	DefaultVisitors[N_STMT_WHILE] = VisitWhileStmt
	DefaultVisitors[N_STMT_WHILE_BEFORE] = VisitWhileStmtBefore
	DefaultVisitors[N_STMT_WHILE_AFTER] = VisitWhileStmtAfter
	DefaultVisitors[N_STMT_WITH] = VisitWithStmt
	DefaultVisitors[N_STMT_WITH_BEFORE] = VisitWithStmtBefore
	DefaultVisitors[N_STMT_WITH_AFTER] = VisitWithStmtAfter
	DefaultVisitors[N_SUPER] = VisitSuper
	DefaultVisitors[N_SWITCH_CASE] = VisitSwitchCase
	DefaultVisitors[N_SWITCH_CASE_BEFORE] = VisitSwitchCaseBefore
	DefaultVisitors[N_SWITCH_CASE_AFTER] = VisitSwitchCaseAfter
	DefaultVisitors[N_TS_ANY] = VisitTsPredef
	DefaultVisitors[N_TS_ARR] = VisitTsArr
	DefaultVisitors[N_TS_ARR_BEFORE] = VisitTsArrBefore
	DefaultVisitors[N_TS_ARR_AFTER] = VisitTsArrAfter
	DefaultVisitors[N_TS_BIGINT] = VisitTsPredef
	DefaultVisitors[N_TS_BOOL] = VisitTsPredef
	DefaultVisitors[N_TS_CALL_SIG] = VisitTsCallSig
	DefaultVisitors[N_TS_CALL_SIG_BEFORE] = VisitTsCallSigBefore
	DefaultVisitors[N_TS_CALL_SIG_AFTER] = VisitTsCallSigAfter
	DefaultVisitors[N_TS_COND] = VisitTsCondType
	DefaultVisitors[N_TS_COND_BEFORE] = VisitTsCondTypeBefore
	DefaultVisitors[N_TS_COND_AFTER] = VisitTsCondTypeAfter
	DefaultVisitors[N_TS_DEC_CLASS] = VisitTsDec
	DefaultVisitors[N_TS_DEC_CLASS_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_CLASS_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_DEC_ENUM] = VisitTsDec
	DefaultVisitors[N_TS_DEC_ENUM_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_ENUM_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_DEC_FN] = VisitTsDec
	DefaultVisitors[N_TS_DEC_FN_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_FN_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_DEC_GLOBAL] = VisitTsDec
	DefaultVisitors[N_TS_DEC_GLOBAL_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_GLOBAL_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_DEC_INTERFACE] = VisitTsDec
	DefaultVisitors[N_TS_DEC_INTERFACE_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_INTERFACE_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_DEC_MODULE] = VisitTsDec
	DefaultVisitors[N_TS_DEC_MODULE_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_MODULE_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_DEC_NS] = VisitTsDec
	DefaultVisitors[N_TS_DEC_NS_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_NS_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_DEC_TYP_DEC] = VisitTsDec
	DefaultVisitors[N_TS_DEC_TYP_DEC_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_TYP_DEC_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_DEC_VAR_DEC] = VisitTsDec
	DefaultVisitors[N_TS_DEC_VAR_DEC_BEFORE] = VisitTsDecBefore
	DefaultVisitors[N_TS_DEC_VAR_DEC_AFTER] = VisitTsDecAfter
	DefaultVisitors[N_TS_ENUM] = VisitTsEnum
	DefaultVisitors[N_TS_ENUM_BEFORE] = VisitTsEnumBefore
	DefaultVisitors[N_TS_ENUM_AFTER] = VisitTsEnumAfter
	DefaultVisitors[N_TS_ENUM_MEMBER] = VisitTsEnumMember
	DefaultVisitors[N_TS_ENUM_MEMBER_BEFORE] = VisitTsEnumMemberBefore
	DefaultVisitors[N_TS_ENUM_MEMBER_AFTER] = VisitTsEnumMemberAfter
	DefaultVisitors[N_TS_EXPORT_ASSIGN] = VisitTsExportAssign
	DefaultVisitors[N_TS_EXPORT_ASSIGN_BEFORE] = VisitTsExportAssignBefore
	DefaultVisitors[N_TS_EXPORT_ASSIGN_AFTER] = VisitTsExportAssignAfter
	DefaultVisitors[N_TS_FN_TYP] = VisitTsFnTyp
	DefaultVisitors[N_TS_FN_TYP_BEFORE] = VisitTsFnTypBefore
	DefaultVisitors[N_TS_FN_TYP_AFTER] = VisitTsFnTypAfter
	DefaultVisitors[N_TS_IDX_ACCESS] = VisitTsIdxAccess
	DefaultVisitors[N_TS_IDX_ACCESS_BEFORE] = VisitTsIdxAccessBefore
	DefaultVisitors[N_TS_IDX_ACCESS_AFTER] = VisitTsIdxAccessAfter
	DefaultVisitors[N_TS_IDX_SIG] = VisitTsIdxSig
	DefaultVisitors[N_TS_IDX_SIG_BEFORE] = VisitTsIdxSigBefore
	DefaultVisitors[N_TS_IDX_SIG_AFTER] = VisitTsIdxSigAfter
	DefaultVisitors[N_TS_IMPORT_ALIAS] = VisitTsImportAlias
	DefaultVisitors[N_TS_IMPORT_ALIAS_BEFORE] = VisitTsImportAliasBefore
	DefaultVisitors[N_TS_IMPORT_ALIAS_AFTER] = VisitTsImportAliasAfter
	DefaultVisitors[N_TS_IMPORT_REQUIRE] = VisitTsImportRequire
	DefaultVisitors[N_TS_IMPORT_REQUIRE_BEFORE] = VisitTsImportRequireBefore
	DefaultVisitors[N_TS_IMPORT_REQUIRE_AFTER] = VisitTsImportRequireAfter
	DefaultVisitors[N_TS_IMPORT_TYP] = VisitTsImportType
	DefaultVisitors[N_TS_IMPORT_TYP_BEFORE] = VisitTsImportTypeBefore
	DefaultVisitors[N_TS_IMPORT_TYP_AFTER] = VisitTsImportTypeAfter
	DefaultVisitors[N_TS_INTERFACE] = VisitTsInterface
	DefaultVisitors[N_TS_INTERFACE_BEFORE] = VisitTsInterfaceBefore
	DefaultVisitors[N_TS_INTERFACE_AFTER] = VisitTsInterfaceAfter
	DefaultVisitors[N_TS_INTERFACE_BODY] = VisitTsInterfaceBody
	DefaultVisitors[N_TS_INTERFACE_BODY_BEFORE] = VisitTsInterfaceBodyBefore
	DefaultVisitors[N_TS_INTERFACE_BODY_AFTER] = VisitTsInterfaceBodyAfter
	DefaultVisitors[N_TS_INTERSECT_TYP] = VisitTsIntersectTyp
	DefaultVisitors[N_TS_INTERSECT_TYP_BEFORE] = VisitTsIntersectTypBefore
	DefaultVisitors[N_TS_INTERSECT_TYP_AFTER] = VisitTsIntersectTypAfter
	DefaultVisitors[N_TS_INTRINSIC] = VisitTsPredef
	DefaultVisitors[N_TS_LIT] = VisitTsLit
	DefaultVisitors[N_TS_LIT_BEFORE] = VisitTsLitBefore
	DefaultVisitors[N_TS_LIT_AFTER] = VisitTsLitAfter
	DefaultVisitors[N_TS_LIT_OBJ] = VisitTsObj
	DefaultVisitors[N_TS_LIT_OBJ_BEFORE] = VisitTsObjBefore
	DefaultVisitors[N_TS_LIT_OBJ_AFTER] = VisitTsObjAfter
	DefaultVisitors[N_TS_MAPPED] = VisitTsMapped
	DefaultVisitors[N_TS_MAPPED_BEFORE] = VisitTsMappedBefore
	DefaultVisitors[N_TS_MAPPED_AFTER] = VisitTsMappedAfter
	DefaultVisitors[N_TS_NAMESPACE] = VisitTsNS
	DefaultVisitors[N_TS_NAMESPACE_BEFORE] = VisitTsNSBefore
	DefaultVisitors[N_TS_NAMESPACE_AFTER] = VisitTsNSAfter
	DefaultVisitors[N_TS_NEVER] = VisitTsPredef
	DefaultVisitors[N_TS_NEW] = VisitTsNewSig
	DefaultVisitors[N_TS_NEW_BEFORE] = VisitTsNewSigBefore
	DefaultVisitors[N_TS_NEW_AFTER] = VisitTsNewSigAfter
	DefaultVisitors[N_TS_NEW_SIG] = VisitTsNewSig
	DefaultVisitors[N_TS_NEW_SIG_BEFORE] = VisitTsNewSigBefore
	DefaultVisitors[N_TS_NEW_SIG_AFTER] = VisitTsNewSigAfter
	DefaultVisitors[N_TS_NO_NULL] = VisitTsNoNull
	DefaultVisitors[N_TS_NO_NULL_BEFORE] = VisitTsNoNullBefore
	DefaultVisitors[N_TS_NO_NULL_AFTER] = VisitTsNoNullAfter
	DefaultVisitors[N_TS_NS_NAME] = VisitTsNsName
	DefaultVisitors[N_TS_NS_NAME_BEFORE] = VisitTsNsNameBefore
	DefaultVisitors[N_TS_NS_NAME_AFTER] = VisitTsNsNameAfter
	DefaultVisitors[N_TS_NULL] = VisitTsPredef
	DefaultVisitors[N_TS_NUM] = VisitTsPredef
	DefaultVisitors[N_TS_OBJ] = VisitTsPredef
	DefaultVisitors[N_TS_OPT] = VisitTsOpt
	DefaultVisitors[N_TS_OPT_BEFORE] = VisitTsOptBefore
	DefaultVisitors[N_TS_OPT_AFTER] = VisitTsOptAfter
	DefaultVisitors[N_TS_PARAM] = VisitTsParam
	DefaultVisitors[N_TS_PARAM_BEFORE] = VisitTsParamBefore
	DefaultVisitors[N_TS_PARAM_AFTER] = VisitTsParamAfter
	DefaultVisitors[N_TS_PARAM_DEC] = VisitTsParamsDec
	DefaultVisitors[N_TS_PARAM_DEC_BEFORE] = VisitTsParamsDecBefore
	DefaultVisitors[N_TS_PARAM_DEC_AFTER] = VisitTsParamsDecAfter
	DefaultVisitors[N_TS_PARAM_INST] = VisitTsParamsInst
	DefaultVisitors[N_TS_PARAM_INST_BEFORE] = VisitTsParamsInstBefore
	DefaultVisitors[N_TS_PARAM_INST_AFTER] = VisitTsParamsInstAfter
	DefaultVisitors[N_TS_PAREN] = VisitTsParen
	DefaultVisitors[N_TS_PAREN_BEFORE] = VisitTsParenBefore
	DefaultVisitors[N_TS_PAREN_AFTER] = VisitTsParenAfter
	DefaultVisitors[N_TS_PROP] = VisitTsProp
	DefaultVisitors[N_TS_PROP_BEFORE] = VisitTsPropBefore
	DefaultVisitors[N_TS_PROP_AFTER] = VisitTsPropAfter
	DefaultVisitors[N_TS_REF] = VisitTsRef
	DefaultVisitors[N_TS_REF_BEFORE] = VisitTsRefBefore
	DefaultVisitors[N_TS_REF_AFTER] = VisitTsRefAfter
	DefaultVisitors[N_TS_REST] = VisitTsRest
	DefaultVisitors[N_TS_REST_BEFORE] = VisitTsRestBefore
	DefaultVisitors[N_TS_REST_AFTER] = VisitTsRestAfter
	DefaultVisitors[N_TS_ROUGH_PARAM] = VisitTsRoughParam
	DefaultVisitors[N_TS_STR] = VisitTsPredef
	DefaultVisitors[N_TS_SYM] = VisitTsPredef
	DefaultVisitors[N_TS_THIS] = VisitTsThis
	DefaultVisitors[N_TS_TUPLE] = VisitTsTuple
	DefaultVisitors[N_TS_TUPLE_BEFORE] = VisitTsTupleBefore
	DefaultVisitors[N_TS_TUPLE_AFTER] = VisitTsTupleAfter
	DefaultVisitors[N_TS_TUPLE_NAMED_MEMBER] = VisitTsTupleNamedMember
	DefaultVisitors[N_TS_TUPLE_NAMED_MEMBER_BEFORE] = VisitTsTupleNamedMemberBefore
	DefaultVisitors[N_TS_TUPLE_NAMED_MEMBER_AFTER] = VisitTsTupleNamedMemberAfter
	DefaultVisitors[N_TS_TYP_ANNOT] = VisitTsTypAnnot
	DefaultVisitors[N_TS_TYP_ANNOT_BEFORE] = VisitTsTypAnnotBefore
	DefaultVisitors[N_TS_TYP_ANNOT_AFTER] = VisitTsTypAnnotAfter
	DefaultVisitors[N_TS_TYP_ASSERT] = VisitTsTypAssert
	DefaultVisitors[N_TS_TYP_ASSERT_BEFORE] = VisitTsTypAssertBefore
	DefaultVisitors[N_TS_TYP_ASSERT_AFTER] = VisitTsTypAssertAfter
	DefaultVisitors[N_TS_TYP_DEC] = VisitTsTypDec
	DefaultVisitors[N_TS_TYP_DEC_BEFORE] = VisitTsTypDecBefore
	DefaultVisitors[N_TS_TYP_DEC_AFTER] = VisitTsTypDecAfter
	DefaultVisitors[N_TS_TYP_INFER] = VisitTsTypInfer
	DefaultVisitors[N_TS_TYP_INFER_BEFORE] = VisitTsTypInferBefore
	DefaultVisitors[N_TS_TYP_INFER_AFTER] = VisitTsTypInferAfter
	DefaultVisitors[N_TS_TYP_OP] = VisitTsTypOp
	DefaultVisitors[N_TS_TYP_OP_BEFORE] = VisitTsTypOpBefore
	DefaultVisitors[N_TS_TYP_OP_AFTER] = VisitTsTypOpAfter
	DefaultVisitors[N_TS_TYP_PREDICATE] = VisitTsTypPredicate
	DefaultVisitors[N_TS_TYP_PREDICATE_BEFORE] = VisitTsTypPredicateBefore
	DefaultVisitors[N_TS_TYP_PREDICATE_AFTER] = VisitTsTypPredicateAfter
	DefaultVisitors[N_TS_TYP_QUERY] = VisitTsTypQuery
	DefaultVisitors[N_TS_TYP_QUERY_BEFORE] = VisitTsTypQueryBefore
	DefaultVisitors[N_TS_TYP_QUERY_AFTER] = VisitTsTypQueryAfter
	DefaultVisitors[N_TS_UNDEF] = VisitTsPredef
	DefaultVisitors[N_TS_UNION_TYP] = VisitTsUnionTyp
	DefaultVisitors[N_TS_UNION_TYP_BEFORE] = VisitTsUnionTypBefore
	DefaultVisitors[N_TS_UNION_TYP_AFTER] = VisitTsUnionTypAfter
	DefaultVisitors[N_TS_UNKNOWN] = VisitTsPredef
	DefaultVisitors[N_TS_VOID] = VisitTsPredef
	DefaultVisitors[N_VAR_DEC] = VisitVarDec
	DefaultVisitors[N_VAR_DEC_BEFORE] = VisitVarDecBefore
	DefaultVisitors[N_VAR_DEC_AFTER] = VisitVarDecAfter

	DefaultListeners[N_CATCH] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_CLASS_BODY] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_DECORATOR] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPORT_SPEC] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_ARROW] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_ASSIGN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_BIN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_CALL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_CHAIN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_CLASS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_COND] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_FN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_MEMBER] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_NEW] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_PAREN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_SEQ] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_THIS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_TPL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_UNARY] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_UPDATE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_EXPR_YIELD] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_FIELD] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_IMPORT_CALL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_IMPORT_SPEC] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_ATTR] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_ATTR_SPREAD] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_CHILD_SPREAD] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_CLOSE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_ELEM] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_EMPTY] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_EXPR_SPAN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_ID] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_MEMBER] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_NS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_OPEN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_JSX_TXT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_LIT_ARR] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_LIT_BOOL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_LIT_NULL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_LIT_NUM] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_LIT_OBJ] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_LIT_REGEXP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_LIT_STR] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_META_PROP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_METHOD] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_NAME] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_PAT_ARRAY] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_PAT_ASSIGN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_PAT_OBJ] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_PAT_REST] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_PROG] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_PROP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_SPREAD] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STATIC_BLOCK] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_BLOCK] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_BRK] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_CLASS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_CONT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_DEBUG] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_DO_WHILE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_EXPORT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_EXPR] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_FN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_FOR] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_FOR_IN_OF] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_IF] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_IMPORT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_LABEL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_RET] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_SWITCH] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_THROW] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_TRY] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_VAR_DEC] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_WHILE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_STMT_WITH] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_SUPER] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_SWITCH_CASE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_ANY] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_ARR] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_BIGINT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_BOOL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_CALL_SIG] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_COND] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_CLASS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_ENUM] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_FN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_GLOBAL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_INTERFACE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_MODULE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_NS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_TYP_DEC] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_DEC_VAR_DEC] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_ENUM] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_ENUM_MEMBER] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_EXPORT_ASSIGN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_FN_TYP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_IDX_ACCESS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_IDX_SIG] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_IMPORT_ALIAS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_IMPORT_REQUIRE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_IMPORT_TYP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_INTERFACE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_INTERFACE_BODY] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_INTERSECT_TYP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_INTRINSIC] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_LIT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_LIT_OBJ] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_MAPPED] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_NAMESPACE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_NEVER] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_NEW] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_NEW_SIG] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_NO_NULL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_NS_NAME] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_NULL] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_NUM] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_OBJ] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_OPT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_PARAM] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_PARAM_DEC] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_PARAM_INST] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_PAREN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_PROP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_REF] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_REST] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_ROUGH_PARAM] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_STR] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_SYM] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_THIS] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TUPLE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TUPLE_NAMED_MEMBER] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TYP_ANNOT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TYP_ASSERT] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TYP_DEC] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TYP_INFER] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TYP_OP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TYP_PREDICATE] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_TYP_QUERY] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_UNDEF] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_UNION_TYP] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_UNKNOWN] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_TS_VOID] = util.NewOrderedMap[string, *Listener]()
	DefaultListeners[N_VAR_DEC] = util.NewOrderedMap[string, *Listener]()
}