JavaScriptNextEdited.sublime-syntax

%YAML 1.2
---
# http://www.sublimetext.com/docs/3/syntax.html
name: JavaScript Next JSDoc
file_extensions:
  - js
  - htc
  - jsx
first_line_match: ^#!/.*\b(node|js)$\n?
scope: source.js
contexts:
  main:
    - include: core
  brackets:
    - include: round-brackets
    - include: square-brackets
    - include: curly-brackets
  comments:
    - include: special-comments-conditional-compilation
    - match: /\*\*(?!/)
      captures:
        0: punctuation.definition.comment.js
      push:
        - meta_scope: comment.block.documentation.js
      
        # JS-DOC COMMENT HIGHLIGHTING #

        # @tag {blue} [?orange=purple|'yellow']?
        - match: \*\s(@param|@property)\s+
          captures:
            1: keyword.control.conditional.js
          push:
            - match: ({\S*})\s+(\[?[^=\]\s]*)=?(["'][^=\]\s]*["'])(\]?)
              captures:
                1: variable.language.this.js
                2: variable.parameter.function.js
                3: string.quoted.double.js
                4: variable.parameter.function.js
              pop: true
            - match: ({\S*})\s+(\[?[^=\]\s]*)=?([^=\]\s]*)(\]?)
              captures:
                1: variable.language.this.js
                2: variable.parameter.function.js
                3: constant.numeric.js
                4: variable.parameter.function.js
              pop: true
            - match: $
              pop: true
  
        # @tag {blue} green 
        - match: \*\s(@(?:typedef))
          captures:
            1: keyword.control.conditional.js
          push:
            - match: ({\S*})\s+(\S*)
              captures:
                1: variable.language.this.js
                2: variable.other.class.js
              pop: true
            - match: $
              pop: true

        # @tag {blue}
        - match: \*\s(@(?:return|extends|type|enum))
          captures:
            1: keyword.control.conditional.js
          push:
            - match: ({\S*})
              captures:
                1: variable.language.this.js
              pop: true
            - match: $
              pop: true

        # @tag <caption>orange</caption>
        - match: \*\s(@(?:example))
          captures:
            1: keyword.control.conditional.js
          push:
            - match: <caption>(.*)</caption>
              captures:
                1: variable.parameter.function.js
              pop: true
            - match: $
              pop: true

        # @tag purple/'yellow'
        - match: \*\s(@(?:default|version))
          captures:
            1: keyword.control.conditional.js
          push:
            - match: \s+(["']\S*["'])
              captures:
                1: string.quoted.double.js
              pop: true
            - match: \s+(\S*)
              captures:
                1: constant.numeric.js
              pop: true
            - match: $
              pop: true

        # @tag green
        - match: \*\s(@(?:memberof|external|function|name|class))
          captures:
            1: keyword.control.conditional.js
          push:
            - match: \s+(\S*)
              captures:
                1: variable.other.class.js
              pop: true
            - match: $
              pop: true

        # @tag
        - match: \*\s(@\S*)[\s$]
          captures:
            1: keyword.control.conditional.js
         
        # {@link green}
        - match: '({@link\s[^}]*})'
          captures:
            1: variable.other.class.js

        # `yellow comments`
        - match: "(`[^`]*`)"
          captures:
            1: string.quoted.double.js

        # // Comments
        - match: \s//.*$
          scope: string.quoted.double.js

        # /JS-DOC COMMENT HIGHLIGHTING #

        - match: \*/
          captures:
            0: punctuation.definition.comment.js
          pop: true
    - match: /\*
      captures:
        0: punctuation.definition.comment.js
      push:
        - meta_scope: comment.block.js
        - match: \*/
          captures:
            0: punctuation.definition.comment.js
          pop: true
    - match: (<!--|-->)
      scope: comment.block.html.js
      captures:
        0: punctuation.definition.comment.js

    # JS-DOC COMMENT HIGHLIGHTING #

    # @include comments
    - match: //(@include\:)(.*)$
      scope: comment.line.double-slash.js
      captures:
        1: variable.language.this.js
        2: variable.other.class.js

    # /JS-DOC COMMENT HIGHLIGHTING #
    
    - match: (//).*$\n?
      scope: comment.line.double-slash.js
      captures:
        1: punctuation.definition.comment.js
    - match: ^(#!).*$\n?
      scope: comment.line.shebang.js
      captures:
        1: punctuation.definition.comment.js
  core:
    - 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
  curly-brackets:
    - match: '\{'
      captures:
        0: meta.brace.curly.js
      push:
        - meta_scope: meta.group.braces.curly
        - match: '\}'
          captures:
            0: meta.brace.curly.js
          pop: true
        - include: main
  expression:
    - include: support
    - include: literal-function
    - include: literal-arrow-function
    - include: literal-prototype
    - include: literal-regexp
    - include: literal-number
    - include: literal-template-string
    - 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
  function-declaration-parameters:
    - match: \(
      captures:
        0: punctuation.definition.parameters.begin.js
      push:
        - match: \)
          captures:
            0: punctuation.definition.parameters.end.js
          pop: true
        - match: (?<!\.)\.\.\.
          scope: keyword.operator.spread.js
        - match: '[_$a-zA-Z][$\w]*'
          scope: variable.parameter.function.js
        - match: ","
          scope: punctuation.separator.parameter.function.js
        - match: "="
          captures:
            0: keyword.operator.assignment.js
          push:
            - meta_scope: meta.parameter.optional.js
            - match: "(?=[,)])"
              pop: true
            - include: expression
        - include: comments
  literal-arrow-function:
    - match: |-
        (?x)
        (\basync)?\s*
        (?=\([^()]*\)\s*(=>))
      captures:
        1: storage.type.js
      push:
        - meta_scope: meta.function.arrow.js
        - match: (?<=\))\s*(=>)
          captures:
            1: storage.type.function.arrow.js
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (\basync)?\s*
        \b([_$a-zA-Z][$\w]*)\s*(=>)
      scope: meta.function.arrow.js
      captures:
        1: storage.type.js
        2: variable.parameter.function.js
        3: storage.type.function.arrow.js
    - match: |-
        (?x)
        (\b[_$a-zA-Z][$\w]*)
        \s*=
        \s*(async)?
        \s*(?=\([^()]*\)\s*(=>))
      captures:
        1: entity.name.function.js
        2: storage.type.js
      push:
        - meta_scope: meta.function.arrow.js
        - match: (?<=\))\s*(=>)
          captures:
            1: storage.type.function.arrow.js
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (\b[_$a-zA-Z][$\w]*)
        \s*=
        \s*(async)?
        \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      scope: meta.function.arrow.js
      captures:
        1: entity.name.function.js
        2: storage.type.js
        3: variable.parameter.function.js
        4: storage.type.function.arrow.js
    - match: |-
        (?x)
        (\b_?[A-Z][$\w]*)?
        (\.)(prototype)
        (\.)([_$a-zA-Z][$\w]*)
        \s*=
        \s*(async)?
        \s*(?=\([^()]*\)\s*(=>))
      captures:
        1: entity.name.class.js
        2: keyword.operator.accessor.js
        3: variable.language.prototype.js
        4: keyword.operator.accessor.js
        5: entity.name.function.js
        6: storage.type.js
      push:
        - meta_scope: meta.prototype.function.arrow.js
        - match: (?<=\))\s*(=>)
          captures:
            1: storage.type.function.arrow.js
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (\b_?[A-Z][$\w]*)?
        (\.)(prototype)
        (\.)([_$a-zA-Z][$\w]*)
        \s*=
        \s*(async)?
        \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      scope: meta.prototype.function.arrow.js
      captures:
        1: entity.name.class.js
        2: keyword.operator.accessor.js
        3: variable.language.prototype.js
        4: keyword.operator.accessor.js
        5: entity.name.function.js
        6: storage.type.js
        7: variable.parameter.function.js
        8: storage.type.function.arrow.js
    - match: |-
        (?x)
        (\b_?[A-Z][$\w]*)?
        (\.)([_$a-zA-Z][$\w]*)
        \s*=
        \s*(async)?
        \s*(?=\([^()]*\)\s*(=>))
      captures:
        1: entity.name.class.js
        2: keyword.operator.accessor.js
        3: entity.name.function.js
        4: storage.type.js
      push:
        - meta_scope: meta.function.static.arrow.js
        - match: (?<=\))\s*(=>)
          captures:
            1: storage.type.function.arrow.js
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (\b_?[A-Z][$\w]*)?
        (\.)([_$a-zA-Z][$\w]*)
        \s*=
        \s*(async)?
        \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      scope: meta.function.static.arrow.js
      captures:
        1: entity.name.class.js
        2: keyword.operator.accessor.js
        3: entity.name.function.js
        4: storage.type.js
        5: variable.parameter.function.js
        6: storage.type.function.arrow.js
  literal-arrow-function-labels:
    - match: |-
        (?x)
        \b([_$a-zA-Z][$\w]*)
        \s*(:)
        \s*(async)?
        \s*(?=\([^()]*\)\s*(=>))
      captures:
        1: entity.name.function.js
        2: punctuation.separator.key-value.js
        3: storage.type.js
      push:
        - meta_scope: meta.function.json.arrow.js
        - match: (?<=\))\s*(=>)
          captures:
            1: storage.type.function.arrow.js
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        \b([_$a-zA-Z][$\w]*)
        \s*(:)
        \s*(async)?
        \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      scope: meta.function.json.arrow.js
      captures:
        1: entity.name.function.js
        2: punctuation.separator.key-value.js
        3: storage.type.js
        4: variable.parameter.function.js
        5: storage.type.function.arrow.js
    - match: |-
        (?x)
        (?:
          ((')((?:[^']|\\')*)('))|
          ((")((?:[^"]|\\")*)("))
        )
        \s*(:)
        \s*(async)?
        \s*(?=\([^()]*\)\s*(=>))
      captures:
        1: string.quoted.single.js
        2: punctuation.definition.string.begin.js
        3: entity.name.function.js
        4: punctuation.definition.string.end.js
        5: string.quoted.double.js
        6: punctuation.definition.string.begin.js
        7: entity.name.function.js
        8: punctuation.definition.string.end.js
        9: punctuation.separator.key-value.js
        10: storage.type.js
      push:
        - meta_scope: meta.function.json.arrow.js
        - match: (?<=\))\s*(=>)
          captures:
            1: storage.type.function.arrow.js
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (?:
          ((')((?:[^']|\\')*)('))|
          ((")((?:[^"]|\\")*)("))
        )
        \s*(:)
        \s*(async)?
        \s*\b([_$a-zA-Z][$\w]*)\s*(=>)
      scope: meta.function.json.arrow.js
      captures:
        1: string.quoted.single.js
        2: punctuation.definition.string.begin.js
        3: entity.name.function.js
        4: punctuation.definition.string.end.js
        5: string.quoted.double.js
        6: punctuation.definition.string.begin.js
        7: entity.name.function.js
        8: punctuation.definition.string.end.js
        9: punctuation.separator.key-value.js
        10: storage.type.js
        11: variable.parameter.function.js
        12: storage.type.function.arrow.js
  literal-class:
    - match: |-
        (?x)
        (?<!\.)\b(class)
        \s+((?!\b(extends)\b)[_$a-zA-Z][$\w]*)?
      captures:
        1: storage.type.class.js
        2: entity.name.class.js
      push:
        - meta_scope: meta.class.js
        - match: "}"
          captures:
            0: meta.brace.curly.js
          pop: true
        - match: \b(extends)\b
          captures:
            1: storage.type.extends.js
          push:
            - meta_scope: meta.class.extends.js
            - match: "(?={)"
              pop: true
            - include: expression
        - match: "{"
          captures:
            0: meta.brace.curly.js
          push:
            - match: "(?=})"
              pop: true
            - include: brackets
            - include: comments
            - include: literal-method
            - include: literal-property-initializer
            - include: expression
  literal-constructor:
    - match: '(new)\s+(?=[_$a-zA-Z][$\w.]*)'
      captures:
        1: keyword.operator.new.js
      push:
        - meta_scope: meta.instance.constructor
        - match: "(?![_$a-zA-Z.])"
          pop: true
        - include: support
        - include: literal-language-variable
        - match: \.
          scope: keyword.operator.accessor.js
        - match: '(?<=\.)\s*[_$a-zA-Z][$\w]*(?=\s*\()'
          scope: entity.name.type.new.js
        - match: '(?<=\.)\s*[_$a-zA-Z][$\w]*'
          scope: meta.property.object.js
          captures:
            2: variable.other.property.js
  literal-for:
    - match: (?<!\.)\b(for)\b
      captures:
        1: keyword.control.loop.js
      push:
        - meta_scope: meta.for.js
        - match: \)
          captures:
            0: meta.brace.round.js
          pop: true
        - match: \(
          captures:
            0: meta.brace.round.js
          push:
            - match: (?=\))
              pop: true
            - include: literal-keyword-storage
            - include: expression
            - include: literal-punctuation
  literal-function:
    - match: |-
        (?x)
        (?:\b(async)\s+)?
        \s*(function)(?:\s*(\*)|(?=\s|[(]))
        \s*([_$a-zA-Z][$\w]*)?\s*
      captures:
        1: storage.type.js
        2: storage.type.function.js
        3: keyword.generator.asterisk.js
        4: entity.name.function.js
      push:
        - meta_scope: meta.function.js
        - match: (?<=\))
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (\b[_$a-zA-Z][$\w]*)
        \s*=
        \s*(?:(async)\s+)?
        \s*(function)(?:\s*(\*)|(?=\s|[(]))
        \s*([_$a-zA-Z][$\w]*)?\s*
      captures:
        1: entity.name.function.js
        2: storage.type.js
        3: storage.type.function.js
        4: keyword.generator.asterisk.js
        5: entity.name.function.js
      push:
        - meta_scope: meta.function.js
        - match: (?<=\))
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (\b_?[A-Z][$\w]*)?
        (\.)(prototype)
        (\.)([_$a-zA-Z][$\w]*)
        \s*=
        \s*(?:(async)\s+)?
        \s*(function)(?:\s*(\*)|(?=\s|[(]))
        \s*([_$a-zA-Z][$\w]*)?\s*
      captures:
        1: entity.name.class.js
        2: keyword.operator.accessor.js
        3: variable.language.prototype.js
        4: keyword.operator.accessor.js
        5: entity.name.function.js
        6: storage.type.js
        7: storage.type.function.js
        8: keyword.generator.asterisk.js
        9: entity.name.function.js
      push:
        - meta_scope: meta.prototype.function.js
        - match: (?<=\))
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (\b_?[A-Z][$\w]*)?
        (\.)([_$a-zA-Z][$\w]*)
        \s*=
        \s*(?:(async)\s+)?
        \s*(function)(?:\s*(\*)|(?=\s|[(]))
        \s*([_$a-zA-Z][$\w]*)?\s*
      captures:
        1: entity.name.class.js
        2: keyword.operator.accessor.js
        3: entity.name.function.js
        4: storage.type.js
        5: storage.type.function.js
        6: keyword.generator.asterisk.js
        7: entity.name.function.js
      push:
        - meta_scope: meta.function.static.js
        - match: (?<=\))
          pop: true
        - include: function-declaration-parameters
  literal-function-call:
    - match: |-
        (?x)
        ([_$a-zA-Z][$\w]*)\s*
        (\(\s*\))
      scope: meta.function-call.without-arguments.js
      captures:
        1: entity.name.function.js
        2: meta.group.braces.round.function.arguments.js
    - match: |-
        (?x)
        ([_$a-zA-Z][$\w]*)\s*
        (?=\()
      scope: meta.function-call.with-arguments.js
      captures:
        1: entity.name.function.js
  literal-function-labels:
    - match: |-
        (?x)
        \b([_$a-zA-Z][$\w]*)
        \s*(:)
        \s*(?:(async)\s+)?
        \s*(function)(?:\s*(\*)|(?=\s|[(]))
        \s*([_$a-zA-Z][$\w]*)?\s*
      captures:
        1: entity.name.function.js
        2: punctuation.separator.key-value.js
        3: storage.type.js
        4: storage.type.function.js
        5: keyword.generator.asterisk.js
        6: entity.name.function.js
      push:
        - meta_scope: meta.function.json.js
        - match: (?<=\))
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        (?:
          ((')((?:[^']|\\')*)('))|
          ((")((?:[^"]|\\")*)("))
        )
        \s*(:)
        \s*(?:(async)\s+)?
        \s*(function)(?:\s*(\*)|(?=\s|[(]))
        \s*([_$a-zA-Z][$\w]*)?\s*
      captures:
        1: string.quoted.single.js
        2: punctuation.definition.string.begin.js
        3: entity.name.function.js
        4: punctuation.definition.string.end.js
        5: string.quoted.double.js
        6: punctuation.definition.string.begin.js
        7: entity.name.function.js
        8: punctuation.definition.string.end.js
        9: punctuation.separator.key-value.js
        10: storage.type.js
        11: storage.type.function.js
        12: keyword.generator.asterisk.js
        13: entity.name.function.js
      push:
        - meta_scope: meta.function.json.js
        - match: (?<=\))
          pop: true
        - include: function-declaration-parameters
  literal-keyword-storage:
    - match: (?<!\.)\b(const|let|var)\b
      scope: storage.type.js
  literal-keywords:
    - include: literal-keyword-storage
    - match: (?<!\.)\b(yield)\b(?:\s*(\*))?
      captures:
        1: keyword.control.flow.js
        2: keyword.generator.asterisk.js
    - match: (?<!\.)\b(await|return)\b
      scope: keyword.control.flow.js
    - match: (?<!\.)\b(if|else)\b
      scope: keyword.control.conditional.js
    - match: (?<!\.)\b(catch|finally|throw|try)\b
      scope: keyword.control.trycatch.js
    - match: (?<!\.)\b(break|continue|do|goto|while)\b
      scope: keyword.control.loop.js
  literal-labels:
    - match: |-
        (?x)
        (?<!\?)(?<!\?\s)(?=(
          ((')((?:[^']|\\')*)('))|
          ((")((?:[^"]|\\")*)("))
        )\s*:)
      push:
        - match: ":"
          captures:
            0: punctuation.separator.key-value.js
          pop: true
        - include: literal-string
    - match: '(?<!\.|\?|\?\s)([_$a-zA-Z][$\w]*)\s*(:)'
      scope: constant.other.object.key.js
      captures:
        1: string.unquoted.label.js
        2: punctuation.separator.key-value.js
  literal-language-constant:
    - match: (?<!\.)\btrue\b
      scope: constant.language.boolean.true.js
    - match: (?<!\.)\bfalse\b
      scope: constant.language.boolean.false.js
    - match: (?<!\.)\bnull\b
      scope: constant.language.null.js
    - match: (?<!\.)\bundefined\b
      scope: constant.language.undefined.js
    - match: (?<!\.)\bNaN\b
      scope: constant.language.nan.js
  literal-language-variable:
    - match: (?<!(?<!\.\.)\.)\b(arguments)\b
      scope: variable.language.arguments.js
    - match: (?<!(?<!\.\.)\.)\b(super)\b
      scope: variable.language.super.js
    - match: (?<!(?<!\.\.)\.)\b(this)\b
      scope: variable.language.this.js
    - match: (?<!(?<!\.\.)\.)\b(self)\b
      scope: variable.language.self.js
    - match: (?<=\.)\b(__proto__)\b
      scope: variable.language.proto.js
    - match: (?<=\.)\b(constructor)\b
      scope: variable.language.constructor.js
    - match: (?<=\.)\b(prototype)\b
      scope: variable.language.prototype.js
  literal-method:
    - match: |-
        (?x)
        (?:\b(static)\s+)?
        (?:\b(async)\s+)?
        (?:(\*)\s*)?([_$a-zA-Z][$\w]*)\s*
        (?=\([^())]*\)(?:\s|/\*.*\*/)*\{)
      captures:
        1: storage.type.js
        2: storage.type.js
        3: keyword.generator.asterisk.js
        4: entity.name.method.js
      push:
        - meta_scope: meta.method.js
        - match: (?<=\))
          pop: true
        - include: function-declaration-parameters
    - match: |-
        (?x)
        \b(?:(static)\s+)?
        (get|set)\s+
        ([_$a-zA-Z][$\w]*)\s*
        (?=\([^())]*\)(?:\s|/\*.*\*/)*\{)
      captures:
        1: storage.type.js
        2: storage.type.accessor.js
        3: entity.name.accessor.js
      push:
        - meta_scope: meta.accessor.js
        - match: (?<=\))
          pop: true
        - include: function-declaration-parameters
  literal-method-call:
    - match: |-
        (?x)
        (?:(?<=\.)|\b)
        ([A-Z][$\w]*)\s*(\.)
        ([_$a-zA-Z][$\w]*)\s*
        (\(\s*\))
      scope: meta.function-call.static.without-arguments.js
      captures:
        1: variable.other.class.js
        2: keyword.operator.accessor.js
        3: entity.name.function.js
        4: meta.group.braces.round.function.arguments.js
    - match: |-
        (?x)
        (?:(?<=\.)|\b)
        ([A-Z][$\w]*)\s*(\.)
        ([_$a-zA-Z][$\w]*)\s*
        (?=\()
      scope: meta.function-call.static.with-arguments.js
      captures:
        1: variable.other.class.js
        2: keyword.operator.accessor.js
        3: entity.name.function.js
    - match: |-
        (?x)
        (?<=\.)
        ([_$a-zA-Z][$\w]*)\s*
        (\(\s*\))
      scope: meta.function-call.method.without-arguments.js
      captures:
        1: entity.name.function.js
        2: meta.group.braces.round.function.arguments.js
    - match: |-
        (?x)
        (?<=\.)
        ([_$a-zA-Z][$\w]*)\s*
        (?=\()
      scope: meta.function-call.method.with-arguments.js
      captures:
        1: entity.name.function.js
  literal-module:
    - match: (?<!\.)\b(import|export|default|from|as)\b
      scope: keyword.operator.module.js
  literal-number:
    - match: '(?i)(?:\B[-+]|\b)0x[0-9a-f]*\.(\B|\b[0-9]+)'
      scope: invalid.illegal.numeric.hex.js
    - match: '(?:\B[-+]|\b)0[0-9]+\.(\B|\b[0-9]+)'
      scope: invalid.illegal.numeric.octal.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
        )
      scope: constant.numeric.js
    - match: '(?:\B[-+]|\b)(Infinity)\b'
      scope: constant.language.infinity.js
  literal-operators:
    - match: (?<!\.)\b(delete|in|instanceof|new|of|typeof|void|with)\b
      scope: keyword.operator.js
    - match: |-
        (?x)
        !(?!=)| # logical-not     right-to-left   right
        &&    | # logical-and     left-to-right   both
        \|\|  | # logical-or      left-to-right   both
      scope: keyword.operator.logical.js
    - match: |-
        (?x)
        =(?!=)| # assignment      right-to-left   both
      scope: keyword.operator.assignment.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
      scope: keyword.operator.assignment.augmented.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
      scope: keyword.operator.bitwise.js
    - match: |-
        (?x)
        <=   | # relational      left-to-right   both
        >=   | # relational      left-to-right   both
        <    | # relational      left-to-right   both
        >      # relational      left-to-right   both
      scope: keyword.operator.relational.js
    - match: |-
        (?x)
        ===  | # equality        left-to-right   both
        !==  | # equality        left-to-right   both
        ==   | # equality        left-to-right   both
        !=     # equality        left-to-right   both
      scope: keyword.operator.comparison.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
      scope: keyword.operator.arithmetic.js
    - match: '\?|:'
      scope: keyword.operator.ternary.js
    - match: (?<!\.)\.\.\.
      scope: keyword.operator.spread.js
    - match: \.
      scope: keyword.operator.accessor.js
  literal-property-initializer:
    - match: '\b(?:(static)\s+)?([_$a-zA-Z][$\w]*)\s*='
      scope: meta.class.property.js
      captures:
        1: storage.type.js
        2: variable.class.property.js
  literal-prototype:
    - match: '([_$a-zA-Z][$\w]*)(\.)(prototype)\b'
      scope: meta.prototype.access.js
      captures:
        1: entity.name.class.js
        2: keyword.operator.accessor.js
        3: variable.language.prototype.js
    - match: '([_$a-zA-Z][$\w]*)(\.)(prototype)\s*=\s*'
      scope: meta.prototype.declaration.js
      captures:
        1: entity.name.class.js
        2: keyword.operator.accessor.js
        3: variable.language.prototype.js
  literal-punctuation:
    - match: \;
      scope: punctuation.terminator.statement.js
    - match: ","
      scope: meta.delimiter.comma.js
  literal-regexp:
    - match: |-
        (?x)
        (?<=
          \.|\(|,|{|}|\[|;|,|<|>|<=|>=|==|!=|===|!==|\+|-|\*|%|\+\+|--|<<|>>|>>>|&|\||\^|!|~|&&|\|\||\?|:|=|\+=|-=|\*=|%=|<<=|>>=|>>>=|&=|\|=|\^=|/|/=|
          \Wnew|\Wdelete|\Wvoid|\Wtypeof|\Winstanceof|\Win|\Wdo|\Wreturn|\Wcase|\Wthrow|
          ^new|^delete|^void|^typeof|^instanceof|^in|^do|^return|^case|^throw|^
        )\s*
        (/)
        (?!/|\*|$)
      captures:
        1: punctuation.definition.string.begin.js
      push:
        - meta_scope: string.regexp.js
        - match: "(/)([gimy]*)"
          captures:
            1: punctuation.definition.string.end.js
            2: keyword.other.js
          pop: true
        - include: scope:source.regexp.js
  literal-string:
    - match: "'"
      captures:
        0: punctuation.definition.string.begin.js
      push:
        - meta_scope: string.quoted.single.js
        - match: (')|(\n)
          captures:
            1: punctuation.definition.string.end.js
            2: invalid.illegal.newline.js
          pop: true
        - include: string-content
    - match: '"'
      captures:
        0: punctuation.definition.string.begin.js
      push:
        - meta_scope: string.quoted.double.js
        - match: (")|(\n)
          captures:
            1: punctuation.definition.string.end.js
            2: invalid.illegal.newline.js
          pop: true
        - include: string-content
  literal-switch:
    - match: (?<!\.)\b(switch)\b
      captures:
        1: keyword.control.switch.js
      push:
        - meta_scope: meta.switch.js
        - match: '\}'
          captures:
            0: meta.brace.curly.js
          pop: true
        - include: round-brackets
        - match: '\{'
          captures:
            0: meta.brace.curly.js
          push:
            - match: "(?=})"
              pop: true
            - match: (?<!\.)\b(case|default)\b
              captures:
                1: keyword.control.switch.js
              push:
                - match: (?=:)
                  pop: true
                - include: expression
            - include: main
  literal-template-string:
    - match: '([a-zA-Z$_][\w$_]*)?(`)'
      captures:
        1: entity.template-string.tag.name.js
        2: punctuation.definition.template-string.begin.js
      push:
        - meta_scope: string.template-string.js
        - match: "`"
          captures:
            0: punctuation.definition.template-string.end.js
          pop: true
        - include: string-content
        - match: '\${'
          captures:
            0: punctuation.template-string.element.begin.js
          push:
            - meta_scope: entity.template-string.element.js
            - match: "}"
              captures:
                0: punctuation.template-string.element.end.js
              pop: true
            - include: expression
  literal-variable:
    - match: '[A-Z][_$\dA-Z]*\b'
      scope: variable.other.constant.js
    - match: '(\$)[$\w]+'
      scope: variable.other.dollar.js
      captures:
        1: punctuation.dollar.js
    - match: |-
        (?x)
        \b([A-Z][$\w]*)\s*(\.)
        ([_$a-zA-Z][$\w]*)
      scope: meta.property.class.js
      captures:
        1: variable.other.class.js
        2: keyword.operator.accessor.js
        3: variable.other.property.static.js
    - match: '(?<!\.)[_$a-zA-Z][$\w]*\s*(?=[\[\.])'
      scope: variable.other.object.js
      captures:
        1: variable.other.object.js
    - match: '(?<=\.)\s*[_$a-zA-Z][$\w]*'
      scope: meta.property.object.js
      captures:
        2: variable.other.property.js
    - match: '[_$a-zA-Z][$\w]*'
      scope: variable.other.readwrite.js
  round-brackets:
    - match: \(
      captures:
        0: meta.brace.round.js
      push:
        - meta_scope: meta.group.braces.round
        - match: \)
          captures:
            0: meta.brace.round.js
          pop: true
        - include: expression
  special-comments-conditional-compilation:
    - match: /\*(?=@)
      captures:
        0: punctuation.definition.comment.js
      push:
        - meta_scope: comment.block.conditional.js
        - match: \*/
          captures:
            1: keyword.control.conditional.js
            2: punctuation.definition.keyword.js
          pop: true
        - match: /\*
          scope: punctuation.definition.comment.js
        - include: main
    - match: (@)(if|elif|else|end|ifdef|endif|cc_on|set)\b
      scope: keyword.control.conditional.js
      captures:
        1: punctuation.definition.keyword.js
    - match: '(@)(_win32|_win16|_mac|_alpha|_x86|_mc680x0|_PowerPC|_jscript|_jscript_build|_jscript_version|_debug|_fast|[a-zA-Z]\w+)'
      scope: variable.other.conditional.js
      captures:
        1: punctuation.definition.variable.js
  square-brackets:
    - match: '\['
      captures:
        0: meta.brace.square.js
      push:
        - meta_scope: meta.group.braces.square
        - match: '\]'
          captures:
            0: meta.brace.square.js
          pop: true
        - include: expression
  string-content:
    - match: \\\s*\n
      scope: constant.character.escape.newline.js
    - match: '\\(x[\da-fA-F]{2}|u[\da-fA-F]{4}|.)'
      scope: constant.character.escape.js
  support:
    - match: \b(Array|Boolean|Date|Function|Map|Math|Number|Object|Promise|Proxy|RegExp|Set|String|WeakMap)\b
      scope: support.class.builtin.js
    - match: (?<!\.)\b(decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|isFinite|isNaN|parseFloat|parseInt|unescape)\b
      scope: support.function.js
    - match: \.(shift|sort|splice|unshift|pop|push|reverse)\b
      scope: support.function.mutator.js
    - match: (?<!\.)\b((Eval|Range|Reference|Syntax|Type|URI)?Error)\b
      scope: support.class.error.js
    - match: (?<!\.)\b(debugger)\b
      scope: keyword.other.js
    - match: (?<!\.)\b(document|window)\b
      scope: support.type.object.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
      scope: support.constant.dom.js
    - match: (?<!\.)\b(console)(?:(\.)(warn|info|log|error|time|timeEnd|assert|count|dir|group|groupCollapsed|groupEnd|profile|profileEnd|table|trace))?\b
      captures:
        1: support.type.object.console.js
        2: keyword.operator.accessor.js
        3: support.function.console.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
      scope: support.module.node.js
    - match: (?<!\.)\b(process)(?:(\.)(stdout|stderr|stdin|argv|execPath|execArgv|env|exitCode|version|versions|config|pid|title|arch|platform|mainModule))?\b
      captures:
        1: support.type.object.process.js
        2: keyword.operator.accessor.js
        3: 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: support.type.object.process.js
        2: keyword.operator.accessor.js
        3: support.function.process.js
    - match: (?<!\.)\b(exports|module(?:(\.)(exports|id|filename|loaded|parent|children)))?\b
      captures:
        1: support.type.object.module.js
        2: keyword.operator.accessor.js
        3: support.type.object.module.js
    - match: (?<!\.)\b(global|GLOBAL|root|__dirname|__filename)\b
      scope: support.type.object.node.js
    - match: \b(Buffer|EventEmitter|Server|Pipe|Socket|REPLServer|ReadStream|WriteStream|Stream|Inflate|Deflate|InflateRaw|DeflateRaw|GZip|GUnzip|Unzip|Zip)\b
      scope: support.class.node.js
    - match: "{{"
      push:
        - meta_scope: meta.tag.mustache.js
        - match: "}}"
          pop: true