MVT.sublime-syntax

%YAML 1.2
---
name: Miva Template Language (MVT)
file_extensions:
  - mvt
scope: text.mvt
variables:
  identifier: '[a-zA-Z_][a-zA-Z0-9_]*'
  identifier_w_brackets: '[a-zA-Z_][a-zA-Z0-9_:\[\]]*'

contexts:
  main:
    - match: ""
      push: "Packages/HTML/HTML.sublime-syntax"
      with_prototype:

        # AngularJS
        - include: angular-expression
        - include: angular-attributes

        # Comments
        - match: (?i)<mvt:comment>
          push: comments

        # Tags
        - include: tags

        # Entities
        - include: entities

  # =-======================== Angular ========================-= #
  angular-expression:
    - match: "{{"
      embed: scope:source.js
      embed_scope: source.js.embedded.html
      escape: "}}"

  angular-attributes:
    - match: (?i)(?<=[^=])\b((data\-)?ng\-[a-z-]+)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.angularjs
        2: entity.other.attribute-name.angularjs
        3: punctuation.separator.key-value.angularjs
        4: attribute-value.angularjs punctuation.definition.string.begin.angularjs
      push:
        - match: (")
          scope: attribute-value.angularjs punctuation.definition.string.end.angularjs
          pop: true
        - match: (?=\S)
          embed: scope:source.js
          embed_scope: source.js.embedded.html
          escape: (?=")

          # embed: scope:source.js
          # embed_scope: source.js.embedded.html
          # escape: ([^\]")
      # push:
      #   - match: (")
      #     scope: punctuation.definition.string.begin.html
      #     embed: scope:source.js
      #     embed_scope: source.js.embedded.html
      #     escape: ([^\]")



  # =-======================== Comments ========================-= #
  comments:
    - meta_scope: comment.block.mvt
    - match: (?i)<\/mvt:comment>
      pop: true

  # =-======================== Entities ========================-= #
  entities:
    - match: (?i)(&)(mvt)(a|e|j|s)?(:)({{identifier_w_brackets}})(;)
      captures:
        1: constant.character.entity.begin.mvt
        2: constant.character.entity.namespace.mvt
        3: constant.character.entity.encoding.mvt
        4: constant.character.entity.separator.mvt
        5: constant.character.entity.identifier.mvt
        6: constant.character.entity.end.mvt

  # =-======================== Tags ========================-= #
  tags:
    - include: tag-assign
    - include: tag-call
    - include: tag-do
    - include: tag-else
    - include: tag-elseif
    - include: tag-eval
    - include: tag-exit
    - include: tag-foreach
    - include: tag-if
    - include: tag-inline
    - include: tag-miva
    - include: tag-while
    - include: tag-item
    - include: tag-capture

  tag-item:
    - match: (</?)(?i:(mvt)(:)(item)\b)
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.item.mvt
        - match: '(\/?>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: item-name-attribute
        - include: param-attribute
        - include: illegal-attributes


  tag-capture:
    - match: (</?)(?i:(mvt)(:)(capture)\b)
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.block.capture.mvt
        - match: '(>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: variable-attribute
        - include: illegal-attributes

  tag-call:
    - match: (</?)(?i:(mvt)(:)(call)\b)
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.block.call.mvt
        - match: '(>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: method-attribute
        - include: action-attribute
        - include: content-type-attribute
        - include: fields-attribute
        - include: certpass-attribute
        - include: files-attribute
        - include: certtype-attribute
        - include: cerfile-attribute
        - include: timeout-attribute
        - include: headers-attribute
        - include: illegal-attributes

  tag-foreach:
    - match: (</?)(?i:(mvt)(:)(foreach)\b)
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.block.foreach.mvt
        - match: '(>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: iterator-attribute
        - include: array-attribute
        - include: illegal-attributes

  tag-while:
    - match: (</?)(?i:(mvt)(:)(while)\b)
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.block.while.mvt
        - match: '(>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: expr-attribute
        - include: illegal-attributes

  tag-if:
    - match: (</?)(?i:(mvt)(:)(if)\b)
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.block.if.mvt
        - match: '(>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: expr-attribute
        - include: illegal-attributes

  tag-inline:
    - match: '(?i)(<)(mvt)(:)(callcontinue|callstop|foreachcontinue|foreachstop|whilecontinue|whilestop)\b'
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.any.mvt
        - match: '(\/>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: illegal-attributes

  tag-exit:
    - match: '(?i)(<)(mvt)(:)(exit)\b'
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.exit.mvt
        - match: '(\/?>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: illegal-attributes

  tag-else:
    - match: '(?i)(<)(mvt)(:)(else)\b'
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.else.mvt
        - match: '\/'
          scope: invalid.illegal.slash.mvt
        - match: '(>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: illegal-attributes

  tag-miva:
    - match: '(?i)(<)(mvt)(:)(miva)\b'
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.miva.mvt
        - match: '(\/>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: output-attribute
        - include: compresswhitespace-attribute
        - include: illegal-attributes

  tag-elseif:
    - match: '(?i)(<)(mvt)(:)(elseif)\b'
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.elseif.mvt
        - match: '(>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: expr-attribute
        - include: illegal-attributes

  tag-eval:
    - match: '(?i)(<)(mvt)(:)(eval)\b'
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.eval.mvt
        - match: '(\/>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: expr-attribute
        - include: illegal-attributes

  tag-do:
    - match: '(?i)(<)(mvt)(:)(do)\b'
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.do.mvt
        - match: '(\/>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: file-attribute
        - include: name-attribute
        - include: value-attribute
        - include: illegal-attributes

  tag-assign:
    - match: '(?i)(<)(mvt)(:)(assign)\b'
      captures:
        1: punctuation.definition.tag.begin.mvt meta.preprocessor.begin.mvt
        2: storage.type.namespace.mvt meta.preprocessor.namespace.mvt
        3: storage.type.namespace.separator.mvt meta.preprocessor.namespace.separator.mvt
        4: storage.type.localname.mvt meta.preprocessor.localname.mvt
      push:
        - meta_scope: meta.tag.inline.assign.mvt
        - match: '(\/>)'
          captures:
            1: punctuation.definition.tag.end.mvt meta.preprocessor.end.mvt
          pop: true
        - include: assign-name-attribute
        - include: value-attribute
        - include: illegal-attributes


  # =-======================== Tag Attributes ========================-= #
  illegal-attributes:
    - match: '(?<=[^=])\b([a-zA-Z0-9\:\-\_]+)\s*(=?)'
      captures:
        1: invalid.illegal.attribute-name.mvt

  output-attribute:
    - match: (?i)(?<=[^=])\b(output)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.expr.mvt
        2: punctuation.separator.key-value.mvt
        3: punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: string.quoted.single.mvt
        - match: \b(off|on)\b
          scope: string.quoted.single.mvt
        - match: '[^"]'
          scope: invalid.illegal.identifier.mvt
        - match: (")
          captures:
            0: punctuation.definition.string.end.mvt
          pop: true

  compresswhitespace-attribute:
    - match: (?i)(?<=[^=])\b(compresswhitespace)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.expr.mvt
        2: punctuation.separator.key-value.mvt
        3: punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: string.quoted.single.mvt
        - match: \b(off|on)\b
          scope: string.quoted.single.mvt
        - match: '[^"]'
          scope: invalid.illegal.identifier.mvt
        - match: (")
          captures:
            0: punctuation.definition.string.end.mvt
          pop: true

  headers-attribute:
    - match: (?i)(?<=[^=])\b(headers)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.headers.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.headers.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.headers.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.headers.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  timeout-attribute:
    - match: (?i)(?<=[^=])\b(timeout)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.timeout.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.timeout.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.timeout.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.timeout.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  cerfile-attribute:
    - match: (?i)(?<=[^=])\b(cerfile)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.cerfile.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.cerfile.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.cerfile.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.cerfile.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  certtype-attribute:
    - match: (?i)(?<=[^=])\b(certtype)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.certtype.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.certtype.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.certtype.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.certtype.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  param-attribute:
    - match: (?i)(?<=[^=])\b(param)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.param.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.param.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.param.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.param.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins
        - include: source-all-module-functions

  files-attribute:
    - match: (?i)(?<=[^=])\b(files)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.files.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.files.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.files.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.files.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  certpass-attribute:
    - match: (?i)(?<=[^=])\b(certpass)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.certpass.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.certpass.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.certpass.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.certpass.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  fields-attribute:
    - match: (?i)(?<=[^=])\b(fields)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.fields.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.fields.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.fields.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.fields.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  content-type-attribute:
    - match: (?i)(?<=[^=])\b(content-type)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.content-type.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.content-type.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.content-type.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.content-type.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  action-attribute:
    - match: (?i)(?<=[^=])\b(action)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.action.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.action.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.action.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.action.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  method-attribute:
    - match: (?i)(?<=[^=])\b(method)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.method.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.method.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.method.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.method.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  iterator-attribute:
    - match: (?i)(?<=[^=])\b(iterator)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.iterator.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.iterator.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.iterator.mvt source.mvt variable.language.implied.mvt
        - match: (")
          captures:
            0: attribute-value.iterator.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true

  array-attribute:
    - match: (?i)(?<=[^=])\b(array)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.array.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.array.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.array.mvt source.mvt variable.language.implied.mvt
        - match: (")
          captures:
            0: attribute-value.array.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true

  expr-attribute:
    - match: (?i)(?<=[^=])\b(expr)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.expr.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.expr.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.expr.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.expr.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  file-attribute:
    - match: (?i)(?<=[^=])\b(file)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.file.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.file.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.file.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.file.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  item-name-attribute:
    - match: (?i)(?<=[^=])\b(name)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.name.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.name.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.name.mvt source.mvt support.class.module.mvt
        - match: (")
          captures:
            0: attribute-value.name.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true

  assign-name-attribute:
    - match: (?i)(?<=[^=])\b(name)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.name.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.name.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.name.mvt source.mvt assign.declaration.mvt
        - match: (")
          captures:
            0: attribute-value.name.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-variables
        - include: source-string-single
        - include: source-numbers
        - include: source-brackets-no-functions
        - include: source-group-no-functions

  name-attribute:
    - match: (?i)(?<=[^=])\b(name)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.name.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.name.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.name.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.name.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-variables
        - include: source-string-single
        - include: source-numbers
        - include: source-brackets-no-functions
        - include: source-group-no-functions

  value-attribute:
    - match: (?i)(?<=[^=])\b(value)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.value.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.value.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.value.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.value.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins
        - include: source-functions-merchant

  variable-attribute:
    - match: (?i)(?<=[^=])\b(variable)\s*(=?)\s*(")
      captures:
        1: entity.other.attribute-name.variable.mvt
        2: punctuation.separator.key-value.mvt
        3: attribute-value.variable.mvt source.mvt punctuation.definition.string.begin.mvt
      push:
        - meta_content_scope: attribute-value.variable.mvt source.mvt
        - match: (")
          captures:
            0: attribute-value.variable.mvt source.mvt punctuation.definition.string.end.mvt
          pop: true
        - include: source-variables
        - include: source-brackets-no-functions


  # =-======================== Source ========================-= #
  source-mvt:
    - include: source-brackets
    - include: source-group
    - include: source-variables
    - include: source-string-single
    - include: source-numbers
    - include: source-operators
    - include: source-constants

  # =-======== Functions - Source ========-= #
  source-functions-builtins:
    - match: \b({{identifier}})\s*(\()
      captures:
        1: support.function.builtin.mvt
        2: puncuation.definition.group.mvt
      push:
        - meta_scope: meta.function.builtin.declaration.mvt
        - match: (\))
          captures:
            0: puncuation.terminator.group.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  source-functions-merchant:
    - match: \b({{identifier}})\s*(\()
      captures:
        1: support.function.merchant.mvt
        2: puncuation.definition.group.mvt
      push:
        - meta_scope: meta.function.merchant.declaration.mvt
        - match: (\))
          captures:
            0: puncuation.terminator.group.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  source-all-module-functions:
    - include: source-functions-readytheme
    - include: source-functions-customfields
    - include: source-functions-toolkit
    - include: source-functions-toolbelt
    - include: source-functions-tgwaitlist
    - include: source-functions-tgreviews

  source-functions-readytheme:
    - match: \b({{identifier}})\s*(\()
      captures:
        1: support.function.readytheme.mvt
        2: puncuation.definition.group.mvt
      push:
        - meta_scope: meta.function.readytheme.declaration.mvt
        - match: (\))
          captures:
            0: puncuation.terminator.group.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  source-functions-customfields:
    - match: \b({{identifier}})\s*(\()
      captures:
        1: support.function.customfields.mvt
        2: puncuation.definition.group.mvt
      push:
        - meta_scope: meta.function.customfields.declaration.mvt
        - match: (\))
          captures:
            0: puncuation.terminator.group.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  source-functions-toolkit:
    - match: (?<!\w|\|)({{identifier}})(?=\|)
      scope: support.function.toolkit.mvt

  source-functions-toolbelt:
    - match: (?<!\w|\|)({{identifier}})(?=\|)
      scope: support.function.toolbelt.mvt

  source-functions-tgwaitlist:
    - match: \b({{identifier}})\s*(\()
      captures:
        1: support.function.tgwaitlist.mvt
        2: puncuation.definition.group.mvt
      push:
        - meta_scope: meta.function.tgwaitlist.declaration.mvt
        - match: (\))
          captures:
            0: puncuation.terminator.group.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  source-functions-tgreviews:
    - match: \b({{identifier}})\s*(\()
      captures:
        1: support.function.tgreviews.mvt
        2: puncuation.definition.group.mvt
      push:
        - meta_scope: meta.function.tgreviews.declaration.mvt
        - match: (\))
          captures:
            0: puncuation.terminator.group.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins

  # =-======== Operators - Source ========-= #
  source-operators:
    # Arithmetic Operators
    - match: (\b(?i:POW|MOD|ROUND)\b)
      scope: keyword.operator.arithmetic.mvt

    # Arithmetic Operators (Symbols)
    - match: >-
        (?x)
          --   | # decrement
          \+\+ | # increment
          /    | # division
          \*   | # multiplication
          \+   | # addition
          -    | # subtraction
      scope: keyword.operator.arithmetic.mvt

    # Comparison Operators
    - match: (\b(?i:EQ|GT|GE|LT|NE|LE)\b)
      scope: keyword.operator.comparison.mvt

    # Logical Operators
    - match: (\b(?i:NOT|AND|OR|ISNULL)\b)
      scope: keyword.operator.logical.mvt

    # Text Operators
    - match: (\b(?i:IN|CIN|EIN|ECIN|CRYPT)\b)
      scope: keyword.operator.string.mvt

    # Text Operators (Symbols)
    - match: >-
        (?x)
          \$
      scope: keyword.operator.string.mvt


  # =-======== Constants - Source ========-= #
  source-constants:
    # NULL
    - match: \b(?i:NULL)\b
      scope: constant.language.null.mvt

  # =-======== Numbers - Source ========-= #
  source-numbers:
    - match: \b(([0-9]+(\.[0-9]+)?))\b
      scope: constant.numeric.mvt


  # =-======== Variables - Source ========-= #
  source-variables:
    # Variables Base
    - match: '\b(g|global)(\.)'
      captures:
        1: variable.language.global.namespace.mvt
        2: variable.language.global.separator.mvt
      push:
        - match: '({{identifier}})'
          scope: variable.language.global.name.mvt
        - match: '(:?)({{identifier}})'
          captures:
            1: variable.language.global.name.separator.mvt
            2: variable.language.global.name.member.mvt
        - match: \b
          pop: true

    - match: '\b(l|local)(\.)'
      captures:
        1: variable.language.local.namespace.mvt
        2: variable.language.local.separator.mvt
      push:
        - match: '({{identifier}})'
          scope: variable.language.local.name.mvt
        - match: '(:?)({{identifier}})'
          captures:
            1: variable.language.local.name.separator.mvt
            2: variable.language.local.name.member.mvt
        - match: \b
          pop: true

    - match: '\b(s|system)(\.)'
      captures:
        1: variable.language.system.namespace.mvt
        2: variable.language.system.separator.mvt
      push:
        - match: '({{identifier}})'
          scope: variable.language.system.name.mvt
        - match: '(:?)({{identifier}})'
          captures:
            1: variable.language.system.name.separator.mvt
            2: variable.language.system.name.member.mvt
        - match: \b
          pop: true

    # Variables Cont. (continue after square brackets)
    - match: '(?<=\])(:)({{identifier}})'
      captures:
        1: variable.language.separator.mvt
        2: variable.language.member.mvt
      push:
        - match: '(:?)({{identifier}})'
          captures:
            1: variable.language.separator.mvt
            2: variable.language.member.mvt
        - match: \b
          pop: true

    # POSX
    - match: \b(?i:POS)[0-9]+\b
      scope: variable.language.posx.mvt

  # =-======== Strings - Source ========-= #
  source-string-single:
    - match: "'"
      scope: punctuation.definition.string.begin.mvt
      push:
        - meta_scope: string.quoted.single.mvt
        - match: "'"
          pop: true
        - include: source-string-escapes

  source-string-escapes:
    - match: \\\s*\n
      scope: constant.character.escape.newline.js
    - match: '\\(x[\da-fA-F][\da-fA-F]|u[\da-fA-F][\da-fA-F][\da-fA-F][\da-fA-F]|.)'
      scope: constant.character.escape.js


  # =-======== Brackets / Group (Parenthesis) - Source ========-= #
  source-brackets-no-functions:
    - match: \[
      scope: puncuation.definition.brackets.mvt
      push:
        - meta_scope: meta.brackets.mvt
        - match: \]
          scope: puncuation.terminator.bracket.mvt
          pop: true
        - include: source-mvt
    - match: \]
      scope: invalid.illegal.stray-bracket-end

  source-brackets:
    - match: \[
      scope: puncuation.definition.brackets.mvt
      push:
        - meta_scope: meta.brackets.mvt
        - match: \]
          scope: puncuation.terminator.bracket.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins
    - match: \]
      scope: invalid.illegal.stray-bracket-end

  source-group-no-functions:
    - match: \(
      scope: puncuation.definition.group.mvt
      push:
        - meta_scope: meta.group.mvt
        - match: \)
          scope: puncuation.terminator.group.mvt
          pop: true
        - include: source-mvt
    - match: \)
      scope: invalid.illegal.stray-group-end

  source-group:
    - match: \(
      scope: puncuation.definition.group.mvt
      push:
        - meta_scope: meta.group.mvt
        - match: \)
          scope: puncuation.terminator.group.mvt
          pop: true
        - include: source-mvt
        - include: source-functions-builtins
    - match: \)
      scope: invalid.illegal.stray-group-end