TypstCodeSyntaxes.sublime-syntax

%YAML 1.2
---
scope: syntax.text.typst
version: 2
hidden: true

contexts:

  main:
    - include: fenced-syntaxes-gen

  # ASP: asa
  fenced-asp:
    - match: (`{3,})((?i:asa))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.asp
      embed_scope: markup.raw.block.asp.typst source.asp
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # HTML (ASP): asp
  fenced-html-asp:
    - match: (`{3,})((?i:asp))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.asp
      embed_scope: markup.raw.block.html-asp.typst text.html.asp
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # ActionScript: as
  fenced-actionscript:
    - match: (`{3,})((?i:actionscript|as))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.actionscript
      embed_scope: markup.raw.block.actionscript.typst source.actionscript
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # AppleScript: applescript, script editor
  fenced-applescript:
    - match: (`{3,})((?i:applescript))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.applescript
      embed_scope: markup.raw.block.applescript.typst source.applescript
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Batch File: bat, cmd
  fenced-dosbatch:
    - match: (`{3,})((?i:bat|cmd))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.dosbatch
      embed_scope: markup.raw.block.dosbatch.typst source.dosbatch
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # NAnt Build File: build
  fenced-nant-build:
    - match: (`{3,})((?i:build))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.nant-build
      embed_scope: markup.raw.block.nant-build.typst source.nant-build
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # C#: cs, csx
  fenced-csharp:
    - match: (`{3,})((?i:cs|csx))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.cs
      embed_scope: markup.raw.block.csharp.typst source.cs
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # C++: cpp, cc, cp, cxx, c++, C, h, hh, hpp, hxx, h++, inl, ipp
  fenced-cpp:
    - match: (`{3,})((?i:c\+\+|cc|cp|cpp|cxx|h\+\+|hh|hpp|hxx|inl|ipp))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.c++
      embed_scope: markup.raw.block.cpp.typst source.c++
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # C: c, h
  fenced-c:
    - match: (`{3,})((?i:c))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.c
      embed_scope: markup.raw.block.c.typst source.c
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # CSS: css, css.erb, css.liquid
  fenced-css:
    - match: (`{3,})((?i:css))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.css
      embed_scope: markup.raw.block.css.typst source.css
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Clojure: clj, cljc, cljs, edn
  fenced-clojure:
    - match: (`{3,})((?i:clj|cljc|cljs|clojure|edn))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.clojure
      embed_scope: markup.raw.block.clojure.typst source.clojure
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # D: d, di
  fenced-d:
    - match: (`{3,})((?i:d|di))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.d
      embed_scope: markup.raw.block.d.typst source.d
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Diff: diff, patch
  fenced-diff:
    - match: (`{3,})((?i:diff|patch))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.diff
      embed_scope: markup.raw.block.diff.typst source.diff
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Erlang: erl, hrl, Emakefile, emakefile, escript
  fenced-erlang:
    - match: (`{3,})((?i:Emakefile|emakefile|erl|erlang|escript|hrl))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.erlang
      embed_scope: markup.raw.block.erlang.typst source.erlang
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # HTML (Erlang): yaws
  fenced-html-erlang:
    - match: (`{3,})((?i:yaws))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.erlang
      embed_scope: markup.raw.block.html-erlang.typst text.html.erlang
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Git Attributes: attributes, gitattributes, .gitattributes
  fenced-git-attributes:
    - match: (`{3,})((?i:attributes|gitattributes))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.git.attributes
      embed_scope: markup.raw.block.git-attributes.typst text.git.attributes
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Git Commit: COMMIT_EDITMSG, MERGE_MSG, TAG_EDITMSG
  fenced-git-commit:
    - match: (`{3,})((?i:COMMIT_EDITMSG|MERGE_MSG|TAG_EDITMSG))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.git.commit
      embed_scope: markup.raw.block.git-commit.typst text.git.commit
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Git Config: gitconfig, .gitconfig, .gitmodules
  fenced-git-config:
    - match: (`{3,})((?i:gitconfig))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.git.config
      embed_scope: markup.raw.block.git-config.typst text.git.config
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Git Ignore: exclude, gitignore, .gitignore
  fenced-git-ignore:
    - match: (`{3,})((?i:exclude|gitignore))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.git.ignore
      embed_scope: markup.raw.block.git-ignore.typst text.git.ignore
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Git Log: gitlog
  fenced-git-log:
    - match: (`{3,})((?i:gitlog))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.git.log
      embed_scope: markup.raw.block.git-log.typst text.git.log
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Git Mailmap: .mailmap, mailmap
  fenced-git-mailmap:
    - match: (`{3,})((?i:mailmap))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.git.mailmap
      embed_scope: markup.raw.block.git-mailmap.typst text.git.mailmap
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Git Rebase Todo: git-rebase-todo
  fenced-git-rebase:
    - match: (`{3,})((?i:git-rebase-todo))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.git.rebase
      embed_scope: markup.raw.block.git-rebase.typst text.git.rebase
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Go: go
  fenced-go:
    - match: (`{3,})((?i:go))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.go
      embed_scope: markup.raw.block.go.typst source.go
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Graphviz (DOT): dot, DOT, gv
  fenced-graphviz:
    - match: (`{3,})((?i:DOT|dot|gv))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.dot
      embed_scope: markup.raw.block.graphviz.typst source.dot
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Groovy: groovy, gvy, gradle, Jenkinsfile
  fenced-groovy:
    - match: (`{3,})((?i:Jenkinsfile|gradle|groovy|gvy))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.groovy
      embed_scope: markup.raw.block.groovy.typst source.groovy
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # HTML: html, htm, shtml, xhtml
  fenced-html:
    - match: (`{3,})((?i:htm|html|shtml|xhtml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.basic
      embed_scope: markup.raw.block.html.typst text.html.basic
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Haskell: hs
  fenced-haskell:
    - match: (`{3,})((?i:haskell|hs))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.haskell
      embed_scope: markup.raw.block.haskell.typst source.haskell
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Literate Haskell: lhs
  fenced-tex-latex-haskell:
    - match: (`{3,})((?i:lhs))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.tex.latex.haskell
      embed_scope: markup.raw.block.tex-latex-haskell.typst text.tex.latex.haskell
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # JSON: json, sublime-settings, sublime-menu, sublime-keymap, sublime-mousemap, sublime-theme, sublime-build, sublime-project, sublime-completions, sublime-commands, sublime-macro, sublime-color-scheme, ipynb, Pipfile.lock
  fenced-json:
    - match: (`{3,})((?i:ipynb|json|sublime-build|sublime-color-scheme|sublime-commands|sublime-completions|sublime-keymap|sublime-macro|sublime-menu|sublime-mousemap|sublime-project|sublime-settings|sublime-theme))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.json
      embed_scope: markup.raw.block.json.typst source.json
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Java Server Page (JSP): jsp
  fenced-html-jsp:
    - match: (`{3,})((?i:jsp))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.jsp
      embed_scope: markup.raw.block.html-jsp.typst text.html.jsp
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Java: java, bsh
  fenced-java:
    - match: (`{3,})((?i:bsh|java))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.java
      embed_scope: markup.raw.block.java.typst source.java
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Java Properties: properties
  fenced-java-props:
    - match: (`{3,})((?i:properties))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.java-props
      embed_scope: markup.raw.block.java-props.typst source.java-props
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # JavaScript: js, htc
  fenced-javascript:
    - match: (`{3,})((?i:htc|javascript|js))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.js
      embed_scope: markup.raw.block.javascript.typst source.js
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # BibTeX: bib
  fenced-bibtex:
    - match: (`{3,})((?i:bib|bibtex))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.bibtex
      embed_scope: markup.raw.block.bibtex.typst text.bibtex
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # LaTeX: tex, ltx
  fenced-latex:
    - match: (`{3,})((?i:latex|ltx|tex))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.tex.latex
      embed_scope: markup.raw.block.latex.typst text.tex.latex
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # TeX: sty, cls
  fenced-tex:
    - match: (`{3,})((?i:cls|sty))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.tex
      embed_scope: markup.raw.block.tex.typst text.tex
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Lisp: lisp, cl, clisp, l, mud, el, scm, ss, lsp, fasl, sld
  fenced-lisp:
    - match: (`{3,})((?i:cl|clisp|el|fasl|l|lisp|lsp|mud|scm|sld|ss))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.lisp
      embed_scope: markup.raw.block.lisp.typst source.lisp
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Lua: lua
  fenced-lua:
    - match: (`{3,})((?i:lua))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.lua
      embed_scope: markup.raw.block.lua.typst source.lua
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Makefile: make, GNUmakefile, makefile, Makefile, makefile.am, Makefile.am, makefile.in, Makefile.in, OCamlMakefile, mak, mk
  fenced-makefile:
    - match: (`{3,})((?i:GNUmakefile|Makefile|OCamlMakefile|mak|make|makefile|mk))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.makefile
      embed_scope: markup.raw.block.makefile.typst source.makefile
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Markdown: md, mdown, markdown, markdn
  fenced-markdown:
    - match: (`{3,})((?i:markdn|markdown|md|mdown))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.markdown
      embed_scope: markup.raw.block.markdown.typst text.html.markdown
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # MultiMarkdown: 
  fenced-multimarkdown:
    - match: (`{3,})((?i:multimarkdown))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.markdown.multimarkdown
      embed_scope: markup.raw.block.multimarkdown.typst text.html.markdown.multimarkdown
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # MATLAB: matlab
  fenced-matlab:
    - match: (`{3,})((?i:matlab))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.matlab
      embed_scope: markup.raw.block.matlab.typst source.matlab
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # OCaml: ml, mli
  fenced-ocaml:
    - match: (`{3,})((?i:ml|mli|ocaml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ocaml
      embed_scope: markup.raw.block.ocaml.typst source.ocaml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # OCamllex: mll
  fenced-ocamllex:
    - match: (`{3,})((?i:mll|ocamllex))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ocamllex
      embed_scope: markup.raw.block.ocamllex.typst source.ocamllex
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # OCamlyacc: mly
  fenced-ocamlyacc:
    - match: (`{3,})((?i:mly|ocamlyacc))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ocamlyacc
      embed_scope: markup.raw.block.ocamlyacc.typst source.ocamlyacc
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Objective-C++: mm, M, h
  fenced-objcpp:
    - match: (`{3,})((?i:mm))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.objc++
      embed_scope: markup.raw.block.objcpp.typst source.objc++
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Objective-C: m, h
  fenced-objc:
    - match: (`{3,})((?i:h|m|objective-c))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.objc
      embed_scope: markup.raw.block.objc.typst source.objc
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # PHP: php, php3, php4, php5, php7, phps, phpt, phtml
  fenced-php:
    - match: (`{3,})((?i:php|php3|php4|php5|php7|phps|phpt|phtml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:embedding.php
      embed_scope: markup.raw.block.php.typst embedding.php
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Pascal: pas, p, dpr
  fenced-pascal:
    - match: (`{3,})((?i:dpr|p|pas|pascal))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.pascal
      embed_scope: markup.raw.block.pascal.typst source.pascal
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Perl: pl, pc, pm, pmc, pod, t
  fenced-perl:
    - match: (`{3,})((?i:pc|perl|pl|pm|pmc|pod|t))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.perl
      embed_scope: markup.raw.block.perl.typst source.perl
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Python: py, py3, pyw, pyi, pyx, pyx.in, pxd, pxd.in, pxi, pxi.in, rpy, cpy, SConstruct, Sconstruct, sconstruct, SConscript, gyp, gypi, Snakefile, vpy, wscript, bazel, bzl
  fenced-python:
    - match: (`{3,})((?i:SConscript|SConstruct|Sconstruct|Snakefile|bazel|bzl|cpy|gyp|gypi|pxd|pxi|py|py3|pyi|python|pyw|pyx|rpy|sconstruct|vpy|wscript))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.python
      embed_scope: markup.raw.block.python.typst source.python
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # R: R, r, Rprofile
  fenced-r:
    - match: (`{3,})((?i:R|Rprofile|r))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.r
      embed_scope: markup.raw.block.r.typst source.r
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Rd (R Documentation): rd
  fenced-tex-latex-rd:
    - match: (`{3,})((?i:rd))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.tex.latex.rd
      embed_scope: markup.raw.block.tex-latex-rd.typst text.tex.latex.rd
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # HTML (Rails): rails, rhtml, erb, html.erb
  fenced-html-ruby:
    - match: (`{3,})((?i:erb|rails|rhtml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.ruby
      embed_scope: markup.raw.block.html-ruby.typst text.html.ruby
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Ruby Haml: haml, sass
  fenced-haml:
    - match: (`{3,})((?i:haml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.haml
      embed_scope: markup.raw.block.haml.typst text.haml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Ruby on Rails: rxml, builder
  fenced-ruby-rails:
    - match: (`{3,})((?i:builder|rxml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ruby.rails
      embed_scope: markup.raw.block.ruby-rails.typst source.ruby.rails
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # SQL (Rails): erbsql, sql.erb
  fenced-sql-ruby:
    - match: (`{3,})((?i:erbsql))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.sql.ruby
      embed_scope: markup.raw.block.sql-ruby.typst source.sql.ruby
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Regular Expression: re
  fenced-regexp:
    - match: (`{3,})((?i:re))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.regexp
      embed_scope: markup.raw.block.regexp.typst source.regexp
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # reStructuredText: rst, rest
  fenced-restructuredtext:
    - match: (`{3,})((?i:rest|restructuredtext|rst))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.restructuredtext
      embed_scope: markup.raw.block.restructuredtext.typst text.restructuredtext
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Ruby: rb, Appfile, Appraisals, Berksfile, Brewfile, capfile, cgi, Cheffile, config.ru, Deliverfile, Fastfile, fcgi, Gemfile, gemspec, Guardfile, irbrc, jbuilder, Podfile, podspec, prawn, rabl, rake, Rakefile, Rantfile, rbx, rjs, ruby.rail, Scanfile, simplecov, Snapfile, thor, Thorfile, Vagrantfile
  fenced-ruby:
    - match: (`{3,})((?i:Appfile|Appraisals|Berksfile|Brewfile|Cheffile|Deliverfile|Fastfile|Gemfile|Guardfile|Podfile|Rakefile|Rantfile|Scanfile|Snapfile|Thorfile|Vagrantfile|capfile|cgi|fcgi|gemspec|irbrc|jbuilder|podspec|prawn|rabl|rake|rb|rbx|rjs|ruby|simplecov|thor))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ruby
      embed_scope: markup.raw.block.ruby.typst source.ruby
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Rust: rs
  fenced-rust:
    - match: (`{3,})((?i:rs|rust))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.rust
      embed_scope: markup.raw.block.rust.typst source.rust
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # SQL: sql, ddl, dml
  fenced-sql:
    - match: (`{3,})((?i:ddl|dml|sql))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.sql
      embed_scope: markup.raw.block.sql.typst source.sql
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Scala: scala, sbt, sc
  fenced-scala:
    - match: (`{3,})((?i:sbt|sc|scala))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.scala
      embed_scope: markup.raw.block.scala.typst source.scala
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Bourne Again Shell (bash): sh, bash, zsh, ash, .bash_aliases, .bash_completions, .bash_functions, .bash_login, .bash_logout, .bash_profile, .bash_variables, .bashrc, .profile, .textmate_init, .zlogin, .zlogout, .zprofile, .zshenv, .zshrc, PKGBUILD, ebuild, eclass
  fenced-shell-script:
    - match: (`{3,})((?i:PKGBUILD|ash|bash|ebuild|eclass|sh|zsh))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.shell.bash
      embed_scope: markup.raw.block.shell-script.typst source.shell.bash
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # HTML (Tcl): adp
  fenced-html-tcl:
    - match: (`{3,})((?i:adp))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.tcl
      embed_scope: markup.raw.block.html-tcl.typst text.html.tcl
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Tcl: tcl
  fenced-tcl:
    - match: (`{3,})((?i:tcl))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.tcl
      embed_scope: markup.raw.block.tcl.typst source.tcl
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Textile: textile
  fenced-textile:
    - match: (`{3,})((?i:textile))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.textile
      embed_scope: markup.raw.block.textile.typst text.html.textile
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # XML: xml, xsd, xslt, tld, dtml, rng, rss, opml, svg, xaml
  fenced-xml:
    - match: (`{3,})((?i:dtml|opml|rng|rss|svg|tld|xaml|xml|xsd|xslt))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.xml
      embed_scope: markup.raw.block.xml.typst text.xml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # YAML: yaml, yml, sublime-syntax
  fenced-yaml:
    - match: (`{3,})((?i:sublime-syntax|yaml|yml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.yaml
      embed_scope: markup.raw.block.yaml.typst source.yaml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # AWK: awk
  fenced-awk:
    - match: (`{3,})((?i:awk))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.awk
      embed_scope: markup.raw.block.awk.typst source.awk
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Ada: adb, ads, gpr
  fenced-ada:
    - match: (`{3,})((?i:ada|adb|ads|gpr))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ada
      embed_scope: markup.raw.block.ada.typst source.ada
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Apache Conf: envvars, htaccess, HTACCESS, htgroups, HTGROUPS, htpasswd, HTPASSWD, .htaccess, .HTACCESS, .htgroups, .HTGROUPS, .htpasswd, .HTPASSWD
  fenced-apacheconf:
    - match: (`{3,})((?i:HTACCESS|HTGROUPS|HTPASSWD|envvars|htaccess|htgroups|htpasswd))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.apacheconf
      embed_scope: markup.raw.block.apacheconf.typst source.apacheconf
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # AsciiDoc (Asciidoctor): adoc, ad, asciidoc
  fenced-asciidoc:
    - match: (`{3,})((?i:ad|adoc|asciidoc))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.asciidoc
      embed_scope: markup.raw.block.asciidoc.typst text.asciidoc
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Assembly (x86_64): yasm, nasm, asm, inc, mac
  fenced-asm-x86-64:
    - match: (`{3,})((?i:asm|inc|mac|nasm|yasm))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.asm.x86_64
      embed_scope: markup.raw.block.asm-x86-64.typst source.asm.x86_64
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # CFML: cfml, cfm, cfc
  fenced-cfml:
    - match: (`{3,})((?i:cfc|cfm|cfml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:embedding.cfml
      embed_scope: markup.raw.block.cfml.typst embedding.cfml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # CMake: CMakeLists.txt, cmake
  fenced-cmake:
    - match: (`{3,})((?i:cmake))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.cmake
      embed_scope: markup.raw.block.cmake.typst source.cmake
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # CMakeCache: CMakeCache.txt
  fenced-cmakecache:
    - match: (`{3,})((?i:CMakeCache|cmakecache))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.cmakecache
      embed_scope: markup.raw.block.cmakecache.typst source.cmakecache
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Comma Separated Values: csv, tsv
  fenced-csv:
    - match: (`{3,})((?i:csv|tsv))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.csv
      embed_scope: markup.raw.block.csv.typst text.csv
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Cabal: cabal
  fenced-cabal:
    - match: (`{3,})((?i:cabal))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.cabal
      embed_scope: markup.raw.block.cabal.typst source.cabal
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # CoffeeScript: coffee, Cakefile, coffee.erb, cson
  fenced-coffeescript:
    - match: (`{3,})((?i:Cakefile|coffee|coffeescript|cson))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.coffee
      embed_scope: markup.raw.block.coffeescript.typst source.coffee
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # CpuInfo: cpuinfo
  fenced-cpuinfo:
    - match: (`{3,})((?i:cpuinfo))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.cpuinfo
      embed_scope: markup.raw.block.cpuinfo.typst source.cpuinfo
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Crontab: tab, crontab, cron.d
  fenced-crontab:
    - match: (`{3,})((?i:crontab|tab))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.crontab
      embed_scope: markup.raw.block.crontab.typst source.crontab
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Crystal: cr
  fenced-crystal:
    - match: (`{3,})((?i:cr|crystal))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.crystal
      embed_scope: markup.raw.block.crystal.typst source.crystal
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Dart: dart
  fenced-dart:
    - match: (`{3,})((?i:dart))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.dart
      embed_scope: markup.raw.block.dart.typst source.dart
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Dockerfile: Dockerfile, dockerfile, .Dockerfile
  fenced-dockerfile:
    - match: (`{3,})((?i:Dockerfile|dockerfile))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.dockerfile
      embed_scope: markup.raw.block.dockerfile.typst source.dockerfile
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # DotENV: .env, .env.dist, .env.local, .env.sample, .env.example, .env.template, .env.test, .env.test.local, .env.testing, .env.dev, .env.development, .env.development.local, .env.prod, .env.production, .env.production.local, .env.dusk.local, .env.staging, .env.default, .env.defaults, .envrc, .flaskenv, env, env.example, env.sample, env.template
  fenced-dotenv:
    - match: (`{3,})((?i:dotenv|env))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.env
      embed_scope: markup.raw.block.dotenv.typst source.env
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Elixir: ex, exs
  fenced-elixir:
    - match: (`{3,})((?i:elixir|ex|exs))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.elixir
      embed_scope: markup.raw.block.elixir.typst source.elixir
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Elm: elm
  fenced-elm:
    - match: (`{3,})((?i:elm))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.elm
      embed_scope: markup.raw.block.elm.typst source.elm
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Email: eml, msg, mbx, mboxz
  fenced-email:
    - match: (`{3,})((?i:email|eml|mboxz|mbx|msg))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.eml
      embed_scope: markup.raw.block.email.typst text.eml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # F#: fs, fsi, fsx
  fenced-fsharp:
    - match: (`{3,})((?i:fsi|fsx))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.fsharp
      embed_scope: markup.raw.block.fsharp.typst source.fsharp
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Fish: fish
  fenced-fish:
    - match: (`{3,})((?i:fish))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.shell.fish
      embed_scope: markup.raw.block.fish.typst source.shell.fish
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Fortran (Fixed Form): f, F, f77, F77, for, FOR, fpp, FPP
  fenced-fixedform-fortran:
    - match: (`{3,})((?i:F|F77|FOR|FPP|f|f77|for|fpp))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.fixedform-fortran
      embed_scope: markup.raw.block.fixedform-fortran.typst source.fixedform-fortran
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Fortran (Modern): f90, F90, f95, F95, f03, F03, f08, F08
  fenced-modern-fortran:
    - match: (`{3,})((?i:F03|F08|F90|F95|f03|f08|f90|f95))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.modern-fortran
      embed_scope: markup.raw.block.modern-fortran.typst source.modern-fortran
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Fortran Namelist: namelist
  fenced-fortran-namelist:
    - match: (`{3,})((?i:namelist))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.fortran-namelist
      embed_scope: markup.raw.block.fortran-namelist.typst source.fortran-namelist
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # fstab: fstab, crypttab, mtab
  fenced-fstab:
    - match: (`{3,})((?i:crypttab|fstab|mtab))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.fstab
      embed_scope: markup.raw.block.fstab.typst source.fstab
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # GLSL: vs, fs, gs, vsh, fsh, gsh, vshader, fshader, gshader, vert, frag, geom, tesc, tese, comp, glsl, mesh, task, rgen, rint, rahit, rchit, rmiss, rcall
  fenced-glsl:
    - match: (`{3,})((?i:comp|frag|fs|fsh|fshader|geom|glsl|gs|gsh|gshader|mesh|rahit|rcall|rchit|rgen|rint|rmiss|task|tesc|tese|vert|vs|vsh|vshader))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.glsl
      embed_scope: markup.raw.block.glsl.typst source.glsl
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # GraphQL: graphql, graphqls, gql
  fenced-graphql:
    - match: (`{3,})((?i:gql|graphql|graphqls))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.graphql
      embed_scope: markup.raw.block.graphql.typst source.graphql
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Groff/troff: groff, troff, 1, 2, 3, 4, 5, 6, 7, 8, 9
  fenced-groff:
    - match: (`{3,})((?i:1|2|3|4|5|6|7|8|9|groff|troff))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.groff
      embed_scope: markup.raw.block.groff.typst text.groff
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # group: group
  fenced-group:
    - match: (`{3,})((?i:group))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.group
      embed_scope: markup.raw.block.group.typst source.group
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # HTML (Twig): twig, html.twig
  fenced-html-twig:
    - match: (`{3,})((?i:twig))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.twig
      embed_scope: markup.raw.block.html-twig.typst text.html.twig
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # hosts: hosts
  fenced-hosts:
    - match: (`{3,})((?i:hosts))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.hosts
      embed_scope: markup.raw.block.hosts.typst source.hosts
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # INI: ini, INI, inf, INF, reg, REG, lng, cfg, CFG, desktop, url, URL, .editorconfig, .coveragerc, .pylintrc, .gitlint, .hgrc, hgrc
  fenced-ini:
    - match: (`{3,})((?i:CFG|INF|INI|REG|URL|cfg|desktop|hgrc|inf|ini|lng|reg|url))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ini
      embed_scope: markup.raw.block.ini.typst source.ini
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Jinja2: j2, jinja2, jinja
  fenced-jinja2:
    - match: (`{3,})((?i:j2|jinja|jinja2))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.jinja2
      embed_scope: markup.raw.block.jinja2.typst source.jinja2
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # jsonnet: jsonnet, libsonnet, libjsonnet
  fenced-jsonnet:
    - match: (`{3,})((?i:jsonnet|libjsonnet|libsonnet))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.jsonnet
      embed_scope: markup.raw.block.jsonnet.typst source.jsonnet
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Julia: jl
  fenced-julia:
    - match: (`{3,})((?i:jl|julia))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.julia
      embed_scope: markup.raw.block.julia.typst source.julia
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Kotlin: kt, kts
  fenced-kotlin:
    - match: (`{3,})((?i:kotlin|kt|kts))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.Kotlin
      embed_scope: markup.raw.block.kotlin.typst source.Kotlin
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Less: less, css.less
  fenced-less:
    - match: (`{3,})((?i:less))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.less
      embed_scope: markup.raw.block.less.typst source.less
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # LLVM: ll
  fenced-llvm:
    - match: (`{3,})((?i:ll|llvm))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.llvm
      embed_scope: markup.raw.block.llvm.typst source.llvm
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Lean: lean
  fenced-lean:
    - match: (`{3,})((?i:lean))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.lean
      embed_scope: markup.raw.block.lean.typst source.lean
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # LiveScript: ls, Slakefile, ls.erb
  fenced-livescript:
    - match: (`{3,})((?i:Slakefile|livescript|ls))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.livescript
      embed_scope: markup.raw.block.livescript.typst source.livescript
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Manpage: man
  fenced-manpage:
    - match: (`{3,})((?i:man|manpage))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.man
      embed_scope: markup.raw.block.manpage.typst source.man
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # MediaWiki: mediawiki, wikipedia, wiki
  fenced-mediawiki:
    - match: (`{3,})((?i:mediawiki|wiki|wikipedia))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.mediawiki
      embed_scope: markup.raw.block.mediawiki.typst text.html.mediawiki
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # MemInfo: meminfo
  fenced-meminfo:
    - match: (`{3,})((?i:meminfo))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.meminfo
      embed_scope: markup.raw.block.meminfo.typst source.meminfo
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # NSIS: nsi, nsh, bnsi, bnsh, nsdinc
  fenced-nsis:
    - match: (`{3,})((?i:bnsh|bnsi|nsdinc|nsh|nsi|nsis))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.nsis
      embed_scope: markup.raw.block.nsis.typst source.nsis
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # nginx: conf.erb, conf, nginx.conf, mime.types, fastcgi_params, scgi_params, uwsgi_params
  fenced-nginx:
    - match: (`{3,})((?i:conf|fastcgi_params|nginx|scgi_params|uwsgi_params))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.nginx
      embed_scope: markup.raw.block.nginx.typst source.nginx
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Nim: nim, nims, nimble
  fenced-nim:
    - match: (`{3,})((?i:nim|nimble|nims))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.nim
      embed_scope: markup.raw.block.nim.typst source.nim
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Ninja: ninja
  fenced-ninja:
    - match: (`{3,})((?i:ninja))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ninja
      embed_scope: markup.raw.block.ninja.typst source.ninja
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Nix: nix
  fenced-nix:
    - match: (`{3,})((?i:nix))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.nix
      embed_scope: markup.raw.block.nix.typst source.nix
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # orgmode: org
  fenced-orgmode:
    - match: (`{3,})((?i:org|orgmode))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.orgmode
      embed_scope: markup.raw.block.orgmode.typst text.orgmode
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # passwd: passwd
  fenced-passwd:
    - match: (`{3,})((?i:passwd))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.passwd
      embed_scope: markup.raw.block.passwd.typst source.passwd
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Protocol Buffer: proto, protobuf, protodevel
  fenced-proto:
    - match: (`{3,})((?i:proto|protobuf|protodevel))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.proto
      embed_scope: markup.raw.block.proto.typst source.proto
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Protocol Buffer (TEXT): pb.txt, proto.text, textpb, pbtxt, prototxt, textproto
  fenced-prototxt:
    - match: (`{3,})((?i:pbtxt|prototxt|textpb|textproto))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.prototxt
      embed_scope: markup.raw.block.prototxt.typst text.prototxt
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Puppet: pp, epp
  fenced-puppet:
    - match: (`{3,})((?i:epp|pp|puppet))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.puppet
      embed_scope: markup.raw.block.puppet.typst source.puppet
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # PureScript: purs
  fenced-purescript:
    - match: (`{3,})((?i:purescript|purs))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.purescript
      embed_scope: markup.raw.block.purescript.typst source.purescript
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # QML: qml, qmlproject
  fenced-qml:
    - match: (`{3,})((?i:qml|qmlproject))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.qml
      embed_scope: markup.raw.block.qml.typst source.qml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Racket: rkt
  fenced-racket:
    - match: (`{3,})((?i:racket|rkt))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.racket
      embed_scope: markup.raw.block.racket.typst source.racket
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Rego: rego
  fenced-rego:
    - match: (`{3,})((?i:rego))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.rego
      embed_scope: markup.raw.block.rego.typst source.rego
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Requirements.txt: requirements.txt, requirements.in, pip
  fenced-requirements-txt:
    - match: (`{3,})((?i:pip))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.requirements-txt
      embed_scope: markup.raw.block.requirements-txt.typst source.requirements-txt
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # resolv: resolv.conf
  fenced-resolv:
    - match: (`{3,})((?i:resolv))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.resolv
      embed_scope: markup.raw.block.resolv.typst source.resolv
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Robot Framework: robot, resource
  fenced-robot:
    - match: (`{3,})((?i:resource|robot))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.robot
      embed_scope: markup.raw.block.robot.typst source.robot
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # SCSS: scss
  fenced-scss:
    - match: (`{3,})((?i:scss))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.scss
      embed_scope: markup.raw.block.scss.typst source.scss
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Sass: sass
  fenced-sass:
    - match: (`{3,})((?i:sass))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.sass
      embed_scope: markup.raw.block.sass.typst source.sass
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # SML: sml, cm, sig
  fenced-sml:
    - match: (`{3,})((?i:cm|sig|sml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.sml
      embed_scope: markup.raw.block.sml.typst source.sml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Ruby Slim: slim, skim
  fenced-slim:
    - match: (`{3,})((?i:skim|slim))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.slim
      embed_scope: markup.raw.block.slim.typst text.slim
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Strace: strace
  fenced-strace:
    - match: (`{3,})((?i:strace))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.strace
      embed_scope: markup.raw.block.strace.typst source.strace
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Stylus: styl, stylus
  fenced-stylus:
    - match: (`{3,})((?i:styl|stylus))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.stylus
      embed_scope: markup.raw.block.stylus.typst source.stylus
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Solidity: sol
  fenced-solidity:
    - match: (`{3,})((?i:sol|solidity))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.solidity
      embed_scope: markup.raw.block.solidity.typst source.solidity
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Vyper: vy
  fenced-vyper:
    - match: (`{3,})((?i:vy|vyper))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.vyper
      embed_scope: markup.raw.block.vyper.typst source.vyper
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # JQ: jq
  fenced-jq:
    - match: (`{3,})((?i:jq))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.jq
      embed_scope: markup.raw.block.jq.typst source.jq
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Svelte: svlt, svelte
  fenced-svelte:
    - match: (`{3,})((?i:svelte|svlt))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.svelte
      embed_scope: markup.raw.block.svelte.typst text.html.svelte
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Swift: swift
  fenced-swift:
    - match: (`{3,})((?i:swift))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.swift
      embed_scope: markup.raw.block.swift.typst source.swift
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # SystemVerilog: sv, v, svh, vh
  fenced-systemverilog:
    - match: (`{3,})((?i:sv|svh|systemverilog|vh))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.systemverilog
      embed_scope: markup.raw.block.systemverilog.typst source.systemverilog
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # TOML: toml, tml, Cargo.lock, Gopkg.lock, Pipfile, pdm.lock, poetry.lock, uv.lock
  fenced-toml:
    - match: (`{3,})((?i:Pipfile|tml|toml))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.toml
      embed_scope: markup.raw.block.toml.typst source.toml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Terraform: tf, tfvars, hcl
  fenced-terraform:
    - match: (`{3,})((?i:hcl|terraform|tf|tfvars))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.terraform
      embed_scope: markup.raw.block.terraform.typst source.terraform
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # TypeScript: ts, mts, cts
  fenced-typescript:
    - match: (`{3,})((?i:cts|mts|ts|typescript))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ts
      embed_scope: markup.raw.block.typescript.typst source.ts
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # TypeScriptReact: tsx
  fenced-typescriptreact:
    - match: (`{3,})((?i:tsx|typescriptreact))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.tsx
      embed_scope: markup.raw.block.typescriptreact.typst source.tsx
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Verilog: v, V
  fenced-verilog:
    - match: (`{3,})((?i:V|v|verilog))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.verilog
      embed_scope: markup.raw.block.verilog.typst source.verilog
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # VimL: vim, vimrc, gvimrc, .vimrc, .gvimrc, _vimrc, _gvimrc
  fenced-viml:
    - match: (`{3,})((?i:_gvimrc|_vimrc|gvimrc|vim|viml|vimrc))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.viml
      embed_scope: markup.raw.block.viml.typst source.viml
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Vue Component: vue
  fenced-html-vue:
    - match: (`{3,})((?i:vue))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.html.vue
      embed_scope: markup.raw.block.html-vue.typst text.html.vue
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Zig: zig
  fenced-zig:
    - match: (`{3,})((?i:zig))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.zig
      embed_scope: markup.raw.block.zig.typst source.zig
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Command Help: cmd-help, help
  fenced-cmd-help:
    - match: (`{3,})((?i:cmd-help|help))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.cmd-help
      embed_scope: markup.raw.block.cmd-help.typst text.cmd-help
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # gnuplot: gp, gpl, gnuplot, gnu, plot, plt
  fenced-gnuplot:
    - match: (`{3,})((?i:gnu|gnuplot|gp|gpl|plot|plt))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.gnuplot
      embed_scope: markup.raw.block.gnuplot.typst source.gnuplot
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # HTTP Request and Response: http
  fenced-http-request-response:
    - match: (`{3,})((?i:http))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.http-request-response
      embed_scope: markup.raw.block.http-request-response.typst text.http-request-response
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # log: log
  fenced-log:
    - match: (`{3,})((?i:log))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.log
      embed_scope: markup.raw.block.log.typst text.log
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Highlight non-printables: show-nonprintable
  fenced-whitespace:
    - match: (`{3,})((?i:show-nonprintable))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:whitespace
      embed_scope: markup.raw.block.whitespace.typst whitespace
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Authorized Keys: authorized_keys, pub, authorized_keys2
  fenced-authorized-keys:
    - match: (`{3,})((?i:authorized_keys|authorized_keys2|pub))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.authorized_keys
      embed_scope: markup.raw.block.authorized-keys.typst text.authorized_keys
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # Known Hosts: known_hosts, known_hosts.old
  fenced-known-hosts:
    - match: (`{3,})((?i:known_hosts))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.known_hosts
      embed_scope: markup.raw.block.known-hosts.typst text.known_hosts
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # SSH Config: ssh_config
  fenced-ssh-config:
    - match: (`{3,})((?i:ssh_config))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.ssh_config
      embed_scope: markup.raw.block.ssh-config.typst source.ssh_config
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # SSHD Config: sshd_config
  fenced-sshd-config:
    - match: (`{3,})((?i:sshd_config))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.sshd_config
      embed_scope: markup.raw.block.sshd-config.typst source.sshd_config
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # syslog: syslog
  fenced-syslog:
    - match: (`{3,})((?i:syslog))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:text.log.syslog
      embed_scope: markup.raw.block.syslog.typst text.log.syslog
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # varlink: varlink
  fenced-varlink:
    - match: (`{3,})((?i:varlink))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.varlink
      embed_scope: markup.raw.block.varlink.typst source.varlink
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  # WGSL: wgsl
  fenced-wgsl:
    - match: (`{3,})((?i:wgsl))($\n?|\b)
      captures:
        1: punctuation.definition.raw.code-fence.begin.typst
        2: constant.other.language-name.typst
      embed: scope:source.wgsl
      embed_scope: markup.raw.block.wgsl.typst source.wgsl
      escape: '(?:^[ \t]*)?(\1)\s*'
      escape_captures:
        1: punctuation.definition.raw.code-fence.end.typst

  fenced-syntaxes-gen:
    - include: fenced-actionscript
    - include: fenced-ada
    - include: fenced-apacheconf
    - include: fenced-applescript
    - include: fenced-asciidoc
    - include: fenced-asm-x86-64
    - include: fenced-asp
    - include: fenced-authorized-keys
    - include: fenced-awk
    - include: fenced-bibtex
    - include: fenced-c
    - include: fenced-cabal
    - include: fenced-cfml
    - include: fenced-clojure
    - include: fenced-cmake
    - include: fenced-cmakecache
    - include: fenced-cmd-help
    - include: fenced-coffeescript
    - include: fenced-cpp
    - include: fenced-cpuinfo
    - include: fenced-crontab
    - include: fenced-crystal
    - include: fenced-csharp
    - include: fenced-css
    - include: fenced-csv
    - include: fenced-d
    - include: fenced-dart
    - include: fenced-diff
    - include: fenced-dockerfile
    - include: fenced-dosbatch
    - include: fenced-dotenv
    - include: fenced-elixir
    - include: fenced-elm
    - include: fenced-email
    - include: fenced-erlang
    - include: fenced-fish
    - include: fenced-fixedform-fortran
    - include: fenced-fortran-namelist
    - include: fenced-fsharp
    - include: fenced-fstab
    - include: fenced-git-attributes
    - include: fenced-git-commit
    - include: fenced-git-config
    - include: fenced-git-ignore
    - include: fenced-git-log
    - include: fenced-git-mailmap
    - include: fenced-git-rebase
    - include: fenced-glsl
    - include: fenced-gnuplot
    - include: fenced-go
    - include: fenced-graphql
    - include: fenced-graphviz
    - include: fenced-groff
    - include: fenced-groovy
    - include: fenced-group
    - include: fenced-haml
    - include: fenced-haskell
    - include: fenced-hosts
    - include: fenced-html
    - include: fenced-html-asp
    - include: fenced-html-erlang
    - include: fenced-html-jsp
    - include: fenced-html-ruby
    - include: fenced-html-tcl
    - include: fenced-html-twig
    - include: fenced-html-vue
    - include: fenced-http-request-response
    - include: fenced-ini
    - include: fenced-java
    - include: fenced-java-props
    - include: fenced-javascript
    - include: fenced-jinja2
    - include: fenced-jq
    - include: fenced-json
    - include: fenced-jsonnet
    - include: fenced-julia
    - include: fenced-known-hosts
    - include: fenced-kotlin
    - include: fenced-latex
    - include: fenced-lean
    - include: fenced-less
    - include: fenced-lisp
    - include: fenced-livescript
    - include: fenced-llvm
    - include: fenced-log
    - include: fenced-lua
    - include: fenced-makefile
    - include: fenced-manpage
    - include: fenced-markdown
    - include: fenced-matlab
    - include: fenced-mediawiki
    - include: fenced-meminfo
    - include: fenced-modern-fortran
    - include: fenced-multimarkdown
    - include: fenced-nant-build
    - include: fenced-nginx
    - include: fenced-nim
    - include: fenced-ninja
    - include: fenced-nix
    - include: fenced-nsis
    - include: fenced-objc
    - include: fenced-objcpp
    - include: fenced-ocaml
    - include: fenced-ocamllex
    - include: fenced-ocamlyacc
    - include: fenced-orgmode
    - include: fenced-pascal
    - include: fenced-passwd
    - include: fenced-perl
    - include: fenced-php
    - include: fenced-proto
    - include: fenced-prototxt
    - include: fenced-puppet
    - include: fenced-purescript
    - include: fenced-python
    - include: fenced-qml
    - include: fenced-r
    - include: fenced-racket
    - include: fenced-regexp
    - include: fenced-rego
    - include: fenced-requirements-txt
    - include: fenced-resolv
    - include: fenced-restructuredtext
    - include: fenced-robot
    - include: fenced-ruby
    - include: fenced-ruby-rails
    - include: fenced-rust
    - include: fenced-sass
    - include: fenced-scala
    - include: fenced-scss
    - include: fenced-shell-script
    - include: fenced-slim
    - include: fenced-sml
    - include: fenced-solidity
    - include: fenced-sql
    - include: fenced-sql-ruby
    - include: fenced-ssh-config
    - include: fenced-sshd-config
    - include: fenced-strace
    - include: fenced-stylus
    - include: fenced-svelte
    - include: fenced-swift
    - include: fenced-syslog
    - include: fenced-systemverilog
    - include: fenced-tcl
    - include: fenced-terraform
    - include: fenced-tex
    - include: fenced-tex-latex-haskell
    - include: fenced-tex-latex-rd
    - include: fenced-textile
    - include: fenced-toml
    - include: fenced-typescript
    - include: fenced-typescriptreact
    - include: fenced-varlink
    - include: fenced-verilog
    - include: fenced-viml
    - include: fenced-vyper
    - include: fenced-wgsl
    - include: fenced-whitespace
    - include: fenced-xml
    - include: fenced-yaml
    - include: fenced-zig