From a7e155de6dd9829f1455ac0888142a071ec3b249 Mon Sep 17 00:00:00 2001
From: Catalin Constantin Mititiuc <webdevcat@proton.me>
Date: Fri, 20 Jun 2025 15:09:39 -0700
Subject: [PATCH 1/6] Add rough draft

---
 posts/2025-06-20-chroma.md | 183 +++++++++++++++++++++++++++++++++++++
 1 file changed, 183 insertions(+)
 create mode 100644 posts/2025-06-20-chroma.md

diff --git a/posts/2025-06-20-chroma.md b/posts/2025-06-20-chroma.md
new file mode 100644
index 0000000..ea45cb9
--- /dev/null
+++ b/posts/2025-06-20-chroma.md
@@ -0,0 +1,183 @@
+{
+  blurb: "Add a new lexer to chroma"
+}
+
+## Intro
+
+Chroma doesn't have a MoonScript lexer. It does has a Python script that can
+convert Pygments lexers, though, and Pygments has a MoonScript lexer.
+
+## Run MoonScript lexer generation script
+
+To create the lexer, in the Chroma root directory run:
+
+```console
+$ docker run --rm -it -w /opt -v $PWD:/opt python bash -c \
+"pip install pystache pygments \
+&& python _tools/pygments2chroma_xml.py \
+pygments.lexers.scripting.MoonScriptLexer > lexers/embedded/moonscript.xml \
+&& pip list"
+```
+
+## Use the Chroma MoonScript lexer to highlight some code
+
+Create a file like this:
+
+::: filename-for-code-block
+`main.go`
+:::
+
+```go
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/alecthomas/chroma/v2/quick"
+)
+
+func main() {
+    code := `package main
+
+    func main() { }
+    `
+
+    fmt.Println(quick.Highlight(os.Stdout, code, "go", "html", "monokai"))
+}
+```
+
+I did one of these:
+
+```console
+$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
+go mod init main
+```
+
+Which gave me the `go.mod` file.
+
+::: filename-for-code-block
+`go.mod`
+:::
+
+```
+module main
+
+go 1.25
+
+require (
+	github.com/alecthomas/chroma/v2 v2.18.0 // indirect
+	github.com/dlclark/regexp2 v1.11.5 // indirect
+)
+```
+
+Then I did one of these:
+
+```console
+$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
+go run main.go
+```
+
+And that should output markup (and styles) for highlighting that block of Go
+code to the console. But if we notice, it's importing the Chroma package from
+the GitHub repo. We want to use our local version of chroma, so we use `go mod
+edit` to [replace the chroma import with our local version](https://go.dev/ref/mod#go-mod-file-replace):
+
+```console
+$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
+go mod edit -replace github.com/alecthomas/chroma/v2@v2.18.0=./chroma
+```
+
+Which adds this line to our `go.mod` file:
+
+::: filename-for-code-block
+`go.mod`
+:::
+
+```
+...
+
+replace github.com/alecthomas/chroma/v2 v2.18.0 => ./chroma
+```
+
+Now we can put some MoonScript in `main.go`.
+
+```go
+code := `print "Hello, #{@name}!"`
+
+fmt.Println(quick.Highlight(os.Stdout, code, "moonscript", "html", "monokai"))
+```
+
+And we have it:
+
+```console
+$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
+go run main.go
+go: downloading github.com/dlclark/regexp2 v1.11.5
+```
+
+That should output syntax highlighting using our local version of chroma.
+
+## Create testdata
+
+Create a file in `lexers/testdata` called `moonscript.actual`. Add the tokens
+from the language in this file.
+
+## Record test output
+
+Create another file called `lexers/testdata/moonscript.expected`. This is the
+file we will record to.
+
+```console
+$ RECORD=true go test ./lexers
+```
+
+Visually inspect and verify that the expected data is correct.
+
+## Run tests
+
+```console
+$ go test ./lexers
+```
+
+## Bonus!: Use local `pygments` with `pygments2chroma_xml.py`
+
+These lines in `pygments2chroma_xml.py`:
+
+```python
+import pystache
+from pygments import lexer as pygments_lexer
+from pygments.token import _TokenType
+```
+
+Import pygments from pip? How do we get it to load a local version of
+`pygments`?
+
+In Pygments root directory:
+
+```console
+$ docker run --rm -it -w /opt -v $PWD:/opt \
+-v ../gitea-syntax-highlight/chroma/_tools/pygments2chroma_xml.py:/opt/pygments2chroma_xml.py \
+python bash -c "pip install pystache && pip list \
+&& python pygments2chroma_xml.py pygments.lexers.scripting.LuaLexer"
+```
+
+Should see.
+
+```console
+Package  Version
+-------- -------
+pip      25.0.1
+pystache 0.6.8
+```
+
+That shows no remote pygments package is installed. After that you will see the
+lexer markup output.
+
+```console
+<lexer>
+  <config>
+...
+```
+
+If you wanted to save 
-- 
2.39.5


From a7634067019867a0c805172cc06c2bac1f5bcd3e Mon Sep 17 00:00:00 2001
From: Catalin Constantin Mititiuc <webdevcat@proton.me>
Date: Fri, 20 Jun 2025 16:57:53 -0700
Subject: [PATCH 2/6] Add an index to draft post

---
 posts/2025-06-20-chroma.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/posts/2025-06-20-chroma.md b/posts/2025-06-20-chroma.md
index ea45cb9..2da98bc 100644
--- a/posts/2025-06-20-chroma.md
+++ b/posts/2025-06-20-chroma.md
@@ -1,11 +1,13 @@
 {
   blurb: "Add a new lexer to chroma"
 }
+$index
 
 ## Intro
 
-Chroma doesn't have a MoonScript lexer. It does has a Python script that can
-convert Pygments lexers, though, and Pygments has a MoonScript lexer.
+Gitea uses Chroma for syntax highlighting. Chroma doesn't have a MoonScript
+lexer. It does has a Python script that can convert Pygments lexers, though,
+and Pygments has a MoonScript lexer.
 
 ## Run MoonScript lexer generation script
 
@@ -180,4 +182,3 @@ lexer markup output.
 ...
 ```
 
-If you wanted to save 
-- 
2.39.5


From 4274618525b15b2a5aff40ebc7fb527f0eb1b0f9 Mon Sep 17 00:00:00 2001
From: Catalin Constantin Mititiuc <webdevcat@proton.me>
Date: Sat, 21 Jun 2025 13:01:31 -0700
Subject: [PATCH 3/6] Edit post draft

---
 posts/2025-06-20-chroma.md | 218 ++++++++++++++++++++++++-------------
 1 file changed, 145 insertions(+), 73 deletions(-)

diff --git a/posts/2025-06-20-chroma.md b/posts/2025-06-20-chroma.md
index 2da98bc..14f4bb3 100644
--- a/posts/2025-06-20-chroma.md
+++ b/posts/2025-06-20-chroma.md
@@ -1,62 +1,74 @@
 {
-  blurb: "Add a new lexer to chroma"
+  blurb: "Add a new lexer to Chroma"
 }
 $index
 
-## Intro
+## Introduction
 
-Gitea uses Chroma for syntax highlighting. Chroma doesn't have a MoonScript
-lexer. It does has a Python script that can convert Pygments lexers, though,
-and Pygments has a MoonScript lexer.
+[Gitea](https://github.com/go-gitea/gitea) uses [Chroma](https://github.com/alecthomas/chroma) for syntax highlighting. Chroma is based on the Python
+syntax highlighter, [Pygments](https://github.com/pygments/pygments), and includes a [script](https://github.com/alecthomas/chroma/blob/484750a96fc430f49d6b69cc2a2a8b7a67691446/_tools/pygments2chroma_xml.py) to help convert Pygments
+lexers for use with Chroma. This post describes that process.
 
-## Run MoonScript lexer generation script
+## Convert a Pygments lexer to a Chroma lexer with `pygments2chroma_xml.py`
 
-To create the lexer, in the Chroma root directory run:
+In the Chroma root directory, we run:
 
 ```console
 $ docker run --rm -it -w /opt -v $PWD:/opt python bash -c \
-"pip install pystache pygments \
+"pip install pystache pygments && pip list \
 && python _tools/pygments2chroma_xml.py \
-pygments.lexers.scripting.MoonScriptLexer > lexers/embedded/moonscript.xml \
-&& pip list"
+pygments.lexers.scripting.LuaLexer > lexers/embedded/lua.xml"
 ```
 
-## Use the Chroma MoonScript lexer to highlight some code
+As output, we should see this in our terminal:
 
-Create a file like this:
+```
+Package  Version
+-------- -------
+pip      25.0.1
+Pygments 2.19.2
+pystache 0.6.8
+```
+
+This just helps us know what version of Pygments we generated our lexer from.
+The file `lexers/embedded/lua.xml` should now contain all the tokenization
+rules for the [Lua](https://www.lua.org) language.
 
 ::: filename-for-code-block
-`main.go`
+`lexers/embedded/lua.xml`
 :::
 
-```go
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/alecthomas/chroma/v2/quick"
-)
-
-func main() {
-    code := `package main
-
-    func main() { }
-    `
-
-    fmt.Println(quick.Highlight(os.Stdout, code, "go", "html", "monokai"))
-}
+```xml
+<lexer>
+  <config>
+    <name>Lua</name>
+    ...
 ```
 
-I did one of these:
+## Highlight some code with our new lexer
+
+Chroma provides a [simple example test file][1] we can modify to see what syntax
+highlighting with our new lexer looks like. First, though, we need to create a
+new Go module by running `go mod init`:
 
 ```console
 $ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
 go mod init main
+go: creating new go.mod: module main
+go: to add module requirements and sums:
+	go mod tidy
 ```
 
-Which gave me the `go.mod` file.
+We will need required modules, so let's go ahead and run `go mod tidy` as the
+output suggests.
+
+```console
+$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
+go mod tidy
+```
+
+We should now have 2 additional files, `go.mod` and `go.sum`. `go.sum` has some
+package hashes while `go.mod` should look like this:
 
 ::: filename-for-code-block
 `go.mod`
@@ -67,23 +79,55 @@ module main
 
 go 1.25
 
-require (
-	github.com/alecthomas/chroma/v2 v2.18.0 // indirect
-	github.com/dlclark/regexp2 v1.11.5 // indirect
-)
+require github.com/alecthomas/chroma/v2 v2.18.0
+
+require github.com/dlclark/regexp2 v1.11.5 // indirect
 ```
 
-Then I did one of these:
+Now we can create a `main.go` file and copy over the code from Chroma's example
+test file, but we update the `code` variable and the lexer we pass into the
+`Highlight` function for Lua:
+
+
+::: filename-for-code-block
+`main.go`
+:::
+
+```go
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/alecthomas/chroma/v2/quick"
+)
+
+func main() {
+	code := `print("hello")`
+
+	err := quick.Highlight(os.Stdout, code, "lua", "html", "monokai")
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+```
+
+Now we can try running our `main.go` like this:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
-go run main.go
+$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm go run main.go
+go: downloading github.com/alecthomas/chroma/v2 v2.18.0
+go: downloading github.com/dlclark/regexp2 v1.11.5
+<html>
+<style type="text/css">
+...
 ```
 
-And that should output markup (and styles) for highlighting that block of Go
+And that should output markup (and styles) for highlighting that block of Lua
 code to the console. But if we notice, it's importing the Chroma package from
-the GitHub repo. We want to use our local version of chroma, so we use `go mod
-edit` to [replace the chroma import with our local version](https://go.dev/ref/mod#go-mod-file-replace):
+the GitHub repo. If we want to use a local version of Chroma, we have to use a
+[`replace` directive][2] to import Chroma from our local directory:
 
 ```console
 $ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
@@ -102,49 +146,76 @@ Which adds this line to our `go.mod` file:
 replace github.com/alecthomas/chroma/v2 v2.18.0 => ./chroma
 ```
 
-Now we can put some MoonScript in `main.go`.
-
-```go
-code := `print "Hello, #{@name}!"`
-
-fmt.Println(quick.Highlight(os.Stdout, code, "moonscript", "html", "monokai"))
-```
-
-And we have it:
+Now, when we run `main.go`, we should no longer see Chroma being imported,
+because it's using our local copy:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
-go run main.go
+$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm go run main.go
 go: downloading github.com/dlclark/regexp2 v1.11.5
+<html>
+<style type="text/css">
+...
 ```
 
-That should output syntax highlighting using our local version of chroma.
+We should also see a list of styles followed by the HTML markup for
+highlighting our Lua code (formatted for legibility):
 
-## Create testdata
+```html
+<pre class="chroma">
+  <code>
+    <span class="line">
+      <span class="cl">
+        <span class="n">print</span>
+        <span class="p">(</span>
+        <span class="s2">&#34;hello&#34;</span>
+        <span class="p">)</span>
+      </span>
+    </span>
+  </code>
+</pre>
+```
 
-Create a file in `lexers/testdata` called `moonscript.actual`. Add the tokens
-from the language in this file.
+[1]: https://github.com/alecthomas/chroma/blob/484750a96fc430f49d6b69cc2a2a8b7a67691446/quick/example_test.go
+[2]: https://go.dev/ref/mod#go-mod-file-replace 
+
+## Add test data
+
+If we want to add our lexer to Chroma, we will need to create some test data
+for it. We can create a file in `lexers/testdata` called `lua.actual` and
+add the language tokens to it.
 
 ## Record test output
 
-Create another file called `lexers/testdata/moonscript.expected`. This is the
-file we will record to.
+Once we have test data, we need to record the expected output. We create
+another file called `lexers/testdata/lua.expected`. This is the file we
+will record to by running the following command from the Chroma root directory:
 
 ```console
-$ RECORD=true go test ./lexers
+$ docker run --rm -it -w /opt -v $PWD:/opt -e RECORD=true golang:tip-bookworm \
+go test ./lexers
 ```
 
-Visually inspect and verify that the expected data is correct.
+Once test output is recorded in `lexers/testdata/lua.expected`, we should
+visually inspect and verify that the expected data is correct.
 
 ## Run tests
 
+As a final confirmation, we can run the tests to make sure we have not broken
+anything:
+
 ```console
-$ go test ./lexers
+$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
+go test ./lexers
 ```
 
-## Bonus!: Use local `pygments` with `pygments2chroma_xml.py`
+## Conclusion
 
-These lines in `pygments2chroma_xml.py`:
+If we followed all these steps correctly, our lexer should be ready to be
+pushed to a `git` repo and for us to open a pull request!
+
+## Bonus!: Use local Pygments with `pygments2chroma_xml.py`
+
+These lines in `pygments2chroma_xml.py`,
 
 ```python
 import pystache
@@ -152,19 +223,20 @@ from pygments import lexer as pygments_lexer
 from pygments.token import _TokenType
 ```
 
-Import pygments from pip? How do we get it to load a local version of
-`pygments`?
-
-In Pygments root directory:
+import Pygments from the [Python Package Index](https://pypi.org/). But, if we are working on a
+Pygments lexer locally, we might want to convert it to a Chroma lexer for
+testing. We can import a local version of Pygments when running
+`pygments2chroma_xml.py` by running the following from the Pygments root
+directory:
 
 ```console
 $ docker run --rm -it -w /opt -v $PWD:/opt \
--v ../gitea-syntax-highlight/chroma/_tools/pygments2chroma_xml.py:/opt/pygments2chroma_xml.py \
+-v path/to/chroma/_tools/pygments2chroma_xml.py:/opt/pygments2chroma_xml.py \
 python bash -c "pip install pystache && pip list \
 && python pygments2chroma_xml.py pygments.lexers.scripting.LuaLexer"
 ```
 
-Should see.
+We should see
 
 ```console
 Package  Version
@@ -173,8 +245,8 @@ pip      25.0.1
 pystache 0.6.8
 ```
 
-That shows no remote pygments package is installed. After that you will see the
-lexer markup output.
+which indicates no remote Pygments package is installed. Following that, we
+should also see the lexer markup output.
 
 ```console
 <lexer>
-- 
2.39.5


From ecfaf4edaced0d36ed09d3ef3987e3a9ca4ab29a Mon Sep 17 00:00:00 2001
From: Catalin Constantin Mititiuc <webdevcat@proton.me>
Date: Sat, 21 Jun 2025 15:37:57 -0700
Subject: [PATCH 4/6] Update commands; add setup section

---
 posts/2025-06-20-chroma.md | 102 ++++++++++++++++++++++---------------
 1 file changed, 60 insertions(+), 42 deletions(-)

diff --git a/posts/2025-06-20-chroma.md b/posts/2025-06-20-chroma.md
index 14f4bb3..1cd581b 100644
--- a/posts/2025-06-20-chroma.md
+++ b/posts/2025-06-20-chroma.md
@@ -7,20 +7,47 @@ $index
 
 [Gitea](https://github.com/go-gitea/gitea) uses [Chroma](https://github.com/alecthomas/chroma) for syntax highlighting. Chroma is based on the Python
 syntax highlighter, [Pygments](https://github.com/pygments/pygments), and includes a [script](https://github.com/alecthomas/chroma/blob/484750a96fc430f49d6b69cc2a2a8b7a67691446/_tools/pygments2chroma_xml.py) to help convert Pygments
-lexers for use with Chroma. This post describes that process.
+lexers for use with Chroma. We describe how below.
+
+## Setup
+
+We're going to be using the `python` and `golang` [Docker][4] images. Docker
+Desktop is _not_ required.
+
+```console
+$ docker pull python
+$ docker pull golang
+```
+
+Let's set up some aliases to make running the commands easier.
+
+```console
+$ alias docker-run='docker run --rm -it -w /opt -v $PWD:/opt'
+$ alias docker-run-go='docker-run golang'
+$ alias docker-run-py='docker-run python'
+  ```
+
+[3]: https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user
+[4]: https://docs.docker.com/engine/
 
 ## Convert a Pygments lexer to a Chroma lexer with `pygments2chroma_xml.py`
 
+```console
+$ git clone https://github.com/alecthomas/chroma.git
+$ cd chroma
+```
+
 In the Chroma root directory, we run:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt python bash -c \
-"pip install pystache pygments && pip list \
-&& python _tools/pygments2chroma_xml.py \
-pygments.lexers.scripting.LuaLexer > lexers/embedded/lua.xml"
+$ docker-run-py bash -c \
+ "pip install pystache pygments && \
+  python _tools/pygments2chroma_xml.py \
+    pygments.lexers.scripting.LuaLexer > lexers/embedded/lua.xml && \
+  pip list"
 ```
 
-As output, we should see this in our terminal:
+We should see this in the output:
 
 ```
 Package  Version
@@ -45,15 +72,15 @@ rules for the [Lua](https://www.lua.org) language.
     ...
 ```
 
-## Highlight some code with our new lexer
+## Highlight some code with a Chroma lexer
 
 Chroma provides a [simple example test file][1] we can modify to see what syntax
 highlighting with our new lexer looks like. First, though, we need to create a
 new Go module by running `go mod init`:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
-go mod init main
+$ cd ..
+$ docker-run-go go mod init main
 go: creating new go.mod: module main
 go: to add module requirements and sums:
 	go mod tidy
@@ -63,8 +90,7 @@ We will need required modules, so let's go ahead and run `go mod tidy` as the
 output suggests.
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
-go mod tidy
+$ docker-run-go go mod tidy
 ```
 
 We should now have 2 additional files, `go.mod` and `go.sum`. `go.sum` has some
@@ -85,9 +111,8 @@ require github.com/dlclark/regexp2 v1.11.5 // indirect
 ```
 
 Now we can create a `main.go` file and copy over the code from Chroma's example
-test file, but we update the `code` variable and the lexer we pass into the
-`Highlight` function for Lua:
-
+test file, but we update the `code` variable with some Lua, `print("hello")`,
+and the lexer we pass into the `Highlight` function is changed to `"lua"`:
 
 ::: filename-for-code-block
 `main.go`
@@ -116,7 +141,7 @@ func main() {
 Now we can try running our `main.go` like this:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm go run main.go
+$ docker-run-go go run main.go
 go: downloading github.com/alecthomas/chroma/v2 v2.18.0
 go: downloading github.com/dlclark/regexp2 v1.11.5
 <html>
@@ -130,8 +155,8 @@ the GitHub repo. If we want to use a local version of Chroma, we have to use a
 [`replace` directive][2] to import Chroma from our local directory:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
-go mod edit -replace github.com/alecthomas/chroma/v2@v2.18.0=./chroma
+$ docker-run-go go mod edit -replace \
+github.com/alecthomas/chroma/v2@v2.18.0=./chroma
 ```
 
 Which adds this line to our `go.mod` file:
@@ -150,7 +175,7 @@ Now, when we run `main.go`, we should no longer see Chroma being imported,
 because it's using our local copy:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm go run main.go
+$ docker-run-go go run main.go
 go: downloading github.com/dlclark/regexp2 v1.11.5
 <html>
 <style type="text/css">
@@ -191,8 +216,7 @@ another file called `lexers/testdata/lua.expected`. This is the file we
 will record to by running the following command from the Chroma root directory:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt -e RECORD=true golang:tip-bookworm \
-go test ./lexers
+$ docker-run -e RECORD=true golang go test ./lexers
 ```
 
 Once test output is recorded in `lexers/testdata/lua.expected`, we should
@@ -204,8 +228,7 @@ As a final confirmation, we can run the tests to make sure we have not broken
 anything:
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt golang:tip-bookworm \
-go test ./lexers
+$ docker-run-go go test ./lexers
 ```
 
 ## Conclusion
@@ -223,20 +246,23 @@ from pygments import lexer as pygments_lexer
 from pygments.token import _TokenType
 ```
 
-import Pygments from the [Python Package Index](https://pypi.org/). But, if we are working on a
-Pygments lexer locally, we might want to convert it to a Chroma lexer for
-testing. We can import a local version of Pygments when running
-`pygments2chroma_xml.py` by running the following from the Pygments root
-directory:
+import Pygments from the [Python Package Index](https://pypi.org/). But, if we
+want to convert a Pygments lexer from a local `git` repo, we can import it
+by simply running the `pygments2chroma_xml.py` script from the repo root
+directory.
 
 ```console
-$ docker run --rm -it -w /opt -v $PWD:/opt \
--v path/to/chroma/_tools/pygments2chroma_xml.py:/opt/pygments2chroma_xml.py \
-python bash -c "pip install pystache && pip list \
-&& python pygments2chroma_xml.py pygments.lexers.scripting.LuaLexer"
-```
+$ git clone https://github.com/pygments/pygments.git
+$ cd pygments
+$ docker-run \
+-v ../chroma/_tools/pygments2chroma_xml.py:/opt/pygments2chroma_xml.py \
+python bash -c \
+ "pip install pystache && \
+  python pygments2chroma_xml.py pygments.lexers.scripting.LuaLexer && \
+  pip list"
 
-We should see
+```
+We should see the lexer output followed by
 
 ```console
 Package  Version
@@ -245,12 +271,4 @@ pip      25.0.1
 pystache 0.6.8
 ```
 
-which indicates no remote Pygments package is installed. Following that, we
-should also see the lexer markup output.
-
-```console
-<lexer>
-  <config>
-...
-```
-
+which indicates no remote `pygments` package was installed.
-- 
2.39.5


From c9fddb1f4a326a6d7fe35985fa6f8a81e3c4668a Mon Sep 17 00:00:00 2001
From: Catalin Constantin Mititiuc <webdevcat@proton.me>
Date: Sat, 21 Jun 2025 16:16:15 -0700
Subject: [PATCH 5/6] Update blurb and title

---
 ... => 2025-06-20-add-a-pygments-lexer-to-chroma.md} | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)
 rename posts/{2025-06-20-chroma.md => 2025-06-20-add-a-pygments-lexer-to-chroma.md} (93%)

diff --git a/posts/2025-06-20-chroma.md b/posts/2025-06-20-add-a-pygments-lexer-to-chroma.md
similarity index 93%
rename from posts/2025-06-20-chroma.md
rename to posts/2025-06-20-add-a-pygments-lexer-to-chroma.md
index 1cd581b..8072e81 100644
--- a/posts/2025-06-20-chroma.md
+++ b/posts/2025-06-20-add-a-pygments-lexer-to-chroma.md
@@ -1,5 +1,14 @@
 {
-  blurb: "Add a new lexer to Chroma"
+  title: "Add a Pygments Lexer to Chroma"
+  blurb: "[Pygments][4] and [Chroma][5] are syntax highlighting libraries
+  written in [Python][6] and [Go][7], respecitvely. Chroma is missing a
+  language we like, which Pygments already supports. We add support for our
+  language to Chroma by converting the existing lexer from Pygments.
+
+  [4]: https://github.com/pygments/pygments
+  [5]: https://github.com/alecthomas/chroma
+  [6]: https://www.python.org/
+  [7]: https://go.dev/"
 }
 $index
 
@@ -9,6 +18,7 @@ $index
 syntax highlighter, [Pygments](https://github.com/pygments/pygments), and includes a [script](https://github.com/alecthomas/chroma/blob/484750a96fc430f49d6b69cc2a2a8b7a67691446/_tools/pygments2chroma_xml.py) to help convert Pygments
 lexers for use with Chroma. We describe how below.
 
+
 ## Setup
 
 We're going to be using the `python` and `golang` [Docker][4] images. Docker
-- 
2.39.5


From 357462cc195b6498033b7f56bca143edc6563405 Mon Sep 17 00:00:00 2001
From: Catalin Constantin Mititiuc <webdevcat@proton.me>
Date: Sun, 22 Jun 2025 09:49:00 -0700
Subject: [PATCH 6/6] Remove unused link; update html/.gitignore

---
 html/.gitignore                                 |  1 +
 ...2025-06-20-add-a-pygments-lexer-to-chroma.md | 17 ++++++++++-------
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/html/.gitignore b/html/.gitignore
index fc8baad..628bfae 100644
--- a/html/.gitignore
+++ b/html/.gitignore
@@ -2,6 +2,7 @@ app.css
 code.html
 index.html
 pandoc.css
+posts/add-a-pygments-lexer-to-chroma.html
 posts/build-a-neovim-qt-appimage-from-source.html
 posts/build-static-website-generator-part-1.html
 posts/deploy-elixir-generated-html-with-docker-on-digitalocean.html
diff --git a/posts/2025-06-20-add-a-pygments-lexer-to-chroma.md b/posts/2025-06-20-add-a-pygments-lexer-to-chroma.md
index 8072e81..9049063 100644
--- a/posts/2025-06-20-add-a-pygments-lexer-to-chroma.md
+++ b/posts/2025-06-20-add-a-pygments-lexer-to-chroma.md
@@ -14,14 +14,18 @@ $index
 
 ## Introduction
 
-[Gitea](https://github.com/go-gitea/gitea) uses [Chroma](https://github.com/alecthomas/chroma) for syntax highlighting. Chroma is based on the Python
-syntax highlighter, [Pygments](https://github.com/pygments/pygments), and includes a [script](https://github.com/alecthomas/chroma/blob/484750a96fc430f49d6b69cc2a2a8b7a67691446/_tools/pygments2chroma_xml.py) to help convert Pygments
-lexers for use with Chroma. We describe how below.
+[Gitea][8] uses [Chroma][9] for syntax highlighting. Chroma is based on the
+Python syntax highlighter, [Pygments][10], and includes a [script][11] to help
+convert Pygments lexers for use with Chroma. We describe how below.
 
+[8]: https://github.com/go-gitea/gitea
+[9]: https://github.com/alecthomas/chroma
+[10]: https://github.com/pygments/pygments
+[11]: https://github.com/alecthomas/chroma/blob/484750a96fc430f49d6b69cc2a2a8b7a67691446/_tools/pygments2chroma_xml.py
 
 ## Setup
 
-We're going to be using the `python` and `golang` [Docker][4] images. Docker
+We're going to be using the `python` and `golang` [Docker][3] images. Docker
 Desktop is _not_ required.
 
 ```console
@@ -35,10 +39,9 @@ Let's set up some aliases to make running the commands easier.
 $ alias docker-run='docker run --rm -it -w /opt -v $PWD:/opt'
 $ alias docker-run-go='docker-run golang'
 $ alias docker-run-py='docker-run python'
-  ```
+```
 
-[3]: https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user
-[4]: https://docs.docker.com/engine/
+[3]: https://docs.docker.com/engine/
 
 ## Convert a Pygments lexer to a Chroma lexer with `pygments2chroma_xml.py`
 
-- 
2.39.5