Clojure (Sublimed).sublime-syntax

%YAML 1.2
---
# https://www.sublimetext.com/docs/syntax.html
name: Clojure (Sublimed)
file_extensions: [clj, cljs, cljc, cljx, boot, bb, edn]
scope: source.clojure
variables:
  wsb:          '(?<=^|[\s,()\[\]{}~''`"^@]|#_)'
  wse:           '(?=$|[\s,()\[\]{}";])'
  nwse:              '[^\s,()\[\]{}";]'
  
  sym_head:     '[\p{Alpha}*!_?$%&=<>.|]'
  sym_head_lax: '[\p{Alpha}*!_?$%&=<>.|''\-+#:]'
  sym_body:     '[\p{Alpha}*!_?$%&=<>.|''\-+#:0-9]'
  ns_symbol:    '(?:[\-+.]|[\-+.]{{sym_head_lax}}{{sym_body}}*|{{sym_head}}{{sym_body}}*)'
  symbol:       '(?:/|{{ns_symbol}})'
  
  kw:           '\p{Alpha}*!_?$%&=<>''\-+.#0-9' 
  regexp_name:  '[a-zA-Z][a-zA-Z0-9]*'
contexts:
  main:
    - include: skip_forms
    - match: (?=\S)
      push:
        - include: forms

  forms:
    - include: skip_forms
    - include: wrap_forms
    - include: normal_forms
    - include: stray_bracket

  deep_forms:
    - include: skip_forms
    - include: deep_normal_forms
    - include: stray_bracket


  # SKIP FORMS

  skip_forms:
    - include: comma
    - include: deref
    - include: var
    - include: line_comment
    - include: reader_comment
    - include: metadata

  comma:
    - match: ','
      scope: punctuation.definition.comma.clojure

  deref:
    - match: '@'
      scope: keyword.operator.deref.clojure

  var:
    - match: '#'''
      scope: punctuation.definition.var.clojure

  line_comment:
    - match: '(;+).*$'
      scope: comment.line.clojure
      captures:
        1: punctuation.definition.comment.line.clojure

  reader_comment:
    - match: '#_'
      scope: punctuation.definition.comment.reader.clojure
      push: 
      - meta_scope: comment.reader.clojure
      - include: forms

  metadata:
    - match: '\^'
      scope: punctuation.definition.metadata.clojure
      push: 
      - meta_scope: meta.metadata.clojure
      - include: forms


  # WRAP FORMS

  wrap_forms:
    - include: quote
    - include: syntax_quote
    - include: syntax_unquote

  quote:
    - match: ''''
      scope: keyword.operator.quote.clojure
      push: 
      - meta_scope: meta.quoted.clojure
      - include: deep_forms

  syntax_quote:
    - match: '`'
      scope: keyword.operator.quote.syntax.clojure
      push: 
      - meta_scope: meta.quoted.syntax.clojure
      - include: deep_forms

  syntax_unquote:
    - match: '~@?'
      scope: keyword.operator.unquote.clojure
      push: 
      - meta_scope: meta.unquoted.clojure
      - include: deep_forms


  # NORMAL FORMS

  normal_forms:
    - include: character
    - include: string
    - include: regexp
    - include: constant
    - include: keyword
    - include: integer
    - include: float
    - include: ratio
    - include: symbol_unused
    - include: symbol
    - include: list
    - include: anonymous_fn
    - include: reader_conditional
    - include: vector
    - include: map
    - include: set
    - include: tag

  character:
    - match: '{{wsb}}((\\)(u\h{4}|o[0-3]?[0-7]{1,2}|newline|tab|space|backspace|formfeed|return|[^\s]){{wse}}|((\\){{nwse}}*))'
      scope: constant.character.clojure
      captures:
        2: punctuation.definition.character.begin.clojure
        4: invalid.illegal.character.clojure
        5: punctuation.definition.character.begin.clojure
      pop:   1

  string:
    - match: '{{wsb}}"'
      scope: punctuation.definition.string.begin.clojure
      push:
      - meta_scope: string.quoted.double.clojure
      - match: '(\\)(u\h{4}|b|t|n|f|r|"|''|\\|[0-3]?[0-7]{1,2})|((\\).)'
        scope: constant.character.escape.clojure
        captures:
          1: punctuation.definition.character.escape.begin.clojure 
          3: invalid.illegal.escape.string.clojure
          4: punctuation.definition.character.escape.begin.clojure
      - match: '"'
        scope: punctuation.definition.string.end.clojure
        pop:   2

  regexp_quote:
    - match: '\\Q'
      scope: punctuation.section.quotation.begin.clojure
      push:
        - meta_content_scope: constant.character.escape.clojure
        - match: '\\"'
        - match: '(?=")'
          pop:   1
        - match: '\\E'
          scope: punctuation.section.quotation.end.clojure
          pop:   1

  regexp_shared:
    - match: '(\\)(\\|0[0-3]?[0-7]{1,2}|x\h{2}|u\h{4}|x\{1?\h{1,5}\}|\N\{[a-zA-Z0-9\- ]+\}|[tnrfae]|c[A-Z]|[dDhHsSvVwW]|p\{[a-zA-Z]+\}|b\{g\}|[bBAGZz]|[RX]|[0-9]+|k<{{regexp_name}}>|[^a-zA-Z0-9])|((\\).)'
      scope: constant.character.escape.clojure
      captures:
          1: punctuation.definition.character.escape.begin.clojure 
          3: invalid.illegal.escape.regexp.clojure
          4: punctuation.definition.character.escape.begin.clojure
    - match: '"'
      scope: punctuation.definition.string.end.clojure
      pop:   2
    - match: '(\[)(\^)?(-)?'
      captures:
        1: punctuation.section.brackets.begin.clojure
        2: keyword.operator.negation.regexp.clojure
      push:
      - match: '(?=")'
        pop:   1
      - match: '\]'
        scope: punctuation.section.brackets.end.clojure
        pop:   1
      - match: '-(?!\])'
        scope: keyword.operator.range.regexp.clojure
      - match: '&&'
        scope: keyword.operator.intersection.regexp.clojure
      - include: regexp_shared
    - match: '(?:[?*+]|\{\d+(?:,(?:\d+)?)?\})[?+]?'
      scope: keyword.operator.quantifier.regexp.clojure

  regexp_group:
    - include: regexp_quote
    - include: regexp_shared
    - match: '\|'
      scope: keyword.operator.union.regexp.clojure
    - match: '(\()(\?(<{{regexp_name}}>|:|=|!|<=|<!|>|[idmsux]*(-[idmsux]+)?:|[idmsuxU]*(-[idmsuxU]+)?(?!:)))?'
      captures:
        1: punctuation.section.parens.begin.clojure
        2: keyword.operator.special.regexp.clojure
      push:
      - match: '(?=")'
        pop:   1
      - match: '\)'
        scope: punctuation.section.parens.end.clojure
        pop:   1
      - include: regexp_group
    - match: '[\)]'
      scope: invalid.illegal.stray-bracket-end

  regexp:
    - match: '{{wsb}}#"'
      scope: punctuation.definition.string.begin.clojure
      push:
      - meta_scope: string.regexp.clojure
      - include: regexp_group

  constant:
    - match: '{{wsb}}(nil|true|false){{wse}}'
      scope: constant.language.clojure
      pop: 1

  keyword:
    - match: '{{wsb}}(::?)([{{kw}}][{{kw}}:]*[{{kw}}]|[{{kw}}])(/)([{{kw}}:/]*[{{kw}}]|[{{kw}}]|/+){{wse}}'
      scope: constant.other.keyword.clojure
      captures:
        1: punctuation.definition.keyword.begin.clojure
        2: meta.namespace.keyword.clojure
        3: punctuation.definition.namespace.clojure
      pop: 1
    - match: '{{wsb}}(::?)([{{kw}}][{{kw}}:]*[{{kw}}]|[{{kw}}]){{wse}}'
      scope: constant.other.keyword.clojure
      captures:
        1: punctuation.definition.keyword.begin.clojure
      pop: 1
    - match: '{{wsb}}(:)/{{wse}}'
      scope: constant.other.keyword.clojure
      captures:
        1: punctuation.definition.keyword.begin.clojure
      pop: 1
    - match: '{{wsb}}(:)/(//+){{wse}}'
      scope: constant.other.keyword.clojure
      captures:
        1: punctuation.definition.keyword.begin.clojure
        2: punctuation.definition.namespace.clojure
      pop: 1

  integer:
    - match: '{{wsb}}[+-]?(?:0[xX][0-9A-Fa-f]+|0[1-7]+|[1-9][0-9]*|[1-9][0-9]?[rR][0-9A-Za-z]+|0)(N)?{{wse}}'
      scope: constant.numeric.integer.clojure
      captures:
        1: punctuation.definition.integer.precision.clojure
      pop:   1

  float:
    - match: '{{wsb}}[+-]?(?:0|[1-9][0-9]*)(?:(M)|\.[0-9]*(M)?|[eE][+-]?[0-9]+(M)?|\.[0-9]*[eE][+-]?[0-9]+(M)?){{wse}}'
      scope: constant.numeric.float.clojure
      captures:
        1: punctuation.definition.float.precision.clojure
        2: punctuation.definition.float.precision.clojure
        3: punctuation.definition.float.precision.clojure
        4: punctuation.definition.float.precision.clojure
      pop:   1
    - match: '{{wsb}}(##Inf|##-Inf|##NaN){{wse}}'
      scope: constant.numeric.float.clojure
      pop:   1

  ratio:
    - match: '{{wsb}}[+-]?(0|[1-9][0-9]*)/[1-9][0-9]*{{wse}}'
      scope: constant.numeric.ratio.clojure
      pop:   1

  symbol_def:
    - match: '{{wsb}}(?:ns|(?=def){{symbol}}|({{ns_symbol}})(/)(?=def){{symbol}}){{wse}}'
      scope: source.symbol.def.clojure
      captures:
        1: meta.namespace.symbol.clojure
        2: punctuation.definition.namespace.clojure
      pop: 1
      push: list_second

  symbol_name:
    - match: '{{wsb}}(?:{{symbol}}|({{ns_symbol}})(/)(?:/|{{sym_body}})+){{wse}}'
      scope: source.symbol.clojure entity.name.clojure
      captures:
        1: meta.namespace.symbol.clojure
        2: punctuation.definition.namespace.clojure
      pop: 1
      push: list_rest

  symbol_unused:
    - match: '{{wsb}}(?:(?=_){{symbol}}|({{ns_symbol}})(/)(?=_)(?:/|{{sym_body}})*){{wse}}'
      scope: source.symbol.unused.clojure
      captures:
        1: meta.namespace.symbol.clojure
        2: punctuation.definition.namespace.clojure
      pop:   1

  symbol:
    - match: '{{wsb}}(?:{{symbol}}|({{ns_symbol}})(/)(?:/|{{sym_body}})+){{wse}}'
      scope: source.symbol.clojure
      captures:
        1: meta.namespace.symbol.clojure
        2: punctuation.definition.namespace.clojure
      pop:   1

  list:
    - match: '(?=\()'
      branch_point: open_parens
      branch:
        - list_paren
        - form_comment_paren

  list_paren:
    - match: '\('
      scope: punctuation.section.parens.begin.clojure
      set: list_first

  list_first:
    - meta_scope: meta.parens.clojure
    - match: \)
      scope: punctuation.section.parens.end.clojure
      pop:   2
    - include: comma
    - include: line_comment
    - include: reader_comment
    - include: metadata
    - match: 'comment'
      fail: open_parens
    - include: symbol_def
    - match: '(?=\S)'
      set: list_rest

  list_second:
    - meta_scope: meta.parens.clojure
    - match: \)
      scope: punctuation.section.parens.end.clojure
      pop:   2
    - include: comma
    - include: line_comment
    - include: reader_comment
    - include: metadata
    - include: symbol_name
    - match: '(?=\S)'
      set: list_rest

  list_rest:
    - meta_scope: meta.parens.clojure
    - match: \)
      scope: punctuation.section.parens.end.clojure
      pop:   2
    - include: main

  form_comment_paren:
    - match: '\('
      scope: punctuation.section.parens.begin.clojure
      set: form_comment_first

  form_comment_first:
    - meta_scope: comment.form.clojure
    - include: comma
    - include: line_comment
    - include: reader_comment
    - include: metadata
    - match: 'comment'
      set: form_comment_rest
    - match: \)
      fail: open_parens
    - match: '(?=\S)'
      fail: open_parens

  form_comment_rest:
    - meta_scope: comment.form.clojure
    - match: \)
      scope: punctuation.section.parens.end.clojure
      pop:   2
    - include: main

  anonymous_fn:
    - match: '(#)(\()'
      captures:
        1: punctuation.definition.anon_fn.clojure
      scope: punctuation.section.parens.begin.clojure
      push:
      - meta_scope: meta.parens.clojure meta.function.anon.clojure
      - match: \)
        scope: punctuation.section.parens.end.clojure
        pop: 2
      - include: main

  reader_conditional:
    - match: '(#\?@?)\s*\('
      captures:
        1: punctuation.definition.reader_conditional.clojure
      scope: punctuation.section.parens.begin.clojure
      push:
      - meta_scope: meta.parens.clojure meta.reader_conditional.clojure
      - match: '\)'
        scope: punctuation.section.parens.end.clojure
        pop: 2
      - include: main

  vector:
    - match: \[
      scope: punctuation.section.brackets.begin.clojure
      push:
      - meta_scope: meta.brackets.clojure
      - match: \]
        scope: punctuation.section.brackets.end.clojure
        pop:   2
      - include: main

  map:
    - match: '\{'
      scope: punctuation.section.braces.begin.clojure
      push:
      - meta_scope: meta.braces.clojure
      - match: \}
        scope: punctuation.section.braces.end.clojure
        pop:   2
      - include: main

  set:
    - match: '#\{'
      scope: punctuation.section.braces.begin.clojure
      push:
      - meta_scope: meta.braces.clojure
      - match: \}
        scope: punctuation.section.braces.end.clojure
        pop:   2
      - include: main

  tag:
    - match: '{{wsb}}(#inst\s*"\d\d\d\d(?:-[01]\d(?:-[0123]\d(?:T[012]\d(?::[012345]\d(?::[0123456]\d(?:[.]\d{1,9})?)?)?)?)?)?(?:Z|[-+][012]\d:[012345]\d)?"|(#inst\s*"[^"]*")){{wse}}'
      scope: constant.other.instant.clojure
      captures:
        2: invalid.illegal.instant.clojure
      pop:   1
    - match: '{{wsb}}(#uuid\s*"\h{8}-\h{4}-\h{4}-\h{4}-\h{12}"|(#uuid\s*"[^"]*")){{wse}}'
      scope: constant.other.uuid.clojure
      captures:
        2: invalid.illegal.uuid.clojure
      pop:   1
    - match: '{{wsb}}#(?![_#{])(?:{{symbol}}|{{ns_symbol}}(/){{symbol}}){{wse}}'
      scope: storage.type.tag.clojure
      pop:   1


  # DEEP FORMS

  deep_normal_forms:
    - include: deep_character
    - include: deep_string
    - include: deep_regexp
    - include: deep_constant
    - include: deep_keyword
    - include: deep_integer
    - include: deep_float
    - include: deep_ratio
    - include: deep_symbol_unused
    - include: deep_symbol
    - include: deep_var
    - include: deep_list
    - include: deep_anonymous_fn
    - include: deep_reader_conditional
    - include: deep_vector
    - include: deep_map
    - include: deep_set
    - include: deep_tag

  deep_character:
    - match: '{{wsb}}((\\)(u\h{4}|o[0-3]?[0-7]{1,2}|newline|tab|space|backspace|formfeed|return|[^\s]){{wse}}|((\\){{nwse}}*))'
      scope: constant.character.clojure
      captures:
        2: punctuation.definition.character.begin.clojure
        4: invalid.illegal.character.clojure
        5: punctuation.definition.character.begin.clojure
      pop: 2

  deep_string:
    - match: '{{wsb}}"'
      scope: punctuation.definition.string.begin.clojure
      push:
      - meta_scope: string.quoted.double.clojure
      - match: '(\\)(u\h{4}|b|t|n|f|r|"|''|\\|[0-3]?[0-7]{1,2})|((\\).)'
        scope: constant.character.escape.clojure
        captures:
          1: punctuation.definition.character.escape.begin.clojure 
          3: invalid.illegal.escape.string.clojure
          4: punctuation.definition.character.escape.begin.clojure
      - match: '"'
        scope: punctuation.definition.string.end.clojure
        pop:   3

  deep_regexp_shared:
    - match: '(\\)(\\|0[0-3]?[0-7]{1,2}|x\h{2}|u\h{4}|x\{1?\h{1,5}\}|\N\{[a-zA-Z0-9\- ]+\}|[tnrfae]|c[A-Z]|[dDhHsSvVwW]|p\{[a-zA-Z]+\}|b\{g\}|[bBAGZz]|[RX]|[0-9]+|k<{{regexp_name}}>|[^a-zA-Z0-9])|((\\).)'
      scope: constant.character.escape.clojure
      captures:
          1: punctuation.definition.character.escape.begin.clojure 
          3: invalid.illegal.escape.regexp.clojure
          4: punctuation.definition.character.escape.begin.clojure
    - match: '"'
      scope: punctuation.definition.string.end.clojure
      pop: 3
    - match: '(\[)(\^)?(-)?'
      captures:
        1: punctuation.section.brackets.begin.clojure
        2: keyword.operator.negation.regexp.clojure
      push:
      - match: '(?=")'
        pop: 1
      - match: '\]'
        scope: punctuation.section.brackets.end.clojure
        pop: 1
      - match: '-(?!\])'
        scope: keyword.operator.range.regexp.clojure
      - match: '&&'
        scope: keyword.operator.intersection.regexp.clojure
      - include: regexp_shared
    - match: '(?:[?*+]|\{\d+(?:,(?:\d+)?)?\})[?+]?'
      scope: keyword.operator.quantifier.regexp.clojure

  deep_regexp_group:
    - include: regexp_quote
    - include: deep_regexp_shared
    - match: '\|'
      scope: keyword.operator.union.regexp.clojure
    - match: '(\()(\?(<{{regexp_name}}>|:|=|!|<=|<!|>|[idmsux]*(-[idmsux]+)?:|[idmsuxU]*(-[idmsuxU]+)?(?!:)))?'
      captures:
        1: punctuation.section.parens.begin.clojure
        2: keyword.operator.special.regexp.clojure
      push:
      - match: '(?=")'
        pop:   1
      - match: '\)'
        scope: punctuation.section.parens.end.clojure
        pop:   1
      - include: deep_regexp_group
    - match: '[\)]'
      scope: invalid.illegal.stray-bracket-end

  deep_regexp:
    - match: '{{wsb}}#"'
      scope: punctuation.definition.string.begin.clojure
      push:
      - meta_scope: string.regexp.clojure
      - include: deep_regexp_group

  deep_constant:
    - match: '{{wsb}}(nil|true|false){{wse}}'
      scope: constant.language.clojure
      pop: 2

  deep_keyword:
    - match: '{{wsb}}(::?)([{{kw}}][{{kw}}:]*[{{kw}}]|[{{kw}}])(/)([{{kw}}:/]*[{{kw}}]|[{{kw}}]|/+){{wse}}'
      scope: constant.other.keyword.clojure
      captures:
        1: punctuation.definition.keyword.begin.clojure
        2: meta.namespace.keyword.clojure
        3: punctuation.definition.namespace.clojure
      pop: 2
    - match: '{{wsb}}(::?)([{{kw}}][{{kw}}:]*[{{kw}}]|[{{kw}}]){{wse}}'
      scope: constant.other.keyword.clojure
      captures:
        1: punctuation.definition.keyword.begin.clojure
      pop: 2
    - match: '{{wsb}}(:)/{{wse}}'
      scope: constant.other.keyword.clojure
      captures:
        1: punctuation.definition.keyword.begin.clojure
      pop: 2
    - match: '{{wsb}}(:)/(//+){{wse}}'
      scope: constant.other.keyword.clojure
      captures:
        1: punctuation.definition.keyword.begin.clojure
        2: punctuation.definition.namespace.clojure
      pop: 2

  deep_integer:
    - match: '{{wsb}}[+-]?(?:0[xX][0-9A-Fa-f]+|0[1-7]+|[1-9][0-9]*|[1-9][0-9]?[rR][0-9A-Za-z]+|0)(N)?{{wse}}'
      scope: constant.numeric.integer.clojure
      captures:
        1: punctuation.definition.integer.precision.clojure
      pop: 2

  deep_float:
    - match: '{{wsb}}[+-]?(?:0|[1-9][0-9]*)(?:(M)|\.[0-9]*(M)?|[eE][+-]?[0-9]+(M)?|\.[0-9]*[eE][+-]?[0-9]+(M)?){{wse}}'
      scope: constant.numeric.float.clojure
      captures:
        1: punctuation.definition.float.precision.clojure
        2: punctuation.definition.float.precision.clojure
        3: punctuation.definition.float.precision.clojure
        4: punctuation.definition.float.precision.clojure
      pop: 2
    - match: '{{wsb}}(##Inf|##-Inf|##NaN){{wse}}'
      scope: constant.numeric.float.clojure
      pop: 2

  deep_ratio:
    - match: '{{wsb}}[+-]?(0|[1-9][0-9]*)/[1-9][0-9]*{{wse}}'
      scope: constant.numeric.ratio.clojure
      pop: 2

  deep_symbol_def:
    - match: '{{wsb}}(?:ns|(?=def){{symbol}}|({{ns_symbol}})(/)(?=def){{symbol}}){{wse}}'
      scope: source.symbol.def.clojure
      captures:
        1: meta.namespace.symbol.clojure
        2: punctuation.definition.namespace.clojure
      pop: 1
      push: deep_list_second

  deep_symbol_name:
    - match: '{{wsb}}(?:{{symbol}}|({{ns_symbol}})(/)(?:/|{{sym_body}})+){{wse}}'
      scope: source.symbol.clojure entity.name.clojure
      captures:
        1: meta.namespace.symbol.clojure
        2: punctuation.definition.namespace.clojure
      pop: 1
      push: deep_list_rest

  deep_symbol_unused:
    - match: '{{wsb}}(?:(?=_){{symbol}}|({{ns_symbol}})(/)(?=_)(?:/|{{sym_body}})*){{wse}}'
      scope: source.symbol.unused.clojure
      captures:
        1: meta.namespace.symbol.clojure
        2: punctuation.definition.namespace.clojure
      pop: 2

  deep_symbol:
    - match: '{{wsb}}(?:{{symbol}}|({{ns_symbol}})(/)(?:/|{{sym_body}})+){{wse}}'
      scope: source.symbol.clojure
      captures:
        1: meta.namespace.symbol.clojure
        2: punctuation.definition.namespace.clojure
      pop: 2

  deep_list:
    - match: '(?=\()'
      branch_point: deep_open_parens
      branch:
        - deep_list_paren
        - deep_form_comment_paren

  deep_list_paren:
    - match: '\('
      scope: punctuation.section.parens.begin.clojure
      set: deep_list_first

  deep_list_first:
    - meta_scope: meta.parens.clojure
    - match: \)
      scope: punctuation.section.parens.end.clojure
      pop: 3
    - include: skip_forms
    - match: 'comment'
      fail: deep_open_parens
    - include: deep_symbol_def
    - match: '(?=\S)'
      set: deep_list_rest

  deep_list_second:
    - meta_scope: meta.parens.clojure
    - match: \)
      scope: punctuation.section.parens.end.clojure
      pop: 3
    - include: skip_forms
    - include: deep_symbol_name
    - match: '(?=\S)'
      set: deep_list_rest

  deep_list_rest:
    - meta_scope: meta.parens.clojure
    - match: \)
      scope: punctuation.section.parens.end.clojure
      pop: 3
    - include: main

  deep_form_comment_paren:
    - match: '\('
      scope: punctuation.section.parens.begin.clojure
      set: form_comment_first

  deep_form_comment_first:
    - meta_scope: comment.form.clojure
    - include: skip_forms
    - match: 'comment'
      set: deep_form_comment_rest
    - match: \)
      fail: deep_open_parens
    - match: '(?=\S)'
      fail: deep_open_parens

  deep_form_comment_rest:
    - meta_scope: comment.form.clojure
    - match: \)
      scope: punctuation.section.parens.end.clojure
      pop: 3
    - include: main

  deep_anonymous_fn:
    - match: '(#)(\()'
      captures:
        1: punctuation.definition.anon_fn.clojure
      scope: punctuation.section.parens.begin.clojure
      push:
      - meta_scope: meta.parens.clojure meta.function.anon.clojure
      - match: \)
        scope: punctuation.section.parens.end.clojure
        pop: 3
      - include: main

  deep_reader_conditional:
    - match: '(#\?@?)\s*\('
      captures:
        1: punctuation.definition.reader_conditional.clojure
      scope: punctuation.section.parens.begin.clojure
      push:
      - meta_scope: meta.parens.clojure meta.reader_conditional.clojure
      - match: '\)'
        scope: punctuation.section.parens.end.clojure
        pop: 3
      - include: main

  deep_vector:
    - match: \[
      scope: punctuation.section.brackets.begin.clojure
      push:
      - meta_scope: meta.brackets.clojure
      - match: \]
        scope: punctuation.section.brackets.end.clojure
        pop: 3
      - include: main

  deep_map:
    - match: '\{'
      scope: punctuation.section.braces.begin.clojure
      push:
      - meta_scope: meta.braces.clojure
      - match: \}
        scope: punctuation.section.braces.end.clojure
        pop: 3
      - include: main

  deep_set:
    - match: '#\{'
      scope: punctuation.section.braces.begin.clojure
      push:
      - meta_scope: meta.braces.clojure
      - match: \}
        scope: punctuation.section.braces.end.clojure
        pop: 3
      - include: main

  deep_tag:
    - match: '{{wsb}}(#inst\s*"\d\d\d\d(?:-[01]\d(?:-[0123]\d(?:T[012]\d(?::[012345]\d(?::[0123456]\d(?:[.]\d{1,9})?)?)?)?)?)?(?:Z|[-+][012]\d:[012345]\d)?"|(#inst\s*"[^"]*")){{wse}}'
      scope: constant.other.instant.clojure
      captures:
        2: invalid.illegal.instant.clojure
      pop: 2
    - match: '{{wsb}}(#uuid\s*"\h{8}-\h{4}-\h{4}-\h{4}-\h{12}"|(#uuid\s*"[^"]*")){{wse}}'
      scope: constant.other.uuid.clojure
      captures:
        2: invalid.illegal.uuid.clojure
      pop: 2
    - match: '{{wsb}}#(?![_#{])(?:{{symbol}}|{{ns_symbol}}(/){{symbol}}){{wse}}'
      scope: storage.type.tag.clojure
      pop: 2

  # ERRORS

  stray_bracket:
    - match: '[\]\)\}]'
      scope: invalid.illegal.stray-bracket-end
      pop:   1

  fail:
      - match: '(?=\S)'
        pop: 1