JavaScript (Babel).sublime-syntax

%YAML 1.2
---
variables:
  dot_accessor: (?:\??\.)
  non_reserved_identifier: (?:(?!{{reserved_word}}){{identifier_name}})
  block_comment: (?:/\*{{block_comment_contents}}\*/)
  function_call_lookahead: >-
    (?x:(?=
      {{identifier_name}}
      \s*
      (?:
        <
        .*
        >
        \s*
      )?
      (?:{{dot_accessor}})?
      \(
    ))
  identifier_name: (?:{{identifier_start}}{{identifier_part}}*{{identifier_break}})
  jsx_identifier_break: (?!{{jsx_identifier_part}})
  identifier_escape: (?:\\u(?:\h{4}|\{\h+\}))
  jsdoc_block_tag: \@[^\n\t\f\v *@]+
  line_ending_ahead: (?={{nothing}}(?:/\*{{block_comment_contents}})?$)
  hex_digit: '[\h_]'
  left_expression_end_lookahead: (?!\s*[.\[\(])
  bin_digit: '[01_]'
  arrow_func_lookahead: |-
    (?x)(?:
      \s*(async\s*)?
      (?:
        {{non_reserved_identifier}}
        |\( (?: [^()]|\([^()]*\) )* \)
      )
      (?:
        \s*:
        \s*{{non_reserved_identifier}}
      )?
      \s*=>
    )
  dollar_identifier: (?:(\$){{identifier_part}}*{{identifier_break}})
  dec_exponent: '[Ee](?:[-+]|(?![-+])){{dec_digit}}*'
  reserved_word: |-
    (?x:
      break|case|catch|class|const|continue|debugger|default|delete|do|else|
      export|extends|finally|for|function|if|import|in|instanceof|new|return|
      super|switch|this|throw|try|typeof|var|void|while|with|yield|
      enum|
      null|true|false
    ){{identifier_break}}
  identifier_start: (?:[_$\p{L}\p{Nl}]|{{identifier_escape}})
  method_lookahead: |-
    (?x)(?=
      (?: get|set|async ){{identifier_break}}(?!\s*:)
      | \*
      | {{property_name}} \s* (?:\(|<)
    )
  modifier: (?:static{{identifier_break}})
  either_func_lookahead: (?:{{func_lookahead}}|{{arrow_func_lookahead}})
  func_lookahead: |-
    (?x:
      (?:async{{identifier_break}}{{nothing}})?
      function{{identifier_break}}
    )
  line_continuation_lookahead: >-
    (?x:(?=
      (?! \+\+ | -- )
      (?=
        != |
        [-+*/%><=&|^\[(;,.:?] |
        (?:in|instanceof){{identifier_break}}
      )
    ))
  jsx_identifier: '{{identifier_start}}{{jsx_identifier_part}}*{{jsx_identifier_break}}'
  jsx_identifier_part: (?:{{identifier_part}}|-)
  identifier_part: (?:[_$\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}\x{200C}\x{200D}]|{{identifier_escape}})
  oct_digit: '[0-7_]'
  block_comment_contents: (?:(?:[^*]|\*(?!/))*)
  dec_integer: (?:0|[1-9]{{dec_digit}}*)
  identifier_break: (?!{{identifier_part}})
  property_name: >-
    (?x:
      {{identifier_name}}
      | [0-9]+
      | '(?:[^\\']|\\.)*'
      | "(?:[^\\"]|\\.)*"
      | \[ .* \]
    )
  binding_pattern_lookahead: (?:{{identifier_name}}|\[|\{)
  dollar_only_identifier: (?:\${{identifier_break}})
  function_assignment_lookahead: |-
    (?x:(?=
      \s* = \s*
      {{either_func_lookahead}}
    ))
  class_element_name: |-
    (?x:
      \+?
      (?:
        \*?
        {{property_name}}
        | \#{{non_reserved_identifier}}
      )
    )
  constant_identifier: (?:[[:upper:]]{{identifier_part}}*{{identifier_break}})
  dec_digit: '[0-9_]'
  nothing: (?x:(?:\s+|{{block_comment}})*)
scope: source.js
contexts:
  bare-arrow-function-fallback:
    - meta_include_prototype: false
    - match: ''
      push:
        - immediately-pop-2
        - arrow-function-declaration

  support-property-node-module:
    - match: (?:children|exports|filename|id|loaded|parent|paths){{identifier_break}}
      scope: support.constant.node.js
      pop: true
    - match: require{{identifier_break}}
      scope: support.function.node.js
      pop: true

  variable-binding-list-top:
    - match: '{{line_ending_ahead}}'
      set:
        - match: '{{line_continuation_lookahead}}'
          set: variable-binding-top
        - include: else-pop
    - match: ','
      scope: punctuation.separator.comma.js
      push: variable-binding-top
    - include: else-pop

  branch-possible-parenthesized-arrow-function:
    - meta_include_prototype: false
    - match: ''
      push:
        - detect-parenthesized-arrow
        - parenthesized-expression

  jsx-body:
    - meta_include_prototype: false

    - match: <
      scope: punctuation.definition.tag.begin.js
      set:
        - meta_scope: meta.tag.js

        - match: /
          scope: punctuation.definition.tag.begin.js
          set:
            - jsx-expect-tag-end
            - jsx-tag-name

        - match: (?=\S)
          set:
            - jsx-body
            - jsx-tag-attributes
            - jsx-tag-name

    - include: jsx-html-escapes
    - include: jsx-interpolation
  expression-statement-end:
    - match: '{{line_ending_ahead}}'
      set:
        - match: '{{line_continuation_lookahead}}'
          set: expression-statement-end
        - include: else-pop
    - include: expression-end

  flow-type-existential:
    - match: \*
      scope: constant.language.type.existential.js
      pop: true

  import-export-from:
    - match: from{{identifier_break}}
      scope: keyword.control.import-export.js
      set: literal-string
    - include: else-pop

  expect-label:
    - meta_include_prototype: false
    - match: (?={{nothing}}{{identifier_name}})
      set:
        - match: '{{non_reserved_identifier}}'
          scope: variable.label.js
          pop: true
        - match: '{{identifier_name}}'
          scope: invalid.illegal.identifier.js variable.label.js
          pop: true
        - include: else-pop
    - include: immediately-pop

  function-parameter-binding-object-destructuring:
    - match: \{
      scope: punctuation.section.block.begin.js
      set:
        - meta_scope: meta.binding.destructuring.mapping.js
        - match: ','
          scope: punctuation.separator.parameter.function.js
        - match: \}
          scope: punctuation.section.block.end.js
          pop: true
        - include: function-parameter-binding-spread
        - match: (?={{identifier_start}}|\[|'|")
          push:
            - initializer
            - function-parameter-binding-object-alias
            - object-literal-meta-key
            - function-parameter-binding-object-key

  flow-less-than:
    - match: <
      scope: keyword.operator.comparison.js
      set: expression-begin

  styled-component-end:
    - match: \.
      scope: punctuation.accessor.dot.js
      push: styled-component-begin

    - match: (?=`)
      set:
        - match: '`'
          scope: string.quoted.other.js punctuation.definition.string.begin.js
          push:
            -   - meta_include_prototype: false
                - meta_scope: meta.string.js string.quoted.other.js
                - match: '`'
                  scope: punctuation.definition.string.end.js
                  pop: true
                - include: immediately-pop
            -   - meta_include_prototype: false
                - clear_scopes: 1
                - include: immediately-pop
            -   - meta_include_prototype: false
                - match: ''
                  set: scope:source.js.css
                  with_prototype:
                    - match: (?=`)
                      pop: true
                    - match: \$\{
                      scope: punctuation.section.interpolation.begin.js
                      push:
                        - clear_scopes: 1
                        - meta_scope: meta.interpolation.js
                        - meta_content_scope: source.js.embedded.expression
                        - match: \}
                          scope: punctuation.section.interpolation.end.js
                          pop: true
                        - match: (?=\S)
                          push: expression
                    - include: string-content
        - include: else-pop
    - include: expression-end

  support-property-ecma-array:
    - match: (?:from|isArray|of){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  import-meta:
    - meta_include_prototype: false
    - meta_scope: meta.import.js
    - include: immediately-pop

  variable-binding-name:
    - match: (?={{non_reserved_identifier}})
      set:
        -   - meta_scope: meta.binding.name.js
            - include: immediately-pop
        - literal-variable

  support-variable-console:
    # https://console.spec.whatwg.org/
    - match: console{{identifier_break}}
      scope: support.type.object.console.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set: builtin-console-properties
        - 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
        - expect-parenthesized-expression

  for-condition-contents:
    # This could be either type of for loop.
    - match: (?:const|let|var){{identifier_break}}
      scope: keyword.declaration.js
      set:
        -   - include: for-of-rest
            - match: (?=\S)
              set:
                - for-oldstyle-rest
                - variable-binding-list
                - initializer
        - variable-binding-pattern

    - match: (?=\S)
      set:
        -   - include: for-of-rest
            - match: (?=\S)
              set: for-oldstyle-rest
        - expression-end-no-in
        - expression-begin

  jsx-tag-attributes-top:
    - meta_scope: meta.tag.js
    - match: /
      scope: punctuation.definition.tag.begin.js
      set:
        -   - meta_scope: invalid.illegal.unmatched-tag.js
            - include: immediately-pop
        - jsx-expect-tag-end
        - jsx-tag-name

    - match: (?=\S)
      set:
        - jsx-tag-attributes
        - jsx-tag-name

  import-brace:
    - include: flow-type-import-type

    - meta_scope: meta.block.js
    - include: comma-separator
    - match: \}
      scope: punctuation.section.block.end.js
      pop: true
    - match: '{{identifier_name}}'
      scope: variable.other.readwrite.js
      push: import-export-alias
    - match: \*
      scope: constant.other.js
      push: import-export-alias
    - include: else-pop

  decorator-expression-begin:
    - include: decorator-name
    - include: expression-begin

  switch-meta:
    - meta_include_prototype: false
    - meta_scope: meta.switch.js
    - include: immediately-pop

  jsx-interpolation-plain:
    - match: '{'
      scope: punctuation.definition.interpolation.begin.js
      set:
        -   - meta_scope: meta.interpolation.js
            - meta_content_scope: source.js.embedded.jsx
            - match: '}'
              scope: punctuation.definition.interpolation.end.js
              pop: true
        - expression

  new-target:
    - match: \.
      scope: punctuation.accessor.dot.js
      set:
        - match: target{{identifier_break}}
          scope: variable.language.target.js
          pop: true
        - include: else-pop

    - include: else-pop

  constructor-body-expect-class-end:
    - include: property-access
    - include: else-pop

  import-list:
    - match: ','
      scope: punctuation.separator.comma.js
      push:
        - import-export-alias
        - import-item
    - include: else-pop

  for-await:
    - match: await{{identifier_break}}
      scope: keyword.control.flow.await.js
      pop: true
    - include: else-pop

  literal-string-template-custom-comments: []
  class-element-modifier:
    - match: '{{modifier}}'
      scope: storage.modifier.js
      set:
        - match: (?={{class_element_name}}|\*)
          pop: true
        - match: (?=\S)
          fail: class-element-modifier

  detect-parenthesized-arrow:
    - match: (?=:)
      pop: true
      branch_point: flow-arrow-function-return-type
      branch:
        - flow-detect-arrow-function-return-type
        - immediately-pop-2

    - match: (?==>)
      fail: parenthesized-arrow-function
    - match: (?=\S)
      pop: 2

  support-property-node-process:
    - match: (?:arch|argv|argv0|channel|config|connected|debugPort|env|execArgv|execPath|exitCode|mainModule|noDeprecation|pid|platform|ppid|release|stderr|stdin|stdout|throwDeprecation|title|traceDeprecation|version|versions){{identifier_break}}
      scope: support.constant.node.js
      pop: true
    - match: (?:abort|chdir|cpuUsage|cwd|disconnect|dlopen|emitWarning|exit|getegid|geteuid|getgit|getgroups|getuid|hasUncaughtExceptionCaptureCallback|hrtime|initGroups|kill|memoryUsage|nextTick|send|setegid|seteuid|setgid|setgroups|setuid|hasUncaughtExceptionCaptureCallback|umask|uptime){{identifier_break}}
      scope: support.function.node.js
      pop: true

  for-condition:
    - match: \(
      scope: punctuation.section.group.js
      set:
        - for-condition-end
        - for-condition-contents
    - include: else-pop

  decorator:
    - match: '@'
      scope: punctuation.definition.annotation.js
      push:
        - decorator-meta
        - decorator-expression-end
        - decorator-expression-begin

  flow-type-tuple:
    - match: \[
      scope: punctuation.section.brackets.begin.js
      set:
        - meta_scope: meta.sequence.js
        - match: \]
          scope: punctuation.section.brackets.end.js
          pop: true
        - include: flow-type-list

  variable-binding-array-destructuring:
    - match: \[
      scope: punctuation.section.brackets.begin.js
      set:
        - meta_scope: meta.binding.destructuring.sequence.js
        - match: \]
          scope: punctuation.section.brackets.end.js
          pop: true
        - include: variable-binding-spread
        - include: variable-binding-list

  import-export-alias:
    - match: as{{identifier_break}}
      scope: keyword.control.import-export.js
      set:
        - match: default{{identifier_break}}
          scope: keyword.control.import-export.js
          pop: true
        - match: '{{identifier_name}}'
          scope: variable.other.readwrite.js
          pop: true
        - include: else-pop
    - include: else-pop

  literal-variable:
    - include: special-identifier
    - include: support

    - match: (?={{identifier_name}}{{function_assignment_lookahead}})
      set:
        - function-name-meta
        - literal-variable-base

    - match: '{{constant_identifier}}(?=\s*(?:{{dot_accessor}}|\[))'
      scope: support.class.js
      pop: true

    - match: '{{function_call_lookahead}}'
      set: call-function-name

    - include: literal-variable-base

  flow-type-object:
    - match: \{\|
      scope: punctuation.section.block.begin.js
      set:
        - meta_scope: meta.type.object.exact.js
        - match: \|\}
          scope: punctuation.section.block.end.js
          pop: true
        - include: flow-type-object-contents

    - match: \{
      scope: punctuation.section.block.begin.js
      set:
        - meta_scope: meta.type.object.js
        - match: \}
          scope: punctuation.section.block.end.js
          pop: true
        - include: flow-type-object-contents

  flow-type-end:
    - include: flow-type-operators
    - include: flow-type-generic-arguments
    - include: else-pop

  builtin-console-properties:
    - match: (?:warn|info|log|error|time|timeEnd|assert|count|dir|group|groupCollapsed|groupEnd|profile|profileEnd|table|trace|timeStamp){{identifier_break}}
      scope: support.function.console.js
      pop: true
    - include: object-property

  variable-binding-spread:
    - match: \.\.\.
      scope: keyword.operator.spread.js
      push: variable-binding-pattern

  function-declaration-expect-generator-star:
    - match: \*
      scope: keyword.declaration.generator.js
      pop: true
    - include: else-pop

  for-condition-end:
    - meta_scope: meta.group.js

    - match: \)
      scope: punctuation.section.group.js
      pop: true

  export-list:
    - match: ','
      scope: punctuation.separator.comma.js
      push:
        - import-export-alias
        - export-item
    - include: else-pop

  prefix-operators:
    - match: '~'
      scope: keyword.operator.bitwise.js
    - match: '!(?!=)'
      scope: keyword.operator.logical.js
    - match: --
      scope: keyword.operator.arithmetic.js
    - match: \+\+
      scope: keyword.operator.arithmetic.js
    - match: \.\.\.
      scope: keyword.operator.spread.js
    - match: \+|\-
      scope: keyword.operator.arithmetic.js
    - match: (?:delete|typeof|void){{identifier_break}}
      scope: keyword.operator.js

  styled-components:
    - match: (?=(?:styled|css|createGlobalStyle|injectGlobal){{identifier_break}})
      set:
        - styled-component-end
        - styled-component-begin
    - match: (?=keyframes{{identifier_break}})
      set:
        - styled-component-keyframes-end
        - styled-component-begin
  main:
    - include: comments-top-level

    - match: \)|\}|\]
      scope: invalid.illegal.stray-bracket-end.js
      # Don't pop or embedding could break.

    - include: statements

  function-declaration-expect-async:
    - match: async{{identifier_break}}
      scope: keyword.declaration.async.js
      pop: true
    - include: else-pop

  function-meta:
    - meta_include_prototype: false
    - meta_scope: meta.function.js
    - include: immediately-pop

  class-field-check:
    - match: (?=[(<])
      fail: class-field
    - include: else-pop

  initializer:
    - match: '='
      scope: keyword.operator.assignment.js
      set: expression-no-comma
    - include: else-pop

  field-name:
    - match: '{{dollar_identifier}}'
      scope: meta.mapping.key.dollar.js variable.other.readwrite.js
      captures:
        1: punctuation.dollar.js
      pop: true
    - match: '{{identifier_name}}'
      scope: variable.other.readwrite.js
      pop: true
    - match: "'"
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: meta.string.js string.quoted.single.js
        - meta_content_scope: variable.other.readwrite.js
        - match: \'
          scope: punctuation.definition.string.end.js
          pop: true
        - match: \n
          scope: invalid.illegal.newline.js
          pop: true
        - include: string-content
    - match: '"'
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: meta.string.js string.quoted.double.js
        - meta_content_scope: variable.other.readwrite.js
        - match: \"
          scope: punctuation.definition.string.end.js
          pop: true
        - match: \n
          scope: invalid.illegal.newline.js
          pop: true
        - include: string-content
    - match: (#)({{identifier_name}})
      captures:
        1: punctuation.definition.variable.js
        2: variable.other.readwrite.js

    - match: (?=\[)
      push: computed-property-name

    - include: else-pop

  catch-meta:
    - meta_include_prototype: false
    - meta_scope: meta.catch.js
    - include: immediately-pop

  function-parameter-binding-array-destructuring:
    - match: \[
      scope: punctuation.section.brackets.begin.js
      set:
        - meta_scope: meta.binding.destructuring.sequence.js
        - match: \]
          scope: punctuation.section.brackets.end.js
          pop: true
        - include: function-parameter-binding-list

  literal-variable-base:
    - match: '{{dollar_only_identifier}}'
      scope: variable.other.dollar.only.js punctuation.dollar.js
      pop: true
    - match: '{{dollar_identifier}}'
      scope: variable.other.dollar.js
      captures:
        1: punctuation.dollar.js
      pop: true
    - match: '{{constant_identifier}}'
      scope: variable.other.constant.js
      pop: true
    - match: '{{identifier_name}}'
      scope: variable.other.readwrite.js
      pop: true
    - include: literal-private-variable

  flow-type-object-indexer-type:
    - match: \]
      scope: punctuation.section.brackets.end.js
      pop: true
    - include: flow-type-list

  custom-templates-default:
    - include: literal-string-template

  class-body-contents:
    - meta_scope: meta.block.js

    - match: \}
      scope: punctuation.section.block.end.js
      pop: true

    - match: \;
      scope: punctuation.terminator.statement.js

    - include: decorator

    - match: constructor{{identifier_break}}
      scope: entity.name.function.constructor.js
      push:
        - function-meta
        - function-declaration-expect-body
        - function-declaration-expect-parameters

    - include: class-element-modifiers

    - match: |-
        (?x)(?=
          \#? {{identifier_name}}
          \s* = \s*
          {{either_func_lookahead}}
        )
      push:
        - initializer
        - function-name-meta
        - literal-variable-base

    - match: (?=(?:get|set|async){{identifier_break}})
      branch_point: prefixed-method
      branch:
        - prefixed-method
        - class-element

    - match: (?=\*)
      push: method-declaration

    - match: (?={{class_element_name}})
      push: class-element

  object-literal:
    - match: \{
      scope: punctuation.section.block.begin.js
      set: object-literal-contents

  expression-end-no-in:
    - match: (?=in{{identifier_break}})
      pop: true
    - include: expression-end

  special-name:
    - match: true{{identifier_break}}
      scope: constant.language.boolean.true.js
      pop: true
    - match: false{{identifier_break}}
      scope: constant.language.boolean.false.js
      pop: true
    - match: null{{identifier_break}}
      scope: constant.language.null.js
      pop: true
    - match: super{{identifier_break}}
      scope: variable.language.super.js
      pop: true
    - match: this{{identifier_break}}
      scope: variable.language.this.js
      pop: true

  import-check-branch:
    - match: (?=[.(]) # Recovery for import expressions
      fail: import-statement
    - include: else-pop

  function-parameter-binding-name:
    - 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

  support-property-ecma-number:
    - match: (?:EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY){{identifier_break}}
      scope: support.constant.builtin.js
      pop: true
    - match: (?:isFinite|isInteger|isNaN|isSafeInteger|NaN|parseFloat|parseInt){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  immediately-pop-2:
    - meta_include_prototype: false
    - match: ''
      pop: 2

  support-property-ecma-promise:
    - match: (?:all|race|reject|resolve|allSettled|any){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  decorator-meta:
    - meta_include_prototype: false
    - meta_scope: meta.annotation.js
    - include: immediately-pop

  decorator-name:
    - match: '{{identifier_name}}{{left_expression_end_lookahead}}'
      scope: variable.annotation.js
      pop: true

  function-parameter:
    - match: ''
      set:
        - initializer
        - function-parameter-binding-pattern

  expression:
    - meta_include_prototype: false
    - match: ''
      set: [expression-end, expression-begin]

  parenthesized-arrow-function-fallback:
    - meta_include_prototype: false
    - match: ''
      push:
        - immediately-pop-2
        - arrow-function-declaration

  flow-type-meta:
    - meta_scope: meta.flow-type.js
    - include: immediately-pop

  flow-type-module-body:
    - match: \{
      scope: punctuation.section.block.begin.js
      set: flow-type-module-contents
    - include: else-pop

  function-declaration-expect-function-keyword:
    - match: function{{identifier_break}}
      scope: keyword.declaration.function.js
      pop: true
    - include: else-pop

  expect-semicolon:
    - match: \;
      scope: punctuation.terminator.statement.js
      pop: true
    - include: else-pop

  class-field:
    - match: ''
      set:
        - initializer
        - flow-type-annotation
        - class-field-check
        - field-name

  flow-type-annotation:
    - match: ':'
      scope: punctuation.separator.type.js
      set:
        - flow-type-meta
        - flow-type
    - match: (?!\s*(?:$|:|//|/\*))
      pop: true

  constructor:
    - match: new{{identifier_break}}
      scope: keyword.operator.word.new.js
      set:
        - match: (?=\s*\.)
          set: new-target
        - match: (?=\s*\S)
          set:
            - constructor-meta
            - constructor-body-expect-arguments
            - constructor-body-expect-class-end
            - constructor-body-expect-class-begin

  function-block:
    - match: \{
      scope: punctuation.section.block.begin.js
      set:
        - meta_scope: meta.block.js
        - match: \}
          scope: punctuation.section.block.end.js
          pop: true
        - include: statements

  flow-type-object-value:
    - match: (\?)?(:)
      captures:
        1: storage.modifier.optional.js
        2: punctuation.separator.key-value.js
      set: flow-type
    - include: else-pop

  restricted-production:
    - meta_include_prototype: false
    - match: '{{line_ending_ahead}}'
      pop: true
    - match: ''
      set: expression-statement

  variable-binding-object-alias:
    - match: ':'
      scope: punctuation.separator.key-value.js
      set: variable-binding-pattern
    - include: else-pop

  flow-type-module-meta:
    - meta_scope: meta.module.js
    - include: immediately-pop

  parenthesized-expression:
    - match: \(
      scope: punctuation.section.group.begin.js
      set:
        - meta_scope: meta.group.js
        - match: \)
          scope: punctuation.section.group.end.js
          pop: true
        - match: (?=:)
          push: flow-type-annotation
        - match: (?=\S)
          push: expression

  support-property-ecma-atomics:
    - match: (?:and|add|compareExchange|exchange|isLockFree|load|or|store|sub|wait|wake|xor){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  ternary-operator-expect-colon:
    - match: ':'
      scope: keyword.operator.ternary.js
      set: expression-no-comma
    - include: else-pop

  switch-block:
    - match: \{
      scope: punctuation.section.block.begin.js
      set: switch-block-contents
    - include: else-pop

  jsx-expect-tag-end:
    - meta_content_scope: meta.tag.js
    - match: '>'
      scope: meta.tag.js punctuation.definition.tag.end.js
      pop: true
    - include: else-pop

  support-property-ecma-symbol:
    - match: (?:asyncIterator|hasInstance|isConcatSpreadable|iterator|match|replace|search|species|split|toPrimitive|toStringTag|unscopeables){{identifier_break}}
      scope: support.constant.builtin.js
      pop: true
    - match: (?:for|keyFor){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  inherited-class-name:
    - match: '{{non_reserved_identifier}}{{left_expression_end_lookahead}}'
      scope: entity.other.inherited-class.js
      pop: true

  async-arrow-function:
    - match: async{{identifier_break}}
      scope: keyword.declaration.async.js
      set:
        - function-meta
        - arrow-function-expect-body
        - arrow-function-expect-arrow-or-fail-async
        - arrow-function-expect-parameters

  jsdoc-block-tag:
    - match: '{{jsdoc_block_tag}}'
      scope: entity.other.attribute-name.documentation.js
      pop: 1
    - match: (?=\S)|$
      pop: 1

  literal-private-variable:
    - match: (#)({{identifier_name}})
      captures:
        1: punctuation.definition.variable.js
        2: variable.other.readwrite.js
      pop: true

  flow-detect-arrow-after-return-type:
    - match: (?==>)
      fail: parenthesized-arrow-function
    - match: (?=\S)
      fail: flow-arrow-function-return-type

  expect-case-colon:
    - match: ':'
      scope: punctuation.separator.js
      pop: true
    - include: else-pop

  prefixed-object-literal-method:
    - match: (?:get|set){{identifier_break}}
      scope: storage.type.accessor.js
      set:
        - meta_scope: meta.function.js
        - match: (?={{class_element_name}})
          set: method-declaration
        - match: (?=\S)
          fail: prefixed-object-literal-method
    - match: (?:async){{identifier_break}}
      scope: keyword.declaration.async.js
      set:
        - meta_scope: meta.function.js
        - match: (?=\*|{{class_element_name}})
          set: method-declaration
        - match: (?=\S)
          fail: prefixed-object-literal-method

  call-function-meta:
    - meta_include_prototype: false
    - meta_scope: meta.function-call.js
    - include: else-pop

  left-expression-end:
    - include: expression-break

    - match: (?=`)
      push: literal-string-template

    - match: (?=(?:{{dot_accessor}})?\()
      push: function-call-arguments

    - include: property-access

    - include: else-pop

  import-expression-end:
    - match: (?=\()
      set: function-call-arguments
    - match: '{{dot_accessor}}'
      scope: punctuation.accessor.js
      set:
        - match: meta{{identifier_break}}
          scope: variable.language.import.js
          pop: true
        - include: object-property
    - include: else-pop
  flow-type-special:
    - match: any{{identifier_break}}
      scope: support.type.any.js
      pop: true

    - match: mixed{{identifier_break}}
      scope: support.type.mixed.js
      pop: true

  jsx-interpolation:
    - match: (?={/\*)
      branch_point: jsx-interpolation-comment
      branch:
        - jsx-interpolation-comment
        - jsx-interpolation-plain
    - match: (?={)
      push: jsx-interpolation-plain

  variable-declaration:
    - match: (?:const|let|var){{identifier_break}}
      scope: keyword.declaration.js
      set:
        - expect-semicolon
        - variable-binding-list-top
        - variable-binding-top

  support-variable-dom:
    - match: XMLHttpRequest{{identifier_break}}
      scope: support.class.dom.js
      pop: true
    - match: (?:document|window|navigator){{identifier_break}}
      scope: support.type.object.dom.js
      pop: true
    - match: (?:clearTimeout|clearInterval|setTimeout|setInterval){{identifier_break}}
      scope: support.function.dom.js
      pop: true

  object-literal-element:
    - match: '{{identifier_name}}(?=\s*(?:[},]|$|//|/\*))'
      scope: variable.other.readwrite.js
      pop: true
    - match: (?=\S)
      pop: true
      branch_point: object-literal-property
      branch:
        - object-literal-property
        - method-declaration

  support-variable-ecma:
    - match: Array{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-array
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: ArrayBuffer{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-arraybuffer
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Atomics{{identifier_break}}
      scope: support.constant.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-atomics
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: BigInt{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-bigint
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Date{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-date
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: JSON{{identifier_break}}
      scope: support.constant.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-json
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Math{{identifier_break}}
      scope: support.constant.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-math
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Number{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-number
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Object{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-object
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Promise{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-promise
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Proxy{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-proxy
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Reflect{{identifier_break}}
      scope: support.constant.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-reflect
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: String{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-string
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: Symbol{{identifier_break}}
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-symbol
            - include: object-property
            - include: else-pop
        - include: else-pop

    - match: |-
        (?x:
          (?:
            BigInt64|
            BigUint64|
            Float(?:32|64)|
            Int(?:8|16|32)|
            Uint(?:8|16|32|32Clamped)
          )
          Array{{identifier_break}}
        )
      scope: support.class.builtin.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-ecma-typedarray
            - include: object-property
            - include: else-pop
        - include: else-pop

    # Classes with no constructor properties
    - match: (?:Boolean|DataView|Function|Map|RegExp|Set|WeakMap|WeakSet){{identifier_break}}
      scope: support.class.builtin.js
      pop: true
    - match: (?:Eval|Range|Reference|Syntax|Type|URI)?Error{{identifier_break}}
      scope: support.class.builtin.js
      pop: true

    - match: (?:eval|isFinite|isNaN|parseFloat|parseInt|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent){{identifier_break}}
      scope: support.function.js
      pop: true

  support-property-ecma-date:
    - match: (?:now|parse|UTC){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  literal-string-template-custom-lookahead: []
  object-literal-meta-key:
    - meta_scope: meta.mapping.key.js
    - include: else-pop

  support-property:
    - include: support-property-ecma

  arrow-function-expect-parameters:
    - match: (?={{identifier_start}})
      set:
        - clear_scopes: 1
        - meta_scope: meta.function.parameters.js
        - match: '{{identifier_name}}'
          scope: variable.parameter.function.js
          pop: true
    - include: function-declaration-parameters
    - include: else-pop

  object-property-name:
    - match: '{{identifier_name}}'
      scope: string.unquoted.js
      pop: true

    - match: (?=\[)
      set: computed-property-name

    - include: literal-string
    - include: literal-number

    - match: '{{identifier_name}}'
      pop: true

    - include: else-pop

  expect-parenthesized-expression:
    - include: parenthesized-expression
    - include: else-pop

  regular-function:
    - match: (?={{func_lookahead}})
      set: function-declaration

  variable-binding-top:
    - match: (?={{binding_pattern_lookahead}})
      set:
        - initializer
        - variable-binding-pattern
    - include: else-pop

  special-identifier:
    # These are ordinary identifiers, not reserved words
    - match: arguments{{identifier_break}}
      scope: variable.language.arguments.js
      pop: true
    - match: globalThis{{identifier_break}}
      scope: variable.language.global.js
      pop: true
    - match: undefined{{identifier_break}}
      scope: constant.language.undefined.js
      pop: true
    - match: NaN{{identifier_break}}
      scope: constant.language.nan.js
      pop: true
    - match: Infinity{{identifier_break}}
      scope: constant.language.infinity.js
      pop: true

  flow-type-annotation-optional:
    - match: \?(?=:)
      scope: storage.modifier.optional.js
    - include: flow-type-annotation

  variable-binding-list:
    - include: comma-separator
    - match: (?={{binding_pattern_lookahead}})
      push:
        - initializer
        - variable-binding-pattern
    - include: else-pop

  object-literal-contents:
    - meta_scope: meta.mapping.js

    - match: \}
      scope: punctuation.section.block.end.js
      pop: true

    - match: \.\.\.
      scope: keyword.operator.spread.js
      push: expression-no-comma

    - match: >-
        (?x)(?=
          {{property_name}}\s*:\s*
          {{either_func_lookahead}}
        )
      push:
        - object-literal-meta-key
        - method-name

    - match: (?=\*)
      push: method-declaration

    - match: (?=(?:get|set|async){{identifier_break}})
      branch_point: prefixed-object-literal-method
      branch:
        - prefixed-object-literal-method
        - object-literal-element

    - match: (?={{property_name}})
      push: object-literal-element

    - include: comma-separator

    - match: ':'
      scope: punctuation.separator.key-value.js
      push: expression-no-comma

    # If there's any garbage, parse it as an expression
    # so that close braces won't break things.
    - match: (?=\S)
      push: expression-no-comma

  jsx-tag-name-component:
    - match: '{{jsx_identifier}}'
      scope: entity.name.tag.js
      set:
        - match: '[:.]'
          scope: punctuation.accessor.js
          set: jsx-tag-name
        - include: else-pop
    - include: else-pop

  constructor-body-expect-class-begin:
    - match: (?={{non_reserved_identifier}}\s*\()
      set:
        - include: support
        - match: '{{dollar_only_identifier}}'
          scope: variable.type.dollar.only.js punctuation.dollar.js
          pop: true
        - match: '{{dollar_identifier}}'
          scope: variable.type.dollar.js
          captures:
            1: punctuation.dollar.js
          pop: true
        - match: '{{identifier_name}}'
          scope: variable.type.js
          pop: true
        - include: else-pop

    - include: expression-begin

  support-property-ecma-string:
    - match: (?:fromCharCode|fromCodePoint|raw){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  flow-arrow-function-return-type-annotation:
    - match: ':'
      scope: punctuation.separator.type.js
      set:
        - flow-type-meta
        - flow-type-end-no-arrow
        - flow-type-begin
    - match: (?!\s*(?:$|:|//|/\*))
      pop: true

  arrow-function-expect-arrow-or-fail-async:
    - match: =>
      scope: keyword.declaration.function.arrow.js
      pop: true
    - match: (?=\S)
      fail: async-arrow-function

  call-method-meta:
    - meta_include_prototype: false
    - meta_scope: meta.function-call.method.js
    - include: else-pop

  jsx-tag-name:
    - meta_include_prototype: false
    - match: ''
      set:
        -   - clear_scopes: 1
            - meta_scope: meta.tag.name.js
            - include: immediately-pop
        - jsx-tag-name-component

  ternary-operator:
    - match: \?(?=[^.]|\.[0-9])
      scope: keyword.operator.ternary.js
      set:
        - ternary-operator-expect-colon
        - expression-no-comma

  tagged-template:
    - include: literal-string-template-custom-comments
    - include: literal-string-template-custom-tags
    - include: styled-components

    - match: '{{identifier_name}}(?=\s*`)'
      scope: variable.function.tagged-template.js
      pop: true

  arrow-function-expect-arrow:
    - match: =>
      scope: keyword.declaration.function.arrow.js
      pop: true
    - include: else-pop

  literal-string-template-custom-tags: []
  flow-type-typeof:
    - match: typeof{{identifier_break}}
      scope: keyword.operator.js
      set:
        - left-expression-end
        - expression-begin

  flow-detect-arrow-function-return-type:
    - match: ''
      push:
        - flow-detect-arrow-after-return-type
        - flow-arrow-function-return-type-annotation

  statements:
    - match: \)|\}|\]
      scope: invalid.illegal.stray-bracket-end.js
      pop: true

    - match: (?=\S)
      push: statement

  flow-type-literal:
    - match: true{{identifier_break}}
      scope: constant.language.boolean.true.js
      pop: true
    - match: false{{identifier_break}}
      scope: constant.language.boolean.false.js
      pop: true
    - match: (?=\d)
      set:
        -   - match: '{{identifier_part}}+'
              scope: invalid.illegal.js
            - include: immediately-pop
        - literal-number
    - match: (?=['"])
      set: literal-string

  detect-bare-arrow:
    - match: (?==>)
      fail: bare-arrow-function
    - match: (?=\S)
      pop: 2

  flow-type-object-indexer-label:
    - match: ({{non_reserved_identifier}})\s*(:)
      captures:
        1: meta.object-literal.key.js
        2: punctuation.separator.key-value.js
      pop: true
    - include: else-pop

  jsx-tag:
    - match: <
      scope: punctuation.definition.tag.begin.js
      set:
        - jsx-meta
        - jsx-tag-attributes-top

  function-declaration:
    - match: ''
      set:
        - function-meta
        - function-declaration-expect-body
        - flow-type-annotation
        - function-declaration-expect-parameters
        - flow-type-generic-parameters
        - function-declaration-expect-name
        - function-declaration-expect-generator-star
        - function-declaration-expect-function-keyword
        - function-declaration-expect-async

    - match: extends{{identifier_break}}
      scope: storage.modifier.extends.js
      set:
        - inherited-class-expression-end
        - inherited-class-expression-begin
    - include: else-pop

  support-property-ecma-typedarray:
    - match: (?:BYTES_PER_ELEMENT){{identifier_break}}
      scope: support.constant.builtin.js
      pop: true

  support-property-ecma-bigint:
    - match: (?:asUintN|asIntN){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  export-item:
    - match: \{
      scope: punctuation.section.block.begin.js
      set: export-brace
    - match: '{{non_reserved_identifier}}'
      scope: variable.other.readwrite.js
      pop: true
    - match: \*
      scope: constant.other.js
      pop: true
    - include: else-pop

  literal-string:
    - match: "'"
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: meta.string.js string.quoted.single.js
        - match: \'
          scope: punctuation.definition.string.end.js
          pop: true
        - match: \n
          scope: invalid.illegal.newline.js
          pop: true
        - include: string-content
    - match: '"'
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: meta.string.js string.quoted.double.js
        - match: \"
          scope: punctuation.definition.string.end.js
          pop: true
        - match: \n
          scope: invalid.illegal.newline.js
          pop: true
        - include: string-content

  flow-type-list:
    - include: comma-separator
    - match: (?=\S)
      push: flow-type

  immediately-pop:
    - match: ''
      pop: true

  export-meta:
    - meta_include_prototype: false
    - meta_scope: meta.export.js
    - include: immediately-pop

  for-meta:
    - meta_include_prototype: false
    - meta_scope: meta.for.js
    - include: immediately-pop

  jsx-attribute-value:
    - include: jsx-tag
    - include: jsx-interpolation

    - match: "'"
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: string.quoted.single.js
        - match: \'
          scope: punctuation.definition.string.end.js
          pop: true
        - include: jsx-html-escapes
    - match: '"'
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: string.quoted.double.js
        - match: \"
          scope: punctuation.definition.string.end.js
          pop: true
        - include: jsx-html-escapes

    - include: else-pop

  styled-component-keyframes-end:
    - match: (?=`)
      push:
        - match: '`'
          scope: string.quoted.other.js punctuation.definition.string.begin.js
          push:
            -   - meta_include_prototype: false
                - meta_scope: meta.string.js string.quoted.other.js
                - match: '`'
                  scope: punctuation.definition.string.end.js
                  pop: true
                - include: immediately-pop
            -   - meta_include_prototype: false
                - clear_scopes: 1
                - include: immediately-pop
            -   - meta_include_prototype: false
                - match: ''
                  set: scope:source.js.css#at-keyframe-block-content
                  with_prototype:
                    - match: (?=`)
                      pop: true
                    - match: \$\{
                      scope: punctuation.section.interpolation.begin.js
                      push:
                        - clear_scopes: 1
                        - meta_scope: meta.interpolation.js
                        - meta_content_scope: source.js.embedded.expression
                        - match: \}
                          scope: punctuation.section.interpolation.end.js
                          pop: true
                        - match: (?=\S)
                          push: expression
                    - include: string-content
        - include: else-pop
    - include: else-pop

  block-scope:
    - include: block
    - include: else-pop

  styled-component-begin:
    - match: '{{non_reserved_identifier}}(?=\s*\()'
      scope: variable.function.js
      pop: true

    - match: '{{non_reserved_identifier}}(?=\s*`)'
      scope: variable.function.tagged-template.js
      pop: true

    - match: '{{non_reserved_identifier}}'
      scope: variable.other.readwrite.js
      pop: true

    - include: else-pop
  statement:
    - include: flow-type-declare
    - include: flow-type-alias

    - match: \;
      scope: punctuation.terminator.statement.empty.js
      pop: true

    - include: import-statement-or-import-meta
    - include: export-statement
    - include: conditional
    - include: block
    - include: label
    - include: variable-declaration

    - 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: class
    - include: regular-function

    - include: decorator

    - include: expression-statement

  prototype:
    - include: comments

  flow-type-primitive:
    - match: boolean{{identifier_break}}
      scope: support.type.primitive.boolean.js
      pop: true

    - match: number{{identifier_break}}
      scope: support.type.primitive.number.js
      pop: true

    - match: string{{identifier_break}}
      scope: support.type.primitive.string.js
      pop: true

    - match: null{{identifier_break}}
      scope: support.type.primitive.null.js
      pop: true

    - match: void{{identifier_break}}
      scope: support.type.primitive.void.js
      pop: true

  with-meta:
    - meta_include_prototype: false
    - meta_scope: meta.with.js
    - include: immediately-pop

  array-literal:
    - match: \[
      scope: punctuation.section.brackets.begin.js
      set:
        - meta_scope: meta.sequence.js
        - match: \]
          scope: punctuation.section.brackets.end.js
          pop: true
        - include: expression-list

  flow-type-import-type:
    - match: type{{identifier_break}}
      scope: keyword.declaration.js

    - match: typeof{{identifier_break}}
      scope: keyword.operator.js

  method-name:
    - match: '{{dollar_identifier}}'
      scope: meta.mapping.key.dollar.js entity.name.function.js
      captures:
        1: punctuation.dollar.js
      pop: true
    - match: '{{identifier_name}}'
      scope: entity.name.function.js
      pop: true
    - match: (#){{identifier_name}}
      scope: entity.name.function.js
      captures:
        1: punctuation.definition.js
      pop: true
    - match: "'"
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: meta.string.js string.quoted.single.js
        - meta_content_scope: entity.name.function.js
        - match: \'
          scope: punctuation.definition.string.end.js
          pop: true
        - match: \n
          scope: invalid.illegal.newline.js
          pop: true
        - include: string-content
    - match: '"'
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: meta.string.js string.quoted.double.js
        - meta_content_scope: entity.name.function.js
        - match: \"
          scope: punctuation.definition.string.end.js
          pop: true
        - match: \n
          scope: invalid.illegal.newline.js
          pop: true
        - include: string-content

    - match: (?=\[)
      push: computed-property-name

    - include: else-pop

  expression-end-no-comma:
    - match: (?=,)
      pop: true
    - include: expression-end

  function-declaration-expect-parameters:
    - include: function-declaration-parameters
    - include: else-pop

  regexp:
    - meta_include_prototype: false
    - meta_scope: meta.string.js string.regexp.js
    - match: /
      scope: punctuation.definition.string.end.js
      set:
        - meta_include_prototype: false
        - meta_content_scope: meta.string.js string.regexp.js
        - match: '[gimyus]'
          scope: keyword.other.js
        - match: '[A-Za-z0-9]'   # Ignore unknown flags for future-compatibility
        - include: immediately-pop
    - match: (?=.|\n)
      push:
        - meta_include_prototype: false
        - match: (?=/)
          pop: true
        - include: scope:source.regexp.js

  support-property-ecma-json:
    - match: (?:parse|stringify){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  flow-type-object-contents:
    - include: comma-separator
    - match: ;
      scope: punctuation.separator.semicolon.js
    - match: '{{method_lookahead}}'
      push: method-declaration
    - match: \+
      scope: storage.modifier.variance.js
    - match: '{{non_reserved_identifier}}'
      scope: meta.object-literal.key.js
      push: flow-type-object-value
    - match: \[
      scope: punctuation.section.brackets.begin.js
      push:
        - flow-type-object-value
        - flow-type-object-indexer-type
        - flow-type-object-indexer-label

  string-content:
    - match: \\\n
      scope: constant.character.escape.newline.js
    - match: \\(?:x\h\h|u\h\h\h\h|.)
      scope: constant.character.escape.js

  expression-statement:
    - match: (?=\S)
      set:
        - expect-semicolon
        - expression-statement-end
        - expression-begin

  object-property:
    - include: support-property

    - match: (?=\#?{{identifier_name}}{{function_assignment_lookahead}})
      set:
        - function-name-meta
        - object-property-base

    - match: (?=#?{{identifier_name}}\s*(?:{{dot_accessor}})?\()
      set: call-method-name

    - include: object-property-base
    - include: else-pop

  call-function-name:
    - match: '{{dollar_only_identifier}}'
      scope: variable.function.js variable.other.dollar.only.js punctuation.dollar.js
      pop: true
    - match: '{{identifier_name}}'
      scope: variable.function.js
      pop: true
    - include: else-pop

  comments:
    - match: /\*\*(?!/)
      scope: punctuation.definition.comment.begin.js
      push:
        - jsdoc-comment
        - jsdoc-block-tag
    - match: /\*
      scope: punctuation.definition.comment.begin.js
      push:
        - meta_include_prototype: false
        - meta_scope: comment.block.js
        - match: \*/
          scope: punctuation.definition.comment.end.js
          pop: true
    - match: //
      scope: punctuation.definition.comment.js
      push:
        - meta_include_prototype: false
        - meta_scope: comment.line.double-slash.js
        - match: \n
          pop: true

  export-extended:
    - include: flow-type-export-type

    - include: variable-declaration
    - include: class
    - include: regular-function

    - match: default{{identifier_break}}
      scope: keyword.control.import-export.js
      set:
        - include: class
        - include: regular-function
        - match: (?=\S)
          set: expression-statement

    - match: (?=\S)
      set:
        - expect-semicolon
        - import-export-from
        - export-list
        - import-export-alias
        - export-item

  prefixed-method:
    - match: (?:get|set){{identifier_break}}
      scope: storage.type.accessor.js
      set:
        - meta_scope: meta.function.js
        - match: (?={{class_element_name}})
          set: method-declaration
        - match: (?=\S)
          fail: prefixed-method
    - match: (?:async){{identifier_break}}
      scope: keyword.declaration.async.js
      set:
        - meta_scope: meta.function.js
        - match: (?=\*|{{class_element_name}})
          set: method-declaration
        - match: (?=\S)
          fail: prefixed-method

  comma-separator:
    - match: ','
      scope: punctuation.separator.comma.js

  variable-binding-object-key:
    - match: '{{identifier_name}}(?=\s*:)'
      scope: string.unquoted.js
      pop: true
    - match: '{{identifier_name}}(?=\s*:)'
      pop: true
    - include: literal-string
    - include: computed-property-name
    - include: variable-binding-name
    - include: else-pop

  yield-expression:
    - match: yield{{identifier_break}}
      scope: keyword.control.flow.yield.js
      set:
        - match: $
          pop: true
        - match: \*
          scope: keyword.generator.asterisk.js
          set: expression-begin
        - match: (?=\S)
          set: expression-begin

  regexp-complete:
    - match: /
      scope: punctuation.definition.string.begin.js
      set: regexp

  finally-meta:
    - meta_include_prototype: false
    - meta_scope: meta.finally.js
    - include: immediately-pop

  constructor-body-expect-arguments:
    - include: function-call-arguments
    - include: else-pop

  conditional-meta:
    - meta_include_prototype: false
    - meta_scope: meta.conditional.js
    - include: immediately-pop

  function-declaration-parameters:
    - match: \(
      scope: punctuation.section.group.begin.js
      set:
        - clear_scopes: 1
        - meta_scope: meta.function.parameters.js
        - match: \)
          scope: punctuation.section.group.end.js
          pop: true
        - include: function-parameter-binding-list

  while-meta:
    - meta_include_prototype: false
    - meta_scope: meta.while.js
    - include: immediately-pop

  class-body:
    - match: \{
      scope: punctuation.section.block.begin.js
      set: class-body-contents

    - include: else-pop

  expression-end:
    - include: flow-function-type-arguments-or-less-than

    - include: postfix-operators
    - include: binary-operators
    - include: ternary-operator

    - include: left-expression-end

  branch-possible-bare-arrow-function:
    - meta_include_prototype: false
    - match: ''
      push:
        - detect-bare-arrow
        - literal-variable

  flow-type-operators:
    - match: \|(?!\})
      scope: keyword.operator.type.union.js
      push: flow-type-begin
    - match: \&
      scope: keyword.operator.type.intersection.js
      push: flow-type-begin
    - match: =>
      scope: keyword.declaration.function.arrow.js
      push: flow-type-begin
    - match: \?
      scope: storage.modifier.maybe.js
      push: flow-type-begin
    - match: \.
      scope: punctuation.separator.accessor.js
      push: flow-type-begin

    - match: \[\]
      scope: storage.modifier.array.js
    - match: '%checks{{identifier_break}}'
      scope: storage.modifier.checks.js

  class-element:
    - match: ''
      pop: true
      branch_point: class-field
      branch:
        - class-field
        - method-declaration

  support-property-ecma-object:
    - match: (?:assign|create|defineProperties|defineProperty|entries|freeze|fromEntries|getOwnPropertyDescriptors?|getOwnPropertyNames|getOwnPropertySymbols|getPrototypeOf|is|isExtensible|isFrozen|isSealed|keys|preventExtensions|seal|setPrototypeOf|values){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  literal-number:
    # floats
    - match: |-
        (?x:
          # 1., 1.1, 1.1e1, 1.1e-1, 1.e1, 1.e-1 | 1e1, 1e-1
          {{dec_integer}} (?: (\.) {{dec_digit}}* (?:{{dec_exponent}})? | {{dec_exponent}} )
          # .1, .1e1, .1e-1
          | (\.) {{dec_digit}}+ (?:{{dec_exponent}})?
        ){{identifier_break}}
      scope: meta.number.float.decimal.js constant.numeric.value.js
      captures:
        1: punctuation.separator.decimal.js
        2: punctuation.separator.decimal.js
      pop: true

    # integers
    - match: (0)({{dec_digit}}+){{identifier_break}}
      scope: meta.number.integer.octal.js
      captures:
        1: constant.numeric.base.js invalid.deprecated.numeric.octal.js
        2: constant.numeric.value.js invalid.deprecated.numeric.octal.js
      pop: true

    - match: (0[Xx])({{hex_digit}}*)(n)?{{identifier_break}}
      scope: meta.number.integer.hexadecimal.js
      captures:
        1: constant.numeric.base.js
        2: constant.numeric.value.js
        3: constant.numeric.suffix.js
      pop: true

    - match: (0[Oo])({{oct_digit}}*)(n)?{{identifier_break}}
      scope: meta.number.integer.octal.js
      captures:
        1: constant.numeric.base.js
        2: constant.numeric.value.js
        3: constant.numeric.suffix.js
      pop: true

    - match: (0[Bb])({{bin_digit}}*)(n)?{{identifier_break}}
      scope: meta.number.integer.binary.js
      captures:
        1: constant.numeric.base.js
        2: constant.numeric.value.js
        3: constant.numeric.suffix.js
      pop: true

    - match: ({{dec_integer}})(n|(?!\.)){{identifier_break}}
      scope: meta.number.integer.decimal.js
      captures:
        1: constant.numeric.value.js
        2: constant.numeric.suffix.js
      pop: true

    # illegal numbers
    - match: 0[Xx]{{identifier_part}}+
      scope: invalid.illegal.numeric.hexadecimal.js
      pop: true

    - match: 0[Bb]{{identifier_part}}+
      scope: invalid.illegal.numeric.binary.js
      pop: true

    - match: 0{{identifier_part}}+
      scope: invalid.illegal.numeric.octal.js
      pop: true

    - match: '[1-9]{{identifier_part}}+(?:\.{{identifier_part}}*)?'
      scope: invalid.illegal.numeric.decimal.js
      pop: true

  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

  support-property-ecma-arraybuffer:
    - match: isView{{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  support-property-ecma-proxy:
    - match: revocable{{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  flow-function-type-arguments-or-less-than:
    - match: (?=<(?![<=]))
      branch_point: flow-function-type-arguments
      branch:
        - flow-function-type-arguments
        - flow-less-than

  function-parameter-binding-pattern:
    - match: ''
      set:
        -   - include: flow-type-annotation-optional
        -   - include: function-parameter-binding-name
            - include: function-parameter-binding-array-destructuring
            - include: function-parameter-binding-object-destructuring
            - include: else-pop

  method-declaration:
    - meta_include_prototype: false
    - match: ''
      set:
        - function-meta
        - function-declaration-expect-body
        - flow-type-annotation
        - function-declaration-expect-parameters
        - flow-type-generic-parameters
        - method-name
        - method-declaration-expect-asterisk

  flow-type-export-type:
    - match: type{{identifier_break}}(?=\s*\{)
      scope: keyword.declaration.js
      set: export-item
    - include: flow-type-alias

  class-element-modifiers:
    - match: (?={{modifier}})
      branch_point: class-element-modifier
      branch:
        - class-element-modifier
        - class-element

  expression-list:
    - include: expression-break
    - include: comma-separator
    - match: (?=\S)
      push: expression-no-comma

  jsx-tag-attributes:
    - meta_scope: meta.tag.attributes.js

    - match: '>'
      scope: punctuation.definition.tag.end.js
      set: jsx-body

    - match: /
      scope: punctuation.definition.tag.end.js
      set: jsx-expect-tag-end

    - include: jsx-interpolation

    - match: '{{jsx_identifier}}'
      scope: entity.other.attribute-name.js

    - match: '='
      scope: punctuation.separator.key-value.js
      push: jsx-attribute-value

  expression-break:
    - match: (?=[;})\]])
      pop: true

  arrow-function-expect-body:
    - include: function-block
    - match: (?=\S)
      set:
        - block-meta
        - expression-no-comma

  support:
    - include: support-variable-ecma
    - include: support-variable-console
    - include: support-variable-dom
    - include: support-variable-node

  constructor-meta:
    - meta_include_prototype: false
    - meta_scope: meta.function-call.constructor.js
    - include: immediately-pop

  support-property-ecma-math:
    - match: (?:E|LN10|LN2|LOG10E|LOG2E|PI|SQRT1_2|SQRT2){{identifier_break}}
      scope: support.constant.builtin.js
      pop: true
    - match: (?:abs|acos|acosh|asin|asin|atan|atanh|atan2|cbrt|ceil|clz32|cos|cosh|exp|expm1|floor|fround|hypot|imul|log|log1p|log10|log2|max|min|pow|random|round|sign|sin|sinh|sqrt|tan|tanh|trunc){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  call-method-name:
    - include: support-property
    - match: '{{identifier_name}}'
      scope: variable.function.js
      pop: true
    - match: (#){{identifier_name}}
      scope: variable.function.js
      captures:
        1: punctuation.definition.js
      pop: true
    - include: else-pop

  switch-block-contents:
    - meta_scope: meta.block.js

    - match: \}
      scope: punctuation.section.block.end.js
      pop: true

    - match: case{{identifier_break}}
      scope: keyword.control.conditional.case.js
      push:
        - expect-case-colon
        - expression

    - match: default{{identifier_break}}
      scope: keyword.control.conditional.default.js
      push:
        - expect-case-colon

    - include: statements

  jsx-meta:
    - meta_include_prototype: false
    - meta_scope: meta.jsx.js
    - include: immediately-pop

  class-name:
    - match: '{{non_reserved_identifier}}'
      scope: entity.name.class.js
      set: flow-type-generic-parameters
    - include: else-pop

  flow-type-utility:
    - match: |-
        (?x) (?:
          Class|Function|
          \$(?:
            Keys|Values|ReadOnly|Exact|Diff|Rest|PropertyType|ElementType|
            ObjMap|TupleMap|Call|Supertype|Subtype
          )
        ){{identifier_break}}
      scope: support.type.utility.js
      pop: true

  literal-call:
    - match: (?={{identifier_name}}\s*(?:{{dot_accessor}})?\()
      set:
        - call-function-meta
        - function-call-arguments
        - literal-variable

    - match: (?={{identifier_name}}\s*(?:{{dot_accessor}}\s*#?{{identifier_name}}\s*)+(?:{{dot_accessor}})?\()
      set:
        - call-method-meta
        - function-call-arguments
        - call-path
        - literal-variable

  function-declaration-expect-body:
    - include: function-block
    - include: else-pop

  function-declaration-expect-name:
    - match: '{{non_reserved_identifier}}'
      scope: entity.name.function.js
      pop: true
    - include: else-pop

  try-meta:
    - meta_include_prototype: false
    - meta_scope: meta.try.js
    - include: immediately-pop

  import-statement:
    - match: import{{identifier_break}}
      scope: keyword.control.import-export.js
      set:
        - import-meta
        - expect-semicolon
        - import-string-or-items
        - import-check-branch

  inherited-class-expression-begin:
    - include: inherited-class-name
    - include: expression-begin

  object-literal-property:
    - match: ''
      set:
        - object-literal-property-check
        - object-literal-meta-key
        - object-property-name

  flow-type-generic-arguments:
    - match: <
      scope: punctuation.definition.generic.begin.js
      set:
        - meta_scope: meta.generic.js
        - match: '>'
          scope: punctuation.definition.generic.end.js
          pop: true
        - include: flow-type-list

  do-while-meta:
    - meta_include_prototype: false
    - meta_scope: meta.do-while.js
    - include: immediately-pop

  label:
    - match: ({{identifier_name}})\s*(:)
      captures:
        1: entity.name.label.js
        2: punctuation.separator.js

  variable-binding-object-destructuring:
    - match: \{
      scope: punctuation.section.block.begin.js
      set:
        - meta_scope: meta.binding.destructuring.mapping.js
        - match: \}
          scope: punctuation.section.block.end.js
          pop: true
        - include: variable-binding-spread
        - match: (?={{identifier_start}}|\[|'|")
          push:
            - initializer
            - variable-binding-object-alias
            - object-literal-meta-key
            - variable-binding-object-key
        - include: comma-separator

  object-literal-property-check:
    - match: (?=\()
      fail: object-literal-property
    - include: else-pop

  function-parameter-binding-object-key:
    - match: '{{identifier_name}}(?=\s*:)'
      pop: true
    - include: literal-string
    - include: computed-property-name
    - include: function-parameter-binding-name
    - include: else-pop

  flow-type-alias:
    - match: (?=type{{identifier_break}})
      set:
        -   - match: (?={{non_reserved_identifier}})
              set:
                -   - meta_scope: meta.declaration.type.js
                    - match: ''
                      pop: true
                - flow-type-alias-initializer
                - flow-type-generic-parameters
                -   - match: '{{non_reserved_identifier}}'
                      scope: entity.name.type.js
                      pop: true
                -   - include: else-pop

            - match: (?=\S)
              set: [expression-statement, expression-end]
        -   - match: type{{identifier_break}}(?=\s*(?:$|{{non_reserved_identifier}}))
              scope: keyword.declaration.js
              set:
                - meta_scope: meta.declaration.type.js
                - include: else-pop
            - include: expression-begin

  await-expression:
    - match: await{{identifier_break}}
      scope: keyword.control.flow.await.js

  class-extends:
    - match: extends{{identifier_break}}
      scope: storage.modifier.extends.js
      set:
        - inherited-class-expression-end
        - inherited-class-expression-begin
    - include: else-pop

  export-brace:
    - meta_scope: meta.block.js
    - include: comma-separator
    - match: \}
      scope: punctuation.section.block.end.js
      pop: true
    - match: '{{identifier_name}}'
      scope: variable.other.readwrite.js
      push: import-export-alias
    - match: \*
      scope: constant.other.js
      push: import-export-alias
    - include: else-pop

  support-variable-node:
    - match: global{{identifier_break}}
      scope: support.type.object.node.js
      pop: true

    - match: Buffer{{identifier_break}}
      scope: support.class.node.js
      pop: true

    - match: process{{identifier_break}}
      scope: support.constant.node.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-node-process
            - include: object-property
            - include: else-pop
        - include: else-pop

    # Module-level variables
    - match: (?:__dirname|__filename|exports){{identifier_break}}
      scope: support.constant.node.js
      pop: true
    - match: module{{identifier_break}}
      scope: support.constant.node.js
      set:
        - match: '{{dot_accessor}}'
          scope: punctuation.accessor.js
          set:
            - include: support-property-node-module
            - include: object-property
            - include: else-pop
        - include: else-pop
    - match: require{{identifier_break}}
      scope: support.function.node.js
      pop: true

  flow-type-declare-export:
    - match: default{{identifier_break}}
      scope: keyword.control.import-export.js
      set: flow-type
    - match: (?=\S)
      pop: true

  export-statement:
    - match: export{{identifier_break}}
      scope: keyword.control.import-export.js
      set:
        - export-meta
        - export-extended

  jsx-html-escapes:
    - match: (&)#?[[:alnum:]]+(;)
      scope: constant.character.escape.js
      captures:
        1: punctuation.definition.entity.js
        2: punctuation.definition.entity.js

  else-pop:
    - match: (?=\S)
      pop: true

  jsdoc-comment:
    - meta_include_prototype: false
    - meta_scope: comment.block.documentation.js
    - match: \*/
      scope: punctuation.definition.comment.end.js
      pop: 1
    # 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

  import-meta-expression:
    - match: import{{identifier_break}}
      scope: keyword.import.js
      set: import-expression-end

  import-item:
    - include: flow-type-import-type

    - match: \{
      scope: punctuation.section.block.begin.js
      set: import-brace
    - match: '{{non_reserved_identifier}}'
      scope: variable.other.readwrite.js
      pop: true
    - match: \*
      scope: constant.other.js
      pop: true
    - include: else-pop

  import-string-or-items:
    - include: literal-string
    - match: (?=\S)
      set:
        - import-export-from
        - import-list
        - import-export-alias
        - import-item

  block:
    - match: \{
      scope: punctuation.section.block.begin.js
      set:
        - meta_scope: meta.block.js
        - match: \}
          scope: punctuation.section.block.end.js
          pop: true
        - include: statements

  call-path:
    - match: '{{dot_accessor}}'
      scope: punctuation.accessor.js
      push: object-property
    - include: else-pop

  flow-type-function:
    - match: \(
      scope: punctuation.section.grouping.begin.js
      set:
        - meta_scope: meta.group.js
        - match: \)
          scope: punctuation.section.grouping.end.js
          pop: true
        - include: flow-type-list

  support-property-ecma:
    - match: constructor{{identifier_break}}
      scope: variable.language.constructor.js
      pop: true
    - match: prototype{{identifier_break}}
      scope: support.constant.prototype.js
      pop: true

    - match: (?:hasOwnProperty|isPrototypeOf|propertyIsEnumerable|toLocaleString|toString|valueOf){{identifier_break}}
      scope: support.function.js
      pop: true

    # Annex B
    - match: __proto__{{identifier_break}}
      scope: invalid.deprecated.js variable.language.prototype.js
      pop: true
    - match: (?:__defineGetter__|__defineSetter__|__lookupGetter__){{identifier_break}}
      scope: invalid.deprecated.js support.function.js
      pop: true

  flow-type-module-name:
    - include: literal-string
    - match: '{{non_reserved_identifier}}'
      scope: entity.name.module.js
      pop: true
    - include: else-pop

  for-oldstyle-rest:
    - match: (?=\))
      pop: true
    - match: ;
      scope: punctuation.separator.expression.js
    - match: (?=\S)
      push: expression

  postfix-operators:
    - match: --
      scope: keyword.operator.arithmetic.js
    - match: \+\+
      scope: keyword.operator.arithmetic.js

  function-parameter-binding-spread:
    - match: \.\.\.
      scope: keyword.operator.spread.js
      push: function-parameter

  flow-type:
    - match: ''
      set:
        - flow-type-end
        - flow-type-begin

  flow-type-class:
    - match: '{{non_reserved_identifier}}'
      scope: variable.other.class.js
      pop: true

  expression-no-comma:
    - meta_include_prototype: false
    - match: ''
      set: [expression-end-no-comma, expression-begin]

  support-property-ecma-reflect:
    - match: (?:apply|construct|defineProperty|deleteProperty|get|getOwnPropertyDescriptor|getPrototypeOf|has|isExtensible|ownKeys|preventExtensions|set|setPrototypeOf){{identifier_break}}
      scope: support.function.builtin.js
      pop: true

  variable-binding-pattern:
    - match: ''
      set:
        -   - include: flow-type-annotation
        -   - include: variable-binding-name
            - include: variable-binding-array-destructuring
            - include: variable-binding-object-destructuring
            - include: else-pop

  comments-top-level:
    - match: ^(#!).*$\n?
      scope: comment.line.shebang.js
      captures:
        1: punctuation.definition.comment.js

  object-property-base:
    - match: '{{dollar_only_identifier}}'
      scope: meta.property.object.dollar.only.js punctuation.dollar.js
      pop: true
    - match: '{{dollar_identifier}}'
      scope: meta.property.object.dollar.js
      captures:
        1: punctuation.dollar.js
      pop: true
    - match: '{{identifier_name}}'
      scope: meta.property.object.js
      pop: true
    - match: '{{identifier_part}}+{{identifier_break}}'
      scope: invalid.illegal.illegal-identifier.js
      pop: true
    - match: (#)({{identifier_name}})
      captures:
        1: punctuation.definition.variable.js
        2: meta.property.object.js
      pop: true

  function-call-arguments:
    - match: ({{dot_accessor}})?(\()
      captures:
        1: punctuation.accessor.js
        2: punctuation.section.group.begin.js
      set:
        - meta_scope: meta.group.js
        - match: \)
          scope: punctuation.section.group.end.js
          pop: true
        - include: expression-list

  arrow-function-declaration:
    - meta_include_prototype: false
    - match: ''
      set:
        - function-meta
        - arrow-function-expect-body
        - arrow-function-expect-arrow
        - flow-arrow-function-return-type-annotation
        - arrow-function-expect-parameters

  jsx-interpolation-comment:
    - match: ({)(/\*)
      captures:
        1: punctuation.definition.interpolation.begin.js
        2: punctuation.definition.comment.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: meta.interpolation.js comment.block.js
        - match: (\*/)(})
          captures:
            1: punctuation.definition.comment.end.js
            2: punctuation.definition.interpolation.end.js
          pop: true
        - match: (?=\*/)
          fail: jsx-interpolation-comment

  class-meta:
    - meta_include_prototype: false
    - meta_scope: meta.class.js
    - include: immediately-pop

  import-statement-or-import-meta:
    - match: (?=import{{identifier_break}})
      branch_point: import-statement
      branch:
        - import-statement
        - expression-statement

  flow-type-declare:
    - match: declare{{identifier_break}}(?=\s*(?:type|class|function|var|let|const|opaque|export|module){{identifier_break}})
      scope: keyword.declaration.js
      set:
        - match: opaque{{identifier_break}}
          scope: storage.modifier.js
          pop: true
        - match: module{{identifier_break}}
          scope: keyword.declaration.js
          set:
            - flow-type-module-meta
            - flow-type-module-body
            - flow-type-module-name
        - match: export{{identifier_break}}
          scope: keyword.declaration.js
          set: flow-type-declare-export
        - include: else-pop

  for-of-rest:
    - match: (?:of|in){{identifier_break}}
      scope: keyword.operator.word.js
      set: expression

  expression-begin:
    - include: jsx-tag

    - match: (?=`)
      set:
        - include: literal-string-template-custom-comments
        - include: literal-string-template-custom-lookahead
        - include: custom-templates-default

    - include: expression-break

    - include: yield-expression
    - include: await-expression

    - include: regexp-complete
    - include: literal-string
    - include: tagged-template
    - include: literal-string-template
    - include: constructor
    - include: literal-number
    - include: prefix-operators
    - include: import-meta-expression

    - include: class
    - include: special-name

    - include: regular-function

    - match: (?={{reserved_word}})
      pop: true

    - match: (?={{identifier_name}}{{function_assignment_lookahead}})
      set:
        - function-name-meta
        - literal-variable

    - include: object-literal

    # Newline not allowed between `async` and parameters.
    - match: (?=async{{identifier_break}}{{nothing}}(?:\(|{{identifier_start}}))
      pop: true
      branch_point: async-arrow-function
      branch:
        - async-arrow-function
        - literal-variable

    - include: literal-call

    - match: (?={{identifier_start}})
      pop: true
      branch_point: bare-arrow-function
      branch:
        - branch-possible-bare-arrow-function
        - bare-arrow-function-fallback

    - match: (?=\()
      pop: true
      branch_point: parenthesized-arrow-function
      branch:
        - branch-possible-parenthesized-arrow-function
        - parenthesized-arrow-function-fallback

    - include: array-literal

    - include: literal-private-variable

    - include: else-pop

  property-access:
    - match: ({{dot_accessor}})?(\[)
      captures:
        1: punctuation.accessor.js
        2: punctuation.section.brackets.begin.js
      push:
        - meta_scope: meta.brackets.js
        - match: \]
          scope: punctuation.section.brackets.end.js
          pop: true
        - match: (?=\S)
          push: expression

    - match: '{{dot_accessor}}'
      scope: punctuation.accessor.js
      push:
        - match: (?={{identifier_name}}\s*(?:{{dot_accessor}})?\()
          set:
            - call-method-meta
            - function-call-arguments
            - call-path
            - object-property
        - include: object-property

  flow-function-type-arguments:
    - match: \<(?!<)
      scope: punctuation.definition.generic.begin.js
      set:
        -   - match: (?=[\]()};,`])
              pop: true
            - match: (?=\S)
              fail: flow-function-type-arguments
        -   - meta_scope: meta.generic.js
            - match: \>
              scope: punctuation.definition.generic.end.js
              pop: true
            - match: ','
              scope: punctuation.separator.comma.js
              push: flow-type
            - match: (?=\S)
              fail: flow-function-type-arguments
        - flow-type

  flow-type-generic-parameters:
    - match: <
      scope: punctuation.definition.generic.begin.js
      set:
        - meta_scope: meta.generic.declaration.js
        - match: '>'
          scope: punctuation.definition.generic.end.js
          pop: true
        - include: comma-separator
        - match: \+
          scope: storage.modifier.variance.js
        - match: '{{non_reserved_identifier}}'
          scope: variable.parameter.type.js
          push:
            -   - match: '='
                  scope: keyword.operator.assignment.js
                  set: flow-type
                - include: else-pop
            - flow-type-annotation
    - include: else-pop

  do-while-condition:
    - match: while{{identifier_break}}
      scope: keyword.control.loop.while.js
      set: parenthesized-expression
    - include: else-pop

  literal-string-template:
    - match: '`'
      scope: punctuation.definition.string.begin.js
      set:
        - meta_include_prototype: false
        - meta_scope: meta.string.js string.quoted.other.js
        - match: '`'
          scope: punctuation.definition.string.end.js
          pop: true
        - match: \$\{
          scope: punctuation.section.interpolation.begin.js
          push:
            - clear_scopes: 1
            - meta_scope: meta.interpolation.js
            - meta_content_scope: source.js.embedded
            - match: \}
              scope: punctuation.section.interpolation.end.js
              pop: true
            - match: (?=\S)
              push: expression
        - include: string-content

  method-declaration-expect-asterisk:
    - match: \*
      scope: keyword.generator.asterisk.js
    - include: else-pop

  inherited-class-expression-end:
    - include: flow-type-generic-arguments

    - match: '{{dot_accessor}}'
      scope: punctuation.accessor.js
      push:
        - include: inherited-class-name
        - include: object-property

    - include: left-expression-end

  binary-operators:
    - match: instanceof{{identifier_break}}
      scope: keyword.operator.js
      push: expression-begin
    - match: in{{identifier_break}}
      scope: keyword.operator.js
      push: expression-begin
    - match: =(?![=>])
      scope: keyword.operator.assignment.js
      push: expression-begin
    - 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
      push: expression-begin
    - match: '&&|\|\||\?\?'
      scope: keyword.operator.logical.js
      push: expression-begin
    - match: |-
        (?x)
        <<   | # 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
      push: expression-begin
    - match: |-
        (?x)
        <=   | # comparison      left-to-right   both
        >=   | # comparison      left-to-right   both
        <    | # comparison      left-to-right   both
        >      # comparison      left-to-right   both
      scope: keyword.operator.comparison.js
      push: expression-begin
    - 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
      push: expression-begin
    - match: |-
        (?x)
        /    | # 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
      push: expression-begin
    - match: ','
      scope: keyword.operator.comma.js # Comma operator, not punctuation.
      push: expression-begin

  function-parameter-binding-object-alias:
    - match: ':'
      scope: punctuation.separator.key-value.js
      set: function-parameter-binding-pattern
    - include: else-pop

  flow-type-module-contents:
    - match: \}
      scope: punctuation.section.block.end.js
      pop: true
    - include: main

  computed-property-name:
    - match: \[
      scope: punctuation.section.brackets.begin.js
      set:
        - match: \]
          scope: punctuation.section.brackets.end.js
          pop: true
        - match: (?=\S)
          push: expression

  flow-type-alias-initializer:
    - match: '='
      scope: keyword.operator.assignment.js
      set:
        - flow-type-meta
        - flow-type
    - include: else-pop
  decorator-expression-end:
    - match: '{{dot_accessor}}'
      scope: punctuation.accessor.js
      push:
        - include: decorator-name
        - include: object-property

    - include: left-expression-end

  class:
    - match: class{{identifier_break}}
      scope: keyword.declaration.class.js
      set:
        - class-meta
        - class-body
        - class-extends
        - class-name

  block-meta:
    - meta_include_prototype: false
    - meta_scope: meta.block.js
    - include: immediately-pop

  function-name-meta:
    - meta_include_prototype: false
    - meta_scope: entity.name.function.js
    - include: immediately-pop

  flow-type-end-no-arrow:
    - match: (?==>)
      pop: true
    - include: flow-type-end

  flow-type-begin:
    - include: flow-type-existential
    - include: flow-type-literal
    - include: flow-type-special
    - include: flow-type-primitive
    - include: flow-type-utility
    - include: flow-type-typeof
    - include: flow-type-class
    - include: flow-type-function
    - include: flow-type-tuple
    - include: flow-type-object

    - include: else-pop

version: 2
name: JavaScript (Babel)
file_extensions:
  - js
  - jsx
  - es6
  - babel
first_line_match: ^#!\s*/.*\b(node|js)\b