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)$\n?
keyEquivalent: ^~J

patterns:
- include: '#core'

repository:
  core:
    patterns:
    - include: '#literal-function-labels'
    - include: '#literal-arrow-function-labels'
    - include: '#literal-labels'

    - include: '#literal-keywords'
    - include: '#literal-for'
    - include: '#literal-switch'

    - include: '#expression'
    - include: '#literal-punctuation'

  expression:
    patterns:
    - include: '#support'
    - include: '#literal-function'
    - include: '#literal-arrow-function'
    - include: '#literal-prototype'           # after literal-function, which includes some prototype strings

    - include: '#literal-regexp'              # before operators to avoid ambiguities
    - include: '#literal-number'
    - include: '#literal-quasi'
    - include: '#literal-string'
    - include: '#literal-language-constant'
    - include: '#literal-language-variable'

    - include: '#literal-method'
    - include: '#literal-module'
    - include: '#literal-class'

    - include: '#literal-constructor'
    - include: '#literal-method-call'
    - include: '#literal-function-call'

    - include: '#comments'
    - include: '#brackets'

    - include: '#literal-operators'
    - include: '#literal-variable'

  round-brackets:
    patterns:
    - name: meta.group.braces.round
      begin: \(
      beginCaptures:
        '0': {name: meta.brace.round.js}
      end: \)
      endCaptures:
        '0': {name: meta.brace.round.js}
      patterns:
      - include: '#expression'

  square-brackets:
    patterns:
    - name: meta.group.braces.square
      begin: \[
      beginCaptures:
        '0': {name: meta.brace.square.js}
      end: \]
      endCaptures:
        '0': {name: meta.brace.square.js}
      patterns:
      - include: '#expression'

  curly-brackets:
    patterns:
    - name: meta.group.braces.curly
      begin: \{
      beginCaptures:
        '0': {name: meta.brace.curly.js}
      end: \}
      endCaptures:
        '0': {name: meta.brace.curly.js}
      patterns:
      - include: $self

  brackets:
    patterns:
    - include: '#round-brackets'
    - include: '#square-brackets'
    - include: '#curly-brackets'

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

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

    - name: comment.line.shebang.js
      match: ^(#!).*$\n?
      captures:
        '1': {name: punctuation.definition.comment.js}

  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:
      - name: punctuation.definition.comment.js
        match: /\*
      - include: $self

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

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

  function-declaration-parameters:
    patterns:
    - begin: \(
      beginCaptures:
        '0': {name: punctuation.definition.parameters.begin.js}
      end: \)
      endCaptures:
        '0': {name: punctuation.definition.parameters.end.js}
      patterns:
      - name: keyword.operator.spread.js
        match: (?<!\.)\.\.\.
      - name: variable.parameter.function.js
        match: '[_$a-zA-Z][$\w]*'
      - name: punctuation.separator.parameter.function.js
        match: ','
      - name: meta.parameter.optional.js
        begin: '='
        beginCaptures:
          '0': {name: keyword.operator.assignment.js}
        end: '(?=[,)])'
        patterns:
        - include: '#expression'
      - include: '#comments'

  literal-module:
    patterns:
    - name: keyword.operator.module.js
      match: (?<!\.)\b(import|export|default|from|as)\b

  literal-class:
    patterns:
    # e.g. class MyClass {  }
    - name: meta.class.js
      begin: >-
        (?x)
          (?<!\.)\b(class)
          \s+((?!\b(extends)\b)[_$a-zA-Z][$\w]*)?
      beginCaptures:
        '1': {name: storage.type.class.js}
        '2': {name: entity.name.class.js}
      end: '}'
      endCaptures:
        '0': {name: meta.brace.curly.js}
      patterns:
      - name: meta.class.extends.js
        begin: \b(extends)\b
        beginCaptures:
          '1': {name: storage.type.extends.js}
        end: '(?={)'
        patterns:
        - include: '#expression'

      - begin: '{'
        beginCaptures:
          '0': {name: meta.brace.curly.js}
        end: '(?=})'
        patterns:
        - include: '#brackets'
        - include: '#comments'
        - include: '#literal-method'
        - include: '#literal-property-initializer'
        - include: '#expression'

  literal-method:
    patterns:
    # e.g. play(arg1, arg2) {  }
    - name: meta.method.js
      begin: >-
        (?x)
          (?:\b(static)\s+)?
          (?:\b(async)\s+)?
          (?:(\*)\s*)?([_$a-zA-Z][$\w]*)\s*
          (?=\([^())]*\)(?:\s|/\*.*\*/)*\{)
      beginCaptures:
        '1': {name: storage.type.js}
        '2': {name: storage.type.js}
        '3': {name: keyword.generator.asterisk.js}
        '4': {name: entity.name.method.js}
      end: (?<=\))
      patterns:
      - include: '#function-declaration-parameters'

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

  literal-property-initializer:
    patterns:
    - name: meta.class.property.js
      match: \b(?:(static)\s+)?([_$a-zA-Z][$\w]*)\s*=
      captures:
        '1': {name: storage.type.js}
        '2': {name: variable.class.property.js}

  literal-prototype:
    patterns:
    # e.g. Sound.prototype
    - name: meta.prototype.access.js
      match: ([_$a-zA-Z][$\w]*)(\.)(prototype)\b
      captures:
        '1': {name: entity.name.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: variable.language.prototype.js}

    # 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: keyword.operator.accessor.js}
        '3': {name: variable.language.prototype.js}

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

    # e.g. play = function(arg1, arg2) {  }
    - name: meta.function.js
      begin: >-
        (?x)
          (\b[_$a-zA-Z][$\w]*)
          \s*=
          \s*(?:(async)\s+)?
          \s*(function)(?:\s*(\*)|(?=\s|[(]))
          \s*([_$a-zA-Z][$\w]*)?\s*
      beginCaptures:
        '1': {name: entity.name.function.js}
        '2': {name: storage.type.js}
        '3': {name: storage.type.function.js}
        '4': {name: keyword.generator.asterisk.js}
        '5': {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: >-
        (?x)
          (\b_?[A-Z][$\w]*)?
          (\.)(prototype)
          (\.)([_$a-zA-Z][$\w]*)
          \s*=
          \s*(?:(async)\s+)?
          \s*(function)(?:\s*(\*)|(?=\s|[(]))
          \s*([_$a-zA-Z][$\w]*)?\s*
      beginCaptures:
        '1': {name: entity.name.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: variable.language.prototype.js}
        '4': {name: keyword.operator.accessor.js}
        '5': {name: entity.name.function.js}
        '6': {name: storage.type.js}
        '7': {name: storage.type.function.js}
        '8': {name: keyword.generator.asterisk.js}
        '9': {name: entity.name.function.js}
      end: (?<=\))
      patterns:
      - include: '#function-declaration-parameters'

    # e.g. Sound.play = function(arg1, arg2) {  }
    - name: meta.function.static.js
      begin: >-
        (?x)
          (\b_?[A-Z][$\w]*)?
          (\.)([_$a-zA-Z][$\w]*)
          \s*=
          \s*(?:(async)\s+)?
          \s*(function)(?:\s*(\*)|(?=\s|[(]))
          \s*([_$a-zA-Z][$\w]*)?\s*
      beginCaptures:
        '1': {name: entity.name.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: entity.name.function.js}
        '4': {name: storage.type.js}
        '5': {name: storage.type.function.js}
        '6': {name: keyword.generator.asterisk.js}
        '7': {name: entity.name.function.js}
      end: (?<=\))
      patterns:
      - include: '#function-declaration-parameters'

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

    # e.g. "play": function(arg1, arg2) {  }
    - name: meta.function.json.js
      begin: >-
        (?x)
          (?:
            ((')((?:[^']|\\')*)('))|
            ((")((?:[^"]|\\")*)("))
          )
          \s*(:)
          \s*(?:(async)\s+)?
          \s*(function)(?:\s*(\*)|(?=\s|[(]))
          \s*([_$a-zA-Z][$\w]*)?\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.js}
        '11': {name: storage.type.function.js}
        '12': {name: keyword.generator.asterisk.js}
        '13': {name: entity.name.function.js}
      end: (?<=\))
      patterns:
      - include: '#function-declaration-parameters'

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

    # e.g. arg => { }
    - name: meta.function.arrow.js
      match: >-
        (?x)
          (\basync)?\s*
          \b([_$a-zA-Z][$\w]*)\s*(=>)
      captures:
        '1': {name: storage.type.js}
        '2': {name: variable.parameter.function.js}
        '3': {name: storage.type.function.arrow.js}

    # e.g. play = (args) => { }
    - name: meta.function.arrow.js
      begin: >-
        (?x)
          (\b[_$a-zA-Z][$\w]*)
          \s*=
          \s*(async)?
          \s*(?=\([^()]*\)\s*(=>))
      beginCaptures:
        '1': {name: entity.name.function.js}
        '2': {name: storage.type.js}
      end: (?<=\))\s*(=>)
      endCaptures:
        '1': {name: storage.type.function.arrow.js}
      patterns:
      - include: '#function-declaration-parameters'

    # e.g. play = arg => { }
    - name: meta.function.arrow.js
      match: >-
        (?x)
          (\b[_$a-zA-Z][$\w]*)
          \s*=
          \s*(async)?
          \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      captures:
        '1': {name: entity.name.function.js}
        '2': {name: storage.type.js}
        '3': {name: variable.parameter.function.js}
        '4': {name: storage.type.function.arrow.js}

    # e.g. Sound.prototype.play = (args) => { }
    - name: meta.prototype.function.arrow.js
      begin: >-
        (?x)
          (\b_?[A-Z][$\w]*)?
          (\.)(prototype)
          (\.)([_$a-zA-Z][$\w]*)
          \s*=
          \s*(async)?
          \s*(?=\([^()]*\)\s*(=>))
      beginCaptures:
        '1': {name: entity.name.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: variable.language.prototype.js}
        '4': {name: keyword.operator.accessor.js}
        '5': {name: entity.name.function.js}
        '6': {name: storage.type.js}
      end: (?<=\))\s*(=>)
      endCaptures:
        '1': {name: storage.type.function.arrow.js}
      patterns:
      - include: '#function-declaration-parameters'

    # e.g. Sound.prototype.play = arg => { }
    - name: meta.prototype.function.arrow.js
      match: >-
        (?x)
          (\b_?[A-Z][$\w]*)?
          (\.)(prototype)
          (\.)([_$a-zA-Z][$\w]*)
          \s*=
          \s*(async)?
          \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      captures:
        '1': {name: entity.name.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: variable.language.prototype.js}
        '4': {name: keyword.operator.accessor.js}
        '5': {name: entity.name.function.js}
        '6': {name: storage.type.js}
        '7': {name: variable.parameter.function.js}
        '8': {name: storage.type.function.arrow.js}

    # e.g. Sound.play = (args) => { }
    - name: meta.function.static.arrow.js
      begin: >-
        (?x)
          (\b_?[A-Z][$\w]*)?
          (\.)([_$a-zA-Z][$\w]*)
          \s*=
          \s*(async)?
          \s*(?=\([^()]*\)\s*(=>))
      beginCaptures:
        '1': {name: entity.name.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: entity.name.function.js}
        '4': {name: storage.type.js}
      end: (?<=\))\s*(=>)
      endCaptures:
        '1': {name: storage.type.function.arrow.js}
      patterns:
      - include: '#function-declaration-parameters'

    # e.g. Sound.play = arg => { }
    - name: meta.function.static.arrow.js
      match: >-
        (?x)
          (\b_?[A-Z][$\w]*)?
          (\.)([_$a-zA-Z][$\w]*)
          \s*=
          \s*(async)?
          \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      captures:
        '1': {name: entity.name.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: entity.name.function.js}
        '4': {name: storage.type.js}
        '5': {name: variable.parameter.function.js}
        '6': {name: storage.type.function.arrow.js}

  literal-arrow-function-labels:
    patterns:
    # e.g. play: (args) => { }
    - name: meta.function.json.arrow.js
      begin: >-
        (?x)
          \b([_$a-zA-Z][$\w]*)
          \s*(:)
          \s*(async)?
          \s*(?=\([^()]*\)\s*(=>))
      beginCaptures:
        '1': {name: entity.name.function.js}
        '2': {name: punctuation.separator.key-value.js}
        '3': {name: storage.type.js}
      end: (?<=\))\s*(=>)
      endCaptures:
        '1': {name: storage.type.function.arrow.js}
      patterns:
      - include: '#function-declaration-parameters'

    # e.g. play: arg => { }
    - name: meta.function.json.arrow.js
      match: >-
        (?x)
          \b([_$a-zA-Z][$\w]*)
          \s*(:)
          \s*(async)?
          \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      captures:
        '1': {name: entity.name.function.js}
        '2': {name: punctuation.separator.key-value.js}
        '3': {name: storage.type.js}
        '4': {name: variable.parameter.function.js}
        '5': {name: storage.type.function.arrow.js}

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

    # e.g. "play": arg => { }
    - name: meta.function.json.arrow.js
      match: >-
        (?x)
          (?:
            ((')((?:[^']|\\')*)('))|
            ((")((?:[^"]|\\")*)("))
          )
          \s*(:)
          \s*(async)?
          \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      captures:
        '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.js}
        '11': {name: variable.parameter.function.js}
        '12': {name: storage.type.function.arrow.js}

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

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

  literal-method-call:
    patterns:
    - name: meta.function-call.static.without-arguments.js
      match: >-
        (?x)
          (?:(?<=\.)|\b)
          ([A-Z][$\w]*)\s*(\.)
          ([_$a-zA-Z][$\w]*)\s*
          (\(\s*\))
      captures:
        '1': {name: variable.other.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: entity.name.function.js}
        '4': {name: meta.group.braces.round.function.arguments.js}

    - name: meta.function-call.static.with-arguments.js
      match: >-
        (?x)
          (?:(?<=\.)|\b)
          ([A-Z][$\w]*)\s*(\.)
          ([_$a-zA-Z][$\w]*)\s*
          (?=\()
      captures:
        '1': {name: variable.other.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: entity.name.function.js}

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

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

  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
      
    - name: constant.language.this.js
      match: (?<!\.)\bthis\b

  literal-constructor:
    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}

  literal-keyword-storage:
    patterns:
    - name: storage.type.js
      match: (?<!\.)\b(const|let|var)\b

  literal-keywords:
    patterns:
    - include: '#literal-keyword-storage'

    - match: (?<!\.)\b(yield)\b(?:\s*(\*))?
      captures:
        '1': {name: keyword.control.flow.js}
        '2': {name: keyword.generator.asterisk.js}

    - name: keyword.control.flow.js
      match: (?<!\.)\b(await|return)\b

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

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

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

  literal-for:
    patterns:
    - name: meta.for.js
      begin: (?<!\.)\b(for)\b
      beginCaptures:
        '1': {name: keyword.control.loop.js}
      end: \)
      endCaptures:
        '0': {name: meta.brace.round.js}
      patterns:
      - begin: \(
        beginCaptures:
          '0': {name: meta.brace.round.js}
        end: (?=\))
        patterns:
        - include: '#literal-keyword-storage'
        - include: '#expression'
        - include: '#literal-punctuation'

  literal-switch:
    patterns:
    - name: meta.switch.js
      begin: (?<!\.)\b(switch)\b
      beginCaptures:
        '1': {name: keyword.control.switch.js}
      end: \}
      endCaptures:
        '0': {name: meta.brace.curly.js}
      patterns:
      - include: '#round-brackets'
      - begin: \{
        beginCaptures:
          '0': {name: meta.brace.curly.js}
        end: (?=})
        patterns:
        - begin: (?<!\.)\b(case|default)\b
          beginCaptures:
            '1': {name: keyword.control.switch.js}
          end: (?=:)
          patterns:
          - include: '#expression'
        - include: $self

  literal-operators:
    patterns:
    - name: keyword.operator.js
      match: (?<!\.)\b(delete|in|instanceof|new|of|typeof|void|with)\b

    - 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.js
      match: >-
        (?x)
          =(?!=)| # assignment      right-to-left   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.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

    - name: keyword.operator.ternary.js
      match: '\?|:'

    - name: keyword.operator.spread.js
      match: (?<!\.)\.\.\.

    - name: keyword.operator.accessor.js
      match: \.

  literal-labels:
    patterns:
    - begin: >-
        (?x)
          (?<!\?)(?<!\?\s)(?=(
            ((')((?:[^']|\\')*)('))|
            ((")((?:[^"]|\\")*)("))
          )\s*:)
      end: ':'
      endCaptures:
        '0': {name: punctuation.separator.key-value.js}
      patterns:
      - include: '#literal-string'

    - name: constant.other.object.key.js
      match: (?<!\.|\?|\?\s)([_$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[-+])?
          (?:
            \b0b[0-1]*|                 # binary
            \b0o[0-7]*|                 # octal
            \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.comma.js
      match: ','

  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:
      - include: '#string-content'
      - 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: '#expression'

  literal-regexp:
    patterns:
    # ignore ++, -- since they're uncommon, distinguishing them is not possible in sublime text, see:
    #   http://stackoverflow.com/questions/5519596/when-parsing-javascript-what-determines-the-meaning-of-a-slash
    - name: string.regexp.js
      begin: >-
        (?x)
          (?<=
            \.|\(|,|{|}|\[|;|,|<|>|<=|>=|==|!=|===|!==|\+|-|\*|%|\+\+|--|<<|>>|>>>|&|\||\^|!|~|&&|\|\||\?|:|=|\+=|-=|\*=|%=|<<=|>>=|>>>=|&=|\|=|\^=|/|/=|
            \Wnew|\Wdelete|\Wvoid|\Wtypeof|\Winstanceof|\Win|\Wdo|\Wreturn|\Wcase|\Wthrow|
            ^new|^delete|^void|^typeof|^instanceof|^in|^do|^return|^case|^throw|^
          )\s*
          (/)
          (?!/|\*|$)
      beginCaptures:
        '1': {name: punctuation.definition.string.begin.js}
      end: (/)([gimy]*)
      endCaptures:
        '1': {name: punctuation.definition.string.end.js}
        '2': {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'

  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}|.)

  literal-variable:
    patterns:
    # e.g. CONSTANT
    - name: variable.other.constant.js
      match: '[A-Z][_$\dA-Z]*\b'

    # dollar variables
    - name: variable.other.dollar.js
      match: '(\$)[$\w]+'
      captures:
        '1': {name: punctuation.dollar.js}

    # e.g. Class.property
    - name: meta.property.class.js
      match: >-
        (?x)
          \b([A-Z][$\w]*)\s*(\.)
          ([_$a-zA-Z][$\w]*)
      captures:
        '1': {name: variable.other.class.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: variable.other.property.static.js}

    # e.g. obj.property
    - name: variable.other.object.js
      match: (?<!\.)[_$a-zA-Z][$\w]*\s*(?=[\[\.])
      captures:
        '1': {name: variable.other.object.js}

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

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

  support:
    patterns:
    # built-ins
    - name: support.class.builtin.js
      match: \b(Array|Boolean|Date|Function|Map|Math|Number|Object|Promise|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: \.(shift|sort|splice|unshift|pop|push|reverse)\b

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

    # debugger
    - name: keyword.other.js
      match: (?<!\.)\b(debugger)\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

    # console
    - match: (?<!\.)\b(console)(?:(\.)(warn|info|log|error|time|timeEnd|assert|count|dir|group|groupCollapsed|groupEnd|profile|profileEnd|table|trace))?\b
      captures:
        '1': {name: support.type.object.console.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: support.function.console.js}

    # node
    - name: support.module.node.js
      match: (?<!\.)\b(assert|buffer|child_process|cluster|constants|crypto|dgram|dns|domain|events|fs|http|https|net|os|path|punycode|querystring|readline|repl|stream|string_decoder|timers|tls|tty|url|util|vm|zlib)\b

    - match: (?<!\.)\b(process)(?:(\.)(stdout|stderr|stdin|argv|execPath|execArgv|env|exitCode|version|versions|config|pid|title|arch|platform|mainModule))?\b
      captures:
        '1': {name: support.type.object.process.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: support.type.object.process.js}

    - match: (?<!\.)\b(process)(?:(\.)(abort|chdir|cwd|exit|getgid|setgid|getuid|setuid|setgroups|getgroups|initgroups|kill|memoryUsage|nextTick|umask|uptime|hrtime))?\b
      captures:
        '1': {name: support.type.object.process.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: support.function.process.js}

    - match: (?<!\.)\b(exports|module(?:(\.)(exports|id|filename|loaded|parent|children)))?\b
      captures:
        '1': {name: support.type.object.module.js}
        '2': {name: keyword.operator.accessor.js}
        '3': {name: support.type.object.module.js}

    - name: support.type.object.node.js
      match: (?<!\.)\b(global|GLOBAL|root|__dirname|__filename)\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

    # mustache
    - name: meta.tag.mustache.js
      begin: '{{'
      end: '}}'