(grammar (start program) (matching longest) (settling tokens precedence dynamic ambiguity))
(extra (ref comment))
(extra (ref html_comment))
(extra (class plain (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B) (category Zs) (char %EF%BB%BF) (char %E2%80%A8) (char %E2%80%A9) (char %E2%81%A0) (char %E2%80%8B)))
(conflict primary_expression property_name)
(conflict primary_expression await_expression)
(conflict primary_expression await_expression property_name)
(conflict primary_expression arrow_function)
(conflict primary_expression arrow_function property_name)
(conflict primary_expression method_definition)
(conflict primary_expression rest_pattern)
(conflict primary_expression pattern)
(conflict primary_expression for_header)
(conflict variable_declarator for_header)
(conflict array array_pattern)
(conflict object object_pattern)
(conflict assignment_expression pattern)
(conflict assignment_expression object_assignment_pattern)
(conflict labeled_statement property_name)
(conflict computed_property_name array)
(conflict binary_expression initializer)
(conflict class_static_block property_name)
(precedences (name member) (name template_call) (name call) (rule update_expression) (name unary_void) (name binary_exp) (name binary_times) (name binary_plus) (name binary_shift) (name binary_compare) (name binary_relation) (name binary_equality) (name bitwise_and) (name bitwise_xor) (name bitwise_or) (name logical_and) (name logical_or) (name ternary) (rule sequence_expression) (rule arrow_function))
(precedences (name assign) (rule primary_expression))
(precedences (name member) (name template_call) (name new) (name call) (rule expression))
(precedences (name declaration) (name literal))
(precedences (rule primary_expression) (rule statement_block) (name object))
(precedences (rule meta_property) (rule import))
(precedences (rule import_statement) (rule import))
(precedences (rule export_statement) (rule primary_expression))
(precedences (rule lexical_declaration) (rule primary_expression))
(scanner automatic_semicolon (tokens automatic_semicolon) (operations (if atEnd (then (emit automatic_semicolon))) mark (push looking (integer 1)) (while (greater (depth looking) (integer 0)) (do (if atEnd (then (while (greater (depth looking) (integer 0)) (do (pop looking))) (emit automatic_semicolon))) (if (next (literal %2F)) (then (push scanning (integer 1)) (while (greater (depth scanning) (integer 0)) (do (while (next (class plain (char %20) (char %09) (char %0A) (char %0B) (char %0C) (char %0D))) (do advance)) (if (next (literal %2F)) (then advance (if (next (literal %2F)) (then advance (while (not (some atEnd (some (next (literal %0A)) (next (literal %E2%80%A8)) (next (literal %E2%80%A9))))) (do advance))) (else (if (next (literal %2A)) (then advance (push block (integer 1)) (while (all (greater (depth block) (integer 0)) (not atEnd)) (do (if (next (literal %2A)) (then advance (if (next (literal %2F)) (then advance (while (greater (depth block) (integer 0)) (do (pop block))) (if (not (next (literal %2F))) (then (if (greater (depth block_newline) (integer 0)) (then (push accept (integer 1)))) (while (greater (depth scanning) (integer 0)) (do (pop scanning)))))))) (else (if (some (next (literal %0A)) (next (literal %E2%80%A8)) (next (literal %E2%80%A9))) (then (if (equal (depth block_newline) (integer 0)) (then (push block_newline (integer 1)))) advance) (else advance)))))) (while (greater (depth block) (integer 0)) (do (pop block)))) (else fail))))) (else (push accept (integer 1)) (while (greater (depth scanning) (integer 0)) (do (pop scanning))))))) (while (greater (depth block_newline) (integer 0)) (do (pop block_newline))) (if (all (greater (depth accept) (integer 0)) (not (expected (literal %7C%7C))) (not (some (next (literal %2C)) (next (literal %3D))))) (then (while (greater (depth accept) (integer 0)) (do (pop accept))) (while (greater (depth looking) (integer 0)) (do (pop looking))) (emit automatic_semicolon))) (while (greater (depth accept) (integer 0)) (do (pop accept))))) (if (next (literal %7D)) (then (while (greater (depth looking) (integer 0)) (do (pop looking))) (emit automatic_semicolon))) (if (some (next (literal %0A)) (next (literal %E2%80%A8)) (next (literal %E2%80%A9))) (then (while (greater (depth looking) (integer 0)) (do (pop looking)))) (else (if (not (next (class plain (char %20) (char %09) (char %0A) (char %0B) (char %0C) (char %0D)))) (then fail)) advance)))) advance (push scanning (integer 1)) (while (greater (depth scanning) (integer 0)) (do (while (next (class plain (char %20) (char %09) (char %0A) (char %0B) (char %0C) (char %0D))) (do advance)) (if (next (literal %2F)) (then advance (if (next (literal %2F)) (then advance (while (not (some atEnd (some (next (literal %0A)) (next (literal %E2%80%A8)) (next (literal %E2%80%A9))))) (do advance))) (else (if (next (literal %2A)) (then advance (push block (integer 1)) (while (all (greater (depth block) (integer 0)) (not atEnd)) (do (if (next (literal %2A)) (then advance (if (next (literal %2F)) (then advance (while (greater (depth block) (integer 0)) (do (pop block)))))) (else (if (some (next (literal %0A)) (next (literal %E2%80%A8)) (next (literal %E2%80%A9))) (then (if (equal (depth block_newline) (integer 0)) (then (push block_newline (integer 1)))) advance) (else advance)))))) (while (greater (depth block) (integer 0)) (do (pop block)))) (else fail))))) (else (while (greater (depth scanning) (integer 0)) (do (pop scanning))))))) (while (greater (depth block_newline) (integer 0)) (do (pop block_newline))) (if (some (next (literal %60)) (next (literal %2C)) (next (literal %3A)) (next (literal %3B)) (next (literal %2A)) (next (literal %25)) (next (literal %3E)) (next (literal %3C)) (next (literal %3D)) (next (literal %5B)) (next (literal %28)) (next (literal %3F)) (next (literal %5E)) (next (literal %7C)) (next (literal %26)) (next (literal %2F))) (then fail)) (if (next (literal .)) (then (if (next (seq (literal .) (class plain (range 0 9)))) (then (emit automatic_semicolon)) (else fail)))) (if (next (literal %2B)) (then (if (next (literal %2B%2B)) (then (emit automatic_semicolon)) (else fail)))) (if (next (literal -)) (then (if (next (literal --)) (then (emit automatic_semicolon)) (else fail)))) (if (next (literal %21)) (then (if (next (literal %21%3D)) (then fail) (else (emit automatic_semicolon))))) (if (next (literal in)) (then (if (not (next (seq (literal in) (class plain (range a z) (range A Z))))) (then fail)) (if (next (literal instanceof)) (then (if (not (next (seq (literal instanceof) (class plain (range a z) (range A Z))))) (then fail)))))) (emit automatic_semicolon)))
(scanner template_characters (tokens template_characters) (operations (while (not atEnd) (do mark (if (some (next (literal %60)) (next (literal %5C)) (next (literal %24%7B))) (then (if (greater (depth content) (integer 0)) (then (while (greater (depth content) (integer 0)) (do (pop content))) (emit template_characters)) (else fail)))) advance (if (equal (depth content) (integer 0)) (then (push content (integer 1)))))) fail))
(scanner ternary_question_mark (tokens ternary_question_mark) (operations (while (next (class plain (char %20) (char %09) (char %0A) (char %0B) (char %0C) (char %0D))) (do (skip (class plain (char %20) (char %09) (char %0A) (char %0B) (char %0C) (char %0D))))) (consume (literal %3F)) (if (next (literal %3F)) (then fail)) mark (if (next (literal .)) (then advance (if (not (next (class plain (range 0 9)))) (then fail)))) (emit ternary_question_mark)))
(scanner html_comment (tokens html_comment) (operations (if (next (literal %3C%21--)) (then (consume (literal %3C%21--))) (else (consume (literal --%3E)))) (while (not (some atEnd (some (next (literal %0A)) (next (literal %E2%80%A8)) (next (literal %E2%80%A9))))) (do advance)) (if (some (expected (literal %7C%7C)) (expected (ref escape_sequence)) (expected (ref regular_expression_pattern))) (then fail)) mark (emit html_comment)))
(scanner jsx_text (tokens jsx_text) (operations (while (not (some atEnd (some (next (literal %3C)) (next (literal %3E)) (next (literal %7B)) (next (literal %7D)) (next (literal %26))))) (do (if (next (literal %0A)) (then (if (equal (depth at_newline) (integer 0)) (then (push at_newline (integer 1))))) (else (if (not (next (class plain (char %20) (char %09) (char %0A) (char %0B) (char %0C) (char %0D)))) (then (while (greater (depth at_newline) (integer 0)) (do (pop at_newline))))) (if (not (greater (depth at_newline) (integer 0))) (then (if (equal (depth text) (integer 0)) (then (push text (integer 1)))))))) advance)) (while (greater (depth at_newline) (integer 0)) (do (pop at_newline))) (if (greater (depth text) (integer 0)) (then (while (greater (depth text) (integer 0)) (do (pop text))) (emit jsx_text))) fail))
(rule program normal (seq (optional (ref hash_bang_line)) (repeat0 (ref statement))) (concept grammar.program))
(rule hash_bang_line token (seq (literal %23%21) (repeat0 (class negated (char %0A)))) (concept grammar.hash-bang-line))
(rule export_statement normal (choice unordered (seq (token (seq (literal export) (not (ref word_characters)))) (choice unordered (seq (literal %2A) (ref from_clause)) (seq (ref namespace_export) (ref from_clause)) (seq (ref export_clause) (ref from_clause)) (ref export_clause)) (ref semicolon)) (seq (repeat0 (capture labeled decorator (ref decorator))) (token (seq (literal export) (not (ref word_characters)))) (choice unordered (capture labeled declaration (ref declaration)) (seq (token (seq (literal default) (not (ref word_characters)))) (choice unordered (capture labeled declaration (ref declaration)) (seq (capture labeled value (ref expression)) (ref semicolon))))))) (concept grammar.export-statement))
(rule namespace_export normal (seq (literal %2A) (token (seq (literal as) (not (ref word_characters)))) (ref module_export_name)) (concept grammar.namespace-export))
(rule export_clause normal (seq (literal %7B) (optional (seq (ref export_specifier) (repeat0 (seq (literal %2C) (ref export_specifier))))) (optional (literal %2C)) (literal %7D)) (concept grammar.export-clause))
(rule export_specifier normal (seq (capture labeled name (ref module_export_name)) (optional (seq (token (seq (literal as) (not (ref word_characters)))) (capture labeled alias (ref module_export_name))))) (concept grammar.export-specifier))
(rule module_export_name silent (choice unordered (ref identifier) (ref string) (token (seq (literal default) (not (ref word_characters))))) (concept grammar.module-export-name) (source-names (tree-sitter _module_export_name)))
(rule declaration silent (choice unordered (ref function_declaration) (ref generator_function_declaration) (ref class_declaration) (ref lexical_declaration) (ref variable_declaration) (ref using_declaration)) (concept grammar.declaration))
(rule import normal (token (seq (literal import) (not (ref word_characters)))) (concept grammar.import))
(rule import_statement normal (seq (token (seq (literal import) (not (ref word_characters)))) (choice unordered (seq (ref import_clause) (ref from_clause)) (capture labeled source (ref string))) (optional (ref import_attribute)) (ref semicolon)) (concept grammar.import-statement))
(rule import_clause normal (choice unordered (ref namespace_import) (ref named_imports) (seq (ref identifier) (optional (seq (literal %2C) (choice unordered (ref namespace_import) (ref named_imports)))))) (concept grammar.import-clause))
(rule from_clause silent (seq (token (seq (literal from) (not (ref word_characters)))) (capture labeled source (ref string))) (concept grammar.from-clause) (source-names (tree-sitter _from_clause)))
(rule namespace_import normal (seq (literal %2A) (token (seq (literal as) (not (ref word_characters)))) (ref identifier)) (concept grammar.namespace-import))
(rule named_imports normal (seq (literal %7B) (optional (seq (ref import_specifier) (repeat0 (seq (literal %2C) (ref import_specifier))))) (optional (literal %2C)) (literal %7D)) (concept grammar.named-imports))
(rule import_specifier normal (choice unordered (capture labeled name (ref identifier)) (seq (capture labeled name (ref module_export_name)) (token (seq (literal as) (not (ref word_characters)))) (capture labeled alias (ref identifier)))) (concept grammar.import-specifier))
(rule import_attribute normal (seq (token (seq (literal with) (not (ref word_characters)))) (ref object)) (concept grammar.import-attribute))
(rule statement silent (choice unordered (ref export_statement) (ref import_statement) (ref debugger_statement) (ref expression_statement) (ref declaration) (ref statement_block) (ref if_statement) (ref switch_statement) (ref for_statement) (ref for_in_statement) (ref while_statement) (ref do_statement) (ref try_statement) (ref with_statement) (ref break_statement) (ref continue_statement) (ref return_statement) (ref throw_statement) (ref empty_statement) (ref labeled_statement)) (concept grammar.statement))
(rule expression_statement normal (seq (ref expressions) (ref semicolon)) (concept grammar.expression-statement))
(rule variable_declaration normal (seq (token (seq (literal var) (not (ref word_characters)))) (seq (ref variable_declarator) (repeat0 (seq (literal %2C) (ref variable_declarator)))) (ref semicolon)) (concept grammar.variable-declaration))
(rule lexical_declaration normal (seq (capture labeled kind (choice unordered (token (seq (literal let) (not (ref word_characters)))) (token (seq (literal const) (not (ref word_characters)))))) (seq (ref variable_declarator) (repeat0 (seq (literal %2C) (ref variable_declarator)))) (ref semicolon)) (concept grammar.lexical-declaration))
(rule using_declaration normal (seq (capture labeled kind (choice unordered (token (seq (literal using) (not (ref word_characters)))) (seq (token (seq (literal await) (not (ref word_characters)))) (token (seq (literal using) (not (ref word_characters))))))) (seq (ref variable_declarator) (repeat0 (seq (literal %2C) (ref variable_declarator)))) (ref semicolon)) (concept grammar.using-declaration))
(rule variable_declarator normal (seq (capture labeled name (choice unordered (ref identifier) (alias identifier (token (seq (literal of) (not (ref word_characters))))) (ref destructuring_pattern))) (optional (ref initializer))) (concept grammar.variable-declarator))
(rule statement_block normal (precedence 0 right (seq (literal %7B) (repeat0 (ref statement)) (literal %7D) (optional (alias unnamed_token (immediateToken (ref automatic_semicolon)))))) (concept grammar.statement-block))
(rule else_clause normal (seq (token (seq (literal else) (not (ref word_characters)))) (ref statement)) (concept grammar.else-clause))
(rule if_statement normal (precedence 0 right (seq (token (seq (literal if) (not (ref word_characters)))) (capture labeled condition (ref parenthesized_expression)) (capture labeled consequence (ref statement)) (optional (capture labeled alternative (ref else_clause))))) (concept grammar.if-statement))
(rule switch_statement normal (seq (token (seq (literal switch) (not (ref word_characters)))) (capture labeled value (ref parenthesized_expression)) (capture labeled body (ref switch_body))) (concept grammar.switch-statement))
(rule for_statement normal (seq (token (seq (literal for) (not (ref word_characters)))) (literal %28) (choice unordered (capture labeled initializer (choice unordered (ref lexical_declaration) (ref variable_declaration))) (seq (capture labeled initializer (ref expressions)) (literal %3B)) (capture labeled initializer (ref empty_statement))) (capture labeled condition (choice unordered (seq (ref expressions) (literal %3B)) (ref empty_statement))) (capture labeled increment (optional (ref expressions))) (literal %29) (capture labeled body (ref statement))) (concept grammar.for-statement))
(rule for_in_statement normal (seq (token (seq (literal for) (not (ref word_characters)))) (optional (token (seq (literal await) (not (ref word_characters))))) (ref for_header) (capture labeled body (ref statement))) (concept grammar.for-in-statement))
(rule for_header silent (seq (literal %28) (choice unordered (capture labeled left (choice unordered (ref left_hand_side_expression) (ref parenthesized_expression))) (seq (capture labeled kind (token (seq (literal var) (not (ref word_characters))))) (capture labeled left (choice unordered (ref identifier) (alias identifier (token (seq (literal of) (not (ref word_characters))))) (ref destructuring_pattern))) (optional (ref initializer))) (seq (capture labeled kind (choice unordered (token (seq (literal let) (not (ref word_characters)))) (token (seq (literal const) (not (ref word_characters)))))) (capture labeled left (choice unordered (ref identifier) (alias identifier (token (seq (literal of) (not (ref word_characters))))) (ref destructuring_pattern))) (optional (alias unnamed_token (immediateToken (ref automatic_semicolon))))) (seq (capture labeled kind (choice unordered (token (seq (literal using) (not (ref word_characters)))) (seq (token (seq (literal await) (not (ref word_characters)))) (token (seq (literal using) (not (ref word_characters))))))) (capture labeled left (choice unordered (ref identifier) (alias identifier (token (seq (literal of) (not (ref word_characters))))) (ref destructuring_pattern))) (optional (alias unnamed_token (immediateToken (ref automatic_semicolon)))))) (capture labeled operator (choice unordered (token (seq (literal in) (not (ref word_characters)))) (token (seq (literal of) (not (ref word_characters)))))) (capture labeled right (ref expressions)) (literal %29)) (concept grammar.for-header) (source-names (tree-sitter _for_header)))
(rule while_statement normal (seq (token (seq (literal while) (not (ref word_characters)))) (capture labeled condition (ref parenthesized_expression)) (capture labeled body (ref statement))) (concept grammar.while-statement))
(rule do_statement normal (precedence 0 right (seq (token (seq (literal do) (not (ref word_characters)))) (capture labeled body (ref statement)) (token (seq (literal while) (not (ref word_characters)))) (capture labeled condition (ref parenthesized_expression)) (optional (ref semicolon)))) (concept grammar.do-statement))
(rule try_statement normal (seq (token (seq (literal try) (not (ref word_characters)))) (capture labeled body (ref statement_block)) (optional (capture labeled handler (ref catch_clause))) (optional (capture labeled finalizer (ref finally_clause)))) (concept grammar.try-statement))
(rule with_statement normal (seq (token (seq (literal with) (not (ref word_characters)))) (capture labeled object (ref parenthesized_expression)) (capture labeled body (ref statement))) (concept grammar.with-statement))
(rule break_statement normal (seq (token (seq (literal break) (not (ref word_characters)))) (capture labeled label (optional (alias statement_identifier (ref identifier)))) (ref semicolon)) (concept grammar.break-statement))
(rule continue_statement normal (seq (token (seq (literal continue) (not (ref word_characters)))) (capture labeled label (optional (alias statement_identifier (ref identifier)))) (ref semicolon)) (concept grammar.continue-statement))
(rule debugger_statement normal (seq (token (seq (literal debugger) (not (ref word_characters)))) (ref semicolon)) (concept grammar.debugger-statement))
(rule return_statement normal (seq (token (seq (literal return) (not (ref word_characters)))) (optional (ref expressions)) (ref semicolon)) (concept grammar.return-statement))
(rule throw_statement normal (seq (token (seq (literal throw) (not (ref word_characters)))) (ref expressions) (ref semicolon)) (concept grammar.throw-statement))
(rule empty_statement normal (literal %3B) (concept grammar.empty-statement))
(rule labeled_statement normal (dynamicPrecedence -1 (seq (capture labeled label (alias statement_identifier (choice unordered (ref identifier) (ref reserved_identifier)))) (literal %3A) (capture labeled body (ref statement)))) (concept grammar.labeled-statement))
(rule switch_body normal (seq (literal %7B) (repeat0 (choice unordered (ref switch_case) (ref switch_default))) (literal %7D)) (concept grammar.switch-body))
(rule switch_case normal (seq (token (seq (literal case) (not (ref word_characters)))) (capture labeled value (ref expressions)) (literal %3A) (capture labeled body (repeat0 (ref statement)))) (concept grammar.switch-case))
(rule switch_default normal (seq (token (seq (literal default) (not (ref word_characters)))) (literal %3A) (capture labeled body (repeat0 (ref statement)))) (concept grammar.switch-default))
(rule catch_clause normal (seq (token (seq (literal catch) (not (ref word_characters)))) (optional (seq (literal %28) (capture labeled parameter (choice unordered (ref identifier) (ref destructuring_pattern))) (literal %29))) (capture labeled body (ref statement_block))) (concept grammar.catch-clause))
(rule finally_clause normal (seq (token (seq (literal finally) (not (ref word_characters)))) (capture labeled body (ref statement_block))) (concept grammar.finally-clause))
(rule parenthesized_expression normal (seq (literal %28) (ref expressions) (literal %29)) (concept grammar.parenthesized-expression))
(rule expressions silent (choice unordered (ref expression) (ref sequence_expression)) (concept grammar.expression-or-sequence) (source-names (tree-sitter _expressions)))
(rule expression silent (choice unordered (ref primary_expression) (ref jsx_element_choice) (ref assignment_expression) (ref augmented_assignment_expression) (ref await_expression) (ref unary_expression) (ref binary_expression) (ref ternary_expression) (ref update_expression) (ref new_expression) (ref yield_expression)) (concept grammar.expression))
(rule primary_expression silent (choice unordered (ref subscript_expression) (ref member_expression) (ref parenthesized_expression) (ref identifier_choice) (alias identifier (choice unordered (token (seq (literal get) (not (ref word_characters)))) (token (seq (literal set) (not (ref word_characters)))) (token (seq (literal async) (not (ref word_characters)))) (token (seq (literal await) (not (ref word_characters)))) (token (seq (literal static) (not (ref word_characters)))) (token (seq (literal export) (not (ref word_characters)))) (token (seq (literal let) (not (ref word_characters)))))) (ref this) (ref super) (ref number) (ref string) (ref template_string) (ref regular_expression) (ref true) (ref false) (ref null) (ref object) (ref array) (ref function_expression) (ref arrow_function) (ref generator_function) (ref class) (ref meta_property) (ref call_expression)) (concept grammar.primary-expression))
(rule yield_expression normal (precedence 0 right (seq (token (seq (literal yield) (not (ref word_characters)))) (choice unordered (seq (literal %2A) (ref expression)) (optional (ref expression))))) (concept grammar.yield-expression))
(rule object normal (namedPrecedence object none (seq (literal %7B) (optional (seq (optional (choice unordered (ref pair) (ref spread_element) (ref method_definition) (alias shorthand_property_identifier (choice unordered (ref identifier) (ref reserved_identifier))))) (repeat0 (seq (literal %2C) (optional (choice unordered (ref pair) (ref spread_element) (ref method_definition) (alias shorthand_property_identifier (choice unordered (ref identifier) (ref reserved_identifier))))))))) (literal %7D))) (concept grammar.object))
(rule object_pattern normal (namedPrecedence object none (seq (literal %7B) (optional (seq (optional (choice unordered (ref pair_pattern) (ref rest_pattern) (ref object_assignment_pattern) (alias shorthand_property_identifier_pattern (choice unordered (ref identifier) (ref reserved_identifier))))) (repeat0 (seq (literal %2C) (optional (choice unordered (ref pair_pattern) (ref rest_pattern) (ref object_assignment_pattern) (alias shorthand_property_identifier_pattern (choice unordered (ref identifier) (ref reserved_identifier))))))))) (literal %7D))) (concept grammar.object-pattern))
(rule assignment_pattern normal (seq (capture labeled left (ref pattern)) (literal %3D) (capture labeled right (ref expression))) (concept grammar.assignment-pattern))
(rule object_assignment_pattern normal (seq (capture labeled left (choice unordered (alias shorthand_property_identifier_pattern (choice unordered (ref reserved_identifier) (ref identifier))) (ref destructuring_pattern))) (literal %3D) (capture labeled right (ref expression))) (concept grammar.object-assignment-pattern))
(rule array normal (seq (literal %5B) (optional (seq (optional (choice unordered (ref expression) (ref spread_element))) (repeat0 (seq (literal %2C) (optional (choice unordered (ref expression) (ref spread_element))))))) (literal %5D)) (concept grammar.array))
(rule array_pattern normal (seq (literal %5B) (optional (seq (optional (choice unordered (ref pattern) (ref assignment_pattern))) (repeat0 (seq (literal %2C) (optional (choice unordered (ref pattern) (ref assignment_pattern))))))) (literal %5D)) (concept grammar.array-pattern))
(rule jsx_element_choice silent (choice unordered (ref jsx_element) (ref jsx_self_closing_element)) (concept grammar.jsx-element-choice) (source-names (tree-sitter _jsx_element)))
(rule jsx_element normal (seq (capture labeled open_tag (ref jsx_opening_element)) (repeat0 (ref jsx_child)) (capture labeled close_tag (ref jsx_closing_element))) (concept grammar.jsx-element))
(rule html_character_reference token (seq (literal %26) (choice unordered (seq (literal %23) (choice unordered (seq (class plain (char x) (char X)) (repeat 1 6 (class plain (range 0 9) (range a f) (range A F)))) (repeat 1 5 (class plain (range 0 9))))) (repeat 1 30 (class plain (range A Z) (range a z)))) (literal %3B)) (concept grammar.html-character-reference))
(rule jsx_expression normal (seq (literal %7B) (optional (choice unordered (ref expression) (ref sequence_expression) (ref spread_element))) (literal %7D)) (concept grammar.jsx-expression))
(rule jsx_child silent (choice unordered (alias jsx_text (immediateToken (ref jsx_text))) (ref html_character_reference) (ref jsx_element_choice) (ref jsx_expression)) (concept grammar.jsx-child) (source-names (tree-sitter _jsx_child)))
(rule jsx_opening_element normal (dynamicPrecedence -1 (seq (literal %3C) (optional (seq (capture labeled name (ref jsx_element_name)) (repeat0 (capture labeled attribute (ref jsx_attribute_choice))))) (literal %3E))) (concept grammar.jsx-opening-element))
(rule jsx_identifier token (seq (class plain (range a z) (range A Z) (char _) (char %24)) (repeat0 (class plain (range a z) (range A Z) (range 0 9) (char _) (char %24))) (literal -) (repeat0 (class plain (range a z) (range A Z) (range 0 9) (char _) (char %24) (char -)))) (concept grammar.jsx-identifier))
(rule jsx_identifier_choice silent (choice unordered (alias identifier (ref jsx_identifier)) (ref identifier)) (concept grammar.jsx-identifier-choice) (source-names (tree-sitter _jsx_identifier)))
(rule nested_identifier normal (namedPrecedence member none (seq (capture labeled object (choice unordered (ref identifier) (alias member_expression (ref nested_identifier)))) (literal .) (capture labeled property (alias property_identifier (ref identifier))))) (concept grammar.nested-identifier))
(rule jsx_namespace_name normal (seq (ref jsx_identifier_choice) (literal %3A) (ref jsx_identifier_choice)) (concept grammar.jsx-namespace-name))
(rule jsx_element_name silent (choice unordered (ref jsx_identifier_choice) (alias member_expression (ref nested_identifier)) (ref jsx_namespace_name)) (concept grammar.jsx-element-name) (source-names (tree-sitter _jsx_element_name)))
(rule jsx_closing_element normal (seq (literal %3C%2F) (optional (capture labeled name (ref jsx_element_name))) (literal %3E)) (concept grammar.jsx-closing-element))
(rule jsx_self_closing_element normal (seq (literal %3C) (capture labeled name (ref jsx_element_name)) (repeat0 (capture labeled attribute (ref jsx_attribute_choice))) (literal %2F%3E)) (concept grammar.jsx-self-closing-element))
(rule jsx_attribute_choice silent (choice unordered (ref jsx_attribute) (ref jsx_expression)) (concept grammar.jsx-attribute-choice) (source-names (tree-sitter _jsx_attribute)))
(rule jsx_attribute_name silent (choice unordered (alias property_identifier (choice unordered (alias identifier (ref jsx_identifier)) (ref identifier))) (ref jsx_namespace_name)) (concept grammar.jsx-attribute-name) (source-names (tree-sitter _jsx_attribute_name)))
(rule jsx_attribute normal (seq (ref jsx_attribute_name) (optional (seq (literal %3D) (ref jsx_attribute_value)))) (concept grammar.jsx-attribute))
(rule jsx_string silent (choice unordered (seq (literal %22) (repeat0 (choice unordered (alias string_fragment (immediateToken (lexicalPrecedence 1 (repeat1 (choice unordered (class negated (char %22) (char %26)) (seq (literal %26) (class negated (char %23) (range A Z) (range a z)))))))) (ref html_character_reference))) (literal %22)) (seq (literal %27) (repeat0 (choice unordered (alias string_fragment (immediateToken (lexicalPrecedence 1 (repeat1 (choice unordered (class negated (char %27) (char %26)) (seq (literal %26) (class negated (char %23) (range A Z) (range a z)))))))) (ref html_character_reference))) (literal %27))) (concept grammar.jsx-string) (source-names (tree-sitter _jsx_string)))
(rule unescaped_double_jsx_string_fragment silent (alias unescaped_double_jsx_string_fragment (immediateToken (lexicalPrecedence 1 (repeat1 (choice unordered (class negated (char %22) (char %26)) (seq (literal %26) (class negated (char %23) (range A Z) (range a z)))))))) (concept grammar.unescaped-double-jsx-string-fragment))
(rule unescaped_single_jsx_string_fragment silent (alias unescaped_single_jsx_string_fragment (immediateToken (lexicalPrecedence 1 (repeat1 (choice unordered (class negated (char %27) (char %26)) (seq (literal %26) (class negated (char %23) (range A Z) (range a z)))))))) (concept grammar.unescaped-single-jsx-string-fragment))
(rule jsx_attribute_value silent (choice unordered (alias string (ref jsx_string)) (ref jsx_expression) (ref jsx_element_choice)) (concept grammar.jsx-attribute-value) (source-names (tree-sitter _jsx_attribute_value)))
(rule class normal (namedPrecedence literal none (seq (repeat0 (capture labeled decorator (ref decorator))) (token (seq (literal class) (not (ref word_characters)))) (capture labeled name (optional (ref identifier))) (optional (ref class_heritage)) (capture labeled body (ref class_body)))) (concept grammar.class))
(rule class_declaration normal (namedPrecedence declaration none (seq (repeat0 (capture labeled decorator (ref decorator))) (token (seq (literal class) (not (ref word_characters)))) (capture labeled name (ref identifier)) (optional (ref class_heritage)) (capture labeled body (ref class_body)) (optional (alias unnamed_token (immediateToken (ref automatic_semicolon)))))) (concept grammar.class-declaration))
(rule class_heritage normal (seq (token (seq (literal extends) (not (ref word_characters)))) (ref expression)) (concept grammar.class-heritage))
(rule function_expression normal (namedPrecedence literal none (seq (optional (token (seq (literal async) (not (ref word_characters))))) (token (seq (literal function) (not (ref word_characters)))) (capture labeled name (optional (ref identifier))) (ref call_signature) (capture labeled body (ref statement_block)))) (concept grammar.function-expression))
(rule function_declaration normal (namedPrecedence declaration right (seq (optional (token (seq (literal async) (not (ref word_characters))))) (token (seq (literal function) (not (ref word_characters)))) (capture labeled name (ref identifier)) (ref call_signature) (capture labeled body (ref statement_block)) (optional (alias unnamed_token (immediateToken (ref automatic_semicolon)))))) (concept grammar.function-declaration))
(rule generator_function normal (namedPrecedence literal none (seq (optional (token (seq (literal async) (not (ref word_characters))))) (token (seq (literal function) (not (ref word_characters)))) (literal %2A) (capture labeled name (optional (ref identifier))) (ref call_signature) (capture labeled body (ref statement_block)))) (concept grammar.generator-function))
(rule generator_function_declaration normal (namedPrecedence declaration right (seq (optional (token (seq (literal async) (not (ref word_characters))))) (token (seq (literal function) (not (ref word_characters)))) (literal %2A) (capture labeled name (ref identifier)) (ref call_signature) (capture labeled body (ref statement_block)) (optional (alias unnamed_token (immediateToken (ref automatic_semicolon)))))) (concept grammar.generator-function-declaration))
(rule arrow_function normal (seq (optional (token (seq (literal async) (not (ref word_characters))))) (choice unordered (capture labeled parameter (choice unordered (alias identifier (choice unordered (token (seq (literal get) (not (ref word_characters)))) (token (seq (literal set) (not (ref word_characters)))) (token (seq (literal async) (not (ref word_characters)))) (token (seq (literal await) (not (ref word_characters)))) (token (seq (literal static) (not (ref word_characters)))) (token (seq (literal export) (not (ref word_characters)))) (token (seq (literal let) (not (ref word_characters)))))) (ref identifier))) (ref call_signature)) (literal %3D%3E) (capture labeled body (choice unordered (ref expression) (ref statement_block)))) (concept grammar.arrow-function))
(rule call_signature silent (capture labeled parameters (ref formal_parameters)) (concept grammar.call-signature) (source-names (tree-sitter _call_signature)))
(rule formal_parameter silent (choice unordered (ref pattern) (ref assignment_pattern)) (concept grammar.formal-parameter) (source-names (tree-sitter _formal_parameter)))
(rule optional_chain token (literal %3F.) (concept grammar.optional-chain))
(rule call_expression normal (choice unordered (namedPrecedence call none (seq (capture labeled function (choice unordered (ref expression) (ref import))) (capture labeled arguments (ref arguments)))) (namedPrecedence template_call none (seq (capture labeled function (choice unordered (ref primary_expression) (ref new_expression))) (capture labeled arguments (ref template_string)))) (namedPrecedence member none (seq (capture labeled function (ref primary_expression)) (capture labeled optional_chain (ref optional_chain)) (capture labeled arguments (ref arguments))))) (concept grammar.call-expression))
(rule new_expression normal (namedPrecedence new right (seq (token (seq (literal new) (not (ref word_characters)))) (capture labeled constructor (choice unordered (ref primary_expression) (ref new_expression))) (capture labeled arguments (optional (dynamicPrecedence 1 (ref arguments)))))) (concept grammar.new-expression))
(rule await_expression normal (namedPrecedence unary_void none (seq (token (seq (literal await) (not (ref word_characters)))) (ref expression))) (concept grammar.await-expression))
(rule member_expression normal (namedPrecedence member none (seq (capture labeled object (choice unordered (ref expression) (ref primary_expression) (ref import))) (choice unordered (literal .) (capture labeled optional_chain (ref optional_chain))) (capture labeled property (choice unordered (ref private_property_identifier) (alias property_identifier (ref identifier)))))) (concept grammar.member-expression))
(rule subscript_expression normal (namedPrecedence member right (seq (capture labeled object (choice unordered (ref expression) (ref primary_expression))) (optional (capture labeled optional_chain (ref optional_chain))) (literal %5B) (capture labeled index (ref expressions)) (literal %5D))) (concept grammar.subscript-expression))
(rule left_hand_side_expression silent (choice unordered (ref member_expression) (ref subscript_expression) (ref identifier_choice) (alias identifier (choice unordered (token (seq (literal get) (not (ref word_characters)))) (token (seq (literal set) (not (ref word_characters)))) (token (seq (literal async) (not (ref word_characters)))) (token (seq (literal await) (not (ref word_characters)))) (token (seq (literal static) (not (ref word_characters)))) (token (seq (literal export) (not (ref word_characters)))) (token (seq (literal let) (not (ref word_characters)))))) (ref destructuring_pattern)) (concept grammar.left-hand-side-expression) (source-names (tree-sitter _lhs_expression)))
(rule assignment_expression normal (namedPrecedence assign right (seq (capture labeled left (choice unordered (ref parenthesized_expression) (ref left_hand_side_expression))) (literal %3D) (capture labeled right (ref expression)))) (concept grammar.assignment-expression))
(rule augmented_assignment_left_hand_side silent (choice unordered (ref member_expression) (ref subscript_expression) (alias identifier (choice unordered (token (seq (literal get) (not (ref word_characters)))) (token (seq (literal set) (not (ref word_characters)))) (token (seq (literal async) (not (ref word_characters)))) (token (seq (literal await) (not (ref word_characters)))) (token (seq (literal static) (not (ref word_characters)))) (token (seq (literal export) (not (ref word_characters)))) (token (seq (literal let) (not (ref word_characters)))))) (ref identifier) (ref parenthesized_expression)) (concept grammar.augmented-assignment-left-hand-side) (source-names (tree-sitter _augmented_assignment_lhs)))
(rule augmented_assignment_expression normal (namedPrecedence assign right (seq (capture labeled left (ref augmented_assignment_left_hand_side)) (capture labeled operator (choice unordered (literal %2B%3D) (literal -%3D) (literal %2A%3D) (literal %2F%3D) (literal %25%3D) (literal %5E%3D) (literal %26%3D) (literal %7C%3D) (literal %3E%3E%3D) (literal %3E%3E%3E%3D) (literal %3C%3C%3D) (literal %2A%2A%3D) (literal %26%26%3D) (literal %7C%7C%3D) (literal %3F%3F%3D))) (capture labeled right (ref expression)))) (concept grammar.augmented-assignment-expression))
(rule initializer silent (seq (literal %3D) (capture labeled value (ref expression))) (concept grammar.initializer) (source-names (tree-sitter _initializer)))
(rule destructuring_pattern silent (choice unordered (ref object_pattern) (ref array_pattern)) (concept grammar.destructuring-pattern) (source-names (tree-sitter _destructuring_pattern)))
(rule spread_element normal (seq (literal ...) (ref expression)) (concept grammar.spread-element))
(rule ternary_expression normal (namedPrecedence ternary right (seq (capture labeled condition (ref expression)) (alias %27%3F (ref ternary_question_mark)) (capture labeled consequence (ref expression)) (literal %3A) (capture labeled alternative (ref expression)))) (concept grammar.ternary-expression))
(rule binary_expression normal (choice unordered (namedPrecedence logical_and left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %26%26)) (capture labeled right (ref expression)))) (namedPrecedence logical_or left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %7C%7C)) (capture labeled right (ref expression)))) (namedPrecedence binary_shift left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3E%3E)) (capture labeled right (ref expression)))) (namedPrecedence binary_shift left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3E%3E%3E)) (capture labeled right (ref expression)))) (namedPrecedence binary_shift left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3C%3C)) (capture labeled right (ref expression)))) (namedPrecedence bitwise_and left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %26)) (capture labeled right (ref expression)))) (namedPrecedence bitwise_xor left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %5E)) (capture labeled right (ref expression)))) (namedPrecedence bitwise_or left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %7C)) (capture labeled right (ref expression)))) (namedPrecedence binary_plus left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %2B)) (capture labeled right (ref expression)))) (namedPrecedence binary_plus left (seq (capture labeled left (ref expression)) (capture labeled operator (literal -)) (capture labeled right (ref expression)))) (namedPrecedence binary_times left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %2A)) (capture labeled right (ref expression)))) (namedPrecedence binary_times left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %2F)) (capture labeled right (ref expression)))) (namedPrecedence binary_times left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %25)) (capture labeled right (ref expression)))) (namedPrecedence binary_exp right (seq (capture labeled left (ref expression)) (capture labeled operator (literal %2A%2A)) (capture labeled right (ref expression)))) (namedPrecedence binary_relation left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3C)) (capture labeled right (ref expression)))) (namedPrecedence binary_relation left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3C%3D)) (capture labeled right (ref expression)))) (namedPrecedence binary_equality left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3D%3D)) (capture labeled right (ref expression)))) (namedPrecedence binary_equality left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3D%3D%3D)) (capture labeled right (ref expression)))) (namedPrecedence binary_equality left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %21%3D)) (capture labeled right (ref expression)))) (namedPrecedence binary_equality left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %21%3D%3D)) (capture labeled right (ref expression)))) (namedPrecedence binary_relation left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3E%3D)) (capture labeled right (ref expression)))) (namedPrecedence binary_relation left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3E)) (capture labeled right (ref expression)))) (namedPrecedence ternary left (seq (capture labeled left (ref expression)) (capture labeled operator (literal %3F%3F)) (capture labeled right (ref expression)))) (namedPrecedence binary_relation left (seq (capture labeled left (ref expression)) (capture labeled operator (token (seq (literal instanceof) (not (ref word_characters))))) (capture labeled right (ref expression)))) (namedPrecedence binary_relation left (seq (capture labeled left (choice unordered (ref expression) (ref private_property_identifier))) (capture labeled operator (token (seq (literal in) (not (ref word_characters))))) (capture labeled right (ref expression))))) (concept grammar.binary-expression))
(rule unary_expression normal (namedPrecedence unary_void left (seq (capture labeled operator (choice unordered (literal %21) (literal %7E) (literal -) (literal %2B) (token (seq (literal typeof) (not (ref word_characters)))) (token (seq (literal void) (not (ref word_characters)))) (token (seq (literal delete) (not (ref word_characters)))))) (capture labeled argument (ref expression)))) (concept grammar.unary-expression))
(rule update_expression normal (precedence 0 left (choice unordered (seq (capture labeled argument (ref expression)) (capture labeled operator (choice unordered (literal %2B%2B) (literal --)))) (seq (capture labeled operator (choice unordered (literal %2B%2B) (literal --))) (capture labeled argument (ref expression))))) (concept grammar.update-expression))
(rule sequence_expression normal (precedence 0 right (seq (ref expression) (repeat0 (seq (literal %2C) (ref expression))))) (concept grammar.sequence-expression))
(rule string normal (choice unordered (seq (literal %22) (repeat0 (choice unordered (alias string_fragment (immediateToken (lexicalPrecedence 1 (repeat1 (class negated (char %22) (char %5C) (char %0D) (char %0A)))))) (ref escape_sequence))) (literal %22)) (seq (literal %27) (repeat0 (choice unordered (alias string_fragment (immediateToken (lexicalPrecedence 1 (repeat1 (class negated (char %27) (char %5C) (char %0D) (char %0A)))))) (ref escape_sequence))) (literal %27))) (concept grammar.string))
(rule unescaped_double_string_fragment silent (alias unescaped_double_string_fragment (immediateToken (lexicalPrecedence 1 (repeat1 (class negated (char %22) (char %5C) (char %0D) (char %0A)))))) (concept grammar.unescaped-double-string-fragment))
(rule unescaped_single_string_fragment silent (alias unescaped_single_string_fragment (immediateToken (lexicalPrecedence 1 (repeat1 (class negated (char %27) (char %5C) (char %0D) (char %0A)))))) (concept grammar.unescaped-single-string-fragment))
(rule escape_sequence silent (alias escape_sequence (immediateToken (seq (literal %5C) (choice unordered (class negated (char x) (char u) (range 0 7)) (repeat 1 3 (class plain (range 0 7))) (seq (literal x) (repeat 2 2 (class plain (range 0 9) (range a f) (range A F)))) (seq (literal u) (repeat 4 4 (class plain (range 0 9) (range a f) (range A F)))) (seq (literal u%7B) (repeat1 (class plain (range 0 9) (range a f) (range A F))) (literal %7D)) (seq (class plain (char %0D) (char %3F)) (class plain (char %0A) (char %E2%80%A8) (char %E2%80%A9))))))) (concept grammar.escape-sequence))
(rule comment token (choice unordered (seq (literal %2F%2F) (repeat0 (class negated (char %0D) (char %0A) (char %E2%80%A8) (char %E2%80%A9)))) (seq (literal %2F%2A) (seq (repeat0 (class negated (char %2A))) (repeat1 (literal %2A)) (repeat0 (seq (class negated (char %2F) (char %2A)) (repeat0 (class negated (char %2A))) (repeat1 (literal %2A))))) (literal %2F))) (concept grammar.comment))
(rule template_string normal (seq (literal %60) (repeat0 (choice unordered (alias string_fragment (immediateToken (ref template_characters))) (ref escape_sequence) (ref template_substitution))) (literal %60)) (concept grammar.template-string))
(rule template_substitution normal (seq (literal %24%7B) (ref expressions) (literal %7D)) (concept grammar.template-substitution))
(rule regular_expression normal (seq (literal %2F) (capture labeled pattern (ref regular_expression_pattern)) (immediateToken (lexicalPrecedence 1 (literal %2F))) (optional (capture labeled flags (ref regular_expression_flags)))) (concept grammar.regular-expression) (source-names (tree-sitter regex)))
(rule regular_expression_pattern silent (alias regular_expression_pattern (immediateToken (lexicalPrecedence -1 (repeat1 (choice unordered (seq (literal %5B) (repeat0 (choice unordered (seq (literal %5C) (class negated (char %0A))) (class negated (char %5D) (char %0A) (char %5C)))) (literal %5D)) (seq (literal %5C) (class negated (char %0A))) (class negated (char %2F) (char %5C) (char %5B) (char %0A))))))) (concept grammar.regular-expression-pattern) (source-names (tree-sitter regex_pattern)))
(rule regular_expression_flags silent (alias regular_expression_flags (immediateToken (repeat1 (class plain (range a z))))) (concept grammar.regular-expression-flags) (source-names (tree-sitter regex_flags)))
(rule number token (choice unordered (seq (choice unordered (literal 0x) (literal 0X)) (seq (class plain (range 0 9) (range a f) (range A F)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9) (range a f) (range A F)))))) (choice unordered (seq (choice unordered (literal 0) (seq (optional (literal 0)) (class plain (range 1 9)) (optional (seq (optional (literal _)) (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9))))))))) (literal .) (optional (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9)))))) (optional (seq (choice unordered (literal e) (literal E)) (seq (optional (choice unordered (literal -) (literal %2B))) (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9))))))))) (seq (literal .) (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9))))) (optional (seq (choice unordered (literal e) (literal E)) (seq (optional (choice unordered (literal -) (literal %2B))) (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9))))))))) (seq (choice unordered (literal 0) (seq (optional (literal 0)) (class plain (range 1 9)) (optional (seq (optional (literal _)) (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9))))))))) (seq (choice unordered (literal e) (literal E)) (seq (optional (choice unordered (literal -) (literal %2B))) (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9)))))))) (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9)))))) (seq (choice unordered (literal 0b) (literal 0B)) (seq (class plain (range 0 1)) (repeat0 (seq (optional (literal _)) (class plain (range 0 1)))))) (seq (choice unordered (literal 0o) (literal 0O)) (seq (class plain (range 0 7)) (repeat0 (seq (optional (literal _)) (class plain (range 0 7)))))) (seq (choice unordered (seq (choice unordered (literal 0x) (literal 0X)) (seq (class plain (range 0 9) (range a f) (range A F)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9) (range a f) (range A F)))))) (seq (choice unordered (literal 0b) (literal 0B)) (seq (class plain (range 0 1)) (repeat0 (seq (optional (literal _)) (class plain (range 0 1)))))) (seq (choice unordered (literal 0o) (literal 0O)) (seq (class plain (range 0 7)) (repeat0 (seq (optional (literal _)) (class plain (range 0 7)))))) (seq (class plain (range 0 9)) (repeat0 (seq (optional (literal _)) (class plain (range 0 9)))))) (literal n))) (concept grammar.number))
(rule identifier_choice silent (choice unordered (ref undefined) (ref identifier)) (concept grammar.identifier-choice) (source-names (tree-sitter _identifier)))
(rule identifier token (seq (choice unordered (class negated (range %00 %1F) (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B) (category Zs) (range 0 9) (char %3A) (char %3B) (char %60) (char %22) (char %27) (char %40) (char %23) (char .) (char %2C) (char %7C) (char %5E) (char %26) (char %3C) (char %3D) (char %3E) (char %2B) (char -) (char %2A) (char %2F) (char %5C) (char %25) (char %3F) (char %21) (char %7E) (char %28) (char %29) (char %5B) (char %5D) (char %7B) (char %7D) (char %EF%BB%BF) (char %E2%81%A0) (char %E2%80%8B) (char %E2%80%A8) (char %E2%80%A9)) (seq (literal %5Cu) (repeat 4 4 (class plain (range 0 9) (range a f) (range A F)))) (seq (literal %5Cu%7B) (repeat1 (class plain (range 0 9) (range a f) (range A F))) (literal %7D))) (repeat0 (choice unordered (class negated (range %00 %1F) (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B) (category Zs) (char %3A) (char %3B) (char %60) (char %22) (char %27) (char %40) (char %23) (char .) (char %2C) (char %7C) (char %5E) (char %26) (char %3C) (char %3D) (char %3E) (char %2B) (char -) (char %2A) (char %2F) (char %5C) (char %25) (char %3F) (char %21) (char %7E) (char %28) (char %29) (char %5B) (char %5D) (char %7B) (char %7D) (char %EF%BB%BF) (char %E2%81%A0) (char %E2%80%8B) (char %E2%80%A8) (char %E2%80%A9)) (seq (literal %5Cu) (repeat 4 4 (class plain (range 0 9) (range a f) (range A F)))) (seq (literal %5Cu%7B) (repeat1 (class plain (range 0 9) (range a f) (range A F))) (literal %7D))))) (concept grammar.identifier))
(rule private_property_identifier token (seq (literal %23) (choice unordered (class negated (range %00 %1F) (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B) (category Zs) (range 0 9) (char %3A) (char %3B) (char %60) (char %22) (char %27) (char %40) (char %23) (char .) (char %2C) (char %7C) (char %5E) (char %26) (char %3C) (char %3D) (char %3E) (char %2B) (char -) (char %2A) (char %2F) (char %5C) (char %25) (char %3F) (char %21) (char %7E) (char %28) (char %29) (char %5B) (char %5D) (char %7B) (char %7D) (char %EF%BB%BF) (char %E2%81%A0) (char %E2%80%8B) (char %E2%80%A8) (char %E2%80%A9)) (seq (literal %5Cu) (repeat 4 4 (class plain (range 0 9) (range a f) (range A F)))) (seq (literal %5Cu%7B) (repeat1 (class plain (range 0 9) (range a f) (range A F))) (literal %7D))) (repeat0 (choice unordered (class negated (range %00 %1F) (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B) (category Zs) (char %3A) (char %3B) (char %60) (char %22) (char %27) (char %40) (char %23) (char .) (char %2C) (char %7C) (char %5E) (char %26) (char %3C) (char %3D) (char %3E) (char %2B) (char -) (char %2A) (char %2F) (char %5C) (char %25) (char %3F) (char %21) (char %7E) (char %28) (char %29) (char %5B) (char %5D) (char %7B) (char %7D) (char %EF%BB%BF) (char %E2%81%A0) (char %E2%80%8B) (char %E2%80%A8) (char %E2%80%A9)) (seq (literal %5Cu) (repeat 4 4 (class plain (range 0 9) (range a f) (range A F)))) (seq (literal %5Cu%7B) (repeat1 (class plain (range 0 9) (range a f) (range A F))) (literal %7D))))) (concept grammar.private-property-identifier))
(rule meta_property normal (choice unordered (seq (token (seq (literal new) (not (ref word_characters)))) (literal .) (token (seq (literal target) (not (ref word_characters))))) (seq (token (seq (literal import) (not (ref word_characters)))) (literal .) (token (seq (literal meta) (not (ref word_characters)))))) (concept grammar.meta-property))
(rule this token (seq (literal this) (not (ref word_characters))) (concept grammar.this))
(rule super token (seq (literal super) (not (ref word_characters))) (concept grammar.super))
(rule true token (seq (literal true) (not (ref word_characters))) (concept grammar.true-value))
(rule false token (seq (literal false) (not (ref word_characters))) (concept grammar.false-value))
(rule null token (seq (literal null) (not (ref word_characters))) (concept grammar.null))
(rule undefined token (seq (literal undefined) (not (ref word_characters))) (concept grammar.undefined-value))
(rule arguments normal (seq (literal %28) (optional (seq (optional (choice unordered (ref expression) (ref spread_element))) (repeat0 (seq (literal %2C) (optional (choice unordered (ref expression) (ref spread_element))))))) (literal %29)) (concept grammar.argument-list))
(rule decorator normal (seq (literal %40) (choice unordered (ref identifier) (alias member_expression (ref decorator_member_expression)) (alias call_expression (ref decorator_call_expression)))) (concept grammar.decorator))
(rule decorator_member_expression normal (namedPrecedence member none (seq (capture labeled object (choice unordered (ref identifier) (alias member_expression (ref decorator_member_expression)))) (literal .) (capture labeled property (alias property_identifier (ref identifier))))) (concept grammar.decorator-member-expression))
(rule decorator_call_expression normal (namedPrecedence call none (seq (capture labeled function (choice unordered (ref identifier) (alias member_expression (ref decorator_member_expression)))) (capture labeled arguments (ref arguments)))) (concept grammar.decorator-call-expression))
(rule class_body normal (seq (literal %7B) (repeat0 (choice unordered (seq (capture labeled member (ref method_definition)) (optional (literal %3B))) (seq (capture labeled member (ref field_definition)) (ref semicolon)) (capture labeled member (ref class_static_block)) (literal %3B))) (literal %7D)) (concept grammar.class-body))
(rule field_definition normal (seq (repeat0 (capture labeled decorator (ref decorator))) (optional (token (seq (literal static) (not (ref word_characters))))) (capture labeled property (ref property_name)) (optional (ref initializer))) (concept grammar.field-definition))
(rule formal_parameters normal (seq (literal %28) (optional (seq (seq (ref formal_parameter) (repeat0 (seq (literal %2C) (ref formal_parameter)))) (optional (literal %2C)))) (literal %29)) (concept grammar.formal-parameter-list))
(rule class_static_block normal (seq (token (seq (literal static) (not (ref word_characters)))) (optional (alias unnamed_token (immediateToken (ref automatic_semicolon)))) (capture labeled body (ref statement_block))) (concept grammar.class-static-block))
(rule pattern silent (dynamicPrecedence -1 (choice unordered (ref left_hand_side_expression) (ref rest_pattern))) (concept grammar.pattern))
(rule rest_pattern normal (precedence 0 right (seq (literal ...) (ref left_hand_side_expression))) (concept grammar.rest-pattern))
(rule method_definition normal (seq (repeat0 (capture labeled decorator (ref decorator))) (optional (choice unordered (token (seq (literal static) (not (ref word_characters)))) (alias %27static%20get (token (seq (literal static) (repeat1 (class plain (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B))) (literal get) (seq (repeat0 (class plain (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B))) (literal %0A))))))) (optional (token (seq (literal async) (not (ref word_characters))))) (optional (choice unordered (token (seq (literal get) (not (ref word_characters)))) (token (seq (literal set) (not (ref word_characters)))) (literal %2A))) (capture labeled name (ref property_name)) (capture labeled parameters (ref formal_parameters)) (capture labeled body (ref statement_block))) (concept grammar.method-definition))
(rule pair normal (seq (capture labeled key (ref property_name)) (literal %3A) (capture labeled value (ref expression))) (concept grammar.pair))
(rule pair_pattern normal (seq (capture labeled key (ref property_name)) (literal %3A) (capture labeled value (choice unordered (ref pattern) (ref assignment_pattern)))) (concept grammar.pair-pattern))
(rule property_name silent (choice unordered (alias property_identifier (choice unordered (ref identifier) (ref reserved_identifier))) (ref private_property_identifier) (ref string) (ref number) (ref computed_property_name)) (concept grammar.property-name) (source-names (tree-sitter _property_name)))
(rule computed_property_name normal (seq (literal %5B) (ref expression) (literal %5D)) (concept grammar.computed-property-name))
(rule reserved_identifier silent (choice unordered (token (seq (literal get) (not (ref word_characters)))) (token (seq (literal set) (not (ref word_characters)))) (token (seq (literal async) (not (ref word_characters)))) (token (seq (literal await) (not (ref word_characters)))) (token (seq (literal static) (not (ref word_characters)))) (token (seq (literal export) (not (ref word_characters)))) (token (seq (literal let) (not (ref word_characters))))) (concept grammar.reserved-identifier) (source-names (tree-sitter _reserved_identifier)))
(rule semicolon silent (choice unordered (alias unnamed_token (immediateToken (ref automatic_semicolon))) (literal %3B)) (concept grammar.semicolon) (source-names (tree-sitter _semicolon)))
(rule word_characters token (seq (choice unordered (class negated (range %00 %1F) (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B) (category Zs) (range 0 9) (char %3A) (char %3B) (char %60) (char %22) (char %27) (char %40) (char %23) (char .) (char %2C) (char %7C) (char %5E) (char %26) (char %3C) (char %3D) (char %3E) (char %2B) (char -) (char %2A) (char %2F) (char %5C) (char %25) (char %3F) (char %21) (char %7E) (char %28) (char %29) (char %5B) (char %5D) (char %7B) (char %7D) (char %EF%BB%BF) (char %E2%81%A0) (char %E2%80%8B) (char %E2%80%A8) (char %E2%80%A9)) (seq (literal %5Cu) (repeat 4 4 (class plain (range 0 9) (range a f) (range A F)))) (seq (literal %5Cu%7B) (repeat1 (class plain (range 0 9) (range a f) (range A F))) (literal %7D))) (repeat0 (choice unordered (class negated (range %00 %1F) (char %20) (char %09) (char %0A) (char %0D) (char %0C) (char %0B) (category Zs) (char %3A) (char %3B) (char %60) (char %22) (char %27) (char %40) (char %23) (char .) (char %2C) (char %7C) (char %5E) (char %26) (char %3C) (char %3D) (char %3E) (char %2B) (char -) (char %2A) (char %2F) (char %5C) (char %25) (char %3F) (char %21) (char %7E) (char %28) (char %29) (char %5B) (char %5D) (char %7B) (char %7D) (char %EF%BB%BF) (char %E2%81%A0) (char %E2%80%8B) (char %E2%80%A8) (char %E2%80%A9)) (seq (literal %5Cu) (repeat 4 4 (class plain (range 0 9) (range a f) (range A F)))) (seq (literal %5Cu%7B) (repeat1 (class plain (range 0 9) (range a f) (range A F))) (literal %7D))))) (concept grammar.word-characters))