%YAML 1.2

---

# Derived from JavaScript Next: https://github.com/Benvie/JavaScriptNext.tmLanguage

name: JavaScript

scope: source.js

version: 2

file_extensions:

- js

- mjs

- cjs

- htc

first_line_match: |-

(?xi:

^ \#! .* \b(?:node|js|bun|osascript\s+-l\s+JavaScript)\b # shebang

| ^ \s* // .*? -\*- .*? \b(?:js|javascript)\b .*? -\*- # editorconfig

)

variables:

shebang_lang: \b(?:node|js|bun|osascript\s+-l\s+JavaScript)\b

bin_digit: '[01_]'

oct_digit: '[0-7_]'

dec_digit: '[0-9_]'

hex_digit: '[\h_]'

dec_integer: (?:0|[1-9]{{dec_digit}}*)

dec_exponent: '[Ee](?:[-+]|(?![-+])){{dec_digit}}*'

identifier_escape: (?:\\u(?:\h{4}|\{\h+\}))

identifier_start: (?:[_$\p{L}\p{Nl}]|{{identifier_escape}})

identifier_part: (?:[_$\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}\x{200C}\x{200D}]|{{identifier_escape}})

identifier_break: (?!{{identifier_part}})

identifier_name: (?:{{identifier_start}}{{identifier_part}}*{{identifier_break}})

constant_identifier: (?:[[:upper:]]{{identifier_part}}*{{identifier_break}})

dollar_only_identifier: (?:\${{identifier_break}})

dollar_identifier: '(?:(\$){{identifier_part}}*{{identifier_break}})'

block_comment_contents: (?:(?:[^*]|\*(?!/))*)

block_comment: (?:/\*{{block_comment_contents}}\*/)

nothing: (?:(?:\s|{{block_comment}})*)

line_ending_ahead: (?={{nothing}}(?:/\*{{block_comment_contents}}|//.*)?$)

# https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar

reserved_word: |-

(?x:

# standard mode

break

| case

| catch

| class

| const

| continue

| debugger

| default

| delete

| do

| else

| export

| extends

| false

| finally

| for

| function

| if

| import

| in

| instanceof

| new

| null

| return

| super

| switch

| this

| throw

| true

| try

| typeof

| var

| void

| while

| with

# strict mode

# | let # currently allowed as variable

| static

| yield

# async code

| await

# future reserved words

| enum

| implements

| interface

| package

| private

| protected

| public

){{identifier_break}}

non_reserved_identifier: (?:(?!{{reserved_word}}){{identifier_name}})

possible_arrow_function_begin: (?:\(|{{identifier_start}})

either_func_lookahead: (?:{{func_lookahead}}|{{arrow_func_lookahead}})

binding_pattern_lookahead: (?:{{identifier_name}}|\[|\{)

left_expression_end_lookahead: (?!\s*[.\[\(])

dot_accessor: (?:\??\.)

property_name: >-

(?x:

{{identifier_name}}

| [0-9]+

| '(?:[^\\']|\\.)*'

| "(?:[^\\"]|\\.)*"

| \[ .* \]

)

class_element_name: |-

(?x:

{{property_name}}

| \#{{identifier_name}}

)

modifier: (?:(?:static|accessor){{identifier_break}})

# Newline not permitted between `async` and `function`.

func_lookahead: |-

(?x:

(?:async{{identifier_break}}{{nothing}})?

function{{identifier_break}}

)

arrow_func_lookahead: |-

(?x:

(?:async\s*)?

(?:

{{identifier_name}}

| \( ( [^()] | \( [^()]* \) )* \)

)

\s*

=>

)

function_call_after_lookahead: (?=\s*(?:\?\.\s*)?\()

function_assignment_lookahead: |-

(?x:(?=

\s* = \s*

{{either_func_lookahead}}

))

# '@' followed by a pattern like \S but excluding literal '*' and '@'.

jsdoc_block_tag: \@[^\n\t\f\v *@]+

leading_wspace: (?:^\s*)

trailing_wspace: (?:\s*$\n?)

tagged_template_quote_begin: \`

tagged_template_quote_end: \`

tagged_template_quote_escape: '{{no_escape_behind}}{{tagged_template_quote_end}}'

no_escape_behind: (?<![^\\]\\)(?<![\\]{3})

contexts:

main:

- meta_include_prototype: false # don't match comments before shebang

- match: ''

push: [script, shebang]

script:

- match: '\)|\}|\]'

scope: invalid.illegal.stray-bracket-end.js

# Don't pop or embedding could break.

- include: statements

prototype:

- include: comments

comments:

- include: line-comments

- include: block-comments

block-comments:

# empty block comments

- match: /\*\*+/

scope: comment.block.empty.js punctuation.definition.comment.js

# documentation block comments

- match: /\*\*+

scope: punctuation.definition.comment.begin.js

push:

- jsdoc-comment-body

- jsdoc-block-tag

# normal block comments

- match: /\*

scope: punctuation.definition.comment.begin.js

push: block-comment-body

block-comment-end:

- match: \*+/

scope: punctuation.definition.comment.end.js

pop: 1

block-comment-body:

- meta_include_prototype: false

- meta_scope: comment.block.js

- include: block-comment-end

- match: ^\s*(\*)(?!/)

captures:

1: punctuation.definition.comment.js

jsdoc-comment-body:

- meta_include_prototype: false

- meta_scope: comment.block.documentation.js

- include: block-comment-end

# JSDoc "block" tags (i.e. @param) are only accepted at the beginning of the documentation

# line so directly after the '/**' or after the '*' marker on the next lines.

- match: ^\s*(\*)(?!/)

captures:

1: punctuation.definition.comment.js

push: jsdoc-block-tag

jsdoc-block-tag:

- match: '{{jsdoc_block_tag}}'

scope: entity.other.attribute-name.documentation.js

pop: 1

- match: (?=\S)|$

pop: 1

line-comments:

- match: /{4,}

scope: punctuation.definition.comment.js

push: line-comment-other-body

- match: /{3}

scope: punctuation.definition.comment.js

push: line-comment-triple-slash-body

- match: /{2}

scope: punctuation.definition.comment.js

push: line-comment-double-slash-body

line-comment-end:

- match: (//+)?\n

captures:

1: punctuation.definition.comment.js

pop: 1

line-comment-double-slash-body:

- meta_include_prototype: false

- meta_scope: comment.line.double-slash.js

- include: line-comment-end

line-comment-triple-slash-body:

- meta_include_prototype: false

- meta_scope: comment.line.triple-slash.js

- include: line-comment-end

line-comment-other-body:

- meta_include_prototype: false

- meta_scope: comment.line.other.js

- include: line-comment-end

shebang:

- meta_include_prototype: false

- match: ^\#!

scope: punctuation.definition.comment.js

set: shebang-body

- match: ^|(?=\S) # Note: Ensure to highlight shebang if the syntax is embedded.

pop: 1

shebang-body:

- meta_include_prototype: false

- meta_scope: comment.line.shebang.js

# Note: Keep sync with first_line_match!

- match: '{{shebang_lang}}'

scope: constant.language.shebang.js

- match: \n

pop: 1

else-pop:

- match: (?=\S)

pop: 1

else-pop-2:

- match: (?=\S)

pop: 2

immediately-pop:

- meta_include_prototype: false

- match: ''

pop: 1

immediately-pop-2:

- meta_include_prototype: false

- match: ''

pop: 2

comma-separator:

- match: ','

scope: punctuation.separator.comma.js

import-statement-or-import-meta:

- match: (?=import{{identifier_break}})

branch_point: import-statement

branch:

- import-statement

- expression-statement

import-statement:

- match: import{{identifier_break}}

scope: keyword.control.import-export.js

set:

- import-meta

- expect-semicolon

- import-export-assert

- import-string-or-items

- import-check-branch

import-check-branch:

- match: (?=[.(]) # Recovery for import expressions

fail: import-statement

- include: else-pop

import-meta:

- meta_include_prototype: false

- meta_scope: meta.import.js

- include: immediately-pop

import-export-alias:

- match: as{{identifier_break}}

scope: keyword.control.import-export.js

set: import-export-name

- include: else-pop

import-export-name:

- match: default{{identifier_break}}

scope: keyword.control.import-export.js

pop: 1

- match: '{{identifier_name}}'

scope: variable.other.readwrite.js

pop: 1

- include: literal-string

- include: else-pop

import-export-from:

- match: 'from{{identifier_break}}'

scope: keyword.control.import-export.js

set: import-export-from-name

- include: else-pop

import-export-from-name:

- include: literal-string

- include: else-pop

import-string-or-items:

- include: literal-string

- match: (?=\S)

set:

- import-export-from

- import-list

- import-export-item

import-list:

- match: ','

scope: punctuation.separator.comma.js

push: import-export-item

- include: else-pop

import-export-item:

- match: '\{'

scope: punctuation.section.block.begin.js

set: import-export-brace

- match: '{{non_reserved_identifier}}'

scope: variable.other.readwrite.js

pop: 1

- match: '\*'

scope: constant.other.wildcard.asterisk.js

set: import-export-alias

- include: else-pop

import-export-brace:

- meta_scope: meta.block.js

- include: comma-separator

- match: '\}'

scope: punctuation.section.block.end.js

pop: 1

- match: (?={{identifier_start}}|'|")

push:

- import-export-alias

- import-export-name

- match: '\*'

scope: constant.other.wildcard.asterisk.js

push: import-export-alias

- include: else-pop

import-export-assert:

- match: (?:assert|with){{identifier_break}}

scope: keyword.control.import-export.js

set: import-export-object

- include: else-pop

import-export-object:

- include: object-literal

- include: else-pop

export-statement:

- match: export{{identifier_break}}

scope: keyword.control.import-export.js

set:

- export-meta

- export-body

export-meta:

- meta_include_prototype: false

- meta_scope: meta.export.js

- include: immediately-pop

export-body:

- include: declaration

- match: default{{identifier_break}}

scope: keyword.control.import-export.js

set: export-default

- match: (?=\S)

set:

- expect-semicolon

- import-export-assert

- import-export-from

- import-export-item

export-default:

- include: declaration

- include: expression-statement

statements:

- match: '\)|\}|\]'

scope: invalid.illegal.stray-bracket-end.js

pop: 1

- match: (?=\S)

push: statement

statement:

- match: \;

scope: punctuation.terminator.statement.empty.js

pop: 1

- include: declaration

- include: import-statement-or-import-meta

- include: export-statement

- include: conditional

- include: block

- include: label

- match: break{{identifier_break}}

scope: keyword.control.flow.break.js

set:

- expect-semicolon

- expect-label

- match: continue{{identifier_break}}

scope: keyword.control.flow.continue.js

set:

- expect-semicolon

- expect-label

- match: debugger{{identifier_break}}

scope: keyword.control.flow.debugger.js

set: expect-semicolon

- match: return{{identifier_break}}

scope: keyword.control.flow.return.js

set: restricted-production

- match: throw{{identifier_break}}

scope: keyword.control.flow.throw.js

set: restricted-production

- include: decorator

- include: expression-statement

declaration:

- include: variable-declaration

- include: using-declaration

- include: class

- include: regular-function

expect-semicolon:

- match: \;

scope: punctuation.terminator.statement.js

pop: 1

- include: else-pop

expect-label:

- meta_include_prototype: false

- match: '(?={{nothing}}{{identifier_name}})'

set:

- match: '{{non_reserved_identifier}}'

scope: variable.label.js

pop: 1

- match: '{{identifier_name}}'

scope: invalid.illegal.identifier.js variable.label.js

pop: 1

- include: else-pop

- include: immediately-pop

block:

- match: '\{'

scope: punctuation.section.block.begin.js

set:

- meta_scope: meta.block.js

- match: '\}'

scope: punctuation.section.block.end.js

pop: 1

- include: statements

variable-binding-pattern:

- include: variable-binding-name

- include: variable-binding-array-destructuring

- include: variable-binding-object-destructuring

- include: else-pop

variable-binding-name:

- match: (?={{non_reserved_identifier}})

set:

- - meta_scope: meta.binding.name.js

- include: immediately-pop

- literal-variable

variable-binding-array-destructuring:

- match: '\['

scope: punctuation.section.sequence.begin.js

set:

- meta_scope: meta.binding.destructuring.sequence.js

- match: '\]'

scope: punctuation.section.sequence.end.js

pop: 1

- include: variable-binding-spread

- include: variable-binding-list

variable-binding-object-destructuring:

- match: '\{'

scope: punctuation.section.mapping.begin.js

set:

- meta_scope: meta.binding.destructuring.mapping.js

- match: '\}'

scope: punctuation.section.mapping.end.js

pop: 1

- include: variable-binding-spread

- match: (?={{identifier_start}}|\[|'|")

push:

- initializer

- variable-binding-object-alias

- object-literal-meta-key

- variable-binding-object-key

- include: comma-separator

variable-binding-object-alias:

- match: ':'

scope: punctuation.separator.key-value.js

set: variable-binding-pattern

- include: else-pop

variable-binding-object-key:

- match: '{{identifier_name}}(?=\s*:)'

pop: 1

- include: literal-string

- include: computed-property-name

- include: variable-binding-name

- include: else-pop

variable-binding-spread:

- match: '\.\.\.'

scope: keyword.operator.spread.js

push: variable-binding-pattern

variable-binding-list:

- include: comma-separator

- match: (?={{binding_pattern_lookahead}})

push:

- initializer

- variable-binding-pattern

- include: else-pop

variable-binding-top:

- match: (?={{binding_pattern_lookahead}})

set:

- initializer

- variable-binding-pattern

- include: else-pop

variable-binding-list-top:

- match: ','

scope: punctuation.separator.comma.js

push: variable-binding-top

- include: else-pop

variable-declaration:

- match: (?:const|let|var){{identifier_break}}

scope: keyword.declaration.js

set:

- expect-semicolon

- variable-binding-list-top

- variable-binding-top

using-declaration:

- include: plain-using-declaration

- match: (?=await{{identifier_break}})

branch_point: await-using-declaration

branch:

- await-using-declaration

- expression-statement

pop: 1

plain-using-declaration:

- match: using{{identifier_break}}(?={{nothing}}{{non_reserved_identifier}})

scope: keyword.declaration.js

set:

- expect-semicolon

- variable-binding-list-top

- variable-binding-top

await-using-declaration:

- match: await{{identifier_break}}

scope: keyword.declaration.js

set:

- include: using-declaration

- match: (?=\S)

fail: await-using-declaration

function-parameter-binding-pattern:

- include: function-parameter-binding-name

- include: function-parameter-binding-array-destructuring

- include: function-parameter-binding-object-destructuring

- include: else-pop

function-parameter-binding-name:

- match: '{{dollar_identifier}}'

scope: meta.binding.name.js variable.parameter.function.js

captures:

1: punctuation.dollar.js

- match: '{{non_reserved_identifier}}'

scope: meta.binding.name.js variable.parameter.function.js

- match: '{{identifier_name}}'

scope: invalid.illegal.identifier.js meta.binding.name.js variable.parameter.function.js

function-parameter-binding-array-destructuring:

- match: '\['

scope: punctuation.section.sequence.begin.js

set:

- meta_scope: meta.binding.destructuring.sequence.js

- match: '\]'

scope: punctuation.section.sequence.end.js

pop: 1

- include: function-parameter-binding-list

function-parameter-binding-object-destructuring:

- match: '\{'

scope: punctuation.section.mapping.begin.js

set:

- meta_scope: meta.binding.destructuring.mapping.js

- match: ','

scope: punctuation.separator.parameter.function.js

- match: '\}'

scope: punctuation.section.mapping.end.js

pop: 1

- include: function-parameter-binding-spread

- match: (?={{identifier_start}}|\[|'|")

push:

- initializer

- function-parameter-binding-object-alias

- object-literal-meta-key

- function-parameter-binding-object-key

function-parameter-binding-object-alias:

- match: ':'

scope: punctuation.separator.key-value.js

set: function-parameter-binding-pattern

- include: else-pop

function-parameter-binding-object-key:

- match: '{{identifier_name}}(?=\s*:)'

pop: 1

- include: literal-string

- include: computed-property-name

- include: function-parameter-binding-name

- include: else-pop

function-parameter-binding-spread:

- match: '\.\.\.'

scope: keyword.operator.spread.js

push: function-parameter

function-parameter-binding-list:

- match: ','

scope: punctuation.separator.parameter.function.js

- include: function-parameter-binding-spread

- match: (?={{binding_pattern_lookahead}})

push: function-parameter

- include: else-pop

function-parameter:

- match: ''

set:

- initializer

- function-parameter-binding-pattern

initializer:

- match: '='

scope: keyword.operator.assignment.js

set: expression-no-comma

- include: else-pop

expression-statement:

- match: (?=\S)

set:

- expect-semicolon

- expression-statement-end

- expression-begin

expression-statement-end:

- match: '{{line_ending_ahead}}'

branch_point: expression-statement-continuation

branch:

- expression-statement-continuation

- expression-statement-pop

- include: expression-end

expression-statement-continuation:

- match: (?=\+\+|--)

fail: expression-statement-continuation

- match: |-

(?x)

(?=

!=

| [-+*/%><=&|^\[(;,.:?]

| (?:in|instanceof){{identifier_break}}

)

pop: 1

- match: (?=\S)

fail: expression-statement-continuation

expression-statement-pop:

# Consume only comments (ignore patterns from inheriting syntaxes) and

# pop `expression-statement-end` at the same text point the previous branch

# fails at in order to prevent ST's syntax engine to lock up.

# see: https://github.com/sublimehq/sublime_text/issues/5853

- meta_include_prototype: false

- include: comments

- include: else-pop-2

restricted-production:

- meta_include_prototype: false

- match: '{{line_ending_ahead}}'

pop: 1

- match: ''

set: expression-statement

expect-case-colon:

- match: ':'

scope: punctuation.separator.js

pop: 1

- include: else-pop

conditional:

- match: switch{{identifier_break}}

scope: keyword.control.conditional.switch.js

set:

- switch-meta

- switch-block

- expect-parenthesized-expression

- match: do{{identifier_break}}

scope: keyword.control.loop.do-while.js

set:

- do-while-meta

- do-while-condition

- statement

- match: for{{identifier_break}}

scope: keyword.control.loop.for.js

set:

- for-meta

- block-scope

- for-condition

- for-await

- match: while{{identifier_break}}

scope: keyword.control.loop.while.js

set:

- while-meta

- block-scope

- expect-parenthesized-expression

- match: with{{identifier_break}}

scope: keyword.control.import.with.js

set:

- with-meta

- block-scope

- expect-parenthesized-expression

- match: if{{identifier_break}}

scope: keyword.control.conditional.if.js

set:

- conditional-meta

- statement

- expect-parenthesized-expression

- match: else\s+if{{identifier_break}}

scope: keyword.control.conditional.elseif.js

set:

- conditional-meta

- statement

- expect-parenthesized-expression

- match: else{{identifier_break}}

scope: keyword.control.conditional.else.js

set:

- conditional-meta

- statement

- match: try{{identifier_break}}

scope: keyword.control.exception.try.js

set:

- try-meta

- block-scope

- match: finally{{identifier_break}}

scope: keyword.control.exception.finally.js

set:

- finally-meta

- block-scope

- match: catch{{identifier_break}}

scope: keyword.control.exception.catch.js

set:

- catch-meta

- block-scope

- catch-binding

expect-parenthesized-expression:

- include: parenthesized-expression

- include: else-pop

switch-meta:

- meta_include_prototype: false

- meta_scope: meta.switch.js

- include: immediately-pop

do-while-meta:

- meta_include_prototype: false

- meta_scope: meta.do-while.js

- include: immediately-pop

for-meta:

- meta_include_prototype: false

- meta_scope: meta.for.js

- include: immediately-pop

while-meta:

- meta_include_prototype: false

- meta_scope: meta.while.js

- include: immediately-pop

with-meta:

- meta_include_prototype: false

- meta_scope: meta.with.js

- include: immediately-pop

conditional-meta:

- meta_include_prototype: false

- meta_scope: meta.conditional.js

- include: immediately-pop

try-meta:

- meta_include_prototype: false

- meta_scope: meta.try.js

- include: immediately-pop

finally-meta:

- meta_include_prototype: false

- meta_scope: meta.finally.js

- include: immediately-pop

catch-meta:

- meta_include_prototype: false

- meta_scope: meta.catch.js

- include: immediately-pop

for-await:

- match: await{{identifier_break}}

scope: keyword.control.flow.await.js

pop: 1

- include: else-pop

for-condition:

- match: \(

scope: punctuation.section.group.begin.js

branch_point: for-in-of

branch:

- for-in-of

- for-oldstyle

pop: 1

- include: else-pop

for-condition-end:

- meta_scope: meta.group.js

- match: \)

scope: punctuation.section.group.end.js

pop: 1

- match: ;

scope: invalid.illegal.unexpected-token.js

- include: expressions

for-in-of:

- meta_include_prototype: false

- meta_scope: meta.group.js

- match: ''

set:

- for-condition-end

- for-in-of-word

- for-in-of-declaration

for-in-of-declaration:

- match: (?:const|let|var){{identifier_break}}

scope: keyword.declaration.js

set: for-in-of-binding

- match: |-

(?x:

(?! # [lookahead ≠ using of]

using{{identifier_break}}{{nothing}}

of{{identifier_break}}

)

(?= # await [no LineTerminator here] using [no LineTerminator here] ForBinding

(?:await{{identifier_break}}{{nothing}})?

using{{identifier_break}}{{nothing}}

{{non_reserved_identifier}}

)

)

scope: keyword.declaration.js

set:

- match: await{{identifier_break}}

scope: keyword.declaration.js

- match: using{{identifier_break}}

scope: keyword.declaration.js

set: for-in-of-binding

- match: (?=\S)

set:

- left-expression-end

- expression-begin

for-in-of-binding:

- include: variable-binding-name

- include: variable-binding-array-destructuring

- include: variable-binding-object-destructuring

- match: (?=\S)

fail: for-in-of

for-in-of-word:

- match: (?:of|in){{identifier_break}}

scope: keyword.operator.word.js

pop: 1

- match: (?=\S)

fail: for-in-of

for-oldstyle:

- meta_include_prototype: false

- meta_scope: meta.group.js

- match: ''

set:

- for-condition-end

- for-oldstyle-separator

- expression

- for-oldstyle-separator

- for-oldstyle-declaration

for-oldstyle-declaration:

- match: (?:const|let|var){{identifier_break}}

scope: keyword.declaration.js

set:

- variable-binding-list-top

- variable-binding-top

- include: expression

for-oldstyle-separator:

- match: ;

scope: punctuation.separator.expression.js

pop: 1

- include: else-pop

block-scope:

- include: block

- include: else-pop

block-meta:

- meta_include_prototype: false

- meta_scope: meta.block.js