[ Avaa Bypassed ]

<?xml version="1.0" encoding="UTF-8"?>
<!--

 This file is part of GtkSourceView

 Author: Scott Martin <scott@coffeeblack.org>
 Copyright (C) 2004 Scott Martin <scott@coffeeblack.org>
 Copyright (C) 2005 Stef Walter (formerly Nate Nielsen) <stef@memberwebs.com>
 Copyright (C) 2005-2007 Marco Barisione <barisione@gmail.com>
 Copyright (C) 2005-2007 Emanuele Aina
 Copyright (C) 2019 Jeffery To <jeffery.to@gmail.com>

 GtkSourceView is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 GtkSourceView is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, see <http://www.gnu.org/licenses/>.

-->
<language id="js-expr" name="JavaScript Expressions" version="2.0" _section="Script" hidden="true">
  <!-- from js:identifier-char -->
  <keyword-char-class>[\p{L}\p{Nl}\x{1885}-\x{1886}\x{2118}\x{212E}\x{309B}-\x{309C}\p{Mn}\p{Mc}\p{Nd}\p{Pc}\x{00B7}\x{0387}\x{1369}-\x{1371}\x{19DA}$\x{200C}\x{200D}]</keyword-char-class>

  <definitions>

    <!--
         See javascript.lang for general notes, naming conventions, etc.
    -->

    <!--
         Expression / context structure:

         left-hand side (lhs) expression:  new Array ()
                                           === ===== ==
                                           /     |     \
                                pre-primary   primary   post-primary
                                expression   expression  expression

         expression: - obj.count + 1
                     = ========= ===
                    /      |       \
             pre-lhs      lhs       post-lhs
         expression    expression    expression
    -->


    <!-- # Pre-primary expression -->

    <context id="_pre-primary-expression">
      <include>
        <context ref="js:embedded-lang-hooks"/>

        <!-- ES2017, cannot be followed by line terminator -->
        <context id="_async-pre-primary-expression-keyword" style-ref="js:keyword">
          <match extended="true">
            \%[ async \%]
            (?=                                       # preceeds arrow function
              \%{js:optional-whitespace-or-comments}
              (?:
                \%{js:identifier}
                \%{js:optional-whitespace-or-comments}
                =&gt; |
                \(                                      # can this be better?
              )
            )
            (?!                                       # does not preceed "function" (leave to function expression)
              \%{js:optional-whitespace-or-comments}
              \%[ function \%]
            )
          </match>
        </context> <!-- /_async-pre-primary-expression-keyword -->

        <context id="_new-pre-primary-expression-keyword" style-ref="js:keyword">
          <match extended="true">
            \%[ new \%] (?! \%{js:new-target-object-keyword-suffix} )
          </match>
        </context> <!-- /_new-pre-primary-expression-keyword -->

      </include>
    </context> <!-- /_pre-primary-expression -->

    <context id="_ordered-pre-primary-expression" once-only="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="_pre-primary-expression"/>
      </include>
    </context> <!-- /_ordered-pre-primary-expression -->


    <!-- # Grouping / arrow function parameters

         (2 + 3) * 4
         (x, y) => x + y
         (x, ...rest) => { return rest; }
    -->

    <!-- doing it this way, instead of using expression-with-comma,
         will make later augmentation easier -->

    <context id="_grouping-item-content">
      <include>
        <context ref="js:ordered-rest-syntax"/>
        <context ref="expression-without-comma"/>
      </include>
    </context> <!-- /_grouping-item-content -->

    <!-- <CoverParenthesizedExpressionAndArrowParameterList> -->
    <context id="_choice-grouping" style-ref="js:grouping" end-parent="true">
      <start>\(</start>
      <end>\)</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:grouping-operator"/>
        <context sub-pattern="0" where="end" style-ref="js:grouping-operator"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_grouping-content">
          <include>

            <context id="_grouping-first-item" once-only="true">
              <start>\%{js:before-next-token}</start>
              <end>\%{js:before-next-token}</end>
              <include>
                <context ref="js:embedded-lang-hooks"/>
                <context ref="js:comments"/>
                <context ref="_grouping-item-content"/>
              </include>
            </context> <!-- /_grouping-first-item -->

            <context id="_grouping-items">
              <start>,</start>
              <end>\%{js:before-next-token}</end>
              <include>
                <context ref="js:embedded-lang-hooks"/>
                <context ref="js:comments"/>
                <context ref="_grouping-item-content"/>
              </include>
            </context> <!-- /_grouping-items -->

          </include>
        </context> <!-- /_grouping-content -->

      </include>
    </context> <!-- /_choice-grouping -->


    <!-- # Primary expression

         this
         Array
         'string'
         100
         ( ... )
         [ 1, 2, 3 ]
         function () { ... }
         /regex/
         `template`
    -->

    <!-- <PrimaryExpression> -->
    <context id="_primary-expression" once-only="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_primary-expression-content">
          <include>
            <context ref="js-lit:choice-array-literal"/>
            <context ref="js-lit:choice-object-literal"/>
            <context ref="js-lit:choice-regular-expression-literal"/>
            <context ref="js-lit:choice-template-literal"/>
            <context ref="js-fn:choice-function-expression"/>
            <context ref="js-fn:choice-class-expression"/>
            <context ref="_choice-grouping"/>
            <context ref="js-lit:choice-number"/>
            <context ref="js-lit:choice-string"/>

            <context id="_choice-primary-expression-identifier" end-parent="true">
              <start>(?=\%{js:identifier-start})</start>
              <end>\%{def:always-match}</end>
              <include>
                <!-- no embedded-lang-hooks here -->
                <!-- no comments here -->
                <!-- do not extend the context by matching comments or
                     embedded-lang-hooks, which may lead to multiple identifiers -->

                <context id="_primary-expression-identifier-content">
                  <include>
                    <!-- technically these would be choices, but it would be very
                         difficult to turn large keyword contexts into container
                         contexts with end-parent="true" -->
                    <context ref="js-lit:null-value"/>
                    <context ref="js-lit:boolean"/>
                    <context ref="js-val:global-values"/>
                    <context ref="js:identifier"/>
                  </include>
                </context> <!-- /_primary-expression-identifier-content -->

              </include>
            </context> <!-- /_choice-primary-expression-identifier -->

          </include>
        </context> <!-- /_primary-expression-content -->

      </include>
    </context> <!-- /_primary-expression -->

    <context id="_ordered-primary-expression" once-only="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="_primary-expression"/>
      </include>
    </context> <!-- /_ordered-primary-expression -->


    <!-- # Function call
         (in an expression, function arguments list after primary
         value)

         fn()
         fn(a, b, ...list)
    -->

    <context id="_function-arguments-content">
      <include>
        <context ref="js:ordered-spread-syntax"/>
        <context ref="expression-without-comma"/>
      </include>
    </context> <!-- /_function-arguments-content -->

    <!-- <Arguments> -->
    <context id="_function-arguments-lists">
      <start>\(</start>
      <end>\)</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_function-arguments-list-content">
          <include>

            <context id="_function-first-argument" once-only="true">
              <start>\%{js:before-next-token}</start>
              <end>\%{js:before-next-token}</end>
              <include>
                <context ref="js:embedded-lang-hooks"/>
                <context ref="js:comments"/>
                <context ref="_function-arguments-content"/>
              </include>
            </context> <!-- /_function-first-argument -->

            <context id="_function-arguments">
              <start>,</start>
              <end>\%{js:before-next-token}</end>
              <include>
                <context ref="js:embedded-lang-hooks"/>
                <context ref="js:comments"/>
                <context ref="_function-arguments-content"/>
              </include>
            </context> <!-- /_function-arguments -->

          </include>
        </context> <!-- /_function-arguments-list-content -->

      </include>
    </context> <!-- /_function-arguments-lists -->


    <!-- # Post-primary expression

         obj.property
         obj['property']
         fn()
         tag`template`
         obj?.property
         obj?.[expr]
         func?.()
    -->

    <context id="_post-primary-expression">
      <include>
        <context ref="js:embedded-lang-hooks"/>

        <!-- <MemberExpression> (part of) -->
        <context id="_dot-property-accessors">
          <start>\.(?!\.)</start> <!-- avoid matching rest/spread syntax -->
          <end>\%{js:before-next-token}</end>
          <include>
            <context ref="js:embedded-lang-hooks"/>
            <context ref="js:comments"/>

            <context id="_dot-property-accessor-content">
              <include>
                <context ref="js-val:properties-methods"/>
                <context ref="js:identifier-name"/>
              </include>
            </context> <!-- /_dot-property-accessor-content -->

          </include>
        </context> <!-- /_dot-property-accessors -->

        <!-- <MemberExpression> (part of) -->
        <context id="_bracket-property-accessors">
          <start>\[</start>
          <end>]</end>
          <include>
            <context ref="js:embedded-lang-hooks"/>
            <context ref="js:comments"/>

            <context id="_bracket-property-accessor-content">
              <include>
                <context ref="expression-with-comma"/>
              </include>
            </context> <!-- /_bracket-property-accessor-content -->

          </include>
        </context> <!-- /_bracket-property-accessors -->

        <!-- ES2020 -->
        <!-- <OptionalChain> (part of) -->
        <context id="_optional-chain">
          <start>\?\.(?![0-9])</start>
          <end>\%{js:before-next-token}</end>
          <include>
            <context ref="js:embedded-lang-hooks"/>
            <context ref="js:comments"/>

            <context id="_optional-chain-content">
              <include>
                <!-- only match dot-property accessor content here
                     this context will end early for other cases
                -->
                <context ref="js-val:properties-methods"/>
                <context ref="js:identifier-name"/>
              </include>
            </context> <!-- /_optional-chain-content -->

          </include>
        </context> <!-- /_optional-chain -->

        <context ref="_function-arguments-lists"/>
        <context ref="js-lit:template-literals"/>
      </include>
    </context> <!-- /_post-primary-expression -->

    <context id="_ordered-post-primary-expression" once-only="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="_post-primary-expression"/>
      </include>
    </context> <!-- /_ordered-post-primary-expression -->


    <!-- # Increment / decrement operators -->

    <!-- shared between pre- and post-lhs expressions -->
    <context id="_increment-decrement-operators" style-ref="js:increment-decrement-operator">
      <match>(\+\+|--)</match>
    </context> <!-- /_increment-decrement-operators -->


    <!-- # Pre-LHS expression -->

    <context id="_pre-lhs-expression">
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="_increment-decrement-operators"/>

        <context id="_keyword-unary-operators" style-ref="js:keyword">
          <keyword>await</keyword> <!-- ES2017 -->
          <keyword>delete</keyword>
          <keyword>typeof</keyword>
          <keyword>void</keyword>
          <keyword>yield</keyword>
        </context> <!-- /_keyword-unary-operators -->

        <context ref="js:generator-modifier"/> <!-- for yield* -->

        <context id="_unary-operators" style-ref="js:unary-operator">
          <match extended="true">
            (
              \+ |  # unary plus
              - |   # unary negation
              ~ |   # bitwise not
              !     # logical not
            )
          </match>
        </context> <!-- /_unary-operators -->

      </include>
    </context> <!-- /_pre-lhs-expression -->

    <context id="_ordered-pre-lhs-expression" once-only="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="_pre-lhs-expression"/>
      </include>
    </context> <!-- /_ordered-pre-lhs-expression -->


    <!-- # Left-hand side expression

         this
         new Array
         'string'.length
         fn.apply()
         list[1]
         tag`template`
    -->

    <define-regex id="_expression-start" extended="true">
      (?= \%{js:not-whitespace} )
      (?= [^:;\])}] )
      (?! /[/*] )
    </define-regex> <!-- /_expression-start -->

    <!-- <LeftHandSideExpression> -->
    <context id="lhs-expression" style-ref="js:expression" once-only="true">
      <start>\%{_expression-start}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_lhs-expression-content">
          <include>
            <context ref="_ordered-pre-primary-expression"/>
            <context ref="_ordered-primary-expression"/>
            <context ref="_ordered-post-primary-expression"/>
          </include>
        </context> <!-- /_lhs-expression-content -->

      </include>
    </context> <!-- /lhs-expression -->


    <!-- # Ternary operator -->

    <context id="_choice-ternary-operator-missing-true-expression" end-parent="true">
      <start>(?=:)</start>
      <end>\%{def:always-match}</end>
    </context> <!-- /_choice-ternary-operator-missing-true-expression -->

    <!-- ## Without comma -->

    <context id="_ternary-operator-without-comma-false-clause" once-only="true">
      <start>:</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:ternary-operator"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_ternary-operator-without-comma-false-clause-content">
          <include>
            <context ref="expression-without-comma"/>
          </include>
        </context> <!-- /_ternary-operator-without-comma-false-clause-content -->

      </include>
    </context> <!-- /_ternary-operator-without-comma-false-clause -->

    <context id="_choice-ternary-operator-without-comma-true-expression" end-parent="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_ternary-operator-without-comma-true-expression-content">
          <include>
            <context ref="expression-without-comma"/>
            <context ref="_ternary-operator-without-comma-false-clause"/>
          </include>
        </context> <!-- /_ternary-operator-without-comma-true-expression-content -->

      </include>
    </context> <!-- /_choice-ternary-operator-without-comma-true-expression -->

    <context id="_ternary-operators-without-comma">
      <start>\?</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:ternary-operator"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_ternary-operator-without-comma-content">
          <include>
            <context ref="_choice-ternary-operator-missing-true-expression"/>
            <context ref="_choice-ternary-operator-without-comma-true-expression"/>
          </include>
        </context> <!-- /_ternary-operator-without-comma-content -->

      </include>
    </context> <!-- /_ternary-operators-without-comma -->

    <!-- ## With comma -->

    <context id="_ternary-operator-with-comma-false-clause" once-only="true">
      <start>:</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:ternary-operator"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_ternary-operator-with-comma-false-clause-content">
          <include>
            <context ref="expression-with-comma"/>
          </include>
        </context> <!-- /_ternary-operator-with-comma-false-clause-content -->

      </include>
    </context> <!-- /_ternary-operator-with-comma-false-clause -->

    <context id="_choice-ternary-operator-with-comma-true-expression" end-parent="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_ternary-operator-with-comma-true-expression-content">
          <include>
            <context ref="expression-with-comma"/>
            <context ref="_ternary-operator-with-comma-false-clause"/>
          </include>
        </context> <!-- /_ternary-operator-with-comma-true-expression-content -->

      </include>
    </context> <!-- /_choice-ternary-operator-with-comma-true-expression -->

    <context id="_ternary-operators-with-comma">
      <start>\?</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:ternary-operator"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_ternary-operator-with-comma-content">
          <include>
            <context ref="_choice-ternary-operator-missing-true-expression"/>
            <context ref="_choice-ternary-operator-with-comma-true-expression"/>
          </include>
        </context> <!-- /_ternary-operator-with-comma-content -->

      </include>
    </context> <!-- /_ternary-operators-with-comma -->


    <!-- # Binary operators -->

    <define-regex id="_keyword-binary-operator" extended="true">
      (?: \%[ (?: instanceof | in ) \%] )
    </define-regex> <!-- /_keyword-binary-operator -->

    <!-- excluding comma operator -->
    <define-regex id="_binary-operator" extended="true">
      (?:
        \*\* =? |                            # exponentiation (assignment) (ES2016)
        [+/*%-] =? |                         # arithmetic (assignment)
        [!=]==? |                            # equality
        &amp;&amp; | \|\| |                  # logical
        \?\? |                               # nullish coalescing (ES2020)
        [&amp;|^] =? |                       # bitwise logical (assignment)
        (?: &lt;&lt; | &gt;&gt;&gt;? ) =? |  # bitwise shift (assignment)
        [&lt;&gt;]=? |                       # relational
        =                                    # assignment
      )
    </define-regex> <!-- /_binary-operator -->

    <!-- ## Without comma -->

    <context id="_keyword-binary-operators-without-comma">
      <start>\%{_keyword-binary-operator}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:keyword"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_keyword-binary-operator-without-comma-content">
          <include>
            <context ref="expression-without-comma"/>
          </include>
        </context> <!-- /_keyword-binary-operator-without-comma-content -->

      </include>
    </context> <!-- /_keyword-binary-operators-without-comma -->

    <context id="_binary-operators-without-comma">
      <start>\%{_binary-operator}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:binary-operator"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_binary-operator-without-comma-content">
          <include>
            <context ref="expression-without-comma"/>
          </include>
        </context> <!-- /_binary-operator-without-comma-content -->

      </include>
    </context> <!-- /_binary-operators-without-comma -->

    <!-- ## With comma -->

    <context id="_keyword-binary-operators-with-comma">
      <start>\%{_keyword-binary-operator}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:keyword"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_keyword-binary-operator-with-comma-content">
          <include>
            <context ref="expression-with-comma"/>
          </include>
        </context> <!-- /_keyword-binary-operator-with-comma-content -->

      </include>
    </context> <!-- /_keyword-binary-operators-with-comma -->

    <context id="_binary-operators-with-comma">
      <start>(\%{_binary-operator}|,)</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context sub-pattern="0" where="start" style-ref="js:binary-operator"/>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>

        <context id="_binary-operator-with-comma-content">
          <include>
            <context ref="expression-with-comma"/>
          </include>
        </context> <!-- /_binary-operator-with-comma-content -->
      </include>
    </context> <!-- /_binary-operators-with-comma -->


    <!-- # Post-LHS expression -->

    <!-- ## Without comma -->

    <context id="_post-lhs-expression-without-comma">
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="_increment-decrement-operators"/>
        <context ref="js-fn:arrow-functions"/>
        <context ref="_keyword-binary-operators-without-comma"/>
        <context ref="_binary-operators-without-comma"/>
        <context ref="_ternary-operators-without-comma"/>
      </include>
    </context> <!-- /_post-lhs-expression-without-comma -->

    <context id="_ordered-post-lhs-expression-without-comma" once-only="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="_post-lhs-expression-without-comma"/>
      </include>
    </context> <!-- /_ordered-post-lhs-expression-without-comma -->

    <!-- ## With comma -->

    <context id="_post-lhs-expression-with-comma">
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="_increment-decrement-operators"/>
        <context ref="js-fn:arrow-functions"/>
        <context ref="_keyword-binary-operators-with-comma"/>
        <context ref="_binary-operators-with-comma"/>
        <context ref="_ternary-operators-with-comma"/>
      </include>
    </context> <!-- /_post-lhs-expression-with-comma -->

    <context id="_ordered-post-lhs-expression-with-comma" once-only="true">
      <start>\%{js:before-next-token}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="_post-lhs-expression-with-comma"/>
      </include>
    </context> <!-- /_ordered-post-lhs-expression-with-comma -->


    <!-- # Expression

         2 + 3 - 1
         true ? doThis() : doThat()
    -->

    <!-- ## Without comma -->

    <context id="_expression-without-comma-content">
      <include>
        <context ref="_ordered-pre-lhs-expression"/>
        <context ref="_lhs-expression-content"/>
        <context ref="_ordered-post-lhs-expression-without-comma"/>
      </include>
    </context> <!-- /_expression-without-comma-content -->

    <!-- <AssignmentExpression> -->
    <context id="expression-without-comma" style-ref="js:expression" once-only="true">
      <start>\%{_expression-start}(?!,)</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>
        <context ref="_expression-without-comma-content"/>
      </include>
    </context> <!-- /expression-without-comma -->

    <!-- <AssignmentExpression> -->
    <context id="choice-expression-without-comma" style-ref="js:expression" end-parent="true">
      <start>\%{_expression-start}(?!,)</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>
        <context ref="_expression-without-comma-content"/>
      </include>
    </context> <!-- /choice-expression-without-comma -->

    <!-- ## With comma -->

    <context id="_expression-with-comma-content">
      <include>
        <context ref="_ordered-pre-lhs-expression"/>
        <context ref="_lhs-expression-content"/>
        <context ref="_ordered-post-lhs-expression-with-comma"/>
      </include>
    </context> <!-- /_expression-with-comma-content -->

    <!-- <Expression> -->
    <context id="expression-with-comma" style-ref="js:expression" once-only="true">
      <start>\%{_expression-start}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>
        <context ref="_expression-with-comma-content"/>
      </include>
    </context> <!-- /expression-with-comma -->

    <!-- <Expression> -->
    <context id="choice-expression-with-comma" style-ref="js:expression" end-parent="true">
      <start>\%{_expression-start}</start>
      <end>\%{js:before-next-token}</end>
      <include>
        <context ref="js:embedded-lang-hooks"/>
        <context ref="js:comments"/>
        <context ref="_expression-with-comma-content"/>
      </include>
    </context> <!-- /choice-expression-with-comma -->

  </definitions>
</language>