tree-sitter-cfml 0.26.32

/**
 * @file CFSCRIPT grammar for tree-sitter
 * @author Gareth Edwards, Gavin Baumanis
 * @license MIT
 */

/// <reference types="tree-sitter-cli/dsl" />
// @ts-check

/**
 * @param {Rule} rule
 * @returns {SeqRule}
 */
function commaSep1(rule) {
  return seq(rule, repeat(seq(',', rule)));
}

/**
 * @param {Rule} rule
 * @returns {ChoiceRule}
 */
function commaSep(rule) {
  return optional(commaSep1(rule));
}

module.exports = grammar({
  name: 'cfscript',

  externals: ($) => [
    $._automatic_semicolon,
    $._template_chars,
    $._ternary_qmark,
    $._elvis_operator,
    $.logical_or,
    // Scanner tracks string/template context so HTML comments are not parsed inside them.
    $.regex_pattern,
    $.query_text,
    $.tag_linefeed,
    $.cfml_template_content,
    $.cf_comment,
  ],

  extras: ($) => [
    $.comment,
    // @ts-ignore
    /[\s\p{Zs}\uFEFF\u2028\u2029\u2060\u200B]/,
  ],

  supertypes: $ => [
    $.statement,
    $.declaration,
    $.expression,
    $.primary_expression,
    $.pattern,
  ],

  inline: ($) => [
    $._kw_abstract,
    $._kw_break,
    $._kw_case,
    $._kw_catch,
    $._kw_component,
    $._kw_continue,
    $._kw_debugger,
    $._kw_default,
    $._kw_do,
    $._kw_else,
    $._kw_final,
    $._kw_finally,
    $._kw_for,
    $._kw_function,
    $._kw_if,
    $._kw_import,
    $._kw_in,
    $._kw_include,
    $._kw_instanceof,
    $._kw_interface,
    $._kw_new,
    $._kw_of,
    $._kw_package,
    $._kw_private,
    $._kw_property,
    $._kw_public,
    $._kw_remote,
    $._kw_return,
    $._kw_static,
    $._kw_switch,
    $._kw_throw,
    $._kw_try,
    $._kw_var,
    $._kw_while,
    $._kw_with,
    $._call_signature,
    $._formal_parameter,
    $._expressions,
    $._semicolon,
    $._identifier,
    $._reserved_identifier,
    $._lhs_expression,
  ],

  precedences: ($) => [
    [
      'member',
      'call',
      $.update_expression,
      'unary_void',
      'binary_exp',
      'binary_times',
      'binary_plus',
      'binary_shift',
      'binary_compare',
      'binary_relation',
      'binary_equality',
      'bitwise_and',
      'bitwise_xor',
      'bitwise_or',
      'logical_and',
      'logical_xor',
      'logical_or',
      'ternary',
      'elvis',
      $.sequence_expression,
      $.arrow_function,
    ],
    ['assign', $.primary_expression],
    ['member', 'new', 'call', $.expression],
    ['declaration', 'literal'],
    [$.primary_expression, $.statement_block, 'object'],
  ],

  conflicts: ($) => [
    [$.object, $.object_pattern],
    [$.primary_expression, $.pattern],
    [$.assignment_expression, $.pattern],
    [$.function_expression, $.function_declaration],
    [$.expression, $.function_expression, $.function_declaration],
    [$.primary_expression, $.path],
    // `public(`, `private(` … — an access modifier starting a member
    // declaration looks exactly like a call until the parser sees what follows.
    // `final X` / `public X` — a member declaration and a function declaration
    // (`final query function f()`) share their prefix.
    [$.primary_expression, $.variable_declaration],
    [$.variable_declaration, $.access_type],
    [$.variable_declaration, $.primary_expression, $._property_name],
    [$.primary_expression, $.parameter_type],
    [$.primary_expression, $.parameter_type, $.pattern],
    [$.parameter_type, $.pattern],
    // `( function ( ... ` is either a parameter typed `Function` or an
    // anonymous function used as a parameter default.
    [$.function_expression, $.parameter_type],
    [$.primary_expression, $._property_name],
    [$.primary_expression, $.method_definition],
    [$.primary_expression, $.rest_pattern],
    [$.primary_expression, $._for_header],
    [$.array, $.array_pattern],
    [$.assignment_expression, $.object_assignment_pattern],
    [$.labeled_statement, $._property_name],
    [$.computed_property_name, $.array],
    // `for ( var x = y in z )` — the initializer, an assignment and a binary
    // `in` expression all fit the same prefix.
    [$.assignment_expression, $._initializer, $.binary_expression],
    [$.method_definition, $.access_type],
    // `pair` (expression ':' expression) is reachable from `arguments` and
    // `array`, so `case <expr> :` is ambiguous with the start of a pair.
    [$.switch_case, $.expression],
    [$.primary_expression, $.new_expression],
    [$.primary_expression, $.query_tag],
    [$._for_header, $.primary_expression, $.new_expression],
    [$.primary_expression, $.new_expression, $.rest_pattern],
    [$.new_expression, $.pattern],
    [$.primary_expression, $.new_expression, $.pattern],
    [$.primary_expression, $.new_expression, $._property_name],
    [$.function_expression, $.pattern],
    [$.function_expression, $.parameter_type, $.pattern],
    [$._property_name, $.primary_expression, $.query_tag],
    [$.primary_expression, $.query_expression],
    [$._property_name, $.primary_expression, $.query_expression],
    [$.arguments, $.parenthesized_expression],
    [$.expression, $.parenthesized_expression],
    [$.expression, $.expression_statement],

    [$.expression, $.arguments],
    [$.expression, $.assignment_expression],
    [$.expression, $.return_statement],
    [$.expression, $.throw_statement],
    [$.assignment_expression, $._property_name],
    [$.object_assignment_pattern, $._property_name],
    [$.object_assignment_pattern, $.assignment_expression, $._property_name],
    [$.call_expression, $._property_name],
    [$._for_header, $.expression],
    [$.expression, $.for_statement],
    [$.parenthesized_expression, $.expression, $.arguments],
    [$.expression, $.template_substitution],

    [$.primary_expression, $.tag_statement],
    [$.expression, $.tag_statement],
    [$.tag_statement, $.expression],
    [$.program, $.statement],
    // The heart of it: at `f( a •= ` the parser cannot tell a tag-call
    // attribute from an ordinary named argument. It only finds out on reaching
    // the value, and on whether a second `name=` follows.
    [$.assignment_expression, $.tag_call_attribute, $.pattern],
    // `cfdirectory( … )` at statement position: `identifier (` could start a
    // tag call, an ordinary call, or a tag statement. Confined to statement
    // position, so unlike the previous formulation it is not live at every
    // call site in the language.
    [$.primary_expression, $._tag_call, $.tag_statement],
    // The same decision at the start of a `{`, where a struct-literal key is
    // also possible.
    [$.primary_expression, $._tag_call, $._property_name, $.tag_statement],
    [$.sequence_expression, $.arguments],
    [$.component_attribute, $.property_declaration],
    [$.parameter_attribute, $.assignment_expression, $.pattern],
    [$.primary_expression, $.parameter_attribute],
  ],

  word: ($) => $.identifier,

  rules: {

    program: ($) => seq(
      repeat(
        choice(
          $.import_statement,
          $.tag_statement,
          $.comment,
        ),
      ),
      choice(
        $.component,
        repeat($.statement),
      ),
    ),


    /*
        START SCRIPT BASE RULES
      */
    _module_export_name: ($) => choice(
      $.identifier,
      $.string,
    ),

    declaration: ($) => choice(
      $.function_declaration,
      $.variable_declaration,
    ),

    //
    // Import declarations
    //

    import_statement: ($) => seq(
      $._kw_import,
      choice(
        seq($.import_clause, $._from_clause),
        field('source', $.string),
        field('source', $.identifier),
        field('source', $.import_path),
      ),
      optional($.import_attribute),
      $._semicolon,
    ),

    import_path: ($) => seq($.identifier, repeat1(seq('.', choice($.identifier, '*')))),

    path: ($) => seq($.identifier, repeat1(seq('.', $.identifier))),

    import_clause: ($) => choice(
      $.namespace_import,
      $.named_imports,
      seq(
        $.identifier,
        optional(seq(
          ',',
          choice(
            $.namespace_import,
            $.named_imports,
          ),
        )),
      ),
    ),

    _from_clause: ($) => seq(
      'from', field('source', $.string),
    ),

    namespace_import: ($) => seq(
      '*', 'as', $.identifier,
    ),

    named_imports: ($) => seq(
      '{',
      commaSep($.import_specifier),
      optional(','),
      '}',
    ),

    import_specifier: ($) => choice(
      field('name', $.identifier),
      seq(
        field('name', $._module_export_name),
        'as',
        field('alias', $.identifier),
      ),
    ),

    import_attribute: ($) => seq($._kw_with, $.object),

    //
    // Statements
    //

    statement: ($) => choice(
      // $.export_statement,
      // `<!--- … --->` between statements. Deliberately a statement rather than
      // an extra: as an extra it also matched inside a string, so
      // `reReplace( src, "<!---.*?--->", "" )` grew a comment node.
      $.cf_comment,
      alias($.tag_call_statement, $.expression_statement),
      $.import_statement,
      $.debugger_statement,
      $.expression_statement,
      $.declaration,
      $.statement_block,

      $.if_statement,
      $.switch_statement,
      $.for_statement,
      $.for_in_statement,
      $.while_statement,
      $.do_statement,
      $.try_statement,
      $.with_statement,

      $.break_statement,
      $.continue_statement,
      $.return_statement,
      $.throw_statement,
      $.empty_statement,
      $.labeled_statement,
      $.include_statement,

      $.cfml_template,
      $.tag_statement,
      $.query_tag,
      $.component,
    ),

    expression_statement: ($) => seq(
      $._expressions,
      $._semicolon,
    ),

    // `var x = 1`, and the Lucee member forms `final MEMBER = "value"` and
    // `public prop = "prop"` inside a component body.
    variable_declaration: ($) => choice(
      seq(
        choice(
          $._kw_var,
          $._kw_final,
          seq($._kw_final, $._kw_var),
          seq($._kw_var, $._kw_final),
        ),
        commaSep1($.variable_declarator),
        $._semicolon,
      ),
      // `public prop = "prop"`. Access modifiers only — `static` and `abstract`
      // are excluded because `static { … }` and `abstract component { … }` claim
      // those words. The negative dynamic precedence keeps
      // `private component function f()` a function declaration: there the
      // modifier is followed by a return type, not a variable name.
      prec.dynamic(-1, seq(
        alias(choice($._kw_public, $._kw_private, $._kw_package, $._kw_remote), $.access_type),
        commaSep1(alias($._plain_declarator, $.variable_declarator)),
        $._semicolon,
      )),
    ),

    // A member declaration's name is a plain identifier — no keywords and no
    // scoped name. Accepting keywords here would make `component` after
    // `public` lex as a keyword, and `public component function f()` is a
    // function declaration with a return type, not a member.
    _plain_declarator: ($) => seq(
      field('name', $.identifier),
      optional($._initializer),
    ),

    variable_declarator: ($) => seq(
      // A scoped name is legal in CFML: `var local.result = …`, `var a.b.c = 1`.
      // `_reserved_identifier` has to be spelled out because allowing a
      // `member_expression` here makes keyword-led expressions valid straight
      // after `var`, so `var new = 1` would otherwise lex `new` as a keyword.
      // `var mappings[ key ] = value` is the same idea one step further —
      // declare and index in one statement. Kept next to `member_expression`
      // because CFML treats `a.b` and `a["b"]` as the same access.
      field('name', choice(
        $.identifier,
        alias($._reserved_identifier, $.identifier),
        $.member_expression,
        $.subscript_expression,
        $._destructuring_pattern,
      )),
      optional($._initializer),
    ),

    statement_block: ($) => prec.right(seq(
      '{',
      repeat($.statement),
      '}',
      optional($._automatic_semicolon),
    )),

    else_clause: ($) => seq($._kw_else, $.statement),

    if_statement: ($) => prec.right(seq(
      $._kw_if,
      field('condition', $.parenthesized_expression),
      field('consequence', $.statement),
      optional(field('alternative', $.else_clause)),
    )),

    switch_statement: ($) => seq(
      $._kw_switch,
      field('value', $.parenthesized_expression),
      field('body', $.switch_body),
    ),

    for_statement: ($) => seq(
      $._kw_for,
      '(',
      choice(
        field('initializer', $.variable_declaration),
        seq(field('initializer', $._expressions), ';'),
        field('initializer', $.empty_statement),
      ),
      field('condition', choice(
        seq($._expressions, ';'),
        $.empty_statement,
      )),
      field('increment', optional($._expressions)),
      ')',
      field('body', $.statement),
    ),

    for_in_statement: ($) => seq(
      $._kw_for,
      $._for_header,
      field('body', $.statement),
    ),

    _for_header: ($) => seq(
      '(',
      choice(
        field('left', choice(
          $._lhs_expression,
          $.parenthesized_expression,
        )),
        seq(
          field('kind', $._kw_var),
          field('left', choice(
            // `for ( var export in … )` — a keyword-shaped loop variable. `var`
            // now makes keywords valid here (see variable_declarator), so they
            // have to be accepted rather than lexed as keywords.
            $.identifier,
            alias($._reserved_identifier, $.identifier),
            $._destructuring_pattern,
          )),
          optional($._initializer),
        ),
        seq(
          field('kind', choice('let', 'const')),
          field('left', choice(
            $.identifier,
            $._destructuring_pattern,
          )),
          optional($._automatic_semicolon),
        ),
      ),
      field('operator', choice($._kw_in, $._kw_of)),
      field('right', $._expressions),
      ')',
    ),

    while_statement: ($) => seq(
      $._kw_while,
      field('condition', $.parenthesized_expression),
      field('body', $.statement),
    ),

    do_statement: ($) => prec.right(seq(
      $._kw_do,
      field('body', $.statement),
      $._kw_while,
      field('condition', $.parenthesized_expression),
      optional($._semicolon),
    )),

    try_statement: ($) => seq(
      $._kw_try,
      field('body', $.statement_block),
      repeat(field('handler', $.catch_clause)),
      optional(field('finalizer', $.finally_clause)),
    ),

    with_statement: ($) => seq(
      $._kw_with,
      field('object', $.parenthesized_expression),
      field('body', $.statement),
    ),

    break_statement: ($) => seq(
      $._kw_break,
      field('label', optional(alias($.identifier, $.statement_identifier))),
      $._semicolon,
    ),

    continue_statement: ($) => seq(
      $._kw_continue,
      field('label', optional(alias($.identifier, $.statement_identifier))),
      $._semicolon,
    ),

    // `prec`, not a declared conflict: with `debugger` now a reserved
    // identifier, `debugger;` parses both as this statement and as a bare
    // expression. The statement is the right reading and precedence settles
    // it at generation time, where a conflict would carry two GLR stacks
    // every time the word appears.
    debugger_statement: ($) => prec(1, seq(
      $._kw_debugger,
      $._semicolon,
    )),

    return_statement: ($) => seq(
      $._kw_return,
      optional($._expressions),
      $._semicolon,
    ),

    // `throw` takes an expression (`throw "msg";`) but is also called with
    // named arguments (`throw(type="x", message="y")` / `throw(type:"x")`).
    // `pair` is only reachable from `arguments`, so accept those explicitly.
    throw_statement: ($) => seq(
      $._kw_throw,
      choice(prec.dynamic(1, $.arguments), $._expressions),
      $._semicolon,
    ),

    include_statement: ($) => prec(1, seq(
      $._kw_include,
      choice(
        seq(repeat1($.parameter_attribute), $._semicolon),
        seq($._expressions, $._semicolon),
      ),
    )),

    empty_statement: (_) => ';',

    labeled_statement: ($) => prec.dynamic(-1, seq(
      field('label', alias(choice($.identifier, $._reserved_identifier), $.statement_identifier)),
      ':',
      field('body', $.statement),
    )),

    //
    // Statement components
    //

    switch_body: ($) => seq(
      '{',
      repeat(choice($.switch_case, $.switch_default)),
      '}',
    ),

    switch_case: ($) => seq(
      $._kw_case,
      field('value', $._expressions),
      ':',
      field('body', repeat($.statement)),
    ),

    switch_default: ($) => seq(
      $._kw_default,
      ':',
      field('body', repeat($.statement)),
    ),

    catch_clause: ($) => seq(
      $._kw_catch,
      optional(
        seq(
          '(',
          optional(field('type', alias(choice($.identifier, $.nested_identifier, $.string), $.catch_type))),
          // `catch( any var e )` — CommandBox's endpoints scope the caught
          // variable, which Lucee and ACF both accept.
          optional($._kw_var),
          field('parameter', choice($.identifier, $.nested_identifier, $._destructuring_pattern)),
          ')',
        ),
      ),
      field('body', $.statement_block),
    ),

    finally_clause: ($) => seq(
      $._kw_finally,
      field('body', $.statement_block),
    ),

    parenthesized_expression: ($) => seq(
      '(',
      $._expressions,
      ')',
    ),

    //
    // Expressions
    //
    _expressions: ($) => choice(
      $.expression,
      $.sequence_expression,
      $._hash_always_eval,
    ),

    expression: ($) => choice(
      $.primary_expression,
      $.assignment_expression,
      $.augmented_assignment_expression,
      $.unary_expression,
      $.binary_expression,
      $.ternary_expression,
      $.elvis_expression,
      $.update_expression,
      $.new_expression,
      $._hash_always_eval,
      $.object_pattern,
      $.query_expression,
    ),

    primary_expression: ($) => choice(
      $.subscript_expression,
      $.member_expression,
      $.parenthesized_expression,
      $._identifier,
      alias($._reserved_identifier, $.identifier),
      $.this,
      $.super,
      $.number,
      $.string,
      $.template_string,
      $.regex,
      $.true,
      $.false,
      $.null,
      $.object,
      $.array,
      $.ordered_struct,
      $.function_expression,
      $.arrow_function,
      $.call_expression,
    ),

    object: ($) => prec('object', seq(
      '{',
      commaSep(optional(choice(
        $.pair,
        $.cf_pair,
        $.spread_element,
        $.method_definition,
        alias(
          choice($.identifier, $._reserved_identifier),
          $.shorthand_property_identifier,
        ),
      ))),
      '}',
    )),

    object_pattern: ($) => prec('object', seq(
      '{',
      commaSep(optional(choice(
        $.pair_pattern,
        $.cf_pair,
        $.rest_pattern,
        $.object_assignment_pattern,
        alias(
          choice($.identifier, $._reserved_identifier),
          $.shorthand_property_identifier_pattern,
        ),
      ))),
      '}',
    )),

    assignment_pattern: ($) => seq(
      field('left', $.pattern),
      '=',
      field('right', $.expression),
    ),

    object_assignment_pattern: ($) => seq(
      field('left', choice(
        alias(choice($._reserved_identifier, $.identifier), $.shorthand_property_identifier_pattern),
        $._destructuring_pattern,
      )),
      '=',
      field('right', $.expression),
    ),

    array: ($) => seq(
      '[',
      commaSep(optional(choice(
        $.expression,
        $.pair,
        $.spread_element,
      ))),
      ']',
    ),

    // `[ : ]` and `[ = ]` are both empty ordered structs; Lucee accepts either.
    ordered_struct: ($) => prec(1, choice(seq('[', ':', ']'), seq('[', '=', ']'))),

    array_pattern: ($) => seq(
      '[',
      commaSep(optional(choice(
        $.pattern,
        $.assignment_pattern,
      ))),
      ']',
    ),

    nested_identifier: ($) => prec('member', seq(
      field('object', choice($.identifier, alias($.nested_identifier, $.member_expression))),
      /[.:]/,
      field('property', alias($.identifier, $.property_identifier)),
    )),

    component: ($) => prec('literal', seq(
      optional(choice($._kw_static, $._kw_abstract, $._kw_final)),
      choice(
        $._kw_component,
        $._kw_interface,
      ),
      repeat(seq(optional($.tag_linefeed), $.component_attribute)),
      field('body', $.component_body),
    )),

    component_attribute: ($) => choice(
      seq(
        alias($.identifier, $.attribute_label),
        ':',
        $.component_attribute,
      ),
      seq(
        $.identifier,
        '=',
        $.expression,
      ),
      $.identifier,
    ),

    function_expression: ($) => prec('literal', seq(
      $._kw_function,
      field('name', optional($.identifier)),
      $._call_signature,
      repeat(prec(1, $.assignment_expression)),
      field('body', $.statement_block),
    )),

    // NOTE: these overlap with `_reserved_identifier` (they must stay usable as
    // plain identifiers), so they cannot become `token(prec(1, ...))` keywords
    // without breaking `static['key']` / `query.newQuery()`. Left case-sensitive.
    access_type: ($) => choice(
      $._kw_public,
      $._kw_private,
      $._kw_package,
      $._kw_remote,
      $._kw_static,
      $._kw_final,
      $._kw_abstract,
    ),

    // CFML type names are spelled with the same words as several keywords
    // (`Component listener`, `Static state`, `Final value`). Those words lex as
    // keywords here because `_reserved_identifier` makes them valid at the start
    // of a parameter, so accept them as a type name too.
    parameter_type: ($) => choice(
      keyword('Any'),
      keyword('String'),
      keyword('Numeric'),
      keyword('Xml'),
      keyword('Binary'),
      keyword('Boolean'),
      keyword('Date'),
      $._kw_function,
      keyword('Guid'),
      keyword('Query'),
      keyword('Void'),
      // `Component listener` — `component` lexes as a keyword here because
      // `_reserved_identifier` makes it valid at the start of a parameter, so it
      // never reaches `$.identifier` below.
      alias($._kw_component, $.identifier),
      $.path,
      $.identifier,
    ),

    function_declaration: ($) => prec.right('declaration', seq(
      repeat($.access_type),
      optional(seq(
        choice($._kw_function, keyword('Query'), $.path, $.identifier),
        // `IValidationError[] function getFieldErrors()` — an array of that
        // type (cbvalidation). The brackets must be empty and adjacent: that is
        // the only thing separating this from a subscript, `User[0]`.
        optional($.array_return_suffix),
      )),
      $._kw_function,
      field('name', $.identifier),
      $._call_signature,
      repeat(prec(1, seq(optional($.tag_linefeed), choice($.assignment_expression, $.identifier)))),
      choice(
        seq(optional($.tag_linefeed), field('body', $.statement_block), optional($._automatic_semicolon)),
        $._semicolon,
      ),
    )),

    // A single token, not `seq('[', ']')`: as two tokens the `[` is reachable
    // from `subscript_expression` and `array` in the same state, and the parser
    // cannot tell which until it has read the `]`. Lexing the pair together
    // moves that decision into the lexer, where one character of lookahead
    // settles it.
    array_return_suffix: (_) => token(seq('[', ']')),

    arrow_function: ($) => seq(
      // optional('async'),
      choice(
        field('parameter', choice(
          alias($._reserved_identifier, $.identifier),
          $.identifier,
        )),
        $._call_signature,
      ),
      // Lucee spells a closure `=>` and a lambda `->`. The two differ in how
      // they capture scope at runtime, not in shape, so one rule covers both
      // and the token itself records which was written.
      choice('=>', '->'),
      field('body', choice(
        $.expression,
        $.statement_block,
      )),
    ),

    _call_signature: ($) => field('parameters', $.formal_parameters),
    _formal_parameter: ($) => choice(
      seq(
        optional(keyword('Required')),
        $.parameter_type,
        optional(choice($.pattern, $.assignment_pattern)),
        repeat($.parameter_attribute),
      ),
      seq(
        optional(keyword('Required')),
        choice($.pattern, $.assignment_pattern),
        repeat($.parameter_attribute),
      ),
    ),

    parameter_attribute: ($) => prec.dynamic(-2, seq(
      $.identifier,
      '=',
      $.string,
    )),

    optional_chain: (_) => '?.',
    static_chain: (_) => '::',

    call_expression: ($) => choice(
      prec('call', seq(
        field('function', choice($.primary_expression, $._hash_always_eval)),
        field('arguments', $.arguments),
      )),
      prec('member', seq(
        field('function', $.primary_expression),
        field('optional_chain', $.optional_chain),
        field('arguments', $.arguments),
      )),
    ),

    new_expression: ($) => prec.right('new', choice(
      seq(
        $._kw_new,
        // Standalone token on purpose: inside `new <X>` the extracted keyword
        // would lex as an identifier, breaking the inline-component form.
        $._kw_component,
        repeat(seq(optional($.tag_linefeed), $.component_attribute)),
        field('body', $.component_body),
      ),
      seq(
        $._kw_new,
        // One token including the `:`, not `seq(choice('java','cfml'), ':')`.
        // As separate tokens the bare `java` and `cfml` out-lex `identifier`
        // straight after `new`, so `new java.util.Properties()` lexed `java` as
        // the prefix and then demanded a colon. Requiring the colon inside the
        // token means `java.` simply fails to match it and falls back to an
        // identifier, which is what CFML's Java interop needs.
        optional(field('prefix', alias($._new_type_prefix, $.type_prefix))),
        optional(field('constructor', choice($.primary_expression, $.new_expression))),
        field('arguments', optional(prec.dynamic(1, $.arguments))),
      ),
    )),

    _new_type_prefix: (_) => token(seq(choice('java', 'cfml'), ':')),

    member_expression: $ => prec('member', seq(
      field('object', choice($.expression, $.primary_expression)),
      choice('.', field('optional_chain', $.optional_chain), field('static_chain', $.static_chain)),
      field('property', choice(
        $.private_property_identifier,
        alias($.identifier, $.property_identifier),
        alias($._kw_new, $.property_identifier),
      )),
    )),

    subscript_expression: ($) => prec.right('member', seq(
      field('object', choice($.expression, $.primary_expression)),
      optional(field('optional_chain', $.optional_chain)),
      '[', field('index', choice($._expressions, $.slice_expression)), ']',
    )),

    // Lucee string / array slicing: `s[4:13]`, `s[4:13:2]`, `s[-10:-4]`.
    // Bounds are optional (`s[:5]`, `s[3:]`). This used to fall out of `pair`
    // being reachable inside a subscript through the expression conflicts;
    // spelling it out keeps slicing working without that ambiguity.
    slice_expression: ($) => prec.right(seq(
      optional(field('start', $.expression)),
      ':',
      optional(field('end', $.expression)),
      optional(seq(':', optional(field('step', $.expression)))),
    )),

    _lhs_expression: ($) => choice(
      $.string,
      $.member_expression,
      $.null,
      $.subscript_expression,
      $._identifier,
      alias($._reserved_identifier, $.identifier),
      // `function` is a legal attribute / argument name in script-syntax tag
      // calls (Lucee's `admin ... function="" ...`), so it has to be assignable.
      // It is deliberately not in `_reserved_identifier`: as a general expression
      // start it would make every binary operator valid straight after
      // `function`, and keyword extraction would then lex the name in
      // `function instanceOf( ... )` as the `instanceof` operator.
      alias($._kw_function, $.identifier),
      $._destructuring_pattern,
    ),

    assignment_expression: ($) => prec.right('assign', seq(
      field('left', choice(
        $.parenthesized_expression,
        $._lhs_expression,
      )),
      '=',
      field('right', choice($.expression, $._hash_always_eval)),
    )),

    _augmented_assignment_lhs: ($) => choice(
      $.member_expression,
      $.subscript_expression,
      alias($._reserved_identifier, $.identifier),
      $.identifier,
      $.parenthesized_expression,
    ),

    augmented_assignment_expression: ($) => prec.right('assign', seq(
      field('left', $._augmented_assignment_lhs),
      field('operator', choice('+=', '-=', '*=', '/=', '%=', '^=', '&=', '|=', '>>=', '>>>=',
        '<<=', '**=', '&&=', '||=', '??=')),
      field('right', $.expression),
    )),

    _initializer: ($) => seq(
      '=',
      field('value', $.expression),
    ),

    _destructuring_pattern: ($) => choice(
      $.array_pattern,
    ),

    spread_element: ($) => seq('...', $.expression),

    ternary_expression: ($) => prec.right('ternary', seq(
      field('condition', $.expression),
      alias($._ternary_qmark, '?'),
      field('consequence', $.expression),
      ':',
      field('alternative', $.expression),
    )),

    elvis_expression: ($) => prec.right('elvis', seq(
      field('condition', $.expression),
      alias($._elvis_operator, '?:'),
      field('alternative', $.expression),
    )),

    binary_expression: ($) => choice(
      ...[
        ['&&', 'logical_and'],
        [/[aA][nN][dD]/, 'logical_and'],
        [choice($.logical_or, '||'), 'logical_or'],
        [/[oO][rR]/, 'logical_or'],
        [/[xX][oO][rR]/, 'logical_xor'],
        ['>>', 'binary_shift'],
        ['>>>', 'binary_shift'],
        ['<<', 'binary_shift'],
        ['&', 'bitwise_and'],
        ['^', 'bitwise_xor'],
        ['|', 'bitwise_or'],
        ['+', 'binary_plus'],
        ['-', 'binary_plus'],
        ['*', 'binary_times'],
        ['/', 'binary_times'],
        ['%', 'binary_times'],
        ['\\', 'binary_times'],
        [/[mM][oO][dD]/, 'binary_times'],
        ['**', 'binary_exp', 'right'],
        ['<', 'binary_relation'],
        [/[lL][tT]/, 'binary_relation'],
        ['<=', 'binary_relation'],
        [/[lL][tT][eE]/, 'binary_relation'],
        [/[lL][eE]/, 'binary_relation'],
        ['==', 'binary_equality'],
        ['===', 'binary_equality'],
        [/[eE][qQ]/, 'binary_equality'],
        [/[eE][qQ][uU][aA][lL]/, 'binary_equality'],
        [/[iI][sS]/, 'binary_equality'],
        ['<>', 'binary_equality'],
        ['!=', 'binary_equality'],
        ['!==', 'binary_equality'],
        [/[nN][eE][qQ]/, 'binary_equality'],
        [/[cC][oO][nN][tT][aA][iI][nN][sS]/, 'binary_equality'],
        [/[cC][tT]/, 'binary_equality'],
        [/[dD][oO][eE][sS]\s[nN][oO][tT]\s[cC][oO][nN][tT][aA][iI][nN]/, 'binary_equality'],
        [/[nN][cC][tT]/, 'binary_equality'],
        ['>=', 'binary_relation'],
        [/[gG][tT][eE]/, 'binary_relation'],
        [/[gG][eE]/, 'binary_relation'],
        ['>', 'binary_relation'],
        [/[gG][tT]/, 'binary_relation'],
        [/[gG][rR][eE][aA][tT][eE][rR]\s+[tT][hH][aA][nN]/, 'binary_relation'],
        [/[lL][eE][sS][sS]\s+[tT][hH][aA][nN]/, 'binary_relation'],
        [/[gG][rR][eE][aA][tT][eE][rR]\s+[tT][hH][aA][nN]\s+[oO][rR]\s+[eE][qQ][uU][aA][lL]\s+[tT][oO]/, 'binary_relation'],
        [/[lL][eE][sS][sS]\s+[tT][hH][aA][nN]\s+[oO][rR]\s+[eE][qQ][uU][aA][lL]\s+[tT][oO]/, 'binary_relation'],
        [/[nN][oO][tT]\s+[eE][qQ][uU][aA][lL]/, 'binary_equality'],
        ['??', 'ternary'],
        [$._kw_instanceof, 'binary_relation'],
        [$._kw_in, 'binary_relation'],
      ].map(([operator, precedence, associativity]) =>
        // @ts-ignore
        (associativity === 'right' ? prec.right : prec.left)(precedence, seq(
          field('left', $.expression),
          field('operator', operator),
          field('right', $.expression),
        )),
      ),
    ),

    // @ts-ignore
    unary_operator: $ => choice(
      '!',
      '~',
      '-',
      '+',
      alias(/[nN][oO][tT]/, 'not'),
    ),

    unary_expression: ($) => prec.left('unary_void', seq(
      field('operator', $.unary_operator),
      field('argument', $.expression),
    )),

    update_expression: ($) => prec.left(choice(
      seq(
        field('argument', $.expression),
        field('operator', choice('++', '--')),
      ),
      seq(
        field('operator', choice('++', '--')),
        field('argument', $.expression),
      ),
    )),

    sequence_expression: ($) => prec.right(commaSep1($.expression)),

    //
    // Primitives
    //

    string: ($) => choice(
      seq(
        '"',
        choice(
          repeat(choice(
            $._hash_always_eval,
            '""',
            alias($.unescaped_double_string_fragment, $.string_fragment),
          )),
        ),
        '"',
      ),

      seq(
        '\'',
        choice(
          repeat(choice(
            alias($.unescaped_single_string_fragment, $.string_fragment),
            $._hash_always_eval,
            '\'\'',
          )),
        ),
        '\'',
      ),
    ),

    // tree-sitter/tree-sitter#1156: named token() regexp rules so string fragments appear in the CST.
    //
    unescaped_double_string_fragment: (_) => token.immediate(prec(1, /[^"#]+/)),

    // Pair: single-quoted string fragment.
    unescaped_single_string_fragment: (_) => token.immediate(prec(1, /[^'#]+/)),

    // http://stackoverflow.com/questions/13014947/regex-to-match-a-c-style-multiline-comment/36328890#36328890
    comment: (_) => token(choice(
      seq('//', /[^\r\n\u2028\u2029]*/),
      seq(
        '/*',
        /[^*]*\*+([^/*][^*]*\*+)*/,
        '/',
      ),
    )),

    template_substitution: ($) => seq(
      '${',
      $._expressions,
      '}',
    ),

    regex: ($) => seq(
      '/',
      field('pattern', $.regex_pattern),
      token.immediate(prec(1, '/')),
      optional(field('flags', $.regex_flags)),
    ),

    regex_pattern: (_) => token.immediate(prec(-1,
      repeat1(choice(
        seq(
          '[',
          repeat(choice(
            seq('\\', /./), // escaped character
            /[^\]\n\\]/, // any character besides ']' or '\n'
          )),
          ']',
        ), // square-bracket-delimited character class
        seq('\\', /./), // escaped character
        /[^/\\\[\n]/, // any character besides '[', '\', '/', '\n'
      )),
    )),

    regex_flags: (_) => token.immediate(/[a-z]+/),

    number: (_) => {
      const hexLiteral = seq(
        choice('0x', '0X'),
        /[\da-fA-F](_?[\da-fA-F])*/,
      );

      const decimalDigits = /\d(_?\d)*/;
      const signedInteger = seq(optional(choice('-', '+')), decimalDigits);
      const exponentPart = seq(choice('e', 'E'), signedInteger);

      const binaryLiteral = seq(choice('0b', '0B'), /[0-1](_?[0-1])*/);

      const octalLiteral = seq(choice('0o', '0O'), /[0-7](_?[0-7])*/);

      const bigintLiteral = seq(choice(hexLiteral, binaryLiteral, octalLiteral, decimalDigits), 'n');

      const decimalIntegerLiteral = choice(
        '0',
        seq(optional('0'), /[1-9]/, optional(seq(optional('_'), decimalDigits))),
      );

      const decimalLiteral = choice(
        seq(decimalIntegerLiteral, '.', optional(decimalDigits), optional(exponentPart)),
        seq('.', decimalDigits, optional(exponentPart)),
        seq(decimalIntegerLiteral, exponentPart),
        decimalDigits,
      );

      return token(choice(
        hexLiteral,
        decimalLiteral,
        binaryLiteral,
        octalLiteral,
        bigintLiteral,
      ));
    },

    // 'undefined' is syntactically a regular identifier in JavaScript.
    // However, its main use is as the read-only global variable whose
    // value is [undefined], for which there's no literal representation
    // unlike 'null'. Kept as a distinct rule for highlighting and tooling.
    _identifier: ($) => choice(
      $.undefined,
      $.identifier,
    ),

    identifier: (_) => {
      // @ts-ignore
      const alphanumeric = /[^\x00-\x1F\s\p{Zs}:;`"'@#.,|^&<=>+#\-*/\\%?!~()\[\]{}\uFEFF\u2060\u200B\u2028\u2029]|\\u[0-9a-fA-F]{4}|\\u\{[0-9a-fA-F]+\}/;
      return token(seq(alphanumeric, repeat(alphanumeric)));
    },

    private_property_identifier: _ => {
      // @ts-ignore
      const alpha = /[^\x00-\x1F\s\p{Zs}0-9:;`"'@#&?.,\[\]|^&<=>+\-*#/\\%?!~()\[\]{}\uFEFF\u2060\u200B\u2028\u2029]|\\u[0-9a-fA-F]{4}|\\u\{[0-9a-fA-F]+\}/;

      // @ts-ignore

      const alphanumeric = /[^\x00-\x1F\s\p{Zs}:;`"'@#&?.,\[\]|^&<=>+\-*#/\\%?!~()\[\]{}\uFEFF\u2060\u200B\u2028\u2029]|\\u[0-9a-fA-F]{4}|\\u\{[0-9a-fA-F]+\}/;
      return token(seq('~', alpha, repeat(alphanumeric)));
    },


    this: (_) => keyword('This'),
    super: (_) => keyword('Super'),
    true: (_) => keyword('True'),
    false: (_) => keyword('False'),
    null: (_) => keyword('Null'),
    undefined: (_) => keyword('Undefined'),

    //
    // Expression components
    //

    arguments: ($) => seq(
      '(',
      commaSep(optional(choice($.expression, $.pair, $._hash_always_eval, $.spread_element))),
      ')',
    ),

    // Script-syntax tag calls: `cfdirectory( directory="#d#" action="create" )`.
    //
    // The commas are optional rather than absent. Real code mixes both in one
    // call — Lucee has `cflog(file="#n#" text="load test", type="error",
    // async=false)` and `cfdirectory(action="list", directory=trg, name="x"
    // recurse=true)` — so a rule that required all-spaces would miss most of
    // the corpus cases.
    //
    // Two restrictions keep this from colliding with an ordinary call:
    //
    // 1. Values are narrower than `expression`. With a general expression,
    //    `f( a=1 [x] )` is ambiguous between a second argument and a subscript
    //    on `1`, and tree-sitter's resolution for that is a conflict on
    //    `expression` with itself, which cannot be declared. That ambiguity is
    //    what sank the first attempt at this rule. Every value shape below was
    //    taken from real tag calls in the corpus; none of them is a subscript
    //    or an array literal, so no `[` can ever follow a complete value.
    // 2. At least two arguments are required. A single `f( a=1 )` already
    //    parses through `arguments` above, so admitting it here would add an
    //    ambiguity that buys nothing.
    // A script-syntax tag call is only ever a **statement**. The corpus has 61
    // space-separated tag calls and not one is a sub-expression — no
    // `x = cfdirectory( a="1" b="2" )`, none nested inside another call.
    //
    // That matters for cost, not just tidiness. While this form lived in
    // `call_expression` it was reachable from every expression, so its
    // conflicts were live at every call site in the language, and a large
    // script component (cfwheels `Global.cfc`) went 144 ms -> 401 ms.
    // Aliased to `expression_statement` at the use site, so
    // `cfdirectory( a="1" b="2" );` and `cfdirectory( a="1", b="2" );` produce
    // identical trees — the comma form is an ordinary call in an expression
    // statement, and nothing downstream should have to tell them apart.
    tag_call_statement: ($) => seq(
      alias($._tag_call, $.call_expression),
      $._semicolon,
    ),

    _tag_call: ($) => prec('call', seq(
      field('function', $.identifier),
      field('arguments', alias($.tag_call_arguments, $.arguments)),
    )),

    tag_call_arguments: ($) => seq(
      '(',
      // The first two arguments have no comma between them; after that commas
      // are optional, because real calls mix the two — Lucee writes
      // `cflog(file="#n#" text="load test", type="error", async=false)`.
      //
      // Requiring the space at the *first* junction rather than anywhere is
      // what keeps this tractable. A rule that allowed a leading comma-run
      // would be ambiguous with ordinary `arguments` from the opening paren
      // until the first space, so every comma-separated named call in the
      // language would carry two live GLR stacks — in a grammar that has
      // already had to fix a GLR state explosion once (0.26.29).
      //
      // The corpus says the trade is worth it: of the calls this feature
      // targets, 74 across 32 files put a space at the first junction and 11
      // across 4 files put a comma there. Those 4 files stay unparsed, and are
      // recorded in LIMITATIONS.md.
      $._tag_call_argument,
      $._tag_call_argument,
      repeat(seq(optional(','), $._tag_call_argument)),
      optional(','),
      ')',
    ),

    // Aliased to `assignment_expression` so that `cfdirectory( a="1" b="2" )`
    // and `cfdirectory( a="1", b="2" )` produce identical trees. They mean the
    // same thing, and every highlight query, indent rule and downstream
    // consumer already handles the comma form.
    _tag_call_argument: ($) => alias($.tag_call_attribute, $.assignment_expression),

    tag_call_attribute: ($) => seq(
      field('left', $.identifier),
      '=',
      field('right', $._tag_call_value),
    ),

    // Shapes observed in the corpus: quoted strings with and without `#hash#`
    // interpolation, bare variables (`params=p`), dotted paths
    // (`returnType=form.returnType`), booleans (`recurse=true`), numbers, and
    // bare hash expressions.
    _tag_call_value: ($) => choice(
      $.string,
      $.number,
      $.true,
      $.false,
      $.null,
      $.identifier,
      $.member_expression,
      $._hash_always_eval,
    ),

    decorator: ($) => seq(
      '@',
      choice(
        $.identifier,
        alias($.decorator_member_expression, $.member_expression),
        alias($.decorator_call_expression, $.call_expression),
      ),
    ),

    decorator_member_expression: ($) => prec('member', seq(
      field('object', choice(
        $.identifier,
        alias($.decorator_member_expression, $.member_expression),
      )),
      /[.:]/,
      field('property', alias($.identifier, $.property_identifier)),
    )),

    decorator_call_expression: ($) => prec('call', seq(
      field('function', choice(
        $.identifier,
        alias($.decorator_member_expression, $.member_expression),
      )),
      field('arguments', $.arguments),
    )),

    component_body: ($) => seq(
      '{',
      repeat(choice($.statement, $.property_declaration, $.static_initializer)),
      '}',
    ),

    static_initializer: ($) => seq($._kw_static, $.statement_block),

    property_declaration: ($) => seq(
      $._kw_property,
      choice(
        prec.dynamic(1, seq(
          optional(field('type', choice($.path, $.identifier))),
          field('name', $.identifier),
          repeat(seq(optional($.tag_linefeed), $.component_attribute)),
        )),
        repeat1(seq(optional($.tag_linefeed), $.component_attribute)),
      ),
      $._semicolon,
    ),

    field_definition: ($) => seq(
      repeat(field('decorator', $.decorator)),
      optional($._kw_static),
      field('property', $._property_name),
      optional($._initializer),
    ),

    formal_parameters: ($) => seq(
      '(',
      optional(seq(
        commaSep1($._formal_parameter),
        optional(','),
      )),
      ')',
    ),

    // This negative dynamic precedence ensures that during error recovery,
    // unfinished constructs are generally treated as literal expressions,
    // not patterns.
    pattern: ($) => prec.dynamic(-1, choice(
      $._lhs_expression,
      $.rest_pattern,
    )),

    rest_pattern: ($) => prec.right(seq(
      '...',
      $._lhs_expression,
    )),

    method_definition: ($) => seq(
      repeat(field('decorator', $.decorator)),
      optional(choice(
        $._kw_static,
        alias(token(seq(/[sS][tT][aA][tT][iI][cC]/, /\s+/, /[gG][eE][tT]/, /\s*\n/)), 'static get'),
      )),
      // optional('async'),
      optional(choice('get', 'set', '*')),
      field('name', $._property_name),
      field('parameters', $.formal_parameters),
      field('body', $.statement_block),
    ),

    pair: ($) => seq(
      field('key', $._property_name),
      ':',
      field('value', $.expression),
    ),

    cf_pair: ($) => seq(
      field('key', $._property_name),
      '=',
      field('value', $.expression),
    ),

    pair_pattern: ($) => seq(
      field('key', $._property_name),
      ':',
      field('value', choice($.pattern, $.assignment_pattern)),
    ),

    _property_name: ($) => choice(
      alias(
        choice($.identifier, $._reserved_identifier),
        $.property_identifier,
      ),
      // $.private_property_identifier,
      $.null,
      $.string,
      $.number,
      $.computed_property_name,
      $._hash_always_eval,
    ),

    _hash_always_eval: ($) => choice(
      $.hash_expression,
      $.hash_empty,
    ),

    _hash: ($) => '#',

    hash_expression: ($) => seq(
      '#',
      $.expression,
      '#',
    ),

    hash_empty: ($) => token.immediate('##'),

    computed_property_name: ($) => seq(
      '[',
      $.expression,
      ']',
    ),

    // NOTE: these stay case-sensitive on purpose. They must remain usable as
    // plain identifiers (`static['key']`, `query.newQuery()`), and a
    // `token(prec(1, ...))` keyword would always win in the lexer.
    _reserved_identifier: ($) => choice(
      'get',
      'set',
      $._kw_static,
      'export',
      'let',
      $._kw_component,
      $._kw_private,
      $._kw_public,
      $._kw_include,
      keyword('Query'),
      keyword('QueryExecute'),
      $._kw_new,
      $._kw_package,
      $._kw_remote,
      $._kw_abstract,
      $._kw_final,
      // `debugger.log( … )` and `debugger = 1` — Preside's SAML module uses
      // `debugger` as an ordinary scope. Without this the keyword out-lexes
      // the identifier at statement start, though `x = debugger.foo` always
      // parsed because no statement keyword is valid there.
      $._kw_debugger,
      // `function` is deliberately absent. Listing it here made `function` a
      // valid expression start, which in turn made every binary operator —
      // including `instanceof` — valid immediately after it. Keyword extraction
      // then lexed the name in `function instanceOf( ... )` as the operator
      // instead of an identifier. See
      // test/probes/cfscript/function_named_instanceof.cfc.
    ),

    _semicolon: ($) => choice($._automatic_semicolon, ';'),

    /*
        END SCRIPT BASED RULES
      */
    template_string: ($) => seq(
      '`',
      repeat(choice(
        alias($._template_chars, $.string_fragment),
        $.template_substitution,
      )),
      '`',
    ),

    cfml_template: ($) => seq('```', $.cfml_template_content, '```'),

    query_expression: ($) => seq(
      keyword('QueryExecute'),
      '(',
      choice(
        seq('"', $.query_text, '"'),
        seq('\'', $.query_text, '\''),
      ),
      repeat(
        seq(
          '&',
          choice(
            seq('"', $.query_text, '"'),
            seq('\'', $.query_text, '\''),
            $.identifier,
            $.parenthesized_expression,
          ),
        ),
      ),
      repeat(seq(',', $.expression)),
      ')',
    ),

    query_tag: ($) => seq(
      keyword('Query'),
      repeat(prec(1, seq(optional($.tag_linefeed), field('arguments', $.assignment_expression)))),
      optional($.tag_linefeed),
      field('body', $.statement_block),
    ),

    tag_statement: $ => choice(
      // `param string url.id default="0";` — the shorthand form names a type and
      // the variable before the attributes. The attribute-only form
      // (`param name="url.id" default="0";`) is the second branch below.
      seq(
        // Both the tag and the type stay plain identifiers. Spelling the type as
        // a set of keyword tokens instead would make `array` lex as a keyword
        // wherever this branch is live, which breaks the attribute form of every
        // other tag statement — `loop array=data` loses its `array` identifier.
        // What separates the two forms is what follows the type: a name here, an
        // `=` in the attribute branch below.
        field('tag', $.identifier),
        field('type', alias($.identifier, $.parameter_type)),
        field('name', choice($.identifier, $.member_expression)),
        field('arguments', repeat(seq(optional($.tag_linefeed), $.assignment_expression, optional(',')))),
        $._semicolon,
      ),
      seq(
        field('tag', $.identifier),
        optional($.tag_linefeed),
        // The space-separated attribute form reaches the bodyless call through
        // `call_expression`, but a tag call with a body is a statement, so it
        // needs the alternative spelled out here too. `cfquery( name="q"
        // datasource="d" ) { ... }` is the common shape.
        optional(field('arguments', choice(
          $.arguments,
          alias($.tag_call_arguments, $.arguments),
        ))),
        field('body', $.statement_block),
        $._semicolon,
      ),
      seq(
        field('tag', $.identifier),
        field('arguments', repeat1(seq(optional($.tag_linefeed), $.assignment_expression, optional(',')))),
        optional(field('body', $.statement_block)),
        $._semicolon,
      ),
    ),

    // Keyword tokens. Defined once here and referenced as `$._kw_<word>`
    // so a keyword can never be spelled two different ways in two rules —
    // that divergence is what previously produced two competing tokens for
    // `component`. Hidden (leading `_`) so they add no node to the tree.
    _kw_abstract: (_) => keyword('Abstract'),
    _kw_break: (_) => keyword('Break'),
    _kw_case: (_) => keyword('Case'),
    _kw_catch: (_) => keyword('Catch'),
    _kw_component: (_) => keyword('Component'),
    _kw_continue: (_) => keyword('Continue'),
    _kw_debugger: (_) => keyword('Debugger'),
    _kw_default: (_) => keyword('Default'),
    _kw_do: (_) => keyword('Do'),
    _kw_else: (_) => keyword('Else'),
    _kw_final: (_) => keyword('Final'),
    _kw_finally: (_) => keyword('Finally'),
    _kw_for: (_) => keyword('For'),
    _kw_function: (_) => keyword('Function'),
    _kw_if: (_) => keyword('If'),
    _kw_import: (_) => keyword('Import'),
    _kw_in: (_) => keyword('In'),
    _kw_include: (_) => keyword('Include'),
    _kw_instanceof: (_) => keyword('InstanceOf', 'instanceof'),
    _kw_interface: (_) => keyword('Interface'),
    _kw_new: (_) => keyword('New'),
    _kw_of: (_) => keyword('Of'),
    _kw_package: (_) => keyword('Package'),
    _kw_private: (_) => keyword('Private'),
    _kw_property: (_) => keyword('Property'),
    _kw_public: (_) => keyword('Public'),
    _kw_remote: (_) => keyword('Remote'),
    _kw_return: (_) => keyword('Return'),
    _kw_static: (_) => keyword('Static'),
    _kw_switch: (_) => keyword('Switch'),
    _kw_throw: (_) => keyword('Throw'),
    _kw_try: (_) => keyword('Try'),
    _kw_var: (_) => keyword('Var'),
    _kw_while: (_) => keyword('While'),
    _kw_with: (_) => keyword('With'),

  },
});

/**
 * CFML keywords are case-insensitive. Keywords are written in PascalCase and
 * matched in any of the accepted casings, then aliased back to a canonical node
 * name so node names and `.scm` queries stay stable.
 *
 * @param {string} word PascalCase spelling of the keyword, e.g. `Break`.
 * @param {string} [nodeName] Canonical node name. Defaults to `lowerFirst(word)`;
 *   pass it explicitly for tokens starting with punctuation, e.g. `('<Cf', '<cf')`.
 */
function keyword(word, nodeName = lowerFirst(word)) {
  return alias(choice(...casings(word)), nodeName);
}

/**
 * Casings accepted for a keyword. Keywords are written in PascalCase
 * (`Break`, `QueryExecute`, `<Cf`) so all four real-world forms fall out of the
 * one spelling: PascalCase, lowercase, UPPERCASE and camelCase.
 *
 * Interior mixed casing such as `reTURN` is deliberately not matched — it does
 * not occur in real code, and enumerating 2^n variants inflates the lexer.
 *
 * @param {string} word
 * @returns {string[]}
 */
function casings(word) {
  return [...new Set([
    word,
    word.toLowerCase(),
    word.toUpperCase(),
    lowerFirst(word),
  ])];
}

/**
 * Lowercase the first character. This is the canonical node name a keyword is
 * aliased to, which keeps `.scm` queries matching regardless of the casing in
 * the source. Tokens starting with punctuation (`<Cf`) must pass `nodeName`
 * explicitly, since lowercasing `<` is a no-op.
 *
 * @param {string} word
 * @returns {string}
 */
function lowerFirst(word) {
  return word.charAt(0).toLowerCase() + word.slice(1);
}