JavaScriptNext.YAML-tmLanguage

# [PackageDev] target_format: plist, ext: tmLanguage
name: JavaScript Next
scopeName: source.js
fileTypes: [js, htc, jsx]
uuid: 487CF323-A3F9-48FA-B140-DCE8C893E664
firstLineMatch: ^#!/.*\b(node|js)
keyEquivalent: ^~J

patterns:
- include: '#comments'
- include: '#support'
- include: '#core'
- include: '#special'

repository:
 brackets:
 patterns:
 - name: meta.function-call.method.with-arguments.js
 match: >-
 (?x)
 (?<=\.)
 ([_$a-zA-Z][_$\w]*)?
 (?=\()
 captures:
 '1': {name: entity.name.function.js}

 - name: meta.group.braces.round
 begin: (\()
 beginCaptures:
 '1': {name: meta.brace.round.js}
 end: (\))
 endCaptures:
 '1': {name: meta.brace.round.js}
 patterns:
 - include: source.js

 - name: meta.group.braces.square
 begin: (\[)
 beginCaptures:
 '1': {name: meta.brace.square.js}
 end: (\])
 endCaptures:
 '1': {name: meta.brace.square.js}
 patterns:
 - include: source.js

 comments:
 patterns:
 - include: '#special-comments-conditional-compilation'

 - name: comment.block.documentation.js
 begin: /\*\*(?!/)
 end: \*/
 captures:
 '0': {name: punctuation.definition.comment.js}

 - name: comment.block.js
 begin: /\*
 end: \*/
 captures:
 '0': {name: punctuation.definition.comment.js}

 - name: comment.line.double-slash.js
 match: (//).*$\n?
 captures:
 '1': {name: punctuation.definition.comment.js}

 - name: comment.block.html.js
 match: (<!--|-->)
 captures:
 '0': {name: punctuation.definition.comment.html.js}
 '2': {name: punctuation.definition.comment.html.js}

 function-declaration-parameters:
 patterns:
 - begin: (\()
 beginCaptures:
 '1': {name: punctuation.definition.parameters.begin.js}
 end: (\))
 endCaptures:
 '1': {name: punctuation.definition.parameters.end.js}
 patterns:
 - name: variable.parameter.function.js
 match: |-
 (?x)
 [_$a-zA-Z][_$\w]*
 - name: punctuation.separator.parameter.function.js
 match: ','
 - include: '#comments'

 core:
 patterns:
 - include: '#leading-space'

 # literals
 - include: '#literal-regex' # before operators to avoid ambiguities
 - include: '#literal-number'
 - include: '#literal-quasi'
 - include: '#literal-language-constant'

 # keywords/operators
 - include: '#literal-keywords'

 # modules/classes/functions
 - include: '#literal-class'
 - include: '#literal-module'
 - include: '#literal-arrow-function'
 - include: '#literal-function-storage'
 - include: '#literal-method' # before function calls & after function declarations, to differentiate methods from them
 - include: '#literal-prototype-storage' # after literal-function-storage, which includes some prototype strings

 # after literal-function-storage which requires the below in some cases
 - include: '#literal-string'
 - include: '#literal-language-variable'

 # function calls
 - include: '#literal-function-call'

 # punctuation
 - include: '#literal-labels'
 - include: '#literal-variable'
 - include: '#literal-punctuation'

 # brackets
 - include: '#brackets'

 literal-module:
 patterns:
 # module names are defined using strings
 - name: storage.type.module.js
 match: \b(module)\b

 - name: keyword.operator.module.js
 match: \b(import|export|from|as)\b

 literal-class:
 patterns:
 # e.g. class MyClass { }
 - name: meta.class.js
 match: \b(class)\b(?:\s+([_$a-zA-Z][_$\w]*)\s*(?:\b(extends)\b\s*([_$a-zA-Z][_$\w]*))?)?\s*
 captures:
 '1': {name: storage.type.class.js}
 '2': {name: entity.name.class.js}
 '3': {name: storage.type.extends.js}
 '4': {name: entity.name.extends.js}

 # definitions here don't include field modifications (e.g. this.a = 'b'), as modifications can occur outside the class
 - match: \b(?:(public|private|static)\s+)(?:(var|let|const)\s+)?([_$a-zA-Z][_$\w]*\s*)(?=\=)
 captures:
 '1': {name: storage.modifier.js}
 '2': {name: storage.type.js}
 '3': {name: entity.name.field.js}

 - match: \b(private)(?=\s*\()
 captures:
 '1': {name: support.function.private.js}

 - name: storage.modifier.js
 match: \b(public|private|static)\b

 # getter/setter
 - name: meta.accessor.js
 begin: \b(get|set)\s*\b([_$a-zA-Z][_$\w]*)\s*
 beginCaptures:
 '1': {name: storage.type.accessor.js}
 '2': {name: entity.name.accessor.js}
 end: (?<=\))
 patterns:
 - include: '#function-declaration-parameters'

 literal-function-call:
 patterns:
 - name: meta.function-call.static.with-arguments.js
 begin: (?=[_$a-zA-Z][_$\w]*\s*\()
 end: (?=\()
 patterns:
 - name: entity.name.function.js
 match: ([_$a-zA-Z][_$\w]*)?

 literal-prototype-storage:
 patterns:
 # e.g. Sound.prototype = { } when extending an object
 - name: meta.prototype.declaration.js
 match: ([_$a-zA-Z][_$\w]*)\.(prototype)\s*=\s*
 captures:
 '1': {name: entity.name.class.js}
 '2': {name: support.constant.js}

 # e.g. Sound.prototype
 - name: meta.prototype.js
 match: ([_$a-zA-Z][_$\w]*)\.(prototype)
 captures:
 '1': {name: entity.name.class.js}
 '2': {name: support.constant.js}

 literal-function-storage:
 patterns:
 # e.g. function play(arg1, arg2) { }
 - name: meta.function.js
 begin: \b(function(?:\s*\*|(?=\s|[(])))(?:\s*([a-zA-Z_$][_$\w]*))?\s*
 beginCaptures:
 '1': {name: storage.type.function.js}
 '2': {name: entity.name.function.js}
 end: (?<=\))
 patterns:
 - include: '#function-declaration-parameters'

 # e.g. Sound.prototype.play = function(arg1, arg2) { }
 - name: meta.prototype.function.js
 begin: ([_$a-zA-Z][_$\w]*)\.(prototype)\.([_$a-zA-Z][_$\w]*)\s*=\s*(function(?:\s*\*|(?=\s|[(])))\s*
 beginCaptures:
 '1': {name: entity.name.class.js}
 '2': {name: support.constant.js}
 '3': {name: entity.name.function.js}
 '4': {name: storage.type.function.js}
 end: (?<=\))
 patterns:
 - include: '#function-declaration-parameters'

 # include symbol classes which not involve expressions
 # e.g. Sound.play = function(arg1, arg2) { }
 - name: meta.function.static.js
 begin: >-
 (?x)
 (?=
 ([_$a-zA-Z][_$\w]*)?
 \.([_$a-zA-Z][_$\w]*)\s*
 =\s*
 (function\s*\*?)\s*
 )
 end: (?<=\))
 patterns:
 - include: '#literal-language-variable'
 - begin: \b(function(?:\s*\*|(?=\s|[(])))(?:\s*([a-zA-Z_$][_$\w]*))?\s*
 beginCaptures:
 '1': {name: storage.type.function.js}
 '2': {name: entity.name.function.js}
 end: (?<=\))
 patterns:
 - include: '#function-declaration-parameters'

 # e.g. play: function(arg1, arg2) { }
 - name: meta.function.json.js
 begin: \b([_$a-zA-Z][_$\w]*)\s*(:)\s*\b(function(?:\s*\*|(?=\s|[(])))\s*
 beginCaptures:
 '1': {name: entity.name.function.js}
 '2': {name: punctuation.separator.key-value.js}
 '3': {name: storage.type.function.js}
 end: (?<=\))
 patterns:
 - include: '#function-declaration-parameters'

 # e.g. "play": function(arg1, arg2) { }
 - name: meta.function.json.js
 begin: |-
 (?x)
 (?:
 ((')(.*?)(?<!\\)('))|
 ((")(.*?)(?<!\\)("))
 )\s*
 (:)\s*
 \b(function(?:\s*\*|(?=\s|[(])))\s*
 beginCaptures:
 '1': {name: string.quoted.single.js}
 '2': {name: punctuation.definition.string.begin.js}
 '3': {name: entity.name.function.js}
 '4': {name: punctuation.definition.string.end.js}
 '5': {name: string.quoted.double.js}
 '6': {name: punctuation.definition.string.begin.js}
 '7': {name: entity.name.function.js}
 '8': {name: punctuation.definition.string.end.js}
 '9': {name: punctuation.separator.key-value.js}
 '10': {name: storage.type.function.js}
 end: (?<=\))
 patterns:
 - include: '#function-declaration-parameters'

 literal-arrow-function:
 patterns:
 # e.g. (args) => { }
 - name: meta.function.arrow.js
 begin: |-
 (?x)
 (?=\([^())]*\)\s*(=>))
 end: (?<=\))\s*(=>)
 endCaptures:
 '1': {name: storage.type.function.arrow.js}
 patterns:
 - include: '#function-declaration-parameters'

 literal-method:
 patterns:
 - name: meta.function-call.method.with-arguments.js
 match: |-
 (?x)
 (?<=\.)
 ([_$a-zA-Z][_$\w]*)
 (?=\()
 captures:
 '1': {name: entity.name.function.js}

 - name: meta.function-call.method.without-arguments.js
 match: |-
 (?x)
 (?<=\.)
 ([_$a-zA-Z][_$\w]*)
 (\(\s*\))
 captures:
 '1': {name: entity.name.function.js}
 '2': {name: meta.group.braces.round.function.arguments.js}
 '3': {name: meta.brace.round.js}

 # ES6 methods, e.g. play(arg1, arg2) { }
 - name: meta.method.js
 begin: |-
 (?x)
 (?<!function\s) # An approximation due to fixed width look-behind, but usually good enough
 \b([_$a-zA-Z][_$\w]*)
 \s*
 (?=\([^())]*\)\s*\{)
 beginCaptures:
 '1': {name: entity.name.method.js}
 end: (?<=\))
 patterns:
 - include: '#function-declaration-parameters'

 literal-language-variable:
 patterns:
 - name: variable.language.arguments.js
 match: (?<!\.)\b(arguments)\b

 - name: variable.language.super.js
 match: (?<!\.)\b(super)\b

 - name: variable.language.this.js
 match: (?<!\.)\b(this)\b

 - name: variable.language.self.js
 match: (?<!\.)\b(self)\b

 - name: variable.language.proto.js
 match: (?<=\.)\b(__proto__)\b

 - name: variable.language.constructor.js
 match: (?<=\.)\b(constructor)\b

 - name: variable.language.prototype.js
 match: (?<=\.)\b(prototype)\b

 literal-language-constant:
 patterns:
 - name: constant.language.boolean.true.js
 match: \btrue\b

 - name: constant.language.boolean.false.js
 match: \bfalse\b

 - name: constant.language.null.js
 match: \bnull\b

 - name: constant.language.undefined.js
 match: \bundefined\b

 - name: constant.language.nan.js
 match: \bNaN\b

 literal-keywords:
 patterns:
 - name: meta.instance.constructor
 begin: (new)\s+(?=[_$a-zA-Z][_$\w.]*)
 beginCaptures:
 '1': {name: keyword.operator.new.js}
 end: (?![_$a-zA-Z][_$\w.]*)
 patterns:
 - include: '#support'
 - match: ([_$a-zA-Z][_$\w.]*\.)?([_$a-zA-Z][_$\w]*)
 captures:
 '2': {name: entity.name.type.new.js}

 - name: storage.type.js
 match: \b(var|let|const)\b

 - name: keyword.control.flow.js
 match: \b(return|yield)\b

 - name: keyword.control.conditional.js
 match: \b(else|if)\b

 - name: keyword.control.trycatch.js
 match: \b(catch|finally|throw|try)\b

 - name: keyword.control.loop.js
 match: \b(break|continue|do|for|goto|while)\b

 - name: keyword.control.switch.js
 match: \b(case|default|switch)\b

 - name: keyword.operator.js
 match: \b(delete|in(stanceof)?|of|new|typeof|void|with)\b

 - name: keyword.operator.js
 match: '!|%|&|\*|\-\-|\-|\+\+|\+|~|===|==|=|!=|!==|<=|>=|<<=|>>=|>>>=|<>|<|>|!|&&|\|\||\?\:|\*=|/=|%=|\+=|\-=|&=|\^='

 - name: punctuation.separator.key-value
 match: ':'

 - name: keyword.operator.logical.js
 match: |-
 (?x)
 !(?!=)| # logical-not right-to-left right
 && | # logical-and left-to-right both
 \|\| # logical-or left-to-right both

 - name: keyword.operator.assignment.augmented.js
 match: |-
 (?x)
 %= | # assignment right-to-left both
 &= | # assignment right-to-left both
 \*= | # assignment right-to-left both
 \+= | # assignment right-to-left both
 -= | # assignment right-to-left both
 /= | # assignment right-to-left both
 \^= | # assignment right-to-left both
 \|= | # assignment right-to-left both
 <<= | # assignment right-to-left both
 >>= | # assignment right-to-left both
 >>>= # assignment right-to-left both

 - name: keyword.operator.bitwise.js
 match: |-
 (?x)
 ~ | # bitwise-not right-to-left right
 << | # bitwise-shift left-to-right both
 >>> | # bitwise-shift left-to-right both
 >> | # bitwise-shift left-to-right both
 & | # bitwise-and left-to-right both
 \^ | # bitwise-xor left-to-right both
 \| # bitwise-or left-to-right both

 - name: keyword.operator.relational.js
 match: |-
 (?x)
 <= | # relational left-to-right both
 >= | # relational left-to-right both
 < | # relational left-to-right both
 > # relational left-to-right both

 - name: keyword.operator.comparison.js
 match: |-
 (?x)
 === | # equality left-to-right both
 !== | # equality left-to-right both
 == | # equality left-to-right both
 != # equality left-to-right both

 - name: keyword.operator.assignment.js
 match: (?x)=

 - name: keyword.operator.arithmetic.js
 match: |-
 (?x)
 -- | # decrement n/a right-or-left
 \+\+ | # increment n/a right-or-left
 / | # division left-to-right both
 % | # modulus left-to-right both
 \* | # multiplication left-to-right both
 \+ | # addition left-to-right both
 - # subtraction left-to-right both

 literal-labels:
 patterns:
 - match: (?<=['"])(\s*)(:)
 captures:
 '2': {name: punctuation.separator.key-value.js}

 - name: constant.other.object.key.js
 match: (?<!\?|\? |case )(?!\?)([_$a-zA-Z][_$\w]*)\s*(:)
 captures:
 '1': {name: string.unquoted.label.js}
 '2': {name: punctuation.separator.key-value.js}

 literal-number:
 patterns:
 - name: invalid.illegal.numeric.hex.js
 match: (?i)(?:\B[-+]|\b)0x[0-9a-f]*\.(\B|\b[0-9]+)

 - name: invalid.illegal.numeric.octal.js
 match: (?:\B[-+]|\b)0[0-9]+\.(\B|\b[0-9]+)

 - name: constant.numeric.js
 match: |-
 (?xi)
 (?:\B[-+])?
 (?:
 \b0x[0-9a-f]*| # hex
 (
 \B\.[0-9]+| # e.g. .999
 \b[0-9]+(\.[0-9]*)? # e.g. 999.999, 999. or 999
 )(e[-+]?[0-9]+)? # e.g. e+123, E-123
 )

 - name: constant.language.infinity.js
 match: (?:\B[-+]|\b)(Infinity)\b

 literal-punctuation:
 patterns:
 - name: punctuation.terminator.statement.js
 match: \;

 - name: meta.delimiter.object.comma.js
 match: ','

 - name: meta.delimiter.method.period.js
 match: \.

 - name: meta.brace.curly.js
 match: \{|\}

 - name: meta.brace.round.js
 match: \(|\)

 - name: meta.brace.square.js
 match: \[|\]

 - name: meta.complete.method
 match: (?<=\.)\s

 literal-quasi:
 patterns:
 - name: string.quasi.js
 begin: ([a-zA-Z$_][\w$_]*)?(`)
 beginCaptures:
 '1': {name: entity.quasi.tag.name.js}
 '2': {name: punctuation.definition.quasi.begin.js}
 end: '`'
 endCaptures:
 '0': {name: punctuation.definition.quasi.end.js}
 patterns:
 - name: entity.quasi.element.js
 begin: \${
 beginCaptures:
 '0': {name: punctuation.quasi.element.begin.js}
 end: '}'
 endCaptures:
 '0': {name: punctuation.quasi.element.end.js}
 patterns:
 - include: source.js

 literal-regex:
 patterns:
 - contentName: string.regexp.js
 begin: >-
 (?x)
 (?<=
 [\[,=(:?]|
 ^|&&|
 return
 )\s*
 (/)
 (?![/*+{}?]|$)
 beginCaptures:
 '1': {name: string.regexp.js}
 '2': {name: punctuation.definition.string.begin.js}
 end: ((/)([gimy]*))
 endCaptures:
 '1': {name: string.regexp.js}
 '2': {name: punctuation.definition.string.end.js}
 '3': {name: keyword.other.js}
 patterns:
 - include: source.regexp.js

 literal-string:
 patterns:
 - name: string.quoted.single.js
 begin: "'"
 beginCaptures:
 '0': {name: punctuation.definition.string.begin.js}
 end: (')|(\n)
 endCaptures:
 '1': {name: punctuation.definition.string.end.js}
 '2': {name: invalid.illegal.newline.js}
 patterns:
 - include: '#string-content'

 - name: string.quoted.double.js
 begin: '"'
 beginCaptures:
 '0': {name: punctuation.definition.string.begin.js}
 end: (")|(\n)
 endCaptures:
 '1': {name: punctuation.definition.string.end.js}
 '2': {name: invalid.illegal.newline.js}
 patterns:
 - include: '#string-content'

 literal-variable:
 patterns:
 - name: variable.other.constant.js
 match: \.?[A-Z][_$\dA-Z]*\b

 - name: meta.entity.static.js
 match: \b([A-Z][_$\w]*\.?)\s*?(?:([a-z$_][\w_$]*(?=\())|([a-z$_][\w_$]*))?
 captures:
 '1': {name: variable.other.class.js}
 '2': {name: meta.function-call.class.static.js}
 '3': {name: variable.other.class.static.js}

 - name: variable.other.object.js
 match: (?<!\.)[_$a-zA-Z][_$\w]*\s*(?=[\[\.])

 - name: meta.property.js
 match: ([_$a-zA-Z][_$\w]*)\s*(?=[\[\.])
 captures:
 '0': {name: meta.property-name.js}
 '1': {name: variable.other.object.js}

 - name: meta.property.js
 match: (?<=[\.])\s*[_$a-zA-Z][_$\w]*
 captures:
 '0': {name: variable.other.property.js}

 - name: variable.other.readwrite.js
 match: '[_$a-zA-Z][_$\w]*'

 special:
 patterns:
 - name: entity.name.type.object.js.firebug
 match: \b(console)\b

 - name: support.function.js.firebug
 match: \.(warn|info|log|error|time|timeEnd|assert)\b

 - name: keyword.other.js
 match: \b(debugger)\b

 special-comments-conditional-compilation:
 patterns:
 - name: comment.block.conditional.js
 begin: /\*(?=@)
 end: \*/
 endCaptures:
 '1': {name: keyword.control.conditional.js}
 '2': {name: punctuation.definition.keyword.js}
 captures:
 '0': {name: punctuation.definition.comment.js}
 patterns:
 - include: source.js

 - name: keyword.control.conditional.js
 match: (@)(if|elif|else|end)
 captures:
 '1': {name: punctuation.definition.keyword.js}

 - name: keyword.operator.conditional.js
 match: (@)(cc_on|set)
 captures:
 '1': {name: punctuation.definition.keyword.js}

 - name: variable.other.conditional.js
 match: (@)(_win32|_win16|_mac|_alpha|_x86|_mc680x0|_PowerPC|_jscript_build|_jscript_version|_jscript|_debug|_fast|[a-zA-Z]\w+)
 captures:
 '1': {name: punctuation.definition.variable.js}

 string-content:
 patterns:
 - name: constant.character.escape.newline.js
 match: \\\s*\n

 - name: constant.character.escape.js
 match: \\(x[\da-fA-F]{2}|u[\da-fA-F]{4}|.)

 leading-space:
 patterns:
 - name: meta.leading-tabs
 begin: ^(?=(\t| ))
 end: (?=[^\t\s])
 patterns:
 - match: ( )( )?( )?( )?( )?( )?( )?( )?( )?( )?( )?
 captures:
 '1': {name: meta.odd-tab.group1.spaces}
 '2': {name: meta.even-tab.group2.spaces}
 '3': {name: meta.odd-tab.group3.spaces}
 '4': {name: meta.even-tab.group4.spaces}
 '5': {name: meta.odd-tab.group5.spaces}
 '6': {name: meta.even-tab.group6.spaces}
 '7': {name: meta.odd-tab.group7.spaces}
 '8': {name: meta.even-tab.group8.spaces}
 '9': {name: meta.odd-tab.group9.spaces}
 '10': {name: meta.even-tab.group10.spaces}
 '11': {name: meta.odd-tab.group11.spaces}

 - match: (\t)(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?(\t)?
 captures:
 '1': {name: meta.odd-tab.group1.tab}
 '2': {name: meta.even-tab.group2.tab}
 '3': {name: meta.odd-tab.group3.tab}
 '4': {name: meta.even-tab.group4.tab}
 '5': {name: meta.odd-tab.group5.tab}
 '6': {name: meta.even-tab.group6.tab}
 '7': {name: meta.odd-tab.group7.tab}
 '8': {name: meta.even-tab.group8.tab}
 '9': {name: meta.odd-tab.group9.tab}
 '10': {name: meta.even-tab.group10.tab}
 '11': {name: meta.odd-tab.group11.tab}

 support:
 patterns:
 # built-ins
 - name: support.class.builtin.js
 match: \b(Array|Boolean|Date|Function|Map|Number|Object|Proxy|RegExp|Set|String|WeakMap)\b

 - name: support.function.js
 match: \b(decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|isFinite|isNaN|parseFloat|parseInt|unescape)\b(?=\()

 - name: support.function.mutator.js
 match: \b(s(hift|ort|plice)|unshift|p(op|ush)|reverse)\b(?=\()

 - name: support.class.error.js
 match: \b((Eval|Range|Reference|Syntax|Type|URI)?Error)\b

 # dom
 - name: support.type.object.dom.js
 match: \b(document|window)\b

 - name: support.constant.dom.js
 match: >
 (?x)
 \b(
 ELEMENT_NODE|ATTRIBUTE_NODE|TEXT_NODE|CDATA_SECTION_NODE|ENTITY_REFERENCE_NODE|ENTITY_NODE|PROCESSING_INSTRUCTION_NODE|COMMENT_NODE|
 DOCUMENT_NODE|DOCUMENT_TYPE_NODE|DOCUMENT_FRAGMENT_NODE|NOTATION_NODE|INDEX_SIZE_ERR|DOMSTRING_SIZE_ERR|HIERARCHY_REQUEST_ERR|
 WRONG_DOCUMENT_ERR|INVALID_CHARACTER_ERR|NO_DATA_ALLOWED_ERR|NO_MODIFICATION_ALLOWED_ERR|NOT_FOUND_ERR|NOT_SUPPORTED_ERR|INUSE_ATTRIBUTE_ERR
 )\b

 # firebug
 - name: support.type.object.firebug.js
 match: \b(console)\b

 # node
 - name: support.module.node.js
 match: \b(natives|buffer|child_process|cluster|crypto|d(gram|ns)|fs|http(s)?|net|os|path|punycode|(query)?string(_decoder)?|re(adline|pl)|tls|tty|util|vm|zlib)\b

 - name: support.type.object.node.js
 match: \b(process(.env)?|global|GLOBAL|root|std(out|in|err)|exports|__dirname|__filename|console)\b

 - name: support.class.node.js
 match: \b(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream|Inflate|Deflate|InflateRaw|DeflateRaw|GZip|GUnzip|Unzip|Zip)\b