diff --git a/css/global/_code.scss b/css/global/_code.scss
index 3c25b6fb..59a4b794 100644
--- a/css/global/_code.scss
+++ b/css/global/_code.scss
@@ -56,6 +56,9 @@ aside {
   &.cpp::before {
     content: "c++";
   }
+  &.djot::before {
+    content: "djot";
+  }
   &.bash::before {
     content: "bash";
   }
diff --git a/drafts/blogging_in_djot_instead_of_markdown.dj b/drafts/blogging_in_djot_instead_of_markdown.dj
new file mode 100644
index 00000000..6aa34a12
--- /dev/null
+++ b/drafts/blogging_in_djot_instead_of_markdown.dj
@@ -0,0 +1,127 @@
+---
+title: "Blogging in Djot instead of Markdown"
+tags: ["Djot", "Webpage", "Rust"]
+---
+
+I recently happened to see an offhand comment on [Hacker News][] about a markup language called [Djot][].
+I don't really have any large issues with the {-Markdown-} [CommonMark][] I use to generate the posts for this website, but my brain saw a chance to get sidetracked yet again, and here we are.
+
+I spent some hours to port my hacky custom markup extensions to Djot and started to write my posts in Djot.
+Having used Markdown for many years, I'm still not comfortable with some of Djot's different syntax choices, but it ...
+
+# What and why Djot?
+
+The creator of Djot is John MacFarlane, the same philosophy professor that also created [Pandoc][] and [CommonMark][].
+These might be two of the most influential projects in the markup space, so you'd get the feeling that there should be a good reason for [Djot][]'s creation.
+
+The rationale for [Djot][] is specified in the [GitHub repo][Djot] and references his blog post [Beyond Markdown][] that inspired the whole project.
+
+If I should make an attempt to summarize the goals of [Djot][], I'd say that Djot tries to fix flaws of CommonMark in two areas:
+
+1. It's much easier to parse.
+
+  {author="John Macfarlane"}
+  > So, to fully specify emphasis parsing, we need additional rules. The 17 discouragingly complex rules in the CommonMark spec are intended to force the sorts of readings that humans will find most natural.
+
+  17 rules just to parse emphasis sounds like fun times...
+
+  At least it's better than Markdown that's ambiguous.
+
+1. More features than CommonMark.
+
+   For instance proper support for footnotes, math, divs, and attributes that can be applied to any element.
+
+I'm sympathetic to the parsing problem, and for that alone I was willing to at least try it out.
+But what really sold me was first-class support for attributes and divs, something I've added ugly hacks to work around.
+
+If I'm going to bring up the negative parts, it's that for a regular user Djot mostly fixes edge-cases.
+For me, 95% of the time it's just like writing Markdown, and (unfortunately) it'll have difficulties overcoming the "good enough" barrier of the various flavors of Markdown.
+
+# Tools
+
+Given that Djot is a relatively young project, I expected the tooling to be lacking.
+There are for sure some things missing, but it wasn't so bad for my use-case.
+
+I found a Djot Sublime Text grammar I can use for syntax highlighting the blog,
+and there is Vim syntax highlighting in the [Djot repo][Djot].
+
+(Sad for those who don't use Vim I guess.)
+
+More annoying is that there's no treesitter implementation for Djot.
+This is unfortunate, as with treesitter I get proper syntax highlighting inside code blocks for Markdown and I have a general treesitter jump command that, for Markdown, jumps between headers with `]g` and `[g`.
+(In Rust it jumps between structs, implementations, enums, and functions.)
+
+Not a deal-breaker of course.
+Using the Markdown treesitter works well enough for the time being.
+(Maybe I need to explore how treesitter grammars work one day, and create one for Djot.)
+
+As for parsing I found [Jotdown][], which is a Rust library with an API inspired by [pulldown-cmark][], the library I use to parse CommonMark.
+
+# Abstracting away markup parsing
+
+# Customized markup
+
+For the blog I have some [markup transformations][] I apply to Markdown.
+This includes demoting headers (they only `h1` i want is the post title), embedding bare YouTube links and prettifying code.
+
+[markup transformations]: /blog/2022/08/29/rewriting_my_blog_in_rust_for_fun_and_profit/#markdown-transformations
+
+## Epigraph
+
+Before:
+
+```markdown
+> This is an epigraph
+{ :epigraph }
+```
+
+```djot
+::: epigraph
+> This is an epigraph
+:::
+```
+
+Produces:
+
+```html
+<div class="epigraph">
+  <blockquote>
+    <p>This is an epigraph</p>
+  </blockquote>
+</div>
+```
+
+## Asides
+
+```markdown
+> This is an <aside>
+{ :notice }
+```
+
+## Images and figures
+
+::: Flex
+/images/configura14/octree1.png
+/images/configura14/octree2.png
+:::
+
+```markdown
+::: Flex
+/images/configura14/octree1.png
+/images/configura14/octree2.png
+:::
+```
+
+```djot
+::: flex
+![](/images/configura14/octree1.png){ height=100 }
+![](/images/configura14/octree2.png){ height=100 }
+:::
+```
+
+[CommonMark]: https://commonmark.org/
+[Pandoc]: https://pandoc.org/
+[Beyond Markdown]: https://johnmacfarlane.net/beyond-markdown.html
+[Djot]: https://github.com/jgm/djot
+[pulldown-cmark]: https://crates.io/crates/pulldown-cmark
+[Jotdown]: https://github.com/hellux/jotdown
diff --git a/drafts/djottest.dj b/drafts/djottest.dj
index a54293dc..834150fa 100644
--- a/drafts/djottest.dj
+++ b/drafts/djottest.dj
@@ -70,8 +70,9 @@ Ordered list:
 
 # Quotes and attributes
 
+::: epigraph
 > This is an epigraph
-{ :epigraph }
+:::
 
 Text
 
@@ -95,8 +96,8 @@ This is [a notice](#)
 
 Text
 
+{ author="John Doe" }
 > With author attribution
-{ author=John Doe }
 
 # Tables
 
diff --git a/src/gen.rs b/src/gen.rs
index 501cb1c4..32d7bd8f 100644
--- a/src/gen.rs
+++ b/src/gen.rs
@@ -23,11 +23,11 @@ pub fn new_draft(title: String) -> Result<()> {
 
 fn post_path(slug: &str) -> Utf8PathBuf {
     let now = Utc::now();
-    format!("posts/{}-{}.markdown", now.format("%Y-%m-%d"), slug).into()
+    format!("posts/{}-{}.dj", now.format("%Y-%m-%d"), slug).into()
 }
 
 fn draft_path(slug: &str) -> Utf8PathBuf {
-    format!("drafts/{slug}.markdown").into()
+    format!("drafts/{slug}.dj").into()
 }
 
 fn new_prototype(title: &str, path: &Utf8Path) -> Result<()> {
@@ -41,7 +41,7 @@ fn prototype_post(title: &str) -> String {
     format!(
         r#"---
 title: "{title}"
-tags: [Tag1, Tag2]
+tags: ["Tag1", "Tag2"]
 ---
 
 Lorem ipsum...
diff --git a/src/markup/djot/mod.rs b/src/markup/djot/mod.rs
index ae3440a9..b562f707 100644
--- a/src/markup/djot/mod.rs
+++ b/src/markup/djot/mod.rs
@@ -2,6 +2,7 @@ mod auto_figures;
 mod code;
 mod div_transforms;
 mod embed_youtube;
+mod quote_transforms;
 mod transform_headers;
 
 use eyre::Result;
@@ -11,6 +12,7 @@ use self::auto_figures::AutoFigures;
 use self::code::{CodeBlockSyntaxHighlight, InlineCodeSyntaxHighlight};
 use self::div_transforms::DivTransforms;
 use self::embed_youtube::EmbedYoutube;
+use self::quote_transforms::QuoteTransforms;
 use self::transform_headers::TransformHeaders;
 
 pub fn djot_to_html(djot: &str) -> Result<String> {
@@ -21,6 +23,7 @@ pub fn djot_to_html(djot: &str) -> Result<String> {
     let transformed = CodeBlockSyntaxHighlight::new(transformed);
     let transformed = InlineCodeSyntaxHighlight::new(transformed);
     let transformed = DivTransforms::new(transformed);
+    let transformed = QuoteTransforms::new(transformed);
 
     let mut body = String::new();
     html::Renderer::default().push(transformed, &mut body)?;
diff --git a/src/markup/djot/quote_transforms.rs b/src/markup/djot/quote_transforms.rs
new file mode 100644
index 00000000..eaed4f6e
--- /dev/null
+++ b/src/markup/djot/quote_transforms.rs
@@ -0,0 +1,113 @@
+use jotdown::{Attributes, Container, Event};
+
+pub struct QuoteTransforms<'a, I: Iterator<Item = Event<'a>>> {
+    parent: I,
+    event_queue: Vec<Event<'a>>,
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> QuoteTransforms<'a, I> {
+    pub fn new(parent: I) -> Self {
+        Self {
+            parent,
+            event_queue: vec![],
+        }
+    }
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> Iterator for QuoteTransforms<'a, I> {
+    type Item = Event<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(event) = self.event_queue.pop() {
+            return Some(event);
+        }
+
+        let author = match self.parent.next()? {
+            Event::Start(Container::Blockquote, attrs) => {
+                if let Some(author) = attrs.get("author") {
+                    author.to_string()
+                } else {
+                    return Some(Event::Start(Container::Blockquote, attrs));
+                }
+            }
+            other => return Some(other),
+        };
+
+        let mut events = Vec::new();
+        loop {
+            match self.parent.next()? {
+                // Yeah, don't support nesting for now.
+                Event::End(Container::Blockquote) => {
+                    break;
+                }
+                other => events.push(other),
+            }
+        }
+
+        let html = Container::RawBlock { format: "html" };
+        self.event_queue.push(Event::End(Container::Blockquote));
+        self.event_queue.push(Event::End(html.clone()));
+        self.event_queue.push(Event::Str(
+            format!(
+                r#"<footer><span class="author">{}</span></footer>"#,
+                html_escape::encode_text(&author),
+            )
+            .into(),
+        ));
+        self.event_queue.push(Event::Start(html, Attributes::new()));
+        for x in events.into_iter().rev() {
+            self.event_queue.push(x);
+        }
+        Some(Event::Start(Container::Blockquote, Attributes::new()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use eyre::Result;
+    use jotdown::{html, Parser, Render};
+
+    fn convert(s: &str) -> Result<String> {
+        let parser = Parser::new(s);
+        let transformed = QuoteTransforms::new(parser);
+        let mut body = String::new();
+        html::Renderer::default().push(transformed, &mut body)?;
+        Ok(body)
+    }
+
+    #[test]
+    fn test_parse_notice() -> Result<()> {
+        let s = "::: notice
+Text here
+:::";
+        assert_eq!(
+            convert(s)?,
+            r"<aside>
+<p>Text here</p>
+</aside>
+"
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_quote_src() -> Result<()> {
+        let s = r#"
+{author="John > Jane"}
+> Text here
+"#;
+        assert_eq!(
+            convert(s)?,
+            r#"
+<blockquote>
+<p>Text here</p>
+<footer><span class="author">John &gt; Jane</span></footer>
+</blockquote>
+"#
+        );
+
+        Ok(())
+    }
+}
diff --git a/src/markup/syntax_highlight.rs b/src/markup/syntax_highlight.rs
index 816363db..94138e5a 100644
--- a/src/markup/syntax_highlight.rs
+++ b/src/markup/syntax_highlight.rs
@@ -206,6 +206,7 @@ fn syntect_lang_name(lang: &str) -> &str {
         "shell" => "Shell-Unix-Generic",
         "erlang" => "Erlang",
         "js" => "JavaScript",
+        "djot" => "Djot",
 
         // "pollen" => "",
         x => x,
diff --git a/syntaxes/Djot.sublime-syntax b/syntaxes/Djot.sublime-syntax
new file mode 100644
index 00000000..1ea1fc30
--- /dev/null
+++ b/syntaxes/Djot.sublime-syntax
@@ -0,0 +1,3529 @@
+#
+# SPDX-License-Identifier: MIT
+#
+# Copyright (C) 2012 Brett Terpstra
+# Copyright (C) 2023 Shun Sakai
+#
+
+%YAML 1.2
+---
+#
+# This definition aims to meet Djot syntax reference:
+#
+#   https://github.com/jgm/djot/blob/main/doc/syntax.md
+#
+# Syntax definition of `.sublime-syntax` file:
+#
+#   https://www.sublimetext.com/docs/syntax.html
+#
+name: Djot
+file_extensions: [dj]
+scope: text.html.djot
+hidden: true
+
+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_escape: ^(?=[ ]{,3}(?:=+|-+)\s*$)            # between 0 and 3 spaces, followed by at least one hyphon or equal sign (setext underline can be of any length)
+
+  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})(?![\s`])(?:[^`]+(?=`)|(?!`{4})`+(?!`))+(`{4})(?!`)  # 4 backticks, followed by at least one non whitespace, 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})(?![\s`])(?:[^`]+(?=`)|(?!`{3})`+(?!`))+(`{3})(?!`)  # 3 backticks, followed by at least one non whitespace, 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})(?![\s`])(?:[^`]+(?=`)|(?!`{2})`+(?!`))+(`{2})(?!`)  # 2 backticks, followed by at least one non whitespace, 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})(?![\s`])(?:[^`]+(?=`)|(?!`{1})`+(?!`))+(`{1})(?!`)  # 1 backtick,  followed by at least one non whitespace, non backtick character, followed by (                          at least one non backtick character) at least once, followed by exactly 1 backtick
+    )
+  escapes: \\[-+*/!"#$%&'(),.:;<=>?@\[\\\]^_`{|}~]
+
+  balance_square_brackets: |-
+    (?x:
+      (?:
+        (?:{{escapes}})+                  # escape characters
+      | [^\[\]`\\]+(?=[\[\]`\\]|$)        # anything that isn't a square bracket or a backtick or the start of an escape character
+      | {{backticks}}                     # inline code
+      | \[(?:                             # nested square brackets (one level deep)
+          [^\[\]`]+(?=[\[\]`])            #  anything that isn't a square bracket or a backtick
+          {{backticks}}?                  #  balanced backticks
+        )*\]                              #  closing square bracket
+      )+
+    )
+  balance_square_brackets_and_emphasis: |-
+    (?x:
+      (?:
+        (?:{{escapes}})+                  # escape characters
+      | [^\[\]`\\_*]+(?=[\[\]`\\_*]|$)    # anything that isn't a square bracket, a backtick, the start of an escape character, or an emphasis character
+      | {{backticks}}                     # inline code
+      | \[(?:                             # nested square brackets (one level deep)
+          [^\[\]`]+(?=[\[\]`])            #  anything that isn't a square bracket or a backtick
+          {{backticks}}?                  #  balanced backticks
+        )*\]                              #  closing square bracket
+      )+                                  # at least one character
+    )
+  balance_square_brackets_pipes_and_emphasis: |-
+    (?x:
+      (?:
+        (?:{{escapes}})+                  # escape characters
+      | [^\[\]`\\_*|]+(?=[\[\]`\\_*|]|$)  # anything that isn't a square bracket, a backtick, the start of an escape character, or an emphasis character
+      | {{backticks}}                     # inline code
+      | \[(?:                             # nested square brackets (one level deep)
+          [^\[\]`]+(?=[\[\]`])            #  anything that isn't a square bracket or a backtick
+          {{backticks}}?                  #  balanced backticks
+        )*\]                              #  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 hyphon,
+      # followed by something other than whitespace and the end of the line
+    | (?! \s*\-\s+ | \s+\|){{table_cell}}\|(?!\s+$)
+    )
+
+  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
+      )
+      \s*            # allow for whitespace between code block start and info string
+    )
+  fenced_code_block_language: |-
+    (?x:             # first word of an infostring is used as language specifier
+      (
+        [[: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*          # any whitespace, or ..
+      |
+        \s[^`]*      # any characters (except backticks), separated by whitespace ...
+      )
+      $\n?           # ... until EOL
+    )
+  fenced_code_block_end: |-
+    (?x:
+      [ \t]*
+      (
+        \2           # the backtick/tilde combination that opened the code fence
+        (?:\3|\4)*   # plus optional additional closing characters
+      )
+      \s*$           # any amount of whitespace until EOL
+    )
+  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}}}]|/?>)
+
+  math_block: '[ ]{,3}\$\$'
+
+  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
+       |  {{math_block}}              # a math block 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}}
+    )
+
+  # 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: djot
+
+  frontmatter:
+    - match: (---)\s*(?i:(coffee)\s*)\n
+      captures:
+        0: meta.frontmatter.djot
+        1: punctuation.section.block.begin.frontmatter.djot
+        2: constant.other.language-name.djot
+      embed: scope:source.coffee
+      embed_scope: meta.frontmatter.djot source.coffee.embedded.djot
+      escape: ^(---|\.{3})\s*\n  # pandoc requires the remainder of the line to be blank
+      escape_captures:
+        0: meta.frontmatter.djot
+        1: punctuation.section.block.end.frontmatter.djot
+    - match: (---)\s*(?i:(json)\s*)\n
+      captures:
+        0: meta.frontmatter.djot
+        1: punctuation.section.block.begin.frontmatter.djot
+        2: constant.other.language-name.djot
+      embed: scope:source.json
+      embed_scope: meta.frontmatter.djot source.json.embedded.djot
+      escape: ^(---|\.{3})\s*\n # pandoc requires the remainder of the line to be blank
+      escape_captures:
+        0: meta.frontmatter.djot
+        1: punctuation.section.block.end.frontmatter.djot
+    - match: (---)\s*(?i:(yaml|yml)\s*)?\n
+      captures:
+        0: meta.frontmatter.djot
+        1: punctuation.section.block.begin.frontmatter.djot
+        2: constant.other.language-name.djot
+      embed: scope:source.yaml
+      embed_scope: meta.frontmatter.djot source.yaml.embedded.djot
+      escape: ^(---|\.{3})\s*\n  # pandoc requires the remainder of the line to be blank
+      escape_captures:
+        0: meta.frontmatter.djot
+        1: punctuation.section.block.end.frontmatter.djot
+
+  djot:
+    - include: indented-code-blocks
+    - include: thematic-breaks
+    - include: block-quotes
+    - include: list-blocks
+    - include: tables
+    - include: fenced-code-blocks
+    - include: math-blocks
+    - include: html-blocks
+    - include: reference-definitions
+    - include: atx-headings
+    - include: setext-heading-or-paragraph
+
+  indented-djot:
+    # 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}(>)[ ]?'
+      captures:
+        1: punctuation.definition.blockquote.djot
+      push:
+        - block-quote-meta
+        - block-quote-body
+        - block-quote-punctuation-body
+
+  block-quote-meta:
+    - meta_include_prototype: false
+    - meta_scope: markup.quote.djot
+    - 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: true
+
+  block-quote-punctuations:
+    - match: ^[ \t]{,3}(>)[ ]?
+      captures:
+        1: punctuation.definition.blockquote.djot
+      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.djot
+
+  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.djot
+      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.djot
+
+###[ CONTAINER BLOCKS: BLOCK QUOTES > FENCED CODE BLOCKS ]####################
+
+  block-quote-fenced-code-block:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          {{fenced_code_block_language}}?
+          .*$\n?       # all characters until EOL
+      captures:
+        0: meta.code-fence.definition.begin.text.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      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.djot
+
+  block-quote-fenced-code-block-end:
+    - include: block-quote-end
+    - match: '{{fenced_code_block_end}}'
+      captures:
+        0: meta.code-fence.definition.end.text.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+      pop: true
+
+###[ 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.djot
+        3: entity.name.reference.link.djot
+        4: punctuation.definition.reference.end.djot
+        5: punctuation.separator.key-value.djot
+      push: block-quote-footnote-def-body
+
+  block-quote-footnote-def-body:
+    - meta_scope: meta.link.reference.def.footnote.djot
+    - 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: true
+
+  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
+           |   {{math_block}}              # a math block begins the line
+           |   {{html_block}}              # a html block begins the line
+           )
+        )
+      pop: true
+
+  block-quote-link-definitions:
+    # https://spec.commonmark.org/0.30/#link-reference-definition
+    - match: '[ \t]*(\[)({{reference_name}})(\])(:)'
+      captures:
+        1: punctuation.definition.reference.begin.djot
+        2: entity.name.reference.link.djot
+        3: punctuation.definition.reference.end.djot
+        4: punctuation.separator.key-value.djot
+      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.djot
+    - 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.djot
+      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.djot
+    - 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.djot
+        2: markup.list.unnumbered.bullet.djot punctuation.definition.list_item.djot
+        3: markup.list.unnumbered.djot
+        4: markup.checkbox.begin.djot punctuation.definition.checkbox.begin.djot
+        5: markup.checkbox.mark.djot
+        6: markup.checkbox.end.djot punctuation.definition.checkbox.end.djot
+      set: block-quote-unordered-list-block-body
+    - match: ([ \t]*)(\d{1,9}([.)]))(\s)
+      captures:
+        1: markup.list.numbered.djot
+        2: markup.list.numbered.bullet.djot
+        3: punctuation.definition.list_item.djot
+        4: markup.list.numbered.djot
+      set: block-quote-ordered-list-block-body
+
+  block-quote-ordered-list-block-body:
+    - meta_content_scope: markup.list.numbered.djot
+    - include: block-quote-list-block-end
+    - include: block-quote-list-block-content
+
+  block-quote-unordered-list-block-body:
+    - meta_content_scope: markup.list.unnumbered.djot
+    - 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: true
+
+  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.djot
+    - 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
+           |   {{math_block}}              # a math block begins the line
+           |   {{html_block}}              # a html block begins the line
+           )
+        )
+      pop: true
+
+###[ CONTAINER BLOCKS: BLOCK QUOTES > PARAGRAPHS ]############################
+
+  block-quote-paragraph:
+    - match: '[ \t]*(?=\S)'
+      set: block-quote-paragraph-body
+
+  block-quote-paragraph-body:
+    - meta_scope: markup.paragraph.djot
+    - 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
+           |   {{math_block}}              # a math block begins the line
+           |   {{html_block}}              # a html block begins the line
+           )
+        )
+      pop: true
+
+###[ CONTAINER BLOCKS: LISTS ]################################################
+
+  list-blocks:
+    - match: ([ \t]*)([*+-])((?:[ ](\[)([ xX])(\]))?\s)
+      captures:
+        1: markup.list.unnumbered.djot
+        2: markup.list.unnumbered.bullet.djot punctuation.definition.list_item.djot
+        3: markup.list.unnumbered.djot
+        4: markup.checkbox.begin.djot punctuation.definition.checkbox.begin.djot
+        5: markup.checkbox.mark.djot
+        6: markup.checkbox.end.djot punctuation.definition.checkbox.end.djot
+      push: unordered-list-block
+    - match: ([ \t]*)(\d{1,9}([.)]))(\s)
+      captures:
+        1: markup.list.numbered.djot
+        2: markup.list.numbered.bullet.djot
+        3: punctuation.definition.list_item.djot
+        4: markup.list.numbered.djot
+      push: ordered-list-block
+
+  unordered-list-block:
+    - meta_content_scope: markup.list.unnumbered.djot
+    - include: list-block-end
+    - include: list-block-content
+
+  ordered-list-block:
+    - meta_content_scope: markup.list.numbered.djot
+    - include: list-block-end
+    - include: list-block-content
+
+  list-block-end:
+    - match: ^(?=\S)
+      pop: true
+
+  list-block-content:
+    - include: fenced-code-blocks
+    - include: math-blocks
+    - include: html-blocks
+    - include: reference-definitions
+    - include: list-block-common
+    - include: list-block-quotes
+    - include: list-paragraphs
+
+  list-block-common:
+    - include: thematic-breaks
+    - include: atx-headings
+    - include: list-items
+
+  list-items:
+    - match: ([ \t]*)([*+-])((?:[ ](\[)([ xX])(\]))?\s)
+      captures:
+        1: markup.list.unnumbered.djot
+        2: markup.list.unnumbered.bullet.djot punctuation.definition.list_item.djot
+        3: markup.list.unnumbered.djot
+        4: markup.checkbox.begin.djot punctuation.definition.checkbox.begin.djot
+        5: markup.checkbox.mark.djot
+        6: markup.checkbox.end.djot punctuation.definition.checkbox.end.djot
+    - match: ([ \t]*)(\d{1,9}([.)]))(\s)
+      captures:
+        1: markup.list.numbered.djot
+        2: markup.list.numbered.bullet.djot
+        3: punctuation.definition.list_item.djot
+        4: markup.list.numbered.djot
+
+  list-block-quotes:
+    - match: '[ \t]*(>)[ ]?'
+      captures:
+        1: punctuation.definition.blockquote.djot
+      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.djot
+      push: block-quote-punctuation-body
+
+  list-block-quote-paragraph:
+    - match: '[ \t]*(?=\S)'
+      set: list-block-quote-paragraph-body
+
+  list-block-quote-paragraph-body:
+    - meta_scope: markup.paragraph.djot
+    - include: block-quote-nested-paragraph-end
+    - include: list-block-quote-punctuations
+    - include: inlines
+
+  list-paragraphs:
+    - match: '[ \t]*(?=\S)'
+      push: list-paragraph-body
+
+  list-paragraph-body:
+    - meta_scope: meta.paragraph.list.djot
+    - include: list-paragraph-end
+    - include: inlines
+
+  list-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)
+          |   {{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
+          |   {{math_block}}              # a math block begins the line
+          |   {{html_block}}              # a html block begins the line
+          )
+        )
+      pop: true
+
+###[ 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.djot
+      push: atx-heading1-content
+    - match: '[ \t]*(#{2}){{atx_heading_space}}'
+      captures:
+        1: punctuation.definition.heading.begin.djot
+      push: atx-heading2-content
+    - match: '[ \t]*(#{3}){{atx_heading_space}}'
+      captures:
+        1: punctuation.definition.heading.begin.djot
+      push: atx-heading3-content
+    - match: '[ \t]*(#{4}){{atx_heading_space}}'
+      captures:
+        1: punctuation.definition.heading.begin.djot
+      push: atx-heading4-content
+    - match: '[ \t]*(#{5}){{atx_heading_space}}'
+      captures:
+        1: punctuation.definition.heading.begin.djot
+      push: atx-heading5-content
+    - match: '[ \t]*(#{6}){{atx_heading_space}}'
+      captures:
+        1: punctuation.definition.heading.begin.djot
+      push: atx-heading6-content
+
+  atx-heading1-content:
+    - meta_scope: markup.heading.1.djot
+    - meta_content_scope: entity.name.section.djot
+    - include: atx-heading-content
+
+  atx-heading2-content:
+    - meta_scope: markup.heading.2.djot
+    - meta_content_scope: entity.name.section.djot
+    - include: atx-heading-content
+
+  atx-heading3-content:
+    - meta_scope: markup.heading.3.djot
+    - meta_content_scope: entity.name.section.djot
+    - include: atx-heading-content
+
+  atx-heading4-content:
+    - meta_scope: markup.heading.4.djot
+    - meta_content_scope: entity.name.section.djot
+    - include: atx-heading-content
+
+  atx-heading5-content:
+    - meta_scope: markup.heading.5.djot
+    - meta_content_scope: entity.name.section.djot
+    - include: atx-heading-content
+
+  atx-heading6-content:
+    - meta_scope: markup.heading.6.djot
+    - meta_content_scope: entity.name.section.djot
+    - include: atx-heading-content
+
+  atx-heading-content:
+    - match: '{{atx_heading_end}}'
+      captures:
+        1: punctuation.definition.heading.end.djot
+        2: meta.whitespace.newline.djot
+      pop: true
+    - include: emphasis
+    - include: images
+    - include: literals
+    - include: links
+
+###[ LEAF BLOCKS: SETEXT HEADINGS OR PARAGRAPH ]##############################
+
+  setext-heading-or-paragraph:
+    # https://spec.commonmark.org/0.30/#setext-headings
+    # 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: ^[ ]{,3}(?:=+|(?=\S))
+      push: paragraph
+
+  setext-heading1:
+    - match: ^[ ]{,3}(=+)[ \t]*$(\n?)
+      scope: markup.heading.1.setext.djot
+      captures:
+        1: punctuation.definition.heading.setext.djot
+        2: meta.whitespace.newline.djot
+      pop: true
+
+  setext-heading2:
+    - match: ^[ ]{,3}(-+)[ \t]*$(\n?)
+      scope: markup.heading.2.setext.djot
+      captures:
+        1: punctuation.definition.heading.setext.djot
+        2: meta.whitespace.newline.djot
+      pop: true
+
+  paragraph:
+    - meta_scope: meta.paragraph.djot
+    - include: setext-heading1
+    - include: setext-heading2
+    - include: paragraph-end
+    - include: inlines
+
+  paragraph-end:
+    - match: '{{paragraph_end}}'
+      pop: true
+
+###[ LEAF BLOCKS: INDENTED CODE BLOCKS ]######################################
+
+  indented-code-blocks:
+    # https://spec.commonmark.org/0.30/#indented-code-blocks
+    - match: '{{indented_code_block}}.*$\n?'
+      scope: markup.raw.block.djot
+
+###[ 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: true
+    - 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-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-shell-script
+    - include: fenced-sql
+    - include: fenced-tsx
+    - include: fenced-typescript
+    - include: fenced-xml
+    - include: fenced-yaml
+    # 3rd-party syntaxes
+    - include: fenced-ada
+    - include: fenced-akh
+    - include: fenced-arduino
+    - include: fenced-coffee
+    - include: fenced-dart
+    - include: fenced-docker
+    - include: fenced-elixir
+    - include: fenced-fish
+    - include: fenced-graphql
+    - include: fenced-http
+    - include: fenced-ini
+    - include: fenced-jade
+    - include: fenced-julia
+    - include: fenced-kotlin
+    - include: fenced-less
+    - include: fenced-mermaid
+    - include: fenced-nim
+    - include: fenced-powershell
+    - include: fenced-protobuf
+    - include: fenced-reason
+    - include: fenced-sass
+    - include: fenced-scheme
+    - include: fenced-scss
+    - include: fenced-stata
+    - include: fenced-svelte
+    - include: fenced-swift
+    - include: fenced-terraform
+    - include: fenced-toml
+    - include: fenced-twee
+    - include: fenced-twig
+    - include: fenced-verilog
+    - include: fenced-xonsh
+
+  fenced-actionscript:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:actionscript|as))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.actionscript.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.actionscript.2
+      embed_scope: markup.raw.code-fence.actionscript.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.actionscript.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-applescript:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:applescript|osascript))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.applescript.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.applescript
+      embed_scope: markup.raw.code-fence.applescript.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.applescript.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-clojure:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:clojure|clj))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.clojure.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.clojure
+      embed_scope: markup.raw.code-fence.clojure.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.clojure.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-c:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:c|h))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.c.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.c
+      embed_scope: markup.raw.code-fence.c.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.c.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-cpp:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:c\+\+|cc|cpp|cxx|h\+\+|hpp|hxx))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.c++.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.c++
+      embed_scope: markup.raw.code-fence.c++.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.c++.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-csharp:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:csharp|c\#|cs))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.csharp.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.cs
+      embed_scope: markup.raw.code-fence.csharp.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.csharp.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-css:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:css))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.css.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.css
+      embed_scope: markup.raw.code-fence.css.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.css.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-diff:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:diff|patch))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.diff.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.diff
+      embed_scope: markup.raw.code-fence.diff.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.diff.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-dosbatch:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:bat|cmd|dos))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.dosbatch.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.dosbatch
+      embed_scope: markup.raw.code-fence.dosbatch.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.dosbatch.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-erlang:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:erlang|escript))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.erlang.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.erlang
+      embed_scope: markup.raw.code-fence.erlang.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.erlang.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-graphviz:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:graphviz))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.graphviz.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.dot
+      embed_scope: markup.raw.code-fence.graphviz.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.graphviz.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-golang:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:go(?:lang)?))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.go.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.go
+      embed_scope: markup.raw.code-fence.go.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.go.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-haskell:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:haskell))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.haskell.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.haskell
+      embed_scope: markup.raw.code-fence.haskell.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.haskell.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-html-php:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:html\+php))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.html-php.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:embedding.php
+      embed_scope: markup.raw.code-fence.html-php.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.html-php.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-html:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:html))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.html.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:text.html.basic
+      embed_scope: markup.raw.code-fence.html.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.html.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-java:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:java))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.java.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.java
+      embed_scope: markup.raw.code-fence.java.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.java.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-javascript:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:javascript|js))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.javascript.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.js
+      embed_scope: markup.raw.code-fence.javascript.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.javascript.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-jsonc:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:jsonc?))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.json.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.json
+      embed_scope: markup.raw.code-fence.json.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.json.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-jspx:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:jspx?))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.jsp.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:text.html.jsp
+      embed_scope: markup.raw.code-fence.jsp.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.jsp.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-jsx:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:jsx))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.jsx.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.jsx
+      embed_scope: markup.raw.code-fence.jsx.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.jsx.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-lisp:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:lisp))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.lisp.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.lisp
+      embed_scope: markup.raw.code-fence.lisp.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.lisp.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-lua:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:lua))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.lua.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.lua
+      embed_scope: markup.raw.code-fence.lua.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.lua.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-makefile:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:makefile))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.makefile
+      embed_scope:
+        markup.raw.code-fence.makefile.djot
+        source.makefile
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-matlab:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:matlab))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.matlab.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.matlab
+      embed_scope: markup.raw.code-fence.matlab.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.matlab.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-objc:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:objc|obj-c|objectivec|objective-c))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.objc.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.objc
+      embed_scope: markup.raw.code-fence.objc.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.objc.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-objcpp:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:objc\+\+|obj-c\+\+|objectivec\+\+|objective-c\+\+))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.objc++.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.objc++
+      embed_scope: markup.raw.code-fence.objc++.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.objc++.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-ocaml:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:ocaml))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.ocaml.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.ocaml
+      embed_scope: markup.raw.code-fence.ocaml.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.ocaml.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-perl:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:perl))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.perl.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.perl
+      embed_scope: markup.raw.code-fence.perl.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.perl.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-php:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:php|inc))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.php.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.php
+      embed_scope: markup.raw.code-fence.php.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.php.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-python:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:python|py))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.python.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.python
+      embed_scope: markup.raw.code-fence.python.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.python.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-regexp:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:regexp?))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.regexp.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.regexp
+      embed_scope: markup.raw.code-fence.regexp.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.regexp.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-rscript:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:rscript|r|splus))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.r.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.r
+      embed_scope: markup.raw.code-fence.r.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.r.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-ruby:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:ruby|rb|rbx))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.ruby.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.ruby
+      embed_scope: markup.raw.code-fence.ruby.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.ruby.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-rust:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:rust|rs))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.rust.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.rust
+      embed_scope: markup.raw.code-fence.rust.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.rust.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-scala:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:scala))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.scala.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.scala
+      embed_scope: markup.raw.code-fence.scala.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.scala.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-shell:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:console|shell))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.shell.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.shell.interactive.djot
+      embed_scope: markup.raw.code-fence.shell.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.shell.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-shell-script:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:shell-script|sh|bash|zsh))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.shell-script.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.shell.bash
+      embed_scope: markup.raw.code-fence.shell-script.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.shell-script.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-sql:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:sql))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.sql.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.sql
+      embed_scope: markup.raw.code-fence.sql.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.sql.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-tsx:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:tsx))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.tsx.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.tsx
+      embed_scope: markup.raw.code-fence.tsx.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.tsx.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-typescript:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:typescript|ts))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.typescript.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.ts
+      embed_scope: markup.raw.code-fence.typescript.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.typescript.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-xml:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:atom|plist|svg|xjb|xml|xsd|xsl))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.xml.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:text.xml
+      embed_scope: markup.raw.code-fence.xml.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.xml.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-yaml:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:yaml|yml))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.yaml.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.yaml
+      embed_scope: markup.raw.code-fence.yaml.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.yaml.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-raw:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          {{fenced_code_block_language}}?
+          .*$\n?       # all characters until EOL
+      captures:
+        0: meta.code-fence.definition.begin.text.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      push: fenced-raw-content
+
+  fenced-raw-content:
+    - meta_content_scope: markup.raw.code-fence.djot
+    - match: '{{fenced_code_block_escape}}'
+      captures:
+        0: meta.code-fence.definition.end.text.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+      pop: true
+
+  fenced-ada:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:ada))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.ada.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.ada
+      embed_scope: markup.raw.code-fence.ada.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.ada.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-akh:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:akh))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.akh.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.akh
+      embed_scope: markup.raw.code-fence.akh.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.akh.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-arduino:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:arduino|ino))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.arduino.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.arduino
+      embed_scope: markup.raw.code-fence.arduino.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.arduino.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-coffee:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:coffee(?:script)?|cjsx|cson|iced))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.coffee.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.coffee
+      embed_scope: markup.raw.code-fence.coffee.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.coffee.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-dart:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:dart))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.dart.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.dart
+      embed_scope: markup.raw.code-fence.dart.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.dart.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-docker:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:docker(?:file)?))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.docker.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.shell.docker
+      embed_scope: markup.raw.code-fence.docker.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.docker.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-elixir:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:elixir))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.elixir.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.elixir
+      embed_scope: markup.raw.code-fence.elixir.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.elixir.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-fish:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:fish))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.fish.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.shell.fish
+      embed_scope: markup.raw.code-fence.fish.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.fish.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-graphql:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:graphql))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.graphql.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.graphql
+      embed_scope: markup.raw.code-fence.graphql.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.graphql.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-http:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:http))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.http.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:text.http-request-response
+      embed_scope: markup.raw.code-fence.http.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.http.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-ini:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:ini))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.ini.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.ini
+      embed_scope: markup.raw.code-fence.ini.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.ini.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-jade:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:jade))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.jade.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.jade
+      embed_scope: markup.raw.code-fence.jade.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.jade.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-julia:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:julia))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.julia.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.julia
+      embed_scope: markup.raw.code-fence.julia.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.julia.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-kotlin:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:kotlin))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.kotlin.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.kotlin
+      embed_scope: markup.raw.code-fence.kotlin.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.kotlin.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-less:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:less))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.less.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.less
+      embed_scope: markup.raw.code-fence.less.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.less.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-mermaid:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:mermaid))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.mermaid.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.mermaid
+      embed_scope:
+        markup.raw.code-fence.mermaid.djot
+        source.mermaid.embedded.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.mermaid.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-nim:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:nim))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.nim.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.nim
+      embed_scope: markup.raw.code-fence.nim.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.nim.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-powershell:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:pwsh|powershell))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.powershell.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.powershell
+      embed_scope: markup.raw.code-fence.powershell.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.powershell.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-protobuf:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:protobuf))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.protobuf.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.proto
+      embed_scope: markup.raw.code-fence.protobuf.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.protobuf.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-reason:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:re|reason))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.reason.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.reason
+      embed_scope: markup.raw.code-fence.reason.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.reason.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-sass:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:sass))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.sass.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.sass
+      embed_scope: markup.raw.code-fence.sass.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.sass.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-scheme:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:scheme))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.scheme.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.scheme
+      embed_scope: markup.raw.code-fence.scheme.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.scheme.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-scss:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:scss))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.scss.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.scss
+      embed_scope: markup.raw.code-fence.scss.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.scss.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-stata:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:s|stata|\{s\}|\{s[\s,].*\}|\{stata\}|\{stata[\s,].*\}))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.stata.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.stata
+      embed_scope: markup.raw.code-fence.stata.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.stata.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-svelte:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:svelte))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.svelte.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:text.html.svelte
+      embed_scope: markup.raw.code-fence.svelte.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.svelte.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-swift:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:swift))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.swift.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.swift
+      embed_scope: markup.raw.code-fence.swift.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.swift.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-terraform:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:terraform|tf|hcl))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.terraform.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.json.terraform
+      embed_scope: markup.raw.code-fence.terraform.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.terraform.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-toml:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:toml))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.toml.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.toml
+      embed_scope: markup.raw.code-fence.toml.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.toml.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-twee:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:twee))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.twee.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:text.twee
+      embed_scope:
+        markup.raw.code-fence.twee.djot
+        text.twee.embedded.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.twee.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-twig:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:twig|craftcms))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.twig.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:text.html.twig
+      embed_scope: markup.raw.code-fence.twig.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.twig.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-verilog:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:verilog|v))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.verilog.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.verilog
+      embed_scope: markup.raw.code-fence.verilog.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.verilog.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+  fenced-xonsh:
+    - match: |-
+         (?x)
+          {{fenced_code_block_start}}
+          ((?i:xonsh|xsh))
+          {{fenced_code_block_trailing_infostring_characters}}
+      captures:
+        0: meta.code-fence.definition.begin.xonsh.djot
+        2: punctuation.definition.raw.code-fence.begin.djot
+        5: constant.other.language-name.djot
+      embed: scope:source.xonsh
+      embed_scope: markup.raw.code-fence.xonsh.djot
+      escape: '{{fenced_code_block_escape}}'
+      escape_captures:
+        0: meta.code-fence.definition.end.xonsh.djot
+        1: punctuation.definition.raw.code-fence.end.djot
+
+###[ 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: true
+    - include: html-content
+
+  html-block-type-1b:
+    - match: (?!</?\1>)
+      pop: true
+    - include: html-content
+
+  html-block-type-2:
+    - match: (?!{{html_block_comment}})
+      pop: true
+    - include: html-content
+
+  html-block-type-3:
+    - match: \?>
+      pop: true
+
+  html-block-type-4:
+    - match: (?!{{html_block_decl}})
+      pop: true
+    - include: html-content
+    - match: '{{html_block_decl}}'
+      set: html-block-type-4-other
+
+  html-block-type-4-other:
+    - match: '>'
+      pop: true
+
+  html-block-type-5:
+    - match: (?!{{html_block_cdata}})
+      pop: true
+    - include: html-content
+
+  html-block-type-6:
+    - meta_scope: meta.disable-djot
+    - match: ^\s*\n
+      pop: true
+    - include: html-content
+
+  html-block-pop-at-eol:
+    - meta_scope: meta.disable-djot
+    - match: $\n?
+      pop: true
+    - 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
+
+  html-kbd-tags:
+    # A simple implementation to add dedicated `markup.kbd` scopes.
+    # Note: Doesn't (intent to) support bold/italic/striked content.
+    - match: ((<)(kbd)(>))([^<]+)((</)(kbd)(>))
+      captures:
+        1: markup.kbd.djot meta.tag.inline.any.html
+        2: punctuation.definition.tag.begin.html
+        3: entity.name.tag.inline.any.html
+        4: punctuation.definition.tag.end.html
+        5: markup.kbd.content.djot
+        6: markup.kbd.djot meta.tag.inline.any.html
+        7: punctuation.definition.tag.begin.html
+        8: entity.name.tag.inline.any.html
+        9: punctuation.definition.tag.end.html
+
+###[ 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.djot
+        3: entity.name.reference.link.djot
+        4: punctuation.definition.reference.end.djot
+        5: punctuation.separator.key-value.djot
+      push: footnote-def-body
+
+  footnote-def-body:
+    - meta_scope: meta.link.reference.def.footnote.djot
+    - include: footnote-def-end
+    - include: footnote-paragraphs
+
+  footnote-def-end:
+    - match: ^(?!(?:\1[ ]{4}|\s*$))
+      pop: true
+
+  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
+           |   {{math_block}}              # a math block begins the line
+           |   {{html_block}}              # a html block begins the line
+           )
+        )
+      pop: true
+
+  link-definitions:
+    # https://spec.commonmark.org/0.30/#link-reference-definition
+    - match: '[ \t]*(\[)({{reference_name}})(\])(:)'
+      captures:
+        1: punctuation.definition.reference.begin.djot
+        2: entity.name.reference.link.djot
+        3: punctuation.definition.reference.end.djot
+        4: punctuation.separator.key-value.djot
+      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.djot
+    - include: immediately-pop
+
+  link-def-attr:
+    - match: \{
+      scope: punctuation.definition.attributes.begin.djot
+      set: link-def-attr-body
+    - match: ^(?!\s*{)|(?=\S)
+      pop: true
+
+  link-def-attr-body:
+    - meta_scope: meta.attributes.djot
+    - include: tag-attributes
+
+  link-def-title:
+    - match: ^(?!\s*["'(])
+      pop: true
+    - match: (?=["'(])
+      set:
+        - expect-attr-or-eol
+        - link-title
+    - match: (?=\{)
+      pop: true
+    - match: \S.+
+      scope: invalid.illegal.expected-eol.djot
+
+  expect-attr-or-eol:
+    - match: (?=\{)
+      pop: true
+    - include: expect-eol
+
+  link-def-url:
+    - match: <
+      scope: punctuation.definition.link.begin.djot
+      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.djot
+    - include: link-url-angled
+
+  link-def-url-unquoted:
+    - meta_scope: markup.underline.link.djot
+    # URLs are terminated by whitespace or newline in reference definitions
+    # Note: \s includes \n
+    - match: (?=\s)
+      pop: true
+    - include: link-url-common
+
+###[ LEAF BLOCKS: TABLES ]####################################################
+
+  tables:
+    - match: ^(?={{table_first_row}})
+      push: table-header
+
+  table-header:
+    - meta_content_scope: meta.table.header.djot
+    - match: \n
+      set: table-header-separator-begin
+    - include: table-cell-content
+
+  table-header-separator-begin:
+    - match: ^(?=[-|:\s]+$)
+      set: table-header-separator
+    - match: ^
+      pop: true
+
+  table-header-separator:
+    - meta_content_scope: meta.table.header-separator.djot
+    - match: \n
+      set: table-body
+    - match: -+
+      scope: punctuation.section.table-header.djot
+    - match: ':'
+      scope: punctuation.definition.table-cell-alignment.djot
+    - include: table-cell-separators
+
+  table-body:
+    - meta_content_scope: meta.table.djot
+    - 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: true
+
+  table-cell-content:
+    - match: (?={{balanced_emphasis}})
+      push: table-cell-emphasis
+    - match: (?!{{backticks}})`+
+      scope: invalid.deprecated.unescaped-backticks.djot
+    - include: table-cell-separators
+    - include: images
+    - include: literals
+    - include: links
+    - include: markups
+
+  table-cell-emphasis:
+    - include: emphasis
+    - include: immediately-pop
+
+  table-cell-separators:
+    - match: \|
+      scope: punctuation.separator.table-cell.djot
+
+###[ 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.djot
+    - match: '[-_*]+'
+      scope: punctuation.definition.thematic-break.djot
+    - match: \n
+      pop: true
+
+###[ 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-kbd-tags
+    - include: html-content
+
+###[ INLINE: CODE SPANS ]#####################################################
+
+  code-spans:
+    # https://spec.commonmark.org/0.30/#code-spans
+    - match: (`+)(?!`)
+      scope: punctuation.definition.raw.begin.djot
+      push: code-span-body
+
+  code-span-body:
+    - meta_scope: markup.raw.inline.djot
+    - match: \1(?!`)
+      scope: punctuation.definition.raw.end.djot
+      pop: true
+    - match: '`+'
+    - match: ^\s*$\n?
+      scope: invalid.illegal.non-terminated.raw.djot
+      pop: true
+    - include: paragraph-end
+
+###[ INLINE: EMPHASIS ]#######################################################
+
+  bold:
+    # https://spec.commonmark.org/0.30/#emphasis-and-strong-emphasis
+    - match: '{{bold_italic_asterisk_begin}}'
+      captures:
+        1: punctuation.definition.bold.begin.djot
+        2: markup.italic.djot punctuation.definition.italic.begin.djot
+        3: punctuation.definition.bold.begin.djot
+        4: markup.italic.djot punctuation.definition.italic.begin.djot
+      push: bold-italic-asterisk
+    - match: '{{bold_asterisk_begin}}'
+      scope: punctuation.definition.bold.begin.djot
+      push: bold-asterisk
+    - match: \b(__)(_)(?=\S)(?!_)
+      captures:
+        1: punctuation.definition.bold.begin.djot
+        2: markup.italic.djot punctuation.definition.italic.begin.djot
+      push: bold-italic-underscore
+    - match: \b__(?=\S)(?!_[_\s])
+      scope: punctuation.definition.bold.begin.djot
+      push: bold-underscore
+
+  bold-asterisk:
+    - meta_scope: markup.bold.djot
+    - 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.djot
+      pop: true
+    # 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.djot
+    - 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.djot
+      pop: true
+    # 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.djot
+    - meta_content_scope: markup.italic.djot
+    - 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.djot punctuation.definition.italic.end.djot
+        2: punctuation.definition.bold.end.djot
+      pop: true
+    - match: \*\*
+      scope: punctuation.definition.bold.end.djot
+      set: italic-after-bold-italic-asterisk
+    - match: \*
+      scope: punctuation.definition.italic.end.djot
+      set: bold-after-bold-italic-asterisk
+    - include: emphasis-common
+    - include: strikethrough
+
+  bold-after-bold-italic-asterisk:
+    - meta_content_scope: markup.bold.djot
+    - 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.djot punctuation.definition.bold.end.djot
+      pop: true
+    - include: bold-common
+
+  italic-after-bold-italic-asterisk:
+    - meta_content_scope: markup.italic.djot
+    - 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.djot punctuation.definition.italic.end.djot
+      pop: true
+    - include: italic-common
+
+  bold-italic-underscore:
+    - meta_scope: markup.bold.djot
+    - meta_content_scope: markup.italic.djot
+    - 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.djot punctuation.definition.italic.end.djot
+        2: punctuation.definition.bold.end.djot
+      pop: true
+    - match: _\b
+      scope: punctuation.definition.italic.end.djot
+      set: bold-after-bold-italic-underscore
+    - match: __\b
+      scope: punctuation.definition.bold.end.djot
+      set: italic-after-bold-italic-underscore
+    - include: emphasis-common
+    - include: strikethrough
+
+  bold-after-bold-italic-underscore:
+    - meta_content_scope: markup.bold.djot
+    - 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.djot punctuation.definition.bold.end.djot
+      pop: true
+    - include: bold-common
+
+  italic-after-bold-italic-underscore:
+    - meta_content_scope: markup.italic.djot
+    - 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.djot punctuation.definition.italic.end.djot
+      pop: true
+    - include: italic-common
+
+  bold-common:
+    - include: emphasis-common
+    - include: italic
+    - include: strikethrough
+
+  italic:
+    - match: '{{italic_asterisk_begin}}'
+      scope: punctuation.definition.italic.begin.djot
+      push: italic-asterisk
+    - match: \b_(?=\S)(?!_)
+      scope: punctuation.definition.italic.begin.djot
+      push: italic-underscore
+    - match: '[*_]+'
+
+  italic-asterisk:
+    - meta_scope: markup.italic.djot
+    - 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.djot
+      pop: true
+    - match: \*+
+    - include: italic-common
+
+  italic-underscore:
+    - meta_scope: markup.italic.djot
+    - 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.djot
+      pop: true
+    - 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.djot
+      push: strikethrough-content
+    - match: ~+(?![~}>\s])  # any number of ~ not looking like ~> or ~~}
+
+  strikethrough-content:
+    - meta_scope: markup.strikethrough.djot
+    - match: ~~(?:(?!~)|(?=~~}|~>))  # 2x ~ maybe followed by ~> or ~~}
+      scope: punctuation.definition.strikethrough.end.djot
+      pop: true
+    - match: ~+(?:(?!~)|(?=~~}|~>))  # any number of ~ maybe followed by ~> or ~~}
+    - include: emphasis-common
+    - include: bold
+    - include: italic
+
+  emphasis-common:
+    - match: '{{setext_escape}}'
+      pop: true
+    - match: ^\s*$\n?
+      scope: invalid.illegal.non-terminated.bold-italic.djot
+      pop: true
+    - 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.djot
+      push:
+        - image-inline-metadata
+        - image-inline-text
+
+  image-inline-text:
+    - meta_scope: meta.image.inline.description.djot
+    - match: \]
+      scope: punctuation.definition.image.end.djot
+      pop: true
+    - include: link-text
+
+  image-inline-metadata:
+    - match: \(
+      scope: punctuation.definition.metadata.begin.djot
+      set:
+        - image-inline-metadata-end
+        - link-title
+        - image-inline-url
+    - include: immediately-pop
+
+  image-inline-metadata-end:
+    - meta_scope: meta.image.inline.metadata.djot
+    - match: \)
+      scope: punctuation.definition.metadata.end.djot
+      set: image-inline-attr
+    - include: else-pop
+
+  image-inline-url:
+    - match: <
+      scope: punctuation.definition.link.begin.djot
+      set: image-inline-url-angled
+    - match: (?=\S)
+      set: image-inline-url-unquoted
+
+  image-inline-url-angled:
+    - meta_content_scope: markup.underline.link.image.djot
+    - include: link-url-angled
+
+  image-inline-url-unquoted:
+    - meta_scope: markup.underline.link.image.djot
+    - include: link-url-unquoted
+
+  image-inline-attr:
+    - match: \{(?=[^}]*\})
+      scope: punctuation.definition.attributes.begin.djot
+      set: image-inline-attr-body
+    - include: immediately-pop
+
+  image-inline-attr-body:
+    - meta_scope: meta.image.inline.attributes.djot
+    - include: tag-attributes
+
+  image-ref:
+    - match: \!\[(?={{balance_square_brackets}}?\]\[{{reference_name}}\])
+      scope: punctuation.definition.image.begin.djot
+      push:
+        - image-ref-attr
+        - image-ref-metadata
+        - image-ref-text
+
+  image-ref-text:
+    - meta_scope: meta.image.reference.description.djot
+    - match: \]
+      scope: punctuation.definition.image.end.djot
+      pop: true
+    - include: link-text
+
+  image-ref-metadata:
+    - match: (\[)({{reference_name}})(\])
+      scope: meta.image.reference.metadata.djot
+      captures:
+        1: punctuation.definition.metadata.begin.djot
+        2: markup.underline.link.djot
+        3: punctuation.definition.metadata.end.djot
+      pop: true
+    - include: immediately-pop
+
+  image-ref-attr:
+    - match: \{(?=[^}]*\})
+      scope: punctuation.definition.attributes.begin.djot
+      set: image-ref-attr-body
+    - include: immediately-pop
+
+  image-ref-attr-body:
+    - meta_scope: meta.image.reference.djot
+    - include: tag-attributes
+
+###[ INLINE: LINKS ]##########################################################
+
+  link-inline:
+    - match: \[(?={{balance_square_brackets}}?\]\()
+      scope: punctuation.definition.link.begin.djot
+      push:
+        - link-inline-metadata
+        - link-inline-text
+
+  link-inline-text:
+    - meta_scope: meta.link.inline.description.djot
+    - match: \]
+      scope: punctuation.definition.link.end.djot
+      pop: true
+    - include: link-text-allow-image
+
+  link-inline-metadata:
+    - match: \(
+      scope: punctuation.definition.metadata.begin.djot
+      set:
+        - link-inline-metadata-end
+        - link-title
+        - link-inline-url
+    - include: immediately-pop
+
+  link-inline-metadata-end:
+    - meta_scope: meta.link.inline.metadata.djot
+    - match: \)
+      scope: punctuation.definition.metadata.end.djot
+      set: link-inline-attr
+    - include: else-pop
+
+  link-inline-url:
+    - match: <
+      scope: punctuation.definition.link.begin.djot
+      set: link-inline-url-angled
+    - match: (?=\S)
+      set: link-inline-url-unquoted
+
+  link-inline-url-angled:
+    - meta_content_scope: markup.underline.link.djot
+    - include: link-url-angled
+
+  link-inline-url-unquoted:
+    - meta_scope: markup.underline.link.djot
+    - include: link-url-unquoted
+
+  link-inline-attr:
+    - match: \{(?=[^}]*\})
+      scope: punctuation.definition.attributes.begin.djot
+      set: link-inline-attr-body
+    - include: immediately-pop
+
+  link-inline-attr-body:
+    - meta_scope: meta.link.inline.attributes.djot
+    - include: tag-attributes
+
+  link-ref:
+    - match: \[(?={{balance_square_brackets}}?\]\[{{reference_name}}\])
+      scope: punctuation.definition.link.begin.djot
+      push:
+        - link-ref-attr
+        - link-ref-metadata
+        - link-ref-link-text
+    - match: \[(?={{balance_square_brackets}}?\])
+      scope: punctuation.definition.link.begin.djot
+      push: link-ref-link-text
+
+  link-ref-link-text:
+    - meta_scope: meta.link.reference.description.djot
+    - match: \]
+      scope: punctuation.definition.link.end.djot
+      pop: true
+    - include: link-text-allow-image
+
+  link-ref-metadata:
+    - match: (\[)({{reference_name}})(\])
+      scope: meta.link.reference.metadata.djot
+      captures:
+        1: punctuation.definition.metadata.begin.djot
+        2: markup.underline.link.djot
+        3: punctuation.definition.metadata.end.djot
+      pop: true
+    - include: immediately-pop
+
+  link-ref-attr:
+    - match: \{(?=[^}]*\})
+      scope: punctuation.definition.attributes.begin.djot
+      set: link-ref-attr-body
+    - include: immediately-pop
+
+  link-ref-attr-body:
+    - meta_scope: meta.link.reference.attributes.djot
+    - include: tag-attributes
+
+  link-ref-literal:
+    - match: \[(?={{balance_square_brackets}}?\]\[\])
+      scope: punctuation.definition.link.begin.djot
+      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.djot
+    - match: \]
+      scope: punctuation.definition.link.end.djot
+      pop: true
+    - include: link-text-allow-image
+
+  link-ref-literal-metadata:
+    - match: (\[)(\])
+      scope: meta.link.reference.literal.metadata.djot
+      captures:
+        1: punctuation.definition.metadata.begin.djot
+        2: punctuation.definition.metadata.end.djot
+      pop: true
+    - include: immediately-pop
+
+  link-ref-literal-attr:
+    - match: \{(?=[^}]*\})
+      scope: punctuation.definition.attributes.begin.djot
+      set: link-ref-literal-attr-body
+    - include: immediately-pop
+
+  link-ref-literal-attr-body:
+    - meta_scope: meta.link.reference.literal.attributes.djot
+    - include: tag-attributes
+
+  link-ref-footnote:
+    - match: (\[)({{footnote_name}})(\])
+      captures:
+        0: meta.link.reference.footnote.djot
+        1: punctuation.definition.link.begin.djot
+        2: meta.link.reference.literal.footnote-id.djot
+        3: punctuation.definition.link.end.djot
+
+  link-ref-wiki:
+    - match: \[\[(?={{balance_square_brackets}}?\]\])
+      scope: punctuation.definition.link.begin.djot
+      push: link-ref-wiki-link-text
+
+  link-ref-wiki-link-text:
+    - meta_scope: meta.link.reference.wiki.description.djot
+    - match: \]\]
+      scope: punctuation.definition.link.end.djot
+      pop: true
+    - 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: true
+
+  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.djot
+      set: link-title-single-quoted-content
+    - match: \"
+      scope: punctuation.definition.string.begin.djot
+      set: link-title-double-quoted-content
+    - match: \(
+      scope: punctuation.definition.string.begin.djot
+      set: link-title-other-quoted-content
+
+  link-title-double-quoted-content:
+    - meta_scope: meta.string.title.djot string.quoted.double.djot
+    - match: \"
+      scope: punctuation.definition.string.end.djot
+      pop: true
+    - include: link-title-common
+
+  link-title-single-quoted-content:
+    - meta_scope: meta.string.title.djot string.quoted.single.djot
+    - match: \'
+      scope: punctuation.definition.string.end.djot
+      pop: true
+    - include: link-title-common
+
+  link-title-other-quoted-content:
+    - meta_scope: meta.string.title.djot string.quoted.other.djot
+    - match: \)
+      scope: punctuation.definition.string.end.djot
+      pop: true
+    - include: link-title-common
+
+  link-title-common:
+    - match: ^\s*$\n?
+      scope: invalid.illegal.non-terminated.link-title.djot
+      pop: true
+    - include: escapes
+    - include: html-entities
+
+  link-url-angled:
+    - match: \>
+      scope: punctuation.definition.link.end.djot
+      pop: true
+    - include: link-url-common
+
+  link-url-unquoted:
+    - match: (?=[ \t)])
+      pop: true
+    - match: \(
+      push: link-url-unquoted-parens
+    - include: link-url-common
+
+  link-url-unquoted-parens:
+    - match: \)
+      pop: true
+    - 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.djot
+      captures:
+        1: punctuation.definition.escape.djot
+
+  link-url-path-separators:
+    - match: '[/&?#]'
+      scope: punctuation.separator.path.djot
+
+  link-url-scheme-separators:
+    - match: ':/{,2}'
+      scope: punctuation.separator.path.djot
+
+  link-url-scheme-separator:
+    - match: ':/{,2}'
+      scope: punctuation.separator.path.djot
+      pop: true
+
+###[ INLINE: LINK/IMAGE/REFERENCE ATTRIBUTES ]################################
+
+  tag-attributes:
+    # https://kramdown.gettalong.org/syntax.html#span-ials
+    # https://michelf.ca/projects/php-djot/extra/
+    # https://pandoc.org/MANUAL.html#extension-link_attributes
+    - match: \}
+      scope: punctuation.definition.attributes.end.djot
+      pop: true
+    - match: \,
+      scope: punctuation.separator.sequence.djot
+    - match: '{{tag_attribute_name_start}}'
+      push: [tag-attr-meta, tag-attr-equals, tag-attr-name]
+
+  tag-attr-name:
+    - meta_scope: entity.other.attribute-name.djot
+    - match: '{{tag_attribute_name_break}}'
+      pop: true
+    - match: '["''`<]'
+      scope: invalid.illegal.attribute-name.djot
+
+  tag-attr-meta:
+    - meta_include_prototype: false
+    - meta_scope: meta.attribute-with-value.djot
+    - include: immediately-pop
+
+  tag-attr-equals:
+    - match: =
+      scope: punctuation.separator.key-value.djot
+      set: tag-attr-value
+    - include: else-pop
+
+  tag-attr-value:
+    - match: \"
+      scope: punctuation.definition.string.begin.djot
+      set: tag-attr-value-double-quoted
+    - match: \'
+      scope: punctuation.definition.string.begin.djot
+      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.djot
+    - match: \"
+      scope: punctuation.definition.string.end.djot
+      pop: true
+
+  tag-attr-value-single-quoted:
+    - meta_scope: string.quoted.single.djot
+    - match: \'
+      scope: punctuation.definition.string.end.djot
+      pop: true
+
+  tag-attr-value-unquoted:
+    - meta_scope: string.unquoted.djot
+    - match: '{{tag_unquoted_attribute_break}}'
+      pop: true
+    - match: '["''`<]'
+      scope: invalid.illegal.attribute-value.djot
+
+###[ 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.djot
+        1: punctuation.definition.link.begin.djot
+        2: markup.underline.link.djot
+        3: punctuation.separator.path.djot
+        4: punctuation.separator.path.djot
+        5: punctuation.definition.link.end.djot
+    # Github Flavoured Markdown
+    - match: '[\w.+-]+(@)[\w-]+(?:\.(?:(?![._-][\W])[\w_-])+)+(?![_-])'
+      captures:
+        0: meta.link.email.djot markup.underline.link.djot
+        1: punctuation.separator.path.djot
+
+  autolink-inet:
+    # CommonMark
+    # https://spec.commonmark.org/0.30/#autolinks
+    - match: <(?=[[:alpha:]][[:alnum:].+-]+:)
+      scope: punctuation.definition.link.begin.djot
+      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.djot
+      push: autolink-inet-unquoted-content
+
+  autolink-inet-angled-content:
+    - meta_scope: meta.link.inet.djot
+    - meta_content_scope: markup.underline.link.djot
+    - match: \>
+      scope: punctuation.definition.link.end.djot
+      pop: true
+    # Spaces are not allowed in autolinks
+    - match: (?=\s)
+      pop: true
+    - include: autolink-inet-common
+
+  autolink-inet-unquoted-content:
+    - meta_scope: meta.link.inet.djot markup.underline.link.djot
+    # 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: true
+    - include: autolink-inet-common
+
+  autolink-inet-group:
+    - match: \)
+      pop: true
+    - match: (?=(?:{{html_entity}})*[?!.,:;*_~'"]*[\s<])
+      pop: true
+    - 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.djot
+
+  hard-line-breaks:
+    # https://spec.commonmark.org/0.30/#hard-line-breaks
+    - match: '[ ]{2,}$'
+      scope: meta.hard-line-break.djot punctuation.definition.hard-line-break.djot
+    - match: (\\)\n
+      captures:
+        0: meta.hard-line-break.djot
+        1: constant.character.escape.djot
+
+###[ 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.djot
+      push: critics-addition-content
+
+  critics-addition-content:
+    - meta_scope: markup.critic.addition.djot
+    - meta_content_scope: markup.inserted.critic.djot
+    - match: \+\+\}
+      scope: punctuation.definition.critic.end.djot
+      pop: true
+    - include: critics-common
+
+  critics-comments:
+    - match: '{>>'
+      scope: punctuation.definition.critic.begin.djot
+      push: critics-comment-content
+
+  critics-comment-content:
+    - meta_scope: markup.critic.comment.djot
+    - meta_content_scope: comment.critic.djot
+    - match: '<<}'
+      scope: punctuation.definition.critic.end.djot
+      pop: true
+    - include: critics-common
+
+  critics-deletions:
+    - match: '{--'
+      scope: punctuation.definition.critic.begin.djot
+      push: critics-deletion-content
+
+  critics-deletion-content:
+    - meta_scope: markup.critic.deletion.djot
+    - meta_content_scope: markup.deleted.critic.djot
+    - match: '--}'
+      scope: punctuation.definition.critic.end.djot
+      pop: true
+    - include: critics-common
+
+  critics-highlights:
+    - match: '{=='
+      scope: punctuation.definition.critic.begin.djot
+      push: critics-highlight-content
+
+  critics-highlight-content:
+    - meta_scope: markup.critic.highlight.djot
+    - meta_content_scope: markup.info.critic.djot
+    - match: '==}'
+      scope: punctuation.definition.critic.end.djot
+      pop: true
+    - include: critics-common
+
+  critics-substitutions:
+    - match: '{~~'
+      scope: punctuation.definition.critic.begin.djot
+      push: critics-substitution-deleted
+
+  critics-substitution-deleted:
+    - meta_scope: markup.critic.substitution.djot
+    - meta_content_scope: markup.deleted.critic.djot
+    - match: (?=~>)
+      set:
+        - meta_include_prototype: false
+        - match: '~>'
+          scope: punctuation.separator.critic.djot
+          set: critics-substitution-inserted
+    - include: critics-substitution-inserted
+
+  critics-substitution-inserted:
+    - meta_scope: markup.critic.substitution.djot
+    - meta_content_scope: markup.inserted.critic.djot
+    - match: '~~}'
+      scope: punctuation.definition.critic.end.djot
+      pop: true
+    - include: critics-common
+
+  critics-common:
+    - match: ^(?=\s*$)
+      pop: true
+    - include: emphasis
+    - include: images
+    - include: literals
+    - include: links
+
+###[ EXTENSIONS: LATEX ]######################################################
+
+  math-blocks:
+    - match: '[ \t]*(\$\$)'
+      captures:
+        1: punctuation.definition.math.begin.djot
+      push: math-block-content
+
+  math-block-content:
+    - meta_scope:
+        markup.math.block.djot
+        text.tex.latex.embedded.djot
+        meta.environment.math.block.dollar.latex
+    - match: (\$\$)(?:\s*\n)?
+      captures:
+        1: punctuation.definition.math.end.djot
+      pop: true
+    - include: math-content
+
+  math-inline:
+    - match: |-
+        (?x)
+        (\$)(?=\S)
+        (?=
+          (?: \\\\ | \\\$ | [^\$] )*?
+          \S\$(?:[^a-zA-Z0-9]|$)
+        )
+      scope: punctuation.definition.math.begin.djot
+      push: math-inline-content
+
+  math-inline-content:
+    - meta_scope:
+        markup.math.inline.djot
+        text.tex.latex.embedded.djot
+        meta.environment.math.block.dollar.latex
+    - match: \$
+      scope: punctuation.definition.math.end.djot
+      pop: true
+    - include: math-content
+
+  math-content:
+    - include: scope:text.tex.latex#macros
+    - include: scope:text.tex.latex#math-content
+
+###[ PROTOTYPES ]#############################################################
+
+  else-pop:
+    - match: (?=\S)
+      pop: true
+
+  eol-pop:
+    - match: $
+      pop: true
+
+  expect-eol:
+    - include: eol-pop
+    - match: \S.+
+      scope: invalid.illegal.expected-eol.djot
+
+  immediately-pop:
+    - match: ''
+      pop: true
+
diff --git a/syntaxes/syntax_set.packdump b/syntaxes/syntax_set.packdump
index b68f3581..17403430 100644
Binary files a/syntaxes/syntax_set.packdump and b/syntaxes/syntax_set.packdump differ