diff --git a/README.md b/README.md
index 154d4c7..74eb528 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,13 @@
# mdZines
-where you make zines online
\ No newline at end of file
+where you make zines online
+
+- a bit like https://rust-lang.github.io/mdBook/
+- but more as a CMS where you can also edit your markdown and CSS online
+- might do server side PDF making too.
+
+## trying out Go for a webinterface project
+- https://gin-gonic.com/docs/quickstart/
+- https://gin-gonic.com/docs/examples/html-rendering/
+- https://github.com/chromedp/chromedp
+- https://github.com/go-rod/rod
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..2fb246a
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,38 @@
+module mdzines.go
+
+go 1.21.4
+
+require (
+ github.com/alecthomas/chroma v0.10.0
+ github.com/gomarkdown/markdown v0.0.0-20231115200524-a660076da3fd
+)
+
+require (
+ github.com/bytedance/sonic v1.10.2 // indirect
+ github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
+ github.com/chenzhuoyu/iasm v0.9.1 // indirect
+ github.com/dlclark/regexp2 v1.4.0 // indirect
+ github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+ github.com/gin-contrib/sse v0.1.0 // indirect
+ github.com/gin-gonic/gin v1.9.1 // indirect
+ github.com/go-playground/locales v0.14.1 // indirect
+ github.com/go-playground/universal-translator v0.18.1 // indirect
+ github.com/go-playground/validator/v10 v10.16.0 // indirect
+ github.com/goccy/go-json v0.10.2 // indirect
+ github.com/json-iterator/go v1.1.12 // indirect
+ github.com/klauspost/cpuid/v2 v2.2.6 // indirect
+ github.com/leodido/go-urn v1.2.4 // indirect
+ github.com/mattn/go-isatty v0.0.20 // indirect
+ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+ github.com/modern-go/reflect2 v1.0.2 // indirect
+ github.com/pelletier/go-toml/v2 v2.1.0 // indirect
+ github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+ github.com/ugorji/go/codec v1.2.11 // indirect
+ golang.org/x/arch v0.6.0 // indirect
+ golang.org/x/crypto v0.16.0 // indirect
+ golang.org/x/net v0.19.0 // indirect
+ golang.org/x/sys v0.15.0 // indirect
+ golang.org/x/text v0.14.0 // indirect
+ google.golang.org/protobuf v1.31.0 // indirect
+ gopkg.in/yaml.v3 v3.0.1 // indirect
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..364a8fd
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,95 @@
+github.com/alecthomas/chroma v0.10.0 h1:7XDcGkCQopCNKjZHfYrNLraA+M7e0fMiJ/Mfikbfjek=
+github.com/alecthomas/chroma v0.10.0/go.mod h1:jtJATyUxlIORhUOFNA9NZDWGAQ8wpxQQqNSB4rjA/1s=
+github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.10.0-rc/go.mod h1:ElCzW+ufi8qKqNW0FY314xriJhyJhuoJ3gFZdAHF7NM=
+github.com/bytedance/sonic v1.10.2 h1:GQebETVBxYB7JGWJtLBi07OVzWwt+8dWA00gEVW2ZFE=
+github.com/bytedance/sonic v1.10.2/go.mod h1:iZcSUejdk5aukTND/Eu/ivjQuEL0Cu9/rf50Hi0u/g4=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d h1:77cEq6EriyTZ0g/qfRdp61a3Uu/AWrgIq2s0ClJV1g0=
+github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d/go.mod h1:8EPpVsBuRksnlj1mLy4AWzRNQYxauNi62uWcE3to6eA=
+github.com/chenzhuoyu/iasm v0.9.0/go.mod h1:Xjy2NpN3h7aUqeqM+woSuuvxmIe6+DDsiNLIrkAmYog=
+github.com/chenzhuoyu/iasm v0.9.1 h1:tUHQJXo3NhBqw6s33wkGn9SP3bvrWLdlVIJ3hQBL7P0=
+github.com/chenzhuoyu/iasm v0.9.1/go.mod h1:Xjy2NpN3h7aUqeqM+woSuuvxmIe6+DDsiNLIrkAmYog=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dlclark/regexp2 v1.4.0 h1:F1rxgk7p4uKjwIQxBs9oAXe5CqrXlCduYEJvrF4u93E=
+github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
+github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
+github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.16.0 h1:x+plE831WK4vaKHO/jpgUGsvLKIqRRkz6M78GuJAfGE=
+github.com/go-playground/validator/v10 v10.16.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/gomarkdown/markdown v0.0.0-20231115200524-a660076da3fd h1:PppHBegd3uPZ3Y/Iax/2mlCFJm1w4Qf/zP1MdW4ju2o=
+github.com/gomarkdown/markdown v0.0.0-20231115200524-a660076da3fd/go.mod h1:JDGcbDT52eL4fju3sZ4TeHGsQwhG9nbDV21aMyhwPoA=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc=
+github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4=
+github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.6.0 h1:S0JTfE48HbRj80+4tbvZDYsJ3tGv6BUU3XxyZ7CirAc=
+golang.org/x/arch v0.6.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.16.0 h1:mMMrFzRSCF0GvB7Ne27XVtVAaXLrPmgPC7/v0tkwHaY=
+golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c=
+golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
diff --git a/main.go b/main.go
new file mode 100644
index 0000000..b0b6f2f
--- /dev/null
+++ b/main.go
@@ -0,0 +1,19 @@
+package main
+
+import (
+ "net/http"
+
+ "github.com/gin-gonic/gin"
+)
+
+func main() {
+ router := gin.Default()
+ router.LoadHTMLGlob("templates/*")
+ router.StaticFS("/static", http.Dir("./files"))
+ router.GET("/index", func(c *gin.Context) {
+ c.HTML(http.StatusOK, "index.tmpl", gin.H{
+ "title": "CRUNK",
+ })
+ })
+ router.Run(":5000") // listen and serve on localhost:5000
+}
diff --git a/mdzines.go b/mdzines.go
new file mode 100644
index 0000000..89ed996
--- /dev/null
+++ b/mdzines.go
@@ -0,0 +1,92 @@
+package main
+
+// example for https://blog.kowalczyk.info/article/cxn3/advanced-markdown-processing-in-go.html
+import (
+ "fmt"
+ "io"
+
+ "github.com/gomarkdown/markdown"
+ "github.com/gomarkdown/markdown/ast"
+ mdhtml "github.com/gomarkdown/markdown/html"
+
+ "github.com/alecthomas/chroma"
+ "github.com/alecthomas/chroma/formatters/html"
+ "github.com/alecthomas/chroma/lexers"
+ "github.com/alecthomas/chroma/styles"
+)
+
+var (
+ htmlFormatter *html.Formatter
+ highlightStyle *chroma.Style
+)
+
+func init() {
+ htmlFormatter = html.New(html.WithClasses(true), html.TabWidth(2))
+ if htmlFormatter == nil {
+ panic("couldn't create html formatter")
+ }
+ styleName := "monokailight"
+ highlightStyle = styles.Get(styleName)
+ if highlightStyle == nil {
+ panic(fmt.Sprintf("didn't find style '%s'", styleName))
+ }
+}
+
+// based on https://github.com/alecthomas/chroma/blob/master/quick/quick.go
+func htmlHighlight(w io.Writer, source, lang, defaultLang string) error {
+ if lang == "" {
+ lang = defaultLang
+ }
+ l := lexers.Get(lang)
+ if l == nil {
+ l = lexers.Analyse(source)
+ }
+ if l == nil {
+ l = lexers.Fallback
+ }
+ l = chroma.Coalesce(l)
+
+ it, err := l.Tokenise(nil, source)
+ if err != nil {
+ return err
+ }
+ return htmlFormatter.Format(w, highlightStyle, it)
+}
+
+// an actual rendering of Paragraph is more complicated
+func renderCode(w io.Writer, codeBlock *ast.CodeBlock, entering bool) {
+ defaultLang := ""
+ lang := string(codeBlock.Info)
+ htmlHighlight(w, string(codeBlock.Literal), lang, defaultLang)
+}
+
+func myRenderHook(w io.Writer, node ast.Node, entering bool) (ast.WalkStatus, bool) {
+ if code, ok := node.(*ast.CodeBlock); ok {
+ renderCode(w, code, entering)
+ return ast.GoToNext, true
+ }
+ return ast.GoToNext, false
+}
+
+func newCustomizedRender() *mdhtml.Renderer {
+ opts := mdhtml.RendererOptions{
+ Flags: mdhtml.CommonFlags,
+ RenderNodeHook: myRenderHook,
+ }
+ return mdhtml.NewRenderer(opts)
+}
+
+var mds = "code block:\n```go\nvar n = 384\n```"
+
+func codeHighlight() {
+ md := []byte(mds)
+
+ renderer := newCustomizedRender()
+ html := markdown.ToHTML(md, nil, renderer)
+
+ fmt.Printf("--- Markdown:\n%s\n\n--- HTML:\n%s\n", md, html)
+}
+
+func main() {
+ codeHighlight()
+}
diff --git a/templates/hljs/DIGESTS.md b/templates/hljs/DIGESTS.md
new file mode 100644
index 0000000..3a1c406
--- /dev/null
+++ b/templates/hljs/DIGESTS.md
@@ -0,0 +1,29 @@
+## Subresource Integrity
+
+If you are loading Highlight.js via CDN you may wish to use [Subresource Integrity](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity) to guarantee that you are using a legimitate build of the library.
+
+To do this you simply need to add the `integrity` attribute for each JavaScript file you download via CDN. These digests are used by the browser to confirm the files downloaded have not been modified.
+
+```html
+
+
+
+```
+
+The full list of digests for every file can be found below.
+
+### Digests
+
+```
+sha384-bWwkdmOCj83zZ8/m+oPD9goRMhrPCb25ZA6aTyg7vcsq9IpuyED38kQSw1Na4UTZ /es/languages/markdown.js
+sha384-SqGSUq0DMQ0OUQnQnTuVDCJyhANd/MFNj+0PF67S+VXgHpR8A4tPsf/3GoSFRmrx /es/languages/markdown.min.js
+sha384-U+zIQPoVdPCO0o4poik2hYNbHtNm+L5OojDTulgIeEZTNz+LooLAm72d66mNjwKD /languages/markdown.js
+sha384-mCUujHHbWJEjcupTTfWOk9YR3YCYNHaA578+TTXUd4LPi7fGNuMQbysbl1pmcIGd /languages/markdown.min.js
+sha384-T3iuPyfWZPoYqIwEboJ5mGxyhhRxCQ99OlkULesV7CKerMVXEgDyOzWrQmJREI0r /highlight.js
+sha384-mgfo9RLqcM7eT8VO/iNHqxvxaYUdFMrThn508chNhk8vGeQL4wWOeALavxswYdCz /highlight.min.js
+```
+
diff --git a/templates/hljs/LICENSE b/templates/hljs/LICENSE
new file mode 100644
index 0000000..2250cc7
--- /dev/null
+++ b/templates/hljs/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2006, Ivan Sagalaev.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/templates/hljs/README.md b/templates/hljs/README.md
new file mode 100644
index 0000000..30d84b9
--- /dev/null
+++ b/templates/hljs/README.md
@@ -0,0 +1,45 @@
+# Highlight.js CDN Assets
+
+[![install size](https://packagephobia.now.sh/badge?p=highlight.js)](https://packagephobia.now.sh/result?p=highlight.js)
+
+**This package contains only the CDN build assets of highlight.js.**
+
+This may be what you want if you'd like to install the pre-built distributable highlight.js client-side assets via NPM. If you're wanting to use highlight.js mainly on the server-side you likely want the [highlight.js][1] package instead.
+
+To access these files via CDN:
+https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@latest/build/
+
+**If you just want a single .js file with the common languages built-in:
+**
+
+---
+
+## Highlight.js
+
+Highlight.js is a syntax highlighter written in JavaScript. It works in
+the browser as well as on the server. It works with pretty much any
+markup, doesn’t depend on any framework, and has automatic language
+detection.
+
+If you'd like to read the full README:
+
+
+## License
+
+Highlight.js is released under the BSD License. See [LICENSE][7] file
+for details.
+
+## Links
+
+The official site for the library is at .
+
+The Github project may be found at:
+
+Further in-depth documentation for the API and other topics is at
+.
+
+A list of the Core Team and contributors can be found in the [CONTRIBUTORS.md][8] file.
+
+[1]: https://www.npmjs.com/package/highlight.js
+[7]: https://github.com/highlightjs/highlight.js/blob/main/LICENSE
+[8]: https://github.com/highlightjs/highlight.js/blob/main/CONTRIBUTORS.md
diff --git a/templates/hljs/es/core.js b/templates/hljs/es/core.js
new file mode 100644
index 0000000..7294b81
--- /dev/null
+++ b/templates/hljs/es/core.js
@@ -0,0 +1,2600 @@
+/*!
+ Highlight.js v11.9.0 (git: b7ec4bfafc)
+ (c) 2006-2023 undefined and other contributors
+ License: BSD-3-Clause
+ */
+/* eslint-disable no-multi-assign */
+
+function deepFreeze(obj) {
+ if (obj instanceof Map) {
+ obj.clear =
+ obj.delete =
+ obj.set =
+ function () {
+ throw new Error('map is read-only');
+ };
+ } else if (obj instanceof Set) {
+ obj.add =
+ obj.clear =
+ obj.delete =
+ function () {
+ throw new Error('set is read-only');
+ };
+ }
+
+ // Freeze self
+ Object.freeze(obj);
+
+ Object.getOwnPropertyNames(obj).forEach((name) => {
+ const prop = obj[name];
+ const type = typeof prop;
+
+ // Freeze prop if it is an object or function and also not already frozen
+ if ((type === 'object' || type === 'function') && !Object.isFrozen(prop)) {
+ deepFreeze(prop);
+ }
+ });
+
+ return obj;
+}
+
+/** @typedef {import('highlight.js').CallbackResponse} CallbackResponse */
+/** @typedef {import('highlight.js').CompiledMode} CompiledMode */
+/** @implements CallbackResponse */
+
+class Response {
+ /**
+ * @param {CompiledMode} mode
+ */
+ constructor(mode) {
+ // eslint-disable-next-line no-undefined
+ if (mode.data === undefined) mode.data = {};
+
+ this.data = mode.data;
+ this.isMatchIgnored = false;
+ }
+
+ ignoreMatch() {
+ this.isMatchIgnored = true;
+ }
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeHTML(value) {
+ return value
+ .replace(/&/g, '&')
+ .replace(//g, '>')
+ .replace(/"/g, '"')
+ .replace(/'/g, ''');
+}
+
+/**
+ * performs a shallow merge of multiple objects into one
+ *
+ * @template T
+ * @param {T} original
+ * @param {Record[]} objects
+ * @returns {T} a single new object
+ */
+function inherit$1(original, ...objects) {
+ /** @type Record */
+ const result = Object.create(null);
+
+ for (const key in original) {
+ result[key] = original[key];
+ }
+ objects.forEach(function(obj) {
+ for (const key in obj) {
+ result[key] = obj[key];
+ }
+ });
+ return /** @type {T} */ (result);
+}
+
+/**
+ * @typedef {object} Renderer
+ * @property {(text: string) => void} addText
+ * @property {(node: Node) => void} openNode
+ * @property {(node: Node) => void} closeNode
+ * @property {() => string} value
+ */
+
+/** @typedef {{scope?: string, language?: string, sublanguage?: boolean}} Node */
+/** @typedef {{walk: (r: Renderer) => void}} Tree */
+/** */
+
+const SPAN_CLOSE = '';
+
+/**
+ * Determines if a node needs to be wrapped in
+ *
+ * @param {Node} node */
+const emitsWrappingTags = (node) => {
+ // rarely we can have a sublanguage where language is undefined
+ // TODO: track down why
+ return !!node.scope;
+};
+
+/**
+ *
+ * @param {string} name
+ * @param {{prefix:string}} options
+ */
+const scopeToCSSClass = (name, { prefix }) => {
+ // sub-language
+ if (name.startsWith("language:")) {
+ return name.replace("language:", "language-");
+ }
+ // tiered scope: comment.line
+ if (name.includes(".")) {
+ const pieces = name.split(".");
+ return [
+ `${prefix}${pieces.shift()}`,
+ ...(pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`))
+ ].join(" ");
+ }
+ // simple scope
+ return `${prefix}${name}`;
+};
+
+/** @type {Renderer} */
+class HTMLRenderer {
+ /**
+ * Creates a new HTMLRenderer
+ *
+ * @param {Tree} parseTree - the parse tree (must support `walk` API)
+ * @param {{classPrefix: string}} options
+ */
+ constructor(parseTree, options) {
+ this.buffer = "";
+ this.classPrefix = options.classPrefix;
+ parseTree.walk(this);
+ }
+
+ /**
+ * Adds texts to the output stream
+ *
+ * @param {string} text */
+ addText(text) {
+ this.buffer += escapeHTML(text);
+ }
+
+ /**
+ * Adds a node open to the output stream (if needed)
+ *
+ * @param {Node} node */
+ openNode(node) {
+ if (!emitsWrappingTags(node)) return;
+
+ const className = scopeToCSSClass(node.scope,
+ { prefix: this.classPrefix });
+ this.span(className);
+ }
+
+ /**
+ * Adds a node close to the output stream (if needed)
+ *
+ * @param {Node} node */
+ closeNode(node) {
+ if (!emitsWrappingTags(node)) return;
+
+ this.buffer += SPAN_CLOSE;
+ }
+
+ /**
+ * returns the accumulated buffer
+ */
+ value() {
+ return this.buffer;
+ }
+
+ // helpers
+
+ /**
+ * Builds a span element
+ *
+ * @param {string} className */
+ span(className) {
+ this.buffer += ``;
+ }
+}
+
+/** @typedef {{scope?: string, language?: string, children: Node[]} | string} Node */
+/** @typedef {{scope?: string, language?: string, children: Node[]} } DataNode */
+/** @typedef {import('highlight.js').Emitter} Emitter */
+/** */
+
+/** @returns {DataNode} */
+const newNode = (opts = {}) => {
+ /** @type DataNode */
+ const result = { children: [] };
+ Object.assign(result, opts);
+ return result;
+};
+
+class TokenTree {
+ constructor() {
+ /** @type DataNode */
+ this.rootNode = newNode();
+ this.stack = [this.rootNode];
+ }
+
+ get top() {
+ return this.stack[this.stack.length - 1];
+ }
+
+ get root() { return this.rootNode; }
+
+ /** @param {Node} node */
+ add(node) {
+ this.top.children.push(node);
+ }
+
+ /** @param {string} scope */
+ openNode(scope) {
+ /** @type Node */
+ const node = newNode({ scope });
+ this.add(node);
+ this.stack.push(node);
+ }
+
+ closeNode() {
+ if (this.stack.length > 1) {
+ return this.stack.pop();
+ }
+ // eslint-disable-next-line no-undefined
+ return undefined;
+ }
+
+ closeAllNodes() {
+ while (this.closeNode());
+ }
+
+ toJSON() {
+ return JSON.stringify(this.rootNode, null, 4);
+ }
+
+ /**
+ * @typedef { import("./html_renderer").Renderer } Renderer
+ * @param {Renderer} builder
+ */
+ walk(builder) {
+ // this does not
+ return this.constructor._walk(builder, this.rootNode);
+ // this works
+ // return TokenTree._walk(builder, this.rootNode);
+ }
+
+ /**
+ * @param {Renderer} builder
+ * @param {Node} node
+ */
+ static _walk(builder, node) {
+ if (typeof node === "string") {
+ builder.addText(node);
+ } else if (node.children) {
+ builder.openNode(node);
+ node.children.forEach((child) => this._walk(builder, child));
+ builder.closeNode(node);
+ }
+ return builder;
+ }
+
+ /**
+ * @param {Node} node
+ */
+ static _collapse(node) {
+ if (typeof node === "string") return;
+ if (!node.children) return;
+
+ if (node.children.every(el => typeof el === "string")) {
+ // node.text = node.children.join("");
+ // delete node.children;
+ node.children = [node.children.join("")];
+ } else {
+ node.children.forEach((child) => {
+ TokenTree._collapse(child);
+ });
+ }
+ }
+}
+
+/**
+ Currently this is all private API, but this is the minimal API necessary
+ that an Emitter must implement to fully support the parser.
+
+ Minimal interface:
+
+ - addText(text)
+ - __addSublanguage(emitter, subLanguageName)
+ - startScope(scope)
+ - endScope()
+ - finalize()
+ - toHTML()
+
+*/
+
+/**
+ * @implements {Emitter}
+ */
+class TokenTreeEmitter extends TokenTree {
+ /**
+ * @param {*} options
+ */
+ constructor(options) {
+ super();
+ this.options = options;
+ }
+
+ /**
+ * @param {string} text
+ */
+ addText(text) {
+ if (text === "") { return; }
+
+ this.add(text);
+ }
+
+ /** @param {string} scope */
+ startScope(scope) {
+ this.openNode(scope);
+ }
+
+ endScope() {
+ this.closeNode();
+ }
+
+ /**
+ * @param {Emitter & {root: DataNode}} emitter
+ * @param {string} name
+ */
+ __addSublanguage(emitter, name) {
+ /** @type DataNode */
+ const node = emitter.root;
+ if (name) node.scope = `language:${name}`;
+
+ this.add(node);
+ }
+
+ toHTML() {
+ const renderer = new HTMLRenderer(this, this.options);
+ return renderer.value();
+ }
+
+ finalize() {
+ this.closeAllNodes();
+ return true;
+ }
+}
+
+/**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function source(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function lookahead(re) {
+ return concat('(?=', re, ')');
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function anyNumberOfTimes(re) {
+ return concat('(?:', re, ')*');
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function optional(re) {
+ return concat('(?:', re, ')?');
+}
+
+/**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+function concat(...args) {
+ const joined = args.map((x) => source(x)).join("");
+ return joined;
+}
+
+/**
+ * @param { Array } args
+ * @returns {object}
+ */
+function stripOptionsFromArgs(args) {
+ const opts = args[args.length - 1];
+
+ if (typeof opts === 'object' && opts.constructor === Object) {
+ args.splice(args.length - 1, 1);
+ return opts;
+ } else {
+ return {};
+ }
+}
+
+/** @typedef { {capture?: boolean} } RegexEitherOptions */
+
+/**
+ * Any of the passed expresssions may match
+ *
+ * Creates a huge this | this | that | that match
+ * @param {(RegExp | string)[] | [...(RegExp | string)[], RegexEitherOptions]} args
+ * @returns {string}
+ */
+function either(...args) {
+ /** @type { object & {capture?: boolean} } */
+ const opts = stripOptionsFromArgs(args);
+ const joined = '('
+ + (opts.capture ? "" : "?:")
+ + args.map((x) => source(x)).join("|") + ")";
+ return joined;
+}
+
+/**
+ * @param {RegExp | string} re
+ * @returns {number}
+ */
+function countMatchGroups(re) {
+ return (new RegExp(re.toString() + '|')).exec('').length - 1;
+}
+
+/**
+ * Does lexeme start with a regular expression match at the beginning
+ * @param {RegExp} re
+ * @param {string} lexeme
+ */
+function startsWith(re, lexeme) {
+ const match = re && re.exec(lexeme);
+ return match && match.index === 0;
+}
+
+// BACKREF_RE matches an open parenthesis or backreference. To avoid
+// an incorrect parse, it additionally matches the following:
+// - [...] elements, where the meaning of parentheses and escapes change
+// - other escape sequences, so we do not misparse escape sequences as
+// interesting elements
+// - non-matching or lookahead parentheses, which do not capture. These
+// follow the '(' with a '?'.
+const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+
+// **INTERNAL** Not intended for outside usage
+// join logically computes regexps.join(separator), but fixes the
+// backreferences so they continue to match.
+// it also places each individual regular expression into it's own
+// match group, keeping track of the sequencing of those match groups
+// is currently an exercise for the caller. :-)
+/**
+ * @param {(string | RegExp)[]} regexps
+ * @param {{joinWith: string}} opts
+ * @returns {string}
+ */
+function _rewriteBackreferences(regexps, { joinWith }) {
+ let numCaptures = 0;
+
+ return regexps.map((regex) => {
+ numCaptures += 1;
+ const offset = numCaptures;
+ let re = source(regex);
+ let out = '';
+
+ while (re.length > 0) {
+ const match = BACKREF_RE.exec(re);
+ if (!match) {
+ out += re;
+ break;
+ }
+ out += re.substring(0, match.index);
+ re = re.substring(match.index + match[0].length);
+ if (match[0][0] === '\\' && match[1]) {
+ // Adjust the backreference.
+ out += '\\' + String(Number(match[1]) + offset);
+ } else {
+ out += match[0];
+ if (match[0] === '(') {
+ numCaptures++;
+ }
+ }
+ }
+ return out;
+ }).map(re => `(${re})`).join(joinWith);
+}
+
+/** @typedef {import('highlight.js').Mode} Mode */
+/** @typedef {import('highlight.js').ModeCallback} ModeCallback */
+
+// Common regexps
+const MATCH_NOTHING_RE = /\b\B/;
+const IDENT_RE = '[a-zA-Z]\\w*';
+const UNDERSCORE_IDENT_RE = '[a-zA-Z_]\\w*';
+const NUMBER_RE = '\\b\\d+(\\.\\d+)?';
+const C_NUMBER_RE = '(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
+const BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
+const RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';
+
+/**
+* @param { Partial & {binary?: string | RegExp} } opts
+*/
+const SHEBANG = (opts = {}) => {
+ const beginShebang = /^#![ ]*\//;
+ if (opts.binary) {
+ opts.begin = concat(
+ beginShebang,
+ /.*\b/,
+ opts.binary,
+ /\b.*/);
+ }
+ return inherit$1({
+ scope: 'meta',
+ begin: beginShebang,
+ end: /$/,
+ relevance: 0,
+ /** @type {ModeCallback} */
+ "on:begin": (m, resp) => {
+ if (m.index !== 0) resp.ignoreMatch();
+ }
+ }, opts);
+};
+
+// Common modes
+const BACKSLASH_ESCAPE = {
+ begin: '\\\\[\\s\\S]', relevance: 0
+};
+const APOS_STRING_MODE = {
+ scope: 'string',
+ begin: '\'',
+ end: '\'',
+ illegal: '\\n',
+ contains: [BACKSLASH_ESCAPE]
+};
+const QUOTE_STRING_MODE = {
+ scope: 'string',
+ begin: '"',
+ end: '"',
+ illegal: '\\n',
+ contains: [BACKSLASH_ESCAPE]
+};
+const PHRASAL_WORDS_MODE = {
+ begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+};
+/**
+ * Creates a comment mode
+ *
+ * @param {string | RegExp} begin
+ * @param {string | RegExp} end
+ * @param {Mode | {}} [modeOptions]
+ * @returns {Partial}
+ */
+const COMMENT = function(begin, end, modeOptions = {}) {
+ const mode = inherit$1(
+ {
+ scope: 'comment',
+ begin,
+ end,
+ contains: []
+ },
+ modeOptions
+ );
+ mode.contains.push({
+ scope: 'doctag',
+ // hack to avoid the space from being included. the space is necessary to
+ // match here to prevent the plain text rule below from gobbling up doctags
+ begin: '[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)',
+ end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+ excludeBegin: true,
+ relevance: 0
+ });
+ const ENGLISH_WORD = either(
+ // list of common 1 and 2 letter words in English
+ "I",
+ "a",
+ "is",
+ "so",
+ "us",
+ "to",
+ "at",
+ "if",
+ "in",
+ "it",
+ "on",
+ // note: this is not an exhaustive list of contractions, just popular ones
+ /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, // contractions - can't we'd they're let's, etc
+ /[A-Za-z]+[-][a-z]+/, // `no-way`, etc.
+ /[A-Za-z][a-z]{2,}/ // allow capitalized words at beginning of sentences
+ );
+ // looking like plain text, more likely to be a comment
+ mode.contains.push(
+ {
+ // TODO: how to include ", (, ) without breaking grammars that use these for
+ // comment delimiters?
+ // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
+ // ---
+
+ // this tries to find sequences of 3 english words in a row (without any
+ // "programming" type syntax) this gives us a strong signal that we've
+ // TRULY found a comment - vs perhaps scanning with the wrong language.
+ // It's possible to find something that LOOKS like the start of the
+ // comment - but then if there is no readable text - good chance it is a
+ // false match and not a comment.
+ //
+ // for a visual example please see:
+ // https://github.com/highlightjs/highlight.js/issues/2827
+
+ begin: concat(
+ /[ ]+/, // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+ '(',
+ ENGLISH_WORD,
+ /[.]?[:]?([.][ ]|[ ])/,
+ '){3}') // look for 3 words in a row
+ }
+ );
+ return mode;
+};
+const C_LINE_COMMENT_MODE = COMMENT('//', '$');
+const C_BLOCK_COMMENT_MODE = COMMENT('/\\*', '\\*/');
+const HASH_COMMENT_MODE = COMMENT('#', '$');
+const NUMBER_MODE = {
+ scope: 'number',
+ begin: NUMBER_RE,
+ relevance: 0
+};
+const C_NUMBER_MODE = {
+ scope: 'number',
+ begin: C_NUMBER_RE,
+ relevance: 0
+};
+const BINARY_NUMBER_MODE = {
+ scope: 'number',
+ begin: BINARY_NUMBER_RE,
+ relevance: 0
+};
+const REGEXP_MODE = {
+ scope: "regexp",
+ begin: /\/(?=[^/\n]*\/)/,
+ end: /\/[gimuy]*/,
+ contains: [
+ BACKSLASH_ESCAPE,
+ {
+ begin: /\[/,
+ end: /\]/,
+ relevance: 0,
+ contains: [BACKSLASH_ESCAPE]
+ }
+ ]
+};
+const TITLE_MODE = {
+ scope: 'title',
+ begin: IDENT_RE,
+ relevance: 0
+};
+const UNDERSCORE_TITLE_MODE = {
+ scope: 'title',
+ begin: UNDERSCORE_IDENT_RE,
+ relevance: 0
+};
+const METHOD_GUARD = {
+ // excludes method names from keyword processing
+ begin: '\\.\\s*' + UNDERSCORE_IDENT_RE,
+ relevance: 0
+};
+
+/**
+ * Adds end same as begin mechanics to a mode
+ *
+ * Your mode must include at least a single () match group as that first match
+ * group is what is used for comparison
+ * @param {Partial} mode
+ */
+const END_SAME_AS_BEGIN = function(mode) {
+ return Object.assign(mode,
+ {
+ /** @type {ModeCallback} */
+ 'on:begin': (m, resp) => { resp.data._beginMatch = m[1]; },
+ /** @type {ModeCallback} */
+ 'on:end': (m, resp) => { if (resp.data._beginMatch !== m[1]) resp.ignoreMatch(); }
+ });
+};
+
+var MODES = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ APOS_STRING_MODE: APOS_STRING_MODE,
+ BACKSLASH_ESCAPE: BACKSLASH_ESCAPE,
+ BINARY_NUMBER_MODE: BINARY_NUMBER_MODE,
+ BINARY_NUMBER_RE: BINARY_NUMBER_RE,
+ COMMENT: COMMENT,
+ C_BLOCK_COMMENT_MODE: C_BLOCK_COMMENT_MODE,
+ C_LINE_COMMENT_MODE: C_LINE_COMMENT_MODE,
+ C_NUMBER_MODE: C_NUMBER_MODE,
+ C_NUMBER_RE: C_NUMBER_RE,
+ END_SAME_AS_BEGIN: END_SAME_AS_BEGIN,
+ HASH_COMMENT_MODE: HASH_COMMENT_MODE,
+ IDENT_RE: IDENT_RE,
+ MATCH_NOTHING_RE: MATCH_NOTHING_RE,
+ METHOD_GUARD: METHOD_GUARD,
+ NUMBER_MODE: NUMBER_MODE,
+ NUMBER_RE: NUMBER_RE,
+ PHRASAL_WORDS_MODE: PHRASAL_WORDS_MODE,
+ QUOTE_STRING_MODE: QUOTE_STRING_MODE,
+ REGEXP_MODE: REGEXP_MODE,
+ RE_STARTERS_RE: RE_STARTERS_RE,
+ SHEBANG: SHEBANG,
+ TITLE_MODE: TITLE_MODE,
+ UNDERSCORE_IDENT_RE: UNDERSCORE_IDENT_RE,
+ UNDERSCORE_TITLE_MODE: UNDERSCORE_TITLE_MODE
+});
+
+/**
+@typedef {import('highlight.js').CallbackResponse} CallbackResponse
+@typedef {import('highlight.js').CompilerExt} CompilerExt
+*/
+
+// Grammar extensions / plugins
+// See: https://github.com/highlightjs/highlight.js/issues/2833
+
+// Grammar extensions allow "syntactic sugar" to be added to the grammar modes
+// without requiring any underlying changes to the compiler internals.
+
+// `compileMatch` being the perfect small example of now allowing a grammar
+// author to write `match` when they desire to match a single expression rather
+// than being forced to use `begin`. The extension then just moves `match` into
+// `begin` when it runs. Ie, no features have been added, but we've just made
+// the experience of writing (and reading grammars) a little bit nicer.
+
+// ------
+
+// TODO: We need negative look-behind support to do this properly
+/**
+ * Skip a match if it has a preceding dot
+ *
+ * This is used for `beginKeywords` to prevent matching expressions such as
+ * `bob.keyword.do()`. The mode compiler automatically wires this up as a
+ * special _internal_ 'on:begin' callback for modes with `beginKeywords`
+ * @param {RegExpMatchArray} match
+ * @param {CallbackResponse} response
+ */
+function skipIfHasPrecedingDot(match, response) {
+ const before = match.input[match.index - 1];
+ if (before === ".") {
+ response.ignoreMatch();
+ }
+}
+
+/**
+ *
+ * @type {CompilerExt}
+ */
+function scopeClassName(mode, _parent) {
+ // eslint-disable-next-line no-undefined
+ if (mode.className !== undefined) {
+ mode.scope = mode.className;
+ delete mode.className;
+ }
+}
+
+/**
+ * `beginKeywords` syntactic sugar
+ * @type {CompilerExt}
+ */
+function beginKeywords(mode, parent) {
+ if (!parent) return;
+ if (!mode.beginKeywords) return;
+
+ // for languages with keywords that include non-word characters checking for
+ // a word boundary is not sufficient, so instead we check for a word boundary
+ // or whitespace - this does no harm in any case since our keyword engine
+ // doesn't allow spaces in keywords anyways and we still check for the boundary
+ // first
+ mode.begin = '\\b(' + mode.beginKeywords.split(' ').join('|') + ')(?!\\.)(?=\\b|\\s)';
+ mode.__beforeBegin = skipIfHasPrecedingDot;
+ mode.keywords = mode.keywords || mode.beginKeywords;
+ delete mode.beginKeywords;
+
+ // prevents double relevance, the keywords themselves provide
+ // relevance, the mode doesn't need to double it
+ // eslint-disable-next-line no-undefined
+ if (mode.relevance === undefined) mode.relevance = 0;
+}
+
+/**
+ * Allow `illegal` to contain an array of illegal values
+ * @type {CompilerExt}
+ */
+function compileIllegal(mode, _parent) {
+ if (!Array.isArray(mode.illegal)) return;
+
+ mode.illegal = either(...mode.illegal);
+}
+
+/**
+ * `match` to match a single expression for readability
+ * @type {CompilerExt}
+ */
+function compileMatch(mode, _parent) {
+ if (!mode.match) return;
+ if (mode.begin || mode.end) throw new Error("begin & end are not supported with match");
+
+ mode.begin = mode.match;
+ delete mode.match;
+}
+
+/**
+ * provides the default 1 relevance to all modes
+ * @type {CompilerExt}
+ */
+function compileRelevance(mode, _parent) {
+ // eslint-disable-next-line no-undefined
+ if (mode.relevance === undefined) mode.relevance = 1;
+}
+
+// allow beforeMatch to act as a "qualifier" for the match
+// the full match begin must be [beforeMatch][begin]
+const beforeMatchExt = (mode, parent) => {
+ if (!mode.beforeMatch) return;
+ // starts conflicts with endsParent which we need to make sure the child
+ // rule is not matched multiple times
+ if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
+
+ const originalMode = Object.assign({}, mode);
+ Object.keys(mode).forEach((key) => { delete mode[key]; });
+
+ mode.keywords = originalMode.keywords;
+ mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+ mode.starts = {
+ relevance: 0,
+ contains: [
+ Object.assign(originalMode, { endsParent: true })
+ ]
+ };
+ mode.relevance = 0;
+
+ delete originalMode.beforeMatch;
+};
+
+// keywords that should have no default relevance value
+const COMMON_KEYWORDS = [
+ 'of',
+ 'and',
+ 'for',
+ 'in',
+ 'not',
+ 'or',
+ 'if',
+ 'then',
+ 'parent', // common variable name
+ 'list', // common variable name
+ 'value' // common variable name
+];
+
+const DEFAULT_KEYWORD_SCOPE = "keyword";
+
+/**
+ * Given raw keywords from a language definition, compile them.
+ *
+ * @param {string | Record | Array} rawKeywords
+ * @param {boolean} caseInsensitive
+ */
+function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
+ /** @type {import("highlight.js/private").KeywordDict} */
+ const compiledKeywords = Object.create(null);
+
+ // input can be a string of keywords, an array of keywords, or a object with
+ // named keys representing scopeName (which can then point to a string or array)
+ if (typeof rawKeywords === 'string') {
+ compileList(scopeName, rawKeywords.split(" "));
+ } else if (Array.isArray(rawKeywords)) {
+ compileList(scopeName, rawKeywords);
+ } else {
+ Object.keys(rawKeywords).forEach(function(scopeName) {
+ // collapse all our objects back into the parent object
+ Object.assign(
+ compiledKeywords,
+ compileKeywords(rawKeywords[scopeName], caseInsensitive, scopeName)
+ );
+ });
+ }
+ return compiledKeywords;
+
+ // ---
+
+ /**
+ * Compiles an individual list of keywords
+ *
+ * Ex: "for if when while|5"
+ *
+ * @param {string} scopeName
+ * @param {Array} keywordList
+ */
+ function compileList(scopeName, keywordList) {
+ if (caseInsensitive) {
+ keywordList = keywordList.map(x => x.toLowerCase());
+ }
+ keywordList.forEach(function(keyword) {
+ const pair = keyword.split('|');
+ compiledKeywords[pair[0]] = [scopeName, scoreForKeyword(pair[0], pair[1])];
+ });
+ }
+}
+
+/**
+ * Returns the proper score for a given keyword
+ *
+ * Also takes into account comment keywords, which will be scored 0 UNLESS
+ * another score has been manually assigned.
+ * @param {string} keyword
+ * @param {string} [providedScore]
+ */
+function scoreForKeyword(keyword, providedScore) {
+ // manual scores always win over common keywords
+ // so you can force a score of 1 if you really insist
+ if (providedScore) {
+ return Number(providedScore);
+ }
+
+ return commonKeyword(keyword) ? 0 : 1;
+}
+
+/**
+ * Determines if a given keyword is common or not
+ *
+ * @param {string} keyword */
+function commonKeyword(keyword) {
+ return COMMON_KEYWORDS.includes(keyword.toLowerCase());
+}
+
+/*
+
+For the reasoning behind this please see:
+https://github.com/highlightjs/highlight.js/issues/2880#issuecomment-747275419
+
+*/
+
+/**
+ * @type {Record}
+ */
+const seenDeprecations = {};
+
+/**
+ * @param {string} message
+ */
+const error = (message) => {
+ console.error(message);
+};
+
+/**
+ * @param {string} message
+ * @param {any} args
+ */
+const warn = (message, ...args) => {
+ console.log(`WARN: ${message}`, ...args);
+};
+
+/**
+ * @param {string} version
+ * @param {string} message
+ */
+const deprecated = (version, message) => {
+ if (seenDeprecations[`${version}/${message}`]) return;
+
+ console.log(`Deprecated as of ${version}. ${message}`);
+ seenDeprecations[`${version}/${message}`] = true;
+};
+
+/* eslint-disable no-throw-literal */
+
+/**
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+*/
+
+const MultiClassError = new Error();
+
+/**
+ * Renumbers labeled scope names to account for additional inner match
+ * groups that otherwise would break everything.
+ *
+ * Lets say we 3 match scopes:
+ *
+ * { 1 => ..., 2 => ..., 3 => ... }
+ *
+ * So what we need is a clean match like this:
+ *
+ * (a)(b)(c) => [ "a", "b", "c" ]
+ *
+ * But this falls apart with inner match groups:
+ *
+ * (a)(((b)))(c) => ["a", "b", "b", "b", "c" ]
+ *
+ * Our scopes are now "out of alignment" and we're repeating `b` 3 times.
+ * What needs to happen is the numbers are remapped:
+ *
+ * { 1 => ..., 2 => ..., 5 => ... }
+ *
+ * We also need to know that the ONLY groups that should be output
+ * are 1, 2, and 5. This function handles this behavior.
+ *
+ * @param {CompiledMode} mode
+ * @param {Array} regexes
+ * @param {{key: "beginScope"|"endScope"}} opts
+ */
+function remapScopeNames(mode, regexes, { key }) {
+ let offset = 0;
+ const scopeNames = mode[key];
+ /** @type Record */
+ const emit = {};
+ /** @type Record */
+ const positions = {};
+
+ for (let i = 1; i <= regexes.length; i++) {
+ positions[i + offset] = scopeNames[i];
+ emit[i + offset] = true;
+ offset += countMatchGroups(regexes[i - 1]);
+ }
+ // we use _emit to keep track of which match groups are "top-level" to avoid double
+ // output from inside match groups
+ mode[key] = positions;
+ mode[key]._emit = emit;
+ mode[key]._multi = true;
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function beginMultiClass(mode) {
+ if (!Array.isArray(mode.begin)) return;
+
+ if (mode.skip || mode.excludeBegin || mode.returnBegin) {
+ error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
+ throw MultiClassError;
+ }
+
+ if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
+ error("beginScope must be object");
+ throw MultiClassError;
+ }
+
+ remapScopeNames(mode, mode.begin, { key: "beginScope" });
+ mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function endMultiClass(mode) {
+ if (!Array.isArray(mode.end)) return;
+
+ if (mode.skip || mode.excludeEnd || mode.returnEnd) {
+ error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
+ throw MultiClassError;
+ }
+
+ if (typeof mode.endScope !== "object" || mode.endScope === null) {
+ error("endScope must be object");
+ throw MultiClassError;
+ }
+
+ remapScopeNames(mode, mode.end, { key: "endScope" });
+ mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
+}
+
+/**
+ * this exists only to allow `scope: {}` to be used beside `match:`
+ * Otherwise `beginScope` would necessary and that would look weird
+
+ {
+ match: [ /def/, /\w+/ ]
+ scope: { 1: "keyword" , 2: "title" }
+ }
+
+ * @param {CompiledMode} mode
+ */
+function scopeSugar(mode) {
+ if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
+ mode.beginScope = mode.scope;
+ delete mode.scope;
+ }
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function MultiClass(mode) {
+ scopeSugar(mode);
+
+ if (typeof mode.beginScope === "string") {
+ mode.beginScope = { _wrap: mode.beginScope };
+ }
+ if (typeof mode.endScope === "string") {
+ mode.endScope = { _wrap: mode.endScope };
+ }
+
+ beginMultiClass(mode);
+ endMultiClass(mode);
+}
+
+/**
+@typedef {import('highlight.js').Mode} Mode
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+@typedef {import('highlight.js').Language} Language
+@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+@typedef {import('highlight.js').CompiledLanguage} CompiledLanguage
+*/
+
+// compilation
+
+/**
+ * Compiles a language definition result
+ *
+ * Given the raw result of a language definition (Language), compiles this so
+ * that it is ready for highlighting code.
+ * @param {Language} language
+ * @returns {CompiledLanguage}
+ */
+function compileLanguage(language) {
+ /**
+ * Builds a regex with the case sensitivity of the current language
+ *
+ * @param {RegExp | string} value
+ * @param {boolean} [global]
+ */
+ function langRe(value, global) {
+ return new RegExp(
+ source(value),
+ 'm'
+ + (language.case_insensitive ? 'i' : '')
+ + (language.unicodeRegex ? 'u' : '')
+ + (global ? 'g' : '')
+ );
+ }
+
+ /**
+ Stores multiple regular expressions and allows you to quickly search for
+ them all in a string simultaneously - returning the first match. It does
+ this by creating a huge (a|b|c) regex - each individual item wrapped with ()
+ and joined by `|` - using match groups to track position. When a match is
+ found checking which position in the array has content allows us to figure
+ out which of the original regexes / match groups triggered the match.
+
+ The match object itself (the result of `Regex.exec`) is returned but also
+ enhanced by merging in any meta-data that was registered with the regex.
+ This is how we keep track of which mode matched, and what type of rule
+ (`illegal`, `begin`, end, etc).
+ */
+ class MultiRegex {
+ constructor() {
+ this.matchIndexes = {};
+ // @ts-ignore
+ this.regexes = [];
+ this.matchAt = 1;
+ this.position = 0;
+ }
+
+ // @ts-ignore
+ addRule(re, opts) {
+ opts.position = this.position++;
+ // @ts-ignore
+ this.matchIndexes[this.matchAt] = opts;
+ this.regexes.push([opts, re]);
+ this.matchAt += countMatchGroups(re) + 1;
+ }
+
+ compile() {
+ if (this.regexes.length === 0) {
+ // avoids the need to check length every time exec is called
+ // @ts-ignore
+ this.exec = () => null;
+ }
+ const terminators = this.regexes.map(el => el[1]);
+ this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: '|' }), true);
+ this.lastIndex = 0;
+ }
+
+ /** @param {string} s */
+ exec(s) {
+ this.matcherRe.lastIndex = this.lastIndex;
+ const match = this.matcherRe.exec(s);
+ if (!match) { return null; }
+
+ // eslint-disable-next-line no-undefined
+ const i = match.findIndex((el, i) => i > 0 && el !== undefined);
+ // @ts-ignore
+ const matchData = this.matchIndexes[i];
+ // trim off any earlier non-relevant match groups (ie, the other regex
+ // match groups that make up the multi-matcher)
+ match.splice(0, i);
+
+ return Object.assign(match, matchData);
+ }
+ }
+
+ /*
+ Created to solve the key deficiently with MultiRegex - there is no way to
+ test for multiple matches at a single location. Why would we need to do
+ that? In the future a more dynamic engine will allow certain matches to be
+ ignored. An example: if we matched say the 3rd regex in a large group but
+ decided to ignore it - we'd need to started testing again at the 4th
+ regex... but MultiRegex itself gives us no real way to do that.
+
+ So what this class creates MultiRegexs on the fly for whatever search
+ position they are needed.
+
+ NOTE: These additional MultiRegex objects are created dynamically. For most
+ grammars most of the time we will never actually need anything more than the
+ first MultiRegex - so this shouldn't have too much overhead.
+
+ Say this is our search group, and we match regex3, but wish to ignore it.
+
+ regex1 | regex2 | regex3 | regex4 | regex5 ' ie, startAt = 0
+
+ What we need is a new MultiRegex that only includes the remaining
+ possibilities:
+
+ regex4 | regex5 ' ie, startAt = 3
+
+ This class wraps all that complexity up in a simple API... `startAt` decides
+ where in the array of expressions to start doing the matching. It
+ auto-increments, so if a match is found at position 2, then startAt will be
+ set to 3. If the end is reached startAt will return to 0.
+
+ MOST of the time the parser will be setting startAt manually to 0.
+ */
+ class ResumableMultiRegex {
+ constructor() {
+ // @ts-ignore
+ this.rules = [];
+ // @ts-ignore
+ this.multiRegexes = [];
+ this.count = 0;
+
+ this.lastIndex = 0;
+ this.regexIndex = 0;
+ }
+
+ // @ts-ignore
+ getMatcher(index) {
+ if (this.multiRegexes[index]) return this.multiRegexes[index];
+
+ const matcher = new MultiRegex();
+ this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
+ matcher.compile();
+ this.multiRegexes[index] = matcher;
+ return matcher;
+ }
+
+ resumingScanAtSamePosition() {
+ return this.regexIndex !== 0;
+ }
+
+ considerAll() {
+ this.regexIndex = 0;
+ }
+
+ // @ts-ignore
+ addRule(re, opts) {
+ this.rules.push([re, opts]);
+ if (opts.type === "begin") this.count++;
+ }
+
+ /** @param {string} s */
+ exec(s) {
+ const m = this.getMatcher(this.regexIndex);
+ m.lastIndex = this.lastIndex;
+ let result = m.exec(s);
+
+ // The following is because we have no easy way to say "resume scanning at the
+ // existing position but also skip the current rule ONLY". What happens is
+ // all prior rules are also skipped which can result in matching the wrong
+ // thing. Example of matching "booger":
+
+ // our matcher is [string, "booger", number]
+ //
+ // ....booger....
+
+ // if "booger" is ignored then we'd really need a regex to scan from the
+ // SAME position for only: [string, number] but ignoring "booger" (if it
+ // was the first match), a simple resume would scan ahead who knows how
+ // far looking only for "number", ignoring potential string matches (or
+ // future "booger" matches that might be valid.)
+
+ // So what we do: We execute two matchers, one resuming at the same
+ // position, but the second full matcher starting at the position after:
+
+ // /--- resume first regex match here (for [number])
+ // |/---- full match here for [string, "booger", number]
+ // vv
+ // ....booger....
+
+ // Which ever results in a match first is then used. So this 3-4 step
+ // process essentially allows us to say "match at this position, excluding
+ // a prior rule that was ignored".
+ //
+ // 1. Match "booger" first, ignore. Also proves that [string] does non match.
+ // 2. Resume matching for [number]
+ // 3. Match at index + 1 for [string, "booger", number]
+ // 4. If #2 and #3 result in matches, which came first?
+ if (this.resumingScanAtSamePosition()) {
+ if (result && result.index === this.lastIndex) ; else { // use the second matcher result
+ const m2 = this.getMatcher(0);
+ m2.lastIndex = this.lastIndex + 1;
+ result = m2.exec(s);
+ }
+ }
+
+ if (result) {
+ this.regexIndex += result.position + 1;
+ if (this.regexIndex === this.count) {
+ // wrap-around to considering all matches again
+ this.considerAll();
+ }
+ }
+
+ return result;
+ }
+ }
+
+ /**
+ * Given a mode, builds a huge ResumableMultiRegex that can be used to walk
+ * the content and find matches.
+ *
+ * @param {CompiledMode} mode
+ * @returns {ResumableMultiRegex}
+ */
+ function buildModeRegex(mode) {
+ const mm = new ResumableMultiRegex();
+
+ mode.contains.forEach(term => mm.addRule(term.begin, { rule: term, type: "begin" }));
+
+ if (mode.terminatorEnd) {
+ mm.addRule(mode.terminatorEnd, { type: "end" });
+ }
+ if (mode.illegal) {
+ mm.addRule(mode.illegal, { type: "illegal" });
+ }
+
+ return mm;
+ }
+
+ /** skip vs abort vs ignore
+ *
+ * @skip - The mode is still entered and exited normally (and contains rules apply),
+ * but all content is held and added to the parent buffer rather than being
+ * output when the mode ends. Mostly used with `sublanguage` to build up
+ * a single large buffer than can be parsed by sublanguage.
+ *
+ * - The mode begin ands ends normally.
+ * - Content matched is added to the parent mode buffer.
+ * - The parser cursor is moved forward normally.
+ *
+ * @abort - A hack placeholder until we have ignore. Aborts the mode (as if it
+ * never matched) but DOES NOT continue to match subsequent `contains`
+ * modes. Abort is bad/suboptimal because it can result in modes
+ * farther down not getting applied because an earlier rule eats the
+ * content but then aborts.
+ *
+ * - The mode does not begin.
+ * - Content matched by `begin` is added to the mode buffer.
+ * - The parser cursor is moved forward accordingly.
+ *
+ * @ignore - Ignores the mode (as if it never matched) and continues to match any
+ * subsequent `contains` modes. Ignore isn't technically possible with
+ * the current parser implementation.
+ *
+ * - The mode does not begin.
+ * - Content matched by `begin` is ignored.
+ * - The parser cursor is not moved forward.
+ */
+
+ /**
+ * Compiles an individual mode
+ *
+ * This can raise an error if the mode contains certain detectable known logic
+ * issues.
+ * @param {Mode} mode
+ * @param {CompiledMode | null} [parent]
+ * @returns {CompiledMode | never}
+ */
+ function compileMode(mode, parent) {
+ const cmode = /** @type CompiledMode */ (mode);
+ if (mode.isCompiled) return cmode;
+
+ [
+ scopeClassName,
+ // do this early so compiler extensions generally don't have to worry about
+ // the distinction between match/begin
+ compileMatch,
+ MultiClass,
+ beforeMatchExt
+ ].forEach(ext => ext(mode, parent));
+
+ language.compilerExtensions.forEach(ext => ext(mode, parent));
+
+ // __beforeBegin is considered private API, internal use only
+ mode.__beforeBegin = null;
+
+ [
+ beginKeywords,
+ // do this later so compiler extensions that come earlier have access to the
+ // raw array if they wanted to perhaps manipulate it, etc.
+ compileIllegal,
+ // default to 1 relevance if not specified
+ compileRelevance
+ ].forEach(ext => ext(mode, parent));
+
+ mode.isCompiled = true;
+
+ let keywordPattern = null;
+ if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
+ // we need a copy because keywords might be compiled multiple times
+ // so we can't go deleting $pattern from the original on the first
+ // pass
+ mode.keywords = Object.assign({}, mode.keywords);
+ keywordPattern = mode.keywords.$pattern;
+ delete mode.keywords.$pattern;
+ }
+ keywordPattern = keywordPattern || /\w+/;
+
+ if (mode.keywords) {
+ mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
+ }
+
+ cmode.keywordPatternRe = langRe(keywordPattern, true);
+
+ if (parent) {
+ if (!mode.begin) mode.begin = /\B|\b/;
+ cmode.beginRe = langRe(cmode.begin);
+ if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
+ if (mode.end) cmode.endRe = langRe(cmode.end);
+ cmode.terminatorEnd = source(cmode.end) || '';
+ if (mode.endsWithParent && parent.terminatorEnd) {
+ cmode.terminatorEnd += (mode.end ? '|' : '') + parent.terminatorEnd;
+ }
+ }
+ if (mode.illegal) cmode.illegalRe = langRe(/** @type {RegExp | string} */ (mode.illegal));
+ if (!mode.contains) mode.contains = [];
+
+ mode.contains = [].concat(...mode.contains.map(function(c) {
+ return expandOrCloneMode(c === 'self' ? mode : c);
+ }));
+ mode.contains.forEach(function(c) { compileMode(/** @type Mode */ (c), cmode); });
+
+ if (mode.starts) {
+ compileMode(mode.starts, parent);
+ }
+
+ cmode.matcher = buildModeRegex(cmode);
+ return cmode;
+ }
+
+ if (!language.compilerExtensions) language.compilerExtensions = [];
+
+ // self is not valid at the top-level
+ if (language.contains && language.contains.includes('self')) {
+ throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");
+ }
+
+ // we need a null object, which inherit will guarantee
+ language.classNameAliases = inherit$1(language.classNameAliases || {});
+
+ return compileMode(/** @type Mode */ (language));
+}
+
+/**
+ * Determines if a mode has a dependency on it's parent or not
+ *
+ * If a mode does have a parent dependency then often we need to clone it if
+ * it's used in multiple places so that each copy points to the correct parent,
+ * where-as modes without a parent can often safely be re-used at the bottom of
+ * a mode chain.
+ *
+ * @param {Mode | null} mode
+ * @returns {boolean} - is there a dependency on the parent?
+ * */
+function dependencyOnParent(mode) {
+ if (!mode) return false;
+
+ return mode.endsWithParent || dependencyOnParent(mode.starts);
+}
+
+/**
+ * Expands a mode or clones it if necessary
+ *
+ * This is necessary for modes with parental dependenceis (see notes on
+ * `dependencyOnParent`) and for nodes that have `variants` - which must then be
+ * exploded into their own individual modes at compile time.
+ *
+ * @param {Mode} mode
+ * @returns {Mode | Mode[]}
+ * */
+function expandOrCloneMode(mode) {
+ if (mode.variants && !mode.cachedVariants) {
+ mode.cachedVariants = mode.variants.map(function(variant) {
+ return inherit$1(mode, { variants: null }, variant);
+ });
+ }
+
+ // EXPAND
+ // if we have variants then essentially "replace" the mode with the variants
+ // this happens in compileMode, where this function is called from
+ if (mode.cachedVariants) {
+ return mode.cachedVariants;
+ }
+
+ // CLONE
+ // if we have dependencies on parents then we need a unique
+ // instance of ourselves, so we can be reused with many
+ // different parents without issue
+ if (dependencyOnParent(mode)) {
+ return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null });
+ }
+
+ if (Object.isFrozen(mode)) {
+ return inherit$1(mode);
+ }
+
+ // no special dependency issues, just return ourselves
+ return mode;
+}
+
+var version = "11.9.0";
+
+class HTMLInjectionError extends Error {
+ constructor(reason, html) {
+ super(reason);
+ this.name = "HTMLInjectionError";
+ this.html = html;
+ }
+}
+
+/*
+Syntax highlighting with language autodetection.
+https://highlightjs.org/
+*/
+
+
+
+/**
+@typedef {import('highlight.js').Mode} Mode
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+@typedef {import('highlight.js').CompiledScope} CompiledScope
+@typedef {import('highlight.js').Language} Language
+@typedef {import('highlight.js').HLJSApi} HLJSApi
+@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+@typedef {import('highlight.js').PluginEvent} PluginEvent
+@typedef {import('highlight.js').HLJSOptions} HLJSOptions
+@typedef {import('highlight.js').LanguageFn} LanguageFn
+@typedef {import('highlight.js').HighlightedHTMLElement} HighlightedHTMLElement
+@typedef {import('highlight.js').BeforeHighlightContext} BeforeHighlightContext
+@typedef {import('highlight.js/private').MatchType} MatchType
+@typedef {import('highlight.js/private').KeywordData} KeywordData
+@typedef {import('highlight.js/private').EnhancedMatch} EnhancedMatch
+@typedef {import('highlight.js/private').AnnotatedError} AnnotatedError
+@typedef {import('highlight.js').AutoHighlightResult} AutoHighlightResult
+@typedef {import('highlight.js').HighlightOptions} HighlightOptions
+@typedef {import('highlight.js').HighlightResult} HighlightResult
+*/
+
+
+const escape = escapeHTML;
+const inherit = inherit$1;
+const NO_MATCH = Symbol("nomatch");
+const MAX_KEYWORD_HITS = 7;
+
+/**
+ * @param {any} hljs - object that is extended (legacy)
+ * @returns {HLJSApi}
+ */
+const HLJS = function(hljs) {
+ // Global internal variables used within the highlight.js library.
+ /** @type {Record} */
+ const languages = Object.create(null);
+ /** @type {Record} */
+ const aliases = Object.create(null);
+ /** @type {HLJSPlugin[]} */
+ const plugins = [];
+
+ // safe/production mode - swallows more errors, tries to keep running
+ // even if a single syntax or parse hits a fatal error
+ let SAFE_MODE = true;
+ const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
+ /** @type {Language} */
+ const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: 'Plain text', contains: [] };
+
+ // Global options used when within external APIs. This is modified when
+ // calling the `hljs.configure` function.
+ /** @type HLJSOptions */
+ let options = {
+ ignoreUnescapedHTML: false,
+ throwUnescapedHTML: false,
+ noHighlightRe: /^(no-?highlight)$/i,
+ languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+ classPrefix: 'hljs-',
+ cssSelector: 'pre code',
+ languages: null,
+ // beta configuration options, subject to change, welcome to discuss
+ // https://github.com/highlightjs/highlight.js/issues/1086
+ __emitter: TokenTreeEmitter
+ };
+
+ /* Utility functions */
+
+ /**
+ * Tests a language name to see if highlighting should be skipped
+ * @param {string} languageName
+ */
+ function shouldNotHighlight(languageName) {
+ return options.noHighlightRe.test(languageName);
+ }
+
+ /**
+ * @param {HighlightedHTMLElement} block - the HTML element to determine language for
+ */
+ function blockLanguage(block) {
+ let classes = block.className + ' ';
+
+ classes += block.parentNode ? block.parentNode.className : '';
+
+ // language-* takes precedence over non-prefixed class names.
+ const match = options.languageDetectRe.exec(classes);
+ if (match) {
+ const language = getLanguage(match[1]);
+ if (!language) {
+ warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
+ warn("Falling back to no-highlight mode for this block.", block);
+ }
+ return language ? match[1] : 'no-highlight';
+ }
+
+ return classes
+ .split(/\s+/)
+ .find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
+ }
+
+ /**
+ * Core highlighting function.
+ *
+ * OLD API
+ * highlight(lang, code, ignoreIllegals, continuation)
+ *
+ * NEW API
+ * highlight(code, {lang, ignoreIllegals})
+ *
+ * @param {string} codeOrLanguageName - the language to use for highlighting
+ * @param {string | HighlightOptions} optionsOrCode - the code to highlight
+ * @param {boolean} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
+ *
+ * @returns {HighlightResult} Result - an object that represents the result
+ * @property {string} language - the language name
+ * @property {number} relevance - the relevance score
+ * @property {string} value - the highlighted HTML code
+ * @property {string} code - the original raw code
+ * @property {CompiledMode} top - top of the current mode stack
+ * @property {boolean} illegal - indicates whether any illegal matches were found
+ */
+ function highlight(codeOrLanguageName, optionsOrCode, ignoreIllegals) {
+ let code = "";
+ let languageName = "";
+ if (typeof optionsOrCode === "object") {
+ code = codeOrLanguageName;
+ ignoreIllegals = optionsOrCode.ignoreIllegals;
+ languageName = optionsOrCode.language;
+ } else {
+ // old API
+ deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
+ deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
+ languageName = codeOrLanguageName;
+ code = optionsOrCode;
+ }
+
+ // https://github.com/highlightjs/highlight.js/issues/3149
+ // eslint-disable-next-line no-undefined
+ if (ignoreIllegals === undefined) { ignoreIllegals = true; }
+
+ /** @type {BeforeHighlightContext} */
+ const context = {
+ code,
+ language: languageName
+ };
+ // the plugin can change the desired language or the code to be highlighted
+ // just be changing the object it was passed
+ fire("before:highlight", context);
+
+ // a before plugin can usurp the result completely by providing it's own
+ // in which case we don't even need to call highlight
+ const result = context.result
+ ? context.result
+ : _highlight(context.language, context.code, ignoreIllegals);
+
+ result.code = context.code;
+ // the plugin can change anything in result to suite it
+ fire("after:highlight", result);
+
+ return result;
+ }
+
+ /**
+ * private highlight that's used internally and does not fire callbacks
+ *
+ * @param {string} languageName - the language to use for highlighting
+ * @param {string} codeToHighlight - the code to highlight
+ * @param {boolean?} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
+ * @param {CompiledMode?} [continuation] - current continuation mode, if any
+ * @returns {HighlightResult} - result of the highlight operation
+ */
+ function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
+ const keywordHits = Object.create(null);
+
+ /**
+ * Return keyword data if a match is a keyword
+ * @param {CompiledMode} mode - current mode
+ * @param {string} matchText - the textual match
+ * @returns {KeywordData | false}
+ */
+ function keywordData(mode, matchText) {
+ return mode.keywords[matchText];
+ }
+
+ function processKeywords() {
+ if (!top.keywords) {
+ emitter.addText(modeBuffer);
+ return;
+ }
+
+ let lastIndex = 0;
+ top.keywordPatternRe.lastIndex = 0;
+ let match = top.keywordPatternRe.exec(modeBuffer);
+ let buf = "";
+
+ while (match) {
+ buf += modeBuffer.substring(lastIndex, match.index);
+ const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
+ const data = keywordData(top, word);
+ if (data) {
+ const [kind, keywordRelevance] = data;
+ emitter.addText(buf);
+ buf = "";
+
+ keywordHits[word] = (keywordHits[word] || 0) + 1;
+ if (keywordHits[word] <= MAX_KEYWORD_HITS) relevance += keywordRelevance;
+ if (kind.startsWith("_")) {
+ // _ implied for relevance only, do not highlight
+ // by applying a class name
+ buf += match[0];
+ } else {
+ const cssClass = language.classNameAliases[kind] || kind;
+ emitKeyword(match[0], cssClass);
+ }
+ } else {
+ buf += match[0];
+ }
+ lastIndex = top.keywordPatternRe.lastIndex;
+ match = top.keywordPatternRe.exec(modeBuffer);
+ }
+ buf += modeBuffer.substring(lastIndex);
+ emitter.addText(buf);
+ }
+
+ function processSubLanguage() {
+ if (modeBuffer === "") return;
+ /** @type HighlightResult */
+ let result = null;
+
+ if (typeof top.subLanguage === 'string') {
+ if (!languages[top.subLanguage]) {
+ emitter.addText(modeBuffer);
+ return;
+ }
+ result = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
+ continuations[top.subLanguage] = /** @type {CompiledMode} */ (result._top);
+ } else {
+ result = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
+ }
+
+ // Counting embedded language score towards the host language may be disabled
+ // with zeroing the containing mode relevance. Use case in point is Markdown that
+ // allows XML everywhere and makes every XML snippet to have a much larger Markdown
+ // score.
+ if (top.relevance > 0) {
+ relevance += result.relevance;
+ }
+ emitter.__addSublanguage(result._emitter, result.language);
+ }
+
+ function processBuffer() {
+ if (top.subLanguage != null) {
+ processSubLanguage();
+ } else {
+ processKeywords();
+ }
+ modeBuffer = '';
+ }
+
+ /**
+ * @param {string} text
+ * @param {string} scope
+ */
+ function emitKeyword(keyword, scope) {
+ if (keyword === "") return;
+
+ emitter.startScope(scope);
+ emitter.addText(keyword);
+ emitter.endScope();
+ }
+
+ /**
+ * @param {CompiledScope} scope
+ * @param {RegExpMatchArray} match
+ */
+ function emitMultiClass(scope, match) {
+ let i = 1;
+ const max = match.length - 1;
+ while (i <= max) {
+ if (!scope._emit[i]) { i++; continue; }
+ const klass = language.classNameAliases[scope[i]] || scope[i];
+ const text = match[i];
+ if (klass) {
+ emitKeyword(text, klass);
+ } else {
+ modeBuffer = text;
+ processKeywords();
+ modeBuffer = "";
+ }
+ i++;
+ }
+ }
+
+ /**
+ * @param {CompiledMode} mode - new mode to start
+ * @param {RegExpMatchArray} match
+ */
+ function startNewMode(mode, match) {
+ if (mode.scope && typeof mode.scope === "string") {
+ emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
+ }
+ if (mode.beginScope) {
+ // beginScope just wraps the begin match itself in a scope
+ if (mode.beginScope._wrap) {
+ emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
+ modeBuffer = "";
+ } else if (mode.beginScope._multi) {
+ // at this point modeBuffer should just be the match
+ emitMultiClass(mode.beginScope, match);
+ modeBuffer = "";
+ }
+ }
+
+ top = Object.create(mode, { parent: { value: top } });
+ return top;
+ }
+
+ /**
+ * @param {CompiledMode } mode - the mode to potentially end
+ * @param {RegExpMatchArray} match - the latest match
+ * @param {string} matchPlusRemainder - match plus remainder of content
+ * @returns {CompiledMode | void} - the next mode, or if void continue on in current mode
+ */
+ function endOfMode(mode, match, matchPlusRemainder) {
+ let matched = startsWith(mode.endRe, matchPlusRemainder);
+
+ if (matched) {
+ if (mode["on:end"]) {
+ const resp = new Response(mode);
+ mode["on:end"](match, resp);
+ if (resp.isMatchIgnored) matched = false;
+ }
+
+ if (matched) {
+ while (mode.endsParent && mode.parent) {
+ mode = mode.parent;
+ }
+ return mode;
+ }
+ }
+ // even if on:end fires an `ignore` it's still possible
+ // that we might trigger the end node because of a parent mode
+ if (mode.endsWithParent) {
+ return endOfMode(mode.parent, match, matchPlusRemainder);
+ }
+ }
+
+ /**
+ * Handle matching but then ignoring a sequence of text
+ *
+ * @param {string} lexeme - string containing full match text
+ */
+ function doIgnore(lexeme) {
+ if (top.matcher.regexIndex === 0) {
+ // no more regexes to potentially match here, so we move the cursor forward one
+ // space
+ modeBuffer += lexeme[0];
+ return 1;
+ } else {
+ // no need to move the cursor, we still have additional regexes to try and
+ // match at this very spot
+ resumeScanAtSamePosition = true;
+ return 0;
+ }
+ }
+
+ /**
+ * Handle the start of a new potential mode match
+ *
+ * @param {EnhancedMatch} match - the current match
+ * @returns {number} how far to advance the parse cursor
+ */
+ function doBeginMatch(match) {
+ const lexeme = match[0];
+ const newMode = match.rule;
+
+ const resp = new Response(newMode);
+ // first internal before callbacks, then the public ones
+ const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
+ for (const cb of beforeCallbacks) {
+ if (!cb) continue;
+ cb(match, resp);
+ if (resp.isMatchIgnored) return doIgnore(lexeme);
+ }
+
+ if (newMode.skip) {
+ modeBuffer += lexeme;
+ } else {
+ if (newMode.excludeBegin) {
+ modeBuffer += lexeme;
+ }
+ processBuffer();
+ if (!newMode.returnBegin && !newMode.excludeBegin) {
+ modeBuffer = lexeme;
+ }
+ }
+ startNewMode(newMode, match);
+ return newMode.returnBegin ? 0 : lexeme.length;
+ }
+
+ /**
+ * Handle the potential end of mode
+ *
+ * @param {RegExpMatchArray} match - the current match
+ */
+ function doEndMatch(match) {
+ const lexeme = match[0];
+ const matchPlusRemainder = codeToHighlight.substring(match.index);
+
+ const endMode = endOfMode(top, match, matchPlusRemainder);
+ if (!endMode) { return NO_MATCH; }
+
+ const origin = top;
+ if (top.endScope && top.endScope._wrap) {
+ processBuffer();
+ emitKeyword(lexeme, top.endScope._wrap);
+ } else if (top.endScope && top.endScope._multi) {
+ processBuffer();
+ emitMultiClass(top.endScope, match);
+ } else if (origin.skip) {
+ modeBuffer += lexeme;
+ } else {
+ if (!(origin.returnEnd || origin.excludeEnd)) {
+ modeBuffer += lexeme;
+ }
+ processBuffer();
+ if (origin.excludeEnd) {
+ modeBuffer = lexeme;
+ }
+ }
+ do {
+ if (top.scope) {
+ emitter.closeNode();
+ }
+ if (!top.skip && !top.subLanguage) {
+ relevance += top.relevance;
+ }
+ top = top.parent;
+ } while (top !== endMode.parent);
+ if (endMode.starts) {
+ startNewMode(endMode.starts, match);
+ }
+ return origin.returnEnd ? 0 : lexeme.length;
+ }
+
+ function processContinuations() {
+ const list = [];
+ for (let current = top; current !== language; current = current.parent) {
+ if (current.scope) {
+ list.unshift(current.scope);
+ }
+ }
+ list.forEach(item => emitter.openNode(item));
+ }
+
+ /** @type {{type?: MatchType, index?: number, rule?: Mode}}} */
+ let lastMatch = {};
+
+ /**
+ * Process an individual match
+ *
+ * @param {string} textBeforeMatch - text preceding the match (since the last match)
+ * @param {EnhancedMatch} [match] - the match itself
+ */
+ function processLexeme(textBeforeMatch, match) {
+ const lexeme = match && match[0];
+
+ // add non-matched text to the current mode buffer
+ modeBuffer += textBeforeMatch;
+
+ if (lexeme == null) {
+ processBuffer();
+ return 0;
+ }
+
+ // we've found a 0 width match and we're stuck, so we need to advance
+ // this happens when we have badly behaved rules that have optional matchers to the degree that
+ // sometimes they can end up matching nothing at all
+ // Ref: https://github.com/highlightjs/highlight.js/issues/2140
+ if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
+ // spit the "skipped" character that our regex choked on back into the output sequence
+ modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
+ if (!SAFE_MODE) {
+ /** @type {AnnotatedError} */
+ const err = new Error(`0 width match regex (${languageName})`);
+ err.languageName = languageName;
+ err.badRule = lastMatch.rule;
+ throw err;
+ }
+ return 1;
+ }
+ lastMatch = match;
+
+ if (match.type === "begin") {
+ return doBeginMatch(match);
+ } else if (match.type === "illegal" && !ignoreIllegals) {
+ // illegal match, we do not continue processing
+ /** @type {AnnotatedError} */
+ const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || '') + '"');
+ err.mode = top;
+ throw err;
+ } else if (match.type === "end") {
+ const processed = doEndMatch(match);
+ if (processed !== NO_MATCH) {
+ return processed;
+ }
+ }
+
+ // edge case for when illegal matches $ (end of line) which is technically
+ // a 0 width match but not a begin/end match so it's not caught by the
+ // first handler (when ignoreIllegals is true)
+ if (match.type === "illegal" && lexeme === "") {
+ // advance so we aren't stuck in an infinite loop
+ return 1;
+ }
+
+ // infinite loops are BAD, this is a last ditch catch all. if we have a
+ // decent number of iterations yet our index (cursor position in our
+ // parsing) still 3x behind our index then something is very wrong
+ // so we bail
+ if (iterations > 100000 && iterations > match.index * 3) {
+ const err = new Error('potential infinite loop, way more iterations than matches');
+ throw err;
+ }
+
+ /*
+ Why might be find ourselves here? An potential end match that was
+ triggered but could not be completed. IE, `doEndMatch` returned NO_MATCH.
+ (this could be because a callback requests the match be ignored, etc)
+
+ This causes no real harm other than stopping a few times too many.
+ */
+
+ modeBuffer += lexeme;
+ return lexeme.length;
+ }
+
+ const language = getLanguage(languageName);
+ if (!language) {
+ error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
+ throw new Error('Unknown language: "' + languageName + '"');
+ }
+
+ const md = compileLanguage(language);
+ let result = '';
+ /** @type {CompiledMode} */
+ let top = continuation || md;
+ /** @type Record */
+ const continuations = {}; // keep continuations for sub-languages
+ const emitter = new options.__emitter(options);
+ processContinuations();
+ let modeBuffer = '';
+ let relevance = 0;
+ let index = 0;
+ let iterations = 0;
+ let resumeScanAtSamePosition = false;
+
+ try {
+ if (!language.__emitTokens) {
+ top.matcher.considerAll();
+
+ for (;;) {
+ iterations++;
+ if (resumeScanAtSamePosition) {
+ // only regexes not matched previously will now be
+ // considered for a potential match
+ resumeScanAtSamePosition = false;
+ } else {
+ top.matcher.considerAll();
+ }
+ top.matcher.lastIndex = index;
+
+ const match = top.matcher.exec(codeToHighlight);
+ // console.log("match", match[0], match.rule && match.rule.begin)
+
+ if (!match) break;
+
+ const beforeMatch = codeToHighlight.substring(index, match.index);
+ const processedCount = processLexeme(beforeMatch, match);
+ index = match.index + processedCount;
+ }
+ processLexeme(codeToHighlight.substring(index));
+ } else {
+ language.__emitTokens(codeToHighlight, emitter);
+ }
+
+ emitter.finalize();
+ result = emitter.toHTML();
+
+ return {
+ language: languageName,
+ value: result,
+ relevance,
+ illegal: false,
+ _emitter: emitter,
+ _top: top
+ };
+ } catch (err) {
+ if (err.message && err.message.includes('Illegal')) {
+ return {
+ language: languageName,
+ value: escape(codeToHighlight),
+ illegal: true,
+ relevance: 0,
+ _illegalBy: {
+ message: err.message,
+ index,
+ context: codeToHighlight.slice(index - 100, index + 100),
+ mode: err.mode,
+ resultSoFar: result
+ },
+ _emitter: emitter
+ };
+ } else if (SAFE_MODE) {
+ return {
+ language: languageName,
+ value: escape(codeToHighlight),
+ illegal: false,
+ relevance: 0,
+ errorRaised: err,
+ _emitter: emitter,
+ _top: top
+ };
+ } else {
+ throw err;
+ }
+ }
+ }
+
+ /**
+ * returns a valid highlight result, without actually doing any actual work,
+ * auto highlight starts with this and it's possible for small snippets that
+ * auto-detection may not find a better match
+ * @param {string} code
+ * @returns {HighlightResult}
+ */
+ function justTextHighlightResult(code) {
+ const result = {
+ value: escape(code),
+ illegal: false,
+ relevance: 0,
+ _top: PLAINTEXT_LANGUAGE,
+ _emitter: new options.__emitter(options)
+ };
+ result._emitter.addText(code);
+ return result;
+ }
+
+ /**
+ Highlighting with language detection. Accepts a string with the code to
+ highlight. Returns an object with the following properties:
+
+ - language (detected language)
+ - relevance (int)
+ - value (an HTML string with highlighting markup)
+ - secondBest (object with the same structure for second-best heuristically
+ detected language, may be absent)
+
+ @param {string} code
+ @param {Array} [languageSubset]
+ @returns {AutoHighlightResult}
+ */
+ function highlightAuto(code, languageSubset) {
+ languageSubset = languageSubset || options.languages || Object.keys(languages);
+ const plaintext = justTextHighlightResult(code);
+
+ const results = languageSubset.filter(getLanguage).filter(autoDetection).map(name =>
+ _highlight(name, code, false)
+ );
+ results.unshift(plaintext); // plaintext is always an option
+
+ const sorted = results.sort((a, b) => {
+ // sort base on relevance
+ if (a.relevance !== b.relevance) return b.relevance - a.relevance;
+
+ // always award the tie to the base language
+ // ie if C++ and Arduino are tied, it's more likely to be C++
+ if (a.language && b.language) {
+ if (getLanguage(a.language).supersetOf === b.language) {
+ return 1;
+ } else if (getLanguage(b.language).supersetOf === a.language) {
+ return -1;
+ }
+ }
+
+ // otherwise say they are equal, which has the effect of sorting on
+ // relevance while preserving the original ordering - which is how ties
+ // have historically been settled, ie the language that comes first always
+ // wins in the case of a tie
+ return 0;
+ });
+
+ const [best, secondBest] = sorted;
+
+ /** @type {AutoHighlightResult} */
+ const result = best;
+ result.secondBest = secondBest;
+
+ return result;
+ }
+
+ /**
+ * Builds new class name for block given the language name
+ *
+ * @param {HTMLElement} element
+ * @param {string} [currentLang]
+ * @param {string} [resultLang]
+ */
+ function updateClassName(element, currentLang, resultLang) {
+ const language = (currentLang && aliases[currentLang]) || resultLang;
+
+ element.classList.add("hljs");
+ element.classList.add(`language-${language}`);
+ }
+
+ /**
+ * Applies highlighting to a DOM node containing code.
+ *
+ * @param {HighlightedHTMLElement} element - the HTML element to highlight
+ */
+ function highlightElement(element) {
+ /** @type HTMLElement */
+ let node = null;
+ const language = blockLanguage(element);
+
+ if (shouldNotHighlight(language)) return;
+
+ fire("before:highlightElement",
+ { el: element, language });
+
+ if (element.dataset.highlighted) {
+ console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element);
+ return;
+ }
+
+ // we should be all text, no child nodes (unescaped HTML) - this is possibly
+ // an HTML injection attack - it's likely too late if this is already in
+ // production (the code has likely already done its damage by the time
+ // we're seeing it)... but we yell loudly about this so that hopefully it's
+ // more likely to be caught in development before making it to production
+ if (element.children.length > 0) {
+ if (!options.ignoreUnescapedHTML) {
+ console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
+ console.warn("https://github.com/highlightjs/highlight.js/wiki/security");
+ console.warn("The element with unescaped HTML:");
+ console.warn(element);
+ }
+ if (options.throwUnescapedHTML) {
+ const err = new HTMLInjectionError(
+ "One of your code blocks includes unescaped HTML.",
+ element.innerHTML
+ );
+ throw err;
+ }
+ }
+
+ node = element;
+ const text = node.textContent;
+ const result = language ? highlight(text, { language, ignoreIllegals: true }) : highlightAuto(text);
+
+ element.innerHTML = result.value;
+ element.dataset.highlighted = "yes";
+ updateClassName(element, language, result.language);
+ element.result = {
+ language: result.language,
+ // TODO: remove with version 11.0
+ re: result.relevance,
+ relevance: result.relevance
+ };
+ if (result.secondBest) {
+ element.secondBest = {
+ language: result.secondBest.language,
+ relevance: result.secondBest.relevance
+ };
+ }
+
+ fire("after:highlightElement", { el: element, result, text });
+ }
+
+ /**
+ * Updates highlight.js global options with the passed options
+ *
+ * @param {Partial} userOptions
+ */
+ function configure(userOptions) {
+ options = inherit(options, userOptions);
+ }
+
+ // TODO: remove v12, deprecated
+ const initHighlighting = () => {
+ highlightAll();
+ deprecated("10.6.0", "initHighlighting() deprecated. Use highlightAll() now.");
+ };
+
+ // TODO: remove v12, deprecated
+ function initHighlightingOnLoad() {
+ highlightAll();
+ deprecated("10.6.0", "initHighlightingOnLoad() deprecated. Use highlightAll() now.");
+ }
+
+ let wantsHighlight = false;
+
+ /**
+ * auto-highlights all pre>code elements on the page
+ */
+ function highlightAll() {
+ // if we are called too early in the loading process
+ if (document.readyState === "loading") {
+ wantsHighlight = true;
+ return;
+ }
+
+ const blocks = document.querySelectorAll(options.cssSelector);
+ blocks.forEach(highlightElement);
+ }
+
+ function boot() {
+ // if a highlight was requested before DOM was loaded, do now
+ if (wantsHighlight) highlightAll();
+ }
+
+ // make sure we are in the browser environment
+ if (typeof window !== 'undefined' && window.addEventListener) {
+ window.addEventListener('DOMContentLoaded', boot, false);
+ }
+
+ /**
+ * Register a language grammar module
+ *
+ * @param {string} languageName
+ * @param {LanguageFn} languageDefinition
+ */
+ function registerLanguage(languageName, languageDefinition) {
+ let lang = null;
+ try {
+ lang = languageDefinition(hljs);
+ } catch (error$1) {
+ error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+ // hard or soft error
+ if (!SAFE_MODE) { throw error$1; } else { error(error$1); }
+ // languages that have serious errors are replaced with essentially a
+ // "plaintext" stand-in so that the code blocks will still get normal
+ // css classes applied to them - and one bad language won't break the
+ // entire highlighter
+ lang = PLAINTEXT_LANGUAGE;
+ }
+ // give it a temporary name if it doesn't have one in the meta-data
+ if (!lang.name) lang.name = languageName;
+ languages[languageName] = lang;
+ lang.rawDefinition = languageDefinition.bind(null, hljs);
+
+ if (lang.aliases) {
+ registerAliases(lang.aliases, { languageName });
+ }
+ }
+
+ /**
+ * Remove a language grammar module
+ *
+ * @param {string} languageName
+ */
+ function unregisterLanguage(languageName) {
+ delete languages[languageName];
+ for (const alias of Object.keys(aliases)) {
+ if (aliases[alias] === languageName) {
+ delete aliases[alias];
+ }
+ }
+ }
+
+ /**
+ * @returns {string[]} List of language internal names
+ */
+ function listLanguages() {
+ return Object.keys(languages);
+ }
+
+ /**
+ * @param {string} name - name of the language to retrieve
+ * @returns {Language | undefined}
+ */
+ function getLanguage(name) {
+ name = (name || '').toLowerCase();
+ return languages[name] || languages[aliases[name]];
+ }
+
+ /**
+ *
+ * @param {string|string[]} aliasList - single alias or list of aliases
+ * @param {{languageName: string}} opts
+ */
+ function registerAliases(aliasList, { languageName }) {
+ if (typeof aliasList === 'string') {
+ aliasList = [aliasList];
+ }
+ aliasList.forEach(alias => { aliases[alias.toLowerCase()] = languageName; });
+ }
+
+ /**
+ * Determines if a given language has auto-detection enabled
+ * @param {string} name - name of the language
+ */
+ function autoDetection(name) {
+ const lang = getLanguage(name);
+ return lang && !lang.disableAutodetect;
+ }
+
+ /**
+ * Upgrades the old highlightBlock plugins to the new
+ * highlightElement API
+ * @param {HLJSPlugin} plugin
+ */
+ function upgradePluginAPI(plugin) {
+ // TODO: remove with v12
+ if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
+ plugin["before:highlightElement"] = (data) => {
+ plugin["before:highlightBlock"](
+ Object.assign({ block: data.el }, data)
+ );
+ };
+ }
+ if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
+ plugin["after:highlightElement"] = (data) => {
+ plugin["after:highlightBlock"](
+ Object.assign({ block: data.el }, data)
+ );
+ };
+ }
+ }
+
+ /**
+ * @param {HLJSPlugin} plugin
+ */
+ function addPlugin(plugin) {
+ upgradePluginAPI(plugin);
+ plugins.push(plugin);
+ }
+
+ /**
+ * @param {HLJSPlugin} plugin
+ */
+ function removePlugin(plugin) {
+ const index = plugins.indexOf(plugin);
+ if (index !== -1) {
+ plugins.splice(index, 1);
+ }
+ }
+
+ /**
+ *
+ * @param {PluginEvent} event
+ * @param {any} args
+ */
+ function fire(event, args) {
+ const cb = event;
+ plugins.forEach(function(plugin) {
+ if (plugin[cb]) {
+ plugin[cb](args);
+ }
+ });
+ }
+
+ /**
+ * DEPRECATED
+ * @param {HighlightedHTMLElement} el
+ */
+ function deprecateHighlightBlock(el) {
+ deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+ deprecated("10.7.0", "Please use highlightElement now.");
+
+ return highlightElement(el);
+ }
+
+ /* Interface definition */
+ Object.assign(hljs, {
+ highlight,
+ highlightAuto,
+ highlightAll,
+ highlightElement,
+ // TODO: Remove with v12 API
+ highlightBlock: deprecateHighlightBlock,
+ configure,
+ initHighlighting,
+ initHighlightingOnLoad,
+ registerLanguage,
+ unregisterLanguage,
+ listLanguages,
+ getLanguage,
+ registerAliases,
+ autoDetection,
+ inherit,
+ addPlugin,
+ removePlugin
+ });
+
+ hljs.debugMode = function() { SAFE_MODE = false; };
+ hljs.safeMode = function() { SAFE_MODE = true; };
+ hljs.versionString = version;
+
+ hljs.regex = {
+ concat: concat,
+ lookahead: lookahead,
+ either: either,
+ optional: optional,
+ anyNumberOfTimes: anyNumberOfTimes
+ };
+
+ for (const key in MODES) {
+ // @ts-ignore
+ if (typeof MODES[key] === "object") {
+ // @ts-ignore
+ deepFreeze(MODES[key]);
+ }
+ }
+
+ // merge all the modes/regexes into our main object
+ Object.assign(hljs, MODES);
+
+ return hljs;
+};
+
+// Other names for the variable may break build script
+const highlight = HLJS({});
+
+// returns a new instance of the highlighter to be used for extensions
+// check https://github.com/wooorm/lowlight/issues/47
+highlight.newInstance = () => HLJS({});
+
+export { highlight as default };
diff --git a/templates/hljs/es/core.min.js b/templates/hljs/es/core.min.js
new file mode 100644
index 0000000..c6d4ae5
--- /dev/null
+++ b/templates/hljs/es/core.min.js
@@ -0,0 +1,307 @@
+/*!
+ Highlight.js v11.9.0 (git: b7ec4bfafc)
+ (c) 2006-2023 undefined and other contributors
+ License: BSD-3-Clause
+ */
+function e(t){return t instanceof Map?t.clear=t.delete=t.set=()=>{
+throw Error("map is read-only")}:t instanceof Set&&(t.add=t.clear=t.delete=()=>{
+throw Error("set is read-only")
+}),Object.freeze(t),Object.getOwnPropertyNames(t).forEach((n=>{
+const i=t[n],s=typeof i;"object"!==s&&"function"!==s||Object.isFrozen(i)||e(i)
+})),t}class t{constructor(e){
+void 0===e.data&&(e.data={}),this.data=e.data,this.isMatchIgnored=!1}
+ignoreMatch(){this.isMatchIgnored=!0}}function n(e){
+return e.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")
+}function i(e,...t){const n=Object.create(null);for(const t in e)n[t]=e[t]
+;return t.forEach((e=>{for(const t in e)n[t]=e[t]})),n}const s=e=>!!e.scope
+;class r{constructor(e,t){
+this.buffer="",this.classPrefix=t.classPrefix,e.walk(this)}addText(e){
+this.buffer+=n(e)}openNode(e){if(!s(e))return;const t=((e,{prefix:t})=>{
+if(e.startsWith("language:"))return e.replace("language:","language-")
+;if(e.includes(".")){const n=e.split(".")
+;return[`${t}${n.shift()}`,...n.map(((e,t)=>`${e}${"_".repeat(t+1)}`))].join(" ")
+}return`${t}${e}`})(e.scope,{prefix:this.classPrefix});this.span(t)}
+closeNode(e){s(e)&&(this.buffer+="")}value(){return this.buffer}span(e){
+this.buffer+=``}}const o=(e={})=>{const t={children:[]}
+;return Object.assign(t,e),t};class a{constructor(){
+this.rootNode=o(),this.stack=[this.rootNode]}get top(){
+return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(e){
+this.top.children.push(e)}openNode(e){const t=o({scope:e})
+;this.add(t),this.stack.push(t)}closeNode(){
+if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){
+for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}
+walk(e){return this.constructor._walk(e,this.rootNode)}static _walk(e,t){
+return"string"==typeof t?e.addText(t):t.children&&(e.openNode(t),
+t.children.forEach((t=>this._walk(e,t))),e.closeNode(t)),e}static _collapse(e){
+"string"!=typeof e&&e.children&&(e.children.every((e=>"string"==typeof e))?e.children=[e.children.join("")]:e.children.forEach((e=>{
+a._collapse(e)})))}}class c extends a{constructor(e){super(),this.options=e}
+addText(e){""!==e&&this.add(e)}startScope(e){this.openNode(e)}endScope(){
+this.closeNode()}__addSublanguage(e,t){const n=e.root
+;t&&(n.scope="language:"+t),this.add(n)}toHTML(){
+return new r(this,this.options).value()}finalize(){
+return this.closeAllNodes(),!0}}function l(e){
+return e?"string"==typeof e?e:e.source:null}function g(e){return h("(?=",e,")")}
+function u(e){return h("(?:",e,")*")}function d(e){return h("(?:",e,")?")}
+function h(...e){return e.map((e=>l(e))).join("")}function f(...e){const t=(e=>{
+const t=e[e.length-1]
+;return"object"==typeof t&&t.constructor===Object?(e.splice(e.length-1,1),t):{}
+})(e);return"("+(t.capture?"":"?:")+e.map((e=>l(e))).join("|")+")"}
+function p(e){return RegExp(e.toString()+"|").exec("").length-1}
+const b=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
+;function m(e,{joinWith:t}){let n=0;return e.map((e=>{n+=1;const t=n
+;let i=l(e),s="";for(;i.length>0;){const e=b.exec(i);if(!e){s+=i;break}
+s+=i.substring(0,e.index),
+i=i.substring(e.index+e[0].length),"\\"===e[0][0]&&e[1]?s+="\\"+(Number(e[1])+t):(s+=e[0],
+"("===e[0]&&n++)}return s})).map((e=>`(${e})`)).join(t)}
+const E="[a-zA-Z]\\w*",x="[a-zA-Z_]\\w*",w="\\b\\d+(\\.\\d+)?",y="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",_="\\b(0b[01]+)",O={
+begin:"\\\\[\\s\\S]",relevance:0},k={scope:"string",begin:"'",end:"'",
+illegal:"\\n",contains:[O]},v={scope:"string",begin:'"',end:'"',illegal:"\\n",
+contains:[O]},N=(e,t,n={})=>{const s=i({scope:"comment",begin:e,end:t,
+contains:[]},n);s.contains.push({scope:"doctag",
+begin:"[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+end:/(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,excludeBegin:!0,relevance:0})
+;const r=f("I","a","is","so","us","to","at","if","in","it","on",/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,/[A-Za-z]+[-][a-z]+/,/[A-Za-z][a-z]{2,}/)
+;return s.contains.push({begin:h(/[ ]+/,"(",r,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),s
+},S=N("//","$"),M=N("/\\*","\\*/"),R=N("#","$");var A=Object.freeze({
+__proto__:null,APOS_STRING_MODE:k,BACKSLASH_ESCAPE:O,BINARY_NUMBER_MODE:{
+scope:"number",begin:_,relevance:0},BINARY_NUMBER_RE:_,COMMENT:N,
+C_BLOCK_COMMENT_MODE:M,C_LINE_COMMENT_MODE:S,C_NUMBER_MODE:{scope:"number",
+begin:y,relevance:0},C_NUMBER_RE:y,END_SAME_AS_BEGIN:e=>Object.assign(e,{
+"on:begin":(e,t)=>{t.data._beginMatch=e[1]},"on:end":(e,t)=>{
+t.data._beginMatch!==e[1]&&t.ignoreMatch()}}),HASH_COMMENT_MODE:R,IDENT_RE:E,
+MATCH_NOTHING_RE:/\b\B/,METHOD_GUARD:{begin:"\\.\\s*"+x,relevance:0},
+NUMBER_MODE:{scope:"number",begin:w,relevance:0},NUMBER_RE:w,
+PHRASAL_WORDS_MODE:{
+begin:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+},QUOTE_STRING_MODE:v,REGEXP_MODE:{scope:"regexp",begin:/\/(?=[^/\n]*\/)/,
+end:/\/[gimuy]*/,contains:[O,{begin:/\[/,end:/\]/,relevance:0,contains:[O]}]},
+RE_STARTERS_RE:"!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
+SHEBANG:(e={})=>{const t=/^#![ ]*\//
+;return e.binary&&(e.begin=h(t,/.*\b/,e.binary,/\b.*/)),i({scope:"meta",begin:t,
+end:/$/,relevance:0,"on:begin":(e,t)=>{0!==e.index&&t.ignoreMatch()}},e)},
+TITLE_MODE:{scope:"title",begin:E,relevance:0},UNDERSCORE_IDENT_RE:x,
+UNDERSCORE_TITLE_MODE:{scope:"title",begin:x,relevance:0}});function j(e,t){
+"."===e.input[e.index-1]&&t.ignoreMatch()}function I(e,t){
+void 0!==e.className&&(e.scope=e.className,delete e.className)}function T(e,t){
+t&&e.beginKeywords&&(e.begin="\\b("+e.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",
+e.__beforeBegin=j,e.keywords=e.keywords||e.beginKeywords,delete e.beginKeywords,
+void 0===e.relevance&&(e.relevance=0))}function L(e,t){
+Array.isArray(e.illegal)&&(e.illegal=f(...e.illegal))}function B(e,t){
+if(e.match){
+if(e.begin||e.end)throw Error("begin & end are not supported with match")
+;e.begin=e.match,delete e.match}}function P(e,t){
+void 0===e.relevance&&(e.relevance=1)}const D=(e,t)=>{if(!e.beforeMatch)return
+;if(e.starts)throw Error("beforeMatch cannot be used with starts")
+;const n=Object.assign({},e);Object.keys(e).forEach((t=>{delete e[t]
+})),e.keywords=n.keywords,e.begin=h(n.beforeMatch,g(n.begin)),e.starts={
+relevance:0,contains:[Object.assign(n,{endsParent:!0})]
+},e.relevance=0,delete n.beforeMatch
+},H=["of","and","for","in","not","or","if","then","parent","list","value"],C="keyword"
+;function $(e,t,n=C){const i=Object.create(null)
+;return"string"==typeof e?s(n,e.split(" ")):Array.isArray(e)?s(n,e):Object.keys(e).forEach((n=>{
+Object.assign(i,$(e[n],t,n))})),i;function s(e,n){
+t&&(n=n.map((e=>e.toLowerCase()))),n.forEach((t=>{const n=t.split("|")
+;i[n[0]]=[e,U(n[0],n[1])]}))}}function U(e,t){
+return t?Number(t):(e=>H.includes(e.toLowerCase()))(e)?0:1}const z={},W=e=>{
+console.error(e)},X=(e,...t)=>{console.log("WARN: "+e,...t)},G=(e,t)=>{
+z[`${e}/${t}`]||(console.log(`Deprecated as of ${e}. ${t}`),z[`${e}/${t}`]=!0)
+},K=Error();function F(e,t,{key:n}){let i=0;const s=e[n],r={},o={}
+;for(let e=1;e<=t.length;e++)o[e+i]=s[e],r[e+i]=!0,i+=p(t[e-1])
+;e[n]=o,e[n]._emit=r,e[n]._multi=!0}function Z(e){(e=>{
+e.scope&&"object"==typeof e.scope&&null!==e.scope&&(e.beginScope=e.scope,
+delete e.scope)})(e),"string"==typeof e.beginScope&&(e.beginScope={
+_wrap:e.beginScope}),"string"==typeof e.endScope&&(e.endScope={_wrap:e.endScope
+}),(e=>{if(Array.isArray(e.begin)){
+if(e.skip||e.excludeBegin||e.returnBegin)throw W("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
+K
+;if("object"!=typeof e.beginScope||null===e.beginScope)throw W("beginScope must be object"),
+K;F(e,e.begin,{key:"beginScope"}),e.begin=m(e.begin,{joinWith:""})}})(e),(e=>{
+if(Array.isArray(e.end)){
+if(e.skip||e.excludeEnd||e.returnEnd)throw W("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
+K
+;if("object"!=typeof e.endScope||null===e.endScope)throw W("endScope must be object"),
+K;F(e,e.end,{key:"endScope"}),e.end=m(e.end,{joinWith:""})}})(e)}function V(e){
+function t(t,n){
+return RegExp(l(t),"m"+(e.case_insensitive?"i":"")+(e.unicodeRegex?"u":"")+(n?"g":""))
+}class n{constructor(){
+this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}
+addRule(e,t){
+t.position=this.position++,this.matchIndexes[this.matchAt]=t,this.regexes.push([t,e]),
+this.matchAt+=p(e)+1}compile(){0===this.regexes.length&&(this.exec=()=>null)
+;const e=this.regexes.map((e=>e[1]));this.matcherRe=t(m(e,{joinWith:"|"
+}),!0),this.lastIndex=0}exec(e){this.matcherRe.lastIndex=this.lastIndex
+;const t=this.matcherRe.exec(e);if(!t)return null
+;const n=t.findIndex(((e,t)=>t>0&&void 0!==e)),i=this.matchIndexes[n]
+;return t.splice(0,n),Object.assign(t,i)}}class s{constructor(){
+this.rules=[],this.multiRegexes=[],
+this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(e){
+if(this.multiRegexes[e])return this.multiRegexes[e];const t=new n
+;return this.rules.slice(e).forEach((([e,n])=>t.addRule(e,n))),
+t.compile(),this.multiRegexes[e]=t,t}resumingScanAtSamePosition(){
+return 0!==this.regexIndex}considerAll(){this.regexIndex=0}addRule(e,t){
+this.rules.push([e,t]),"begin"===t.type&&this.count++}exec(e){
+const t=this.getMatcher(this.regexIndex);t.lastIndex=this.lastIndex
+;let n=t.exec(e)
+;if(this.resumingScanAtSamePosition())if(n&&n.index===this.lastIndex);else{
+const t=this.getMatcher(0);t.lastIndex=this.lastIndex+1,n=t.exec(e)}
+return n&&(this.regexIndex+=n.position+1,
+this.regexIndex===this.count&&this.considerAll()),n}}
+if(e.compilerExtensions||(e.compilerExtensions=[]),
+e.contains&&e.contains.includes("self"))throw Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.")
+;return e.classNameAliases=i(e.classNameAliases||{}),function n(r,o){const a=r
+;if(r.isCompiled)return a
+;[I,B,Z,D].forEach((e=>e(r,o))),e.compilerExtensions.forEach((e=>e(r,o))),
+r.__beforeBegin=null,[T,L,P].forEach((e=>e(r,o))),r.isCompiled=!0;let c=null
+;return"object"==typeof r.keywords&&r.keywords.$pattern&&(r.keywords=Object.assign({},r.keywords),
+c=r.keywords.$pattern,
+delete r.keywords.$pattern),c=c||/\w+/,r.keywords&&(r.keywords=$(r.keywords,e.case_insensitive)),
+a.keywordPatternRe=t(c,!0),
+o&&(r.begin||(r.begin=/\B|\b/),a.beginRe=t(a.begin),r.end||r.endsWithParent||(r.end=/\B|\b/),
+r.end&&(a.endRe=t(a.end)),
+a.terminatorEnd=l(a.end)||"",r.endsWithParent&&o.terminatorEnd&&(a.terminatorEnd+=(r.end?"|":"")+o.terminatorEnd)),
+r.illegal&&(a.illegalRe=t(r.illegal)),
+r.contains||(r.contains=[]),r.contains=[].concat(...r.contains.map((e=>(e=>(e.variants&&!e.cachedVariants&&(e.cachedVariants=e.variants.map((t=>i(e,{
+variants:null},t)))),e.cachedVariants?e.cachedVariants:q(e)?i(e,{
+starts:e.starts?i(e.starts):null
+}):Object.isFrozen(e)?i(e):e))("self"===e?r:e)))),r.contains.forEach((e=>{n(e,a)
+})),r.starts&&n(r.starts,o),a.matcher=(e=>{const t=new s
+;return e.contains.forEach((e=>t.addRule(e.begin,{rule:e,type:"begin"
+}))),e.terminatorEnd&&t.addRule(e.terminatorEnd,{type:"end"
+}),e.illegal&&t.addRule(e.illegal,{type:"illegal"}),t})(a),a}(e)}function q(e){
+return!!e&&(e.endsWithParent||q(e.starts))}class J extends Error{
+constructor(e,t){super(e),this.name="HTMLInjectionError",this.html=t}}
+const Y=n,Q=i,ee=Symbol("nomatch"),te=n=>{
+const i=Object.create(null),s=Object.create(null),r=[];let o=!0
+;const a="Could not find the language '{}', did you forget to load/include a language module?",l={
+disableAutodetect:!0,name:"Plain text",contains:[]};let p={
+ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,
+languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",
+cssSelector:"pre code",languages:null,__emitter:c};function b(e){
+return p.noHighlightRe.test(e)}function m(e,t,n){let i="",s=""
+;"object"==typeof t?(i=e,
+n=t.ignoreIllegals,s=t.language):(G("10.7.0","highlight(lang, code, ...args) has been deprecated."),
+G("10.7.0","Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),
+s=e,i=t),void 0===n&&(n=!0);const r={code:i,language:s};N("before:highlight",r)
+;const o=r.result?r.result:E(r.language,r.code,n)
+;return o.code=r.code,N("after:highlight",o),o}function E(e,n,s,r){
+const c=Object.create(null);function l(){if(!N.keywords)return void M.addText(R)
+;let e=0;N.keywordPatternRe.lastIndex=0;let t=N.keywordPatternRe.exec(R),n=""
+;for(;t;){n+=R.substring(e,t.index)
+;const s=_.case_insensitive?t[0].toLowerCase():t[0],r=(i=s,N.keywords[i]);if(r){
+const[e,i]=r
+;if(M.addText(n),n="",c[s]=(c[s]||0)+1,c[s]<=7&&(A+=i),e.startsWith("_"))n+=t[0];else{
+const n=_.classNameAliases[e]||e;u(t[0],n)}}else n+=t[0]
+;e=N.keywordPatternRe.lastIndex,t=N.keywordPatternRe.exec(R)}var i
+;n+=R.substring(e),M.addText(n)}function g(){null!=N.subLanguage?(()=>{
+if(""===R)return;let e=null;if("string"==typeof N.subLanguage){
+if(!i[N.subLanguage])return void M.addText(R)
+;e=E(N.subLanguage,R,!0,S[N.subLanguage]),S[N.subLanguage]=e._top
+}else e=x(R,N.subLanguage.length?N.subLanguage:null)
+;N.relevance>0&&(A+=e.relevance),M.__addSublanguage(e._emitter,e.language)
+})():l(),R=""}function u(e,t){
+""!==e&&(M.startScope(t),M.addText(e),M.endScope())}function d(e,t){let n=1
+;const i=t.length-1;for(;n<=i;){if(!e._emit[n]){n++;continue}
+const i=_.classNameAliases[e[n]]||e[n],s=t[n];i?u(s,i):(R=s,l(),R=""),n++}}
+function h(e,t){
+return e.scope&&"string"==typeof e.scope&&M.openNode(_.classNameAliases[e.scope]||e.scope),
+e.beginScope&&(e.beginScope._wrap?(u(R,_.classNameAliases[e.beginScope._wrap]||e.beginScope._wrap),
+R=""):e.beginScope._multi&&(d(e.beginScope,t),R="")),N=Object.create(e,{parent:{
+value:N}}),N}function f(e,n,i){let s=((e,t)=>{const n=e&&e.exec(t)
+;return n&&0===n.index})(e.endRe,i);if(s){if(e["on:end"]){const i=new t(e)
+;e["on:end"](n,i),i.isMatchIgnored&&(s=!1)}if(s){
+for(;e.endsParent&&e.parent;)e=e.parent;return e}}
+if(e.endsWithParent)return f(e.parent,n,i)}function b(e){
+return 0===N.matcher.regexIndex?(R+=e[0],1):(T=!0,0)}function m(e){
+const t=e[0],i=n.substring(e.index),s=f(N,e,i);if(!s)return ee;const r=N
+;N.endScope&&N.endScope._wrap?(g(),
+u(t,N.endScope._wrap)):N.endScope&&N.endScope._multi?(g(),
+d(N.endScope,e)):r.skip?R+=t:(r.returnEnd||r.excludeEnd||(R+=t),
+g(),r.excludeEnd&&(R=t));do{
+N.scope&&M.closeNode(),N.skip||N.subLanguage||(A+=N.relevance),N=N.parent
+}while(N!==s.parent);return s.starts&&h(s.starts,e),r.returnEnd?0:t.length}
+let w={};function y(i,r){const a=r&&r[0];if(R+=i,null==a)return g(),0
+;if("begin"===w.type&&"end"===r.type&&w.index===r.index&&""===a){
+if(R+=n.slice(r.index,r.index+1),!o){const t=Error(`0 width match regex (${e})`)
+;throw t.languageName=e,t.badRule=w.rule,t}return 1}
+if(w=r,"begin"===r.type)return(e=>{
+const n=e[0],i=e.rule,s=new t(i),r=[i.__beforeBegin,i["on:begin"]]
+;for(const t of r)if(t&&(t(e,s),s.isMatchIgnored))return b(n)
+;return i.skip?R+=n:(i.excludeBegin&&(R+=n),
+g(),i.returnBegin||i.excludeBegin||(R=n)),h(i,e),i.returnBegin?0:n.length})(r)
+;if("illegal"===r.type&&!s){
+const e=Error('Illegal lexeme "'+a+'" for mode "'+(N.scope||"")+'"')
+;throw e.mode=N,e}if("end"===r.type){const e=m(r);if(e!==ee)return e}
+if("illegal"===r.type&&""===a)return 1
+;if(I>1e5&&I>3*r.index)throw Error("potential infinite loop, way more iterations than matches")
+;return R+=a,a.length}const _=O(e)
+;if(!_)throw W(a.replace("{}",e)),Error('Unknown language: "'+e+'"')
+;const k=V(_);let v="",N=r||k;const S={},M=new p.__emitter(p);(()=>{const e=[]
+;for(let t=N;t!==_;t=t.parent)t.scope&&e.unshift(t.scope)
+;e.forEach((e=>M.openNode(e)))})();let R="",A=0,j=0,I=0,T=!1;try{
+if(_.__emitTokens)_.__emitTokens(n,M);else{for(N.matcher.considerAll();;){
+I++,T?T=!1:N.matcher.considerAll(),N.matcher.lastIndex=j
+;const e=N.matcher.exec(n);if(!e)break;const t=y(n.substring(j,e.index),e)
+;j=e.index+t}y(n.substring(j))}return M.finalize(),v=M.toHTML(),{language:e,
+value:v,relevance:A,illegal:!1,_emitter:M,_top:N}}catch(t){
+if(t.message&&t.message.includes("Illegal"))return{language:e,value:Y(n),
+illegal:!0,relevance:0,_illegalBy:{message:t.message,index:j,
+context:n.slice(j-100,j+100),mode:t.mode,resultSoFar:v},_emitter:M};if(o)return{
+language:e,value:Y(n),illegal:!1,relevance:0,errorRaised:t,_emitter:M,_top:N}
+;throw t}}function x(e,t){t=t||p.languages||Object.keys(i);const n=(e=>{
+const t={value:Y(e),illegal:!1,relevance:0,_top:l,_emitter:new p.__emitter(p)}
+;return t._emitter.addText(e),t})(e),s=t.filter(O).filter(v).map((t=>E(t,e,!1)))
+;s.unshift(n);const r=s.sort(((e,t)=>{
+if(e.relevance!==t.relevance)return t.relevance-e.relevance
+;if(e.language&&t.language){if(O(e.language).supersetOf===t.language)return 1
+;if(O(t.language).supersetOf===e.language)return-1}return 0})),[o,a]=r,c=o
+;return c.secondBest=a,c}function w(e){let t=null;const n=(e=>{
+let t=e.className+" ";t+=e.parentNode?e.parentNode.className:""
+;const n=p.languageDetectRe.exec(t);if(n){const t=O(n[1])
+;return t||(X(a.replace("{}",n[1])),
+X("Falling back to no-highlight mode for this block.",e)),t?n[1]:"no-highlight"}
+return t.split(/\s+/).find((e=>b(e)||O(e)))})(e);if(b(n))return
+;if(N("before:highlightElement",{el:e,language:n
+}),e.dataset.highlighted)return void console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",e)
+;if(e.children.length>0&&(p.ignoreUnescapedHTML||(console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),
+console.warn("https://github.com/highlightjs/highlight.js/wiki/security"),
+console.warn("The element with unescaped HTML:"),
+console.warn(e)),p.throwUnescapedHTML))throw new J("One of your code blocks includes unescaped HTML.",e.innerHTML)
+;t=e;const i=t.textContent,r=n?m(i,{language:n,ignoreIllegals:!0}):x(i)
+;e.innerHTML=r.value,e.dataset.highlighted="yes",((e,t,n)=>{const i=t&&s[t]||n
+;e.classList.add("hljs"),e.classList.add("language-"+i)
+})(e,n,r.language),e.result={language:r.language,re:r.relevance,
+relevance:r.relevance},r.secondBest&&(e.secondBest={
+language:r.secondBest.language,relevance:r.secondBest.relevance
+}),N("after:highlightElement",{el:e,result:r,text:i})}let y=!1;function _(){
+"loading"!==document.readyState?document.querySelectorAll(p.cssSelector).forEach(w):y=!0
+}function O(e){return e=(e||"").toLowerCase(),i[e]||i[s[e]]}
+function k(e,{languageName:t}){"string"==typeof e&&(e=[e]),e.forEach((e=>{
+s[e.toLowerCase()]=t}))}function v(e){const t=O(e)
+;return t&&!t.disableAutodetect}function N(e,t){const n=e;r.forEach((e=>{
+e[n]&&e[n](t)}))}
+"undefined"!=typeof window&&window.addEventListener&&window.addEventListener("DOMContentLoaded",(()=>{
+y&&_()}),!1),Object.assign(n,{highlight:m,highlightAuto:x,highlightAll:_,
+highlightElement:w,
+highlightBlock:e=>(G("10.7.0","highlightBlock will be removed entirely in v12.0"),
+G("10.7.0","Please use highlightElement now."),w(e)),configure:e=>{p=Q(p,e)},
+initHighlighting:()=>{
+_(),G("10.6.0","initHighlighting() deprecated. Use highlightAll() now.")},
+initHighlightingOnLoad:()=>{
+_(),G("10.6.0","initHighlightingOnLoad() deprecated. Use highlightAll() now.")
+},registerLanguage:(e,t)=>{let s=null;try{s=t(n)}catch(t){
+if(W("Language definition for '{}' could not be registered.".replace("{}",e)),
+!o)throw t;W(t),s=l}
+s.name||(s.name=e),i[e]=s,s.rawDefinition=t.bind(null,n),s.aliases&&k(s.aliases,{
+languageName:e})},unregisterLanguage:e=>{delete i[e]
+;for(const t of Object.keys(s))s[t]===e&&delete s[t]},
+listLanguages:()=>Object.keys(i),getLanguage:O,registerAliases:k,
+autoDetection:v,inherit:Q,addPlugin:e=>{(e=>{
+e["before:highlightBlock"]&&!e["before:highlightElement"]&&(e["before:highlightElement"]=t=>{
+e["before:highlightBlock"](Object.assign({block:t.el},t))
+}),e["after:highlightBlock"]&&!e["after:highlightElement"]&&(e["after:highlightElement"]=t=>{
+e["after:highlightBlock"](Object.assign({block:t.el},t))})})(e),r.push(e)},
+removePlugin:e=>{const t=r.indexOf(e);-1!==t&&r.splice(t,1)}}),n.debugMode=()=>{
+o=!1},n.safeMode=()=>{o=!0},n.versionString="11.9.0",n.regex={concat:h,
+lookahead:g,either:f,optional:d,anyNumberOfTimes:u}
+;for(const t in A)"object"==typeof A[t]&&e(A[t]);return Object.assign(n,A),n
+},ne=te({});ne.newInstance=()=>te({});export{ne as default};
\ No newline at end of file
diff --git a/templates/hljs/es/highlight.js b/templates/hljs/es/highlight.js
new file mode 100644
index 0000000..7294b81
--- /dev/null
+++ b/templates/hljs/es/highlight.js
@@ -0,0 +1,2600 @@
+/*!
+ Highlight.js v11.9.0 (git: b7ec4bfafc)
+ (c) 2006-2023 undefined and other contributors
+ License: BSD-3-Clause
+ */
+/* eslint-disable no-multi-assign */
+
+function deepFreeze(obj) {
+ if (obj instanceof Map) {
+ obj.clear =
+ obj.delete =
+ obj.set =
+ function () {
+ throw new Error('map is read-only');
+ };
+ } else if (obj instanceof Set) {
+ obj.add =
+ obj.clear =
+ obj.delete =
+ function () {
+ throw new Error('set is read-only');
+ };
+ }
+
+ // Freeze self
+ Object.freeze(obj);
+
+ Object.getOwnPropertyNames(obj).forEach((name) => {
+ const prop = obj[name];
+ const type = typeof prop;
+
+ // Freeze prop if it is an object or function and also not already frozen
+ if ((type === 'object' || type === 'function') && !Object.isFrozen(prop)) {
+ deepFreeze(prop);
+ }
+ });
+
+ return obj;
+}
+
+/** @typedef {import('highlight.js').CallbackResponse} CallbackResponse */
+/** @typedef {import('highlight.js').CompiledMode} CompiledMode */
+/** @implements CallbackResponse */
+
+class Response {
+ /**
+ * @param {CompiledMode} mode
+ */
+ constructor(mode) {
+ // eslint-disable-next-line no-undefined
+ if (mode.data === undefined) mode.data = {};
+
+ this.data = mode.data;
+ this.isMatchIgnored = false;
+ }
+
+ ignoreMatch() {
+ this.isMatchIgnored = true;
+ }
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function escapeHTML(value) {
+ return value
+ .replace(/&/g, '&')
+ .replace(//g, '>')
+ .replace(/"/g, '"')
+ .replace(/'/g, ''');
+}
+
+/**
+ * performs a shallow merge of multiple objects into one
+ *
+ * @template T
+ * @param {T} original
+ * @param {Record[]} objects
+ * @returns {T} a single new object
+ */
+function inherit$1(original, ...objects) {
+ /** @type Record */
+ const result = Object.create(null);
+
+ for (const key in original) {
+ result[key] = original[key];
+ }
+ objects.forEach(function(obj) {
+ for (const key in obj) {
+ result[key] = obj[key];
+ }
+ });
+ return /** @type {T} */ (result);
+}
+
+/**
+ * @typedef {object} Renderer
+ * @property {(text: string) => void} addText
+ * @property {(node: Node) => void} openNode
+ * @property {(node: Node) => void} closeNode
+ * @property {() => string} value
+ */
+
+/** @typedef {{scope?: string, language?: string, sublanguage?: boolean}} Node */
+/** @typedef {{walk: (r: Renderer) => void}} Tree */
+/** */
+
+const SPAN_CLOSE = '';
+
+/**
+ * Determines if a node needs to be wrapped in
+ *
+ * @param {Node} node */
+const emitsWrappingTags = (node) => {
+ // rarely we can have a sublanguage where language is undefined
+ // TODO: track down why
+ return !!node.scope;
+};
+
+/**
+ *
+ * @param {string} name
+ * @param {{prefix:string}} options
+ */
+const scopeToCSSClass = (name, { prefix }) => {
+ // sub-language
+ if (name.startsWith("language:")) {
+ return name.replace("language:", "language-");
+ }
+ // tiered scope: comment.line
+ if (name.includes(".")) {
+ const pieces = name.split(".");
+ return [
+ `${prefix}${pieces.shift()}`,
+ ...(pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`))
+ ].join(" ");
+ }
+ // simple scope
+ return `${prefix}${name}`;
+};
+
+/** @type {Renderer} */
+class HTMLRenderer {
+ /**
+ * Creates a new HTMLRenderer
+ *
+ * @param {Tree} parseTree - the parse tree (must support `walk` API)
+ * @param {{classPrefix: string}} options
+ */
+ constructor(parseTree, options) {
+ this.buffer = "";
+ this.classPrefix = options.classPrefix;
+ parseTree.walk(this);
+ }
+
+ /**
+ * Adds texts to the output stream
+ *
+ * @param {string} text */
+ addText(text) {
+ this.buffer += escapeHTML(text);
+ }
+
+ /**
+ * Adds a node open to the output stream (if needed)
+ *
+ * @param {Node} node */
+ openNode(node) {
+ if (!emitsWrappingTags(node)) return;
+
+ const className = scopeToCSSClass(node.scope,
+ { prefix: this.classPrefix });
+ this.span(className);
+ }
+
+ /**
+ * Adds a node close to the output stream (if needed)
+ *
+ * @param {Node} node */
+ closeNode(node) {
+ if (!emitsWrappingTags(node)) return;
+
+ this.buffer += SPAN_CLOSE;
+ }
+
+ /**
+ * returns the accumulated buffer
+ */
+ value() {
+ return this.buffer;
+ }
+
+ // helpers
+
+ /**
+ * Builds a span element
+ *
+ * @param {string} className */
+ span(className) {
+ this.buffer += ``;
+ }
+}
+
+/** @typedef {{scope?: string, language?: string, children: Node[]} | string} Node */
+/** @typedef {{scope?: string, language?: string, children: Node[]} } DataNode */
+/** @typedef {import('highlight.js').Emitter} Emitter */
+/** */
+
+/** @returns {DataNode} */
+const newNode = (opts = {}) => {
+ /** @type DataNode */
+ const result = { children: [] };
+ Object.assign(result, opts);
+ return result;
+};
+
+class TokenTree {
+ constructor() {
+ /** @type DataNode */
+ this.rootNode = newNode();
+ this.stack = [this.rootNode];
+ }
+
+ get top() {
+ return this.stack[this.stack.length - 1];
+ }
+
+ get root() { return this.rootNode; }
+
+ /** @param {Node} node */
+ add(node) {
+ this.top.children.push(node);
+ }
+
+ /** @param {string} scope */
+ openNode(scope) {
+ /** @type Node */
+ const node = newNode({ scope });
+ this.add(node);
+ this.stack.push(node);
+ }
+
+ closeNode() {
+ if (this.stack.length > 1) {
+ return this.stack.pop();
+ }
+ // eslint-disable-next-line no-undefined
+ return undefined;
+ }
+
+ closeAllNodes() {
+ while (this.closeNode());
+ }
+
+ toJSON() {
+ return JSON.stringify(this.rootNode, null, 4);
+ }
+
+ /**
+ * @typedef { import("./html_renderer").Renderer } Renderer
+ * @param {Renderer} builder
+ */
+ walk(builder) {
+ // this does not
+ return this.constructor._walk(builder, this.rootNode);
+ // this works
+ // return TokenTree._walk(builder, this.rootNode);
+ }
+
+ /**
+ * @param {Renderer} builder
+ * @param {Node} node
+ */
+ static _walk(builder, node) {
+ if (typeof node === "string") {
+ builder.addText(node);
+ } else if (node.children) {
+ builder.openNode(node);
+ node.children.forEach((child) => this._walk(builder, child));
+ builder.closeNode(node);
+ }
+ return builder;
+ }
+
+ /**
+ * @param {Node} node
+ */
+ static _collapse(node) {
+ if (typeof node === "string") return;
+ if (!node.children) return;
+
+ if (node.children.every(el => typeof el === "string")) {
+ // node.text = node.children.join("");
+ // delete node.children;
+ node.children = [node.children.join("")];
+ } else {
+ node.children.forEach((child) => {
+ TokenTree._collapse(child);
+ });
+ }
+ }
+}
+
+/**
+ Currently this is all private API, but this is the minimal API necessary
+ that an Emitter must implement to fully support the parser.
+
+ Minimal interface:
+
+ - addText(text)
+ - __addSublanguage(emitter, subLanguageName)
+ - startScope(scope)
+ - endScope()
+ - finalize()
+ - toHTML()
+
+*/
+
+/**
+ * @implements {Emitter}
+ */
+class TokenTreeEmitter extends TokenTree {
+ /**
+ * @param {*} options
+ */
+ constructor(options) {
+ super();
+ this.options = options;
+ }
+
+ /**
+ * @param {string} text
+ */
+ addText(text) {
+ if (text === "") { return; }
+
+ this.add(text);
+ }
+
+ /** @param {string} scope */
+ startScope(scope) {
+ this.openNode(scope);
+ }
+
+ endScope() {
+ this.closeNode();
+ }
+
+ /**
+ * @param {Emitter & {root: DataNode}} emitter
+ * @param {string} name
+ */
+ __addSublanguage(emitter, name) {
+ /** @type DataNode */
+ const node = emitter.root;
+ if (name) node.scope = `language:${name}`;
+
+ this.add(node);
+ }
+
+ toHTML() {
+ const renderer = new HTMLRenderer(this, this.options);
+ return renderer.value();
+ }
+
+ finalize() {
+ this.closeAllNodes();
+ return true;
+ }
+}
+
+/**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function source(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function lookahead(re) {
+ return concat('(?=', re, ')');
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function anyNumberOfTimes(re) {
+ return concat('(?:', re, ')*');
+}
+
+/**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+function optional(re) {
+ return concat('(?:', re, ')?');
+}
+
+/**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+function concat(...args) {
+ const joined = args.map((x) => source(x)).join("");
+ return joined;
+}
+
+/**
+ * @param { Array } args
+ * @returns {object}
+ */
+function stripOptionsFromArgs(args) {
+ const opts = args[args.length - 1];
+
+ if (typeof opts === 'object' && opts.constructor === Object) {
+ args.splice(args.length - 1, 1);
+ return opts;
+ } else {
+ return {};
+ }
+}
+
+/** @typedef { {capture?: boolean} } RegexEitherOptions */
+
+/**
+ * Any of the passed expresssions may match
+ *
+ * Creates a huge this | this | that | that match
+ * @param {(RegExp | string)[] | [...(RegExp | string)[], RegexEitherOptions]} args
+ * @returns {string}
+ */
+function either(...args) {
+ /** @type { object & {capture?: boolean} } */
+ const opts = stripOptionsFromArgs(args);
+ const joined = '('
+ + (opts.capture ? "" : "?:")
+ + args.map((x) => source(x)).join("|") + ")";
+ return joined;
+}
+
+/**
+ * @param {RegExp | string} re
+ * @returns {number}
+ */
+function countMatchGroups(re) {
+ return (new RegExp(re.toString() + '|')).exec('').length - 1;
+}
+
+/**
+ * Does lexeme start with a regular expression match at the beginning
+ * @param {RegExp} re
+ * @param {string} lexeme
+ */
+function startsWith(re, lexeme) {
+ const match = re && re.exec(lexeme);
+ return match && match.index === 0;
+}
+
+// BACKREF_RE matches an open parenthesis or backreference. To avoid
+// an incorrect parse, it additionally matches the following:
+// - [...] elements, where the meaning of parentheses and escapes change
+// - other escape sequences, so we do not misparse escape sequences as
+// interesting elements
+// - non-matching or lookahead parentheses, which do not capture. These
+// follow the '(' with a '?'.
+const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+
+// **INTERNAL** Not intended for outside usage
+// join logically computes regexps.join(separator), but fixes the
+// backreferences so they continue to match.
+// it also places each individual regular expression into it's own
+// match group, keeping track of the sequencing of those match groups
+// is currently an exercise for the caller. :-)
+/**
+ * @param {(string | RegExp)[]} regexps
+ * @param {{joinWith: string}} opts
+ * @returns {string}
+ */
+function _rewriteBackreferences(regexps, { joinWith }) {
+ let numCaptures = 0;
+
+ return regexps.map((regex) => {
+ numCaptures += 1;
+ const offset = numCaptures;
+ let re = source(regex);
+ let out = '';
+
+ while (re.length > 0) {
+ const match = BACKREF_RE.exec(re);
+ if (!match) {
+ out += re;
+ break;
+ }
+ out += re.substring(0, match.index);
+ re = re.substring(match.index + match[0].length);
+ if (match[0][0] === '\\' && match[1]) {
+ // Adjust the backreference.
+ out += '\\' + String(Number(match[1]) + offset);
+ } else {
+ out += match[0];
+ if (match[0] === '(') {
+ numCaptures++;
+ }
+ }
+ }
+ return out;
+ }).map(re => `(${re})`).join(joinWith);
+}
+
+/** @typedef {import('highlight.js').Mode} Mode */
+/** @typedef {import('highlight.js').ModeCallback} ModeCallback */
+
+// Common regexps
+const MATCH_NOTHING_RE = /\b\B/;
+const IDENT_RE = '[a-zA-Z]\\w*';
+const UNDERSCORE_IDENT_RE = '[a-zA-Z_]\\w*';
+const NUMBER_RE = '\\b\\d+(\\.\\d+)?';
+const C_NUMBER_RE = '(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
+const BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
+const RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';
+
+/**
+* @param { Partial & {binary?: string | RegExp} } opts
+*/
+const SHEBANG = (opts = {}) => {
+ const beginShebang = /^#![ ]*\//;
+ if (opts.binary) {
+ opts.begin = concat(
+ beginShebang,
+ /.*\b/,
+ opts.binary,
+ /\b.*/);
+ }
+ return inherit$1({
+ scope: 'meta',
+ begin: beginShebang,
+ end: /$/,
+ relevance: 0,
+ /** @type {ModeCallback} */
+ "on:begin": (m, resp) => {
+ if (m.index !== 0) resp.ignoreMatch();
+ }
+ }, opts);
+};
+
+// Common modes
+const BACKSLASH_ESCAPE = {
+ begin: '\\\\[\\s\\S]', relevance: 0
+};
+const APOS_STRING_MODE = {
+ scope: 'string',
+ begin: '\'',
+ end: '\'',
+ illegal: '\\n',
+ contains: [BACKSLASH_ESCAPE]
+};
+const QUOTE_STRING_MODE = {
+ scope: 'string',
+ begin: '"',
+ end: '"',
+ illegal: '\\n',
+ contains: [BACKSLASH_ESCAPE]
+};
+const PHRASAL_WORDS_MODE = {
+ begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+};
+/**
+ * Creates a comment mode
+ *
+ * @param {string | RegExp} begin
+ * @param {string | RegExp} end
+ * @param {Mode | {}} [modeOptions]
+ * @returns {Partial}
+ */
+const COMMENT = function(begin, end, modeOptions = {}) {
+ const mode = inherit$1(
+ {
+ scope: 'comment',
+ begin,
+ end,
+ contains: []
+ },
+ modeOptions
+ );
+ mode.contains.push({
+ scope: 'doctag',
+ // hack to avoid the space from being included. the space is necessary to
+ // match here to prevent the plain text rule below from gobbling up doctags
+ begin: '[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)',
+ end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+ excludeBegin: true,
+ relevance: 0
+ });
+ const ENGLISH_WORD = either(
+ // list of common 1 and 2 letter words in English
+ "I",
+ "a",
+ "is",
+ "so",
+ "us",
+ "to",
+ "at",
+ "if",
+ "in",
+ "it",
+ "on",
+ // note: this is not an exhaustive list of contractions, just popular ones
+ /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, // contractions - can't we'd they're let's, etc
+ /[A-Za-z]+[-][a-z]+/, // `no-way`, etc.
+ /[A-Za-z][a-z]{2,}/ // allow capitalized words at beginning of sentences
+ );
+ // looking like plain text, more likely to be a comment
+ mode.contains.push(
+ {
+ // TODO: how to include ", (, ) without breaking grammars that use these for
+ // comment delimiters?
+ // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
+ // ---
+
+ // this tries to find sequences of 3 english words in a row (without any
+ // "programming" type syntax) this gives us a strong signal that we've
+ // TRULY found a comment - vs perhaps scanning with the wrong language.
+ // It's possible to find something that LOOKS like the start of the
+ // comment - but then if there is no readable text - good chance it is a
+ // false match and not a comment.
+ //
+ // for a visual example please see:
+ // https://github.com/highlightjs/highlight.js/issues/2827
+
+ begin: concat(
+ /[ ]+/, // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+ '(',
+ ENGLISH_WORD,
+ /[.]?[:]?([.][ ]|[ ])/,
+ '){3}') // look for 3 words in a row
+ }
+ );
+ return mode;
+};
+const C_LINE_COMMENT_MODE = COMMENT('//', '$');
+const C_BLOCK_COMMENT_MODE = COMMENT('/\\*', '\\*/');
+const HASH_COMMENT_MODE = COMMENT('#', '$');
+const NUMBER_MODE = {
+ scope: 'number',
+ begin: NUMBER_RE,
+ relevance: 0
+};
+const C_NUMBER_MODE = {
+ scope: 'number',
+ begin: C_NUMBER_RE,
+ relevance: 0
+};
+const BINARY_NUMBER_MODE = {
+ scope: 'number',
+ begin: BINARY_NUMBER_RE,
+ relevance: 0
+};
+const REGEXP_MODE = {
+ scope: "regexp",
+ begin: /\/(?=[^/\n]*\/)/,
+ end: /\/[gimuy]*/,
+ contains: [
+ BACKSLASH_ESCAPE,
+ {
+ begin: /\[/,
+ end: /\]/,
+ relevance: 0,
+ contains: [BACKSLASH_ESCAPE]
+ }
+ ]
+};
+const TITLE_MODE = {
+ scope: 'title',
+ begin: IDENT_RE,
+ relevance: 0
+};
+const UNDERSCORE_TITLE_MODE = {
+ scope: 'title',
+ begin: UNDERSCORE_IDENT_RE,
+ relevance: 0
+};
+const METHOD_GUARD = {
+ // excludes method names from keyword processing
+ begin: '\\.\\s*' + UNDERSCORE_IDENT_RE,
+ relevance: 0
+};
+
+/**
+ * Adds end same as begin mechanics to a mode
+ *
+ * Your mode must include at least a single () match group as that first match
+ * group is what is used for comparison
+ * @param {Partial} mode
+ */
+const END_SAME_AS_BEGIN = function(mode) {
+ return Object.assign(mode,
+ {
+ /** @type {ModeCallback} */
+ 'on:begin': (m, resp) => { resp.data._beginMatch = m[1]; },
+ /** @type {ModeCallback} */
+ 'on:end': (m, resp) => { if (resp.data._beginMatch !== m[1]) resp.ignoreMatch(); }
+ });
+};
+
+var MODES = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ APOS_STRING_MODE: APOS_STRING_MODE,
+ BACKSLASH_ESCAPE: BACKSLASH_ESCAPE,
+ BINARY_NUMBER_MODE: BINARY_NUMBER_MODE,
+ BINARY_NUMBER_RE: BINARY_NUMBER_RE,
+ COMMENT: COMMENT,
+ C_BLOCK_COMMENT_MODE: C_BLOCK_COMMENT_MODE,
+ C_LINE_COMMENT_MODE: C_LINE_COMMENT_MODE,
+ C_NUMBER_MODE: C_NUMBER_MODE,
+ C_NUMBER_RE: C_NUMBER_RE,
+ END_SAME_AS_BEGIN: END_SAME_AS_BEGIN,
+ HASH_COMMENT_MODE: HASH_COMMENT_MODE,
+ IDENT_RE: IDENT_RE,
+ MATCH_NOTHING_RE: MATCH_NOTHING_RE,
+ METHOD_GUARD: METHOD_GUARD,
+ NUMBER_MODE: NUMBER_MODE,
+ NUMBER_RE: NUMBER_RE,
+ PHRASAL_WORDS_MODE: PHRASAL_WORDS_MODE,
+ QUOTE_STRING_MODE: QUOTE_STRING_MODE,
+ REGEXP_MODE: REGEXP_MODE,
+ RE_STARTERS_RE: RE_STARTERS_RE,
+ SHEBANG: SHEBANG,
+ TITLE_MODE: TITLE_MODE,
+ UNDERSCORE_IDENT_RE: UNDERSCORE_IDENT_RE,
+ UNDERSCORE_TITLE_MODE: UNDERSCORE_TITLE_MODE
+});
+
+/**
+@typedef {import('highlight.js').CallbackResponse} CallbackResponse
+@typedef {import('highlight.js').CompilerExt} CompilerExt
+*/
+
+// Grammar extensions / plugins
+// See: https://github.com/highlightjs/highlight.js/issues/2833
+
+// Grammar extensions allow "syntactic sugar" to be added to the grammar modes
+// without requiring any underlying changes to the compiler internals.
+
+// `compileMatch` being the perfect small example of now allowing a grammar
+// author to write `match` when they desire to match a single expression rather
+// than being forced to use `begin`. The extension then just moves `match` into
+// `begin` when it runs. Ie, no features have been added, but we've just made
+// the experience of writing (and reading grammars) a little bit nicer.
+
+// ------
+
+// TODO: We need negative look-behind support to do this properly
+/**
+ * Skip a match if it has a preceding dot
+ *
+ * This is used for `beginKeywords` to prevent matching expressions such as
+ * `bob.keyword.do()`. The mode compiler automatically wires this up as a
+ * special _internal_ 'on:begin' callback for modes with `beginKeywords`
+ * @param {RegExpMatchArray} match
+ * @param {CallbackResponse} response
+ */
+function skipIfHasPrecedingDot(match, response) {
+ const before = match.input[match.index - 1];
+ if (before === ".") {
+ response.ignoreMatch();
+ }
+}
+
+/**
+ *
+ * @type {CompilerExt}
+ */
+function scopeClassName(mode, _parent) {
+ // eslint-disable-next-line no-undefined
+ if (mode.className !== undefined) {
+ mode.scope = mode.className;
+ delete mode.className;
+ }
+}
+
+/**
+ * `beginKeywords` syntactic sugar
+ * @type {CompilerExt}
+ */
+function beginKeywords(mode, parent) {
+ if (!parent) return;
+ if (!mode.beginKeywords) return;
+
+ // for languages with keywords that include non-word characters checking for
+ // a word boundary is not sufficient, so instead we check for a word boundary
+ // or whitespace - this does no harm in any case since our keyword engine
+ // doesn't allow spaces in keywords anyways and we still check for the boundary
+ // first
+ mode.begin = '\\b(' + mode.beginKeywords.split(' ').join('|') + ')(?!\\.)(?=\\b|\\s)';
+ mode.__beforeBegin = skipIfHasPrecedingDot;
+ mode.keywords = mode.keywords || mode.beginKeywords;
+ delete mode.beginKeywords;
+
+ // prevents double relevance, the keywords themselves provide
+ // relevance, the mode doesn't need to double it
+ // eslint-disable-next-line no-undefined
+ if (mode.relevance === undefined) mode.relevance = 0;
+}
+
+/**
+ * Allow `illegal` to contain an array of illegal values
+ * @type {CompilerExt}
+ */
+function compileIllegal(mode, _parent) {
+ if (!Array.isArray(mode.illegal)) return;
+
+ mode.illegal = either(...mode.illegal);
+}
+
+/**
+ * `match` to match a single expression for readability
+ * @type {CompilerExt}
+ */
+function compileMatch(mode, _parent) {
+ if (!mode.match) return;
+ if (mode.begin || mode.end) throw new Error("begin & end are not supported with match");
+
+ mode.begin = mode.match;
+ delete mode.match;
+}
+
+/**
+ * provides the default 1 relevance to all modes
+ * @type {CompilerExt}
+ */
+function compileRelevance(mode, _parent) {
+ // eslint-disable-next-line no-undefined
+ if (mode.relevance === undefined) mode.relevance = 1;
+}
+
+// allow beforeMatch to act as a "qualifier" for the match
+// the full match begin must be [beforeMatch][begin]
+const beforeMatchExt = (mode, parent) => {
+ if (!mode.beforeMatch) return;
+ // starts conflicts with endsParent which we need to make sure the child
+ // rule is not matched multiple times
+ if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
+
+ const originalMode = Object.assign({}, mode);
+ Object.keys(mode).forEach((key) => { delete mode[key]; });
+
+ mode.keywords = originalMode.keywords;
+ mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+ mode.starts = {
+ relevance: 0,
+ contains: [
+ Object.assign(originalMode, { endsParent: true })
+ ]
+ };
+ mode.relevance = 0;
+
+ delete originalMode.beforeMatch;
+};
+
+// keywords that should have no default relevance value
+const COMMON_KEYWORDS = [
+ 'of',
+ 'and',
+ 'for',
+ 'in',
+ 'not',
+ 'or',
+ 'if',
+ 'then',
+ 'parent', // common variable name
+ 'list', // common variable name
+ 'value' // common variable name
+];
+
+const DEFAULT_KEYWORD_SCOPE = "keyword";
+
+/**
+ * Given raw keywords from a language definition, compile them.
+ *
+ * @param {string | Record | Array} rawKeywords
+ * @param {boolean} caseInsensitive
+ */
+function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
+ /** @type {import("highlight.js/private").KeywordDict} */
+ const compiledKeywords = Object.create(null);
+
+ // input can be a string of keywords, an array of keywords, or a object with
+ // named keys representing scopeName (which can then point to a string or array)
+ if (typeof rawKeywords === 'string') {
+ compileList(scopeName, rawKeywords.split(" "));
+ } else if (Array.isArray(rawKeywords)) {
+ compileList(scopeName, rawKeywords);
+ } else {
+ Object.keys(rawKeywords).forEach(function(scopeName) {
+ // collapse all our objects back into the parent object
+ Object.assign(
+ compiledKeywords,
+ compileKeywords(rawKeywords[scopeName], caseInsensitive, scopeName)
+ );
+ });
+ }
+ return compiledKeywords;
+
+ // ---
+
+ /**
+ * Compiles an individual list of keywords
+ *
+ * Ex: "for if when while|5"
+ *
+ * @param {string} scopeName
+ * @param {Array} keywordList
+ */
+ function compileList(scopeName, keywordList) {
+ if (caseInsensitive) {
+ keywordList = keywordList.map(x => x.toLowerCase());
+ }
+ keywordList.forEach(function(keyword) {
+ const pair = keyword.split('|');
+ compiledKeywords[pair[0]] = [scopeName, scoreForKeyword(pair[0], pair[1])];
+ });
+ }
+}
+
+/**
+ * Returns the proper score for a given keyword
+ *
+ * Also takes into account comment keywords, which will be scored 0 UNLESS
+ * another score has been manually assigned.
+ * @param {string} keyword
+ * @param {string} [providedScore]
+ */
+function scoreForKeyword(keyword, providedScore) {
+ // manual scores always win over common keywords
+ // so you can force a score of 1 if you really insist
+ if (providedScore) {
+ return Number(providedScore);
+ }
+
+ return commonKeyword(keyword) ? 0 : 1;
+}
+
+/**
+ * Determines if a given keyword is common or not
+ *
+ * @param {string} keyword */
+function commonKeyword(keyword) {
+ return COMMON_KEYWORDS.includes(keyword.toLowerCase());
+}
+
+/*
+
+For the reasoning behind this please see:
+https://github.com/highlightjs/highlight.js/issues/2880#issuecomment-747275419
+
+*/
+
+/**
+ * @type {Record}
+ */
+const seenDeprecations = {};
+
+/**
+ * @param {string} message
+ */
+const error = (message) => {
+ console.error(message);
+};
+
+/**
+ * @param {string} message
+ * @param {any} args
+ */
+const warn = (message, ...args) => {
+ console.log(`WARN: ${message}`, ...args);
+};
+
+/**
+ * @param {string} version
+ * @param {string} message
+ */
+const deprecated = (version, message) => {
+ if (seenDeprecations[`${version}/${message}`]) return;
+
+ console.log(`Deprecated as of ${version}. ${message}`);
+ seenDeprecations[`${version}/${message}`] = true;
+};
+
+/* eslint-disable no-throw-literal */
+
+/**
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+*/
+
+const MultiClassError = new Error();
+
+/**
+ * Renumbers labeled scope names to account for additional inner match
+ * groups that otherwise would break everything.
+ *
+ * Lets say we 3 match scopes:
+ *
+ * { 1 => ..., 2 => ..., 3 => ... }
+ *
+ * So what we need is a clean match like this:
+ *
+ * (a)(b)(c) => [ "a", "b", "c" ]
+ *
+ * But this falls apart with inner match groups:
+ *
+ * (a)(((b)))(c) => ["a", "b", "b", "b", "c" ]
+ *
+ * Our scopes are now "out of alignment" and we're repeating `b` 3 times.
+ * What needs to happen is the numbers are remapped:
+ *
+ * { 1 => ..., 2 => ..., 5 => ... }
+ *
+ * We also need to know that the ONLY groups that should be output
+ * are 1, 2, and 5. This function handles this behavior.
+ *
+ * @param {CompiledMode} mode
+ * @param {Array} regexes
+ * @param {{key: "beginScope"|"endScope"}} opts
+ */
+function remapScopeNames(mode, regexes, { key }) {
+ let offset = 0;
+ const scopeNames = mode[key];
+ /** @type Record */
+ const emit = {};
+ /** @type Record */
+ const positions = {};
+
+ for (let i = 1; i <= regexes.length; i++) {
+ positions[i + offset] = scopeNames[i];
+ emit[i + offset] = true;
+ offset += countMatchGroups(regexes[i - 1]);
+ }
+ // we use _emit to keep track of which match groups are "top-level" to avoid double
+ // output from inside match groups
+ mode[key] = positions;
+ mode[key]._emit = emit;
+ mode[key]._multi = true;
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function beginMultiClass(mode) {
+ if (!Array.isArray(mode.begin)) return;
+
+ if (mode.skip || mode.excludeBegin || mode.returnBegin) {
+ error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
+ throw MultiClassError;
+ }
+
+ if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
+ error("beginScope must be object");
+ throw MultiClassError;
+ }
+
+ remapScopeNames(mode, mode.begin, { key: "beginScope" });
+ mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function endMultiClass(mode) {
+ if (!Array.isArray(mode.end)) return;
+
+ if (mode.skip || mode.excludeEnd || mode.returnEnd) {
+ error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
+ throw MultiClassError;
+ }
+
+ if (typeof mode.endScope !== "object" || mode.endScope === null) {
+ error("endScope must be object");
+ throw MultiClassError;
+ }
+
+ remapScopeNames(mode, mode.end, { key: "endScope" });
+ mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
+}
+
+/**
+ * this exists only to allow `scope: {}` to be used beside `match:`
+ * Otherwise `beginScope` would necessary and that would look weird
+
+ {
+ match: [ /def/, /\w+/ ]
+ scope: { 1: "keyword" , 2: "title" }
+ }
+
+ * @param {CompiledMode} mode
+ */
+function scopeSugar(mode) {
+ if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
+ mode.beginScope = mode.scope;
+ delete mode.scope;
+ }
+}
+
+/**
+ * @param {CompiledMode} mode
+ */
+function MultiClass(mode) {
+ scopeSugar(mode);
+
+ if (typeof mode.beginScope === "string") {
+ mode.beginScope = { _wrap: mode.beginScope };
+ }
+ if (typeof mode.endScope === "string") {
+ mode.endScope = { _wrap: mode.endScope };
+ }
+
+ beginMultiClass(mode);
+ endMultiClass(mode);
+}
+
+/**
+@typedef {import('highlight.js').Mode} Mode
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+@typedef {import('highlight.js').Language} Language
+@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+@typedef {import('highlight.js').CompiledLanguage} CompiledLanguage
+*/
+
+// compilation
+
+/**
+ * Compiles a language definition result
+ *
+ * Given the raw result of a language definition (Language), compiles this so
+ * that it is ready for highlighting code.
+ * @param {Language} language
+ * @returns {CompiledLanguage}
+ */
+function compileLanguage(language) {
+ /**
+ * Builds a regex with the case sensitivity of the current language
+ *
+ * @param {RegExp | string} value
+ * @param {boolean} [global]
+ */
+ function langRe(value, global) {
+ return new RegExp(
+ source(value),
+ 'm'
+ + (language.case_insensitive ? 'i' : '')
+ + (language.unicodeRegex ? 'u' : '')
+ + (global ? 'g' : '')
+ );
+ }
+
+ /**
+ Stores multiple regular expressions and allows you to quickly search for
+ them all in a string simultaneously - returning the first match. It does
+ this by creating a huge (a|b|c) regex - each individual item wrapped with ()
+ and joined by `|` - using match groups to track position. When a match is
+ found checking which position in the array has content allows us to figure
+ out which of the original regexes / match groups triggered the match.
+
+ The match object itself (the result of `Regex.exec`) is returned but also
+ enhanced by merging in any meta-data that was registered with the regex.
+ This is how we keep track of which mode matched, and what type of rule
+ (`illegal`, `begin`, end, etc).
+ */
+ class MultiRegex {
+ constructor() {
+ this.matchIndexes = {};
+ // @ts-ignore
+ this.regexes = [];
+ this.matchAt = 1;
+ this.position = 0;
+ }
+
+ // @ts-ignore
+ addRule(re, opts) {
+ opts.position = this.position++;
+ // @ts-ignore
+ this.matchIndexes[this.matchAt] = opts;
+ this.regexes.push([opts, re]);
+ this.matchAt += countMatchGroups(re) + 1;
+ }
+
+ compile() {
+ if (this.regexes.length === 0) {
+ // avoids the need to check length every time exec is called
+ // @ts-ignore
+ this.exec = () => null;
+ }
+ const terminators = this.regexes.map(el => el[1]);
+ this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: '|' }), true);
+ this.lastIndex = 0;
+ }
+
+ /** @param {string} s */
+ exec(s) {
+ this.matcherRe.lastIndex = this.lastIndex;
+ const match = this.matcherRe.exec(s);
+ if (!match) { return null; }
+
+ // eslint-disable-next-line no-undefined
+ const i = match.findIndex((el, i) => i > 0 && el !== undefined);
+ // @ts-ignore
+ const matchData = this.matchIndexes[i];
+ // trim off any earlier non-relevant match groups (ie, the other regex
+ // match groups that make up the multi-matcher)
+ match.splice(0, i);
+
+ return Object.assign(match, matchData);
+ }
+ }
+
+ /*
+ Created to solve the key deficiently with MultiRegex - there is no way to
+ test for multiple matches at a single location. Why would we need to do
+ that? In the future a more dynamic engine will allow certain matches to be
+ ignored. An example: if we matched say the 3rd regex in a large group but
+ decided to ignore it - we'd need to started testing again at the 4th
+ regex... but MultiRegex itself gives us no real way to do that.
+
+ So what this class creates MultiRegexs on the fly for whatever search
+ position they are needed.
+
+ NOTE: These additional MultiRegex objects are created dynamically. For most
+ grammars most of the time we will never actually need anything more than the
+ first MultiRegex - so this shouldn't have too much overhead.
+
+ Say this is our search group, and we match regex3, but wish to ignore it.
+
+ regex1 | regex2 | regex3 | regex4 | regex5 ' ie, startAt = 0
+
+ What we need is a new MultiRegex that only includes the remaining
+ possibilities:
+
+ regex4 | regex5 ' ie, startAt = 3
+
+ This class wraps all that complexity up in a simple API... `startAt` decides
+ where in the array of expressions to start doing the matching. It
+ auto-increments, so if a match is found at position 2, then startAt will be
+ set to 3. If the end is reached startAt will return to 0.
+
+ MOST of the time the parser will be setting startAt manually to 0.
+ */
+ class ResumableMultiRegex {
+ constructor() {
+ // @ts-ignore
+ this.rules = [];
+ // @ts-ignore
+ this.multiRegexes = [];
+ this.count = 0;
+
+ this.lastIndex = 0;
+ this.regexIndex = 0;
+ }
+
+ // @ts-ignore
+ getMatcher(index) {
+ if (this.multiRegexes[index]) return this.multiRegexes[index];
+
+ const matcher = new MultiRegex();
+ this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
+ matcher.compile();
+ this.multiRegexes[index] = matcher;
+ return matcher;
+ }
+
+ resumingScanAtSamePosition() {
+ return this.regexIndex !== 0;
+ }
+
+ considerAll() {
+ this.regexIndex = 0;
+ }
+
+ // @ts-ignore
+ addRule(re, opts) {
+ this.rules.push([re, opts]);
+ if (opts.type === "begin") this.count++;
+ }
+
+ /** @param {string} s */
+ exec(s) {
+ const m = this.getMatcher(this.regexIndex);
+ m.lastIndex = this.lastIndex;
+ let result = m.exec(s);
+
+ // The following is because we have no easy way to say "resume scanning at the
+ // existing position but also skip the current rule ONLY". What happens is
+ // all prior rules are also skipped which can result in matching the wrong
+ // thing. Example of matching "booger":
+
+ // our matcher is [string, "booger", number]
+ //
+ // ....booger....
+
+ // if "booger" is ignored then we'd really need a regex to scan from the
+ // SAME position for only: [string, number] but ignoring "booger" (if it
+ // was the first match), a simple resume would scan ahead who knows how
+ // far looking only for "number", ignoring potential string matches (or
+ // future "booger" matches that might be valid.)
+
+ // So what we do: We execute two matchers, one resuming at the same
+ // position, but the second full matcher starting at the position after:
+
+ // /--- resume first regex match here (for [number])
+ // |/---- full match here for [string, "booger", number]
+ // vv
+ // ....booger....
+
+ // Which ever results in a match first is then used. So this 3-4 step
+ // process essentially allows us to say "match at this position, excluding
+ // a prior rule that was ignored".
+ //
+ // 1. Match "booger" first, ignore. Also proves that [string] does non match.
+ // 2. Resume matching for [number]
+ // 3. Match at index + 1 for [string, "booger", number]
+ // 4. If #2 and #3 result in matches, which came first?
+ if (this.resumingScanAtSamePosition()) {
+ if (result && result.index === this.lastIndex) ; else { // use the second matcher result
+ const m2 = this.getMatcher(0);
+ m2.lastIndex = this.lastIndex + 1;
+ result = m2.exec(s);
+ }
+ }
+
+ if (result) {
+ this.regexIndex += result.position + 1;
+ if (this.regexIndex === this.count) {
+ // wrap-around to considering all matches again
+ this.considerAll();
+ }
+ }
+
+ return result;
+ }
+ }
+
+ /**
+ * Given a mode, builds a huge ResumableMultiRegex that can be used to walk
+ * the content and find matches.
+ *
+ * @param {CompiledMode} mode
+ * @returns {ResumableMultiRegex}
+ */
+ function buildModeRegex(mode) {
+ const mm = new ResumableMultiRegex();
+
+ mode.contains.forEach(term => mm.addRule(term.begin, { rule: term, type: "begin" }));
+
+ if (mode.terminatorEnd) {
+ mm.addRule(mode.terminatorEnd, { type: "end" });
+ }
+ if (mode.illegal) {
+ mm.addRule(mode.illegal, { type: "illegal" });
+ }
+
+ return mm;
+ }
+
+ /** skip vs abort vs ignore
+ *
+ * @skip - The mode is still entered and exited normally (and contains rules apply),
+ * but all content is held and added to the parent buffer rather than being
+ * output when the mode ends. Mostly used with `sublanguage` to build up
+ * a single large buffer than can be parsed by sublanguage.
+ *
+ * - The mode begin ands ends normally.
+ * - Content matched is added to the parent mode buffer.
+ * - The parser cursor is moved forward normally.
+ *
+ * @abort - A hack placeholder until we have ignore. Aborts the mode (as if it
+ * never matched) but DOES NOT continue to match subsequent `contains`
+ * modes. Abort is bad/suboptimal because it can result in modes
+ * farther down not getting applied because an earlier rule eats the
+ * content but then aborts.
+ *
+ * - The mode does not begin.
+ * - Content matched by `begin` is added to the mode buffer.
+ * - The parser cursor is moved forward accordingly.
+ *
+ * @ignore - Ignores the mode (as if it never matched) and continues to match any
+ * subsequent `contains` modes. Ignore isn't technically possible with
+ * the current parser implementation.
+ *
+ * - The mode does not begin.
+ * - Content matched by `begin` is ignored.
+ * - The parser cursor is not moved forward.
+ */
+
+ /**
+ * Compiles an individual mode
+ *
+ * This can raise an error if the mode contains certain detectable known logic
+ * issues.
+ * @param {Mode} mode
+ * @param {CompiledMode | null} [parent]
+ * @returns {CompiledMode | never}
+ */
+ function compileMode(mode, parent) {
+ const cmode = /** @type CompiledMode */ (mode);
+ if (mode.isCompiled) return cmode;
+
+ [
+ scopeClassName,
+ // do this early so compiler extensions generally don't have to worry about
+ // the distinction between match/begin
+ compileMatch,
+ MultiClass,
+ beforeMatchExt
+ ].forEach(ext => ext(mode, parent));
+
+ language.compilerExtensions.forEach(ext => ext(mode, parent));
+
+ // __beforeBegin is considered private API, internal use only
+ mode.__beforeBegin = null;
+
+ [
+ beginKeywords,
+ // do this later so compiler extensions that come earlier have access to the
+ // raw array if they wanted to perhaps manipulate it, etc.
+ compileIllegal,
+ // default to 1 relevance if not specified
+ compileRelevance
+ ].forEach(ext => ext(mode, parent));
+
+ mode.isCompiled = true;
+
+ let keywordPattern = null;
+ if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
+ // we need a copy because keywords might be compiled multiple times
+ // so we can't go deleting $pattern from the original on the first
+ // pass
+ mode.keywords = Object.assign({}, mode.keywords);
+ keywordPattern = mode.keywords.$pattern;
+ delete mode.keywords.$pattern;
+ }
+ keywordPattern = keywordPattern || /\w+/;
+
+ if (mode.keywords) {
+ mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
+ }
+
+ cmode.keywordPatternRe = langRe(keywordPattern, true);
+
+ if (parent) {
+ if (!mode.begin) mode.begin = /\B|\b/;
+ cmode.beginRe = langRe(cmode.begin);
+ if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
+ if (mode.end) cmode.endRe = langRe(cmode.end);
+ cmode.terminatorEnd = source(cmode.end) || '';
+ if (mode.endsWithParent && parent.terminatorEnd) {
+ cmode.terminatorEnd += (mode.end ? '|' : '') + parent.terminatorEnd;
+ }
+ }
+ if (mode.illegal) cmode.illegalRe = langRe(/** @type {RegExp | string} */ (mode.illegal));
+ if (!mode.contains) mode.contains = [];
+
+ mode.contains = [].concat(...mode.contains.map(function(c) {
+ return expandOrCloneMode(c === 'self' ? mode : c);
+ }));
+ mode.contains.forEach(function(c) { compileMode(/** @type Mode */ (c), cmode); });
+
+ if (mode.starts) {
+ compileMode(mode.starts, parent);
+ }
+
+ cmode.matcher = buildModeRegex(cmode);
+ return cmode;
+ }
+
+ if (!language.compilerExtensions) language.compilerExtensions = [];
+
+ // self is not valid at the top-level
+ if (language.contains && language.contains.includes('self')) {
+ throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");
+ }
+
+ // we need a null object, which inherit will guarantee
+ language.classNameAliases = inherit$1(language.classNameAliases || {});
+
+ return compileMode(/** @type Mode */ (language));
+}
+
+/**
+ * Determines if a mode has a dependency on it's parent or not
+ *
+ * If a mode does have a parent dependency then often we need to clone it if
+ * it's used in multiple places so that each copy points to the correct parent,
+ * where-as modes without a parent can often safely be re-used at the bottom of
+ * a mode chain.
+ *
+ * @param {Mode | null} mode
+ * @returns {boolean} - is there a dependency on the parent?
+ * */
+function dependencyOnParent(mode) {
+ if (!mode) return false;
+
+ return mode.endsWithParent || dependencyOnParent(mode.starts);
+}
+
+/**
+ * Expands a mode or clones it if necessary
+ *
+ * This is necessary for modes with parental dependenceis (see notes on
+ * `dependencyOnParent`) and for nodes that have `variants` - which must then be
+ * exploded into their own individual modes at compile time.
+ *
+ * @param {Mode} mode
+ * @returns {Mode | Mode[]}
+ * */
+function expandOrCloneMode(mode) {
+ if (mode.variants && !mode.cachedVariants) {
+ mode.cachedVariants = mode.variants.map(function(variant) {
+ return inherit$1(mode, { variants: null }, variant);
+ });
+ }
+
+ // EXPAND
+ // if we have variants then essentially "replace" the mode with the variants
+ // this happens in compileMode, where this function is called from
+ if (mode.cachedVariants) {
+ return mode.cachedVariants;
+ }
+
+ // CLONE
+ // if we have dependencies on parents then we need a unique
+ // instance of ourselves, so we can be reused with many
+ // different parents without issue
+ if (dependencyOnParent(mode)) {
+ return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null });
+ }
+
+ if (Object.isFrozen(mode)) {
+ return inherit$1(mode);
+ }
+
+ // no special dependency issues, just return ourselves
+ return mode;
+}
+
+var version = "11.9.0";
+
+class HTMLInjectionError extends Error {
+ constructor(reason, html) {
+ super(reason);
+ this.name = "HTMLInjectionError";
+ this.html = html;
+ }
+}
+
+/*
+Syntax highlighting with language autodetection.
+https://highlightjs.org/
+*/
+
+
+
+/**
+@typedef {import('highlight.js').Mode} Mode
+@typedef {import('highlight.js').CompiledMode} CompiledMode
+@typedef {import('highlight.js').CompiledScope} CompiledScope
+@typedef {import('highlight.js').Language} Language
+@typedef {import('highlight.js').HLJSApi} HLJSApi
+@typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+@typedef {import('highlight.js').PluginEvent} PluginEvent
+@typedef {import('highlight.js').HLJSOptions} HLJSOptions
+@typedef {import('highlight.js').LanguageFn} LanguageFn
+@typedef {import('highlight.js').HighlightedHTMLElement} HighlightedHTMLElement
+@typedef {import('highlight.js').BeforeHighlightContext} BeforeHighlightContext
+@typedef {import('highlight.js/private').MatchType} MatchType
+@typedef {import('highlight.js/private').KeywordData} KeywordData
+@typedef {import('highlight.js/private').EnhancedMatch} EnhancedMatch
+@typedef {import('highlight.js/private').AnnotatedError} AnnotatedError
+@typedef {import('highlight.js').AutoHighlightResult} AutoHighlightResult
+@typedef {import('highlight.js').HighlightOptions} HighlightOptions
+@typedef {import('highlight.js').HighlightResult} HighlightResult
+*/
+
+
+const escape = escapeHTML;
+const inherit = inherit$1;
+const NO_MATCH = Symbol("nomatch");
+const MAX_KEYWORD_HITS = 7;
+
+/**
+ * @param {any} hljs - object that is extended (legacy)
+ * @returns {HLJSApi}
+ */
+const HLJS = function(hljs) {
+ // Global internal variables used within the highlight.js library.
+ /** @type {Record} */
+ const languages = Object.create(null);
+ /** @type {Record} */
+ const aliases = Object.create(null);
+ /** @type {HLJSPlugin[]} */
+ const plugins = [];
+
+ // safe/production mode - swallows more errors, tries to keep running
+ // even if a single syntax or parse hits a fatal error
+ let SAFE_MODE = true;
+ const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
+ /** @type {Language} */
+ const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: 'Plain text', contains: [] };
+
+ // Global options used when within external APIs. This is modified when
+ // calling the `hljs.configure` function.
+ /** @type HLJSOptions */
+ let options = {
+ ignoreUnescapedHTML: false,
+ throwUnescapedHTML: false,
+ noHighlightRe: /^(no-?highlight)$/i,
+ languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+ classPrefix: 'hljs-',
+ cssSelector: 'pre code',
+ languages: null,
+ // beta configuration options, subject to change, welcome to discuss
+ // https://github.com/highlightjs/highlight.js/issues/1086
+ __emitter: TokenTreeEmitter
+ };
+
+ /* Utility functions */
+
+ /**
+ * Tests a language name to see if highlighting should be skipped
+ * @param {string} languageName
+ */
+ function shouldNotHighlight(languageName) {
+ return options.noHighlightRe.test(languageName);
+ }
+
+ /**
+ * @param {HighlightedHTMLElement} block - the HTML element to determine language for
+ */
+ function blockLanguage(block) {
+ let classes = block.className + ' ';
+
+ classes += block.parentNode ? block.parentNode.className : '';
+
+ // language-* takes precedence over non-prefixed class names.
+ const match = options.languageDetectRe.exec(classes);
+ if (match) {
+ const language = getLanguage(match[1]);
+ if (!language) {
+ warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
+ warn("Falling back to no-highlight mode for this block.", block);
+ }
+ return language ? match[1] : 'no-highlight';
+ }
+
+ return classes
+ .split(/\s+/)
+ .find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
+ }
+
+ /**
+ * Core highlighting function.
+ *
+ * OLD API
+ * highlight(lang, code, ignoreIllegals, continuation)
+ *
+ * NEW API
+ * highlight(code, {lang, ignoreIllegals})
+ *
+ * @param {string} codeOrLanguageName - the language to use for highlighting
+ * @param {string | HighlightOptions} optionsOrCode - the code to highlight
+ * @param {boolean} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
+ *
+ * @returns {HighlightResult} Result - an object that represents the result
+ * @property {string} language - the language name
+ * @property {number} relevance - the relevance score
+ * @property {string} value - the highlighted HTML code
+ * @property {string} code - the original raw code
+ * @property {CompiledMode} top - top of the current mode stack
+ * @property {boolean} illegal - indicates whether any illegal matches were found
+ */
+ function highlight(codeOrLanguageName, optionsOrCode, ignoreIllegals) {
+ let code = "";
+ let languageName = "";
+ if (typeof optionsOrCode === "object") {
+ code = codeOrLanguageName;
+ ignoreIllegals = optionsOrCode.ignoreIllegals;
+ languageName = optionsOrCode.language;
+ } else {
+ // old API
+ deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
+ deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
+ languageName = codeOrLanguageName;
+ code = optionsOrCode;
+ }
+
+ // https://github.com/highlightjs/highlight.js/issues/3149
+ // eslint-disable-next-line no-undefined
+ if (ignoreIllegals === undefined) { ignoreIllegals = true; }
+
+ /** @type {BeforeHighlightContext} */
+ const context = {
+ code,
+ language: languageName
+ };
+ // the plugin can change the desired language or the code to be highlighted
+ // just be changing the object it was passed
+ fire("before:highlight", context);
+
+ // a before plugin can usurp the result completely by providing it's own
+ // in which case we don't even need to call highlight
+ const result = context.result
+ ? context.result
+ : _highlight(context.language, context.code, ignoreIllegals);
+
+ result.code = context.code;
+ // the plugin can change anything in result to suite it
+ fire("after:highlight", result);
+
+ return result;
+ }
+
+ /**
+ * private highlight that's used internally and does not fire callbacks
+ *
+ * @param {string} languageName - the language to use for highlighting
+ * @param {string} codeToHighlight - the code to highlight
+ * @param {boolean?} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
+ * @param {CompiledMode?} [continuation] - current continuation mode, if any
+ * @returns {HighlightResult} - result of the highlight operation
+ */
+ function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
+ const keywordHits = Object.create(null);
+
+ /**
+ * Return keyword data if a match is a keyword
+ * @param {CompiledMode} mode - current mode
+ * @param {string} matchText - the textual match
+ * @returns {KeywordData | false}
+ */
+ function keywordData(mode, matchText) {
+ return mode.keywords[matchText];
+ }
+
+ function processKeywords() {
+ if (!top.keywords) {
+ emitter.addText(modeBuffer);
+ return;
+ }
+
+ let lastIndex = 0;
+ top.keywordPatternRe.lastIndex = 0;
+ let match = top.keywordPatternRe.exec(modeBuffer);
+ let buf = "";
+
+ while (match) {
+ buf += modeBuffer.substring(lastIndex, match.index);
+ const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
+ const data = keywordData(top, word);
+ if (data) {
+ const [kind, keywordRelevance] = data;
+ emitter.addText(buf);
+ buf = "";
+
+ keywordHits[word] = (keywordHits[word] || 0) + 1;
+ if (keywordHits[word] <= MAX_KEYWORD_HITS) relevance += keywordRelevance;
+ if (kind.startsWith("_")) {
+ // _ implied for relevance only, do not highlight
+ // by applying a class name
+ buf += match[0];
+ } else {
+ const cssClass = language.classNameAliases[kind] || kind;
+ emitKeyword(match[0], cssClass);
+ }
+ } else {
+ buf += match[0];
+ }
+ lastIndex = top.keywordPatternRe.lastIndex;
+ match = top.keywordPatternRe.exec(modeBuffer);
+ }
+ buf += modeBuffer.substring(lastIndex);
+ emitter.addText(buf);
+ }
+
+ function processSubLanguage() {
+ if (modeBuffer === "") return;
+ /** @type HighlightResult */
+ let result = null;
+
+ if (typeof top.subLanguage === 'string') {
+ if (!languages[top.subLanguage]) {
+ emitter.addText(modeBuffer);
+ return;
+ }
+ result = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
+ continuations[top.subLanguage] = /** @type {CompiledMode} */ (result._top);
+ } else {
+ result = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
+ }
+
+ // Counting embedded language score towards the host language may be disabled
+ // with zeroing the containing mode relevance. Use case in point is Markdown that
+ // allows XML everywhere and makes every XML snippet to have a much larger Markdown
+ // score.
+ if (top.relevance > 0) {
+ relevance += result.relevance;
+ }
+ emitter.__addSublanguage(result._emitter, result.language);
+ }
+
+ function processBuffer() {
+ if (top.subLanguage != null) {
+ processSubLanguage();
+ } else {
+ processKeywords();
+ }
+ modeBuffer = '';
+ }
+
+ /**
+ * @param {string} text
+ * @param {string} scope
+ */
+ function emitKeyword(keyword, scope) {
+ if (keyword === "") return;
+
+ emitter.startScope(scope);
+ emitter.addText(keyword);
+ emitter.endScope();
+ }
+
+ /**
+ * @param {CompiledScope} scope
+ * @param {RegExpMatchArray} match
+ */
+ function emitMultiClass(scope, match) {
+ let i = 1;
+ const max = match.length - 1;
+ while (i <= max) {
+ if (!scope._emit[i]) { i++; continue; }
+ const klass = language.classNameAliases[scope[i]] || scope[i];
+ const text = match[i];
+ if (klass) {
+ emitKeyword(text, klass);
+ } else {
+ modeBuffer = text;
+ processKeywords();
+ modeBuffer = "";
+ }
+ i++;
+ }
+ }
+
+ /**
+ * @param {CompiledMode} mode - new mode to start
+ * @param {RegExpMatchArray} match
+ */
+ function startNewMode(mode, match) {
+ if (mode.scope && typeof mode.scope === "string") {
+ emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
+ }
+ if (mode.beginScope) {
+ // beginScope just wraps the begin match itself in a scope
+ if (mode.beginScope._wrap) {
+ emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
+ modeBuffer = "";
+ } else if (mode.beginScope._multi) {
+ // at this point modeBuffer should just be the match
+ emitMultiClass(mode.beginScope, match);
+ modeBuffer = "";
+ }
+ }
+
+ top = Object.create(mode, { parent: { value: top } });
+ return top;
+ }
+
+ /**
+ * @param {CompiledMode } mode - the mode to potentially end
+ * @param {RegExpMatchArray} match - the latest match
+ * @param {string} matchPlusRemainder - match plus remainder of content
+ * @returns {CompiledMode | void} - the next mode, or if void continue on in current mode
+ */
+ function endOfMode(mode, match, matchPlusRemainder) {
+ let matched = startsWith(mode.endRe, matchPlusRemainder);
+
+ if (matched) {
+ if (mode["on:end"]) {
+ const resp = new Response(mode);
+ mode["on:end"](match, resp);
+ if (resp.isMatchIgnored) matched = false;
+ }
+
+ if (matched) {
+ while (mode.endsParent && mode.parent) {
+ mode = mode.parent;
+ }
+ return mode;
+ }
+ }
+ // even if on:end fires an `ignore` it's still possible
+ // that we might trigger the end node because of a parent mode
+ if (mode.endsWithParent) {
+ return endOfMode(mode.parent, match, matchPlusRemainder);
+ }
+ }
+
+ /**
+ * Handle matching but then ignoring a sequence of text
+ *
+ * @param {string} lexeme - string containing full match text
+ */
+ function doIgnore(lexeme) {
+ if (top.matcher.regexIndex === 0) {
+ // no more regexes to potentially match here, so we move the cursor forward one
+ // space
+ modeBuffer += lexeme[0];
+ return 1;
+ } else {
+ // no need to move the cursor, we still have additional regexes to try and
+ // match at this very spot
+ resumeScanAtSamePosition = true;
+ return 0;
+ }
+ }
+
+ /**
+ * Handle the start of a new potential mode match
+ *
+ * @param {EnhancedMatch} match - the current match
+ * @returns {number} how far to advance the parse cursor
+ */
+ function doBeginMatch(match) {
+ const lexeme = match[0];
+ const newMode = match.rule;
+
+ const resp = new Response(newMode);
+ // first internal before callbacks, then the public ones
+ const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
+ for (const cb of beforeCallbacks) {
+ if (!cb) continue;
+ cb(match, resp);
+ if (resp.isMatchIgnored) return doIgnore(lexeme);
+ }
+
+ if (newMode.skip) {
+ modeBuffer += lexeme;
+ } else {
+ if (newMode.excludeBegin) {
+ modeBuffer += lexeme;
+ }
+ processBuffer();
+ if (!newMode.returnBegin && !newMode.excludeBegin) {
+ modeBuffer = lexeme;
+ }
+ }
+ startNewMode(newMode, match);
+ return newMode.returnBegin ? 0 : lexeme.length;
+ }
+
+ /**
+ * Handle the potential end of mode
+ *
+ * @param {RegExpMatchArray} match - the current match
+ */
+ function doEndMatch(match) {
+ const lexeme = match[0];
+ const matchPlusRemainder = codeToHighlight.substring(match.index);
+
+ const endMode = endOfMode(top, match, matchPlusRemainder);
+ if (!endMode) { return NO_MATCH; }
+
+ const origin = top;
+ if (top.endScope && top.endScope._wrap) {
+ processBuffer();
+ emitKeyword(lexeme, top.endScope._wrap);
+ } else if (top.endScope && top.endScope._multi) {
+ processBuffer();
+ emitMultiClass(top.endScope, match);
+ } else if (origin.skip) {
+ modeBuffer += lexeme;
+ } else {
+ if (!(origin.returnEnd || origin.excludeEnd)) {
+ modeBuffer += lexeme;
+ }
+ processBuffer();
+ if (origin.excludeEnd) {
+ modeBuffer = lexeme;
+ }
+ }
+ do {
+ if (top.scope) {
+ emitter.closeNode();
+ }
+ if (!top.skip && !top.subLanguage) {
+ relevance += top.relevance;
+ }
+ top = top.parent;
+ } while (top !== endMode.parent);
+ if (endMode.starts) {
+ startNewMode(endMode.starts, match);
+ }
+ return origin.returnEnd ? 0 : lexeme.length;
+ }
+
+ function processContinuations() {
+ const list = [];
+ for (let current = top; current !== language; current = current.parent) {
+ if (current.scope) {
+ list.unshift(current.scope);
+ }
+ }
+ list.forEach(item => emitter.openNode(item));
+ }
+
+ /** @type {{type?: MatchType, index?: number, rule?: Mode}}} */
+ let lastMatch = {};
+
+ /**
+ * Process an individual match
+ *
+ * @param {string} textBeforeMatch - text preceding the match (since the last match)
+ * @param {EnhancedMatch} [match] - the match itself
+ */
+ function processLexeme(textBeforeMatch, match) {
+ const lexeme = match && match[0];
+
+ // add non-matched text to the current mode buffer
+ modeBuffer += textBeforeMatch;
+
+ if (lexeme == null) {
+ processBuffer();
+ return 0;
+ }
+
+ // we've found a 0 width match and we're stuck, so we need to advance
+ // this happens when we have badly behaved rules that have optional matchers to the degree that
+ // sometimes they can end up matching nothing at all
+ // Ref: https://github.com/highlightjs/highlight.js/issues/2140
+ if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
+ // spit the "skipped" character that our regex choked on back into the output sequence
+ modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
+ if (!SAFE_MODE) {
+ /** @type {AnnotatedError} */
+ const err = new Error(`0 width match regex (${languageName})`);
+ err.languageName = languageName;
+ err.badRule = lastMatch.rule;
+ throw err;
+ }
+ return 1;
+ }
+ lastMatch = match;
+
+ if (match.type === "begin") {
+ return doBeginMatch(match);
+ } else if (match.type === "illegal" && !ignoreIllegals) {
+ // illegal match, we do not continue processing
+ /** @type {AnnotatedError} */
+ const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || '') + '"');
+ err.mode = top;
+ throw err;
+ } else if (match.type === "end") {
+ const processed = doEndMatch(match);
+ if (processed !== NO_MATCH) {
+ return processed;
+ }
+ }
+
+ // edge case for when illegal matches $ (end of line) which is technically
+ // a 0 width match but not a begin/end match so it's not caught by the
+ // first handler (when ignoreIllegals is true)
+ if (match.type === "illegal" && lexeme === "") {
+ // advance so we aren't stuck in an infinite loop
+ return 1;
+ }
+
+ // infinite loops are BAD, this is a last ditch catch all. if we have a
+ // decent number of iterations yet our index (cursor position in our
+ // parsing) still 3x behind our index then something is very wrong
+ // so we bail
+ if (iterations > 100000 && iterations > match.index * 3) {
+ const err = new Error('potential infinite loop, way more iterations than matches');
+ throw err;
+ }
+
+ /*
+ Why might be find ourselves here? An potential end match that was
+ triggered but could not be completed. IE, `doEndMatch` returned NO_MATCH.
+ (this could be because a callback requests the match be ignored, etc)
+
+ This causes no real harm other than stopping a few times too many.
+ */
+
+ modeBuffer += lexeme;
+ return lexeme.length;
+ }
+
+ const language = getLanguage(languageName);
+ if (!language) {
+ error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
+ throw new Error('Unknown language: "' + languageName + '"');
+ }
+
+ const md = compileLanguage(language);
+ let result = '';
+ /** @type {CompiledMode} */
+ let top = continuation || md;
+ /** @type Record */
+ const continuations = {}; // keep continuations for sub-languages
+ const emitter = new options.__emitter(options);
+ processContinuations();
+ let modeBuffer = '';
+ let relevance = 0;
+ let index = 0;
+ let iterations = 0;
+ let resumeScanAtSamePosition = false;
+
+ try {
+ if (!language.__emitTokens) {
+ top.matcher.considerAll();
+
+ for (;;) {
+ iterations++;
+ if (resumeScanAtSamePosition) {
+ // only regexes not matched previously will now be
+ // considered for a potential match
+ resumeScanAtSamePosition = false;
+ } else {
+ top.matcher.considerAll();
+ }
+ top.matcher.lastIndex = index;
+
+ const match = top.matcher.exec(codeToHighlight);
+ // console.log("match", match[0], match.rule && match.rule.begin)
+
+ if (!match) break;
+
+ const beforeMatch = codeToHighlight.substring(index, match.index);
+ const processedCount = processLexeme(beforeMatch, match);
+ index = match.index + processedCount;
+ }
+ processLexeme(codeToHighlight.substring(index));
+ } else {
+ language.__emitTokens(codeToHighlight, emitter);
+ }
+
+ emitter.finalize();
+ result = emitter.toHTML();
+
+ return {
+ language: languageName,
+ value: result,
+ relevance,
+ illegal: false,
+ _emitter: emitter,
+ _top: top
+ };
+ } catch (err) {
+ if (err.message && err.message.includes('Illegal')) {
+ return {
+ language: languageName,
+ value: escape(codeToHighlight),
+ illegal: true,
+ relevance: 0,
+ _illegalBy: {
+ message: err.message,
+ index,
+ context: codeToHighlight.slice(index - 100, index + 100),
+ mode: err.mode,
+ resultSoFar: result
+ },
+ _emitter: emitter
+ };
+ } else if (SAFE_MODE) {
+ return {
+ language: languageName,
+ value: escape(codeToHighlight),
+ illegal: false,
+ relevance: 0,
+ errorRaised: err,
+ _emitter: emitter,
+ _top: top
+ };
+ } else {
+ throw err;
+ }
+ }
+ }
+
+ /**
+ * returns a valid highlight result, without actually doing any actual work,
+ * auto highlight starts with this and it's possible for small snippets that
+ * auto-detection may not find a better match
+ * @param {string} code
+ * @returns {HighlightResult}
+ */
+ function justTextHighlightResult(code) {
+ const result = {
+ value: escape(code),
+ illegal: false,
+ relevance: 0,
+ _top: PLAINTEXT_LANGUAGE,
+ _emitter: new options.__emitter(options)
+ };
+ result._emitter.addText(code);
+ return result;
+ }
+
+ /**
+ Highlighting with language detection. Accepts a string with the code to
+ highlight. Returns an object with the following properties:
+
+ - language (detected language)
+ - relevance (int)
+ - value (an HTML string with highlighting markup)
+ - secondBest (object with the same structure for second-best heuristically
+ detected language, may be absent)
+
+ @param {string} code
+ @param {Array} [languageSubset]
+ @returns {AutoHighlightResult}
+ */
+ function highlightAuto(code, languageSubset) {
+ languageSubset = languageSubset || options.languages || Object.keys(languages);
+ const plaintext = justTextHighlightResult(code);
+
+ const results = languageSubset.filter(getLanguage).filter(autoDetection).map(name =>
+ _highlight(name, code, false)
+ );
+ results.unshift(plaintext); // plaintext is always an option
+
+ const sorted = results.sort((a, b) => {
+ // sort base on relevance
+ if (a.relevance !== b.relevance) return b.relevance - a.relevance;
+
+ // always award the tie to the base language
+ // ie if C++ and Arduino are tied, it's more likely to be C++
+ if (a.language && b.language) {
+ if (getLanguage(a.language).supersetOf === b.language) {
+ return 1;
+ } else if (getLanguage(b.language).supersetOf === a.language) {
+ return -1;
+ }
+ }
+
+ // otherwise say they are equal, which has the effect of sorting on
+ // relevance while preserving the original ordering - which is how ties
+ // have historically been settled, ie the language that comes first always
+ // wins in the case of a tie
+ return 0;
+ });
+
+ const [best, secondBest] = sorted;
+
+ /** @type {AutoHighlightResult} */
+ const result = best;
+ result.secondBest = secondBest;
+
+ return result;
+ }
+
+ /**
+ * Builds new class name for block given the language name
+ *
+ * @param {HTMLElement} element
+ * @param {string} [currentLang]
+ * @param {string} [resultLang]
+ */
+ function updateClassName(element, currentLang, resultLang) {
+ const language = (currentLang && aliases[currentLang]) || resultLang;
+
+ element.classList.add("hljs");
+ element.classList.add(`language-${language}`);
+ }
+
+ /**
+ * Applies highlighting to a DOM node containing code.
+ *
+ * @param {HighlightedHTMLElement} element - the HTML element to highlight
+ */
+ function highlightElement(element) {
+ /** @type HTMLElement */
+ let node = null;
+ const language = blockLanguage(element);
+
+ if (shouldNotHighlight(language)) return;
+
+ fire("before:highlightElement",
+ { el: element, language });
+
+ if (element.dataset.highlighted) {
+ console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element);
+ return;
+ }
+
+ // we should be all text, no child nodes (unescaped HTML) - this is possibly
+ // an HTML injection attack - it's likely too late if this is already in
+ // production (the code has likely already done its damage by the time
+ // we're seeing it)... but we yell loudly about this so that hopefully it's
+ // more likely to be caught in development before making it to production
+ if (element.children.length > 0) {
+ if (!options.ignoreUnescapedHTML) {
+ console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
+ console.warn("https://github.com/highlightjs/highlight.js/wiki/security");
+ console.warn("The element with unescaped HTML:");
+ console.warn(element);
+ }
+ if (options.throwUnescapedHTML) {
+ const err = new HTMLInjectionError(
+ "One of your code blocks includes unescaped HTML.",
+ element.innerHTML
+ );
+ throw err;
+ }
+ }
+
+ node = element;
+ const text = node.textContent;
+ const result = language ? highlight(text, { language, ignoreIllegals: true }) : highlightAuto(text);
+
+ element.innerHTML = result.value;
+ element.dataset.highlighted = "yes";
+ updateClassName(element, language, result.language);
+ element.result = {
+ language: result.language,
+ // TODO: remove with version 11.0
+ re: result.relevance,
+ relevance: result.relevance
+ };
+ if (result.secondBest) {
+ element.secondBest = {
+ language: result.secondBest.language,
+ relevance: result.secondBest.relevance
+ };
+ }
+
+ fire("after:highlightElement", { el: element, result, text });
+ }
+
+ /**
+ * Updates highlight.js global options with the passed options
+ *
+ * @param {Partial} userOptions
+ */
+ function configure(userOptions) {
+ options = inherit(options, userOptions);
+ }
+
+ // TODO: remove v12, deprecated
+ const initHighlighting = () => {
+ highlightAll();
+ deprecated("10.6.0", "initHighlighting() deprecated. Use highlightAll() now.");
+ };
+
+ // TODO: remove v12, deprecated
+ function initHighlightingOnLoad() {
+ highlightAll();
+ deprecated("10.6.0", "initHighlightingOnLoad() deprecated. Use highlightAll() now.");
+ }
+
+ let wantsHighlight = false;
+
+ /**
+ * auto-highlights all pre>code elements on the page
+ */
+ function highlightAll() {
+ // if we are called too early in the loading process
+ if (document.readyState === "loading") {
+ wantsHighlight = true;
+ return;
+ }
+
+ const blocks = document.querySelectorAll(options.cssSelector);
+ blocks.forEach(highlightElement);
+ }
+
+ function boot() {
+ // if a highlight was requested before DOM was loaded, do now
+ if (wantsHighlight) highlightAll();
+ }
+
+ // make sure we are in the browser environment
+ if (typeof window !== 'undefined' && window.addEventListener) {
+ window.addEventListener('DOMContentLoaded', boot, false);
+ }
+
+ /**
+ * Register a language grammar module
+ *
+ * @param {string} languageName
+ * @param {LanguageFn} languageDefinition
+ */
+ function registerLanguage(languageName, languageDefinition) {
+ let lang = null;
+ try {
+ lang = languageDefinition(hljs);
+ } catch (error$1) {
+ error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+ // hard or soft error
+ if (!SAFE_MODE) { throw error$1; } else { error(error$1); }
+ // languages that have serious errors are replaced with essentially a
+ // "plaintext" stand-in so that the code blocks will still get normal
+ // css classes applied to them - and one bad language won't break the
+ // entire highlighter
+ lang = PLAINTEXT_LANGUAGE;
+ }
+ // give it a temporary name if it doesn't have one in the meta-data
+ if (!lang.name) lang.name = languageName;
+ languages[languageName] = lang;
+ lang.rawDefinition = languageDefinition.bind(null, hljs);
+
+ if (lang.aliases) {
+ registerAliases(lang.aliases, { languageName });
+ }
+ }
+
+ /**
+ * Remove a language grammar module
+ *
+ * @param {string} languageName
+ */
+ function unregisterLanguage(languageName) {
+ delete languages[languageName];
+ for (const alias of Object.keys(aliases)) {
+ if (aliases[alias] === languageName) {
+ delete aliases[alias];
+ }
+ }
+ }
+
+ /**
+ * @returns {string[]} List of language internal names
+ */
+ function listLanguages() {
+ return Object.keys(languages);
+ }
+
+ /**
+ * @param {string} name - name of the language to retrieve
+ * @returns {Language | undefined}
+ */
+ function getLanguage(name) {
+ name = (name || '').toLowerCase();
+ return languages[name] || languages[aliases[name]];
+ }
+
+ /**
+ *
+ * @param {string|string[]} aliasList - single alias or list of aliases
+ * @param {{languageName: string}} opts
+ */
+ function registerAliases(aliasList, { languageName }) {
+ if (typeof aliasList === 'string') {
+ aliasList = [aliasList];
+ }
+ aliasList.forEach(alias => { aliases[alias.toLowerCase()] = languageName; });
+ }
+
+ /**
+ * Determines if a given language has auto-detection enabled
+ * @param {string} name - name of the language
+ */
+ function autoDetection(name) {
+ const lang = getLanguage(name);
+ return lang && !lang.disableAutodetect;
+ }
+
+ /**
+ * Upgrades the old highlightBlock plugins to the new
+ * highlightElement API
+ * @param {HLJSPlugin} plugin
+ */
+ function upgradePluginAPI(plugin) {
+ // TODO: remove with v12
+ if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
+ plugin["before:highlightElement"] = (data) => {
+ plugin["before:highlightBlock"](
+ Object.assign({ block: data.el }, data)
+ );
+ };
+ }
+ if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
+ plugin["after:highlightElement"] = (data) => {
+ plugin["after:highlightBlock"](
+ Object.assign({ block: data.el }, data)
+ );
+ };
+ }
+ }
+
+ /**
+ * @param {HLJSPlugin} plugin
+ */
+ function addPlugin(plugin) {
+ upgradePluginAPI(plugin);
+ plugins.push(plugin);
+ }
+
+ /**
+ * @param {HLJSPlugin} plugin
+ */
+ function removePlugin(plugin) {
+ const index = plugins.indexOf(plugin);
+ if (index !== -1) {
+ plugins.splice(index, 1);
+ }
+ }
+
+ /**
+ *
+ * @param {PluginEvent} event
+ * @param {any} args
+ */
+ function fire(event, args) {
+ const cb = event;
+ plugins.forEach(function(plugin) {
+ if (plugin[cb]) {
+ plugin[cb](args);
+ }
+ });
+ }
+
+ /**
+ * DEPRECATED
+ * @param {HighlightedHTMLElement} el
+ */
+ function deprecateHighlightBlock(el) {
+ deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+ deprecated("10.7.0", "Please use highlightElement now.");
+
+ return highlightElement(el);
+ }
+
+ /* Interface definition */
+ Object.assign(hljs, {
+ highlight,
+ highlightAuto,
+ highlightAll,
+ highlightElement,
+ // TODO: Remove with v12 API
+ highlightBlock: deprecateHighlightBlock,
+ configure,
+ initHighlighting,
+ initHighlightingOnLoad,
+ registerLanguage,
+ unregisterLanguage,
+ listLanguages,
+ getLanguage,
+ registerAliases,
+ autoDetection,
+ inherit,
+ addPlugin,
+ removePlugin
+ });
+
+ hljs.debugMode = function() { SAFE_MODE = false; };
+ hljs.safeMode = function() { SAFE_MODE = true; };
+ hljs.versionString = version;
+
+ hljs.regex = {
+ concat: concat,
+ lookahead: lookahead,
+ either: either,
+ optional: optional,
+ anyNumberOfTimes: anyNumberOfTimes
+ };
+
+ for (const key in MODES) {
+ // @ts-ignore
+ if (typeof MODES[key] === "object") {
+ // @ts-ignore
+ deepFreeze(MODES[key]);
+ }
+ }
+
+ // merge all the modes/regexes into our main object
+ Object.assign(hljs, MODES);
+
+ return hljs;
+};
+
+// Other names for the variable may break build script
+const highlight = HLJS({});
+
+// returns a new instance of the highlighter to be used for extensions
+// check https://github.com/wooorm/lowlight/issues/47
+highlight.newInstance = () => HLJS({});
+
+export { highlight as default };
diff --git a/templates/hljs/es/highlight.min.js b/templates/hljs/es/highlight.min.js
new file mode 100644
index 0000000..c6d4ae5
--- /dev/null
+++ b/templates/hljs/es/highlight.min.js
@@ -0,0 +1,307 @@
+/*!
+ Highlight.js v11.9.0 (git: b7ec4bfafc)
+ (c) 2006-2023 undefined and other contributors
+ License: BSD-3-Clause
+ */
+function e(t){return t instanceof Map?t.clear=t.delete=t.set=()=>{
+throw Error("map is read-only")}:t instanceof Set&&(t.add=t.clear=t.delete=()=>{
+throw Error("set is read-only")
+}),Object.freeze(t),Object.getOwnPropertyNames(t).forEach((n=>{
+const i=t[n],s=typeof i;"object"!==s&&"function"!==s||Object.isFrozen(i)||e(i)
+})),t}class t{constructor(e){
+void 0===e.data&&(e.data={}),this.data=e.data,this.isMatchIgnored=!1}
+ignoreMatch(){this.isMatchIgnored=!0}}function n(e){
+return e.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")
+}function i(e,...t){const n=Object.create(null);for(const t in e)n[t]=e[t]
+;return t.forEach((e=>{for(const t in e)n[t]=e[t]})),n}const s=e=>!!e.scope
+;class r{constructor(e,t){
+this.buffer="",this.classPrefix=t.classPrefix,e.walk(this)}addText(e){
+this.buffer+=n(e)}openNode(e){if(!s(e))return;const t=((e,{prefix:t})=>{
+if(e.startsWith("language:"))return e.replace("language:","language-")
+;if(e.includes(".")){const n=e.split(".")
+;return[`${t}${n.shift()}`,...n.map(((e,t)=>`${e}${"_".repeat(t+1)}`))].join(" ")
+}return`${t}${e}`})(e.scope,{prefix:this.classPrefix});this.span(t)}
+closeNode(e){s(e)&&(this.buffer+="")}value(){return this.buffer}span(e){
+this.buffer+=``}}const o=(e={})=>{const t={children:[]}
+;return Object.assign(t,e),t};class a{constructor(){
+this.rootNode=o(),this.stack=[this.rootNode]}get top(){
+return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(e){
+this.top.children.push(e)}openNode(e){const t=o({scope:e})
+;this.add(t),this.stack.push(t)}closeNode(){
+if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){
+for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}
+walk(e){return this.constructor._walk(e,this.rootNode)}static _walk(e,t){
+return"string"==typeof t?e.addText(t):t.children&&(e.openNode(t),
+t.children.forEach((t=>this._walk(e,t))),e.closeNode(t)),e}static _collapse(e){
+"string"!=typeof e&&e.children&&(e.children.every((e=>"string"==typeof e))?e.children=[e.children.join("")]:e.children.forEach((e=>{
+a._collapse(e)})))}}class c extends a{constructor(e){super(),this.options=e}
+addText(e){""!==e&&this.add(e)}startScope(e){this.openNode(e)}endScope(){
+this.closeNode()}__addSublanguage(e,t){const n=e.root
+;t&&(n.scope="language:"+t),this.add(n)}toHTML(){
+return new r(this,this.options).value()}finalize(){
+return this.closeAllNodes(),!0}}function l(e){
+return e?"string"==typeof e?e:e.source:null}function g(e){return h("(?=",e,")")}
+function u(e){return h("(?:",e,")*")}function d(e){return h("(?:",e,")?")}
+function h(...e){return e.map((e=>l(e))).join("")}function f(...e){const t=(e=>{
+const t=e[e.length-1]
+;return"object"==typeof t&&t.constructor===Object?(e.splice(e.length-1,1),t):{}
+})(e);return"("+(t.capture?"":"?:")+e.map((e=>l(e))).join("|")+")"}
+function p(e){return RegExp(e.toString()+"|").exec("").length-1}
+const b=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
+;function m(e,{joinWith:t}){let n=0;return e.map((e=>{n+=1;const t=n
+;let i=l(e),s="";for(;i.length>0;){const e=b.exec(i);if(!e){s+=i;break}
+s+=i.substring(0,e.index),
+i=i.substring(e.index+e[0].length),"\\"===e[0][0]&&e[1]?s+="\\"+(Number(e[1])+t):(s+=e[0],
+"("===e[0]&&n++)}return s})).map((e=>`(${e})`)).join(t)}
+const E="[a-zA-Z]\\w*",x="[a-zA-Z_]\\w*",w="\\b\\d+(\\.\\d+)?",y="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",_="\\b(0b[01]+)",O={
+begin:"\\\\[\\s\\S]",relevance:0},k={scope:"string",begin:"'",end:"'",
+illegal:"\\n",contains:[O]},v={scope:"string",begin:'"',end:'"',illegal:"\\n",
+contains:[O]},N=(e,t,n={})=>{const s=i({scope:"comment",begin:e,end:t,
+contains:[]},n);s.contains.push({scope:"doctag",
+begin:"[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+end:/(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,excludeBegin:!0,relevance:0})
+;const r=f("I","a","is","so","us","to","at","if","in","it","on",/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,/[A-Za-z]+[-][a-z]+/,/[A-Za-z][a-z]{2,}/)
+;return s.contains.push({begin:h(/[ ]+/,"(",r,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),s
+},S=N("//","$"),M=N("/\\*","\\*/"),R=N("#","$");var A=Object.freeze({
+__proto__:null,APOS_STRING_MODE:k,BACKSLASH_ESCAPE:O,BINARY_NUMBER_MODE:{
+scope:"number",begin:_,relevance:0},BINARY_NUMBER_RE:_,COMMENT:N,
+C_BLOCK_COMMENT_MODE:M,C_LINE_COMMENT_MODE:S,C_NUMBER_MODE:{scope:"number",
+begin:y,relevance:0},C_NUMBER_RE:y,END_SAME_AS_BEGIN:e=>Object.assign(e,{
+"on:begin":(e,t)=>{t.data._beginMatch=e[1]},"on:end":(e,t)=>{
+t.data._beginMatch!==e[1]&&t.ignoreMatch()}}),HASH_COMMENT_MODE:R,IDENT_RE:E,
+MATCH_NOTHING_RE:/\b\B/,METHOD_GUARD:{begin:"\\.\\s*"+x,relevance:0},
+NUMBER_MODE:{scope:"number",begin:w,relevance:0},NUMBER_RE:w,
+PHRASAL_WORDS_MODE:{
+begin:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+},QUOTE_STRING_MODE:v,REGEXP_MODE:{scope:"regexp",begin:/\/(?=[^/\n]*\/)/,
+end:/\/[gimuy]*/,contains:[O,{begin:/\[/,end:/\]/,relevance:0,contains:[O]}]},
+RE_STARTERS_RE:"!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
+SHEBANG:(e={})=>{const t=/^#![ ]*\//
+;return e.binary&&(e.begin=h(t,/.*\b/,e.binary,/\b.*/)),i({scope:"meta",begin:t,
+end:/$/,relevance:0,"on:begin":(e,t)=>{0!==e.index&&t.ignoreMatch()}},e)},
+TITLE_MODE:{scope:"title",begin:E,relevance:0},UNDERSCORE_IDENT_RE:x,
+UNDERSCORE_TITLE_MODE:{scope:"title",begin:x,relevance:0}});function j(e,t){
+"."===e.input[e.index-1]&&t.ignoreMatch()}function I(e,t){
+void 0!==e.className&&(e.scope=e.className,delete e.className)}function T(e,t){
+t&&e.beginKeywords&&(e.begin="\\b("+e.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",
+e.__beforeBegin=j,e.keywords=e.keywords||e.beginKeywords,delete e.beginKeywords,
+void 0===e.relevance&&(e.relevance=0))}function L(e,t){
+Array.isArray(e.illegal)&&(e.illegal=f(...e.illegal))}function B(e,t){
+if(e.match){
+if(e.begin||e.end)throw Error("begin & end are not supported with match")
+;e.begin=e.match,delete e.match}}function P(e,t){
+void 0===e.relevance&&(e.relevance=1)}const D=(e,t)=>{if(!e.beforeMatch)return
+;if(e.starts)throw Error("beforeMatch cannot be used with starts")
+;const n=Object.assign({},e);Object.keys(e).forEach((t=>{delete e[t]
+})),e.keywords=n.keywords,e.begin=h(n.beforeMatch,g(n.begin)),e.starts={
+relevance:0,contains:[Object.assign(n,{endsParent:!0})]
+},e.relevance=0,delete n.beforeMatch
+},H=["of","and","for","in","not","or","if","then","parent","list","value"],C="keyword"
+;function $(e,t,n=C){const i=Object.create(null)
+;return"string"==typeof e?s(n,e.split(" ")):Array.isArray(e)?s(n,e):Object.keys(e).forEach((n=>{
+Object.assign(i,$(e[n],t,n))})),i;function s(e,n){
+t&&(n=n.map((e=>e.toLowerCase()))),n.forEach((t=>{const n=t.split("|")
+;i[n[0]]=[e,U(n[0],n[1])]}))}}function U(e,t){
+return t?Number(t):(e=>H.includes(e.toLowerCase()))(e)?0:1}const z={},W=e=>{
+console.error(e)},X=(e,...t)=>{console.log("WARN: "+e,...t)},G=(e,t)=>{
+z[`${e}/${t}`]||(console.log(`Deprecated as of ${e}. ${t}`),z[`${e}/${t}`]=!0)
+},K=Error();function F(e,t,{key:n}){let i=0;const s=e[n],r={},o={}
+;for(let e=1;e<=t.length;e++)o[e+i]=s[e],r[e+i]=!0,i+=p(t[e-1])
+;e[n]=o,e[n]._emit=r,e[n]._multi=!0}function Z(e){(e=>{
+e.scope&&"object"==typeof e.scope&&null!==e.scope&&(e.beginScope=e.scope,
+delete e.scope)})(e),"string"==typeof e.beginScope&&(e.beginScope={
+_wrap:e.beginScope}),"string"==typeof e.endScope&&(e.endScope={_wrap:e.endScope
+}),(e=>{if(Array.isArray(e.begin)){
+if(e.skip||e.excludeBegin||e.returnBegin)throw W("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
+K
+;if("object"!=typeof e.beginScope||null===e.beginScope)throw W("beginScope must be object"),
+K;F(e,e.begin,{key:"beginScope"}),e.begin=m(e.begin,{joinWith:""})}})(e),(e=>{
+if(Array.isArray(e.end)){
+if(e.skip||e.excludeEnd||e.returnEnd)throw W("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
+K
+;if("object"!=typeof e.endScope||null===e.endScope)throw W("endScope must be object"),
+K;F(e,e.end,{key:"endScope"}),e.end=m(e.end,{joinWith:""})}})(e)}function V(e){
+function t(t,n){
+return RegExp(l(t),"m"+(e.case_insensitive?"i":"")+(e.unicodeRegex?"u":"")+(n?"g":""))
+}class n{constructor(){
+this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}
+addRule(e,t){
+t.position=this.position++,this.matchIndexes[this.matchAt]=t,this.regexes.push([t,e]),
+this.matchAt+=p(e)+1}compile(){0===this.regexes.length&&(this.exec=()=>null)
+;const e=this.regexes.map((e=>e[1]));this.matcherRe=t(m(e,{joinWith:"|"
+}),!0),this.lastIndex=0}exec(e){this.matcherRe.lastIndex=this.lastIndex
+;const t=this.matcherRe.exec(e);if(!t)return null
+;const n=t.findIndex(((e,t)=>t>0&&void 0!==e)),i=this.matchIndexes[n]
+;return t.splice(0,n),Object.assign(t,i)}}class s{constructor(){
+this.rules=[],this.multiRegexes=[],
+this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(e){
+if(this.multiRegexes[e])return this.multiRegexes[e];const t=new n
+;return this.rules.slice(e).forEach((([e,n])=>t.addRule(e,n))),
+t.compile(),this.multiRegexes[e]=t,t}resumingScanAtSamePosition(){
+return 0!==this.regexIndex}considerAll(){this.regexIndex=0}addRule(e,t){
+this.rules.push([e,t]),"begin"===t.type&&this.count++}exec(e){
+const t=this.getMatcher(this.regexIndex);t.lastIndex=this.lastIndex
+;let n=t.exec(e)
+;if(this.resumingScanAtSamePosition())if(n&&n.index===this.lastIndex);else{
+const t=this.getMatcher(0);t.lastIndex=this.lastIndex+1,n=t.exec(e)}
+return n&&(this.regexIndex+=n.position+1,
+this.regexIndex===this.count&&this.considerAll()),n}}
+if(e.compilerExtensions||(e.compilerExtensions=[]),
+e.contains&&e.contains.includes("self"))throw Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.")
+;return e.classNameAliases=i(e.classNameAliases||{}),function n(r,o){const a=r
+;if(r.isCompiled)return a
+;[I,B,Z,D].forEach((e=>e(r,o))),e.compilerExtensions.forEach((e=>e(r,o))),
+r.__beforeBegin=null,[T,L,P].forEach((e=>e(r,o))),r.isCompiled=!0;let c=null
+;return"object"==typeof r.keywords&&r.keywords.$pattern&&(r.keywords=Object.assign({},r.keywords),
+c=r.keywords.$pattern,
+delete r.keywords.$pattern),c=c||/\w+/,r.keywords&&(r.keywords=$(r.keywords,e.case_insensitive)),
+a.keywordPatternRe=t(c,!0),
+o&&(r.begin||(r.begin=/\B|\b/),a.beginRe=t(a.begin),r.end||r.endsWithParent||(r.end=/\B|\b/),
+r.end&&(a.endRe=t(a.end)),
+a.terminatorEnd=l(a.end)||"",r.endsWithParent&&o.terminatorEnd&&(a.terminatorEnd+=(r.end?"|":"")+o.terminatorEnd)),
+r.illegal&&(a.illegalRe=t(r.illegal)),
+r.contains||(r.contains=[]),r.contains=[].concat(...r.contains.map((e=>(e=>(e.variants&&!e.cachedVariants&&(e.cachedVariants=e.variants.map((t=>i(e,{
+variants:null},t)))),e.cachedVariants?e.cachedVariants:q(e)?i(e,{
+starts:e.starts?i(e.starts):null
+}):Object.isFrozen(e)?i(e):e))("self"===e?r:e)))),r.contains.forEach((e=>{n(e,a)
+})),r.starts&&n(r.starts,o),a.matcher=(e=>{const t=new s
+;return e.contains.forEach((e=>t.addRule(e.begin,{rule:e,type:"begin"
+}))),e.terminatorEnd&&t.addRule(e.terminatorEnd,{type:"end"
+}),e.illegal&&t.addRule(e.illegal,{type:"illegal"}),t})(a),a}(e)}function q(e){
+return!!e&&(e.endsWithParent||q(e.starts))}class J extends Error{
+constructor(e,t){super(e),this.name="HTMLInjectionError",this.html=t}}
+const Y=n,Q=i,ee=Symbol("nomatch"),te=n=>{
+const i=Object.create(null),s=Object.create(null),r=[];let o=!0
+;const a="Could not find the language '{}', did you forget to load/include a language module?",l={
+disableAutodetect:!0,name:"Plain text",contains:[]};let p={
+ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,
+languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",
+cssSelector:"pre code",languages:null,__emitter:c};function b(e){
+return p.noHighlightRe.test(e)}function m(e,t,n){let i="",s=""
+;"object"==typeof t?(i=e,
+n=t.ignoreIllegals,s=t.language):(G("10.7.0","highlight(lang, code, ...args) has been deprecated."),
+G("10.7.0","Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),
+s=e,i=t),void 0===n&&(n=!0);const r={code:i,language:s};N("before:highlight",r)
+;const o=r.result?r.result:E(r.language,r.code,n)
+;return o.code=r.code,N("after:highlight",o),o}function E(e,n,s,r){
+const c=Object.create(null);function l(){if(!N.keywords)return void M.addText(R)
+;let e=0;N.keywordPatternRe.lastIndex=0;let t=N.keywordPatternRe.exec(R),n=""
+;for(;t;){n+=R.substring(e,t.index)
+;const s=_.case_insensitive?t[0].toLowerCase():t[0],r=(i=s,N.keywords[i]);if(r){
+const[e,i]=r
+;if(M.addText(n),n="",c[s]=(c[s]||0)+1,c[s]<=7&&(A+=i),e.startsWith("_"))n+=t[0];else{
+const n=_.classNameAliases[e]||e;u(t[0],n)}}else n+=t[0]
+;e=N.keywordPatternRe.lastIndex,t=N.keywordPatternRe.exec(R)}var i
+;n+=R.substring(e),M.addText(n)}function g(){null!=N.subLanguage?(()=>{
+if(""===R)return;let e=null;if("string"==typeof N.subLanguage){
+if(!i[N.subLanguage])return void M.addText(R)
+;e=E(N.subLanguage,R,!0,S[N.subLanguage]),S[N.subLanguage]=e._top
+}else e=x(R,N.subLanguage.length?N.subLanguage:null)
+;N.relevance>0&&(A+=e.relevance),M.__addSublanguage(e._emitter,e.language)
+})():l(),R=""}function u(e,t){
+""!==e&&(M.startScope(t),M.addText(e),M.endScope())}function d(e,t){let n=1
+;const i=t.length-1;for(;n<=i;){if(!e._emit[n]){n++;continue}
+const i=_.classNameAliases[e[n]]||e[n],s=t[n];i?u(s,i):(R=s,l(),R=""),n++}}
+function h(e,t){
+return e.scope&&"string"==typeof e.scope&&M.openNode(_.classNameAliases[e.scope]||e.scope),
+e.beginScope&&(e.beginScope._wrap?(u(R,_.classNameAliases[e.beginScope._wrap]||e.beginScope._wrap),
+R=""):e.beginScope._multi&&(d(e.beginScope,t),R="")),N=Object.create(e,{parent:{
+value:N}}),N}function f(e,n,i){let s=((e,t)=>{const n=e&&e.exec(t)
+;return n&&0===n.index})(e.endRe,i);if(s){if(e["on:end"]){const i=new t(e)
+;e["on:end"](n,i),i.isMatchIgnored&&(s=!1)}if(s){
+for(;e.endsParent&&e.parent;)e=e.parent;return e}}
+if(e.endsWithParent)return f(e.parent,n,i)}function b(e){
+return 0===N.matcher.regexIndex?(R+=e[0],1):(T=!0,0)}function m(e){
+const t=e[0],i=n.substring(e.index),s=f(N,e,i);if(!s)return ee;const r=N
+;N.endScope&&N.endScope._wrap?(g(),
+u(t,N.endScope._wrap)):N.endScope&&N.endScope._multi?(g(),
+d(N.endScope,e)):r.skip?R+=t:(r.returnEnd||r.excludeEnd||(R+=t),
+g(),r.excludeEnd&&(R=t));do{
+N.scope&&M.closeNode(),N.skip||N.subLanguage||(A+=N.relevance),N=N.parent
+}while(N!==s.parent);return s.starts&&h(s.starts,e),r.returnEnd?0:t.length}
+let w={};function y(i,r){const a=r&&r[0];if(R+=i,null==a)return g(),0
+;if("begin"===w.type&&"end"===r.type&&w.index===r.index&&""===a){
+if(R+=n.slice(r.index,r.index+1),!o){const t=Error(`0 width match regex (${e})`)
+;throw t.languageName=e,t.badRule=w.rule,t}return 1}
+if(w=r,"begin"===r.type)return(e=>{
+const n=e[0],i=e.rule,s=new t(i),r=[i.__beforeBegin,i["on:begin"]]
+;for(const t of r)if(t&&(t(e,s),s.isMatchIgnored))return b(n)
+;return i.skip?R+=n:(i.excludeBegin&&(R+=n),
+g(),i.returnBegin||i.excludeBegin||(R=n)),h(i,e),i.returnBegin?0:n.length})(r)
+;if("illegal"===r.type&&!s){
+const e=Error('Illegal lexeme "'+a+'" for mode "'+(N.scope||"")+'"')
+;throw e.mode=N,e}if("end"===r.type){const e=m(r);if(e!==ee)return e}
+if("illegal"===r.type&&""===a)return 1
+;if(I>1e5&&I>3*r.index)throw Error("potential infinite loop, way more iterations than matches")
+;return R+=a,a.length}const _=O(e)
+;if(!_)throw W(a.replace("{}",e)),Error('Unknown language: "'+e+'"')
+;const k=V(_);let v="",N=r||k;const S={},M=new p.__emitter(p);(()=>{const e=[]
+;for(let t=N;t!==_;t=t.parent)t.scope&&e.unshift(t.scope)
+;e.forEach((e=>M.openNode(e)))})();let R="",A=0,j=0,I=0,T=!1;try{
+if(_.__emitTokens)_.__emitTokens(n,M);else{for(N.matcher.considerAll();;){
+I++,T?T=!1:N.matcher.considerAll(),N.matcher.lastIndex=j
+;const e=N.matcher.exec(n);if(!e)break;const t=y(n.substring(j,e.index),e)
+;j=e.index+t}y(n.substring(j))}return M.finalize(),v=M.toHTML(),{language:e,
+value:v,relevance:A,illegal:!1,_emitter:M,_top:N}}catch(t){
+if(t.message&&t.message.includes("Illegal"))return{language:e,value:Y(n),
+illegal:!0,relevance:0,_illegalBy:{message:t.message,index:j,
+context:n.slice(j-100,j+100),mode:t.mode,resultSoFar:v},_emitter:M};if(o)return{
+language:e,value:Y(n),illegal:!1,relevance:0,errorRaised:t,_emitter:M,_top:N}
+;throw t}}function x(e,t){t=t||p.languages||Object.keys(i);const n=(e=>{
+const t={value:Y(e),illegal:!1,relevance:0,_top:l,_emitter:new p.__emitter(p)}
+;return t._emitter.addText(e),t})(e),s=t.filter(O).filter(v).map((t=>E(t,e,!1)))
+;s.unshift(n);const r=s.sort(((e,t)=>{
+if(e.relevance!==t.relevance)return t.relevance-e.relevance
+;if(e.language&&t.language){if(O(e.language).supersetOf===t.language)return 1
+;if(O(t.language).supersetOf===e.language)return-1}return 0})),[o,a]=r,c=o
+;return c.secondBest=a,c}function w(e){let t=null;const n=(e=>{
+let t=e.className+" ";t+=e.parentNode?e.parentNode.className:""
+;const n=p.languageDetectRe.exec(t);if(n){const t=O(n[1])
+;return t||(X(a.replace("{}",n[1])),
+X("Falling back to no-highlight mode for this block.",e)),t?n[1]:"no-highlight"}
+return t.split(/\s+/).find((e=>b(e)||O(e)))})(e);if(b(n))return
+;if(N("before:highlightElement",{el:e,language:n
+}),e.dataset.highlighted)return void console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",e)
+;if(e.children.length>0&&(p.ignoreUnescapedHTML||(console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),
+console.warn("https://github.com/highlightjs/highlight.js/wiki/security"),
+console.warn("The element with unescaped HTML:"),
+console.warn(e)),p.throwUnescapedHTML))throw new J("One of your code blocks includes unescaped HTML.",e.innerHTML)
+;t=e;const i=t.textContent,r=n?m(i,{language:n,ignoreIllegals:!0}):x(i)
+;e.innerHTML=r.value,e.dataset.highlighted="yes",((e,t,n)=>{const i=t&&s[t]||n
+;e.classList.add("hljs"),e.classList.add("language-"+i)
+})(e,n,r.language),e.result={language:r.language,re:r.relevance,
+relevance:r.relevance},r.secondBest&&(e.secondBest={
+language:r.secondBest.language,relevance:r.secondBest.relevance
+}),N("after:highlightElement",{el:e,result:r,text:i})}let y=!1;function _(){
+"loading"!==document.readyState?document.querySelectorAll(p.cssSelector).forEach(w):y=!0
+}function O(e){return e=(e||"").toLowerCase(),i[e]||i[s[e]]}
+function k(e,{languageName:t}){"string"==typeof e&&(e=[e]),e.forEach((e=>{
+s[e.toLowerCase()]=t}))}function v(e){const t=O(e)
+;return t&&!t.disableAutodetect}function N(e,t){const n=e;r.forEach((e=>{
+e[n]&&e[n](t)}))}
+"undefined"!=typeof window&&window.addEventListener&&window.addEventListener("DOMContentLoaded",(()=>{
+y&&_()}),!1),Object.assign(n,{highlight:m,highlightAuto:x,highlightAll:_,
+highlightElement:w,
+highlightBlock:e=>(G("10.7.0","highlightBlock will be removed entirely in v12.0"),
+G("10.7.0","Please use highlightElement now."),w(e)),configure:e=>{p=Q(p,e)},
+initHighlighting:()=>{
+_(),G("10.6.0","initHighlighting() deprecated. Use highlightAll() now.")},
+initHighlightingOnLoad:()=>{
+_(),G("10.6.0","initHighlightingOnLoad() deprecated. Use highlightAll() now.")
+},registerLanguage:(e,t)=>{let s=null;try{s=t(n)}catch(t){
+if(W("Language definition for '{}' could not be registered.".replace("{}",e)),
+!o)throw t;W(t),s=l}
+s.name||(s.name=e),i[e]=s,s.rawDefinition=t.bind(null,n),s.aliases&&k(s.aliases,{
+languageName:e})},unregisterLanguage:e=>{delete i[e]
+;for(const t of Object.keys(s))s[t]===e&&delete s[t]},
+listLanguages:()=>Object.keys(i),getLanguage:O,registerAliases:k,
+autoDetection:v,inherit:Q,addPlugin:e=>{(e=>{
+e["before:highlightBlock"]&&!e["before:highlightElement"]&&(e["before:highlightElement"]=t=>{
+e["before:highlightBlock"](Object.assign({block:t.el},t))
+}),e["after:highlightBlock"]&&!e["after:highlightElement"]&&(e["after:highlightElement"]=t=>{
+e["after:highlightBlock"](Object.assign({block:t.el},t))})})(e),r.push(e)},
+removePlugin:e=>{const t=r.indexOf(e);-1!==t&&r.splice(t,1)}}),n.debugMode=()=>{
+o=!1},n.safeMode=()=>{o=!0},n.versionString="11.9.0",n.regex={concat:h,
+lookahead:g,either:f,optional:d,anyNumberOfTimes:u}
+;for(const t in A)"object"==typeof A[t]&&e(A[t]);return Object.assign(n,A),n
+},ne=te({});ne.newInstance=()=>te({});export{ne as default};
\ No newline at end of file
diff --git a/templates/hljs/es/languages/markdown.js b/templates/hljs/es/languages/markdown.js
new file mode 100644
index 0000000..e4722d2
--- /dev/null
+++ b/templates/hljs/es/languages/markdown.js
@@ -0,0 +1,249 @@
+/*! `markdown` grammar compiled for Highlight.js 11.9.0 */
+var hljsGrammar = (function () {
+ 'use strict';
+
+ /*
+ Language: Markdown
+ Requires: xml.js
+ Author: John Crepezzi
+ Website: https://daringfireball.net/projects/markdown/
+ Category: common, markup
+ */
+
+ function markdown(hljs) {
+ const regex = hljs.regex;
+ const INLINE_HTML = {
+ begin: /<\/?[A-Za-z_]/,
+ end: '>',
+ subLanguage: 'xml',
+ relevance: 0
+ };
+ const HORIZONTAL_RULE = {
+ begin: '^[-\\*]{3,}',
+ end: '$'
+ };
+ const CODE = {
+ className: 'code',
+ variants: [
+ // TODO: fix to allow these to work with sublanguage also
+ { begin: '(`{3,})[^`](.|\\n)*?\\1`*[ ]*' },
+ { begin: '(~{3,})[^~](.|\\n)*?\\1~*[ ]*' },
+ // needed to allow markdown as a sublanguage to work
+ {
+ begin: '```',
+ end: '```+[ ]*$'
+ },
+ {
+ begin: '~~~',
+ end: '~~~+[ ]*$'
+ },
+ { begin: '`.+?`' },
+ {
+ begin: '(?=^( {4}|\\t))',
+ // use contains to gobble up multiple lines to allow the block to be whatever size
+ // but only have a single open/close tag vs one per line
+ contains: [
+ {
+ begin: '^( {4}|\\t)',
+ end: '(\\n)$'
+ }
+ ],
+ relevance: 0
+ }
+ ]
+ };
+ const LIST = {
+ className: 'bullet',
+ begin: '^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)',
+ end: '\\s+',
+ excludeEnd: true
+ };
+ const LINK_REFERENCE = {
+ begin: /^\[[^\n]+\]:/,
+ returnBegin: true,
+ contains: [
+ {
+ className: 'symbol',
+ begin: /\[/,
+ end: /\]/,
+ excludeBegin: true,
+ excludeEnd: true
+ },
+ {
+ className: 'link',
+ begin: /:\s*/,
+ end: /$/,
+ excludeBegin: true
+ }
+ ]
+ };
+ const URL_SCHEME = /[A-Za-z][A-Za-z0-9+.-]*/;
+ const LINK = {
+ variants: [
+ // too much like nested array access in so many languages
+ // to have any real relevance
+ {
+ begin: /\[.+?\]\[.*?\]/,
+ relevance: 0
+ },
+ // popular internet URLs
+ {
+ begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+ relevance: 2
+ },
+ {
+ begin: regex.concat(/\[.+?\]\(/, URL_SCHEME, /:\/\/.*?\)/),
+ relevance: 2
+ },
+ // relative urls
+ {
+ begin: /\[.+?\]\([./?].*?\)/,
+ relevance: 1
+ },
+ // whatever else, lower relevance (might not be a link at all)
+ {
+ begin: /\[.*?\]\(.*?\)/,
+ relevance: 0
+ }
+ ],
+ returnBegin: true,
+ contains: [
+ {
+ // empty strings for alt or link text
+ match: /\[(?=\])/ },
+ {
+ className: 'string',
+ relevance: 0,
+ begin: '\\[',
+ end: '\\]',
+ excludeBegin: true,
+ returnEnd: true
+ },
+ {
+ className: 'link',
+ relevance: 0,
+ begin: '\\]\\(',
+ end: '\\)',
+ excludeBegin: true,
+ excludeEnd: true
+ },
+ {
+ className: 'symbol',
+ relevance: 0,
+ begin: '\\]\\[',
+ end: '\\]',
+ excludeBegin: true,
+ excludeEnd: true
+ }
+ ]
+ };
+ const BOLD = {
+ className: 'strong',
+ contains: [], // defined later
+ variants: [
+ {
+ begin: /_{2}(?!\s)/,
+ end: /_{2}/
+ },
+ {
+ begin: /\*{2}(?!\s)/,
+ end: /\*{2}/
+ }
+ ]
+ };
+ const ITALIC = {
+ className: 'emphasis',
+ contains: [], // defined later
+ variants: [
+ {
+ begin: /\*(?![*\s])/,
+ end: /\*/
+ },
+ {
+ begin: /_(?![_\s])/,
+ end: /_/,
+ relevance: 0
+ }
+ ]
+ };
+
+ // 3 level deep nesting is not allowed because it would create confusion
+ // in cases like `***testing***` because where we don't know if the last
+ // `***` is starting a new bold/italic or finishing the last one
+ const BOLD_WITHOUT_ITALIC = hljs.inherit(BOLD, { contains: [] });
+ const ITALIC_WITHOUT_BOLD = hljs.inherit(ITALIC, { contains: [] });
+ BOLD.contains.push(ITALIC_WITHOUT_BOLD);
+ ITALIC.contains.push(BOLD_WITHOUT_ITALIC);
+
+ let CONTAINABLE = [
+ INLINE_HTML,
+ LINK
+ ];
+
+ [
+ BOLD,
+ ITALIC,
+ BOLD_WITHOUT_ITALIC,
+ ITALIC_WITHOUT_BOLD
+ ].forEach(m => {
+ m.contains = m.contains.concat(CONTAINABLE);
+ });
+
+ CONTAINABLE = CONTAINABLE.concat(BOLD, ITALIC);
+
+ const HEADER = {
+ className: 'section',
+ variants: [
+ {
+ begin: '^#{1,6}',
+ end: '$',
+ contains: CONTAINABLE
+ },
+ {
+ begin: '(?=^.+?\\n[=-]{2,}$)',
+ contains: [
+ { begin: '^[=-]*$' },
+ {
+ begin: '^',
+ end: "\\n",
+ contains: CONTAINABLE
+ }
+ ]
+ }
+ ]
+ };
+
+ const BLOCKQUOTE = {
+ className: 'quote',
+ begin: '^>\\s+',
+ contains: CONTAINABLE,
+ end: '$'
+ };
+
+ return {
+ name: 'Markdown',
+ aliases: [
+ 'md',
+ 'mkdown',
+ 'mkd'
+ ],
+ contains: [
+ HEADER,
+ INLINE_HTML,
+ LIST,
+ BOLD,
+ ITALIC,
+ BLOCKQUOTE,
+ CODE,
+ HORIZONTAL_RULE,
+ LINK,
+ LINK_REFERENCE
+ ]
+ };
+ }
+
+ return markdown;
+
+})();
+;
+export default hljsGrammar;
\ No newline at end of file
diff --git a/templates/hljs/es/languages/markdown.min.js b/templates/hljs/es/languages/markdown.min.js
new file mode 100644
index 0000000..3968746
--- /dev/null
+++ b/templates/hljs/es/languages/markdown.min.js
@@ -0,0 +1,31 @@
+/*! `markdown` grammar compiled for Highlight.js 11.9.0 */
+var hljsGrammar=(()=>{"use strict";return e=>{const n={begin:/<\/?[A-Za-z_]/,
+end:">",subLanguage:"xml",relevance:0},a={variants:[{begin:/\[.+?\]\[.*?\]/,
+relevance:0},{
+begin:/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+relevance:2},{
+begin:e.regex.concat(/\[.+?\]\(/,/[A-Za-z][A-Za-z0-9+.-]*/,/:\/\/.*?\)/),
+relevance:2},{begin:/\[.+?\]\([./?].*?\)/,relevance:1},{
+begin:/\[.*?\]\(.*?\)/,relevance:0}],returnBegin:!0,contains:[{match:/\[(?=\])/
+},{className:"string",relevance:0,begin:"\\[",end:"\\]",excludeBegin:!0,
+returnEnd:!0},{className:"link",relevance:0,begin:"\\]\\(",end:"\\)",
+excludeBegin:!0,excludeEnd:!0},{className:"symbol",relevance:0,begin:"\\]\\[",
+end:"\\]",excludeBegin:!0,excludeEnd:!0}]},i={className:"strong",contains:[],
+variants:[{begin:/_{2}(?!\s)/,end:/_{2}/},{begin:/\*{2}(?!\s)/,end:/\*{2}/}]
+},s={className:"emphasis",contains:[],variants:[{begin:/\*(?![*\s])/,end:/\*/},{
+begin:/_(?![_\s])/,end:/_/,relevance:0}]},c=e.inherit(i,{contains:[]
+}),t=e.inherit(s,{contains:[]});i.contains.push(t),s.contains.push(c)
+;let l=[n,a];return[i,s,c,t].forEach((e=>{e.contains=e.contains.concat(l)
+})),l=l.concat(i,s),{name:"Markdown",aliases:["md","mkdown","mkd"],contains:[{
+className:"section",variants:[{begin:"^#{1,6}",end:"$",contains:l},{
+begin:"(?=^.+?\\n[=-]{2,}$)",contains:[{begin:"^[=-]*$"},{begin:"^",end:"\\n",
+contains:l}]}]},n,{className:"bullet",begin:"^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
+end:"\\s+",excludeEnd:!0},i,s,{className:"quote",begin:"^>\\s+",contains:l,
+end:"$"},{className:"code",variants:[{begin:"(`{3,})[^`](.|\\n)*?\\1`*[ ]*"},{
+begin:"(~{3,})[^~](.|\\n)*?\\1~*[ ]*"},{begin:"```",end:"```+[ ]*$"},{
+begin:"~~~",end:"~~~+[ ]*$"},{begin:"`.+?`"},{begin:"(?=^( {4}|\\t))",
+contains:[{begin:"^( {4}|\\t)",end:"(\\n)$"}],relevance:0}]},{
+begin:"^[-\\*]{3,}",end:"$"},a,{begin:/^\[[^\n]+\]:/,returnBegin:!0,contains:[{
+className:"symbol",begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0},{
+className:"link",begin:/:\s*/,end:/$/,excludeBegin:!0}]}]}}})()
+;export default hljsGrammar;
\ No newline at end of file
diff --git a/templates/hljs/es/package.json b/templates/hljs/es/package.json
new file mode 100644
index 0000000..bb34440
--- /dev/null
+++ b/templates/hljs/es/package.json
@@ -0,0 +1 @@
+{ "type": "module" }
\ No newline at end of file
diff --git a/templates/hljs/highlight.js b/templates/hljs/highlight.js
new file mode 100644
index 0000000..da5c5b4
--- /dev/null
+++ b/templates/hljs/highlight.js
@@ -0,0 +1,2857 @@
+/*!
+ Highlight.js v11.9.0 (git: b7ec4bfafc)
+ (c) 2006-2023 undefined and other contributors
+ License: BSD-3-Clause
+ */
+var hljs = (function () {
+ 'use strict';
+
+ /* eslint-disable no-multi-assign */
+
+ function deepFreeze(obj) {
+ if (obj instanceof Map) {
+ obj.clear =
+ obj.delete =
+ obj.set =
+ function () {
+ throw new Error('map is read-only');
+ };
+ } else if (obj instanceof Set) {
+ obj.add =
+ obj.clear =
+ obj.delete =
+ function () {
+ throw new Error('set is read-only');
+ };
+ }
+
+ // Freeze self
+ Object.freeze(obj);
+
+ Object.getOwnPropertyNames(obj).forEach((name) => {
+ const prop = obj[name];
+ const type = typeof prop;
+
+ // Freeze prop if it is an object or function and also not already frozen
+ if ((type === 'object' || type === 'function') && !Object.isFrozen(prop)) {
+ deepFreeze(prop);
+ }
+ });
+
+ return obj;
+ }
+
+ /** @typedef {import('highlight.js').CallbackResponse} CallbackResponse */
+ /** @typedef {import('highlight.js').CompiledMode} CompiledMode */
+ /** @implements CallbackResponse */
+
+ class Response {
+ /**
+ * @param {CompiledMode} mode
+ */
+ constructor(mode) {
+ // eslint-disable-next-line no-undefined
+ if (mode.data === undefined) mode.data = {};
+
+ this.data = mode.data;
+ this.isMatchIgnored = false;
+ }
+
+ ignoreMatch() {
+ this.isMatchIgnored = true;
+ }
+ }
+
+ /**
+ * @param {string} value
+ * @returns {string}
+ */
+ function escapeHTML(value) {
+ return value
+ .replace(/&/g, '&')
+ .replace(//g, '>')
+ .replace(/"/g, '"')
+ .replace(/'/g, ''');
+ }
+
+ /**
+ * performs a shallow merge of multiple objects into one
+ *
+ * @template T
+ * @param {T} original
+ * @param {Record[]} objects
+ * @returns {T} a single new object
+ */
+ function inherit$1(original, ...objects) {
+ /** @type Record */
+ const result = Object.create(null);
+
+ for (const key in original) {
+ result[key] = original[key];
+ }
+ objects.forEach(function(obj) {
+ for (const key in obj) {
+ result[key] = obj[key];
+ }
+ });
+ return /** @type {T} */ (result);
+ }
+
+ /**
+ * @typedef {object} Renderer
+ * @property {(text: string) => void} addText
+ * @property {(node: Node) => void} openNode
+ * @property {(node: Node) => void} closeNode
+ * @property {() => string} value
+ */
+
+ /** @typedef {{scope?: string, language?: string, sublanguage?: boolean}} Node */
+ /** @typedef {{walk: (r: Renderer) => void}} Tree */
+ /** */
+
+ const SPAN_CLOSE = '';
+
+ /**
+ * Determines if a node needs to be wrapped in
+ *
+ * @param {Node} node */
+ const emitsWrappingTags = (node) => {
+ // rarely we can have a sublanguage where language is undefined
+ // TODO: track down why
+ return !!node.scope;
+ };
+
+ /**
+ *
+ * @param {string} name
+ * @param {{prefix:string}} options
+ */
+ const scopeToCSSClass = (name, { prefix }) => {
+ // sub-language
+ if (name.startsWith("language:")) {
+ return name.replace("language:", "language-");
+ }
+ // tiered scope: comment.line
+ if (name.includes(".")) {
+ const pieces = name.split(".");
+ return [
+ `${prefix}${pieces.shift()}`,
+ ...(pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`))
+ ].join(" ");
+ }
+ // simple scope
+ return `${prefix}${name}`;
+ };
+
+ /** @type {Renderer} */
+ class HTMLRenderer {
+ /**
+ * Creates a new HTMLRenderer
+ *
+ * @param {Tree} parseTree - the parse tree (must support `walk` API)
+ * @param {{classPrefix: string}} options
+ */
+ constructor(parseTree, options) {
+ this.buffer = "";
+ this.classPrefix = options.classPrefix;
+ parseTree.walk(this);
+ }
+
+ /**
+ * Adds texts to the output stream
+ *
+ * @param {string} text */
+ addText(text) {
+ this.buffer += escapeHTML(text);
+ }
+
+ /**
+ * Adds a node open to the output stream (if needed)
+ *
+ * @param {Node} node */
+ openNode(node) {
+ if (!emitsWrappingTags(node)) return;
+
+ const className = scopeToCSSClass(node.scope,
+ { prefix: this.classPrefix });
+ this.span(className);
+ }
+
+ /**
+ * Adds a node close to the output stream (if needed)
+ *
+ * @param {Node} node */
+ closeNode(node) {
+ if (!emitsWrappingTags(node)) return;
+
+ this.buffer += SPAN_CLOSE;
+ }
+
+ /**
+ * returns the accumulated buffer
+ */
+ value() {
+ return this.buffer;
+ }
+
+ // helpers
+
+ /**
+ * Builds a span element
+ *
+ * @param {string} className */
+ span(className) {
+ this.buffer += ``;
+ }
+ }
+
+ /** @typedef {{scope?: string, language?: string, children: Node[]} | string} Node */
+ /** @typedef {{scope?: string, language?: string, children: Node[]} } DataNode */
+ /** @typedef {import('highlight.js').Emitter} Emitter */
+ /** */
+
+ /** @returns {DataNode} */
+ const newNode = (opts = {}) => {
+ /** @type DataNode */
+ const result = { children: [] };
+ Object.assign(result, opts);
+ return result;
+ };
+
+ class TokenTree {
+ constructor() {
+ /** @type DataNode */
+ this.rootNode = newNode();
+ this.stack = [this.rootNode];
+ }
+
+ get top() {
+ return this.stack[this.stack.length - 1];
+ }
+
+ get root() { return this.rootNode; }
+
+ /** @param {Node} node */
+ add(node) {
+ this.top.children.push(node);
+ }
+
+ /** @param {string} scope */
+ openNode(scope) {
+ /** @type Node */
+ const node = newNode({ scope });
+ this.add(node);
+ this.stack.push(node);
+ }
+
+ closeNode() {
+ if (this.stack.length > 1) {
+ return this.stack.pop();
+ }
+ // eslint-disable-next-line no-undefined
+ return undefined;
+ }
+
+ closeAllNodes() {
+ while (this.closeNode());
+ }
+
+ toJSON() {
+ return JSON.stringify(this.rootNode, null, 4);
+ }
+
+ /**
+ * @typedef { import("./html_renderer").Renderer } Renderer
+ * @param {Renderer} builder
+ */
+ walk(builder) {
+ // this does not
+ return this.constructor._walk(builder, this.rootNode);
+ // this works
+ // return TokenTree._walk(builder, this.rootNode);
+ }
+
+ /**
+ * @param {Renderer} builder
+ * @param {Node} node
+ */
+ static _walk(builder, node) {
+ if (typeof node === "string") {
+ builder.addText(node);
+ } else if (node.children) {
+ builder.openNode(node);
+ node.children.forEach((child) => this._walk(builder, child));
+ builder.closeNode(node);
+ }
+ return builder;
+ }
+
+ /**
+ * @param {Node} node
+ */
+ static _collapse(node) {
+ if (typeof node === "string") return;
+ if (!node.children) return;
+
+ if (node.children.every(el => typeof el === "string")) {
+ // node.text = node.children.join("");
+ // delete node.children;
+ node.children = [node.children.join("")];
+ } else {
+ node.children.forEach((child) => {
+ TokenTree._collapse(child);
+ });
+ }
+ }
+ }
+
+ /**
+ Currently this is all private API, but this is the minimal API necessary
+ that an Emitter must implement to fully support the parser.
+
+ Minimal interface:
+
+ - addText(text)
+ - __addSublanguage(emitter, subLanguageName)
+ - startScope(scope)
+ - endScope()
+ - finalize()
+ - toHTML()
+
+ */
+
+ /**
+ * @implements {Emitter}
+ */
+ class TokenTreeEmitter extends TokenTree {
+ /**
+ * @param {*} options
+ */
+ constructor(options) {
+ super();
+ this.options = options;
+ }
+
+ /**
+ * @param {string} text
+ */
+ addText(text) {
+ if (text === "") { return; }
+
+ this.add(text);
+ }
+
+ /** @param {string} scope */
+ startScope(scope) {
+ this.openNode(scope);
+ }
+
+ endScope() {
+ this.closeNode();
+ }
+
+ /**
+ * @param {Emitter & {root: DataNode}} emitter
+ * @param {string} name
+ */
+ __addSublanguage(emitter, name) {
+ /** @type DataNode */
+ const node = emitter.root;
+ if (name) node.scope = `language:${name}`;
+
+ this.add(node);
+ }
+
+ toHTML() {
+ const renderer = new HTMLRenderer(this, this.options);
+ return renderer.value();
+ }
+
+ finalize() {
+ this.closeAllNodes();
+ return true;
+ }
+ }
+
+ /**
+ * @param {string} value
+ * @returns {RegExp}
+ * */
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function source(re) {
+ if (!re) return null;
+ if (typeof re === "string") return re;
+
+ return re.source;
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function lookahead(re) {
+ return concat('(?=', re, ')');
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function anyNumberOfTimes(re) {
+ return concat('(?:', re, ')*');
+ }
+
+ /**
+ * @param {RegExp | string } re
+ * @returns {string}
+ */
+ function optional(re) {
+ return concat('(?:', re, ')?');
+ }
+
+ /**
+ * @param {...(RegExp | string) } args
+ * @returns {string}
+ */
+ function concat(...args) {
+ const joined = args.map((x) => source(x)).join("");
+ return joined;
+ }
+
+ /**
+ * @param { Array } args
+ * @returns {object}
+ */
+ function stripOptionsFromArgs(args) {
+ const opts = args[args.length - 1];
+
+ if (typeof opts === 'object' && opts.constructor === Object) {
+ args.splice(args.length - 1, 1);
+ return opts;
+ } else {
+ return {};
+ }
+ }
+
+ /** @typedef { {capture?: boolean} } RegexEitherOptions */
+
+ /**
+ * Any of the passed expresssions may match
+ *
+ * Creates a huge this | this | that | that match
+ * @param {(RegExp | string)[] | [...(RegExp | string)[], RegexEitherOptions]} args
+ * @returns {string}
+ */
+ function either(...args) {
+ /** @type { object & {capture?: boolean} } */
+ const opts = stripOptionsFromArgs(args);
+ const joined = '('
+ + (opts.capture ? "" : "?:")
+ + args.map((x) => source(x)).join("|") + ")";
+ return joined;
+ }
+
+ /**
+ * @param {RegExp | string} re
+ * @returns {number}
+ */
+ function countMatchGroups(re) {
+ return (new RegExp(re.toString() + '|')).exec('').length - 1;
+ }
+
+ /**
+ * Does lexeme start with a regular expression match at the beginning
+ * @param {RegExp} re
+ * @param {string} lexeme
+ */
+ function startsWith(re, lexeme) {
+ const match = re && re.exec(lexeme);
+ return match && match.index === 0;
+ }
+
+ // BACKREF_RE matches an open parenthesis or backreference. To avoid
+ // an incorrect parse, it additionally matches the following:
+ // - [...] elements, where the meaning of parentheses and escapes change
+ // - other escape sequences, so we do not misparse escape sequences as
+ // interesting elements
+ // - non-matching or lookahead parentheses, which do not capture. These
+ // follow the '(' with a '?'.
+ const BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+
+ // **INTERNAL** Not intended for outside usage
+ // join logically computes regexps.join(separator), but fixes the
+ // backreferences so they continue to match.
+ // it also places each individual regular expression into it's own
+ // match group, keeping track of the sequencing of those match groups
+ // is currently an exercise for the caller. :-)
+ /**
+ * @param {(string | RegExp)[]} regexps
+ * @param {{joinWith: string}} opts
+ * @returns {string}
+ */
+ function _rewriteBackreferences(regexps, { joinWith }) {
+ let numCaptures = 0;
+
+ return regexps.map((regex) => {
+ numCaptures += 1;
+ const offset = numCaptures;
+ let re = source(regex);
+ let out = '';
+
+ while (re.length > 0) {
+ const match = BACKREF_RE.exec(re);
+ if (!match) {
+ out += re;
+ break;
+ }
+ out += re.substring(0, match.index);
+ re = re.substring(match.index + match[0].length);
+ if (match[0][0] === '\\' && match[1]) {
+ // Adjust the backreference.
+ out += '\\' + String(Number(match[1]) + offset);
+ } else {
+ out += match[0];
+ if (match[0] === '(') {
+ numCaptures++;
+ }
+ }
+ }
+ return out;
+ }).map(re => `(${re})`).join(joinWith);
+ }
+
+ /** @typedef {import('highlight.js').Mode} Mode */
+ /** @typedef {import('highlight.js').ModeCallback} ModeCallback */
+
+ // Common regexps
+ const MATCH_NOTHING_RE = /\b\B/;
+ const IDENT_RE = '[a-zA-Z]\\w*';
+ const UNDERSCORE_IDENT_RE = '[a-zA-Z_]\\w*';
+ const NUMBER_RE = '\\b\\d+(\\.\\d+)?';
+ const C_NUMBER_RE = '(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)'; // 0x..., 0..., decimal, float
+ const BINARY_NUMBER_RE = '\\b(0b[01]+)'; // 0b...
+ const RE_STARTERS_RE = '!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~';
+
+ /**
+ * @param { Partial & {binary?: string | RegExp} } opts
+ */
+ const SHEBANG = (opts = {}) => {
+ const beginShebang = /^#![ ]*\//;
+ if (opts.binary) {
+ opts.begin = concat(
+ beginShebang,
+ /.*\b/,
+ opts.binary,
+ /\b.*/);
+ }
+ return inherit$1({
+ scope: 'meta',
+ begin: beginShebang,
+ end: /$/,
+ relevance: 0,
+ /** @type {ModeCallback} */
+ "on:begin": (m, resp) => {
+ if (m.index !== 0) resp.ignoreMatch();
+ }
+ }, opts);
+ };
+
+ // Common modes
+ const BACKSLASH_ESCAPE = {
+ begin: '\\\\[\\s\\S]', relevance: 0
+ };
+ const APOS_STRING_MODE = {
+ scope: 'string',
+ begin: '\'',
+ end: '\'',
+ illegal: '\\n',
+ contains: [BACKSLASH_ESCAPE]
+ };
+ const QUOTE_STRING_MODE = {
+ scope: 'string',
+ begin: '"',
+ end: '"',
+ illegal: '\\n',
+ contains: [BACKSLASH_ESCAPE]
+ };
+ const PHRASAL_WORDS_MODE = {
+ begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+ };
+ /**
+ * Creates a comment mode
+ *
+ * @param {string | RegExp} begin
+ * @param {string | RegExp} end
+ * @param {Mode | {}} [modeOptions]
+ * @returns {Partial}
+ */
+ const COMMENT = function(begin, end, modeOptions = {}) {
+ const mode = inherit$1(
+ {
+ scope: 'comment',
+ begin,
+ end,
+ contains: []
+ },
+ modeOptions
+ );
+ mode.contains.push({
+ scope: 'doctag',
+ // hack to avoid the space from being included. the space is necessary to
+ // match here to prevent the plain text rule below from gobbling up doctags
+ begin: '[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)',
+ end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+ excludeBegin: true,
+ relevance: 0
+ });
+ const ENGLISH_WORD = either(
+ // list of common 1 and 2 letter words in English
+ "I",
+ "a",
+ "is",
+ "so",
+ "us",
+ "to",
+ "at",
+ "if",
+ "in",
+ "it",
+ "on",
+ // note: this is not an exhaustive list of contractions, just popular ones
+ /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, // contractions - can't we'd they're let's, etc
+ /[A-Za-z]+[-][a-z]+/, // `no-way`, etc.
+ /[A-Za-z][a-z]{2,}/ // allow capitalized words at beginning of sentences
+ );
+ // looking like plain text, more likely to be a comment
+ mode.contains.push(
+ {
+ // TODO: how to include ", (, ) without breaking grammars that use these for
+ // comment delimiters?
+ // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
+ // ---
+
+ // this tries to find sequences of 3 english words in a row (without any
+ // "programming" type syntax) this gives us a strong signal that we've
+ // TRULY found a comment - vs perhaps scanning with the wrong language.
+ // It's possible to find something that LOOKS like the start of the
+ // comment - but then if there is no readable text - good chance it is a
+ // false match and not a comment.
+ //
+ // for a visual example please see:
+ // https://github.com/highlightjs/highlight.js/issues/2827
+
+ begin: concat(
+ /[ ]+/, // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+ '(',
+ ENGLISH_WORD,
+ /[.]?[:]?([.][ ]|[ ])/,
+ '){3}') // look for 3 words in a row
+ }
+ );
+ return mode;
+ };
+ const C_LINE_COMMENT_MODE = COMMENT('//', '$');
+ const C_BLOCK_COMMENT_MODE = COMMENT('/\\*', '\\*/');
+ const HASH_COMMENT_MODE = COMMENT('#', '$');
+ const NUMBER_MODE = {
+ scope: 'number',
+ begin: NUMBER_RE,
+ relevance: 0
+ };
+ const C_NUMBER_MODE = {
+ scope: 'number',
+ begin: C_NUMBER_RE,
+ relevance: 0
+ };
+ const BINARY_NUMBER_MODE = {
+ scope: 'number',
+ begin: BINARY_NUMBER_RE,
+ relevance: 0
+ };
+ const REGEXP_MODE = {
+ scope: "regexp",
+ begin: /\/(?=[^/\n]*\/)/,
+ end: /\/[gimuy]*/,
+ contains: [
+ BACKSLASH_ESCAPE,
+ {
+ begin: /\[/,
+ end: /\]/,
+ relevance: 0,
+ contains: [BACKSLASH_ESCAPE]
+ }
+ ]
+ };
+ const TITLE_MODE = {
+ scope: 'title',
+ begin: IDENT_RE,
+ relevance: 0
+ };
+ const UNDERSCORE_TITLE_MODE = {
+ scope: 'title',
+ begin: UNDERSCORE_IDENT_RE,
+ relevance: 0
+ };
+ const METHOD_GUARD = {
+ // excludes method names from keyword processing
+ begin: '\\.\\s*' + UNDERSCORE_IDENT_RE,
+ relevance: 0
+ };
+
+ /**
+ * Adds end same as begin mechanics to a mode
+ *
+ * Your mode must include at least a single () match group as that first match
+ * group is what is used for comparison
+ * @param {Partial} mode
+ */
+ const END_SAME_AS_BEGIN = function(mode) {
+ return Object.assign(mode,
+ {
+ /** @type {ModeCallback} */
+ 'on:begin': (m, resp) => { resp.data._beginMatch = m[1]; },
+ /** @type {ModeCallback} */
+ 'on:end': (m, resp) => { if (resp.data._beginMatch !== m[1]) resp.ignoreMatch(); }
+ });
+ };
+
+ var MODES = /*#__PURE__*/Object.freeze({
+ __proto__: null,
+ APOS_STRING_MODE: APOS_STRING_MODE,
+ BACKSLASH_ESCAPE: BACKSLASH_ESCAPE,
+ BINARY_NUMBER_MODE: BINARY_NUMBER_MODE,
+ BINARY_NUMBER_RE: BINARY_NUMBER_RE,
+ COMMENT: COMMENT,
+ C_BLOCK_COMMENT_MODE: C_BLOCK_COMMENT_MODE,
+ C_LINE_COMMENT_MODE: C_LINE_COMMENT_MODE,
+ C_NUMBER_MODE: C_NUMBER_MODE,
+ C_NUMBER_RE: C_NUMBER_RE,
+ END_SAME_AS_BEGIN: END_SAME_AS_BEGIN,
+ HASH_COMMENT_MODE: HASH_COMMENT_MODE,
+ IDENT_RE: IDENT_RE,
+ MATCH_NOTHING_RE: MATCH_NOTHING_RE,
+ METHOD_GUARD: METHOD_GUARD,
+ NUMBER_MODE: NUMBER_MODE,
+ NUMBER_RE: NUMBER_RE,
+ PHRASAL_WORDS_MODE: PHRASAL_WORDS_MODE,
+ QUOTE_STRING_MODE: QUOTE_STRING_MODE,
+ REGEXP_MODE: REGEXP_MODE,
+ RE_STARTERS_RE: RE_STARTERS_RE,
+ SHEBANG: SHEBANG,
+ TITLE_MODE: TITLE_MODE,
+ UNDERSCORE_IDENT_RE: UNDERSCORE_IDENT_RE,
+ UNDERSCORE_TITLE_MODE: UNDERSCORE_TITLE_MODE
+ });
+
+ /**
+ @typedef {import('highlight.js').CallbackResponse} CallbackResponse
+ @typedef {import('highlight.js').CompilerExt} CompilerExt
+ */
+
+ // Grammar extensions / plugins
+ // See: https://github.com/highlightjs/highlight.js/issues/2833
+
+ // Grammar extensions allow "syntactic sugar" to be added to the grammar modes
+ // without requiring any underlying changes to the compiler internals.
+
+ // `compileMatch` being the perfect small example of now allowing a grammar
+ // author to write `match` when they desire to match a single expression rather
+ // than being forced to use `begin`. The extension then just moves `match` into
+ // `begin` when it runs. Ie, no features have been added, but we've just made
+ // the experience of writing (and reading grammars) a little bit nicer.
+
+ // ------
+
+ // TODO: We need negative look-behind support to do this properly
+ /**
+ * Skip a match if it has a preceding dot
+ *
+ * This is used for `beginKeywords` to prevent matching expressions such as
+ * `bob.keyword.do()`. The mode compiler automatically wires this up as a
+ * special _internal_ 'on:begin' callback for modes with `beginKeywords`
+ * @param {RegExpMatchArray} match
+ * @param {CallbackResponse} response
+ */
+ function skipIfHasPrecedingDot(match, response) {
+ const before = match.input[match.index - 1];
+ if (before === ".") {
+ response.ignoreMatch();
+ }
+ }
+
+ /**
+ *
+ * @type {CompilerExt}
+ */
+ function scopeClassName(mode, _parent) {
+ // eslint-disable-next-line no-undefined
+ if (mode.className !== undefined) {
+ mode.scope = mode.className;
+ delete mode.className;
+ }
+ }
+
+ /**
+ * `beginKeywords` syntactic sugar
+ * @type {CompilerExt}
+ */
+ function beginKeywords(mode, parent) {
+ if (!parent) return;
+ if (!mode.beginKeywords) return;
+
+ // for languages with keywords that include non-word characters checking for
+ // a word boundary is not sufficient, so instead we check for a word boundary
+ // or whitespace - this does no harm in any case since our keyword engine
+ // doesn't allow spaces in keywords anyways and we still check for the boundary
+ // first
+ mode.begin = '\\b(' + mode.beginKeywords.split(' ').join('|') + ')(?!\\.)(?=\\b|\\s)';
+ mode.__beforeBegin = skipIfHasPrecedingDot;
+ mode.keywords = mode.keywords || mode.beginKeywords;
+ delete mode.beginKeywords;
+
+ // prevents double relevance, the keywords themselves provide
+ // relevance, the mode doesn't need to double it
+ // eslint-disable-next-line no-undefined
+ if (mode.relevance === undefined) mode.relevance = 0;
+ }
+
+ /**
+ * Allow `illegal` to contain an array of illegal values
+ * @type {CompilerExt}
+ */
+ function compileIllegal(mode, _parent) {
+ if (!Array.isArray(mode.illegal)) return;
+
+ mode.illegal = either(...mode.illegal);
+ }
+
+ /**
+ * `match` to match a single expression for readability
+ * @type {CompilerExt}
+ */
+ function compileMatch(mode, _parent) {
+ if (!mode.match) return;
+ if (mode.begin || mode.end) throw new Error("begin & end are not supported with match");
+
+ mode.begin = mode.match;
+ delete mode.match;
+ }
+
+ /**
+ * provides the default 1 relevance to all modes
+ * @type {CompilerExt}
+ */
+ function compileRelevance(mode, _parent) {
+ // eslint-disable-next-line no-undefined
+ if (mode.relevance === undefined) mode.relevance = 1;
+ }
+
+ // allow beforeMatch to act as a "qualifier" for the match
+ // the full match begin must be [beforeMatch][begin]
+ const beforeMatchExt = (mode, parent) => {
+ if (!mode.beforeMatch) return;
+ // starts conflicts with endsParent which we need to make sure the child
+ // rule is not matched multiple times
+ if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
+
+ const originalMode = Object.assign({}, mode);
+ Object.keys(mode).forEach((key) => { delete mode[key]; });
+
+ mode.keywords = originalMode.keywords;
+ mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+ mode.starts = {
+ relevance: 0,
+ contains: [
+ Object.assign(originalMode, { endsParent: true })
+ ]
+ };
+ mode.relevance = 0;
+
+ delete originalMode.beforeMatch;
+ };
+
+ // keywords that should have no default relevance value
+ const COMMON_KEYWORDS = [
+ 'of',
+ 'and',
+ 'for',
+ 'in',
+ 'not',
+ 'or',
+ 'if',
+ 'then',
+ 'parent', // common variable name
+ 'list', // common variable name
+ 'value' // common variable name
+ ];
+
+ const DEFAULT_KEYWORD_SCOPE = "keyword";
+
+ /**
+ * Given raw keywords from a language definition, compile them.
+ *
+ * @param {string | Record | Array} rawKeywords
+ * @param {boolean} caseInsensitive
+ */
+ function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
+ /** @type {import("highlight.js/private").KeywordDict} */
+ const compiledKeywords = Object.create(null);
+
+ // input can be a string of keywords, an array of keywords, or a object with
+ // named keys representing scopeName (which can then point to a string or array)
+ if (typeof rawKeywords === 'string') {
+ compileList(scopeName, rawKeywords.split(" "));
+ } else if (Array.isArray(rawKeywords)) {
+ compileList(scopeName, rawKeywords);
+ } else {
+ Object.keys(rawKeywords).forEach(function(scopeName) {
+ // collapse all our objects back into the parent object
+ Object.assign(
+ compiledKeywords,
+ compileKeywords(rawKeywords[scopeName], caseInsensitive, scopeName)
+ );
+ });
+ }
+ return compiledKeywords;
+
+ // ---
+
+ /**
+ * Compiles an individual list of keywords
+ *
+ * Ex: "for if when while|5"
+ *
+ * @param {string} scopeName
+ * @param {Array} keywordList
+ */
+ function compileList(scopeName, keywordList) {
+ if (caseInsensitive) {
+ keywordList = keywordList.map(x => x.toLowerCase());
+ }
+ keywordList.forEach(function(keyword) {
+ const pair = keyword.split('|');
+ compiledKeywords[pair[0]] = [scopeName, scoreForKeyword(pair[0], pair[1])];
+ });
+ }
+ }
+
+ /**
+ * Returns the proper score for a given keyword
+ *
+ * Also takes into account comment keywords, which will be scored 0 UNLESS
+ * another score has been manually assigned.
+ * @param {string} keyword
+ * @param {string} [providedScore]
+ */
+ function scoreForKeyword(keyword, providedScore) {
+ // manual scores always win over common keywords
+ // so you can force a score of 1 if you really insist
+ if (providedScore) {
+ return Number(providedScore);
+ }
+
+ return commonKeyword(keyword) ? 0 : 1;
+ }
+
+ /**
+ * Determines if a given keyword is common or not
+ *
+ * @param {string} keyword */
+ function commonKeyword(keyword) {
+ return COMMON_KEYWORDS.includes(keyword.toLowerCase());
+ }
+
+ /*
+
+ For the reasoning behind this please see:
+ https://github.com/highlightjs/highlight.js/issues/2880#issuecomment-747275419
+
+ */
+
+ /**
+ * @type {Record}
+ */
+ const seenDeprecations = {};
+
+ /**
+ * @param {string} message
+ */
+ const error = (message) => {
+ console.error(message);
+ };
+
+ /**
+ * @param {string} message
+ * @param {any} args
+ */
+ const warn = (message, ...args) => {
+ console.log(`WARN: ${message}`, ...args);
+ };
+
+ /**
+ * @param {string} version
+ * @param {string} message
+ */
+ const deprecated = (version, message) => {
+ if (seenDeprecations[`${version}/${message}`]) return;
+
+ console.log(`Deprecated as of ${version}. ${message}`);
+ seenDeprecations[`${version}/${message}`] = true;
+ };
+
+ /* eslint-disable no-throw-literal */
+
+ /**
+ @typedef {import('highlight.js').CompiledMode} CompiledMode
+ */
+
+ const MultiClassError = new Error();
+
+ /**
+ * Renumbers labeled scope names to account for additional inner match
+ * groups that otherwise would break everything.
+ *
+ * Lets say we 3 match scopes:
+ *
+ * { 1 => ..., 2 => ..., 3 => ... }
+ *
+ * So what we need is a clean match like this:
+ *
+ * (a)(b)(c) => [ "a", "b", "c" ]
+ *
+ * But this falls apart with inner match groups:
+ *
+ * (a)(((b)))(c) => ["a", "b", "b", "b", "c" ]
+ *
+ * Our scopes are now "out of alignment" and we're repeating `b` 3 times.
+ * What needs to happen is the numbers are remapped:
+ *
+ * { 1 => ..., 2 => ..., 5 => ... }
+ *
+ * We also need to know that the ONLY groups that should be output
+ * are 1, 2, and 5. This function handles this behavior.
+ *
+ * @param {CompiledMode} mode
+ * @param {Array} regexes
+ * @param {{key: "beginScope"|"endScope"}} opts
+ */
+ function remapScopeNames(mode, regexes, { key }) {
+ let offset = 0;
+ const scopeNames = mode[key];
+ /** @type Record */
+ const emit = {};
+ /** @type Record */
+ const positions = {};
+
+ for (let i = 1; i <= regexes.length; i++) {
+ positions[i + offset] = scopeNames[i];
+ emit[i + offset] = true;
+ offset += countMatchGroups(regexes[i - 1]);
+ }
+ // we use _emit to keep track of which match groups are "top-level" to avoid double
+ // output from inside match groups
+ mode[key] = positions;
+ mode[key]._emit = emit;
+ mode[key]._multi = true;
+ }
+
+ /**
+ * @param {CompiledMode} mode
+ */
+ function beginMultiClass(mode) {
+ if (!Array.isArray(mode.begin)) return;
+
+ if (mode.skip || mode.excludeBegin || mode.returnBegin) {
+ error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
+ throw MultiClassError;
+ }
+
+ if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
+ error("beginScope must be object");
+ throw MultiClassError;
+ }
+
+ remapScopeNames(mode, mode.begin, { key: "beginScope" });
+ mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
+ }
+
+ /**
+ * @param {CompiledMode} mode
+ */
+ function endMultiClass(mode) {
+ if (!Array.isArray(mode.end)) return;
+
+ if (mode.skip || mode.excludeEnd || mode.returnEnd) {
+ error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
+ throw MultiClassError;
+ }
+
+ if (typeof mode.endScope !== "object" || mode.endScope === null) {
+ error("endScope must be object");
+ throw MultiClassError;
+ }
+
+ remapScopeNames(mode, mode.end, { key: "endScope" });
+ mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
+ }
+
+ /**
+ * this exists only to allow `scope: {}` to be used beside `match:`
+ * Otherwise `beginScope` would necessary and that would look weird
+
+ {
+ match: [ /def/, /\w+/ ]
+ scope: { 1: "keyword" , 2: "title" }
+ }
+
+ * @param {CompiledMode} mode
+ */
+ function scopeSugar(mode) {
+ if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
+ mode.beginScope = mode.scope;
+ delete mode.scope;
+ }
+ }
+
+ /**
+ * @param {CompiledMode} mode
+ */
+ function MultiClass(mode) {
+ scopeSugar(mode);
+
+ if (typeof mode.beginScope === "string") {
+ mode.beginScope = { _wrap: mode.beginScope };
+ }
+ if (typeof mode.endScope === "string") {
+ mode.endScope = { _wrap: mode.endScope };
+ }
+
+ beginMultiClass(mode);
+ endMultiClass(mode);
+ }
+
+ /**
+ @typedef {import('highlight.js').Mode} Mode
+ @typedef {import('highlight.js').CompiledMode} CompiledMode
+ @typedef {import('highlight.js').Language} Language
+ @typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+ @typedef {import('highlight.js').CompiledLanguage} CompiledLanguage
+ */
+
+ // compilation
+
+ /**
+ * Compiles a language definition result
+ *
+ * Given the raw result of a language definition (Language), compiles this so
+ * that it is ready for highlighting code.
+ * @param {Language} language
+ * @returns {CompiledLanguage}
+ */
+ function compileLanguage(language) {
+ /**
+ * Builds a regex with the case sensitivity of the current language
+ *
+ * @param {RegExp | string} value
+ * @param {boolean} [global]
+ */
+ function langRe(value, global) {
+ return new RegExp(
+ source(value),
+ 'm'
+ + (language.case_insensitive ? 'i' : '')
+ + (language.unicodeRegex ? 'u' : '')
+ + (global ? 'g' : '')
+ );
+ }
+
+ /**
+ Stores multiple regular expressions and allows you to quickly search for
+ them all in a string simultaneously - returning the first match. It does
+ this by creating a huge (a|b|c) regex - each individual item wrapped with ()
+ and joined by `|` - using match groups to track position. When a match is
+ found checking which position in the array has content allows us to figure
+ out which of the original regexes / match groups triggered the match.
+
+ The match object itself (the result of `Regex.exec`) is returned but also
+ enhanced by merging in any meta-data that was registered with the regex.
+ This is how we keep track of which mode matched, and what type of rule
+ (`illegal`, `begin`, end, etc).
+ */
+ class MultiRegex {
+ constructor() {
+ this.matchIndexes = {};
+ // @ts-ignore
+ this.regexes = [];
+ this.matchAt = 1;
+ this.position = 0;
+ }
+
+ // @ts-ignore
+ addRule(re, opts) {
+ opts.position = this.position++;
+ // @ts-ignore
+ this.matchIndexes[this.matchAt] = opts;
+ this.regexes.push([opts, re]);
+ this.matchAt += countMatchGroups(re) + 1;
+ }
+
+ compile() {
+ if (this.regexes.length === 0) {
+ // avoids the need to check length every time exec is called
+ // @ts-ignore
+ this.exec = () => null;
+ }
+ const terminators = this.regexes.map(el => el[1]);
+ this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: '|' }), true);
+ this.lastIndex = 0;
+ }
+
+ /** @param {string} s */
+ exec(s) {
+ this.matcherRe.lastIndex = this.lastIndex;
+ const match = this.matcherRe.exec(s);
+ if (!match) { return null; }
+
+ // eslint-disable-next-line no-undefined
+ const i = match.findIndex((el, i) => i > 0 && el !== undefined);
+ // @ts-ignore
+ const matchData = this.matchIndexes[i];
+ // trim off any earlier non-relevant match groups (ie, the other regex
+ // match groups that make up the multi-matcher)
+ match.splice(0, i);
+
+ return Object.assign(match, matchData);
+ }
+ }
+
+ /*
+ Created to solve the key deficiently with MultiRegex - there is no way to
+ test for multiple matches at a single location. Why would we need to do
+ that? In the future a more dynamic engine will allow certain matches to be
+ ignored. An example: if we matched say the 3rd regex in a large group but
+ decided to ignore it - we'd need to started testing again at the 4th
+ regex... but MultiRegex itself gives us no real way to do that.
+
+ So what this class creates MultiRegexs on the fly for whatever search
+ position they are needed.
+
+ NOTE: These additional MultiRegex objects are created dynamically. For most
+ grammars most of the time we will never actually need anything more than the
+ first MultiRegex - so this shouldn't have too much overhead.
+
+ Say this is our search group, and we match regex3, but wish to ignore it.
+
+ regex1 | regex2 | regex3 | regex4 | regex5 ' ie, startAt = 0
+
+ What we need is a new MultiRegex that only includes the remaining
+ possibilities:
+
+ regex4 | regex5 ' ie, startAt = 3
+
+ This class wraps all that complexity up in a simple API... `startAt` decides
+ where in the array of expressions to start doing the matching. It
+ auto-increments, so if a match is found at position 2, then startAt will be
+ set to 3. If the end is reached startAt will return to 0.
+
+ MOST of the time the parser will be setting startAt manually to 0.
+ */
+ class ResumableMultiRegex {
+ constructor() {
+ // @ts-ignore
+ this.rules = [];
+ // @ts-ignore
+ this.multiRegexes = [];
+ this.count = 0;
+
+ this.lastIndex = 0;
+ this.regexIndex = 0;
+ }
+
+ // @ts-ignore
+ getMatcher(index) {
+ if (this.multiRegexes[index]) return this.multiRegexes[index];
+
+ const matcher = new MultiRegex();
+ this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
+ matcher.compile();
+ this.multiRegexes[index] = matcher;
+ return matcher;
+ }
+
+ resumingScanAtSamePosition() {
+ return this.regexIndex !== 0;
+ }
+
+ considerAll() {
+ this.regexIndex = 0;
+ }
+
+ // @ts-ignore
+ addRule(re, opts) {
+ this.rules.push([re, opts]);
+ if (opts.type === "begin") this.count++;
+ }
+
+ /** @param {string} s */
+ exec(s) {
+ const m = this.getMatcher(this.regexIndex);
+ m.lastIndex = this.lastIndex;
+ let result = m.exec(s);
+
+ // The following is because we have no easy way to say "resume scanning at the
+ // existing position but also skip the current rule ONLY". What happens is
+ // all prior rules are also skipped which can result in matching the wrong
+ // thing. Example of matching "booger":
+
+ // our matcher is [string, "booger", number]
+ //
+ // ....booger....
+
+ // if "booger" is ignored then we'd really need a regex to scan from the
+ // SAME position for only: [string, number] but ignoring "booger" (if it
+ // was the first match), a simple resume would scan ahead who knows how
+ // far looking only for "number", ignoring potential string matches (or
+ // future "booger" matches that might be valid.)
+
+ // So what we do: We execute two matchers, one resuming at the same
+ // position, but the second full matcher starting at the position after:
+
+ // /--- resume first regex match here (for [number])
+ // |/---- full match here for [string, "booger", number]
+ // vv
+ // ....booger....
+
+ // Which ever results in a match first is then used. So this 3-4 step
+ // process essentially allows us to say "match at this position, excluding
+ // a prior rule that was ignored".
+ //
+ // 1. Match "booger" first, ignore. Also proves that [string] does non match.
+ // 2. Resume matching for [number]
+ // 3. Match at index + 1 for [string, "booger", number]
+ // 4. If #2 and #3 result in matches, which came first?
+ if (this.resumingScanAtSamePosition()) {
+ if (result && result.index === this.lastIndex) ; else { // use the second matcher result
+ const m2 = this.getMatcher(0);
+ m2.lastIndex = this.lastIndex + 1;
+ result = m2.exec(s);
+ }
+ }
+
+ if (result) {
+ this.regexIndex += result.position + 1;
+ if (this.regexIndex === this.count) {
+ // wrap-around to considering all matches again
+ this.considerAll();
+ }
+ }
+
+ return result;
+ }
+ }
+
+ /**
+ * Given a mode, builds a huge ResumableMultiRegex that can be used to walk
+ * the content and find matches.
+ *
+ * @param {CompiledMode} mode
+ * @returns {ResumableMultiRegex}
+ */
+ function buildModeRegex(mode) {
+ const mm = new ResumableMultiRegex();
+
+ mode.contains.forEach(term => mm.addRule(term.begin, { rule: term, type: "begin" }));
+
+ if (mode.terminatorEnd) {
+ mm.addRule(mode.terminatorEnd, { type: "end" });
+ }
+ if (mode.illegal) {
+ mm.addRule(mode.illegal, { type: "illegal" });
+ }
+
+ return mm;
+ }
+
+ /** skip vs abort vs ignore
+ *
+ * @skip - The mode is still entered and exited normally (and contains rules apply),
+ * but all content is held and added to the parent buffer rather than being
+ * output when the mode ends. Mostly used with `sublanguage` to build up
+ * a single large buffer than can be parsed by sublanguage.
+ *
+ * - The mode begin ands ends normally.
+ * - Content matched is added to the parent mode buffer.
+ * - The parser cursor is moved forward normally.
+ *
+ * @abort - A hack placeholder until we have ignore. Aborts the mode (as if it
+ * never matched) but DOES NOT continue to match subsequent `contains`
+ * modes. Abort is bad/suboptimal because it can result in modes
+ * farther down not getting applied because an earlier rule eats the
+ * content but then aborts.
+ *
+ * - The mode does not begin.
+ * - Content matched by `begin` is added to the mode buffer.
+ * - The parser cursor is moved forward accordingly.
+ *
+ * @ignore - Ignores the mode (as if it never matched) and continues to match any
+ * subsequent `contains` modes. Ignore isn't technically possible with
+ * the current parser implementation.
+ *
+ * - The mode does not begin.
+ * - Content matched by `begin` is ignored.
+ * - The parser cursor is not moved forward.
+ */
+
+ /**
+ * Compiles an individual mode
+ *
+ * This can raise an error if the mode contains certain detectable known logic
+ * issues.
+ * @param {Mode} mode
+ * @param {CompiledMode | null} [parent]
+ * @returns {CompiledMode | never}
+ */
+ function compileMode(mode, parent) {
+ const cmode = /** @type CompiledMode */ (mode);
+ if (mode.isCompiled) return cmode;
+
+ [
+ scopeClassName,
+ // do this early so compiler extensions generally don't have to worry about
+ // the distinction between match/begin
+ compileMatch,
+ MultiClass,
+ beforeMatchExt
+ ].forEach(ext => ext(mode, parent));
+
+ language.compilerExtensions.forEach(ext => ext(mode, parent));
+
+ // __beforeBegin is considered private API, internal use only
+ mode.__beforeBegin = null;
+
+ [
+ beginKeywords,
+ // do this later so compiler extensions that come earlier have access to the
+ // raw array if they wanted to perhaps manipulate it, etc.
+ compileIllegal,
+ // default to 1 relevance if not specified
+ compileRelevance
+ ].forEach(ext => ext(mode, parent));
+
+ mode.isCompiled = true;
+
+ let keywordPattern = null;
+ if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
+ // we need a copy because keywords might be compiled multiple times
+ // so we can't go deleting $pattern from the original on the first
+ // pass
+ mode.keywords = Object.assign({}, mode.keywords);
+ keywordPattern = mode.keywords.$pattern;
+ delete mode.keywords.$pattern;
+ }
+ keywordPattern = keywordPattern || /\w+/;
+
+ if (mode.keywords) {
+ mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
+ }
+
+ cmode.keywordPatternRe = langRe(keywordPattern, true);
+
+ if (parent) {
+ if (!mode.begin) mode.begin = /\B|\b/;
+ cmode.beginRe = langRe(cmode.begin);
+ if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
+ if (mode.end) cmode.endRe = langRe(cmode.end);
+ cmode.terminatorEnd = source(cmode.end) || '';
+ if (mode.endsWithParent && parent.terminatorEnd) {
+ cmode.terminatorEnd += (mode.end ? '|' : '') + parent.terminatorEnd;
+ }
+ }
+ if (mode.illegal) cmode.illegalRe = langRe(/** @type {RegExp | string} */ (mode.illegal));
+ if (!mode.contains) mode.contains = [];
+
+ mode.contains = [].concat(...mode.contains.map(function(c) {
+ return expandOrCloneMode(c === 'self' ? mode : c);
+ }));
+ mode.contains.forEach(function(c) { compileMode(/** @type Mode */ (c), cmode); });
+
+ if (mode.starts) {
+ compileMode(mode.starts, parent);
+ }
+
+ cmode.matcher = buildModeRegex(cmode);
+ return cmode;
+ }
+
+ if (!language.compilerExtensions) language.compilerExtensions = [];
+
+ // self is not valid at the top-level
+ if (language.contains && language.contains.includes('self')) {
+ throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.");
+ }
+
+ // we need a null object, which inherit will guarantee
+ language.classNameAliases = inherit$1(language.classNameAliases || {});
+
+ return compileMode(/** @type Mode */ (language));
+ }
+
+ /**
+ * Determines if a mode has a dependency on it's parent or not
+ *
+ * If a mode does have a parent dependency then often we need to clone it if
+ * it's used in multiple places so that each copy points to the correct parent,
+ * where-as modes without a parent can often safely be re-used at the bottom of
+ * a mode chain.
+ *
+ * @param {Mode | null} mode
+ * @returns {boolean} - is there a dependency on the parent?
+ * */
+ function dependencyOnParent(mode) {
+ if (!mode) return false;
+
+ return mode.endsWithParent || dependencyOnParent(mode.starts);
+ }
+
+ /**
+ * Expands a mode or clones it if necessary
+ *
+ * This is necessary for modes with parental dependenceis (see notes on
+ * `dependencyOnParent`) and for nodes that have `variants` - which must then be
+ * exploded into their own individual modes at compile time.
+ *
+ * @param {Mode} mode
+ * @returns {Mode | Mode[]}
+ * */
+ function expandOrCloneMode(mode) {
+ if (mode.variants && !mode.cachedVariants) {
+ mode.cachedVariants = mode.variants.map(function(variant) {
+ return inherit$1(mode, { variants: null }, variant);
+ });
+ }
+
+ // EXPAND
+ // if we have variants then essentially "replace" the mode with the variants
+ // this happens in compileMode, where this function is called from
+ if (mode.cachedVariants) {
+ return mode.cachedVariants;
+ }
+
+ // CLONE
+ // if we have dependencies on parents then we need a unique
+ // instance of ourselves, so we can be reused with many
+ // different parents without issue
+ if (dependencyOnParent(mode)) {
+ return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null });
+ }
+
+ if (Object.isFrozen(mode)) {
+ return inherit$1(mode);
+ }
+
+ // no special dependency issues, just return ourselves
+ return mode;
+ }
+
+ var version = "11.9.0";
+
+ class HTMLInjectionError extends Error {
+ constructor(reason, html) {
+ super(reason);
+ this.name = "HTMLInjectionError";
+ this.html = html;
+ }
+ }
+
+ /*
+ Syntax highlighting with language autodetection.
+ https://highlightjs.org/
+ */
+
+
+
+ /**
+ @typedef {import('highlight.js').Mode} Mode
+ @typedef {import('highlight.js').CompiledMode} CompiledMode
+ @typedef {import('highlight.js').CompiledScope} CompiledScope
+ @typedef {import('highlight.js').Language} Language
+ @typedef {import('highlight.js').HLJSApi} HLJSApi
+ @typedef {import('highlight.js').HLJSPlugin} HLJSPlugin
+ @typedef {import('highlight.js').PluginEvent} PluginEvent
+ @typedef {import('highlight.js').HLJSOptions} HLJSOptions
+ @typedef {import('highlight.js').LanguageFn} LanguageFn
+ @typedef {import('highlight.js').HighlightedHTMLElement} HighlightedHTMLElement
+ @typedef {import('highlight.js').BeforeHighlightContext} BeforeHighlightContext
+ @typedef {import('highlight.js/private').MatchType} MatchType
+ @typedef {import('highlight.js/private').KeywordData} KeywordData
+ @typedef {import('highlight.js/private').EnhancedMatch} EnhancedMatch
+ @typedef {import('highlight.js/private').AnnotatedError} AnnotatedError
+ @typedef {import('highlight.js').AutoHighlightResult} AutoHighlightResult
+ @typedef {import('highlight.js').HighlightOptions} HighlightOptions
+ @typedef {import('highlight.js').HighlightResult} HighlightResult
+ */
+
+
+ const escape = escapeHTML;
+ const inherit = inherit$1;
+ const NO_MATCH = Symbol("nomatch");
+ const MAX_KEYWORD_HITS = 7;
+
+ /**
+ * @param {any} hljs - object that is extended (legacy)
+ * @returns {HLJSApi}
+ */
+ const HLJS = function(hljs) {
+ // Global internal variables used within the highlight.js library.
+ /** @type {Record} */
+ const languages = Object.create(null);
+ /** @type {Record} */
+ const aliases = Object.create(null);
+ /** @type {HLJSPlugin[]} */
+ const plugins = [];
+
+ // safe/production mode - swallows more errors, tries to keep running
+ // even if a single syntax or parse hits a fatal error
+ let SAFE_MODE = true;
+ const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
+ /** @type {Language} */
+ const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: 'Plain text', contains: [] };
+
+ // Global options used when within external APIs. This is modified when
+ // calling the `hljs.configure` function.
+ /** @type HLJSOptions */
+ let options = {
+ ignoreUnescapedHTML: false,
+ throwUnescapedHTML: false,
+ noHighlightRe: /^(no-?highlight)$/i,
+ languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+ classPrefix: 'hljs-',
+ cssSelector: 'pre code',
+ languages: null,
+ // beta configuration options, subject to change, welcome to discuss
+ // https://github.com/highlightjs/highlight.js/issues/1086
+ __emitter: TokenTreeEmitter
+ };
+
+ /* Utility functions */
+
+ /**
+ * Tests a language name to see if highlighting should be skipped
+ * @param {string} languageName
+ */
+ function shouldNotHighlight(languageName) {
+ return options.noHighlightRe.test(languageName);
+ }
+
+ /**
+ * @param {HighlightedHTMLElement} block - the HTML element to determine language for
+ */
+ function blockLanguage(block) {
+ let classes = block.className + ' ';
+
+ classes += block.parentNode ? block.parentNode.className : '';
+
+ // language-* takes precedence over non-prefixed class names.
+ const match = options.languageDetectRe.exec(classes);
+ if (match) {
+ const language = getLanguage(match[1]);
+ if (!language) {
+ warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
+ warn("Falling back to no-highlight mode for this block.", block);
+ }
+ return language ? match[1] : 'no-highlight';
+ }
+
+ return classes
+ .split(/\s+/)
+ .find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
+ }
+
+ /**
+ * Core highlighting function.
+ *
+ * OLD API
+ * highlight(lang, code, ignoreIllegals, continuation)
+ *
+ * NEW API
+ * highlight(code, {lang, ignoreIllegals})
+ *
+ * @param {string} codeOrLanguageName - the language to use for highlighting
+ * @param {string | HighlightOptions} optionsOrCode - the code to highlight
+ * @param {boolean} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
+ *
+ * @returns {HighlightResult} Result - an object that represents the result
+ * @property {string} language - the language name
+ * @property {number} relevance - the relevance score
+ * @property {string} value - the highlighted HTML code
+ * @property {string} code - the original raw code
+ * @property {CompiledMode} top - top of the current mode stack
+ * @property {boolean} illegal - indicates whether any illegal matches were found
+ */
+ function highlight(codeOrLanguageName, optionsOrCode, ignoreIllegals) {
+ let code = "";
+ let languageName = "";
+ if (typeof optionsOrCode === "object") {
+ code = codeOrLanguageName;
+ ignoreIllegals = optionsOrCode.ignoreIllegals;
+ languageName = optionsOrCode.language;
+ } else {
+ // old API
+ deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
+ deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
+ languageName = codeOrLanguageName;
+ code = optionsOrCode;
+ }
+
+ // https://github.com/highlightjs/highlight.js/issues/3149
+ // eslint-disable-next-line no-undefined
+ if (ignoreIllegals === undefined) { ignoreIllegals = true; }
+
+ /** @type {BeforeHighlightContext} */
+ const context = {
+ code,
+ language: languageName
+ };
+ // the plugin can change the desired language or the code to be highlighted
+ // just be changing the object it was passed
+ fire("before:highlight", context);
+
+ // a before plugin can usurp the result completely by providing it's own
+ // in which case we don't even need to call highlight
+ const result = context.result
+ ? context.result
+ : _highlight(context.language, context.code, ignoreIllegals);
+
+ result.code = context.code;
+ // the plugin can change anything in result to suite it
+ fire("after:highlight", result);
+
+ return result;
+ }
+
+ /**
+ * private highlight that's used internally and does not fire callbacks
+ *
+ * @param {string} languageName - the language to use for highlighting
+ * @param {string} codeToHighlight - the code to highlight
+ * @param {boolean?} [ignoreIllegals] - whether to ignore illegal matches, default is to bail
+ * @param {CompiledMode?} [continuation] - current continuation mode, if any
+ * @returns {HighlightResult} - result of the highlight operation
+ */
+ function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
+ const keywordHits = Object.create(null);
+
+ /**
+ * Return keyword data if a match is a keyword
+ * @param {CompiledMode} mode - current mode
+ * @param {string} matchText - the textual match
+ * @returns {KeywordData | false}
+ */
+ function keywordData(mode, matchText) {
+ return mode.keywords[matchText];
+ }
+
+ function processKeywords() {
+ if (!top.keywords) {
+ emitter.addText(modeBuffer);
+ return;
+ }
+
+ let lastIndex = 0;
+ top.keywordPatternRe.lastIndex = 0;
+ let match = top.keywordPatternRe.exec(modeBuffer);
+ let buf = "";
+
+ while (match) {
+ buf += modeBuffer.substring(lastIndex, match.index);
+ const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
+ const data = keywordData(top, word);
+ if (data) {
+ const [kind, keywordRelevance] = data;
+ emitter.addText(buf);
+ buf = "";
+
+ keywordHits[word] = (keywordHits[word] || 0) + 1;
+ if (keywordHits[word] <= MAX_KEYWORD_HITS) relevance += keywordRelevance;
+ if (kind.startsWith("_")) {
+ // _ implied for relevance only, do not highlight
+ // by applying a class name
+ buf += match[0];
+ } else {
+ const cssClass = language.classNameAliases[kind] || kind;
+ emitKeyword(match[0], cssClass);
+ }
+ } else {
+ buf += match[0];
+ }
+ lastIndex = top.keywordPatternRe.lastIndex;
+ match = top.keywordPatternRe.exec(modeBuffer);
+ }
+ buf += modeBuffer.substring(lastIndex);
+ emitter.addText(buf);
+ }
+
+ function processSubLanguage() {
+ if (modeBuffer === "") return;
+ /** @type HighlightResult */
+ let result = null;
+
+ if (typeof top.subLanguage === 'string') {
+ if (!languages[top.subLanguage]) {
+ emitter.addText(modeBuffer);
+ return;
+ }
+ result = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
+ continuations[top.subLanguage] = /** @type {CompiledMode} */ (result._top);
+ } else {
+ result = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
+ }
+
+ // Counting embedded language score towards the host language may be disabled
+ // with zeroing the containing mode relevance. Use case in point is Markdown that
+ // allows XML everywhere and makes every XML snippet to have a much larger Markdown
+ // score.
+ if (top.relevance > 0) {
+ relevance += result.relevance;
+ }
+ emitter.__addSublanguage(result._emitter, result.language);
+ }
+
+ function processBuffer() {
+ if (top.subLanguage != null) {
+ processSubLanguage();
+ } else {
+ processKeywords();
+ }
+ modeBuffer = '';
+ }
+
+ /**
+ * @param {string} text
+ * @param {string} scope
+ */
+ function emitKeyword(keyword, scope) {
+ if (keyword === "") return;
+
+ emitter.startScope(scope);
+ emitter.addText(keyword);
+ emitter.endScope();
+ }
+
+ /**
+ * @param {CompiledScope} scope
+ * @param {RegExpMatchArray} match
+ */
+ function emitMultiClass(scope, match) {
+ let i = 1;
+ const max = match.length - 1;
+ while (i <= max) {
+ if (!scope._emit[i]) { i++; continue; }
+ const klass = language.classNameAliases[scope[i]] || scope[i];
+ const text = match[i];
+ if (klass) {
+ emitKeyword(text, klass);
+ } else {
+ modeBuffer = text;
+ processKeywords();
+ modeBuffer = "";
+ }
+ i++;
+ }
+ }
+
+ /**
+ * @param {CompiledMode} mode - new mode to start
+ * @param {RegExpMatchArray} match
+ */
+ function startNewMode(mode, match) {
+ if (mode.scope && typeof mode.scope === "string") {
+ emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
+ }
+ if (mode.beginScope) {
+ // beginScope just wraps the begin match itself in a scope
+ if (mode.beginScope._wrap) {
+ emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
+ modeBuffer = "";
+ } else if (mode.beginScope._multi) {
+ // at this point modeBuffer should just be the match
+ emitMultiClass(mode.beginScope, match);
+ modeBuffer = "";
+ }
+ }
+
+ top = Object.create(mode, { parent: { value: top } });
+ return top;
+ }
+
+ /**
+ * @param {CompiledMode } mode - the mode to potentially end
+ * @param {RegExpMatchArray} match - the latest match
+ * @param {string} matchPlusRemainder - match plus remainder of content
+ * @returns {CompiledMode | void} - the next mode, or if void continue on in current mode
+ */
+ function endOfMode(mode, match, matchPlusRemainder) {
+ let matched = startsWith(mode.endRe, matchPlusRemainder);
+
+ if (matched) {
+ if (mode["on:end"]) {
+ const resp = new Response(mode);
+ mode["on:end"](match, resp);
+ if (resp.isMatchIgnored) matched = false;
+ }
+
+ if (matched) {
+ while (mode.endsParent && mode.parent) {
+ mode = mode.parent;
+ }
+ return mode;
+ }
+ }
+ // even if on:end fires an `ignore` it's still possible
+ // that we might trigger the end node because of a parent mode
+ if (mode.endsWithParent) {
+ return endOfMode(mode.parent, match, matchPlusRemainder);
+ }
+ }
+
+ /**
+ * Handle matching but then ignoring a sequence of text
+ *
+ * @param {string} lexeme - string containing full match text
+ */
+ function doIgnore(lexeme) {
+ if (top.matcher.regexIndex === 0) {
+ // no more regexes to potentially match here, so we move the cursor forward one
+ // space
+ modeBuffer += lexeme[0];
+ return 1;
+ } else {
+ // no need to move the cursor, we still have additional regexes to try and
+ // match at this very spot
+ resumeScanAtSamePosition = true;
+ return 0;
+ }
+ }
+
+ /**
+ * Handle the start of a new potential mode match
+ *
+ * @param {EnhancedMatch} match - the current match
+ * @returns {number} how far to advance the parse cursor
+ */
+ function doBeginMatch(match) {
+ const lexeme = match[0];
+ const newMode = match.rule;
+
+ const resp = new Response(newMode);
+ // first internal before callbacks, then the public ones
+ const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
+ for (const cb of beforeCallbacks) {
+ if (!cb) continue;
+ cb(match, resp);
+ if (resp.isMatchIgnored) return doIgnore(lexeme);
+ }
+
+ if (newMode.skip) {
+ modeBuffer += lexeme;
+ } else {
+ if (newMode.excludeBegin) {
+ modeBuffer += lexeme;
+ }
+ processBuffer();
+ if (!newMode.returnBegin && !newMode.excludeBegin) {
+ modeBuffer = lexeme;
+ }
+ }
+ startNewMode(newMode, match);
+ return newMode.returnBegin ? 0 : lexeme.length;
+ }
+
+ /**
+ * Handle the potential end of mode
+ *
+ * @param {RegExpMatchArray} match - the current match
+ */
+ function doEndMatch(match) {
+ const lexeme = match[0];
+ const matchPlusRemainder = codeToHighlight.substring(match.index);
+
+ const endMode = endOfMode(top, match, matchPlusRemainder);
+ if (!endMode) { return NO_MATCH; }
+
+ const origin = top;
+ if (top.endScope && top.endScope._wrap) {
+ processBuffer();
+ emitKeyword(lexeme, top.endScope._wrap);
+ } else if (top.endScope && top.endScope._multi) {
+ processBuffer();
+ emitMultiClass(top.endScope, match);
+ } else if (origin.skip) {
+ modeBuffer += lexeme;
+ } else {
+ if (!(origin.returnEnd || origin.excludeEnd)) {
+ modeBuffer += lexeme;
+ }
+ processBuffer();
+ if (origin.excludeEnd) {
+ modeBuffer = lexeme;
+ }
+ }
+ do {
+ if (top.scope) {
+ emitter.closeNode();
+ }
+ if (!top.skip && !top.subLanguage) {
+ relevance += top.relevance;
+ }
+ top = top.parent;
+ } while (top !== endMode.parent);
+ if (endMode.starts) {
+ startNewMode(endMode.starts, match);
+ }
+ return origin.returnEnd ? 0 : lexeme.length;
+ }
+
+ function processContinuations() {
+ const list = [];
+ for (let current = top; current !== language; current = current.parent) {
+ if (current.scope) {
+ list.unshift(current.scope);
+ }
+ }
+ list.forEach(item => emitter.openNode(item));
+ }
+
+ /** @type {{type?: MatchType, index?: number, rule?: Mode}}} */
+ let lastMatch = {};
+
+ /**
+ * Process an individual match
+ *
+ * @param {string} textBeforeMatch - text preceding the match (since the last match)
+ * @param {EnhancedMatch} [match] - the match itself
+ */
+ function processLexeme(textBeforeMatch, match) {
+ const lexeme = match && match[0];
+
+ // add non-matched text to the current mode buffer
+ modeBuffer += textBeforeMatch;
+
+ if (lexeme == null) {
+ processBuffer();
+ return 0;
+ }
+
+ // we've found a 0 width match and we're stuck, so we need to advance
+ // this happens when we have badly behaved rules that have optional matchers to the degree that
+ // sometimes they can end up matching nothing at all
+ // Ref: https://github.com/highlightjs/highlight.js/issues/2140
+ if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
+ // spit the "skipped" character that our regex choked on back into the output sequence
+ modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
+ if (!SAFE_MODE) {
+ /** @type {AnnotatedError} */
+ const err = new Error(`0 width match regex (${languageName})`);
+ err.languageName = languageName;
+ err.badRule = lastMatch.rule;
+ throw err;
+ }
+ return 1;
+ }
+ lastMatch = match;
+
+ if (match.type === "begin") {
+ return doBeginMatch(match);
+ } else if (match.type === "illegal" && !ignoreIllegals) {
+ // illegal match, we do not continue processing
+ /** @type {AnnotatedError} */
+ const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || '') + '"');
+ err.mode = top;
+ throw err;
+ } else if (match.type === "end") {
+ const processed = doEndMatch(match);
+ if (processed !== NO_MATCH) {
+ return processed;
+ }
+ }
+
+ // edge case for when illegal matches $ (end of line) which is technically
+ // a 0 width match but not a begin/end match so it's not caught by the
+ // first handler (when ignoreIllegals is true)
+ if (match.type === "illegal" && lexeme === "") {
+ // advance so we aren't stuck in an infinite loop
+ return 1;
+ }
+
+ // infinite loops are BAD, this is a last ditch catch all. if we have a
+ // decent number of iterations yet our index (cursor position in our
+ // parsing) still 3x behind our index then something is very wrong
+ // so we bail
+ if (iterations > 100000 && iterations > match.index * 3) {
+ const err = new Error('potential infinite loop, way more iterations than matches');
+ throw err;
+ }
+
+ /*
+ Why might be find ourselves here? An potential end match that was
+ triggered but could not be completed. IE, `doEndMatch` returned NO_MATCH.
+ (this could be because a callback requests the match be ignored, etc)
+
+ This causes no real harm other than stopping a few times too many.
+ */
+
+ modeBuffer += lexeme;
+ return lexeme.length;
+ }
+
+ const language = getLanguage(languageName);
+ if (!language) {
+ error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
+ throw new Error('Unknown language: "' + languageName + '"');
+ }
+
+ const md = compileLanguage(language);
+ let result = '';
+ /** @type {CompiledMode} */
+ let top = continuation || md;
+ /** @type Record */
+ const continuations = {}; // keep continuations for sub-languages
+ const emitter = new options.__emitter(options);
+ processContinuations();
+ let modeBuffer = '';
+ let relevance = 0;
+ let index = 0;
+ let iterations = 0;
+ let resumeScanAtSamePosition = false;
+
+ try {
+ if (!language.__emitTokens) {
+ top.matcher.considerAll();
+
+ for (;;) {
+ iterations++;
+ if (resumeScanAtSamePosition) {
+ // only regexes not matched previously will now be
+ // considered for a potential match
+ resumeScanAtSamePosition = false;
+ } else {
+ top.matcher.considerAll();
+ }
+ top.matcher.lastIndex = index;
+
+ const match = top.matcher.exec(codeToHighlight);
+ // console.log("match", match[0], match.rule && match.rule.begin)
+
+ if (!match) break;
+
+ const beforeMatch = codeToHighlight.substring(index, match.index);
+ const processedCount = processLexeme(beforeMatch, match);
+ index = match.index + processedCount;
+ }
+ processLexeme(codeToHighlight.substring(index));
+ } else {
+ language.__emitTokens(codeToHighlight, emitter);
+ }
+
+ emitter.finalize();
+ result = emitter.toHTML();
+
+ return {
+ language: languageName,
+ value: result,
+ relevance,
+ illegal: false,
+ _emitter: emitter,
+ _top: top
+ };
+ } catch (err) {
+ if (err.message && err.message.includes('Illegal')) {
+ return {
+ language: languageName,
+ value: escape(codeToHighlight),
+ illegal: true,
+ relevance: 0,
+ _illegalBy: {
+ message: err.message,
+ index,
+ context: codeToHighlight.slice(index - 100, index + 100),
+ mode: err.mode,
+ resultSoFar: result
+ },
+ _emitter: emitter
+ };
+ } else if (SAFE_MODE) {
+ return {
+ language: languageName,
+ value: escape(codeToHighlight),
+ illegal: false,
+ relevance: 0,
+ errorRaised: err,
+ _emitter: emitter,
+ _top: top
+ };
+ } else {
+ throw err;
+ }
+ }
+ }
+
+ /**
+ * returns a valid highlight result, without actually doing any actual work,
+ * auto highlight starts with this and it's possible for small snippets that
+ * auto-detection may not find a better match
+ * @param {string} code
+ * @returns {HighlightResult}
+ */
+ function justTextHighlightResult(code) {
+ const result = {
+ value: escape(code),
+ illegal: false,
+ relevance: 0,
+ _top: PLAINTEXT_LANGUAGE,
+ _emitter: new options.__emitter(options)
+ };
+ result._emitter.addText(code);
+ return result;
+ }
+
+ /**
+ Highlighting with language detection. Accepts a string with the code to
+ highlight. Returns an object with the following properties:
+
+ - language (detected language)
+ - relevance (int)
+ - value (an HTML string with highlighting markup)
+ - secondBest (object with the same structure for second-best heuristically
+ detected language, may be absent)
+
+ @param {string} code
+ @param {Array} [languageSubset]
+ @returns {AutoHighlightResult}
+ */
+ function highlightAuto(code, languageSubset) {
+ languageSubset = languageSubset || options.languages || Object.keys(languages);
+ const plaintext = justTextHighlightResult(code);
+
+ const results = languageSubset.filter(getLanguage).filter(autoDetection).map(name =>
+ _highlight(name, code, false)
+ );
+ results.unshift(plaintext); // plaintext is always an option
+
+ const sorted = results.sort((a, b) => {
+ // sort base on relevance
+ if (a.relevance !== b.relevance) return b.relevance - a.relevance;
+
+ // always award the tie to the base language
+ // ie if C++ and Arduino are tied, it's more likely to be C++
+ if (a.language && b.language) {
+ if (getLanguage(a.language).supersetOf === b.language) {
+ return 1;
+ } else if (getLanguage(b.language).supersetOf === a.language) {
+ return -1;
+ }
+ }
+
+ // otherwise say they are equal, which has the effect of sorting on
+ // relevance while preserving the original ordering - which is how ties
+ // have historically been settled, ie the language that comes first always
+ // wins in the case of a tie
+ return 0;
+ });
+
+ const [best, secondBest] = sorted;
+
+ /** @type {AutoHighlightResult} */
+ const result = best;
+ result.secondBest = secondBest;
+
+ return result;
+ }
+
+ /**
+ * Builds new class name for block given the language name
+ *
+ * @param {HTMLElement} element
+ * @param {string} [currentLang]
+ * @param {string} [resultLang]
+ */
+ function updateClassName(element, currentLang, resultLang) {
+ const language = (currentLang && aliases[currentLang]) || resultLang;
+
+ element.classList.add("hljs");
+ element.classList.add(`language-${language}`);
+ }
+
+ /**
+ * Applies highlighting to a DOM node containing code.
+ *
+ * @param {HighlightedHTMLElement} element - the HTML element to highlight
+ */
+ function highlightElement(element) {
+ /** @type HTMLElement */
+ let node = null;
+ const language = blockLanguage(element);
+
+ if (shouldNotHighlight(language)) return;
+
+ fire("before:highlightElement",
+ { el: element, language });
+
+ if (element.dataset.highlighted) {
+ console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element);
+ return;
+ }
+
+ // we should be all text, no child nodes (unescaped HTML) - this is possibly
+ // an HTML injection attack - it's likely too late if this is already in
+ // production (the code has likely already done its damage by the time
+ // we're seeing it)... but we yell loudly about this so that hopefully it's
+ // more likely to be caught in development before making it to production
+ if (element.children.length > 0) {
+ if (!options.ignoreUnescapedHTML) {
+ console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
+ console.warn("https://github.com/highlightjs/highlight.js/wiki/security");
+ console.warn("The element with unescaped HTML:");
+ console.warn(element);
+ }
+ if (options.throwUnescapedHTML) {
+ const err = new HTMLInjectionError(
+ "One of your code blocks includes unescaped HTML.",
+ element.innerHTML
+ );
+ throw err;
+ }
+ }
+
+ node = element;
+ const text = node.textContent;
+ const result = language ? highlight(text, { language, ignoreIllegals: true }) : highlightAuto(text);
+
+ element.innerHTML = result.value;
+ element.dataset.highlighted = "yes";
+ updateClassName(element, language, result.language);
+ element.result = {
+ language: result.language,
+ // TODO: remove with version 11.0
+ re: result.relevance,
+ relevance: result.relevance
+ };
+ if (result.secondBest) {
+ element.secondBest = {
+ language: result.secondBest.language,
+ relevance: result.secondBest.relevance
+ };
+ }
+
+ fire("after:highlightElement", { el: element, result, text });
+ }
+
+ /**
+ * Updates highlight.js global options with the passed options
+ *
+ * @param {Partial} userOptions
+ */
+ function configure(userOptions) {
+ options = inherit(options, userOptions);
+ }
+
+ // TODO: remove v12, deprecated
+ const initHighlighting = () => {
+ highlightAll();
+ deprecated("10.6.0", "initHighlighting() deprecated. Use highlightAll() now.");
+ };
+
+ // TODO: remove v12, deprecated
+ function initHighlightingOnLoad() {
+ highlightAll();
+ deprecated("10.6.0", "initHighlightingOnLoad() deprecated. Use highlightAll() now.");
+ }
+
+ let wantsHighlight = false;
+
+ /**
+ * auto-highlights all pre>code elements on the page
+ */
+ function highlightAll() {
+ // if we are called too early in the loading process
+ if (document.readyState === "loading") {
+ wantsHighlight = true;
+ return;
+ }
+
+ const blocks = document.querySelectorAll(options.cssSelector);
+ blocks.forEach(highlightElement);
+ }
+
+ function boot() {
+ // if a highlight was requested before DOM was loaded, do now
+ if (wantsHighlight) highlightAll();
+ }
+
+ // make sure we are in the browser environment
+ if (typeof window !== 'undefined' && window.addEventListener) {
+ window.addEventListener('DOMContentLoaded', boot, false);
+ }
+
+ /**
+ * Register a language grammar module
+ *
+ * @param {string} languageName
+ * @param {LanguageFn} languageDefinition
+ */
+ function registerLanguage(languageName, languageDefinition) {
+ let lang = null;
+ try {
+ lang = languageDefinition(hljs);
+ } catch (error$1) {
+ error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+ // hard or soft error
+ if (!SAFE_MODE) { throw error$1; } else { error(error$1); }
+ // languages that have serious errors are replaced with essentially a
+ // "plaintext" stand-in so that the code blocks will still get normal
+ // css classes applied to them - and one bad language won't break the
+ // entire highlighter
+ lang = PLAINTEXT_LANGUAGE;
+ }
+ // give it a temporary name if it doesn't have one in the meta-data
+ if (!lang.name) lang.name = languageName;
+ languages[languageName] = lang;
+ lang.rawDefinition = languageDefinition.bind(null, hljs);
+
+ if (lang.aliases) {
+ registerAliases(lang.aliases, { languageName });
+ }
+ }
+
+ /**
+ * Remove a language grammar module
+ *
+ * @param {string} languageName
+ */
+ function unregisterLanguage(languageName) {
+ delete languages[languageName];
+ for (const alias of Object.keys(aliases)) {
+ if (aliases[alias] === languageName) {
+ delete aliases[alias];
+ }
+ }
+ }
+
+ /**
+ * @returns {string[]} List of language internal names
+ */
+ function listLanguages() {
+ return Object.keys(languages);
+ }
+
+ /**
+ * @param {string} name - name of the language to retrieve
+ * @returns {Language | undefined}
+ */
+ function getLanguage(name) {
+ name = (name || '').toLowerCase();
+ return languages[name] || languages[aliases[name]];
+ }
+
+ /**
+ *
+ * @param {string|string[]} aliasList - single alias or list of aliases
+ * @param {{languageName: string}} opts
+ */
+ function registerAliases(aliasList, { languageName }) {
+ if (typeof aliasList === 'string') {
+ aliasList = [aliasList];
+ }
+ aliasList.forEach(alias => { aliases[alias.toLowerCase()] = languageName; });
+ }
+
+ /**
+ * Determines if a given language has auto-detection enabled
+ * @param {string} name - name of the language
+ */
+ function autoDetection(name) {
+ const lang = getLanguage(name);
+ return lang && !lang.disableAutodetect;
+ }
+
+ /**
+ * Upgrades the old highlightBlock plugins to the new
+ * highlightElement API
+ * @param {HLJSPlugin} plugin
+ */
+ function upgradePluginAPI(plugin) {
+ // TODO: remove with v12
+ if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
+ plugin["before:highlightElement"] = (data) => {
+ plugin["before:highlightBlock"](
+ Object.assign({ block: data.el }, data)
+ );
+ };
+ }
+ if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
+ plugin["after:highlightElement"] = (data) => {
+ plugin["after:highlightBlock"](
+ Object.assign({ block: data.el }, data)
+ );
+ };
+ }
+ }
+
+ /**
+ * @param {HLJSPlugin} plugin
+ */
+ function addPlugin(plugin) {
+ upgradePluginAPI(plugin);
+ plugins.push(plugin);
+ }
+
+ /**
+ * @param {HLJSPlugin} plugin
+ */
+ function removePlugin(plugin) {
+ const index = plugins.indexOf(plugin);
+ if (index !== -1) {
+ plugins.splice(index, 1);
+ }
+ }
+
+ /**
+ *
+ * @param {PluginEvent} event
+ * @param {any} args
+ */
+ function fire(event, args) {
+ const cb = event;
+ plugins.forEach(function(plugin) {
+ if (plugin[cb]) {
+ plugin[cb](args);
+ }
+ });
+ }
+
+ /**
+ * DEPRECATED
+ * @param {HighlightedHTMLElement} el
+ */
+ function deprecateHighlightBlock(el) {
+ deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+ deprecated("10.7.0", "Please use highlightElement now.");
+
+ return highlightElement(el);
+ }
+
+ /* Interface definition */
+ Object.assign(hljs, {
+ highlight,
+ highlightAuto,
+ highlightAll,
+ highlightElement,
+ // TODO: Remove with v12 API
+ highlightBlock: deprecateHighlightBlock,
+ configure,
+ initHighlighting,
+ initHighlightingOnLoad,
+ registerLanguage,
+ unregisterLanguage,
+ listLanguages,
+ getLanguage,
+ registerAliases,
+ autoDetection,
+ inherit,
+ addPlugin,
+ removePlugin
+ });
+
+ hljs.debugMode = function() { SAFE_MODE = false; };
+ hljs.safeMode = function() { SAFE_MODE = true; };
+ hljs.versionString = version;
+
+ hljs.regex = {
+ concat: concat,
+ lookahead: lookahead,
+ either: either,
+ optional: optional,
+ anyNumberOfTimes: anyNumberOfTimes
+ };
+
+ for (const key in MODES) {
+ // @ts-ignore
+ if (typeof MODES[key] === "object") {
+ // @ts-ignore
+ deepFreeze(MODES[key]);
+ }
+ }
+
+ // merge all the modes/regexes into our main object
+ Object.assign(hljs, MODES);
+
+ return hljs;
+ };
+
+ // Other names for the variable may break build script
+ const highlight = HLJS({});
+
+ // returns a new instance of the highlighter to be used for extensions
+ // check https://github.com/wooorm/lowlight/issues/47
+ highlight.newInstance = () => HLJS({});
+
+ return highlight;
+
+})();
+if (typeof exports === 'object' && typeof module !== 'undefined') { module.exports = hljs; }
+/*! `markdown` grammar compiled for Highlight.js 11.9.0 */
+ (function(){
+ var hljsGrammar = (function () {
+ 'use strict';
+
+ /*
+ Language: Markdown
+ Requires: xml.js
+ Author: John Crepezzi
+ Website: https://daringfireball.net/projects/markdown/
+ Category: common, markup
+ */
+
+ function markdown(hljs) {
+ const regex = hljs.regex;
+ const INLINE_HTML = {
+ begin: /<\/?[A-Za-z_]/,
+ end: '>',
+ subLanguage: 'xml',
+ relevance: 0
+ };
+ const HORIZONTAL_RULE = {
+ begin: '^[-\\*]{3,}',
+ end: '$'
+ };
+ const CODE = {
+ className: 'code',
+ variants: [
+ // TODO: fix to allow these to work with sublanguage also
+ { begin: '(`{3,})[^`](.|\\n)*?\\1`*[ ]*' },
+ { begin: '(~{3,})[^~](.|\\n)*?\\1~*[ ]*' },
+ // needed to allow markdown as a sublanguage to work
+ {
+ begin: '```',
+ end: '```+[ ]*$'
+ },
+ {
+ begin: '~~~',
+ end: '~~~+[ ]*$'
+ },
+ { begin: '`.+?`' },
+ {
+ begin: '(?=^( {4}|\\t))',
+ // use contains to gobble up multiple lines to allow the block to be whatever size
+ // but only have a single open/close tag vs one per line
+ contains: [
+ {
+ begin: '^( {4}|\\t)',
+ end: '(\\n)$'
+ }
+ ],
+ relevance: 0
+ }
+ ]
+ };
+ const LIST = {
+ className: 'bullet',
+ begin: '^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)',
+ end: '\\s+',
+ excludeEnd: true
+ };
+ const LINK_REFERENCE = {
+ begin: /^\[[^\n]+\]:/,
+ returnBegin: true,
+ contains: [
+ {
+ className: 'symbol',
+ begin: /\[/,
+ end: /\]/,
+ excludeBegin: true,
+ excludeEnd: true
+ },
+ {
+ className: 'link',
+ begin: /:\s*/,
+ end: /$/,
+ excludeBegin: true
+ }
+ ]
+ };
+ const URL_SCHEME = /[A-Za-z][A-Za-z0-9+.-]*/;
+ const LINK = {
+ variants: [
+ // too much like nested array access in so many languages
+ // to have any real relevance
+ {
+ begin: /\[.+?\]\[.*?\]/,
+ relevance: 0
+ },
+ // popular internet URLs
+ {
+ begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+ relevance: 2
+ },
+ {
+ begin: regex.concat(/\[.+?\]\(/, URL_SCHEME, /:\/\/.*?\)/),
+ relevance: 2
+ },
+ // relative urls
+ {
+ begin: /\[.+?\]\([./?].*?\)/,
+ relevance: 1
+ },
+ // whatever else, lower relevance (might not be a link at all)
+ {
+ begin: /\[.*?\]\(.*?\)/,
+ relevance: 0
+ }
+ ],
+ returnBegin: true,
+ contains: [
+ {
+ // empty strings for alt or link text
+ match: /\[(?=\])/ },
+ {
+ className: 'string',
+ relevance: 0,
+ begin: '\\[',
+ end: '\\]',
+ excludeBegin: true,
+ returnEnd: true
+ },
+ {
+ className: 'link',
+ relevance: 0,
+ begin: '\\]\\(',
+ end: '\\)',
+ excludeBegin: true,
+ excludeEnd: true
+ },
+ {
+ className: 'symbol',
+ relevance: 0,
+ begin: '\\]\\[',
+ end: '\\]',
+ excludeBegin: true,
+ excludeEnd: true
+ }
+ ]
+ };
+ const BOLD = {
+ className: 'strong',
+ contains: [], // defined later
+ variants: [
+ {
+ begin: /_{2}(?!\s)/,
+ end: /_{2}/
+ },
+ {
+ begin: /\*{2}(?!\s)/,
+ end: /\*{2}/
+ }
+ ]
+ };
+ const ITALIC = {
+ className: 'emphasis',
+ contains: [], // defined later
+ variants: [
+ {
+ begin: /\*(?![*\s])/,
+ end: /\*/
+ },
+ {
+ begin: /_(?![_\s])/,
+ end: /_/,
+ relevance: 0
+ }
+ ]
+ };
+
+ // 3 level deep nesting is not allowed because it would create confusion
+ // in cases like `***testing***` because where we don't know if the last
+ // `***` is starting a new bold/italic or finishing the last one
+ const BOLD_WITHOUT_ITALIC = hljs.inherit(BOLD, { contains: [] });
+ const ITALIC_WITHOUT_BOLD = hljs.inherit(ITALIC, { contains: [] });
+ BOLD.contains.push(ITALIC_WITHOUT_BOLD);
+ ITALIC.contains.push(BOLD_WITHOUT_ITALIC);
+
+ let CONTAINABLE = [
+ INLINE_HTML,
+ LINK
+ ];
+
+ [
+ BOLD,
+ ITALIC,
+ BOLD_WITHOUT_ITALIC,
+ ITALIC_WITHOUT_BOLD
+ ].forEach(m => {
+ m.contains = m.contains.concat(CONTAINABLE);
+ });
+
+ CONTAINABLE = CONTAINABLE.concat(BOLD, ITALIC);
+
+ const HEADER = {
+ className: 'section',
+ variants: [
+ {
+ begin: '^#{1,6}',
+ end: '$',
+ contains: CONTAINABLE
+ },
+ {
+ begin: '(?=^.+?\\n[=-]{2,}$)',
+ contains: [
+ { begin: '^[=-]*$' },
+ {
+ begin: '^',
+ end: "\\n",
+ contains: CONTAINABLE
+ }
+ ]
+ }
+ ]
+ };
+
+ const BLOCKQUOTE = {
+ className: 'quote',
+ begin: '^>\\s+',
+ contains: CONTAINABLE,
+ end: '$'
+ };
+
+ return {
+ name: 'Markdown',
+ aliases: [
+ 'md',
+ 'mkdown',
+ 'mkd'
+ ],
+ contains: [
+ HEADER,
+ INLINE_HTML,
+ LIST,
+ BOLD,
+ ITALIC,
+ BLOCKQUOTE,
+ CODE,
+ HORIZONTAL_RULE,
+ LINK,
+ LINK_REFERENCE
+ ]
+ };
+ }
+
+ return markdown;
+
+})();
+
+ hljs.registerLanguage('markdown', hljsGrammar);
+ })();
\ No newline at end of file
diff --git a/templates/hljs/highlight.min.js b/templates/hljs/highlight.min.js
new file mode 100644
index 0000000..9c62ebc
--- /dev/null
+++ b/templates/hljs/highlight.min.js
@@ -0,0 +1,339 @@
+/*!
+ Highlight.js v11.9.0 (git: b7ec4bfafc)
+ (c) 2006-2023 undefined and other contributors
+ License: BSD-3-Clause
+ */
+var hljs=function(){"use strict";function e(t){
+return t instanceof Map?t.clear=t.delete=t.set=()=>{
+throw Error("map is read-only")}:t instanceof Set&&(t.add=t.clear=t.delete=()=>{
+throw Error("set is read-only")
+}),Object.freeze(t),Object.getOwnPropertyNames(t).forEach((n=>{
+const i=t[n],s=typeof i;"object"!==s&&"function"!==s||Object.isFrozen(i)||e(i)
+})),t}class t{constructor(e){
+void 0===e.data&&(e.data={}),this.data=e.data,this.isMatchIgnored=!1}
+ignoreMatch(){this.isMatchIgnored=!0}}function n(e){
+return e.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")
+}function i(e,...t){const n=Object.create(null);for(const t in e)n[t]=e[t]
+;return t.forEach((e=>{for(const t in e)n[t]=e[t]})),n}const s=e=>!!e.scope
+;class o{constructor(e,t){
+this.buffer="",this.classPrefix=t.classPrefix,e.walk(this)}addText(e){
+this.buffer+=n(e)}openNode(e){if(!s(e))return;const t=((e,{prefix:t})=>{
+if(e.startsWith("language:"))return e.replace("language:","language-")
+;if(e.includes(".")){const n=e.split(".")
+;return[`${t}${n.shift()}`,...n.map(((e,t)=>`${e}${"_".repeat(t+1)}`))].join(" ")
+}return`${t}${e}`})(e.scope,{prefix:this.classPrefix});this.span(t)}
+closeNode(e){s(e)&&(this.buffer+="")}value(){return this.buffer}span(e){
+this.buffer+=``}}const r=(e={})=>{const t={children:[]}
+;return Object.assign(t,e),t};class a{constructor(){
+this.rootNode=r(),this.stack=[this.rootNode]}get top(){
+return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(e){
+this.top.children.push(e)}openNode(e){const t=r({scope:e})
+;this.add(t),this.stack.push(t)}closeNode(){
+if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){
+for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}
+walk(e){return this.constructor._walk(e,this.rootNode)}static _walk(e,t){
+return"string"==typeof t?e.addText(t):t.children&&(e.openNode(t),
+t.children.forEach((t=>this._walk(e,t))),e.closeNode(t)),e}static _collapse(e){
+"string"!=typeof e&&e.children&&(e.children.every((e=>"string"==typeof e))?e.children=[e.children.join("")]:e.children.forEach((e=>{
+a._collapse(e)})))}}class c extends a{constructor(e){super(),this.options=e}
+addText(e){""!==e&&this.add(e)}startScope(e){this.openNode(e)}endScope(){
+this.closeNode()}__addSublanguage(e,t){const n=e.root
+;t&&(n.scope="language:"+t),this.add(n)}toHTML(){
+return new o(this,this.options).value()}finalize(){
+return this.closeAllNodes(),!0}}function l(e){
+return e?"string"==typeof e?e:e.source:null}function g(e){return h("(?=",e,")")}
+function u(e){return h("(?:",e,")*")}function d(e){return h("(?:",e,")?")}
+function h(...e){return e.map((e=>l(e))).join("")}function f(...e){const t=(e=>{
+const t=e[e.length-1]
+;return"object"==typeof t&&t.constructor===Object?(e.splice(e.length-1,1),t):{}
+})(e);return"("+(t.capture?"":"?:")+e.map((e=>l(e))).join("|")+")"}
+function p(e){return RegExp(e.toString()+"|").exec("").length-1}
+const b=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
+;function m(e,{joinWith:t}){let n=0;return e.map((e=>{n+=1;const t=n
+;let i=l(e),s="";for(;i.length>0;){const e=b.exec(i);if(!e){s+=i;break}
+s+=i.substring(0,e.index),
+i=i.substring(e.index+e[0].length),"\\"===e[0][0]&&e[1]?s+="\\"+(Number(e[1])+t):(s+=e[0],
+"("===e[0]&&n++)}return s})).map((e=>`(${e})`)).join(t)}
+const E="[a-zA-Z]\\w*",x="[a-zA-Z_]\\w*",w="\\b\\d+(\\.\\d+)?",y="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",_="\\b(0b[01]+)",O={
+begin:"\\\\[\\s\\S]",relevance:0},v={scope:"string",begin:"'",end:"'",
+illegal:"\\n",contains:[O]},k={scope:"string",begin:'"',end:'"',illegal:"\\n",
+contains:[O]},N=(e,t,n={})=>{const s=i({scope:"comment",begin:e,end:t,
+contains:[]},n);s.contains.push({scope:"doctag",
+begin:"[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+end:/(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,excludeBegin:!0,relevance:0})
+;const o=f("I","a","is","so","us","to","at","if","in","it","on",/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,/[A-Za-z]+[-][a-z]+/,/[A-Za-z][a-z]{2,}/)
+;return s.contains.push({begin:h(/[ ]+/,"(",o,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),s
+},S=N("//","$"),M=N("/\\*","\\*/"),R=N("#","$");var j=Object.freeze({
+__proto__:null,APOS_STRING_MODE:v,BACKSLASH_ESCAPE:O,BINARY_NUMBER_MODE:{
+scope:"number",begin:_,relevance:0},BINARY_NUMBER_RE:_,COMMENT:N,
+C_BLOCK_COMMENT_MODE:M,C_LINE_COMMENT_MODE:S,C_NUMBER_MODE:{scope:"number",
+begin:y,relevance:0},C_NUMBER_RE:y,END_SAME_AS_BEGIN:e=>Object.assign(e,{
+"on:begin":(e,t)=>{t.data._beginMatch=e[1]},"on:end":(e,t)=>{
+t.data._beginMatch!==e[1]&&t.ignoreMatch()}}),HASH_COMMENT_MODE:R,IDENT_RE:E,
+MATCH_NOTHING_RE:/\b\B/,METHOD_GUARD:{begin:"\\.\\s*"+x,relevance:0},
+NUMBER_MODE:{scope:"number",begin:w,relevance:0},NUMBER_RE:w,
+PHRASAL_WORDS_MODE:{
+begin:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+},QUOTE_STRING_MODE:k,REGEXP_MODE:{scope:"regexp",begin:/\/(?=[^/\n]*\/)/,
+end:/\/[gimuy]*/,contains:[O,{begin:/\[/,end:/\]/,relevance:0,contains:[O]}]},
+RE_STARTERS_RE:"!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
+SHEBANG:(e={})=>{const t=/^#![ ]*\//
+;return e.binary&&(e.begin=h(t,/.*\b/,e.binary,/\b.*/)),i({scope:"meta",begin:t,
+end:/$/,relevance:0,"on:begin":(e,t)=>{0!==e.index&&t.ignoreMatch()}},e)},
+TITLE_MODE:{scope:"title",begin:E,relevance:0},UNDERSCORE_IDENT_RE:x,
+UNDERSCORE_TITLE_MODE:{scope:"title",begin:x,relevance:0}});function A(e,t){
+"."===e.input[e.index-1]&&t.ignoreMatch()}function I(e,t){
+void 0!==e.className&&(e.scope=e.className,delete e.className)}function T(e,t){
+t&&e.beginKeywords&&(e.begin="\\b("+e.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",
+e.__beforeBegin=A,e.keywords=e.keywords||e.beginKeywords,delete e.beginKeywords,
+void 0===e.relevance&&(e.relevance=0))}function L(e,t){
+Array.isArray(e.illegal)&&(e.illegal=f(...e.illegal))}function B(e,t){
+if(e.match){
+if(e.begin||e.end)throw Error("begin & end are not supported with match")
+;e.begin=e.match,delete e.match}}function P(e,t){
+void 0===e.relevance&&(e.relevance=1)}const D=(e,t)=>{if(!e.beforeMatch)return
+;if(e.starts)throw Error("beforeMatch cannot be used with starts")
+;const n=Object.assign({},e);Object.keys(e).forEach((t=>{delete e[t]
+})),e.keywords=n.keywords,e.begin=h(n.beforeMatch,g(n.begin)),e.starts={
+relevance:0,contains:[Object.assign(n,{endsParent:!0})]
+},e.relevance=0,delete n.beforeMatch
+},H=["of","and","for","in","not","or","if","then","parent","list","value"],C="keyword"
+;function $(e,t,n=C){const i=Object.create(null)
+;return"string"==typeof e?s(n,e.split(" ")):Array.isArray(e)?s(n,e):Object.keys(e).forEach((n=>{
+Object.assign(i,$(e[n],t,n))})),i;function s(e,n){
+t&&(n=n.map((e=>e.toLowerCase()))),n.forEach((t=>{const n=t.split("|")
+;i[n[0]]=[e,U(n[0],n[1])]}))}}function U(e,t){
+return t?Number(t):(e=>H.includes(e.toLowerCase()))(e)?0:1}const z={},W=e=>{
+console.error(e)},X=(e,...t)=>{console.log("WARN: "+e,...t)},G=(e,t)=>{
+z[`${e}/${t}`]||(console.log(`Deprecated as of ${e}. ${t}`),z[`${e}/${t}`]=!0)
+},K=Error();function F(e,t,{key:n}){let i=0;const s=e[n],o={},r={}
+;for(let e=1;e<=t.length;e++)r[e+i]=s[e],o[e+i]=!0,i+=p(t[e-1])
+;e[n]=r,e[n]._emit=o,e[n]._multi=!0}function Z(e){(e=>{
+e.scope&&"object"==typeof e.scope&&null!==e.scope&&(e.beginScope=e.scope,
+delete e.scope)})(e),"string"==typeof e.beginScope&&(e.beginScope={
+_wrap:e.beginScope}),"string"==typeof e.endScope&&(e.endScope={_wrap:e.endScope
+}),(e=>{if(Array.isArray(e.begin)){
+if(e.skip||e.excludeBegin||e.returnBegin)throw W("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
+K
+;if("object"!=typeof e.beginScope||null===e.beginScope)throw W("beginScope must be object"),
+K;F(e,e.begin,{key:"beginScope"}),e.begin=m(e.begin,{joinWith:""})}})(e),(e=>{
+if(Array.isArray(e.end)){
+if(e.skip||e.excludeEnd||e.returnEnd)throw W("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
+K
+;if("object"!=typeof e.endScope||null===e.endScope)throw W("endScope must be object"),
+K;F(e,e.end,{key:"endScope"}),e.end=m(e.end,{joinWith:""})}})(e)}function V(e){
+function t(t,n){
+return RegExp(l(t),"m"+(e.case_insensitive?"i":"")+(e.unicodeRegex?"u":"")+(n?"g":""))
+}class n{constructor(){
+this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}
+addRule(e,t){
+t.position=this.position++,this.matchIndexes[this.matchAt]=t,this.regexes.push([t,e]),
+this.matchAt+=p(e)+1}compile(){0===this.regexes.length&&(this.exec=()=>null)
+;const e=this.regexes.map((e=>e[1]));this.matcherRe=t(m(e,{joinWith:"|"
+}),!0),this.lastIndex=0}exec(e){this.matcherRe.lastIndex=this.lastIndex
+;const t=this.matcherRe.exec(e);if(!t)return null
+;const n=t.findIndex(((e,t)=>t>0&&void 0!==e)),i=this.matchIndexes[n]
+;return t.splice(0,n),Object.assign(t,i)}}class s{constructor(){
+this.rules=[],this.multiRegexes=[],
+this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(e){
+if(this.multiRegexes[e])return this.multiRegexes[e];const t=new n
+;return this.rules.slice(e).forEach((([e,n])=>t.addRule(e,n))),
+t.compile(),this.multiRegexes[e]=t,t}resumingScanAtSamePosition(){
+return 0!==this.regexIndex}considerAll(){this.regexIndex=0}addRule(e,t){
+this.rules.push([e,t]),"begin"===t.type&&this.count++}exec(e){
+const t=this.getMatcher(this.regexIndex);t.lastIndex=this.lastIndex
+;let n=t.exec(e)
+;if(this.resumingScanAtSamePosition())if(n&&n.index===this.lastIndex);else{
+const t=this.getMatcher(0);t.lastIndex=this.lastIndex+1,n=t.exec(e)}
+return n&&(this.regexIndex+=n.position+1,
+this.regexIndex===this.count&&this.considerAll()),n}}
+if(e.compilerExtensions||(e.compilerExtensions=[]),
+e.contains&&e.contains.includes("self"))throw Error("ERR: contains `self` is not supported at the top-level of a language. See documentation.")
+;return e.classNameAliases=i(e.classNameAliases||{}),function n(o,r){const a=o
+;if(o.isCompiled)return a
+;[I,B,Z,D].forEach((e=>e(o,r))),e.compilerExtensions.forEach((e=>e(o,r))),
+o.__beforeBegin=null,[T,L,P].forEach((e=>e(o,r))),o.isCompiled=!0;let c=null
+;return"object"==typeof o.keywords&&o.keywords.$pattern&&(o.keywords=Object.assign({},o.keywords),
+c=o.keywords.$pattern,
+delete o.keywords.$pattern),c=c||/\w+/,o.keywords&&(o.keywords=$(o.keywords,e.case_insensitive)),
+a.keywordPatternRe=t(c,!0),
+r&&(o.begin||(o.begin=/\B|\b/),a.beginRe=t(a.begin),o.end||o.endsWithParent||(o.end=/\B|\b/),
+o.end&&(a.endRe=t(a.end)),
+a.terminatorEnd=l(a.end)||"",o.endsWithParent&&r.terminatorEnd&&(a.terminatorEnd+=(o.end?"|":"")+r.terminatorEnd)),
+o.illegal&&(a.illegalRe=t(o.illegal)),
+o.contains||(o.contains=[]),o.contains=[].concat(...o.contains.map((e=>(e=>(e.variants&&!e.cachedVariants&&(e.cachedVariants=e.variants.map((t=>i(e,{
+variants:null},t)))),e.cachedVariants?e.cachedVariants:q(e)?i(e,{
+starts:e.starts?i(e.starts):null
+}):Object.isFrozen(e)?i(e):e))("self"===e?o:e)))),o.contains.forEach((e=>{n(e,a)
+})),o.starts&&n(o.starts,r),a.matcher=(e=>{const t=new s
+;return e.contains.forEach((e=>t.addRule(e.begin,{rule:e,type:"begin"
+}))),e.terminatorEnd&&t.addRule(e.terminatorEnd,{type:"end"
+}),e.illegal&&t.addRule(e.illegal,{type:"illegal"}),t})(a),a}(e)}function q(e){
+return!!e&&(e.endsWithParent||q(e.starts))}class J extends Error{
+constructor(e,t){super(e),this.name="HTMLInjectionError",this.html=t}}
+const Y=n,Q=i,ee=Symbol("nomatch"),te=n=>{
+const i=Object.create(null),s=Object.create(null),o=[];let r=!0
+;const a="Could not find the language '{}', did you forget to load/include a language module?",l={
+disableAutodetect:!0,name:"Plain text",contains:[]};let p={
+ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,
+languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",
+cssSelector:"pre code",languages:null,__emitter:c};function b(e){
+return p.noHighlightRe.test(e)}function m(e,t,n){let i="",s=""
+;"object"==typeof t?(i=e,
+n=t.ignoreIllegals,s=t.language):(G("10.7.0","highlight(lang, code, ...args) has been deprecated."),
+G("10.7.0","Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),
+s=e,i=t),void 0===n&&(n=!0);const o={code:i,language:s};N("before:highlight",o)
+;const r=o.result?o.result:E(o.language,o.code,n)
+;return r.code=o.code,N("after:highlight",r),r}function E(e,n,s,o){
+const c=Object.create(null);function l(){if(!N.keywords)return void M.addText(R)
+;let e=0;N.keywordPatternRe.lastIndex=0;let t=N.keywordPatternRe.exec(R),n=""
+;for(;t;){n+=R.substring(e,t.index)
+;const s=_.case_insensitive?t[0].toLowerCase():t[0],o=(i=s,N.keywords[i]);if(o){
+const[e,i]=o
+;if(M.addText(n),n="",c[s]=(c[s]||0)+1,c[s]<=7&&(j+=i),e.startsWith("_"))n+=t[0];else{
+const n=_.classNameAliases[e]||e;u(t[0],n)}}else n+=t[0]
+;e=N.keywordPatternRe.lastIndex,t=N.keywordPatternRe.exec(R)}var i
+;n+=R.substring(e),M.addText(n)}function g(){null!=N.subLanguage?(()=>{
+if(""===R)return;let e=null;if("string"==typeof N.subLanguage){
+if(!i[N.subLanguage])return void M.addText(R)
+;e=E(N.subLanguage,R,!0,S[N.subLanguage]),S[N.subLanguage]=e._top
+}else e=x(R,N.subLanguage.length?N.subLanguage:null)
+;N.relevance>0&&(j+=e.relevance),M.__addSublanguage(e._emitter,e.language)
+})():l(),R=""}function u(e,t){
+""!==e&&(M.startScope(t),M.addText(e),M.endScope())}function d(e,t){let n=1
+;const i=t.length-1;for(;n<=i;){if(!e._emit[n]){n++;continue}
+const i=_.classNameAliases[e[n]]||e[n],s=t[n];i?u(s,i):(R=s,l(),R=""),n++}}
+function h(e,t){
+return e.scope&&"string"==typeof e.scope&&M.openNode(_.classNameAliases[e.scope]||e.scope),
+e.beginScope&&(e.beginScope._wrap?(u(R,_.classNameAliases[e.beginScope._wrap]||e.beginScope._wrap),
+R=""):e.beginScope._multi&&(d(e.beginScope,t),R="")),N=Object.create(e,{parent:{
+value:N}}),N}function f(e,n,i){let s=((e,t)=>{const n=e&&e.exec(t)
+;return n&&0===n.index})(e.endRe,i);if(s){if(e["on:end"]){const i=new t(e)
+;e["on:end"](n,i),i.isMatchIgnored&&(s=!1)}if(s){
+for(;e.endsParent&&e.parent;)e=e.parent;return e}}
+if(e.endsWithParent)return f(e.parent,n,i)}function b(e){
+return 0===N.matcher.regexIndex?(R+=e[0],1):(T=!0,0)}function m(e){
+const t=e[0],i=n.substring(e.index),s=f(N,e,i);if(!s)return ee;const o=N
+;N.endScope&&N.endScope._wrap?(g(),
+u(t,N.endScope._wrap)):N.endScope&&N.endScope._multi?(g(),
+d(N.endScope,e)):o.skip?R+=t:(o.returnEnd||o.excludeEnd||(R+=t),
+g(),o.excludeEnd&&(R=t));do{
+N.scope&&M.closeNode(),N.skip||N.subLanguage||(j+=N.relevance),N=N.parent
+}while(N!==s.parent);return s.starts&&h(s.starts,e),o.returnEnd?0:t.length}
+let w={};function y(i,o){const a=o&&o[0];if(R+=i,null==a)return g(),0
+;if("begin"===w.type&&"end"===o.type&&w.index===o.index&&""===a){
+if(R+=n.slice(o.index,o.index+1),!r){const t=Error(`0 width match regex (${e})`)
+;throw t.languageName=e,t.badRule=w.rule,t}return 1}
+if(w=o,"begin"===o.type)return(e=>{
+const n=e[0],i=e.rule,s=new t(i),o=[i.__beforeBegin,i["on:begin"]]
+;for(const t of o)if(t&&(t(e,s),s.isMatchIgnored))return b(n)
+;return i.skip?R+=n:(i.excludeBegin&&(R+=n),
+g(),i.returnBegin||i.excludeBegin||(R=n)),h(i,e),i.returnBegin?0:n.length})(o)
+;if("illegal"===o.type&&!s){
+const e=Error('Illegal lexeme "'+a+'" for mode "'+(N.scope||"")+'"')
+;throw e.mode=N,e}if("end"===o.type){const e=m(o);if(e!==ee)return e}
+if("illegal"===o.type&&""===a)return 1
+;if(I>1e5&&I>3*o.index)throw Error("potential infinite loop, way more iterations than matches")
+;return R+=a,a.length}const _=O(e)
+;if(!_)throw W(a.replace("{}",e)),Error('Unknown language: "'+e+'"')
+;const v=V(_);let k="",N=o||v;const S={},M=new p.__emitter(p);(()=>{const e=[]
+;for(let t=N;t!==_;t=t.parent)t.scope&&e.unshift(t.scope)
+;e.forEach((e=>M.openNode(e)))})();let R="",j=0,A=0,I=0,T=!1;try{
+if(_.__emitTokens)_.__emitTokens(n,M);else{for(N.matcher.considerAll();;){
+I++,T?T=!1:N.matcher.considerAll(),N.matcher.lastIndex=A
+;const e=N.matcher.exec(n);if(!e)break;const t=y(n.substring(A,e.index),e)
+;A=e.index+t}y(n.substring(A))}return M.finalize(),k=M.toHTML(),{language:e,
+value:k,relevance:j,illegal:!1,_emitter:M,_top:N}}catch(t){
+if(t.message&&t.message.includes("Illegal"))return{language:e,value:Y(n),
+illegal:!0,relevance:0,_illegalBy:{message:t.message,index:A,
+context:n.slice(A-100,A+100),mode:t.mode,resultSoFar:k},_emitter:M};if(r)return{
+language:e,value:Y(n),illegal:!1,relevance:0,errorRaised:t,_emitter:M,_top:N}
+;throw t}}function x(e,t){t=t||p.languages||Object.keys(i);const n=(e=>{
+const t={value:Y(e),illegal:!1,relevance:0,_top:l,_emitter:new p.__emitter(p)}
+;return t._emitter.addText(e),t})(e),s=t.filter(O).filter(k).map((t=>E(t,e,!1)))
+;s.unshift(n);const o=s.sort(((e,t)=>{
+if(e.relevance!==t.relevance)return t.relevance-e.relevance
+;if(e.language&&t.language){if(O(e.language).supersetOf===t.language)return 1
+;if(O(t.language).supersetOf===e.language)return-1}return 0})),[r,a]=o,c=r
+;return c.secondBest=a,c}function w(e){let t=null;const n=(e=>{
+let t=e.className+" ";t+=e.parentNode?e.parentNode.className:""
+;const n=p.languageDetectRe.exec(t);if(n){const t=O(n[1])
+;return t||(X(a.replace("{}",n[1])),
+X("Falling back to no-highlight mode for this block.",e)),t?n[1]:"no-highlight"}
+return t.split(/\s+/).find((e=>b(e)||O(e)))})(e);if(b(n))return
+;if(N("before:highlightElement",{el:e,language:n
+}),e.dataset.highlighted)return void console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",e)
+;if(e.children.length>0&&(p.ignoreUnescapedHTML||(console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),
+console.warn("https://github.com/highlightjs/highlight.js/wiki/security"),
+console.warn("The element with unescaped HTML:"),
+console.warn(e)),p.throwUnescapedHTML))throw new J("One of your code blocks includes unescaped HTML.",e.innerHTML)
+;t=e;const i=t.textContent,o=n?m(i,{language:n,ignoreIllegals:!0}):x(i)
+;e.innerHTML=o.value,e.dataset.highlighted="yes",((e,t,n)=>{const i=t&&s[t]||n
+;e.classList.add("hljs"),e.classList.add("language-"+i)
+})(e,n,o.language),e.result={language:o.language,re:o.relevance,
+relevance:o.relevance},o.secondBest&&(e.secondBest={
+language:o.secondBest.language,relevance:o.secondBest.relevance
+}),N("after:highlightElement",{el:e,result:o,text:i})}let y=!1;function _(){
+"loading"!==document.readyState?document.querySelectorAll(p.cssSelector).forEach(w):y=!0
+}function O(e){return e=(e||"").toLowerCase(),i[e]||i[s[e]]}
+function v(e,{languageName:t}){"string"==typeof e&&(e=[e]),e.forEach((e=>{
+s[e.toLowerCase()]=t}))}function k(e){const t=O(e)
+;return t&&!t.disableAutodetect}function N(e,t){const n=e;o.forEach((e=>{
+e[n]&&e[n](t)}))}
+"undefined"!=typeof window&&window.addEventListener&&window.addEventListener("DOMContentLoaded",(()=>{
+y&&_()}),!1),Object.assign(n,{highlight:m,highlightAuto:x,highlightAll:_,
+highlightElement:w,
+highlightBlock:e=>(G("10.7.0","highlightBlock will be removed entirely in v12.0"),
+G("10.7.0","Please use highlightElement now."),w(e)),configure:e=>{p=Q(p,e)},
+initHighlighting:()=>{
+_(),G("10.6.0","initHighlighting() deprecated. Use highlightAll() now.")},
+initHighlightingOnLoad:()=>{
+_(),G("10.6.0","initHighlightingOnLoad() deprecated. Use highlightAll() now.")
+},registerLanguage:(e,t)=>{let s=null;try{s=t(n)}catch(t){
+if(W("Language definition for '{}' could not be registered.".replace("{}",e)),
+!r)throw t;W(t),s=l}
+s.name||(s.name=e),i[e]=s,s.rawDefinition=t.bind(null,n),s.aliases&&v(s.aliases,{
+languageName:e})},unregisterLanguage:e=>{delete i[e]
+;for(const t of Object.keys(s))s[t]===e&&delete s[t]},
+listLanguages:()=>Object.keys(i),getLanguage:O,registerAliases:v,
+autoDetection:k,inherit:Q,addPlugin:e=>{(e=>{
+e["before:highlightBlock"]&&!e["before:highlightElement"]&&(e["before:highlightElement"]=t=>{
+e["before:highlightBlock"](Object.assign({block:t.el},t))
+}),e["after:highlightBlock"]&&!e["after:highlightElement"]&&(e["after:highlightElement"]=t=>{
+e["after:highlightBlock"](Object.assign({block:t.el},t))})})(e),o.push(e)},
+removePlugin:e=>{const t=o.indexOf(e);-1!==t&&o.splice(t,1)}}),n.debugMode=()=>{
+r=!1},n.safeMode=()=>{r=!0},n.versionString="11.9.0",n.regex={concat:h,
+lookahead:g,either:f,optional:d,anyNumberOfTimes:u}
+;for(const t in j)"object"==typeof j[t]&&e(j[t]);return Object.assign(n,j),n
+},ne=te({});return ne.newInstance=()=>te({}),ne}()
+;"object"==typeof exports&&"undefined"!=typeof module&&(module.exports=hljs);/*! `markdown` grammar compiled for Highlight.js 11.9.0 */
+(()=>{var e=(()=>{"use strict";return e=>{const n={begin:/<\/?[A-Za-z_]/,
+end:">",subLanguage:"xml",relevance:0},a={variants:[{begin:/\[.+?\]\[.*?\]/,
+relevance:0},{
+begin:/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+relevance:2},{
+begin:e.regex.concat(/\[.+?\]\(/,/[A-Za-z][A-Za-z0-9+.-]*/,/:\/\/.*?\)/),
+relevance:2},{begin:/\[.+?\]\([./?].*?\)/,relevance:1},{
+begin:/\[.*?\]\(.*?\)/,relevance:0}],returnBegin:!0,contains:[{match:/\[(?=\])/
+},{className:"string",relevance:0,begin:"\\[",end:"\\]",excludeBegin:!0,
+returnEnd:!0},{className:"link",relevance:0,begin:"\\]\\(",end:"\\)",
+excludeBegin:!0,excludeEnd:!0},{className:"symbol",relevance:0,begin:"\\]\\[",
+end:"\\]",excludeBegin:!0,excludeEnd:!0}]},i={className:"strong",contains:[],
+variants:[{begin:/_{2}(?!\s)/,end:/_{2}/},{begin:/\*{2}(?!\s)/,end:/\*{2}/}]
+},s={className:"emphasis",contains:[],variants:[{begin:/\*(?![*\s])/,end:/\*/},{
+begin:/_(?![_\s])/,end:/_/,relevance:0}]},c=e.inherit(i,{contains:[]
+}),t=e.inherit(s,{contains:[]});i.contains.push(t),s.contains.push(c)
+;let g=[n,a];return[i,s,c,t].forEach((e=>{e.contains=e.contains.concat(g)
+})),g=g.concat(i,s),{name:"Markdown",aliases:["md","mkdown","mkd"],contains:[{
+className:"section",variants:[{begin:"^#{1,6}",end:"$",contains:g},{
+begin:"(?=^.+?\\n[=-]{2,}$)",contains:[{begin:"^[=-]*$"},{begin:"^",end:"\\n",
+contains:g}]}]},n,{className:"bullet",begin:"^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
+end:"\\s+",excludeEnd:!0},i,s,{className:"quote",begin:"^>\\s+",contains:g,
+end:"$"},{className:"code",variants:[{begin:"(`{3,})[^`](.|\\n)*?\\1`*[ ]*"},{
+begin:"(~{3,})[^~](.|\\n)*?\\1~*[ ]*"},{begin:"```",end:"```+[ ]*$"},{
+begin:"~~~",end:"~~~+[ ]*$"},{begin:"`.+?`"},{begin:"(?=^( {4}|\\t))",
+contains:[{begin:"^( {4}|\\t)",end:"(\\n)$"}],relevance:0}]},{
+begin:"^[-\\*]{3,}",end:"$"},a,{begin:/^\[[^\n]+\]:/,returnBegin:!0,contains:[{
+className:"symbol",begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0},{
+className:"link",begin:/:\s*/,end:/$/,excludeBegin:!0}]}]}}})()
+;hljs.registerLanguage("markdown",e)})();
\ No newline at end of file
diff --git a/templates/hljs/languages/markdown.js b/templates/hljs/languages/markdown.js
new file mode 100644
index 0000000..8fe9fc6
--- /dev/null
+++ b/templates/hljs/languages/markdown.js
@@ -0,0 +1,251 @@
+/*! `markdown` grammar compiled for Highlight.js 11.9.0 */
+ (function(){
+ var hljsGrammar = (function () {
+ 'use strict';
+
+ /*
+ Language: Markdown
+ Requires: xml.js
+ Author: John Crepezzi
+ Website: https://daringfireball.net/projects/markdown/
+ Category: common, markup
+ */
+
+ function markdown(hljs) {
+ const regex = hljs.regex;
+ const INLINE_HTML = {
+ begin: /<\/?[A-Za-z_]/,
+ end: '>',
+ subLanguage: 'xml',
+ relevance: 0
+ };
+ const HORIZONTAL_RULE = {
+ begin: '^[-\\*]{3,}',
+ end: '$'
+ };
+ const CODE = {
+ className: 'code',
+ variants: [
+ // TODO: fix to allow these to work with sublanguage also
+ { begin: '(`{3,})[^`](.|\\n)*?\\1`*[ ]*' },
+ { begin: '(~{3,})[^~](.|\\n)*?\\1~*[ ]*' },
+ // needed to allow markdown as a sublanguage to work
+ {
+ begin: '```',
+ end: '```+[ ]*$'
+ },
+ {
+ begin: '~~~',
+ end: '~~~+[ ]*$'
+ },
+ { begin: '`.+?`' },
+ {
+ begin: '(?=^( {4}|\\t))',
+ // use contains to gobble up multiple lines to allow the block to be whatever size
+ // but only have a single open/close tag vs one per line
+ contains: [
+ {
+ begin: '^( {4}|\\t)',
+ end: '(\\n)$'
+ }
+ ],
+ relevance: 0
+ }
+ ]
+ };
+ const LIST = {
+ className: 'bullet',
+ begin: '^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)',
+ end: '\\s+',
+ excludeEnd: true
+ };
+ const LINK_REFERENCE = {
+ begin: /^\[[^\n]+\]:/,
+ returnBegin: true,
+ contains: [
+ {
+ className: 'symbol',
+ begin: /\[/,
+ end: /\]/,
+ excludeBegin: true,
+ excludeEnd: true
+ },
+ {
+ className: 'link',
+ begin: /:\s*/,
+ end: /$/,
+ excludeBegin: true
+ }
+ ]
+ };
+ const URL_SCHEME = /[A-Za-z][A-Za-z0-9+.-]*/;
+ const LINK = {
+ variants: [
+ // too much like nested array access in so many languages
+ // to have any real relevance
+ {
+ begin: /\[.+?\]\[.*?\]/,
+ relevance: 0
+ },
+ // popular internet URLs
+ {
+ begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+ relevance: 2
+ },
+ {
+ begin: regex.concat(/\[.+?\]\(/, URL_SCHEME, /:\/\/.*?\)/),
+ relevance: 2
+ },
+ // relative urls
+ {
+ begin: /\[.+?\]\([./?].*?\)/,
+ relevance: 1
+ },
+ // whatever else, lower relevance (might not be a link at all)
+ {
+ begin: /\[.*?\]\(.*?\)/,
+ relevance: 0
+ }
+ ],
+ returnBegin: true,
+ contains: [
+ {
+ // empty strings for alt or link text
+ match: /\[(?=\])/ },
+ {
+ className: 'string',
+ relevance: 0,
+ begin: '\\[',
+ end: '\\]',
+ excludeBegin: true,
+ returnEnd: true
+ },
+ {
+ className: 'link',
+ relevance: 0,
+ begin: '\\]\\(',
+ end: '\\)',
+ excludeBegin: true,
+ excludeEnd: true
+ },
+ {
+ className: 'symbol',
+ relevance: 0,
+ begin: '\\]\\[',
+ end: '\\]',
+ excludeBegin: true,
+ excludeEnd: true
+ }
+ ]
+ };
+ const BOLD = {
+ className: 'strong',
+ contains: [], // defined later
+ variants: [
+ {
+ begin: /_{2}(?!\s)/,
+ end: /_{2}/
+ },
+ {
+ begin: /\*{2}(?!\s)/,
+ end: /\*{2}/
+ }
+ ]
+ };
+ const ITALIC = {
+ className: 'emphasis',
+ contains: [], // defined later
+ variants: [
+ {
+ begin: /\*(?![*\s])/,
+ end: /\*/
+ },
+ {
+ begin: /_(?![_\s])/,
+ end: /_/,
+ relevance: 0
+ }
+ ]
+ };
+
+ // 3 level deep nesting is not allowed because it would create confusion
+ // in cases like `***testing***` because where we don't know if the last
+ // `***` is starting a new bold/italic or finishing the last one
+ const BOLD_WITHOUT_ITALIC = hljs.inherit(BOLD, { contains: [] });
+ const ITALIC_WITHOUT_BOLD = hljs.inherit(ITALIC, { contains: [] });
+ BOLD.contains.push(ITALIC_WITHOUT_BOLD);
+ ITALIC.contains.push(BOLD_WITHOUT_ITALIC);
+
+ let CONTAINABLE = [
+ INLINE_HTML,
+ LINK
+ ];
+
+ [
+ BOLD,
+ ITALIC,
+ BOLD_WITHOUT_ITALIC,
+ ITALIC_WITHOUT_BOLD
+ ].forEach(m => {
+ m.contains = m.contains.concat(CONTAINABLE);
+ });
+
+ CONTAINABLE = CONTAINABLE.concat(BOLD, ITALIC);
+
+ const HEADER = {
+ className: 'section',
+ variants: [
+ {
+ begin: '^#{1,6}',
+ end: '$',
+ contains: CONTAINABLE
+ },
+ {
+ begin: '(?=^.+?\\n[=-]{2,}$)',
+ contains: [
+ { begin: '^[=-]*$' },
+ {
+ begin: '^',
+ end: "\\n",
+ contains: CONTAINABLE
+ }
+ ]
+ }
+ ]
+ };
+
+ const BLOCKQUOTE = {
+ className: 'quote',
+ begin: '^>\\s+',
+ contains: CONTAINABLE,
+ end: '$'
+ };
+
+ return {
+ name: 'Markdown',
+ aliases: [
+ 'md',
+ 'mkdown',
+ 'mkd'
+ ],
+ contains: [
+ HEADER,
+ INLINE_HTML,
+ LIST,
+ BOLD,
+ ITALIC,
+ BLOCKQUOTE,
+ CODE,
+ HORIZONTAL_RULE,
+ LINK,
+ LINK_REFERENCE
+ ]
+ };
+ }
+
+ return markdown;
+
+})();
+
+ hljs.registerLanguage('markdown', hljsGrammar);
+ })();
\ No newline at end of file
diff --git a/templates/hljs/languages/markdown.min.js b/templates/hljs/languages/markdown.min.js
new file mode 100644
index 0000000..01a1c28
--- /dev/null
+++ b/templates/hljs/languages/markdown.min.js
@@ -0,0 +1,31 @@
+/*! `markdown` grammar compiled for Highlight.js 11.9.0 */
+(()=>{var e=(()=>{"use strict";return e=>{const n={begin:/<\/?[A-Za-z_]/,
+end:">",subLanguage:"xml",relevance:0},a={variants:[{begin:/\[.+?\]\[.*?\]/,
+relevance:0},{
+begin:/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+relevance:2},{
+begin:e.regex.concat(/\[.+?\]\(/,/[A-Za-z][A-Za-z0-9+.-]*/,/:\/\/.*?\)/),
+relevance:2},{begin:/\[.+?\]\([./?].*?\)/,relevance:1},{
+begin:/\[.*?\]\(.*?\)/,relevance:0}],returnBegin:!0,contains:[{match:/\[(?=\])/
+},{className:"string",relevance:0,begin:"\\[",end:"\\]",excludeBegin:!0,
+returnEnd:!0},{className:"link",relevance:0,begin:"\\]\\(",end:"\\)",
+excludeBegin:!0,excludeEnd:!0},{className:"symbol",relevance:0,begin:"\\]\\[",
+end:"\\]",excludeBegin:!0,excludeEnd:!0}]},i={className:"strong",contains:[],
+variants:[{begin:/_{2}(?!\s)/,end:/_{2}/},{begin:/\*{2}(?!\s)/,end:/\*{2}/}]
+},s={className:"emphasis",contains:[],variants:[{begin:/\*(?![*\s])/,end:/\*/},{
+begin:/_(?![_\s])/,end:/_/,relevance:0}]},c=e.inherit(i,{contains:[]
+}),t=e.inherit(s,{contains:[]});i.contains.push(t),s.contains.push(c)
+;let g=[n,a];return[i,s,c,t].forEach((e=>{e.contains=e.contains.concat(g)
+})),g=g.concat(i,s),{name:"Markdown",aliases:["md","mkdown","mkd"],contains:[{
+className:"section",variants:[{begin:"^#{1,6}",end:"$",contains:g},{
+begin:"(?=^.+?\\n[=-]{2,}$)",contains:[{begin:"^[=-]*$"},{begin:"^",end:"\\n",
+contains:g}]}]},n,{className:"bullet",begin:"^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
+end:"\\s+",excludeEnd:!0},i,s,{className:"quote",begin:"^>\\s+",contains:g,
+end:"$"},{className:"code",variants:[{begin:"(`{3,})[^`](.|\\n)*?\\1`*[ ]*"},{
+begin:"(~{3,})[^~](.|\\n)*?\\1~*[ ]*"},{begin:"```",end:"```+[ ]*$"},{
+begin:"~~~",end:"~~~+[ ]*$"},{begin:"`.+?`"},{begin:"(?=^( {4}|\\t))",
+contains:[{begin:"^( {4}|\\t)",end:"(\\n)$"}],relevance:0}]},{
+begin:"^[-\\*]{3,}",end:"$"},a,{begin:/^\[[^\n]+\]:/,returnBegin:!0,contains:[{
+className:"symbol",begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0},{
+className:"link",begin:/:\s*/,end:/$/,excludeBegin:!0}]}]}}})()
+;hljs.registerLanguage("markdown",e)})();
\ No newline at end of file
diff --git a/templates/hljs/package.json b/templates/hljs/package.json
new file mode 100644
index 0000000..272c6a2
--- /dev/null
+++ b/templates/hljs/package.json
@@ -0,0 +1,93 @@
+{
+ "name": "@highlightjs/cdn-assets",
+ "description": "Syntax highlighting with language autodetection. (pre-compiled CDN assets)",
+ "keywords": [
+ "highlight",
+ "syntax"
+ ],
+ "homepage": "https://highlightjs.org/",
+ "version": "11.9.0",
+ "author": "Josh Goebel ",
+ "contributors": [
+ "Josh Goebel ",
+ "Egor Rogov ",
+ "Vladimir Jimenez ",
+ "Ivan Sagalaev ",
+ "Jeremy Hull ",
+ "Oleg Efimov ",
+ "Gidi Meir Morris ",
+ "Jan T. Sott ",
+ "Li Xuanji ",
+ "Marcos Cáceres ",
+ "Sang Dang "
+ ],
+ "bugs": {
+ "url": "https://github.com/highlightjs/highlight.js/issues"
+ },
+ "license": "BSD-3-Clause",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/highlightjs/highlight.js.git"
+ },
+ "sideEffects": [
+ "./es/common.js",
+ "./lib/common.js",
+ "*.css",
+ "*.scss"
+ ],
+ "scripts": {
+ "mocha": "mocha",
+ "lint": "eslint src/*.js src/lib/*.js demo/*.js tools/**/*.js --ignore-pattern vendor",
+ "lint-languages": "eslint --no-eslintrc -c .eslintrc.lang.js src/languages/**/*.js",
+ "build_and_test": "npm run build && npm run test",
+ "build_and_test_browser": "npm run build-browser && npm run test-browser",
+ "build": "node ./tools/build.js -t node",
+ "build-cdn": "node ./tools/build.js -t cdn",
+ "build-browser": "node ./tools/build.js -t browser :common",
+ "devtool": "npx http-server",
+ "test": "mocha test",
+ "test-markup": "mocha test/markup",
+ "test-detect": "mocha test/detect",
+ "test-browser": "mocha test/browser",
+ "test-parser": "mocha test/parser"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "devDependencies": {
+ "@colors/colors": "^1.6.0",
+ "@rollup/plugin-commonjs": "^25.0.5",
+ "@rollup/plugin-json": "^6.0.1",
+ "@rollup/plugin-node-resolve": "^15.2.3",
+ "@types/mocha": "^10.0.2",
+ "@typescript-eslint/eslint-plugin": "^6.7.4",
+ "@typescript-eslint/parser": "^6.7.4",
+ "clean-css": "^5.3.2",
+ "cli-table": "^0.3.1",
+ "commander": "^11.0.0",
+ "css": "^3.0.0",
+ "css-color-names": "^1.0.1",
+ "deep-freeze-es6": "^3.0.2",
+ "del": "^7.1.0",
+ "dependency-resolver": "^2.0.1",
+ "eslint": "^8.51.0",
+ "eslint-config-standard": "^17.1.0",
+ "eslint-plugin-import": "^2.28.1",
+ "eslint-plugin-node": "^11.1.0",
+ "eslint-plugin-promise": "^6.1.1",
+ "glob": "^8.1.0",
+ "glob-promise": "^6.0.5",
+ "handlebars": "^4.7.8",
+ "http-server": "^14.1.1",
+ "jsdom": "^22.1.0",
+ "lodash": "^4.17.20",
+ "mocha": "^10.2.0",
+ "refa": "^0.4.1",
+ "rollup": "^4.0.2",
+ "should": "^13.2.3",
+ "terser": "^5.21.0",
+ "tiny-worker": "^2.3.0",
+ "typescript": "^5.2.2",
+ "wcag-contrast": "^3.0.0"
+ }
+}
\ No newline at end of file
diff --git a/templates/hljs/styles/base16/windows-95-light.css b/templates/hljs/styles/base16/windows-95-light.css
new file mode 100644
index 0000000..bbf034d
--- /dev/null
+++ b/templates/hljs/styles/base16/windows-95-light.css
@@ -0,0 +1,163 @@
+pre code.hljs {
+ display: block;
+ overflow-x: auto;
+ padding: 1em
+}
+code.hljs {
+ padding: 3px 5px
+}
+/*!
+ Theme: Windows 95 Light
+ Author: Fergus Collins (https://github.com/C-Fergus)
+ License: ~ MIT (or more permissive) [via base16-schemes-source]
+ Maintainer: @highlightjs/core-team
+ Version: 2021.09.0
+*/
+/*
+ WARNING: DO NOT EDIT THIS FILE DIRECTLY.
+
+ This theme file was auto-generated from the Base16 scheme windows-95-light
+ by the Highlight.js Base16 template builder.
+
+ - https://github.com/highlightjs/base16-highlightjs
+*/
+/*
+base00 #fcfcfc Default Background
+base01 #e0e0e0 Lighter Background (Used for status bars, line number and folding marks)
+base02 #c4c4c4 Selection Background
+base03 #a8a8a8 Comments, Invisibles, Line Highlighting
+base04 #7e7e7e Dark Foreground (Used for status bars)
+base05 #545454 Default Foreground, Caret, Delimiters, Operators
+base06 #2a2a2a Light Foreground (Not often used)
+base07 #000000 Light Background (Not often used)
+base08 #a80000 Variables, XML Tags, Markup Link Text, Markup Lists, Diff Deleted
+base09 #fcfc54 Integers, Boolean, Constants, XML Attributes, Markup Link Url
+base0A #a85400 Classes, Markup Bold, Search Text Background
+base0B #00a800 Strings, Inherited Class, Markup Code, Diff Inserted
+base0C #00a8a8 Support, Regular Expressions, Escape Characters, Markup Quotes
+base0D #0000a8 Functions, Methods, Attribute IDs, Headings
+base0E #a800a8 Keywords, Storage, Selector, Markup Italic, Diff Changed
+base0F #54fc54 Deprecated, Opening/Closing Embedded Language Tags, e.g.
+*/
+pre code.hljs {
+ display: block;
+ overflow-x: auto;
+ padding: 1em
+}
+code.hljs {
+ padding: 3px 5px
+}
+.hljs {
+ color: #545454;
+ background: #fcfcfc
+}
+.hljs::selection,
+.hljs ::selection {
+ background-color: #c4c4c4;
+ color: #545454
+}
+/* purposely do not highlight these things */
+.hljs-formula,
+.hljs-params,
+.hljs-property {
+
+}
+/* base03 - #a8a8a8 - Comments, Invisibles, Line Highlighting */
+.hljs-comment {
+ color: #a8a8a8
+}
+/* base04 - #7e7e7e - Dark Foreground (Used for status bars) */
+.hljs-tag {
+ color: #7e7e7e
+}
+/* base05 - #545454 - Default Foreground, Caret, Delimiters, Operators */
+.hljs-subst,
+.hljs-punctuation,
+.hljs-operator {
+ color: #545454
+}
+.hljs-operator {
+ opacity: 0.7
+}
+/* base08 - Variables, XML Tags, Markup Link Text, Markup Lists, Diff Deleted */
+.hljs-bullet,
+.hljs-variable,
+.hljs-template-variable,
+.hljs-selector-tag,
+.hljs-name,
+.hljs-deletion {
+ color: #a80000
+}
+/* base09 - Integers, Boolean, Constants, XML Attributes, Markup Link Url */
+.hljs-symbol,
+.hljs-number,
+.hljs-link,
+.hljs-attr,
+.hljs-variable.constant_,
+.hljs-literal {
+ color: #fcfc54
+}
+/* base0A - Classes, Markup Bold, Search Text Background */
+.hljs-title,
+.hljs-class .hljs-title,
+.hljs-title.class_ {
+ color: #a85400
+}
+.hljs-strong {
+ font-weight: bold;
+ color: #a85400
+}
+/* base0B - Strings, Inherited Class, Markup Code, Diff Inserted */
+.hljs-code,
+.hljs-addition,
+.hljs-title.class_.inherited__,
+.hljs-string {
+ color: #00a800
+}
+/* base0C - Support, Regular Expressions, Escape Characters, Markup Quotes */
+/* guessing */
+.hljs-built_in,
+.hljs-doctag,
+.hljs-quote,
+.hljs-keyword.hljs-atrule,
+.hljs-regexp {
+ color: #00a8a8
+}
+/* base0D - Functions, Methods, Attribute IDs, Headings */
+.hljs-function .hljs-title,
+.hljs-attribute,
+.ruby .hljs-property,
+.hljs-title.function_,
+.hljs-section {
+ color: #0000a8
+}
+/* base0E - Keywords, Storage, Selector, Markup Italic, Diff Changed */
+/* .hljs-selector-id, */
+/* .hljs-selector-class, */
+/* .hljs-selector-attr, */
+/* .hljs-selector-pseudo, */
+.hljs-type,
+.hljs-template-tag,
+.diff .hljs-meta,
+.hljs-keyword {
+ color: #a800a8
+}
+.hljs-emphasis {
+ color: #a800a8;
+ font-style: italic
+}
+/* base0F - Deprecated, Opening/Closing Embedded Language Tags, e.g. */
+/*
+ prevent top level .keyword and .string scopes
+ from leaking into meta by accident
+*/
+.hljs-meta,
+.hljs-meta .hljs-keyword,
+.hljs-meta .hljs-string {
+ color: #54fc54
+}
+/* for v10 compatible themes */
+.hljs-meta .hljs-keyword,
+.hljs-meta-keyword {
+ font-weight: bold
+}
\ No newline at end of file
diff --git a/templates/hljs/styles/base16/windows-95-light.min.css b/templates/hljs/styles/base16/windows-95-light.min.css
new file mode 100644
index 0000000..c30dd24
--- /dev/null
+++ b/templates/hljs/styles/base16/windows-95-light.min.css
@@ -0,0 +1,7 @@
+/*!
+ Theme: Windows 95 Light
+ Author: Fergus Collins (https://github.com/C-Fergus)
+ License: ~ MIT (or more permissive) [via base16-schemes-source]
+ Maintainer: @highlightjs/core-team
+ Version: 2021.09.0
+*/pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{color:#545454;background:#fcfcfc}.hljs ::selection,.hljs::selection{background-color:#c4c4c4;color:#545454}.hljs-comment{color:#a8a8a8}.hljs-tag{color:#7e7e7e}.hljs-operator,.hljs-punctuation,.hljs-subst{color:#545454}.hljs-operator{opacity:.7}.hljs-bullet,.hljs-deletion,.hljs-name,.hljs-selector-tag,.hljs-template-variable,.hljs-variable{color:#a80000}.hljs-attr,.hljs-link,.hljs-literal,.hljs-number,.hljs-symbol,.hljs-variable.constant_{color:#fcfc54}.hljs-class .hljs-title,.hljs-title,.hljs-title.class_{color:#a85400}.hljs-strong{font-weight:700;color:#a85400}.hljs-addition,.hljs-code,.hljs-string,.hljs-title.class_.inherited__{color:#00a800}.hljs-built_in,.hljs-doctag,.hljs-keyword.hljs-atrule,.hljs-quote,.hljs-regexp{color:#00a8a8}.hljs-attribute,.hljs-function .hljs-title,.hljs-section,.hljs-title.function_,.ruby .hljs-property{color:#0000a8}.diff .hljs-meta,.hljs-keyword,.hljs-template-tag,.hljs-type{color:#a800a8}.hljs-emphasis{color:#a800a8;font-style:italic}.hljs-meta,.hljs-meta .hljs-keyword,.hljs-meta .hljs-string{color:#54fc54}.hljs-meta .hljs-keyword,.hljs-meta-keyword{font-weight:700}
\ No newline at end of file
diff --git a/templates/hljs/styles/base16/windows-95.css b/templates/hljs/styles/base16/windows-95.css
new file mode 100644
index 0000000..002d6f9
--- /dev/null
+++ b/templates/hljs/styles/base16/windows-95.css
@@ -0,0 +1,163 @@
+pre code.hljs {
+ display: block;
+ overflow-x: auto;
+ padding: 1em
+}
+code.hljs {
+ padding: 3px 5px
+}
+/*!
+ Theme: Windows 95
+ Author: Fergus Collins (https://github.com/C-Fergus)
+ License: ~ MIT (or more permissive) [via base16-schemes-source]
+ Maintainer: @highlightjs/core-team
+ Version: 2021.09.0
+*/
+/*
+ WARNING: DO NOT EDIT THIS FILE DIRECTLY.
+
+ This theme file was auto-generated from the Base16 scheme windows-95
+ by the Highlight.js Base16 template builder.
+
+ - https://github.com/highlightjs/base16-highlightjs
+*/
+/*
+base00 #000000 Default Background
+base01 #1C1C1C Lighter Background (Used for status bars, line number and folding marks)
+base02 #383838 Selection Background
+base03 #545454 Comments, Invisibles, Line Highlighting
+base04 #7e7e7e Dark Foreground (Used for status bars)
+base05 #a8a8a8 Default Foreground, Caret, Delimiters, Operators
+base06 #d2d2d2 Light Foreground (Not often used)
+base07 #fcfcfc Light Background (Not often used)
+base08 #fc5454 Variables, XML Tags, Markup Link Text, Markup Lists, Diff Deleted
+base09 #a85400 Integers, Boolean, Constants, XML Attributes, Markup Link Url
+base0A #fcfc54 Classes, Markup Bold, Search Text Background
+base0B #54fc54 Strings, Inherited Class, Markup Code, Diff Inserted
+base0C #54fcfc Support, Regular Expressions, Escape Characters, Markup Quotes
+base0D #5454fc Functions, Methods, Attribute IDs, Headings
+base0E #fc54fc Keywords, Storage, Selector, Markup Italic, Diff Changed
+base0F #00a800 Deprecated, Opening/Closing Embedded Language Tags, e.g.
+*/
+pre code.hljs {
+ display: block;
+ overflow-x: auto;
+ padding: 1em
+}
+code.hljs {
+ padding: 3px 5px
+}
+.hljs {
+ color: #a8a8a8;
+ background: #000000
+}
+.hljs::selection,
+.hljs ::selection {
+ background-color: #383838;
+ color: #a8a8a8
+}
+/* purposely do not highlight these things */
+.hljs-formula,
+.hljs-params,
+.hljs-property {
+
+}
+/* base03 - #545454 - Comments, Invisibles, Line Highlighting */
+.hljs-comment {
+ color: #545454
+}
+/* base04 - #7e7e7e - Dark Foreground (Used for status bars) */
+.hljs-tag {
+ color: #7e7e7e
+}
+/* base05 - #a8a8a8 - Default Foreground, Caret, Delimiters, Operators */
+.hljs-subst,
+.hljs-punctuation,
+.hljs-operator {
+ color: #a8a8a8
+}
+.hljs-operator {
+ opacity: 0.7
+}
+/* base08 - Variables, XML Tags, Markup Link Text, Markup Lists, Diff Deleted */
+.hljs-bullet,
+.hljs-variable,
+.hljs-template-variable,
+.hljs-selector-tag,
+.hljs-name,
+.hljs-deletion {
+ color: #fc5454
+}
+/* base09 - Integers, Boolean, Constants, XML Attributes, Markup Link Url */
+.hljs-symbol,
+.hljs-number,
+.hljs-link,
+.hljs-attr,
+.hljs-variable.constant_,
+.hljs-literal {
+ color: #a85400
+}
+/* base0A - Classes, Markup Bold, Search Text Background */
+.hljs-title,
+.hljs-class .hljs-title,
+.hljs-title.class_ {
+ color: #fcfc54
+}
+.hljs-strong {
+ font-weight: bold;
+ color: #fcfc54
+}
+/* base0B - Strings, Inherited Class, Markup Code, Diff Inserted */
+.hljs-code,
+.hljs-addition,
+.hljs-title.class_.inherited__,
+.hljs-string {
+ color: #54fc54
+}
+/* base0C - Support, Regular Expressions, Escape Characters, Markup Quotes */
+/* guessing */
+.hljs-built_in,
+.hljs-doctag,
+.hljs-quote,
+.hljs-keyword.hljs-atrule,
+.hljs-regexp {
+ color: #54fcfc
+}
+/* base0D - Functions, Methods, Attribute IDs, Headings */
+.hljs-function .hljs-title,
+.hljs-attribute,
+.ruby .hljs-property,
+.hljs-title.function_,
+.hljs-section {
+ color: #5454fc
+}
+/* base0E - Keywords, Storage, Selector, Markup Italic, Diff Changed */
+/* .hljs-selector-id, */
+/* .hljs-selector-class, */
+/* .hljs-selector-attr, */
+/* .hljs-selector-pseudo, */
+.hljs-type,
+.hljs-template-tag,
+.diff .hljs-meta,
+.hljs-keyword {
+ color: #fc54fc
+}
+.hljs-emphasis {
+ color: #fc54fc;
+ font-style: italic
+}
+/* base0F - Deprecated, Opening/Closing Embedded Language Tags, e.g. */
+/*
+ prevent top level .keyword and .string scopes
+ from leaking into meta by accident
+*/
+.hljs-meta,
+.hljs-meta .hljs-keyword,
+.hljs-meta .hljs-string {
+ color: #00a800
+}
+/* for v10 compatible themes */
+.hljs-meta .hljs-keyword,
+.hljs-meta-keyword {
+ font-weight: bold
+}
\ No newline at end of file
diff --git a/templates/hljs/styles/base16/windows-95.min.css b/templates/hljs/styles/base16/windows-95.min.css
new file mode 100644
index 0000000..962d307
--- /dev/null
+++ b/templates/hljs/styles/base16/windows-95.min.css
@@ -0,0 +1,7 @@
+/*!
+ Theme: Windows 95
+ Author: Fergus Collins (https://github.com/C-Fergus)
+ License: ~ MIT (or more permissive) [via base16-schemes-source]
+ Maintainer: @highlightjs/core-team
+ Version: 2021.09.0
+*/pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{color:#a8a8a8;background:#000}.hljs ::selection,.hljs::selection{background-color:#383838;color:#a8a8a8}.hljs-comment{color:#545454}.hljs-tag{color:#7e7e7e}.hljs-operator,.hljs-punctuation,.hljs-subst{color:#a8a8a8}.hljs-operator{opacity:.7}.hljs-bullet,.hljs-deletion,.hljs-name,.hljs-selector-tag,.hljs-template-variable,.hljs-variable{color:#fc5454}.hljs-attr,.hljs-link,.hljs-literal,.hljs-number,.hljs-symbol,.hljs-variable.constant_{color:#a85400}.hljs-class .hljs-title,.hljs-title,.hljs-title.class_{color:#fcfc54}.hljs-strong{font-weight:700;color:#fcfc54}.hljs-addition,.hljs-code,.hljs-string,.hljs-title.class_.inherited__{color:#54fc54}.hljs-built_in,.hljs-doctag,.hljs-keyword.hljs-atrule,.hljs-quote,.hljs-regexp{color:#54fcfc}.hljs-attribute,.hljs-function .hljs-title,.hljs-section,.hljs-title.function_,.ruby .hljs-property{color:#5454fc}.diff .hljs-meta,.hljs-keyword,.hljs-template-tag,.hljs-type{color:#fc54fc}.hljs-emphasis{color:#fc54fc;font-style:italic}.hljs-meta,.hljs-meta .hljs-keyword,.hljs-meta .hljs-string{color:#00a800}.hljs-meta .hljs-keyword,.hljs-meta-keyword{font-weight:700}
\ No newline at end of file
diff --git a/templates/hljs/styles/xt256.css b/templates/hljs/styles/xt256.css
new file mode 100644
index 0000000..85950c4
--- /dev/null
+++ b/templates/hljs/styles/xt256.css
@@ -0,0 +1,79 @@
+pre code.hljs {
+ display: block;
+ overflow-x: auto;
+ padding: 1em
+}
+code.hljs {
+ padding: 3px 5px
+}
+/*
+ xt256.css
+
+ Contact: initbar [at] protonmail [dot] ch
+ : github.com/initbar
+*/
+.hljs {
+ color: #eaeaea;
+ background: #000
+}
+.hljs-subst {
+ color: #eaeaea
+}
+.hljs-emphasis {
+ font-style: italic
+}
+.hljs-strong {
+ font-weight: bold
+}
+.hljs-type {
+ color: #eaeaea
+}
+.hljs-params {
+ color: #da0000
+}
+.hljs-literal,
+.hljs-number,
+.hljs-name {
+ color: #ff0000;
+ font-weight: bolder
+}
+.hljs-comment {
+ color: #969896
+}
+.hljs-selector-id,
+.hljs-quote {
+ color: #00ffff
+}
+.hljs-template-variable,
+.hljs-variable,
+.hljs-title {
+ color: #00ffff;
+ font-weight: bold
+}
+.hljs-selector-class,
+.hljs-keyword,
+.hljs-symbol {
+ color: #fff000
+}
+.hljs-string,
+.hljs-bullet {
+ color: #00ff00
+}
+.hljs-tag,
+.hljs-section {
+ color: #000fff
+}
+.hljs-selector-tag {
+ color: #000fff;
+ font-weight: bold
+}
+.hljs-attribute,
+.hljs-built_in,
+.hljs-regexp,
+.hljs-link {
+ color: #ff00ff
+}
+.hljs-meta {
+ color: #fff;
+ font-weight: bolder
+}
\ No newline at end of file
diff --git a/templates/hljs/styles/xt256.min.css b/templates/hljs/styles/xt256.min.css
new file mode 100644
index 0000000..ef34f0c
--- /dev/null
+++ b/templates/hljs/styles/xt256.min.css
@@ -0,0 +1 @@
+pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{color:#eaeaea;background:#000}.hljs-subst{color:#eaeaea}.hljs-emphasis{font-style:italic}.hljs-strong{font-weight:700}.hljs-type{color:#eaeaea}.hljs-params{color:#da0000}.hljs-literal,.hljs-name,.hljs-number{color:red;font-weight:bolder}.hljs-comment{color:#969896}.hljs-quote,.hljs-selector-id{color:#0ff}.hljs-template-variable,.hljs-title,.hljs-variable{color:#0ff;font-weight:700}.hljs-keyword,.hljs-selector-class,.hljs-symbol{color:#fff000}.hljs-bullet,.hljs-string{color:#0f0}.hljs-section,.hljs-tag{color:#000fff}.hljs-selector-tag{color:#000fff;font-weight:700}.hljs-attribute,.hljs-built_in,.hljs-link,.hljs-regexp{color:#f0f}.hljs-meta{color:#fff;font-weight:bolder}
\ No newline at end of file
diff --git a/templates/index.tmpl b/templates/index.tmpl
new file mode 100644
index 0000000..000400c
--- /dev/null
+++ b/templates/index.tmpl
@@ -0,0 +1,5 @@
+
+
+
+
+