Markdown.sublime-syntax

%YAML 1.2
---
# This definition aims to meet CommonMark specifications
#   http://spec.commonmark.org/
# with GitHub Formatted Markdown extensions
#   https://github.github.com/gfm/
# and has a few extras like Markdown Extra's footnotes
#   https://michelf.ca/projects/php-markdown/extra/#footnotes
#
# The scope suffix should indicate which flavor of Markdown the feature came from,
# to help make this syntax definition easier to maintain.
name: Markdown
scope: text.html.markdown
version: 2

file_extensions:
  - md
  - mdown
  - mdwn
  - markdown
  - markdn

variables:
  atx_heading: (?:[ ]{,3}[#]{1,6}(?:[ \t]|$))         # between 0 and 3 spaces, followed 1 to 6 hashes, followed by at least one space or tab or by end of the line
  atx_heading_space: (?:(?=[ \t]+#+[ \t]*$)|[ \t]+|$) # consume spaces only if heading is not empty to ensure `atx_heading_end` can fully match closing hashes
  atx_heading_end: (?:[ \t]+(#+))?[ \t]*($\n?)        # \n is optional so ## is matched as end punctuation in new document (at eof)

  setext_heading_or_paragraph: ^(?:[ ]{,3}=+|(?=[ ]{,3}\S))   # between 0 and 3 spaces, followed by non-whitespace (consume equal signs as paragraphs may start with them)
  setext_heading_escape: ^(?=[ ]{,3}(?:=+|-+)[ \t]*$)         # between 0 and 3 spaces, followed by at least one hyphen or equal sign (setext underline can be of any length)
  setext_heading1_escape: ^(?=[ ]{,3}=+[ \t]*$)               # between 0 and 3 spaces, followed by at least one equal sign (setext underline can be of any length)
  setext_heading1_end: ^[ ]{,3}(=+)[ \t]*$(\n?)               # between 0 and 3 spaces, followed by at least one equal sign (setext underline can be of any length)
  setext_heading2_end: ^[ ]{,3}(-+)[ \t]*$(\n?)               # between 0 and 3 spaces, followed by at least one hyphen (setext underline can be of any length)

  list_setext_heading_or_paragraph: (?:[ \t]*=+|(?=[ \t]*\S))  # any number of spaces, followed by non-whitespace (consume equal signs as paragraphs may start with them)
  list_setext_heading_escape: ^(?=[ \t]{2,}(?:==+|--+)[ \t]*$) # two or more spaces, followed by at least one hyphen or equal sign (setext underline can be of any length, but ST needs at least 2 to avoid ambiguity with empty list items)
  list_setext_heading1_escape: ^(?=[ \t]{2,}==+[ \t]*$)        # two or more spaces, followed by at least one equal sign (setext underline can be of any length, but ST needs at least 2 to avoid ambiguity with empty list items)
  list_setext_heading1_end: ^[ \t]{2,}(==+)[ \t]*$(\n?)        # two or more spaces, followed by at least one equal sign (setext underline can be of any length, but ST needs at least 2 to avoid ambiguity with empty list items)
  list_setext_heading2_end: ^[ \t]{2,}(--+)[ \t]*$(\n?)        # two or more spaces, followed by at least one hyphen (setext underline can be of any length, but ST needs at least 2 to avoid ambiguity with empty list items)

  block_quote: (?:[ ]{,3}(>)[ ]?)                     # between 0 and 3 spaces, followed by a greater than sign, (followed by any character or the end of the line = "only care about optional space!")
  indented_code_block: (?:[ ]{4}|[ ]{0,3}\t)          # a visual tab of width 4 consisting of 4 spaces or 0 to 3 spaces followed by 1 tab

  first_list_item: (?:[ ]{,3}(?:1[.)]|[*+-])\s)       # between 0 and 3 spaces, followed by either: at least one integer and a full stop or a parenthesis, or (a star, plus or dash), followed by whitespace
  list_item: (?:[ ]{,3}(?:\d{1,9}[.)]|[*+-])\s)       # between 0 and 3 spaces, followed by either: at least one integer and a full stop or a parenthesis, or (a star, plus or dash), followed by whitespace

  thematic_break: |-
    (?x:
      [ ]{,3}                    # between 0 to 3 spaces
      (?:                        # followed by one of the following:
        [-](?:[ \t]*[-]){2,}     # - a dash,        followed by the following at least twice: any number of spaces or tabs followed by a dash
      | [*](?:[ \t]*[*]){2,}     # - a star,        followed by the following at least twice: any number of spaces or tabs followed by a star
      | [_](?:[ \t]*[_]){2,}     # - an underscore, followed by the following at least twice: any number of spaces or tabs followed by an underscore
      )
      [ \t]*$                    # followed by any number of tabs or spaces, followed by the end of the line
    )

  backticks: |-
    (?x:
      (`{4})[^`](?:[^`]|(?!`{4})`+[^`])*(`{4})(?!`)  # 4 backticks, followed by at least one non backtick character, followed by (less than 4 backticks, or at least one non backtick character) at least once, followed by exactly 4 backticks
    | (`{3})[^`](?:[^`]|(?!`{3})`+[^`])*(`{3})(?!`)  # 3 backticks, followed by at least one non backtick character, followed by (less than 3 backticks, or at least one non backtick character) at least once, followed by exactly 3 backticks
    | (`{2})[^`](?:[^`]|(?!`{2})`+[^`])*(`{2})(?!`)  # 2 backticks, followed by at least one non backtick character, followed by (less than 2 backticks, or at least one non backtick character) at least once, followed by exactly 2 backticks
    | (`{1})[^`](?:[^`]|(?!`{1})`+[^`])*(`{1})(?!`)  # 1 backtick,  followed by at least one non backtick character, followed by (                          at least one non backtick character) at least once, followed by exactly 1 backtick
    )
  escapes: \\[-+*/!"#$%&'(),.:;<=>?@\[\\\]^_`{|}~]

  balance_square_brackets: |-
    (?x:
      (?:
        \\.                               # maybe escaped character (be lazy)
      | [^\[\]`]                          # anything that isn't a square bracket or backtick
      | {{backticks}}                     # inline code
      | \[ (?:                            # nested square brackets (one level deep)
          \\.                             #  maybe escaped character (be lazy)
        | [^\[\]`]                        #  anything that isn't a square bracket or backtick
        | {{backticks}}                   #  inline code
        )* \]                             #  closing square bracket
      )+
    )
  balance_square_brackets_and_emphasis: |-
    (?x:
      (?:
        \\.                               # maybe escaped character (be lazy)
      | [^\[\]`_*]                        # anything that isn't a square bracket, backtick or emphasis
      | {{backticks}}                     # inline code
      | \[ (?:                            # nested square brackets (one level deep)
          \\.                             #  maybe escaped character (be lazy)
        | [^\[\]`_*]                      #  anything that isn't a square bracket, backtick or emphasis
        | {{backticks}}                   #  inline code
        )* \]                             #  closing square bracket
      )+                                  # at least one character
    )
  balance_square_brackets_pipes_and_emphasis: |-
    (?x:
      (?:
        \\.                               # maybe escaped character (be lazy)
      | [^\[\]`_*|]                       # anything that isn't a square bracket, backtick or emphasis or table cell separator
      | {{backticks}}                     # inline code
      | \[ (?:                            # nested square brackets (one level deep)
          \\.                             #  maybe escaped character (be lazy)
        | [^\[\]`_*|]                     #  anything that isn't a square bracket, backtick or emphasis or table cell separator
        | {{backticks}}                   #  inline code
        )* \]                             #  closing square bracket
      )+                                  # at least one character
    )
  balanced_emphasis: |-
    (?x:
      \*  (?!\*){{balance_square_brackets_and_emphasis}}\*  (?!\*)
    | \*\*      {{balance_square_brackets_and_emphasis}}\*\*
    | _   (?!_) {{balance_square_brackets_and_emphasis}}_   (?!_)
    | __        {{balance_square_brackets_and_emphasis}}__
    )

  table_cell: |-
    (?x:
      # Pipes inside other inline spans (such as emphasis, code, etc.) will not break a cell,
      # emphasis in table cells can't span multiple lines
      (?:
        {{balance_square_brackets_pipes_and_emphasis}}
      | {{balanced_emphasis}}
      )+  # at least one character
    )
  table_first_row: |-
    (?x:
      # at least 2 non-escaped pipe chars on the line
      (?:{{table_cell}}?\|){2}

      # something other than whitespace followed by a pipe char or hyphen,
      # followed by something other than whitespace and the end of the line
    | (?! \s*\-\s+ | \s+\|){{table_cell}}\|(?!\s+$)
    )

  table_codespan_content: |-
    (?x:
      [^`|]             # first or only char must not be a backtick or pipe.
      (?:[^|]*?[^`|])?   # none must be a pipe, the last additionally must not be a backtick
    )

  fenced_code_block_start: |-
    (?x:
      ([ \t]*)
      (
        (`){3,}      #   3 or more backticks
        (?![^`]*`)   #   not followed by any more backticks on the same line
      |              # or
        (~){3,}      #   3 or more tildas
      )
    )
  fenced_code_block_language: |-
    (?x:             # first word of an infostring is used as language specifier
      \s*            # allow for whitespace between code block start and info string
      (
        [[:alpha:]]  # starts with a letter to make sure not to hit any attribute annotation
        [^\s:;`]*    # optionally followed by any nonwhitespace character (except backticks)
      )
    )
  fenced_code_block_trailing_infostring_characters: |-
    (?x:
      (?:
        (?: \s+ | (?=[:;]) ) # separated by colon, semicolon or whitespace ...
        ([^`]+?)             # any characters (except backticks)
      )?
      (\s*$\n?)              # ... until EOL (fold begin marker)
    )
  fenced_code_block_end: |-
    (?x:
      [ \t]*
      (
        \2           # the backtick/tilde combination that opened the code fence
        (?:\3|\4)*   # plus optional additional closing characters
      )
      (\s*$\n?)      # any amount of whitespace until EOL (fold end marker)
    )
  fenced_code_block_escape: ^{{fenced_code_block_end}}

  # https://spec.commonmark.org/0.30/#email-autolink
  email_domain_commonmark: '[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?'
  email_user_commonmark: '[a-zA-Z0-9.!#$%&''*+/=?^_`{|}~-]+'

  # https://spec.commonmark.org/0.30/#html-blocks
  html_block: |-
    (?x:
      [ ]{,3}
      (?:
        {{html_tag_block_end_at_close_tag}}  # html block type 1
      | {{html_tag_block_end_at_blank_line}} # html block type 6
      | {{html_block_open_tag}}              # html block type 7
      | {{html_block_close_tag}}             # html block type 7
      | {{html_block_comment}}               # html block type 2
      | {{html_block_decl}}                  # html block type 4
      | {{html_block_cdata}}                 # html block type 5
      | {{html_block_preprocessor}}          # html block type 3
      )
    )
  html_block_comment: <!--
  html_block_cdata: <!\[CDATA\[
  html_block_decl: <![a-zA-Z]
  html_block_preprocessor: <\?
  html_block_open_tag: |-
    (?xi:
      <
      [a-z]             # A tag name consists of an ASCII letter
      [a-z0-9-]*        # followed by zero or more ASCII letters, digits, or hyphens (-)
      (?:               # An attribute consists of whitespace, an attribute name, and an optional attribute value specification
        \s+
        [a-z_:]         # An attribute name consists of an ASCII letter, _, or :
        [a-z0-9_.:-]*   # followed by zero or more ASCII letters, digits, _, ., :, or -
        (?:             # An attribute value specification consists of optional whitespace, a = character, optional whitespace, and an attribute value
          \s*
          =
          \s*
          (?:
            [^ @'=<>`]+ # An unquoted attribute value is a nonempty string of characters not including spaces, ", ', =, <, >, or `
          | '[^']*'     # A single-quoted attribute value consists of ', zero or more characters not including ', and a final '
          | "[^"]*"     # A double-quoted attribute value consists of ", zero or more characters not including ", and a final "
          )
        )?
      )*
      \s*
      /?
      >
      \s*$
    )
  html_block_close_tag: |-
    (?xi:
      </
      [a-z]             # A tag name consists of an ASCII letter
      [a-z0-9-]*        # followed by zero or more ASCII letters, digits, or hyphens (-)
      \s*
      >
      \s*$
    )
  html_tag_block_end_at_close_tag: |-
    <(?xi: pre | script | style | textarea ){{html_tag_break_char}}
  html_tag_block_end_at_blank_line: |-
    <(?xi:
      address | article | aside | base | basefont | blockquote | body | caption
    | c enter | col | colgroup | dd | details | dialog | dir | div | dl | dt
    | fieldset | figcaption | figure | footer | form | frame | frameset | h1 | h2
    | h3 | h4 | h5 | h6 | head | header | hr | html | iframe | legend | li | link
    | main | menu | menuitem | nav | noframes | ol | optgroup | option | p | param
    | section | source | summary | table | tbody | td | tfoot | th
    | thead | title | tr | track | ul
    ){{html_tag_maybe_selfclosing_break_char}}
  html_tag_break_char: (?:[ \t>]|$)
  html_tag_maybe_selfclosing_break_char: (?:[ \t]|/?>|$)

  html_entity: '&([a-zA-Z0-9]+|#\d+|#[Xx]\h+);'

  ascii_space: '\t\n\f '
  tag_attribute_name_start: (?=[^{{ascii_space}}=/>}])
  tag_attribute_name_break: (?=[{{ascii_space}}=/>}])
  tag_unquoted_attribute_start: (?=[^{{ascii_space}}=/>}])
  tag_unquoted_attribute_break: (?=[{{ascii_space}}}]|/?>)

  reference_definition: (?:\[{{reference_name}}\]\:)
  footnote_name: (?:\^(?:\\\]|[^]])+)
  reference_name: (?:(?:\\\]|[^]])+)

  paragraph_end: |-
    (?x: # pop out of this context if one of the following conditions are met:
      ^(?=\s*$                        # the line is blank (or only contains whitespace)
       |  {{block_quote}}             # a blockquote begins the line
       |  {{atx_heading}}             # an ATX heading begins the line
       |  {{fenced_code_block_start}} # a fenced codeblock begins the line
       |  {{thematic_break}}          # line is a thematic beak
       |  {{first_list_item}}         # a list item begins the line
       |  {{html_block}}              # a html block begins the line
       )
    )

  list_paragraph_end: |-
    (?x: # pop out of this context if one of the following conditions are met:
      ^(?= [ \t]*
        (?: $                           # the line is blank (or only contains whitespace)
        |   {{block_quote}}             # a blockquote begins the line
        |   {{atx_heading}}             # an ATX heading begins the line
        |   {{fenced_code_block_start}} # a fenced codeblock begins the line
        |   {{thematic_break}}          # line is a thematic beak
        |   {{list_item}}               # a list item begins the line
        |   {{html_block}}              # a html block begins the line
        )
      )
    )

  # https://spec.commonmark.org/0.30/#left-flanking-delimiter-run
  bold_italic_asterisk_begin: |-
    (?x:
         (\*\*)(\*) {{no_space_nor_punct}}
    | \B (\*\*)(\*) {{no_space_but_punct}}
    )

  bold_asterisk_begin: |-
    (?x:
         \*{2} {{no_space_nor_punct}}
    | \B \*{2} {{no_space_but_punct}}
    )

  italic_asterisk_begin: |-
    (?x:
         \* {{no_space_nor_punct}}
    | \B \* {{no_space_but_punct}}
    )

  no_escape_behind: (?<![^\\]\\)(?<![\\]{3})
  # not followed by Unicode whitespace and not followed by a Unicode punctuation character
  no_space_nor_punct: (?![\s*\p{P}])
  # not followed by Unicode whitespace and followed by a Unicode punctuation character
  no_space_but_punct: (?=[[^\s*]&&\p{P}])

##############################################################################

contexts:

  main:
    - include: frontmatter
    - match: ''
      set: markdown

  frontmatter:
    - match: (---)\s*(?i:(json)\s*)\n
      captures:
        0: meta.frontmatter.markdown
        1: punctuation.section.frontmatter.begin.markdown
        2: constant.other.language-name.markdown
      embed: scope:source.json
      embed_scope: meta.frontmatter.markdown source.json.embedded.markdown
      escape: ^(---|\.{3})\s*\n # pandoc requires the remainder of the line to be blank
      escape_captures:
        0: meta.frontmatter.markdown
        1: punctuation.section.frontmatter.end.markdown
    - match: (---)\s*(?i:(yaml|yml)\s*)?\n
      captures:
        0: meta.frontmatter.markdown
        1: punctuation.section.frontmatter.begin.markdown
        2: constant.other.language-name.markdown
      embed: scope:source.yaml
      embed_scope: meta.frontmatter.markdown source.yaml.embedded.markdown
      escape: ^(---|\.{3})\s*\n  # pandoc requires the remainder of the line to be blank
      escape_captures:
        0: meta.frontmatter.markdown
        1: punctuation.section.frontmatter.end.markdown

  markdown:
    - include: indented-code-blocks
    - include: thematic-breaks
    - include: block-quotes
    - include: list-blocks
    - include: tables
    - include: fenced-code-blocks
    - include: html-blocks
    - include: reference-definitions
    - include: atx-headings
    - include: setext-headings-or-paragraphs

  indented-markdown:
    # This is a public context which can be embedded by 3rd-party syntaxes
    # to support Markdown highlighting in locations of arbitrary indentation,
    # but without reference to list blocks as this is an implementation detail.
    # The content may diverge from list block content in future.
    - include: list-block-content

###[ CONTAINER BLOCKS: BLOCK QUOTES ]#########################################

  block-quotes:
    # https://spec.commonmark.org/0.30/#block-quotes
    - match: '[ \t]{,3}(>)[ ]?((\[)!CAUTION(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.caution.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-caution-meta
        - block-quote-body
    - match: '[ \t]{,3}(>)[ ]?((\[)!WARNING(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.warning.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-warning-meta
        - block-quote-body
    - match: '[ \t]{,3}(>)[ ]?((\[)!IMPORTANT(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.important.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-important-meta
        - block-quote-body
    - match: '[ \t]{,3}(>)[ ]?((\[)!NOTE(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.note.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-note-meta
        - block-quote-body
    - match: '[ \t]{,3}(>)[ ]?((\[)!TIP(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.tip.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-tip-meta
        - block-quote-body
    - match: '[ \t]{,3}(>)[ ]?'
      captures:
        1: punctuation.definition.blockquote.markdown
      push:
        - block-quote-meta
        - block-quote-body
        - block-quote-punctuation-body

  block-quote-caution-meta:
    - meta_include_prototype: false
    - meta_scope: markup.quote.alert.caution.markdown
    - include: immediately-pop

  block-quote-warning-meta:
    - meta_include_prototype: false
    - meta_scope: markup.quote.alert.warning.markdown
    - include: immediately-pop

  block-quote-important-meta:
    - meta_include_prototype: false
    - meta_scope: markup.quote.alert.important.markdown
    - include: immediately-pop

  block-quote-note-meta:
    - meta_include_prototype: false
    - meta_scope: markup.quote.alert.note.markdown
    - include: immediately-pop

  block-quote-tip-meta:
    - meta_include_prototype: false
    - meta_scope: markup.quote.alert.tip.markdown
    - include: immediately-pop

  block-quote-meta:
    - meta_include_prototype: false
    - meta_scope: markup.quote.markdown
    - include: immediately-pop

  block-quote-body:
    - include: block-quote-end
    - include: block-quote-punctuations
    - include: block-quote-content

  block-quote-content:
    - include: indented-code-blocks
    - include: block-quote-common
    - include: block-quote-paragraph

  block-quote-common:
    - include: thematic-breaks
    - include: atx-headings
    - include: block-quote-reference-definitions
    - include: block-quote-fenced-code-block
    - include: block-quote-list-block

  block-quote-end:
    - match: ^(?!(?:[ \t]*>))
      pop: 1

  block-quote-punctuations:
    - match: ^[ \t]{,3}(>)[ ]?
      captures:
        1: punctuation.definition.blockquote.markdown
      push: block-quote-punctuation-body

  block-quote-punctuation-body:
    - include: block-quote-punctuation-content
    - include: immediately-pop

  block-quote-punctuation-content:
    - match: '[ \t]{,3}(>)[ ]?'
      captures:
        1: punctuation.definition.blockquote.markdown

  block-quote-nested-punctuations:
    # Quotes signs in list items are not restricted by indentation level
    # for technical reasons.
    - match: ^[ \t]*(>)[ ]?
      captures:
        1: punctuation.definition.blockquote.markdown
      push: block-quote-nested-punctuation-body

  block-quote-nested-punctuation-body:
    - include: block-quote-nested-punctuation-content
    - include: immediately-pop

  block-quote-nested-punctuation-content:
    - match: '[ \t]*(>)[ ]?'
      captures:
        1: punctuation.definition.blockquote.markdown

###[ CONTAINER BLOCKS: BLOCK QUOTES > FENCED CODE BLOCKS ]####################

  block-quote-fenced-code-block:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          {{fenced_code_block_language}}?
          .*?(\s*$\n?)   # all characters until EOL
      captures:
        0: meta.code-fence.definition.begin.text.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: meta.fold.code-fence.begin.markdown
      push: block-quote-fenced-code-block-body

  block-quote-fenced-code-block-body:
    - include: block-quote-fenced-code-block-end
    - include: block-quote-fenced-code-block-content

  block-quote-fenced-code-block-content:
    - include: block-quote-punctuation-content
    - match: .*$\n?
      scope: markup.raw.code-fence.markdown-gfm

  block-quote-fenced-code-block-end:
    - include: block-quote-end
    - match: '{{fenced_code_block_end}}'
      captures:
        0: meta.code-fence.definition.end.text.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown
      pop: 1

###[ CONTAINER BLOCKS: BLOCK QUOTES > REFERENCE DEFINITIONS ]#################

  block-quote-reference-definitions:
    # https://spec.commonmark.org/0.30/#link-reference-definitions
    - include: block-quote-footnote-definitions
    - include: block-quote-link-definitions

  block-quote-footnote-definitions:
    # Mardown Extras Footnotes
    - match: '([ \t]*)(\[)({{footnote_name}})(\])(:)'
      captures:
        2: punctuation.definition.reference.begin.markdown
        3: entity.name.reference.link.markdown
        4: punctuation.definition.reference.end.markdown
        5: punctuation.separator.key-value.markdown
      push: block-quote-footnote-def-body

  block-quote-footnote-def-body:
    - meta_scope: meta.link.reference.def.footnote.markdown-extra
    - include: block-quote-footnote-def-end
    - include: block-quote-punctuations
    - include: block-quote-footnote-paragraphs

  block-quote-footnote-def-end:
    # A footnote definition is terminated by blocks not indented by at least 4 characters.
    # Note: The first space after a quotation punctuation is not counted for simplicity reasons.
    - match: ^(?!(?:[ \t]*>)+[ ](?:\1[ ]{4}|\s*$))
      pop: 1

  block-quote-footnote-paragraphs:
    - match: '[ \t]*(?=\S)'
      push: block-quote-footnote-paragraph-body

  block-quote-footnote-paragraph-body:
    - include: block-quote-footnote-paragraph-end
    - include: block-quote-punctuations
    - include: footnote-paragraph-common

  block-quote-footnote-paragraph-end:
    - match: |-
        (?x)
        # pop out of this context if one of the following conditions are met:
        ^(?= (?:[ \t]*>)* [ \t]*
           (?: $                           # the line is blank (or only contains whitespace)
           |   {{reference_definition}}    # a reference definition begins the line
           |   {{atx_heading}}             # an ATX heading begins the line
           |   {{fenced_code_block_start}} # a fenced codeblock begins the line
           |   {{thematic_break}}          # line is a thematic beak
           |   {{list_item}}               # a list item begins the line
           |   {{html_block}}              # a html block begins the line
           )
        )
      pop: 1

  block-quote-link-definitions:
    # https://spec.commonmark.org/0.30/#link-reference-definition
    - match: '[ \t]*(\[)({{reference_name}})(\])(:)'
      captures:
        1: punctuation.definition.reference.begin.markdown
        2: entity.name.reference.link.markdown
        3: punctuation.definition.reference.end.markdown
        4: punctuation.separator.key-value.markdown
      push:
        - block-quote-link-def-meta
        - block-quote-link-def-title
        - block-quote-link-def-url

  block-quote-link-def-meta:
    - meta_include_prototype: false
    - meta_scope: meta.link.reference.def.markdown
    - include: immediately-pop

  block-quote-link-def-title:
    - include: block-quote-nested-paragraph-end
    - include: block-quote-punctuations
    - include: link-title-begin
    - include: else-pop

  block-quote-link-def-url:
    - include: block-quote-nested-paragraph-end
    - include: block-quote-punctuations
    - match: <
      scope: punctuation.definition.link.begin.markdown
      set: block-quote-link-def-url-angled
    - match: (?=\S)
      set: link-def-url-unquoted

  block-quote-link-def-url-angled:
    - meta_content_scope: markup.underline.link.markdown
    - include: block-quote-punctuations
    - include: link-url-angled

###[ CONTAINER BLOCKS: BLOCK QUOTES > LIST BLOCKS ]###########################

  block-quote-list-block:
    - match: ([ \t]*)([*+-])((?:[ ](\[)([ xX])(\]))?\s)
      captures:
        1: markup.list.unnumbered.markdown
        2: markup.list.unnumbered.bullet.markdown punctuation.definition.list_item.markdown
        3: markup.list.unnumbered.markdown
        4: markup.checkbox.begin.markdown-gfm punctuation.definition.checkbox.begin.markdown-gfm
        5: markup.checkbox.mark.markdown-gfm
        6: markup.checkbox.end.markdown-gfm punctuation.definition.checkbox.end.markdown-gfm
      push: block-quote-unordered-list-block-body
    - match: ([ \t]*)(\d{1,9}([.)]))(\s)
      captures:
        1: markup.list.numbered.markdown
        2: markup.list.numbered.bullet.markdown
        3: punctuation.definition.list_item.markdown
        4: markup.list.numbered.markdown
      push: block-quote-ordered-list-block-body

  block-quote-ordered-list-block-body:
    - meta_content_scope: markup.list.numbered.markdown
    - include: block-quote-list-block-end
    - include: block-quote-list-block-content

  block-quote-unordered-list-block-body:
    - meta_content_scope: markup.list.unnumbered.markdown
    - include: block-quote-list-block-end
    - include: block-quote-list-block-content

  block-quote-list-block-content:
    - include: list-block-common
    - include: block-quote-fenced-code-block
    - include: block-quote-nested-punctuation-content
    - include: block-quote-reference-definitions
    - include: block-quote-list-paragraphs

  block-quote-list-block-end:
    - include: block-quote-end
    # A list block ends with the first unindented text block.
    # Note:
    #  This is a simplification as we can't count indentation levels.
    #  According to CommonMark, a list block ends as soon as a new paragraph
    #  starts which is less indented than the first list item's text.
    - match: ^(?=(?:[ \t]*>)+[ ]?\S)
      pop: 1

  block-quote-list-paragraphs:
    # A list paragraph doesn't support indented code blocks.
    - match: '[ \t]*(?=\S)'
      push: block-quote-list-paragraph-body

  block-quote-list-paragraph-body:
    - meta_scope: meta.paragraph.list.markdown
    - include: block-quote-nested-paragraph-end
    - include: block-quote-nested-punctuations
    - include: inlines

  block-quote-nested-paragraph-end:
    - match: |-
        (?x)
        # pop out of this context if one of the following conditions are met:
        ^(?= (?:[ \t]*>)* [ \t]*
           (?: $                           # the line is blank (or only contains whitespace)
           |   {{atx_heading}}             # an ATX heading begins the line
           |   {{fenced_code_block_start}} # a fenced codeblock begins the line
           |   {{thematic_break}}          # line is a thematic beak
           |   {{list_item}}               # a list item begins the line
           |   {{html_block}}              # a html block begins the line
           )
        )
      pop: 1

###[ CONTAINER BLOCKS: BLOCK QUOTES > PARAGRAPHS ]############################

  block-quote-paragraph:
    - match: '[ \t]*(?=\S)'
      push: block-quote-paragraph-body

  block-quote-paragraph-body:
    - meta_scope: markup.paragraph.markdown
    - include: block-quote-paragraph-end
    - include: block-quote-punctuations
    - include: inlines

  block-quote-paragraph-end:
    - match: |-
        (?x)
        # pop out of this context if one of the following conditions are met:
        ^(?= (?:[ \t]{,3}>)*
           (?: \s* $                       # the line is blank (or only contains whitespace)
           |   {{atx_heading}}             # an ATX heading begins the line
           |   {{fenced_code_block_start}} # a fenced codeblock begins the line
           |   {{thematic_break}}          # line is a thematic beak
           |   {{list_item}}               # a list item begins the line
           |   {{html_block}}              # a html block begins the line
           )
        )
      pop: 1

###[ CONTAINER BLOCKS: LISTS ]################################################

  list-blocks:
    - match: ([ \t]*)([*+-])((?:[ ](\[)([ xX])(\]))?\s)
      captures:
        1: markup.list.unnumbered.markdown
        2: markup.list.unnumbered.bullet.markdown punctuation.definition.list_item.markdown
        3: markup.list.unnumbered.markdown
        4: markup.checkbox.begin.markdown-gfm punctuation.definition.checkbox.begin.markdown-gfm
        5: markup.checkbox.mark.markdown-gfm
        6: markup.checkbox.end.markdown-gfm punctuation.definition.checkbox.end.markdown-gfm
      push: unordered-list-block
    - match: ([ \t]*)(\d{1,9}([.)]))(\s)
      captures:
        1: markup.list.numbered.markdown
        2: markup.list.numbered.bullet.markdown
        3: punctuation.definition.list_item.markdown
        4: markup.list.numbered.markdown
      push: ordered-list-block

  unordered-list-block:
    - meta_content_scope: markup.list.unnumbered.markdown
    - include: list-block-end
    - include: list-block-content

  ordered-list-block:
    - meta_content_scope: markup.list.numbered.markdown
    - include: list-block-end
    - include: list-block-content

  list-block-end:
    - match: ^(?=\S)
      pop: 1

  list-block-content:
    - include: fenced-code-blocks
    - include: html-blocks
    - include: reference-definitions
    - include: list-block-common
    - include: list-block-quotes
    - include: list-setext-headings-or-paragraphs

  list-block-common:
    - include: thematic-breaks
    - include: atx-headings
    - include: list-items

  list-items:
    - match: ([ \t]*)([*+-])((?:[ ](\[)([ xX])(\]))?\s)
      captures:
        1: markup.list.unnumbered.markdown
        2: markup.list.unnumbered.bullet.markdown punctuation.definition.list_item.markdown
        3: markup.list.unnumbered.markdown
        4: markup.checkbox.begin.markdown-gfm punctuation.definition.checkbox.begin.markdown-gfm
        5: markup.checkbox.mark.markdown-gfm
        6: markup.checkbox.end.markdown-gfm punctuation.definition.checkbox.end.markdown-gfm
    - match: ([ \t]*)(\d{1,9}([.)]))(\s)
      captures:
        1: markup.list.numbered.markdown
        2: markup.list.numbered.bullet.markdown
        3: punctuation.definition.list_item.markdown
        4: markup.list.numbered.markdown

  list-block-quotes:
    - match: '[ \t]{,3}(>)[ ]?((\[)!CAUTION(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.caution.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-caution-meta
        - list-block-quote-body
    - match: '[ \t]{,3}(>)[ ]?((\[)!WARNING(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.warning.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-warning-meta
        - list-block-quote-body
    - match: '[ \t]{,3}(>)[ ]?((\[)!IMPORTANT(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.important.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-important-meta
        - list-block-quote-body
    - match: '[ \t]{,3}(>)[ ]?((\[)!NOTE(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.note.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-note-meta
        - list-block-quote-body
    - match: '[ \t]{,3}(>)[ ]?((\[)!TIP(\]))'
      captures:
        1: punctuation.definition.blockquote.markdown
        2: markup.heading.alert.tip.markdown
        3: punctuation.definition.heading.begin.markdown
        4: punctuation.definition.heading.end.markdown
      push:
        - block-quote-tip-meta
        - list-block-quote-body
    - match: '[ \t]*(>)[ ]?'
      captures:
        1: punctuation.definition.blockquote.markdown
      push:
        - block-quote-meta
        - list-block-quote-body
        - block-quote-punctuation-body

  list-block-quote-body:
    - include: block-quote-end
    - include: list-block-quote-punctuations
    - include: list-block-quote-content

  list-block-quote-content:
    - include: indented-code-blocks
    - include: block-quote-common
    - include: list-block-quote-paragraph

  list-block-quote-punctuations:
    - match: ^[ \t]*(>)[ ]?
      captures:
        1: punctuation.definition.blockquote.markdown
      push: block-quote-punctuation-body

  list-block-quote-paragraph:
    - match: '[ \t]*(?=\S)'
      push: list-block-quote-paragraph-body

  list-block-quote-paragraph-body:
    - meta_scope: markup.paragraph.markdown
    - include: block-quote-nested-paragraph-end
    - include: list-block-quote-punctuations
    - include: inlines

  list-setext-headings-or-paragraphs:
    # A paragraph may start with a line of equal signs which must not be matched
    # as heading underline. This is achieved by consuming them here, which also
    # applies `meta.paragraph` scope as expected.
    # A line of dashes is already matched as thematic break and thus ignored.
    - match: '{{list_setext_heading_or_paragraph}}'
      branch_point: list-setext-headings-or-paragraphs
      branch:
        - list-paragraph
        - list-setext-heading2
        - list-setext-heading1

  list-setext-heading1:
    # https://spec.commonmark.org/0.30/#setext-headings
    - meta_scope: markup.heading.1.markdown
    - meta_content_scope: entity.name.section.markdown
    - match: '{{list_setext_heading1_end}}'
      captures:
        1: punctuation.definition.heading.setext.markdown
        2: meta.whitespace.newline.markdown
      pop: 1
    - include: setext-heading-content

  list-setext-heading2:
    # https://spec.commonmark.org/0.30/#setext-headings
    - meta_scope: markup.heading.2.markdown
    - meta_content_scope: entity.name.section.markdown
    - match: '{{list_setext_heading2_end}}'
      captures:
        1: punctuation.definition.heading.setext.markdown
        2: meta.whitespace.newline.markdown
      pop: 1
    - match: '{{list_setext_heading1_escape}}'
      fail: list-setext-headings-or-paragraphs
    - include: setext-heading-content

  list-paragraph:
    # https://spec.commonmark.org/0.30/#paragraphs
    - meta_scope: meta.paragraph.list.markdown
    - include: list-paragraph-fail
    - include: list-paragraph-end
    - include: list-math-blocks
    - include: inlines

  list-paragraph-end:
    - match: '{{list_paragraph_end}}'
      pop: 1

  list-paragraph-fail:
    - match: '{{list_setext_heading_escape}}'
      fail: list-setext-headings-or-paragraphs

###[ LEAF BLOCKS: ATX HEADINGS ]##############################################

  atx-headings:
    # https://spec.commonmark.org/0.30/#atx-headings
    # Note:
    #   Consume spaces and tabs after opening hashes so entity.name
    #   starts with first non-whitespace character,
    #   but don't do so if directly followed by closing hashes
    #   as terminator pattern requires them to match then.
    - match: '[ \t]*(#{1}){{atx_heading_space}}'
      captures:
        1: punctuation.definition.heading.begin.markdown
      push: atx-heading1-content
    - match: '[ \t]*(#{2}){{atx_heading_space}}'
      captures:
        1: punctuation.definition.heading.begin.markdown
      push: atx-heading2-content
    - match: '[ \t]*(#{3}){{atx_heading_space}}'
      captures:
        1: punctuation.definition.heading.begin.markdown
      push: atx-heading3-content
    - match: '[ \t]*(#{4}){{atx_heading_space}}'
      captures:
        1: punctuation.definition.heading.begin.markdown
      push: atx-heading4-content
    - match: '[ \t]*(#{5}){{atx_heading_space}}'
      captures:
        1: punctuation.definition.heading.begin.markdown
      push: atx-heading5-content
    - match: '[ \t]*(#{6}){{atx_heading_space}}'
      captures:
        1: punctuation.definition.heading.begin.markdown
      push: atx-heading6-content

  atx-heading1-content:
    - meta_scope: markup.heading.1.markdown
    - meta_content_scope: entity.name.section.markdown
    - include: atx-heading-content

  atx-heading2-content:
    - meta_scope: markup.heading.2.markdown
    - meta_content_scope: entity.name.section.markdown
    - include: atx-heading-content

  atx-heading3-content:
    - meta_scope: markup.heading.3.markdown
    - meta_content_scope: entity.name.section.markdown
    - include: atx-heading-content

  atx-heading4-content:
    - meta_scope: markup.heading.4.markdown
    - meta_content_scope: entity.name.section.markdown
    - include: atx-heading-content

  atx-heading5-content:
    - meta_scope: markup.heading.5.markdown
    - meta_content_scope: entity.name.section.markdown
    - include: atx-heading-content

  atx-heading6-content:
    - meta_scope: markup.heading.6.markdown
    - meta_content_scope: entity.name.section.markdown
    - include: atx-heading-content

  atx-heading-content:
    - match: '{{atx_heading_end}}'
      captures:
        1: punctuation.definition.heading.end.markdown
        2: meta.whitespace.newline.markdown
      pop: 1
    - include: emphasis
    - include: images
    - include: literals
    - include: links
    - include: markups

###[ LEAF BLOCKS: SETEXT HEADINGS OR PARAGRAPH ]##############################

  setext-headings-or-paragraphs:
    # A paragraph may start with a line of equal signs which must not be matched
    # as heading underline. This is achieved by consuming them here, which also
    # applies `meta.paragraph` scope as expected.
    # A line of dashes is already matched as thematic break and thus ignored.
    - match: '{{setext_heading_or_paragraph}}'
      branch_point: setext-headings-or-paragraphs
      branch:
        - paragraph
        - setext-heading2
        - setext-heading1

  setext-heading1:
    # https://spec.commonmark.org/0.30/#setext-headings
    - meta_scope: markup.heading.1.markdown
    - meta_content_scope: entity.name.section.markdown
    - match: '{{setext_heading1_end}}'
      captures:
        1: punctuation.definition.heading.setext.markdown
        2: meta.whitespace.newline.markdown
      pop: 1
    - include: setext-heading-content

  setext-heading2:
    # https://spec.commonmark.org/0.30/#setext-headings
    - meta_scope: markup.heading.2.markdown
    - meta_content_scope: entity.name.section.markdown
    - match: '{{setext_heading2_end}}'
      captures:
        1: punctuation.definition.heading.setext.markdown
        2: meta.whitespace.newline.markdown
      pop: 1
    - match: '{{setext_heading1_escape}}'
      fail: setext-headings-or-paragraphs
    - include: setext-heading-content

  setext-heading-content:
    - include: setext-hard-line-breaks
    - include: emphasis
    - include: images
    - include: literals
    - include: links
    - include: markups

  setext-hard-line-breaks:
    # This context consumes what 'hard-line-breaks' does for normal
    # paragraphs to avoid deadlock of ST's syntax engine.
    #
    # as workaround for
    #    https://github.com/sublimehq/sublime_text/issues/5415
    # causing
    #    https://github.com/sublimehq/Packages/issues/3494
    - match: '[ ]{2,}$'
    - match: '\\\n'

  paragraph:
    # https://spec.commonmark.org/0.30/#paragraphs
    - meta_scope: meta.paragraph.markdown
    - include: paragraph-fail
    - include: paragraph-end
    - include: math-blocks
    - include: inlines

  paragraph-end:
    - match: '{{paragraph_end}}'
      pop: 1

  paragraph-fail:
    - match: '{{setext_heading_escape}}'
      fail: setext-headings-or-paragraphs

###[ LEAF BLOCKS: INDENTED CODE BLOCKS ]######################################

  indented-code-blocks:
    # https://spec.commonmark.org/0.30/#indented-code-blocks
    - match: '{{indented_code_block}}'
      push: indented-code-block-body

  indented-code-block-body:
    - meta_scope: markup.raw.block.markdown
    - match: \n
      pop: 1

###[ LEAF BLOCKS: FENCED CODE BLOCKS ]########################################

  fenced-code-blocks:
    # https://spec.commonmark.org/0.30/#fenced-code-blocks
    - match: (?={{fenced_code_block_start}})
      push: fenced-code-block-content

  fenced-code-block-content:
    - match: $
      pop: 1
    - include: fenced-syntaxes
    - include: fenced-raw

  fenced-syntaxes:
    - include: fenced-actionscript
    - include: fenced-applescript
    - include: fenced-clojure
    - include: fenced-c
    - include: fenced-cpp
    - include: fenced-csharp
    - include: fenced-css
    - include: fenced-diff
    - include: fenced-dosbatch
    - include: fenced-erlang
    - include: fenced-graphviz
    - include: fenced-golang
    - include: fenced-haskell
    - include: fenced-html-php
    - include: fenced-html
    - include: fenced-java
    - include: fenced-javascript
    - include: fenced-jsonc
    - include: fenced-jspx
    - include: fenced-jsx
    - include: fenced-latex
    - include: fenced-lisp
    - include: fenced-lua
    - include: fenced-makefile
    - include: fenced-matlab
    - include: fenced-objc
    - include: fenced-objcpp
    - include: fenced-ocaml
    - include: fenced-perl
    - include: fenced-php
    - include: fenced-python
    - include: fenced-regexp
    - include: fenced-rscript
    - include: fenced-ruby
    - include: fenced-rust
    - include: fenced-scala
    - include: fenced-shell
    - include: fenced-sql
    - include: fenced-tsx
    - include: fenced-typescript
    - include: fenced-xml
    - include: fenced-yaml

  fenced-actionscript:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(actionscript|as))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.actionscript.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.actionscript.2
      embed_scope:
        markup.raw.code-fence.actionscript.markdown-gfm
        source.actionscript.2
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.actionscript.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-applescript:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(applescript|osascript|scpt))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.applescript.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.applescript
      embed_scope:
        markup.raw.code-fence.applescript.markdown-gfm
        source.applescript
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.applescript.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-clojure:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(clojure|clj))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.clojure.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.clojure
      embed_scope:
        markup.raw.code-fence.clojure.markdown-gfm
        source.clojure
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.clojure.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-c:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(c|h))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.c.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.c
      embed_scope:
        markup.raw.code-fence.c.markdown-gfm
        source.c
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.c.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-cpp:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(c\+\+|cc|cpp|cxx|h\+\+|hpp|hxx))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.c++.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.c++
      embed_scope:
        markup.raw.code-fence.c++.markdown-gfm
        source.c++
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.c++.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-csharp:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(csharp|c\#|cs))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.csharp.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.cs
      embed_scope:
        markup.raw.code-fence.csharp.markdown-gfm
        source.cs
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.csharp.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-css:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(css))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.css.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.css
      embed_scope:
        markup.raw.code-fence.css.markdown-gfm
        source.css
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.css.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-diff:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(u?diff|patch))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.diff.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.diff
      embed_scope:
        markup.raw.code-fence.diff.markdown-gfm
        source.diff
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.diff.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-dosbatch:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(bat(?:ch(?:file)?)?|cmd|(?:dos|win)batch))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.dosbatch.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.dosbatch
      embed_scope:
        markup.raw.code-fence.dosbatch.markdown-gfm
        source.dosbatch
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.dosbatch.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-erlang:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(erl(?:ang)?|escript))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.erlang.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.erlang
      embed_scope:
        markup.raw.code-fence.erlang.markdown-gfm
        source.erlang
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.erlang.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-graphviz:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(dot|graphviz|gv))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.graphviz.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.dot
      embed_scope:
        markup.raw.code-fence.graphviz.markdown-gfm
        source.dot
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.graphviz.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-golang:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(go(?:lang)?))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.go.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.go
      embed_scope:
        markup.raw.code-fence.go.markdown-gfm
        source.go
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.go.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-haskell:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(haskell|hsc?))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.haskell.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.haskell
      embed_scope:
        markup.raw.code-fence.haskell.markdown-gfm
        source.haskell
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.haskell.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-html-php:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(html\+php|phtml))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.html-php.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:embedding.php
      embed_scope:
        markup.raw.code-fence.html-php.markdown-gfm
        embedding.php
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.html-php.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-html:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(x?html))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.html.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:text.html.basic
      embed_scope:
        markup.raw.code-fence.html.markdown-gfm
        text.html.basic
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.html.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-java:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(java))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.java.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.java
      embed_scope:
        markup.raw.code-fence.java.markdown-gfm
        source.java
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.java.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-javascript:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(javascript|js|node))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.javascript.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.js
      embed_scope:
        markup.raw.code-fence.javascript.markdown-gfm
        source.js
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.javascript.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-jsonc:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(jsonc?))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.json.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.json
      embed_scope:
        markup.raw.code-fence.json.markdown-gfm
        source.json
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.json.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-jspx:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(jspx?))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.jsp.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:text.html.jsp
      embed_scope:
        markup.raw.code-fence.jsp.markdown-gfm
        text.html.jsp
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.jsp.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-jsx:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(jsx))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.jsx.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.jsx
      embed_scope:
        markup.raw.code-fence.jsx.markdown-gfm
        source.jsx
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.jsx.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-latex:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(latex|tex))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.latex.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:text.tex.latex
      embed_scope:
        markup.raw.code-fence.latex.markdown-gfm
        text.tex.latex
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.latex.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-lisp:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(lisp))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.lisp.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.lisp
      embed_scope:
        markup.raw.code-fence.lisp.markdown-gfm
        source.lisp
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.lisp.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-lua:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(lua))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.lua.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.lua
      embed_scope:
        markup.raw.code-fence.lua.markdown-gfm
        source.lua
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.lua.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-makefile:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(make(?:file)?|mf))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.makefile.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.makefile
      embed_scope:
        markup.raw.code-fence.makefile.markdown-gfm
        source.makefile
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.makefile.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-matlab:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(matlab))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.matlab.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.matlab
      embed_scope:
        markup.raw.code-fence.matlab.markdown-gfm
        source.matlab
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.matlab.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-objc:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(objc|obj-c|objectivec|objective-c))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.objc.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.objc
      embed_scope:
        markup.raw.code-fence.objc.markdown-gfm
        source.objc
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.objc.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-objcpp:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(objc\+\+|obj-c\+\+|objectivec\+\+|objective-c\+\+))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.objc++.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.objc++
      embed_scope:
        markup.raw.code-fence.objc++.markdown-gfm
        source.objc++
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.objc++.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-ocaml:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(ocaml))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.ocaml.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.ocaml
      embed_scope:
        markup.raw.code-fence.ocaml.markdown-gfm
        source.ocaml
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.ocaml.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-perl:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(perl5?))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.perl.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.perl
      embed_scope:
        markup.raw.code-fence.perl.markdown-gfm
        source.perl
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.perl.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-php:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(php|inc))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.php.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.php
      embed_scope:
        markup.raw.code-fence.php.markdown-gfm
        source.php
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.php.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-python:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(python3?|py))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.python.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.python
      embed_scope:
        markup.raw.code-fence.python.markdown-gfm
        source.python
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.python.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-regexp:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(regexp?))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.regexp.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.regexp
      embed_scope:
        markup.raw.code-fence.regexp.markdown-gfm
        source.regexp
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.regexp.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-rscript:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(rscript|r|splus))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.r.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.r
      embed_scope:
        markup.raw.code-fence.r.markdown-gfm
        source.r
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.r.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-ruby:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(ruby|rb|rbx))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.ruby.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.ruby
      embed_scope:
        markup.raw.code-fence.ruby.markdown-gfm
        source.ruby
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.ruby.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-rust:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(rust|rs))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.rust.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.rust
      embed_scope:
        markup.raw.code-fence.rust.markdown-gfm
        source.rust
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.rust.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-scala:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(scala))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.scala.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.scala
      embed_scope:
        markup.raw.code-fence.scala.markdown-gfm
        source.scala
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.scala.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-shell:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(console|bash|shell(?:-script)?|sh))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.shell.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.shell.bash.embedded.markdown
      embed_scope:
        markup.raw.code-fence.shell.markdown-gfm
        source.shell.bash.embedded.markdown
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.shell.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(zsh))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.shell.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.shell.zsh.embedded.markdown
      embed_scope:
        markup.raw.code-fence.shell.markdown-gfm
        source.shell.zsh.embedded.markdown
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.shell.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-sql:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(sql))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.sql.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.sql
      embed_scope:
        markup.raw.code-fence.sql.markdown-gfm
        source.sql
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.sql.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-tsx:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(tsx))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.tsx.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.tsx
      embed_scope:
        markup.raw.code-fence.tsx.markdown-gfm
        source.tsx
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.tsx.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-typescript:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(typescript|ts(?:node)?))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.typescript.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.ts
      embed_scope:
        markup.raw.code-fence.typescript.markdown-gfm
        source.ts
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.typescript.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-xml:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(atom|plist|svg|xjb|xml|xsd|xsl))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.xml.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:text.xml
      embed_scope:
        markup.raw.code-fence.xml.markdown-gfm
        text.xml
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.xml.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-yaml:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          (?i:\s*(yaml|yml))
          {{fenced_code_block_trailing_infostring_characters}}
      captures:
        0: meta.code-fence.definition.begin.yaml.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: comment.line.infostring.markdown
        7: meta.fold.code-fence.begin.markdown
      embed: scope:source.yaml
      embed_scope:
        markup.raw.code-fence.yaml.markdown-gfm
        source.yaml
      escape: '{{fenced_code_block_escape}}'
      escape_captures:
        0: meta.code-fence.definition.end.yaml.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown

  fenced-raw:
    - match: |-
         (?x)
          {{fenced_code_block_start}}
          {{fenced_code_block_language}}?
          .*?(\s*$\n?)   # all characters until EOL
      captures:
        0: meta.code-fence.definition.begin.text.markdown-gfm
        2: punctuation.definition.raw.code-fence.begin.markdown
        5: constant.other.language-name.markdown
        6: meta.fold.code-fence.begin.markdown
      push: fenced-raw-content

  fenced-raw-content:
    - meta_content_scope: markup.raw.code-fence.markdown-gfm
    - match: '{{fenced_code_block_escape}}'
      captures:
        0: meta.code-fence.definition.end.text.markdown-gfm
        1: punctuation.definition.raw.code-fence.end.markdown
        2: meta.fold.code-fence.end.markdown
      pop: 1

###[ LEAF BLOCKS: HTML BLOCKS ]###############################################

  # https://spec.commonmark.org/0.30/#html-blocks
  html-blocks:
    # Markdown formatting is disabled inside block-level tags.
    - match: ^[ \t]*(?=<((?i:pre|textarea)){{html_tag_break_char}})
      push:
        - html-block-pop-at-eol
        - html-block-type-1a
    # Markdown formatting is disabled inside block-level tags.
    - match: ^[ \t]*(?=<((?i:script|style)){{html_tag_break_char}})
      push:
        - html-block-pop-at-eol
        - html-block-type-1b
    # Markdown formatting is disabled inside block level tags and if a complete HTML tag is the only thing on the line.
    - match: ^[ \t]*(?={{html_tag_block_end_at_blank_line}}|{{html_block_open_tag}}|{{html_block_close_tag}})
      push: html-block-type-6
    # Markdown formatting is disabled inside comments.
    - match: ^[ \t]*(?={{html_block_comment}})
      push:
        - html-block-pop-at-eol
        - html-block-type-2
    # Markdown formatting is disabled inside preprocessor instructions.
    - match: ^[ \t]*(?={{html_block_preprocessor}})
      push:
        - html-block-pop-at-eol
        - html-block-type-3
    # Markdown formatting is disabled inside doctype declarations.
    - match: ^[ \t]*(?={{html_block_decl}})
      push:
        - html-block-pop-at-eol
        - html-block-type-4
    # Markdown formatting is disabled inside CDATA.
    - match: ^[ \t]*(?={{html_block_cdata}})
      push:
        - html-block-pop-at-eol
        - html-block-type-5

  html-block-type-1a:
    - match: (</)(\1)(>)
      captures:
        0: meta.tag.block.any.html
        1: punctuation.definition.tag.begin.html
        2: entity.name.tag.block.any.html
        3: punctuation.definition.tag.end.html
      pop: 1
    - include: html-content

  html-block-type-1b:
    - match: (?!</?\1>)
      pop: 1
    - include: html-content

  html-block-type-2:
    - match: (?!{{html_block_comment}})
      pop: 1
    - include: html-content

  html-block-type-3:
    - match: \?>
      pop: 1

  html-block-type-4:
    - match: (?!{{html_block_decl}})
      pop: 1
    - include: html-content
    - match: '{{html_block_decl}}'
      set: html-block-type-4-other

  html-block-type-4-other:
    - match: '>'
      pop: 1

  html-block-type-5:
    - match: (?!{{html_block_cdata}})
      pop: 1
    - include: html-content

  html-block-type-6:
    - meta_scope: meta.disable-markdown
    - match: ^\s*\n
      pop: 1
    - include: html-content

  html-block-pop-at-eol:
    - meta_scope: meta.disable-markdown
    - match: $\n?
      pop: 1
    - include: html-content

  html-content:
    - include: scope:text.html.basic

  html-entities:
    # https://spec.commonmark.org/0.30/#entity-and-numeric-character-references
    - include: scope:text.html.basic#entities

###[ LEAF BLOCKS: LINK REFERENCE DEFINITIONS ]################################

  reference-definitions:
    # https://spec.commonmark.org/0.30/#link-reference-definitions
    - include: footnote-definitions
    - include: link-definitions

  footnote-definitions:
    # Mardown Extras Footnotes
    - match: '([ \t]*)(\[)({{footnote_name}})(\])(:)'
      captures:
        2: punctuation.definition.reference.begin.markdown
        3: entity.name.reference.link.markdown
        4: punctuation.definition.reference.end.markdown
        5: punctuation.separator.key-value.markdown
      push: footnote-def-body

  footnote-def-body:
    - meta_scope: meta.link.reference.def.footnote.markdown-extra
    - include: footnote-def-end
    - include: footnote-paragraphs

  footnote-def-end:
    - match: ^(?!(?:\1[ ]{4}|\s*$))
      pop: 1

  footnote-paragraphs:
    - match: '[ \t]*(?=\S)'
      push: footnote-paragraph-body

  footnote-paragraph-body:
    - include: footnote-paragraph-end
    - include: footnote-paragraph-common

  footnote-paragraph-common:
    - include: emphasis
    - include: images
    - include: literals
    - include: links

  footnote-paragraph-end:
    - match: |-
        (?x)
        # pop out of this context if one of the following conditions are met:
        ^(?= [ \t]*
           (?: $                           # the line is blank (or only contains whitespace)
           |   {{reference_definition}}    # a reference definition begins the line
           |   {{atx_heading}}             # an ATX heading begins the line
           |   {{fenced_code_block_start}} # a fenced codeblock begins the line
           |   {{thematic_break}}          # line is a thematic beak
           |   {{list_item}}               # a list item begins the line
           |   {{html_block}}              # a html block begins the line
           )
        )
      pop: 1

  link-definitions:
    # https://spec.commonmark.org/0.30/#link-reference-definition
    - match: '[ \t]*(\[)({{reference_name}})(\])(:)'
      captures:
        1: punctuation.definition.reference.begin.markdown
        2: entity.name.reference.link.markdown
        3: punctuation.definition.reference.end.markdown
        4: punctuation.separator.key-value.markdown
      push:
        - link-def-meta
        - link-def-attr
        - link-def-title
        - link-def-url

  link-def-meta:
    - meta_include_prototype: false
    - meta_scope: meta.link.reference.def.markdown
    - include: immediately-pop

  link-def-attr:
    - match: \{
      scope: punctuation.definition.attributes.begin.markdown
      set: link-def-attr-body
    - match: ^(?!\s*{)|(?=\S)
      pop: 1

  link-def-attr-body:
    - meta_scope: meta.attributes.markdown
    - include: tag-attributes

  link-def-title:
    - match: ^(?!\s*["'(])
      pop: 1
    - match: (?=["'(])
      set:
        - expect-attr-or-eol
        - link-title
    - match: (?=\{)
      pop: 1
    - match: \S.+
      scope: invalid.illegal.expected-eol.markdown

  expect-attr-or-eol:
    - match: (?=\{)
      pop: 1
    - include: expect-eol

  link-def-url:
    - match: <
      scope: punctuation.definition.link.begin.markdown
      set: link-def-url-angled
    - match: (?=\S)
      set: link-def-url-unquoted
    - include: paragraph-end

  link-def-url-angled:
    - meta_content_scope: markup.underline.link.markdown
    - include: link-url-angled

  link-def-url-unquoted:
    - meta_scope: markup.underline.link.markdown
    # URLs are terminated by whitespace or newline in reference definitions
    # Note: \s includes \n
    - match: (?=\s)
      pop: 1
    - include: link-url-common

###[ LEAF BLOCKS: TABLES ]####################################################

  tables:
    - match: ^(?={{table_first_row}})
      push: table-header

  table-header:
    - meta_scope: meta.table.header.markdown-gfm
    - match: \n
      set: table-header-separator-begin
    - include: table-cell-content

  table-header-separator-begin:
    - match: ^(?=[-|:\s]+$)
      set: table-header-separator
    - match: ^
      pop: 1

  table-header-separator:
    - meta_scope: meta.table.header-separator.markdown-gfm
    - match: \n
      set: table-body
    - match: -+
      scope: punctuation.section.table-header.markdown
    - match: ':'
      scope: punctuation.definition.table-cell-alignment.markdown
    - include: table-cell-separators

  table-body:
    - meta_content_scope: meta.table.markdown-gfm
    - include: table-end
    - include: table-cell-content

  table-end:
    # The table is broken at the first empty line, or beginning of another block-level structure
    - match: |-
          (?x)^
          (?= \s*$
          |   {{atx_heading}}
          |   {{block_quote}}
          |   {{fenced_code_block_start}}
          |   {{indented_code_block}}
          |   {{thematic_break}}
          )
      pop: 1

  table-cell-content:
    - match: (?={{balanced_emphasis}})
      push: table-cell-emphasis
    - include: table-cell-code-spans
    - include: table-cell-separators
    - include: images
    - include: critics
    - include: math-inline
    - include: escapes
    - include: links
    - include: markups

  table-cell-code-spans:
    # code-spans quoted with up to 6 backticks are supported
    # to avoid usage of slower Oniguruma features
    - match: (`{6}){{table_codespan_content}}(`{6})(?!`)
      scope: markup.raw.inline.markdown
      captures:
        1: punctuation.definition.raw.begin.markdown
        2: punctuation.definition.raw.end.markdown
    - match: (`{5}){{table_codespan_content}}(`{5})(?!`)
      scope: markup.raw.inline.markdown
      captures:
        1: punctuation.definition.raw.begin.markdown
        2: punctuation.definition.raw.end.markdown
    - match: (`{4}){{table_codespan_content}}(`{4})(?!`)
      scope: markup.raw.inline.markdown
      captures:
        1: punctuation.definition.raw.begin.markdown
        2: punctuation.definition.raw.end.markdown
    - match: (`{3}){{table_codespan_content}}(`{3})(?!`)
      scope: markup.raw.inline.markdown
      captures:
        1: punctuation.definition.raw.begin.markdown
        2: punctuation.definition.raw.end.markdown
    - match: (`{2}){{table_codespan_content}}(`{2})(?!`)
      scope: markup.raw.inline.markdown
      captures:
        1: punctuation.definition.raw.begin.markdown
        2: punctuation.definition.raw.end.markdown
    - match: (`{1}){{table_codespan_content}}(`{1})(?!`)
      scope: markup.raw.inline.markdown
      captures:
        1: punctuation.definition.raw.begin.markdown
        2: punctuation.definition.raw.end.markdown
    - match: \`+  # consume remainers

  table-cell-emphasis:
    - include: emphasis
    - include: immediately-pop

  table-cell-separators:
    - match: \|
      scope: punctuation.separator.table-cell.markdown

###[ LEAF BLOCKS: THEMATIC BREAKS ]###########################################

  thematic-breaks:
    # https://spec.commonmark.org/0.30/#thematic-breaks
    - match: (?={{thematic_break}})
      push: thematic-break-body

  thematic-break-body:
    - meta_include_prototype: false
    - meta_scope: meta.separator.thematic-break.markdown
    - match: '[-_*]+'
      scope: punctuation.definition.thematic-break.markdown
    - match: \n
      pop: 1

###[ INLINE ]#################################################################

  inlines:
    - include: hard-line-breaks
    - include: emphasis
    - include: images
    - include: literals
    - include: links
    - include: markups

  emphasis:
    - include: bold
    - include: italic
    - include: strikethrough

  images:
    - include: image-inline
    - include: image-ref

  literals:
    - include: code-spans
    - include: critics
    - include: math-inline
    - include: escapes

  links:
    - include: autolink-email
    - include: autolink-inet
    - include: link-ref-wiki
    - include: link-ref-footnote
    - include: link-ref-literal
    - include: link-inline
    - include: link-ref

  markups:
    # Markdown will convert this for us. We match it so that the
    # HTML grammar will not mark it up as invalid.
    - match: '[<>](-+|=+)[<>]?'
    - match: '[<>]?(-+|=+)[<>]'
    - match: '<<+|<>|>>+'
    - match: <(?![A-Za-z/?!])
    - include: html-content

###[ INLINE: CODE SPANS ]#####################################################

  code-spans:
    # https://spec.commonmark.org/0.30/#code-spans
    - match: (?=`+)
      branch_point: code-spans
      branch:
        - code-span
        - no-code-span

  code-span:
    - match: (`+)
      scope: punctuation.definition.raw.begin.markdown
      set: code-span-body

  code-span-body:
    - meta_scope: markup.raw.inline.markdown
    - match: \1(?!`)
      scope: punctuation.definition.raw.end.markdown
      pop: 1
    - match: \`+
    - match: '{{list_paragraph_end}}'
      fail: code-spans

  no-code-span:
    - match: \`+
      pop: 1

###[ INLINE: EMPHASIS ]#######################################################

  bold:
    # https://spec.commonmark.org/0.30/#emphasis-and-strong-emphasis
    - match: '{{bold_italic_asterisk_begin}}'
      captures:
        1: punctuation.definition.bold.begin.markdown
        2: markup.italic.markdown punctuation.definition.italic.begin.markdown
        3: punctuation.definition.bold.begin.markdown
        4: markup.italic.markdown punctuation.definition.italic.begin.markdown
      push: bold-italic-asterisk
    - match: '{{bold_asterisk_begin}}'
      scope: punctuation.definition.bold.begin.markdown
      push: bold-asterisk
    - match: \b(__)(_)(?=\S)(?!_)
      captures:
        1: punctuation.definition.bold.begin.markdown
        2: markup.italic.markdown punctuation.definition.italic.begin.markdown
      push: bold-italic-underscore
    - match: \b__(?=\S)(?!_[_\s])
      scope: punctuation.definition.bold.begin.markdown
      push: bold-underscore

  bold-asterisk:
    - meta_scope: markup.bold.markdown
    - match: |-
        (?x)
          [ \t]*\*{4,}    # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+\*\*+     # whitespace followed by 2 or more is also not applicable
        | ^\*\*           # emphasis can't be closed at the start of the line
    - match: (?:_)?(\*\*)
      captures:
        1: punctuation.definition.bold.end.markdown
      pop: 1
    # Consume the underscore that has no corresponding underscore before the closing bold
    # punctuation on the same line, as it won't be treated as italic by CommonMark
    - match: \b_(?=[^\s_])(?=[^*_]*\*\*)
    - include: bold-common

  bold-underscore:
    - meta_scope: markup.bold.markdown
    - match: |-
        (?x)
          [ \t]*_{4,}     # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+__+       # whitespace followed by 2 or more is also not applicable
        | ^__             # emphasis can't be closed at the start of the line
    - match: (?:\*)?(__\b)
      captures:
        1: punctuation.definition.bold.end.markdown
      pop: 1
    # Consume the asterisk that has no corresponding asterisk before the closing bold
    # punctuation on the same line, as it won't be treated as italic by CommonMark
    - match: \*(?=[^\s*])(?=[^*_]*__\b)
    - include: bold-common

  bold-italic-asterisk:
    - meta_scope: markup.bold.markdown
    - meta_content_scope: markup.italic.markdown
    - match: |-
        (?x)
          [ \t]*\*{4,}    # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+\*(?!\*)  # whitespace followed by 1 is also not applicable (but whitespace followed by 2 could be bold punctuation)
        | ^\*(?!\*)       # emphasis can't be closed at the start of the line
    - match: (\*)(\*\*)
      captures:
        1: markup.italic.markdown punctuation.definition.italic.end.markdown
        2: punctuation.definition.bold.end.markdown
      pop: 1
    - match: \*\*
      scope: markup.italic.markdown punctuation.definition.bold.end.markdown
      set: italic-after-bold-italic-asterisk
    - match: \*
      scope: markup.italic.markdown punctuation.definition.italic.end.markdown
      set: bold-after-bold-italic-asterisk
    - include: emphasis-common
    - include: strikethrough

  bold-after-bold-italic-asterisk:
    - meta_content_scope: markup.bold.markdown
    - match: |-
        (?x)
          [ \t]*\*{3,}    # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+\*\*+     # whitespace followed by 1 is also not applicable (but whitespace followed by 2 could be bold punctuation)
        | ^\*\*           # emphasis can't be closed at the start of the line
    - match: \*\*
      scope: markup.bold.markdown punctuation.definition.bold.end.markdown
      pop: 1
    - include: bold-common

  italic-after-bold-italic-asterisk:
    - meta_content_scope: markup.italic.markdown
    - match: |-
        (?x)
          [ \t]*\*{3,}    # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+\*\*+     # whitespace followed by 1 is also not applicable (but whitespace followed by 2 could be bold punctuation)
        | ^\*\*           # emphasis can't be closed at the start of the line
    - match: \*
      scope: markup.italic.markdown punctuation.definition.italic.end.markdown
      pop: 1
    - include: italic-common

  bold-italic-underscore:
    - meta_scope: markup.bold.markdown
    - meta_content_scope: markup.italic.markdown
    - match: |-
        (?x)
          [ \t]*_{4,}     # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+_(?!_)    # whitespace followed by 1 is also not applicable (but whitespace followed by 2 could be bold punctuation)
        | ^_(?!_)         # emphasis can't be closed at the start of the line
    - match: (_)(__)\b
      captures:
        1: markup.italic.markdown punctuation.definition.italic.end.markdown
        2: punctuation.definition.bold.end.markdown
      pop: 1
    - match: _\b
      scope: markup.italic.markdown punctuation.definition.italic.end.markdown
      set: bold-after-bold-italic-underscore
    - match: __\b
      scope: markup.italic.markdown punctuation.definition.bold.end.markdown
      set: italic-after-bold-italic-underscore
    - include: emphasis-common
    - include: strikethrough

  bold-after-bold-italic-underscore:
    - meta_content_scope: markup.bold.markdown
    - match: |-
        (?x)
          [ \t]*_{3,}     # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+__+       # whitespace followed by 1 is also not applicable (but whitespace followed by 2 could be bold punctuation)
        | ^__             # emphasis can't be closed at the start of the line
    - match: __\b
      scope: markup.bold.markdown punctuation.definition.bold.end.markdown
      pop: 1
    - include: bold-common

  italic-after-bold-italic-underscore:
    - meta_content_scope: markup.italic.markdown
    - match: |-
        (?x)
          [ \t]*_{3,}     # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+__+       # whitespace followed by 1 is also not applicable (but whitespace followed by 2 could be bold punctuation)
        | ^__             # emphasis can't be closed at the start of the line
    - match: _\b
      scope: markup.italic.markdown punctuation.definition.italic.end.markdown
      pop: 1
    - include: italic-common

  bold-common:
    - include: emphasis-common
    - include: italic
    - include: strikethrough

  italic:
    - match: '{{italic_asterisk_begin}}'
      scope: punctuation.definition.italic.begin.markdown
      push: italic-asterisk
    - match: \b_(?=\S)(?!_)
      scope: punctuation.definition.italic.begin.markdown
      push: italic-underscore
    - match: '[*_]+'

  italic-asterisk:
    - meta_scope: markup.italic.markdown
    - match: |-
        (?x)
          [ \t]*\*{4,}    # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+\*(?!\*)  # whitespace followed by 1 is also not applicable (but whitespace followed by 2 could be bold punctuation)
        | ^\*(?!\*)       # emphasis can't be closed at the start of the line
    - match: \*(?!\*[^*])
      scope: punctuation.definition.italic.end.markdown
      pop: 1
    - match: \*+
    - include: italic-common

  italic-underscore:
    - meta_scope: markup.italic.markdown
    - match: |-
        (?x)
          [ \t]*_{4,}     # if there are more than 3 its not applicable to be bold or italic
        | [ \t]+_(?!_)    # whitespace followed by 1 is also not applicable (but whitespace followed by 2 could be bold punctuation)
        | ^_(?!_)         # emphasis can't be closed at the start of the line
    - match: _\b
      scope: punctuation.definition.italic.end.markdown
      pop: 1
    - include: italic-common

  italic-common:
    - include: emphasis-common
    - include: bold
    - include: strikethrough

  strikethrough:
    # https://github.github.com/gfm/#strikethrough-extension-
    - match: ~~(?![~}>\s])  # 2x ~ but no ~> or ~~}
      scope: punctuation.definition.strikethrough.begin.markdown
      push: strikethrough-content
    - match: ~+(?![~}>\s])  # any number of ~ not looking like ~> or ~~}

  strikethrough-content:
    - meta_scope: markup.strikethrough.markdown-gfm
    - match: ~~(?:(?!~)|(?=~~}|~>))  # 2x ~ maybe followed by ~> or ~~}
      scope: punctuation.definition.strikethrough.end.markdown
      pop: 1
    - match: ~+(?:(?!~)|(?=~~}|~>))  # any number of ~ maybe followed by ~> or ~~}
    - include: emphasis-common
    - include: bold
    - include: italic

  emphasis-common:
    - match: '{{setext_heading_escape}}'
      pop: 1
    - match: ^\s*$\n?
      scope: invalid.illegal.non-terminated.bold-italic.markdown
      pop: 1
    - include: paragraph-end
    - include: hard-line-breaks
    - include: images
    - include: literals
    - include: links
    - include: markups

###[ INLINE: IMAGES ]#########################################################

  image-inline:
    - match: \!\[(?={{balance_square_brackets}}?\]\()
      scope: punctuation.definition.image.begin.markdown
      push:
        - image-inline-metadata
        - image-inline-text

  image-inline-text:
    - meta_scope: meta.image.inline.description.markdown
    - match: \]
      scope: punctuation.definition.image.end.markdown
      pop: 1
    - include: link-text

  image-inline-metadata:
    - match: \(
      scope: punctuation.definition.metadata.begin.markdown
      set:
        - image-inline-metadata-end
        - link-title
        - image-inline-url
    - include: immediately-pop

  image-inline-metadata-end:
    - meta_scope: meta.image.inline.metadata.markdown
    - match: \)
      scope: punctuation.definition.metadata.end.markdown
      set: image-inline-attr
    - include: else-pop

  image-inline-url:
    - match: <
      scope: punctuation.definition.link.begin.markdown
      set: image-inline-url-angled
    - match: (?=\S)
      set: image-inline-url-unquoted

  image-inline-url-angled:
    - meta_content_scope: markup.underline.link.image.markdown
    - include: link-url-angled

  image-inline-url-unquoted:
    - meta_scope: markup.underline.link.image.markdown
    - include: link-url-unquoted

  image-inline-attr:
    - match: \{(?=[^}]*\})
      scope: punctuation.definition.attributes.begin.markdown
      set: image-inline-attr-body
    - include: immediately-pop

  image-inline-attr-body:
    - meta_scope: meta.image.inline.attributes.markdown
    - include: tag-attributes

  image-ref:
    - match: \!\[(?={{balance_square_brackets}}?\]\[{{reference_name}}\])
      scope: punctuation.definition.image.begin.markdown
      push:
        - image-ref-attr
        - image-ref-metadata
        - image-ref-text

  image-ref-text:
    - meta_scope: meta.image.reference.description.markdown
    - match: \]
      scope: punctuation.definition.image.end.markdown
      pop: 1
    - include: link-text

  image-ref-metadata:
    - match: (\[)({{reference_name}})(\])
      scope: meta.image.reference.metadata.markdown
      captures:
        1: punctuation.definition.metadata.begin.markdown
        2: markup.underline.link.markdown
        3: punctuation.definition.metadata.end.markdown
      pop: 1
    - include: immediately-pop

  image-ref-attr:
    - match: \{(?=[^}]*\})
      scope: punctuation.definition.attributes.begin.markdown
      set: image-ref-attr-body
    - include: immediately-pop

  image-ref-attr-body:
    - meta_scope: meta.image.reference.markdown
    - include: tag-attributes

###[ INLINE: LINKS ]##########################################################

  link-inline:
    - match: \[(?={{balance_square_brackets}}?\]\()
      scope: punctuation.definition.link.begin.markdown
      push:
        - link-inline-metadata
        - link-inline-text

  link-inline-text:
    - meta_scope: meta.link.inline.description.markdown
    - match: \]
      scope: punctuation.definition.link.end.markdown
      pop: 1
    - include: link-text-allow-image

  link-inline-metadata:
    - match: \(
      scope: punctuation.definition.metadata.begin.markdown
      set:
        - link-inline-metadata-end
        - link-title
        - link-inline-url
    - include: immediately-pop

  link-inline-metadata-end:
    - meta_scope: meta.link.inline.metadata.markdown
    - match: \)
      scope: punctuation.definition.metadata.end.markdown
      set: link-inline-attr
    - include: else-pop

  link-inline-url:
    - match: <
      scope: punctuation.definition.link.begin.markdown
      set: link-inline-url-angled
    - match: (?=\S)
      set: link-inline-url-unquoted

  link-inline-url-angled:
    - meta_content_scope: markup.underline.link.markdown
    - include: link-url-angled

  link-inline-url-unquoted:
    - meta_scope: markup.underline.link.markdown
    - include: link-url-unquoted

  link-inline-attr:
    - match: \{(?=[^}]*\})
      scope: punctuation.definition.attributes.begin.markdown
      set: link-inline-attr-body
    - include: immediately-pop

  link-inline-attr-body:
    - meta_scope: meta.link.inline.attributes.markdown
    - include: tag-attributes

  link-ref:
    - match: \[(?={{balance_square_brackets}}?\]\[{{reference_name}}\])
      scope: punctuation.definition.link.begin.markdown
      push:
        - link-ref-attr
        - link-ref-metadata
        - link-ref-link-text
    - match: \[(?={{balance_square_brackets}}?\])
      scope: punctuation.definition.link.begin.markdown
      push: link-ref-link-text

  link-ref-link-text:
    - meta_scope: meta.link.reference.description.markdown
    - match: \]
      scope: punctuation.definition.link.end.markdown
      pop: 1
    - include: link-text-allow-image

  link-ref-metadata:
    - match: (\[)({{reference_name}})(\])
      scope: meta.link.reference.metadata.markdown
      captures:
        1: punctuation.definition.metadata.begin.markdown
        2: markup.underline.link.markdown
        3: punctuation.definition.metadata.end.markdown
      pop: 1
    - include: immediately-pop

  link-ref-attr:
    - match: \{(?=[^}]*\})
      scope: punctuation.definition.attributes.begin.markdown
      set: link-ref-attr-body
    - include: immediately-pop

  link-ref-attr-body:
    - meta_scope: meta.link.reference.attributes.markdown
    - include: tag-attributes

  link-ref-literal:
    - match: \[(?={{balance_square_brackets}}?\]\[\])
      scope: punctuation.definition.link.begin.markdown
      push:
        - link-ref-literal-attr
        - link-ref-literal-metadata
        - link-ref-literal-link-text

  link-ref-literal-link-text:
    - meta_scope: meta.link.reference.literal.description.markdown
    - match: \]
      scope: punctuation.definition.link.end.markdown
      pop: 1
    - include: link-text-allow-image

  link-ref-literal-metadata:
    - match: (\[)(\])
      scope: meta.link.reference.literal.metadata.markdown
      captures:
        1: punctuation.definition.metadata.begin.markdown
        2: punctuation.definition.metadata.end.markdown
      pop: 1
    - include: immediately-pop

  link-ref-literal-attr:
    - match: \{(?=[^}]*\})
      scope: punctuation.definition.attributes.begin.markdown
      set: link-ref-literal-attr-body
    - include: immediately-pop

  link-ref-literal-attr-body:
    - meta_scope: meta.link.reference.literal.attributes.markdown
    - include: tag-attributes

  link-ref-footnote:
    - match: (\[)({{footnote_name}})(\])
      captures:
        0: meta.link.reference.footnote.markdown-extra
        1: punctuation.definition.link.begin.markdown
        2: meta.link.reference.literal.footnote-id.markdown
        3: punctuation.definition.link.end.markdown

  link-ref-wiki:
    - match: \[\[(?={{balance_square_brackets}}?\]\])
      scope: punctuation.definition.link.begin.markdown
      push: link-ref-wiki-link-text

  link-ref-wiki-link-text:
    - meta_scope: meta.link.reference.wiki.description.markdown
    - match: \]\]
      scope: punctuation.definition.link.end.markdown
      pop: 1
    - include: link-text-allow-image

###[ INLINE: LINK/IMAGE PROTOTYPES ]##########################################

  link-text:
    - match: \[
      push: link-text-nested
    - match: \b__?(?=[^]_]+\]) # eat underscores where there is no pair before the end of the square brackets - it's not a formatting mark
    - match: \b\*\*?(?=[^]*]+\]) # eat asterisks where there is no pair before the end of the square brackets - it's not a formatting mark
    - include: emphasis
    - include: literals
    - include: markups

  link-text-nested:
    - include: link-text
    - match: \]
      pop: 1

  link-text-allow-image:
    - include: link-text
    - include: images

  link-title:
    - include: link-title-begin
    - include: eol-pop
    - include: else-pop

  link-title-begin:
    - match: \'
      scope: punctuation.definition.string.begin.markdown
      set: link-title-single-quoted-content
    - match: \"
      scope: punctuation.definition.string.begin.markdown
      set: link-title-double-quoted-content
    - match: \(
      scope: punctuation.definition.string.begin.markdown
      set: link-title-other-quoted-content

  link-title-double-quoted-content:
    - meta_scope: meta.string.title.markdown string.quoted.double.markdown
    - match: \"
      scope: punctuation.definition.string.end.markdown
      pop: 1
    - include: link-title-common

  link-title-single-quoted-content:
    - meta_scope: meta.string.title.markdown string.quoted.single.markdown
    - match: \'
      scope: punctuation.definition.string.end.markdown
      pop: 1
    - include: link-title-common

  link-title-other-quoted-content:
    - meta_scope: meta.string.title.markdown string.quoted.other.markdown
    - match: \)
      scope: punctuation.definition.string.end.markdown
      pop: 1
    - include: link-title-common

  link-title-common:
    - match: ^\s*$\n?
      scope: invalid.illegal.non-terminated.link-title.markdown
      pop: 1
    - include: escapes
    - include: html-entities

  link-url-angled:
    - match: \>
      scope: punctuation.definition.link.end.markdown
      pop: 1
    - include: link-url-common

  link-url-unquoted:
    - match: (?=[ \t)])
      pop: 1
    - match: \(
      push: link-url-unquoted-parens
    - include: link-url-common

  link-url-unquoted-parens:
    - match: \)
      pop: 1
    - include: link-url-unquoted

  link-url-common:
    - include: escapes
    - include: html-entities
    - include: link-url-path-separators
    - include: link-url-scheme-separators
    - include: link-url-escapes
    - include: paragraph-end

  link-url-escapes:
    - match: (%)\h{2}
      scope: constant.character.escape.url.markdown
      captures:
        1: punctuation.definition.escape.markdown

  link-url-path-separators:
    - match: '[/&?#]'
      scope: punctuation.separator.path.markdown

  link-url-scheme-separators:
    - match: ':/{,2}'
      scope: punctuation.separator.path.markdown

  link-url-scheme-separator:
    - match: ':/{,2}'
      scope: punctuation.separator.path.markdown
      pop: 1

###[ INLINE: LINK/IMAGE/REFERENCE ATTRIBUTES ]################################

  tag-attributes:
    # https://kramdown.gettalong.org/syntax.html#span-ials
    # https://michelf.ca/projects/php-markdown/extra/
    # https://pandoc.org/MANUAL.html#extension-link_attributes
    - match: \}
      scope: punctuation.definition.attributes.end.markdown
      pop: 1
    - match: \,
      scope: punctuation.separator.sequence.markdown
    - match: '{{tag_attribute_name_start}}'
      push: [tag-attr-meta, tag-attr-equals, tag-attr-name]

  tag-attr-name:
    - meta_scope: entity.other.attribute-name.markdown
    - match: '{{tag_attribute_name_break}}'
      pop: 1
    - match: '["''`<]'
      scope: invalid.illegal.attribute-name.markdown

  tag-attr-meta:
    - meta_include_prototype: false
    - meta_scope: meta.attribute-with-value.markdown
    - include: immediately-pop

  tag-attr-equals:
    - match: =
      scope: punctuation.separator.key-value.markdown
      set: tag-attr-value
    - include: else-pop

  tag-attr-value:
    - match: \"
      scope: punctuation.definition.string.begin.markdown
      set: tag-attr-value-double-quoted
    - match: \'
      scope: punctuation.definition.string.begin.markdown
      set: tag-attr-value-single-quoted
    - match: '{{tag_unquoted_attribute_start}}'
      set: tag-attr-value-unquoted
    - include: else-pop

  tag-attr-value-double-quoted:
    - meta_scope: string.quoted.double.markdown
    - match: \"
      scope: punctuation.definition.string.end.markdown
      pop: 1

  tag-attr-value-single-quoted:
    - meta_scope: string.quoted.single.markdown
    - match: \'
      scope: punctuation.definition.string.end.markdown
      pop: 1

  tag-attr-value-unquoted:
    - meta_scope: string.unquoted.markdown
    - match: '{{tag_unquoted_attribute_break}}'
      pop: 1
    - match: '["''`<]'
      scope: invalid.illegal.attribute-value.markdown

###[ INLINE: AUTOLINKS ]######################################################

  autolink-email:
    # CommonMark
    # https://spec.commonmark.org/0.30/#email-autolink
    - match: |-
        (?x)
        (<)
        (
          (?:mailto(:))?
          {{email_user_commonmark}}
          (@)
          {{email_domain_commonmark}}(?:\.{{email_domain_commonmark}})*
        )
        (>)
      captures:
        0: meta.link.email.markdown
        1: punctuation.definition.link.begin.markdown
        2: markup.underline.link.markdown
        3: punctuation.separator.path.markdown
        4: punctuation.separator.path.markdown
        5: punctuation.definition.link.end.markdown
    # Github Flavoured Markdown
    - match: '[\w.+-]+(@)[\w-]+(?:\.(?:(?![._-][\W])[\w_-])+)+(?![_-])'
      captures:
        0: meta.link.email.markdown markup.underline.link.markdown
        1: punctuation.separator.path.markdown

  autolink-inet:
    # CommonMark
    # https://spec.commonmark.org/0.30/#autolinks
    - match: <(?=[[:alpha:]][[:alnum:].+-]+:)
      scope: punctuation.definition.link.begin.markdown
      push:
        - autolink-inet-angled-content
        - link-url-scheme-separator
    # Github Flavoured Markdown
    # After a valid domain, zero or more non-space non-< characters may follow
    # https://github.github.com/gfm/#autolinks-extension-
    - match: (?:(?:https|http|ftp)(://)|www\.)[\w-]+
      captures:
        1: punctuation.separator.path.markdown
      push: autolink-inet-unquoted-content

  autolink-inet-angled-content:
    - meta_scope: meta.link.inet.markdown
    - meta_content_scope: markup.underline.link.markdown
    - match: \>
      scope: punctuation.definition.link.end.markdown
      pop: 1
    # Spaces are not allowed in autolinks
    - match: (?=\s)
      pop: 1
    - include: autolink-inet-common

  autolink-inet-unquoted-content:
    - meta_scope: meta.link.inet.markdown markup.underline.link.markdown-gfm
    # 1. When an autolink ends in ), we scan the entire autolink for the total
    #    number of parentheses. If there is a greater number of closing parentheses
    #    than opening ones, we don’t consider the last character part of the
    #    autolink, in order to facilitate including an autolink inside a parenthesis
    # 2. If an autolink ends in a semicolon (;), we check to see if it appears to
    #    resemble an entity reference; if the preceding text is & followed by one
    #    or more alphanumeric characters. If so, it is excluded from the autolink
    # 3. Trailing punctuation (specifically, ?, !, ., ,, :, *, _, and ~) will not
    #    be considered part of the autolink, though they may be included in the
    #    interior # of the link
    #    Note: contains some empirical (undocumented) punctuation such as ;, ', "
    - match: (?=(?:\)|(?:{{html_entity}})*)[?!.,:;*_~'"]*[\s<])
      pop: 1
    - include: autolink-inet-common

  autolink-inet-group:
    - match: \)
      pop: 1
    - match: (?=(?:{{html_entity}})*[?!.,:;*_~'"]*[\s<])
      pop: 1
    - include: autolink-inet-common

  autolink-inet-common:
    - match: \(
      push: autolink-inet-group
    - include: link-url-path-separators
    - include: link-url-escapes

###[ INLINE: OTHER ]##########################################################

  escapes:
    # https://spec.commonmark.org/0.30/#backslash-escapes
    - match: '{{escapes}}'
      scope: constant.character.escape.markdown

  hard-line-breaks:
    # https://spec.commonmark.org/0.30/#hard-line-breaks
    - match: '[ ]{2,}$'
      scope: meta.hard-line-break.markdown punctuation.definition.hard-line-break.markdown
    - match: (\\)\n
      captures:
        0: meta.hard-line-break.markdown
        1: constant.character.escape.markdown

###[ EXTENSIONS: CRITIC MARKUP ]##############################################

  critics:
    # inline critic markup
    # http://criticmarkup.com/spec.php
    - include: critics-additions
    - include: critics-comments
    - include: critics-deletions
    - include: critics-highlights
    - include: critics-substitutions

  critics-additions:
    - match: \{\+\+
      scope: punctuation.definition.critic.begin.markdown
      push: critics-addition-content

  critics-addition-content:
    - meta_scope: markup.critic.addition.markdown
    - meta_content_scope: markup.inserted.critic.markdown
    - match: \+\+\}
      scope: punctuation.definition.critic.end.markdown
      pop: 1
    - include: critics-common

  critics-comments:
    - match: '{>>'
      scope: punctuation.definition.critic.begin.markdown
      push: critics-comment-content

  critics-comment-content:
    - meta_scope: markup.critic.comment.markdown
    - meta_content_scope: comment.critic.markdown
    - match: '<<}'
      scope: punctuation.definition.critic.end.markdown
      pop: 1
    - include: critics-common

  critics-deletions:
    - match: '{--'
      scope: punctuation.definition.critic.begin.markdown
      push: critics-deletion-content

  critics-deletion-content:
    - meta_scope: markup.critic.deletion.markdown
    - meta_content_scope: markup.deleted.critic.markdown
    - match: '--}'
      scope: punctuation.definition.critic.end.markdown
      pop: 1
    - include: critics-common

  critics-highlights:
    - match: '{=='
      scope: punctuation.definition.critic.begin.markdown
      push: critics-highlight-content

  critics-highlight-content:
    - meta_scope: markup.critic.highlight.markdown
    - meta_content_scope: markup.info.critic.markdown
    - match: '==}'
      scope: punctuation.definition.critic.end.markdown
      pop: 1
    - include: critics-common

  critics-substitutions:
    - match: '{~~'
      scope: punctuation.definition.critic.begin.markdown
      push: critics-substitution-deleted

  critics-substitution-deleted:
    - meta_scope: markup.critic.substitution.markdown
    - meta_content_scope: markup.deleted.critic.markdown
    - match: (?=~>)
      set:
        - meta_include_prototype: false
        - match: '~>'
          scope: punctuation.separator.critic.markdown
          set: critics-substitution-inserted
    - include: critics-substitution-inserted

  critics-substitution-inserted:
    - meta_scope: markup.critic.substitution.markdown
    - meta_content_scope: markup.inserted.critic.markdown
    - match: '~~}'
      scope: punctuation.definition.critic.end.markdown
      pop: 1
    - include: critics-common

  critics-common:
    - match: ^(?=\s*$)
      pop: 1
    - include: emphasis
    - include: images
    - include: literals
    - include: links

###[ EXTENSIONS: MATHJAX ]####################################################

  list-math-blocks:
    - match: (?=(?:^[ \t]*)?\$\$)
      branch_point: list-math-blocks
      branch:
        - list-math-block-begin
        - list-math-inline-block-begin

  list-math-block-begin:
    # Leading and trailing whitespace of standalone math blocks are scoped
    # `markup.math` in case background color is assigned.
    - meta_include_prototype: false
    - match: ^[ \t]*(\$\$)
      captures:
        1: text.tex.latex.embedded.markdown
           meta.environment.math.block.dollar.latex
           punctuation.definition.math.begin.latex
      set:
        - list-math-block-end
        - list-math-block-content
    - match: ''
      fail: list-math-blocks

  list-math-block-end:
    - meta_include_prototype: false
    - meta_scope: markup.math.block.markdown
    - meta_content_scope:
        text.tex.latex.embedded.markdown
        meta.environment.math.block.dollar.latex
    - match: (\$\$)\s*$\n?
      captures:
        1: text.tex.latex.embedded.markdown
           meta.environment.math.block.dollar.latex
           punctuation.definition.math.end.latex
      pop: 1
    - match: ''
      fail: list-math-blocks

  list-math-inline-block-begin:
    # Math blocks preceded or followed by normal text are treated as inline raw
    # code blocks, scoped `markup.math` excluding leading or trailing whitespace.
    - meta_include_prototype: false
    - match: \$\$
      scope: punctuation.definition.math.begin.latex
      set:
        - list-math-inline-block-end
        - list-math-block-content

  list-math-inline-block-end:
    - meta_include_prototype: false
    - meta_scope:
        markup.math.block.markdown
        text.tex.latex.embedded.markdown
        meta.environment.math.block.dollar.latex
    - match: \$\$
      scope: punctuation.definition.math.end.latex
      pop: 1
    - match: ''
      fail: list-math-blocks

  list-math-block-content:
    - meta_include_prototype: false
    - match: ''
      embed: math-content
      escape: (?=\$\$)|{{list_paragraph_end}}|{{list_setext_heading_escape}}
      pop: 1 # embed math once

  math-blocks:
    - match: (?=(?:^[ ]{,3})?\$\$)
      branch_point: math-blocks
      branch:
        - math-block-begin
        - math-inline-block-begin

  math-block-begin:
    # Leading and trailing whitespace of standalone math blocks are scoped
    # `markup.math` in case background color is assigned.
    - meta_include_prototype: false
    - match: ^[ ]{,3}(\$\$)
      captures:
        1: text.tex.latex.embedded.markdown
           meta.environment.math.block.dollar.latex
           punctuation.definition.math.begin.latex
      set:
        - math-block-end
        - math-block-content
    - match: ''
      fail: math-blocks

  math-block-end:
    - meta_include_prototype: false
    - meta_scope: markup.math.block.markdown
    - meta_content_scope:
        text.tex.latex.embedded.markdown
        meta.environment.math.block.dollar.latex
    - match: (\$\$)\s*$\n?
      captures:
        1: text.tex.latex.embedded.markdown
           meta.environment.math.block.dollar.latex
           punctuation.definition.math.end.latex
      pop: 1
    - match: ''
      fail: math-blocks

  math-inline-block-begin:
    # Math blocks preceded or followed by normal text are treated as inline raw
    # code blocks, scoped `markup.math` excluding leading or trailing whitespace.
    - meta_include_prototype: false
    - match: \$\$
      scope: punctuation.definition.math.begin.latex
      set:
        - math-inline-blocks-end
        - math-block-content

  math-inline-blocks-end:
    - meta_include_prototype: false
    - meta_scope:
        markup.math.block.markdown
        text.tex.latex.embedded.markdown
        meta.environment.math.block.dollar.latex
    - match: \$\$
      scope: punctuation.definition.math.end.latex
      pop: 1
    - match: ''
      fail: math-blocks

  math-block-content:
    - meta_include_prototype: false
    - match: ''
      embed: math-content
      escape: (?=\$\$)|{{paragraph_end}}|{{setext_heading_escape}}
      pop: 1 # embed math once

  math-inline:
    # Consume any remaining $$ to prevent deadlock
    # (workaround for https://github.com/sublimehq/sublime_text/issues/5415)
    - match: \$\$
    - match: |-
        (?x)
        # dollar sign not followed by whitespace
        (\$) (?=\S)
        # arbitrary number of chars, maybe escaped dollar sign, but no html tags
        # terminated by non-whitespace, followed by dollar and non-word character
        (?= (?: \\\\ | \\\$ | (?!</?[A-Za-z]+[ \t]*/?>)[^\$] )*? \S\$\W )
      scope:
        markup.math.inline.markdown
        text.tex.latex.embedded.markdown
        meta.environment.math.block.dollar.latex
        punctuation.definition.math.begin.latex
      embed: math-content
      embed_scope:
        markup.math.inline.markdown
        text.tex.latex.embedded.markdown
        meta.environment.math.block.dollar.latex
      escape: '{{no_escape_behind}}\$'
      escape_captures:
        0: markup.math.inline.markdown
           text.tex.latex.embedded.markdown
           meta.environment.math.block.dollar.latex
           punctuation.definition.math.end.latex

  math-content:
    - include: scope:text.tex.latex#macros
    - include: scope:text.tex.latex#math-content

###[ PROTOTYPES ]#############################################################

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

  eol-pop:
    - match: $
      pop: 1

  expect-eol:
    - include: eol-pop
    - match: \S.+
      scope: invalid.illegal.expected-eol.markdown

  immediately-pop:
    - match: ''
      pop: 1