Bump the go-modules-updates group across 1 directory with 11 updates

Bumps the go-modules-updates group with 11 updates in the /backend directory: | Package | From | To | | --- | --- | --- | | [github.com/PuerkitoBio/goquery](https://github.com/PuerkitoBio/goquery) | `1.10.2` | `1.11.0` | | [github.com/alecthomas/chroma/v2](https://github.com/alecthomas/chroma) | `2.15.0` | `2.20.0` | | [github.com/go-chi/chi/v5](https://github.com/go-chi/chi) | `5.2.1` | `5.2.3` | | [github.com/go-chi/cors](https://github.com/go-chi/cors) | `1.2.1` | `1.2.2` | | [github.com/go-pkgz/jrpc](https://github.com/go-pkgz/jrpc) | `0.3.1` | `0.4.0` | | [github.com/go-pkgz/lgr](https://github.com/go-pkgz/lgr) | `0.12.0` | `0.12.1` | | [github.com/go-pkgz/rest](https://github.com/go-pkgz/rest) | `1.20.3` | `1.20.4` | | [github.com/golang-jwt/jwt/v5](https://github.com/golang-jwt/jwt) | `5.2.2` | `5.3.0` | | [github.com/stretchr/testify](https://github.com/stretchr/testify) | `1.10.0` | `1.11.1` | | [go.etcd.io/bbolt](https://github.com/etcd-io/bbolt) | `1.4.0` | `1.4.3` | | [golang.org/x/image](https://github.com/golang/image) | `0.26.0` | `0.33.0` | Updates `github.com/PuerkitoBio/goquery` from 1.10.2 to 1.11.0 - [Release notes](https://github.com/PuerkitoBio/goquery/releases) - [Commits](https://github.com/PuerkitoBio/goquery/compare/v1.10.2...v1.11.0) Updates `github.com/alecthomas/chroma/v2` from 2.15.0 to 2.20.0 - [Release notes](https://github.com/alecthomas/chroma/releases) - [Commits](https://github.com/alecthomas/chroma/compare/v2.15.0...v2.20.0) Updates `github.com/go-chi/chi/v5` from 5.2.1 to 5.2.3 - [Release notes](https://github.com/go-chi/chi/releases) - [Changelog](https://github.com/go-chi/chi/blob/master/CHANGELOG.md) - [Commits](https://github.com/go-chi/chi/compare/v5.2.1...v5.2.3) Updates `github.com/go-chi/cors` from 1.2.1 to 1.2.2 - [Release notes](https://github.com/go-chi/cors/releases) - [Commits](https://github.com/go-chi/cors/compare/v1.2.1...v1.2.2) Updates `github.com/go-pkgz/jrpc` from 0.3.1 to 0.4.0 - [Release notes](https://github.com/go-pkgz/jrpc/releases) - [Commits](https://github.com/go-pkgz/jrpc/compare/v0.3.1...v0.4.0) Updates `github.com/go-pkgz/lgr` from 0.12.0 to 0.12.1 - [Release notes](https://github.com/go-pkgz/lgr/releases) - [Commits](https://github.com/go-pkgz/lgr/compare/v0.12.0...v0.12.1) Updates `github.com/go-pkgz/rest` from 1.20.3 to 1.20.4 - [Release notes](https://github.com/go-pkgz/rest/releases) - [Commits](https://github.com/go-pkgz/rest/compare/v1.20.3...v1.20.4) Updates `github.com/golang-jwt/jwt/v5` from 5.2.2 to 5.3.0 - [Release notes](https://github.com/golang-jwt/jwt/releases) - [Commits](https://github.com/golang-jwt/jwt/compare/v5.2.2...v5.3.0) Updates `github.com/stretchr/testify` from 1.10.0 to 1.11.1 - [Release notes](https://github.com/stretchr/testify/releases) - [Commits](https://github.com/stretchr/testify/compare/v1.10.0...v1.11.1) Updates `go.etcd.io/bbolt` from 1.4.0 to 1.4.3 - [Release notes](https://github.com/etcd-io/bbolt/releases) - [Commits](https://github.com/etcd-io/bbolt/compare/v1.4.0...v1.4.3) Updates `golang.org/x/image` from 0.26.0 to 0.33.0 - [Commits](https://github.com/golang/image/compare/v0.26.0...v0.33.0) --- updated-dependencies: - dependency-name: github.com/PuerkitoBio/goquery dependency-version: 1.11.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: go-modules-updates - dependency-name: github.com/alecthomas/chroma/v2 dependency-version: 2.20.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: go-modules-updates - dependency-name: github.com/go-chi/chi/v5 dependency-version: 5.2.3 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: go-modules-updates - dependency-name: github.com/go-chi/cors dependency-version: 1.2.2 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: go-modules-updates - dependency-name: github.com/go-pkgz/jrpc dependency-version: 0.4.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: go-modules-updates - dependency-name: github.com/go-pkgz/lgr dependency-version: 0.12.1 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: go-modules-updates - dependency-name: github.com/go-pkgz/rest dependency-version: 1.20.4 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: go-modules-updates - dependency-name: github.com/golang-jwt/jwt/v5 dependency-version: 5.3.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: go-modules-updates - dependency-name: github.com/stretchr/testify dependency-version: 1.11.1 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: go-modules-updates - dependency-name: go.etcd.io/bbolt dependency-version: 1.4.3 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: go-modules-updates - dependency-name: golang.org/x/image dependency-version: 0.33.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: go-modules-updates ... Signed-off-by: dependabot[bot] <support@github.com>
2025-12-03 18:17:46 -06:00
parent d925584af8
commit 6d8a0c783b
197 changed files with 4874 additions and 5762 deletions
@@ -23,3 +23,6 @@ _models/
 _examples/
 *.min.*
 build/
+
+cmd/chromad/static/chroma.wasm
+cmd/chromad/static/wasm_exec.js
@@ -1,7 +1,5 @@
 run:
  tests: true
-  skip-dirs:
-    - _examples

 output:
  print-issued-lines: false
@@ -9,8 +7,6 @@ output:
 linters:
  enable-all: true
  disable:
-    - maligned
-    - megacheck
    - lll
    - gocyclo
    - dupl
@@ -18,9 +14,7 @@ linters:
    - funlen
    - godox
    - wsl
-    - gomnd
    - gocognit
-    - goerr113
    - nolintlint
    - testpackage
    - godot
@@ -28,12 +22,10 @@ linters:
    - paralleltest
    - nlreturn
    - cyclop
-    - exhaustivestruct
    - gci
    - gofumpt
    - errorlint
    - exhaustive
-    - ifshort
    - wrapcheck
    - stylecheck
    - thelper
@@ -46,7 +38,6 @@ linters:
    - ireturn
    - maintidx
    - govet
-    - nosnakecase
    - testableexamples
    - musttag
    - depguard
@@ -54,10 +45,11 @@ linters:
    - perfsprint
    - mnd
    - predeclared
+    - recvcheck
+    - tenv
+    - err113

 linters-settings:
-  govet:
-    check-shadowing: true
  gocyclo:
    min-complexity: 10
  dupl:
@@ -72,6 +64,8 @@ linters-settings:


 issues:
+  exclude-dirs:
+    - _examples
  max-per-linter: 0
  max-same: 0
  exclude-use-default: false
@@ -4,34 +4,31 @@ release:
    owner: alecthomas
    name: chroma
 brews:
-  -
-    install: bin.install "chroma"
+  - install: bin.install "chroma"
 env:
  - CGO_ENABLED=0
 builds:
- goos:
-    - linux
-    - darwin
-    - windows
-  goarch:
-    - arm64
-    - amd64
-    - "386"
-  goarm:
-    - "6"
-  dir: ./cmd/chroma
-  main: .
-  ldflags: -s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}
-  binary: chroma
+  - goos:
+      - linux
+      - darwin
+      - windows
+    goarch:
+      - arm64
+      - amd64
+      - "386"
+    goarm:
+      - "6"
+    dir: ./cmd/chroma
+    main: .
+    ldflags: -s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}
+    binary: chroma
 archives:
-  -
-    format: tar.gz
-    name_template: '{{ .Binary }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{
-    .Arm }}{{ end }}'
+  - format: tar.gz
+    name_template: "{{ .Binary }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
    files:
      - COPYING
      - README*
 snapshot:
  name_template: SNAPSHOT-{{ .Commit }}
 checksum:
-  name_template: '{{ .ProjectName }}-{{ .Version }}-checksums.txt'
+  name_template: "{{ .ProjectName }}-{{ .Version }}-checksums.txt"
@@ -0,0 +1,65 @@
+# Multi-stage Dockerfile for chromad Go application using Hermit-managed tools
+
+# Build stage
+FROM ubuntu:24.04 AS builder
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+	curl \
+	git \
+	make \
+	ca-certificates \
+	&& rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy the entire project (including bin directory with Hermit tools)
+COPY . .
+
+# Make Hermit tools executable and add to PATH
+ENV PATH="/app/bin:${PATH}"
+
+# Set Go environment variables for static compilation
+ENV CGO_ENABLED=0
+ENV GOOS=linux
+ENV GOARCH=amd64
+
+# Build the application using make
+RUN make build/chromad
+
+# Runtime stage
+FROM alpine:3.22 AS runtime
+
+# Install ca-certificates for HTTPS requests
+RUN apk --no-cache add ca-certificates curl
+
+# Create a non-root user
+RUN addgroup -g 1001 chromad && \
+	adduser -D -s /bin/sh -u 1001 -G chromad chromad
+
+# Set working directory
+WORKDIR /app
+
+# Copy the binary from build stage
+COPY --from=builder /app/build/chromad /app/chromad
+
+# Change ownership to non-root user
+RUN chown chromad:chromad /app/chromad
+
+# Switch to non-root user
+USER chromad
+
+# Expose port (default is 8080, but can be overridden via PORT env var)
+EXPOSE 8080
+
+# Set default environment variables
+ENV PORT=8080
+ENV CHROMA_CSRF_KEY="testtest"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+	CMD curl -fsSL http://127.0.0.1:8080/ > /dev/null
+
+# Run the application
+CMD ["sh", "-c", "./chromad --csrf-key=$CHROMA_CSRF_KEY --bind=0.0.0.0:$PORT"]
@@ -6,17 +6,36 @@ export GOARCH ?= amd64

 all: README.md tokentype_string.go

-README.md: lexers/*/*.go
-	./table.py
+README.md: lexers/*.go lexers/embedded/*.xml
+	GOOS= GOARCH= ./table.py

 tokentype_string.go: types.go
 	go generate

-chromad:
+.PHONY: format-js
+format-js:
+	biome format --write cmd/chromad/static/{index.js,chroma.js}
+
+.PHONY: chromad
+chromad: build/chromad
+
+build/chromad: $(shell find cmd/chromad -name '*.go' -o -name '*.html' -o -name '*.css' -o -name '*.js') \
+	cmd/chromad/static/wasm_exec.js \
+	cmd/chromad/static/chroma.wasm
 	rm -rf build
-	esbuild --bundle cmd/chromad/static/index.js --minify --outfile=cmd/chromad/static/index.min.js
+	esbuild --platform=node --bundle cmd/chromad/static/index.js --minify --outfile=cmd/chromad/static/index.min.js
 	esbuild --bundle cmd/chromad/static/index.css --minify --outfile=cmd/chromad/static/index.min.css
-	(export CGOENABLED=0 ; cd ./cmd/chromad && go build -ldflags="-X 'main.version=$(VERSION)'" -o ../../build/chromad .)
+	(export CGOENABLED=0 ; go build -C cmd/chromad -ldflags="-X 'main.version=$(VERSION)'" -o ../../build/chromad .)
+
+cmd/chromad/static/wasm_exec.js: $(shell tinygo env TINYGOROOT)/targets/wasm_exec.js
+	install -m644 $< $@
+
+cmd/chromad/static/chroma.wasm: $(shell git ls-files | grep '\.go|\.xml')
+	if type tinygo > /dev/null; then \
+		tinygo build -no-debug -target wasm -o $@ cmd/libchromawasm/main.go; \
+	else \
+		GOOS=js GOARCH=wasm go build -o $@ cmd/libchromawasm/main.go; \
+	fi

 upload: build/chromad
 	scp build/chromad root@swapoff.org: && \
@@ -1,6 +1,9 @@
-# Chroma — A general purpose syntax highlighter in pure Go
+![Chroma](chroma.jpg)
+
+# A general purpose syntax highlighter in pure Go
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/alecthomas/chroma/v2.svg)](https://pkg.go.dev/github.com/alecthomas/chroma/v2) [![CI](https://github.com/alecthomas/chroma/actions/workflows/ci.yml/badge.svg)](https://github.com/alecthomas/chroma/actions/workflows/ci.yml) [![Slack chat](https://img.shields.io/static/v1?logo=slack&style=flat&label=slack&color=green&message=gophers)](https://invite.slack.golangbridge.org/)

-[![Golang Documentation](https://godoc.org/github.com/alecthomas/chroma?status.svg)](https://godoc.org/github.com/alecthomas/chroma) [![CI](https://github.com/alecthomas/chroma/actions/workflows/ci.yml/badge.svg)](https://github.com/alecthomas/chroma/actions/workflows/ci.yml) [![Slack chat](https://img.shields.io/static/v1?logo=slack&style=flat&label=slack&color=green&message=gophers)](https://invite.slack.golangbridge.org/)

 Chroma takes source code and other structured text and converts it into syntax
 highlighted HTML, ANSI-coloured text, etc.
@@ -31,33 +34,34 @@ translators for Pygments lexers and styles.

 ## Supported languages

-| Prefix | Language                                                                                                                                                                                                                                            |
-| :----: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-|   A    | ABAP, ABNF, ActionScript, ActionScript 3, Ada, Agda, AL, Alloy, Angular2, ANTLR, ApacheConf, APL, AppleScript, ArangoDB AQL, Arduino, ArmAsm, AutoHotkey, AutoIt, Awk                                                                               |
-|   B    | Ballerina, Bash, Bash Session, Batchfile, BibTeX, Bicep, BlitzBasic, BNF, BQN, Brainfuck                                                                                                                                                            |
-|   C    | C, C#, C++, Caddyfile, Caddyfile Directives, Cap'n Proto, Cassandra CQL, Ceylon, CFEngine3, cfstatement, ChaiScript, Chapel, Cheetah, Clojure, CMake, COBOL, CoffeeScript, Common Lisp, Coq, Crystal, CSS, Cython                                   |
-|   D    | D, Dart, Dax, Desktop Entry, Diff, Django/Jinja, dns, Docker, DTD, Dylan                                                                                                                                                                            |
-|   E    | EBNF, Elixir, Elm, EmacsLisp, Erlang                                                                                                                                                                                                                |
-|   F    | Factor, Fennel, Fish, Forth, Fortran, FortranFixed, FSharp                                                                                                                                                                                          |
-|   G    | GAS, GDScript, Genshi, Genshi HTML, Genshi Text, Gherkin, Gleam, GLSL, Gnuplot, Go, Go HTML Template, Go Text Template, GraphQL, Groff, Groovy                                                                                                      |
-|   H    | Handlebars, Hare, Haskell, Haxe, HCL, Hexdump, HLB, HLSL, HolyC, HTML, HTTP, Hy                                                                                                                                                                     |
-|   I    | Idris, Igor, INI, Io, ISCdhcpd                                                                                                                                                                                                                      |
-|   J    | J, Java, JavaScript, JSON, Jsonnet, Julia, Jungle                                                                                                                                                                                                   |
-|   K    | Kotlin                                                                                                                                                                                                                                              |
-|   L    | Lighttpd configuration file, LLVM, Lua                                                                                                                                                                                                              |
-|   M    | Makefile, Mako, markdown, Mason, Materialize SQL dialect, Mathematica, Matlab, MCFunction, Meson, Metal, MiniZinc, MLIR, Modula-2, MonkeyC, MorrowindScript, Myghty, MySQL                                                                          |
-|   N    | NASM, Natural, Newspeak, Nginx configuration file, Nim, Nix, NSIS                                                                                                                                                                                   |
-|   O    | Objective-C, OCaml, Octave, Odin, OnesEnterprise, OpenEdge ABL, OpenSCAD, Org Mode                                                                                                                                                                  |
-|   P    | PacmanConf, Perl, PHP, PHTML, Pig, PkgConfig, PL/pgSQL, plaintext, Plutus Core, Pony, PostgreSQL SQL dialect, PostScript, POVRay, PowerQuery, PowerShell, Prolog, PromQL, Promela, properties, Protocol Buffer, PRQL, PSL, Puppet, Python, Python 2 |
-|   Q    | QBasic, QML                                                                                                                                                                                                                                         |
-|   R    | R, Racket, Ragel, Raku, react, ReasonML, reg, Rego, reStructuredText, Rexx, RPMSpec, Ruby, Rust                                                                                                                                                     |
-|   S    | SAS, Sass, Scala, Scheme, Scilab, SCSS, Sed, Sieve, Smali, Smalltalk, Smarty, SNBT, Snobol, Solidity, SourcePawn, SPARQL, SQL, SquidConf, Standard ML, stas, Stylus, Svelte, Swift, SYSTEMD, systemverilog                                                |
-|   T    | TableGen, Tal, TASM, Tcl, Tcsh, Termcap, Terminfo, Terraform, TeX, Thrift, TOML, TradingView, Transact-SQL, Turing, Turtle, Twig, TypeScript, TypoScript, TypoScriptCssData, TypoScriptHtmlData, Typst                                              |
-|   V    | V, V shell, Vala, VB.net, verilog, VHDL, VHS, VimL, vue                                                                                                                                                                                             |
-|   W    | WDTE, WebGPU Shading Language, Whiley                                                                                                                                                                                                               |
-|   X    | XML, Xorg                                                                                                                                                                                                                                           |
-|   Y    | YAML, YANG                                                                                                                                                                                                                                          |
-|   Z    | Z80 Assembly, Zed, Zig                                                                                                                                                                                                                              |
+| Prefix | Language
+| :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+|   A    | ABAP, ABNF, ActionScript, ActionScript 3, Ada, Agda, AL, Alloy, Angular2, ANTLR, ApacheConf, APL, AppleScript, ArangoDB AQL, Arduino, ArmAsm, ATL, AutoHotkey, AutoIt, Awk
+|   B    | Ballerina, Bash, Bash Session, Batchfile, Beef, BibTeX, Bicep, BlitzBasic, BNF, BQN, Brainfuck
+|   C    | C, C#, C++, Caddyfile, Caddyfile Directives, Cap'n Proto, Cassandra CQL, Ceylon, CFEngine3, cfstatement, ChaiScript, Chapel, Cheetah, Clojure, CMake, COBOL, CoffeeScript, Common Lisp, Coq, Core, Crystal, CSS, CSV, CUE, Cython
+|   D    | D, Dart, Dax, Desktop file, Diff, Django/Jinja, dns, Docker, DTD, Dylan
+|   E    | EBNF, Elixir, Elm, EmacsLisp, Erlang
+|   F    | Factor, Fennel, Fish, Forth, Fortran, FortranFixed, FSharp
+|   G    | GAS, GDScript, GDScript3, Gemtext, Genshi, Genshi HTML, Genshi Text, Gherkin, Gleam, GLSL, Gnuplot, Go, Go HTML Template, Go Template, Go Text Template, GraphQL, Groff, Groovy
+|   H    | Handlebars, Hare, Haskell, Haxe, HCL, Hexdump, HLB, HLSL, HolyC, HTML, HTTP, Hy
+|   I    | Idris, Igor, INI, Io, ISCdhcpd
+|   J    | J, Janet, Java, JavaScript, JSON, JSONata, Jsonnet, Julia, Jungle
+|   K    | Kotlin
+|   L    | Lean4, Lighttpd configuration file, LLVM, lox, Lua
+|   M    | Makefile, Mako, markdown, Mason, Materialize SQL dialect, Mathematica, Matlab, MCFunction, Meson, Metal, MiniZinc, MLIR, Modula-2, Mojo, MonkeyC, MoonScript, MorrowindScript, Myghty, MySQL
+|   N    | NASM, Natural, NDISASM, Newspeak, Nginx configuration file, Nim, Nix, NSIS, Nu
+|   O    | Objective-C, ObjectPascal, OCaml, Octave, Odin, OnesEnterprise, OpenEdge ABL, OpenSCAD, Org Mode
+|   P    | PacmanConf, Perl, PHP, PHTML, Pig, PkgConfig, PL/pgSQL, plaintext, Plutus Core, Pony, PostgreSQL SQL dialect, PostScript, POVRay, PowerQuery, PowerShell, Prolog, Promela, PromQL, properties, Protocol Buffer, PRQL, PSL, Puppet, Python, Python 2
+|   Q    | QBasic, QML
+|   R    | R, Racket, Ragel, Raku, react, ReasonML, reg, Rego, reStructuredText, Rexx, RPGLE, RPMSpec, Ruby, Rust
+|   S    | SAS, Sass, Scala, Scheme, Scilab, SCSS, Sed, Sieve, Smali, Smalltalk, Smarty, SNBT, Snobol, Solidity, SourcePawn, SPARQL, SQL, SquidConf, Standard ML, stas, Stylus, Svelte, Swift, SYSTEMD, systemverilog
+|   T    | TableGen, Tal, TASM, Tcl, Tcsh, Termcap, Terminfo, Terraform, TeX, Thrift, TOML, TradingView, Transact-SQL, Turing, Turtle, Twig, TypeScript, TypoScript, TypoScriptCssData, TypoScriptHtmlData, Typst
+|   U    | ucode
+|   V    | V, V shell, Vala, VB.net, verilog, VHDL, VHS, VimL, vue
+|   W    | WDTE, WebGPU Shading Language, WebVTT, Whiley
+|   X    | XML, Xorg
+|   Y    | YAML, YANG
+|   Z    | Z80 Assembly, Zed, Zig

 _I will attempt to keep this section up to date, but an authoritative list can be
 displayed with `chroma --list`._
@@ -210,8 +214,7 @@ python3 _tools/pygments2chroma_xml.py \
  > lexers/embedded/kotlin.xml
 ```

-See notes in [pygments-lexers.txt](https://github.com/alecthomas/chroma/blob/master/pygments-lexers.txt)
-for a list of lexers, and notes on some of the issues importing them.
+A list of all lexers available in Pygments can be found in [pygments-lexers.txt](https://github.com/alecthomas/chroma/blob/master/pygments-lexers.txt).

 ### Formatters

@@ -267,6 +270,13 @@ on under the hood for easy integration with [lesspipe shipping with
 Debian and derivatives](https://manpages.debian.org/lesspipe#USER_DEFINED_FILTERS);
 for that setup the `chroma` executable can be just symlinked to `~/.lessfilter`.

+## Projects using Chroma
+
+* [`moar`](https://github.com/walles/moar) is a full-blown pager that colorizes
+  its input using Chroma
+* [Hugo](https://gohugo.io/) is a static site generator that [uses Chroma for syntax
+  highlighting code examples](https://gohugo.io/content-management/syntax-highlighting/)
+
 ## Testing lexers

 If you edit some lexers and want to try it, open a shell in `cmd/chromad` and run:
@@ -0,0 +1,6 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.0.5/schema.json",
+	"formatter": {
+		"indentStyle": "space"
+	}
+}
@@ -24,6 +24,15 @@ func DelegatingLexer(root Lexer, language Lexer) Lexer {
 	}
 }

+func (d *delegatingLexer) SetTracing(enable bool) {
+	if l, ok := d.language.(TracingLexer); ok {
+		l.SetTracing(enable)
+	}
+	if l, ok := d.root.(TracingLexer); ok {
+		l.SetTracing(enable)
+	}
+}
+
 func (d *delegatingLexer) AnalyseText(text string) float32 {
 	return d.root.AnalyseText(text)
 }
@@ -10,6 +10,12 @@ type Emitter interface {
 	Emit(groups []string, state *LexerState) Iterator
 }

+// ValidatingEmitter is an Emitter that can validate against a compiled rule.
+type ValidatingEmitter interface {
+	Emitter
+	ValidateEmitter(rule *CompiledRule) error
+}
+
 // SerialisableEmitter is an Emitter that can be serialised and deserialised to/from JSON.
 type SerialisableEmitter interface {
 	Emitter
@@ -30,6 +36,8 @@ type byGroupsEmitter struct {
 	Emitters
 }

+var _ ValidatingEmitter = (*byGroupsEmitter)(nil)
+
 // ByGroups emits a token for each matching group in the rule's regex.
 func ByGroups(emitters ...Emitter) Emitter {
 	return &byGroupsEmitter{Emitters: emitters}
@@ -37,6 +45,13 @@ func ByGroups(emitters ...Emitter) Emitter {

 func (b *byGroupsEmitter) EmitterKind() string { return "bygroups" }

+func (b *byGroupsEmitter) ValidateEmitter(rule *CompiledRule) error {
+	if len(rule.Regexp.GetGroupNumbers())-1 != len(b.Emitters) {
+		return fmt.Errorf("number of groups %d does not match number of emitters %d", len(rule.Regexp.GetGroupNumbers())-1, len(b.Emitters))
+	}
+	return nil
+}
+
 func (b *byGroupsEmitter) Emit(groups []string, state *LexerState) Iterator {
 	iterators := make([]Iterator, 0, len(groups)-1)
 	if len(b.Emitters) != len(groups)-1 {
@@ -34,6 +34,9 @@ func WithCustomCSS(css map[chroma.TokenType]string) Option {
 	}
 }

+// WithCSSComments adds prefixe comments to the css classes. Defaults to true.
+func WithCSSComments(b bool) Option { return func(f *Formatter) { f.writeCSSComments = b } }
+
 // TabWidth sets the number of characters for a tab. Defaults to 8.
 func TabWidth(width int) Option { return func(f *Formatter) { f.tabWidth = width } }

@@ -131,8 +134,9 @@ func BaseLineNumber(n int) Option {
 // New HTML formatter.
 func New(options ...Option) *Formatter {
 	f := &Formatter{
-		baseLineNumber: 1,
-		preWrapper:     defaultPreWrapper,
+		baseLineNumber:   1,
+		preWrapper:       defaultPreWrapper,
+		writeCSSComments: true,
 	}
 	f.styleCache = newStyleCache(f)
 	for _, option := range options {
@@ -197,6 +201,7 @@ type Formatter struct {
 	Classes               bool // Exported field to detect when classes are being used
 	allClasses            bool
 	customCSS             map[chroma.TokenType]string
+	writeCSSComments      bool
 	preWrapper            PreWrapper
 	inlineCode            bool
 	preventSurroundingPre bool
@@ -416,21 +421,37 @@ func (f *Formatter) tabWidthStyle() string {
 	return ""
 }

+func (f *Formatter) writeCSSRule(w io.Writer, comment string, selector string, styles string) error {
+	if styles == "" {
+		return nil
+	}
+	if f.writeCSSComments && comment != "" {
+		if _, err := fmt.Fprintf(w, "/* %s */ ", comment); err != nil {
+			return err
+		}
+	}
+	if _, err := fmt.Fprintf(w, "%s { %s }\n", selector, styles); err != nil {
+		return err
+	}
+	return nil
+}
+
 // WriteCSS writes CSS style definitions (without any surrounding HTML).
 func (f *Formatter) WriteCSS(w io.Writer, style *chroma.Style) error {
 	css := f.styleCache.get(style, false)
+
 	// Special-case background as it is mapped to the outer ".chroma" class.
-	if _, err := fmt.Fprintf(w, "/* %s */ .%sbg { %s }\n", chroma.Background, f.prefix, css[chroma.Background]); err != nil {
+	if err := f.writeCSSRule(w, chroma.Background.String(), fmt.Sprintf(".%sbg", f.prefix), css[chroma.Background]); err != nil {
 		return err
 	}
 	// Special-case PreWrapper as it is the ".chroma" class.
-	if _, err := fmt.Fprintf(w, "/* %s */ .%schroma { %s }\n", chroma.PreWrapper, f.prefix, css[chroma.PreWrapper]); err != nil {
+	if err := f.writeCSSRule(w, chroma.PreWrapper.String(), fmt.Sprintf(".%schroma", f.prefix), css[chroma.PreWrapper]); err != nil {
 		return err
 	}
 	// Special-case code column of table to expand width.
 	if f.lineNumbers && f.lineNumbersInTable {
-		if _, err := fmt.Fprintf(w, "/* %s */ .%schroma .%s:last-child { width: 100%%; }",
-			chroma.LineTableTD, f.prefix, f.class(chroma.LineTableTD)); err != nil {
+		selector := fmt.Sprintf(".%schroma .%s:last-child", f.prefix, f.class(chroma.LineTableTD))
+		if err := f.writeCSSRule(w, chroma.LineTableTD.String(), selector, "width: 100%;"); err != nil {
 			return err
 		}
 	}
@@ -438,7 +459,11 @@ func (f *Formatter) WriteCSS(w io.Writer, style *chroma.Style) error {
 	if f.lineNumbers || f.lineNumbersInTable {
 		targetedLineCSS := StyleEntryToCSS(style.Get(chroma.LineHighlight))
 		for _, tt := range []chroma.TokenType{chroma.LineNumbers, chroma.LineNumbersTable} {
-			fmt.Fprintf(w, "/* %s targeted by URL anchor */ .%schroma .%s:target { %s }\n", tt, f.prefix, f.class(tt), targetedLineCSS)
+			comment := fmt.Sprintf("%s targeted by URL anchor", tt)
+			selector := fmt.Sprintf(".%schroma .%s:target", f.prefix, f.class(tt))
+			if err := f.writeCSSRule(w, comment, selector, targetedLineCSS); err != nil {
+				return err
+			}
 		}
 	}
 	tts := []int{}
@@ -456,8 +481,7 @@ func (f *Formatter) WriteCSS(w io.Writer, style *chroma.Style) error {
 		if class == "" {
 			continue
 		}
-		styles := css[tt]
-		if _, err := fmt.Fprintf(w, "/* %s */ .%schroma .%s { %s }\n", tt, f.prefix, class, styles); err != nil {
+		if err := f.writeCSSRule(w, tt.String(), fmt.Sprintf(".%schroma .%s", f.prefix, class), css[tt]); err != nil {
 			return err
 		}
 	}
@@ -18,6 +18,17 @@ func (i Iterator) Tokens() []Token {
 	return out
 }

+// Stdlib converts a Chroma iterator to a Go 1.23-compatible iterator.
+func (i Iterator) Stdlib() func(yield func(Token) bool) {
+	return func(yield func(Token) bool) {
+		for t := i(); t != EOF; t = i() {
+			if !yield(t) {
+				return
+			}
+		}
+	}
+}
+
 // Concaterator concatenates tokens from a series of iterators.
 func Concaterator(iterators ...Iterator) Iterator {
 	return func() Token {
@@ -130,6 +130,23 @@ type Lexer interface {
 	AnalyseText(text string) float32
 }

+// Trace is the trace of a tokenisation process.
+type Trace struct {
+	Lexer   string  `json:"lexer"`
+	State   string  `json:"state"`
+	Rule    int     `json:"rule"`
+	Pattern string  `json:"pattern"`
+	Pos     int     `json:"pos"`
+	Length  int     `json:"length"`
+	Elapsed float64 `json:"elapsedMs"` // Elapsed time spent matching for this rule.
+}
+
+// TracingLexer is a Lexer that can trace its tokenisation process.
+type TracingLexer interface {
+	Lexer
+	SetTracing(enable bool)
+}
+
 // Lexers is a slice of lexers sortable by name.
 type Lexers []Lexer

@@ -6,103 +6,104 @@
  <rules>
    <state name="attr">
      <rule pattern="&#34;.*?&#34;">
-        <token type="LiteralString"/>
-        <pop depth="1"/>
+        <token type="LiteralString" />
+        <pop depth="1" />
      </rule>
      <rule pattern="&#39;.*?&#39;">
-        <token type="LiteralString"/>
-        <pop depth="1"/>
+        <token type="LiteralString" />
+        <pop depth="1" />
      </rule>
      <rule pattern="[^\s&gt;]+">
-        <token type="LiteralString"/>
-        <pop depth="1"/>
+        <token type="LiteralString" />
+        <pop depth="1" />
      </rule>
    </state>
    <state name="root">
      <rule pattern="[^{([*#]+">
-        <token type="Other"/>
+        <token type="Other" />
      </rule>
      <rule pattern="(\{\{)(\s*)">
        <bygroups>
-          <token type="CommentPreproc"/>
-          <token type="Text"/>
+          <token type="CommentPreproc" />
+          <token type="Text" />
        </bygroups>
-        <push state="ngExpression"/>
+        <push state="ngExpression" />
      </rule>
      <rule pattern="([([]+)([\w:.-]+)([\])]+)(\s*)(=)(\s*)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="NameAttribute"/>
-          <token type="Punctuation"/>
-          <token type="Text"/>
-          <token type="Operator"/>
-          <token type="Text"/>
+          <token type="Punctuation" />
+          <token type="NameAttribute" />
+          <token type="Punctuation" />
+          <token type="Text" />
+          <token type="Operator" />
+          <token type="Text" />
        </bygroups>
-        <push state="attr"/>
+        <push state="attr" />
      </rule>
      <rule pattern="([([]+)([\w:.-]+)([\])]+)(\s*)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="NameAttribute"/>
-          <token type="Punctuation"/>
-          <token type="Text"/>
+          <token type="Punctuation" />
+          <token type="NameAttribute" />
+          <token type="Punctuation" />
+          <token type="TextWhitespace" />
        </bygroups>
      </rule>
      <rule pattern="([*#])([\w:.-]+)(\s*)(=)(\s*)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="NameAttribute"/>
-          <token type="Punctuation"/>
-          <token type="Operator"/>
+          <token type="Punctuation" />
+          <token type="NameAttribute" />
+          <token type="Punctuation" />
+          <token type="Operator" />
+          <token type="TextWhitespace" />
        </bygroups>
-        <push state="attr"/>
+        <push state="attr" />
      </rule>
      <rule pattern="([*#])([\w:.-]+)(\s*)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="NameAttribute"/>
-          <token type="Punctuation"/>
+          <token type="Punctuation" />
+          <token type="NameAttribute" />
+          <token type="Punctuation" />
        </bygroups>
      </rule>
    </state>
    <state name="ngExpression">
      <rule pattern="\s+(\|\s+)?">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="\}\}">
-        <token type="CommentPreproc"/>
-        <pop depth="1"/>
+        <token type="CommentPreproc" />
+        <pop depth="1" />
      </rule>
      <rule pattern=":?(true|false)">
-        <token type="LiteralStringBoolean"/>
+        <token type="LiteralStringBoolean" />
      </rule>
      <rule pattern=":?&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
-        <token type="LiteralStringDouble"/>
+        <token type="LiteralStringDouble" />
      </rule>
      <rule pattern=":?&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
-        <token type="LiteralStringSingle"/>
+        <token type="LiteralStringSingle" />
      </rule>
      <rule pattern="[0-9](\.[0-9]*)?(eE[+-][0-9])?[flFLdD]?|0[xX][0-9a-fA-F]+[Ll]?">
-        <token type="LiteralNumber"/>
+        <token type="LiteralNumber" />
      </rule>
      <rule pattern="[a-zA-Z][\w-]*(\(.*\))?">
-        <token type="NameVariable"/>
+        <token type="NameVariable" />
      </rule>
      <rule pattern="\.[\w-]+(\(.*\))?">
-        <token type="NameVariable"/>
+        <token type="NameVariable" />
      </rule>
      <rule pattern="(\?)(\s*)([^}\s]+)(\s*)(:)(\s*)([^}\s]+)(\s*)">
        <bygroups>
-          <token type="Operator"/>
-          <token type="Text"/>
-          <token type="LiteralString"/>
-          <token type="Text"/>
-          <token type="Operator"/>
-          <token type="Text"/>
-          <token type="LiteralString"/>
-          <token type="Text"/>
+          <token type="Operator" />
+          <token type="Text" />
+          <token type="LiteralString" />
+          <token type="Text" />
+          <token type="Operator" />
+          <token type="Text" />
+          <token type="LiteralString" />
+          <token type="Text" />
        </bygroups>
      </rule>
    </state>
  </rules>
-</lexer>
+</lexer>
@@ -8,123 +8,144 @@
  <rules>
    <state name="root">
      <rule pattern="\s+">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="¬\n">
-        <token type="LiteralStringEscape"/>
+        <token type="LiteralStringEscape" />
      </rule>
      <rule pattern="&#39;s\s+">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="(--|#).*?$">
-        <token type="Comment"/>
+        <token type="Comment" />
      </rule>
      <rule pattern="\(\*">
-        <token type="CommentMultiline"/>
-        <push state="comment"/>
+        <token type="CommentMultiline" />
+        <push state="comment" />
      </rule>
      <rule pattern="[(){}!,.:]">
-        <token type="Punctuation"/>
+        <token type="Punctuation" />
      </rule>
      <rule pattern="(«)([^»]+)(»)">
        <bygroups>
-          <token type="Text"/>
-          <token type="NameBuiltin"/>
-          <token type="Text"/>
+          <token type="Text" />
+          <token type="NameBuiltin" />
+          <token type="Text" />
        </bygroups>
      </rule>
-      <rule pattern="\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)">
+      <rule
+        pattern="\b((?:considering|ignoring)\s*)(application responses|case|diacriticals|hyphens|numeric strings|punctuation|white space)"
+      >
        <bygroups>
-          <token type="Keyword"/>
-          <token type="NameBuiltin"/>
+          <token type="Keyword" />
+          <token type="NameBuiltin" />
        </bygroups>
      </rule>
      <rule pattern="(-|\*|\+|&amp;|≠|&gt;=?|&lt;=?|=|≥|≤|/|÷|\^)">
-        <token type="Operator"/>
+        <token type="Operator" />
      </rule>
-      <rule pattern="\b(and|or|is equal|equals|(is )?equal to|is not|isn&#39;t|isn&#39;t equal( to)?|is not equal( to)?|doesn&#39;t equal|does not equal|(is )?greater than|comes after|is not less than or equal( to)?|isn&#39;t less than or equal( to)?|(is )?less than|comes before|is not greater than or equal( to)?|isn&#39;t greater than or equal( to)?|(is  )?greater than or equal( to)?|is not less than|isn&#39;t less than|does not come before|doesn&#39;t come before|(is )?less than or equal( to)?|is not greater than|isn&#39;t greater than|does not come after|doesn&#39;t come after|starts? with|begins? with|ends? with|contains?|does not contain|doesn&#39;t contain|is in|is contained by|is not in|is not contained by|isn&#39;t contained by|div|mod|not|(a  )?(ref( to)?|reference to)|is|does)\b">
-        <token type="OperatorWord"/>
+      <rule
+        pattern="\b(and|or|is equal|equals|(is )?equal to|is not|isn&#39;t|isn&#39;t equal( to)?|is not equal( to)?|doesn&#39;t equal|does not equal|(is )?greater than|comes after|is not less than or equal( to)?|isn&#39;t less than or equal( to)?|(is )?less than|comes before|is not greater than or equal( to)?|isn&#39;t greater than or equal( to)?|(is  )?greater than or equal( to)?|is not less than|isn&#39;t less than|does not come before|doesn&#39;t come before|(is )?less than or equal( to)?|is not greater than|isn&#39;t greater than|does not come after|doesn&#39;t come after|starts? with|begins? with|ends? with|contains?|does not contain|doesn&#39;t contain|is in|is contained by|is not in|is not contained by|isn&#39;t contained by|div|mod|not|(a  )?(ref( to)?|reference to)|is|does)\b"
+      >
+        <token type="OperatorWord" />
      </rule>
-      <rule pattern="^(\s*(?:on|end)\s+)(zoomed|write to file|will zoom|will show|will select tab view item|will resize( sub views)?|will resign active|will quit|will pop up|will open|will move|will miniaturize|will hide|will finish launching|will display outline cell|will display item cell|will display cell|will display browser cell|will dismiss|will close|will become active|was miniaturized|was hidden|update toolbar item|update parameters|update menu item|shown|should zoom|should selection change|should select tab view item|should select row|should select item|should select column|should quit( after last window closed)?|should open( untitled)?|should expand item|should end editing|should collapse item|should close|should begin editing|selection changing|selection changed|selected tab view item|scroll wheel|rows changed|right mouse up|right mouse dragged|right mouse down|resized( sub views)?|resigned main|resigned key|resigned active|read from file|prepare table drop|prepare table drag|prepare outline drop|prepare outline drag|prepare drop|plugin loaded|parameters updated|panel ended|opened|open untitled|number of rows|number of items|number of browser rows|moved|mouse up|mouse moved|mouse exited|mouse entered|mouse dragged|mouse down|miniaturized|load data representation|launched|keyboard up|keyboard down|items changed|item value changed|item value|item expandable|idle|exposed|end editing|drop|drag( (entered|exited|updated))?|double clicked|document nib name|dialog ended|deminiaturized|data representation|conclude drop|column resized|column moved|column clicked|closed|clicked toolbar item|clicked|choose menu item|child of item|changed|change item value|change cell value|cell value changed|cell value|bounds changed|begin editing|became main|became key|awake from nib|alert ended|activated|action|accept table drop|accept outline drop)">
-        <bygroups>
-          <token type="Keyword"/>
-          <token type="NameFunction"/>
-        </bygroups>
+      <rule
+        pattern="^(\s*(?:on|end)\s+)(zoomed|write to file|will zoom|will show|will select tab view item|will resize( sub views)?|will resign active|will quit|will pop up|will open|will move|will miniaturize|will hide|will finish launching|will display outline cell|will display item cell|will display cell|will display browser cell|will dismiss|will close|will become active|was miniaturized|was hidden|update toolbar item|update parameters|update menu item|shown|should zoom|should selection change|should select tab view item|should select row|should select item|should select column|should quit( after last window closed)?|should open( untitled)?|should expand item|should end editing|should collapse item|should close|should begin editing|selection changing|selection changed|selected tab view item|scroll wheel|rows changed|right mouse up|right mouse dragged|right mouse down|resized( sub views)?|resigned main|resigned key|resigned active|read from file|prepare table drop|prepare table drag|prepare outline drop|prepare outline drag|prepare drop|plugin loaded|parameters updated|panel ended|opened|open untitled|number of rows|number of items|number of browser rows|moved|mouse up|mouse moved|mouse exited|mouse entered|mouse dragged|mouse down|miniaturized|load data representation|launched|keyboard up|keyboard down|items changed|item value changed|item value|item expandable|idle|exposed|end editing|drop|drag( (entered|exited|updated))?|double clicked|document nib name|dialog ended|deminiaturized|data representation|conclude drop|column resized|column moved|column clicked|closed|clicked toolbar item|clicked|choose menu item|child of item|changed|change item value|change cell value|cell value changed|cell value|bounds changed|begin editing|became main|became key|awake from nib|alert ended|activated|action|accept table drop|accept outline drop)"
+      >
+        <token type="Keyword" />
      </rule>
      <rule pattern="^(\s*)(in|on|script|to)(\s+)">
        <bygroups>
-          <token type="Text"/>
-          <token type="Keyword"/>
-          <token type="Text"/>
+          <token type="Text" />
+          <token type="Keyword" />
+          <token type="Text" />
        </bygroups>
      </rule>
-      <rule pattern="\b(as )(alias |application |boolean |class |constant |date |file |integer |list |number |POSIX file |real |record |reference |RGB color |script |text |unit types|(?:Unicode )?text|string)\b">
+      <rule
+        pattern="\b(as )(alias |application |boolean |class |constant |date |file |integer |list |number |POSIX file |real |record |reference |RGB color |script |text |unit types|(?:Unicode )?text|string)\b"
+      >
        <bygroups>
-          <token type="Keyword"/>
-          <token type="NameClass"/>
+          <token type="Keyword" />
+          <token type="NameClass" />
        </bygroups>
      </rule>
-      <rule pattern="\b(AppleScript|current application|false|linefeed|missing value|pi|quote|result|return|space|tab|text item delimiters|true|version)\b">
-        <token type="NameConstant"/>
+      <rule
+        pattern="\b(AppleScript|current application|false|linefeed|missing value|pi|quote|result|return|space|tab|text item delimiters|true|version)\b"
+      >
+        <token type="NameConstant" />
      </rule>
-      <rule pattern="\b(ASCII (character|number)|activate|beep|choose URL|choose application|choose color|choose file( name)?|choose folder|choose from list|choose remote application|clipboard info|close( access)?|copy|count|current date|delay|delete|display (alert|dialog)|do shell script|duplicate|exists|get eof|get volume settings|info for|launch|list (disks|folder)|load script|log|make|mount volume|new|offset|open( (for access|location))?|path to|print|quit|random number|read|round|run( script)?|say|scripting components|set (eof|the clipboard to|volume)|store script|summarize|system attribute|system info|the clipboard|time to GMT|write|quoted form)\b">
-        <token type="NameBuiltin"/>
+      <rule
+        pattern="\b(ASCII (character|number)|activate|beep|choose URL|choose application|choose color|choose file( name)?|choose folder|choose from list|choose remote application|clipboard info|close( access)?|copy|count|current date|delay|delete|display (alert|dialog)|do shell script|duplicate|exists|get eof|get volume settings|info for|launch|list (disks|folder)|load script|log|make|mount volume|new|offset|open( (for access|location))?|path to|print|quit|random number|read|round|run( script)?|say|scripting components|set (eof|the clipboard to|volume)|store script|summarize|system attribute|system info|the clipboard|time to GMT|write|quoted form)\b"
+      >
+        <token type="NameBuiltin" />
      </rule>
-      <rule pattern="\b(considering|else|error|exit|from|if|ignoring|in|repeat|tell|then|times|to|try|until|using terms from|while|with|with timeout( of)?|with transaction|by|continue|end|its?|me|my|return|of|as)\b">
-        <token type="Keyword"/>
+      <rule
+        pattern="\b(considering|else|error|exit|from|if|ignoring|in|repeat|tell|then|times|to|try|until|using terms from|while|with|with timeout( of)?|with transaction|by|continue|end|its?|me|my|return|of|as)\b"
+      >
+        <token type="Keyword" />
      </rule>
      <rule pattern="\b(global|local|prop(erty)?|set|get)\b">
-        <token type="Keyword"/>
+        <token type="Keyword" />
      </rule>
      <rule pattern="\b(but|put|returning|the)\b">
-        <token type="NameBuiltin"/>
+        <token type="NameBuiltin" />
      </rule>
      <rule pattern="\b(attachment|attribute run|character|day|month|paragraph|word|year)s?\b">
-        <token type="NameBuiltin"/>
+        <token type="NameBuiltin" />
      </rule>
-      <rule pattern="\b(about|above|against|apart from|around|aside from|at|below|beneath|beside|between|for|given|instead of|on|onto|out of|over|since)\b">
-        <token type="NameBuiltin"/>
+      <rule
+        pattern="\b(about|above|against|apart from|around|aside from|at|below|beneath|beside|between|for|given|instead of|on|onto|out of|over|since)\b"
+      >
+        <token type="NameBuiltin" />
      </rule>
-      <rule pattern="\b(accepts arrow key|action method|active|alignment|allowed identifiers|allows branch selection|allows column reordering|allows column resizing|allows column selection|allows customization|allows editing text attributes|allows empty selection|allows mixed state|allows multiple selection|allows reordering|allows undo|alpha( value)?|alternate image|alternate increment value|alternate title|animation delay|associated file name|associated object|auto completes|auto display|auto enables items|auto repeat|auto resizes( outline column)?|auto save expanded items|auto save name|auto save table columns|auto saves configuration|auto scroll|auto sizes all columns to fit|auto sizes cells|background color|bezel state|bezel style|bezeled|border rect|border type|bordered|bounds( rotation)?|box type|button returned|button type|can choose directories|can choose files|can draw|can hide|cell( (background color|size|type))?|characters|class|click count|clicked( data)? column|clicked data item|clicked( data)? row|closeable|collating|color( (mode|panel))|command key down|configuration|content(s| (size|view( margins)?))?|context|continuous|control key down|control size|control tint|control view|controller visible|coordinate system|copies( on scroll)?|corner view|current cell|current column|current( field)?  editor|current( menu)? item|current row|current tab view item|data source|default identifiers|delta (x|y|z)|destination window|directory|display mode|displayed cell|document( (edited|rect|view))?|double value|dragged column|dragged distance|dragged items|draws( cell)? background|draws grid|dynamically scrolls|echos bullets|edge|editable|edited( data)? column|edited data item|edited( data)? row|enabled|enclosing scroll view|ending page|error handling|event number|event type|excluded from windows menu|executable path|expanded|fax number|field editor|file kind|file name|file type|first responder|first visible column|flipped|floating|font( panel)?|formatter|frameworks path|frontmost|gave up|grid color|has data items|has horizontal ruler|has horizontal scroller|has parent data item|has resize indicator|has shadow|has sub menu|has vertical ruler|has vertical scroller|header cell|header view|hidden|hides when deactivated|highlights by|horizontal line scroll|horizontal page scroll|horizontal ruler view|horizontally resizable|icon image|id|identifier|ignores multiple clicks|image( (alignment|dims when disabled|frame style|scaling))?|imports graphics|increment value|indentation per level|indeterminate|index|integer value|intercell spacing|item height|key( (code|equivalent( modifier)?|window))?|knob thickness|label|last( visible)? column|leading offset|leaf|level|line scroll|loaded|localized sort|location|loop mode|main( (bunde|menu|window))?|marker follows cell|matrix mode|maximum( content)? size|maximum visible columns|menu( form representation)?|miniaturizable|miniaturized|minimized image|minimized title|minimum column width|minimum( content)? size|modal|modified|mouse down state|movie( (controller|file|rect))?|muted|name|needs display|next state|next text|number of tick marks|only tick mark values|opaque|open panel|option key down|outline table column|page scroll|pages across|pages down|palette label|pane splitter|parent data item|parent window|pasteboard|path( (names|separator))?|playing|plays every frame|plays selection only|position|preferred edge|preferred type|pressure|previous text|prompt|properties|prototype cell|pulls down|rate|released when closed|repeated|requested print time|required file type|resizable|resized column|resource path|returns records|reuses columns|rich text|roll over|row height|rulers visible|save panel|scripts path|scrollable|selectable( identifiers)?|selected cell|selected( data)? columns?|selected data items?|selected( data)? rows?|selected item identifier|selection by rect|send action on arrow key|sends action when done editing|separates columns|separator item|sequence number|services menu|shared frameworks path|shared support path|sheet|shift key down|shows alpha|shows state by|size( mode)?|smart insert delete enabled|sort case sensitivity|sort column|sort order|sort type|sorted( data rows)?|sound|source( mask)?|spell checking enabled|starting page|state|string value|sub menu|super menu|super view|tab key traverses cells|tab state|tab type|tab view|table view|tag|target( printer)?|text color|text container insert|text container origin|text returned|tick mark position|time stamp|title(d| (cell|font|height|position|rect))?|tool tip|toolbar|trailing offset|transparent|treat packages as directories|truncated labels|types|unmodified characters|update views|use sort indicator|user defaults|uses data source|uses ruler|uses threaded animation|uses title from previous column|value wraps|version|vertical( (line scroll|page scroll|ruler view))?|vertically resizable|view|visible( document rect)?|volume|width|window|windows menu|wraps|zoomable|zoomed)\b">
-        <token type="NameAttribute"/>
+      <rule
+        pattern="\b(accepts arrow key|action method|active|alignment|allowed identifiers|allows branch selection|allows column reordering|allows column resizing|allows column selection|allows customization|allows editing text attributes|allows empty selection|allows mixed state|allows multiple selection|allows reordering|allows undo|alpha( value)?|alternate image|alternate increment value|alternate title|animation delay|associated file name|associated object|auto completes|auto display|auto enables items|auto repeat|auto resizes( outline column)?|auto save expanded items|auto save name|auto save table columns|auto saves configuration|auto scroll|auto sizes all columns to fit|auto sizes cells|background color|bezel state|bezel style|bezeled|border rect|border type|bordered|bounds( rotation)?|box type|button returned|button type|can choose directories|can choose files|can draw|can hide|cell( (background color|size|type))?|characters|class|click count|clicked( data)? column|clicked data item|clicked( data)? row|closeable|collating|color( (mode|panel))|command key down|configuration|content(s| (size|view( margins)?))?|context|continuous|control key down|control size|control tint|control view|controller visible|coordinate system|copies( on scroll)?|corner view|current cell|current column|current( field)?  editor|current( menu)? item|current row|current tab view item|data source|default identifiers|delta (x|y|z)|destination window|directory|display mode|displayed cell|document( (edited|rect|view))?|double value|dragged column|dragged distance|dragged items|draws( cell)? background|draws grid|dynamically scrolls|echos bullets|edge|editable|edited( data)? column|edited data item|edited( data)? row|enabled|enclosing scroll view|ending page|error handling|event number|event type|excluded from windows menu|executable path|expanded|fax number|field editor|file kind|file name|file type|first responder|first visible column|flipped|floating|font( panel)?|formatter|frameworks path|frontmost|gave up|grid color|has data items|has horizontal ruler|has horizontal scroller|has parent data item|has resize indicator|has shadow|has sub menu|has vertical ruler|has vertical scroller|header cell|header view|hidden|hides when deactivated|highlights by|horizontal line scroll|horizontal page scroll|horizontal ruler view|horizontally resizable|icon image|id|identifier|ignores multiple clicks|image( (alignment|dims when disabled|frame style|scaling))?|imports graphics|increment value|indentation per level|indeterminate|index|integer value|intercell spacing|item height|key( (code|equivalent( modifier)?|window))?|knob thickness|label|last( visible)? column|leading offset|leaf|level|line scroll|loaded|localized sort|location|loop mode|main( (bunde|menu|window))?|marker follows cell|matrix mode|maximum( content)? size|maximum visible columns|menu( form representation)?|miniaturizable|miniaturized|minimized image|minimized title|minimum column width|minimum( content)? size|modal|modified|mouse down state|movie( (controller|file|rect))?|muted|name|needs display|next state|next text|number of tick marks|only tick mark values|opaque|open panel|option key down|outline table column|page scroll|pages across|pages down|palette label|pane splitter|parent data item|parent window|pasteboard|path( (names|separator))?|playing|plays every frame|plays selection only|position|preferred edge|preferred type|pressure|previous text|prompt|properties|prototype cell|pulls down|rate|released when closed|repeated|requested print time|required file type|resizable|resized column|resource path|returns records|reuses columns|rich text|roll over|row height|rulers visible|save panel|scripts path|scrollable|selectable( identifiers)?|selected cell|selected( data)? columns?|selected data items?|selected( data)? rows?|selected item identifier|selection by rect|send action on arrow key|sends action when done editing|separates columns|separator item|sequence number|services menu|shared frameworks path|shared support path|sheet|shift key down|shows alpha|shows state by|size( mode)?|smart insert delete enabled|sort case sensitivity|sort column|sort order|sort type|sorted( data rows)?|sound|source( mask)?|spell checking enabled|starting page|state|string value|sub menu|super menu|super view|tab key traverses cells|tab state|tab type|tab view|table view|tag|target( printer)?|text color|text container insert|text container origin|text returned|tick mark position|time stamp|title(d| (cell|font|height|position|rect))?|tool tip|toolbar|trailing offset|transparent|treat packages as directories|truncated labels|types|unmodified characters|update views|use sort indicator|user defaults|uses data source|uses ruler|uses threaded animation|uses title from previous column|value wraps|version|vertical( (line scroll|page scroll|ruler view))?|vertically resizable|view|visible( document rect)?|volume|width|window|windows menu|wraps|zoomable|zoomed)\b"
+      >
+        <token type="NameAttribute" />
      </rule>
-      <rule pattern="\b(action cell|alert reply|application|box|browser( cell)?|bundle|button( cell)?|cell|clip view|color well|color-panel|combo box( item)?|control|data( (cell|column|item|row|source))?|default entry|dialog reply|document|drag info|drawer|event|font(-panel)?|formatter|image( (cell|view))?|matrix|menu( item)?|item|movie( view)?|open-panel|outline view|panel|pasteboard|plugin|popup button|progress indicator|responder|save-panel|scroll view|secure text field( cell)?|slider|sound|split view|stepper|tab view( item)?|table( (column|header cell|header view|view))|text( (field( cell)?|view))?|toolbar( item)?|user-defaults|view|window)s?\b">
-        <token type="NameBuiltin"/>
+      <rule
+        pattern="\b(action cell|alert reply|application|box|browser( cell)?|bundle|button( cell)?|cell|clip view|color well|color-panel|combo box( item)?|control|data( (cell|column|item|row|source))?|default entry|dialog reply|document|drag info|drawer|event|font(-panel)?|formatter|image( (cell|view))?|matrix|menu( item)?|item|movie( view)?|open-panel|outline view|panel|pasteboard|plugin|popup button|progress indicator|responder|save-panel|scroll view|secure text field( cell)?|slider|sound|split view|stepper|tab view( item)?|table( (column|header cell|header view|view))|text( (field( cell)?|view))?|toolbar( item)?|user-defaults|view|window)s?\b"
+      >
+        <token type="NameBuiltin" />
      </rule>
-      <rule pattern="\b(animate|append|call method|center|close drawer|close panel|display|display alert|display dialog|display panel|go|hide|highlight|increment|item for|load image|load movie|load nib|load panel|load sound|localized string|lock focus|log|open drawer|path for|pause|perform action|play|register|resume|scroll|select( all)?|show|size to fit|start|step back|step forward|stop|synchronize|unlock focus|update)\b">
-        <token type="NameBuiltin"/>
+      <rule
+        pattern="\b(animate|append|call method|center|close drawer|close panel|display|display alert|display dialog|display panel|go|hide|highlight|increment|item for|load image|load movie|load nib|load panel|load sound|localized string|lock focus|log|open drawer|path for|pause|perform action|play|register|resume|scroll|select( all)?|show|size to fit|start|step back|step forward|stop|synchronize|unlock focus|update)\b"
+      >
+        <token type="NameBuiltin" />
      </rule>
-      <rule pattern="\b((in )?back of|(in )?front of|[0-9]+(st|nd|rd|th)|first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|after|back|before|behind|every|front|index|last|middle|some|that|through|thru|where|whose)\b">
-        <token type="NameBuiltin"/>
+      <rule
+        pattern="\b((in )?back of|(in )?front of|[0-9]+(st|nd|rd|th)|first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth|after|back|before|behind|every|front|index|last|middle|some|that|through|thru|where|whose)\b"
+      >
+        <token type="NameBuiltin" />
      </rule>
      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
-        <token type="LiteralStringDouble"/>
+        <token type="LiteralStringDouble" />
      </rule>
      <rule pattern="\b([a-zA-Z]\w*)\b">
-        <token type="NameVariable"/>
+        <token type="NameVariable" />
      </rule>
      <rule pattern="[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?">
-        <token type="LiteralNumberFloat"/>
+        <token type="LiteralNumberFloat" />
      </rule>
      <rule pattern="[-+]?\d+">
-        <token type="LiteralNumberInteger"/>
+        <token type="LiteralNumberInteger" />
      </rule>
    </state>
    <state name="comment">
      <rule pattern="\(\*">
-        <token type="CommentMultiline"/>
-        <push/>
+        <token type="CommentMultiline" />
+        <push />
      </rule>
      <rule pattern="\*\)">
-        <token type="CommentMultiline"/>
-        <pop depth="1"/>
+        <token type="CommentMultiline" />
+        <pop depth="1" />
      </rule>
      <rule pattern="[^*(]+">
-        <token type="CommentMultiline"/>
+        <token type="CommentMultiline" />
      </rule>
      <rule pattern="[*(]">
-        <token type="CommentMultiline"/>
+        <token type="CommentMultiline" />
      </rule>
    </state>
  </rules>
-</lexer>
+</lexer>
@@ -9,301 +9,314 @@
  <rules>
    <state name="whitespace">
      <rule pattern="^#if\s+0">
-        <token type="CommentPreproc"/>
-        <push state="if0"/>
+        <token type="CommentPreproc" />
+        <push state="if0" />
      </rule>
      <rule pattern="^#">
-        <token type="CommentPreproc"/>
-        <push state="macro"/>
+        <token type="CommentPreproc" />
+        <push state="macro" />
      </rule>
      <rule pattern="^(\s*(?:/[*].*?[*]/\s*)?)(#if\s+0)">
        <bygroups>
-          <usingself state="root"/>
-          <token type="CommentPreproc"/>
+          <usingself state="root" />
+          <token type="CommentPreproc" />
        </bygroups>
-        <push state="if0"/>
+        <push state="if0" />
      </rule>
      <rule pattern="^(\s*(?:/[*].*?[*]/\s*)?)(#)">
        <bygroups>
-          <usingself state="root"/>
-          <token type="CommentPreproc"/>
+          <usingself state="root" />
+          <token type="CommentPreproc" />
        </bygroups>
-        <push state="macro"/>
+        <push state="macro" />
      </rule>
      <rule pattern="\n">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="\s+">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="\\\n">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="//(\n|[\w\W]*?[^\\]\n)">
-        <token type="CommentSingle"/>
+        <token type="CommentSingle" />
      </rule>
      <rule pattern="/(\\\n)?[*][\w\W]*?[*](\\\n)?/">
-        <token type="CommentMultiline"/>
+        <token type="CommentMultiline" />
      </rule>
      <rule pattern="/(\\\n)?[*][\w\W]*">
-        <token type="CommentMultiline"/>
+        <token type="CommentMultiline" />
      </rule>
    </state>
    <state name="string">
      <rule pattern="&#34;">
-        <token type="LiteralString"/>
-        <pop depth="1"/>
+        <token type="LiteralString" />
+        <pop depth="1" />
      </rule>
      <rule pattern="\\([\\abfnrtv&#34;\&#39;]|x[a-fA-F0-9]{2,4}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8}|[0-7]{1,3})">
-        <token type="LiteralStringEscape"/>
+        <token type="LiteralStringEscape" />
      </rule>
      <rule pattern="[^\\&#34;\n]+">
-        <token type="LiteralString"/>
+        <token type="LiteralString" />
      </rule>
      <rule pattern="\\\n">
-        <token type="LiteralString"/>
+        <token type="LiteralString" />
      </rule>
      <rule pattern="\\">
-        <token type="LiteralString"/>
+        <token type="LiteralString" />
      </rule>
    </state>
    <state name="macro">
      <rule pattern="(include)(\s*(?:/[*].*?[*]/\s*)?)([^\n]+)">
        <bygroups>
-          <token type="CommentPreproc"/>
-          <token type="Text"/>
-          <token type="CommentPreprocFile"/>
+          <token type="CommentPreproc" />
+          <token type="Text" />
+          <token type="CommentPreprocFile" />
        </bygroups>
      </rule>
      <rule pattern="[^/\n]+">
-        <token type="CommentPreproc"/>
+        <token type="CommentPreproc" />
      </rule>
      <rule pattern="/[*](.|\n)*?[*]/">
-        <token type="CommentMultiline"/>
+        <token type="CommentMultiline" />
      </rule>
      <rule pattern="//.*?\n">
-        <token type="CommentSingle"/>
-        <pop depth="1"/>
+        <token type="CommentSingle" />
+        <pop depth="1" />
      </rule>
      <rule pattern="/">
-        <token type="CommentPreproc"/>
+        <token type="CommentPreproc" />
      </rule>
      <rule pattern="(?&lt;=\\)\n">
-        <token type="CommentPreproc"/>
+        <token type="CommentPreproc" />
      </rule>
      <rule pattern="\n">
-        <token type="CommentPreproc"/>
-        <pop depth="1"/>
+        <token type="CommentPreproc" />
+        <pop depth="1" />
      </rule>
    </state>
    <state name="statements">
-      <rule pattern="(reinterpret_cast|static_assert|dynamic_cast|thread_local|static_cast|const_cast|protected|constexpr|namespace|restrict|noexcept|override|operator|typename|template|explicit|decltype|nullptr|private|alignof|virtual|mutable|alignas|typeid|friend|throws|export|public|delete|final|using|throw|catch|this|try|new)\b">
-        <token type="Keyword"/>
+      <rule
+        pattern="(reinterpret_cast|static_assert|dynamic_cast|thread_local|static_cast|const_cast|protected|constexpr|namespace|restrict|noexcept|override|operator|typename|template|explicit|decltype|nullptr|private|alignof|virtual|mutable|alignas|typeid|friend|throws|export|public|delete|final|using|throw|catch|this|try|new)\b"
+      >
+        <token type="Keyword" />
      </rule>
      <rule pattern="char(16_t|32_t)\b">
-        <token type="KeywordType"/>
+        <token type="KeywordType" />
      </rule>
      <rule pattern="(class)\b">
        <bygroups>
-          <token type="Keyword"/>
-          <token type="Text"/>
+          <token type="Keyword" />
        </bygroups>
-        <push state="classname"/>
+        <push state="classname" />
      </rule>
      <rule pattern="(R)(&#34;)([^\\()\s]{,16})(\()((?:.|\n)*?)(\)\3)(&#34;)">
        <bygroups>
-          <token type="LiteralStringAffix"/>
-          <token type="LiteralString"/>
-          <token type="LiteralStringDelimiter"/>
-          <token type="LiteralStringDelimiter"/>
-          <token type="LiteralString"/>
-          <token type="LiteralStringDelimiter"/>
-          <token type="LiteralString"/>
+          <token type="LiteralStringAffix" />
+          <token type="LiteralString" />
+          <token type="LiteralStringDelimiter" />
+          <token type="LiteralStringDelimiter" />
+          <token type="LiteralString" />
+          <token type="LiteralStringDelimiter" />
+          <token type="LiteralString" />
        </bygroups>
      </rule>
      <rule pattern="(u8|u|U)(&#34;)">
        <bygroups>
-          <token type="LiteralStringAffix"/>
-          <token type="LiteralString"/>
+          <token type="LiteralStringAffix" />
+          <token type="LiteralString" />
        </bygroups>
-        <push state="string"/>
+        <push state="string" />
      </rule>
      <rule pattern="(L?)(&#34;)">
        <bygroups>
-          <token type="LiteralStringAffix"/>
-          <token type="LiteralString"/>
+          <token type="LiteralStringAffix" />
+          <token type="LiteralString" />
        </bygroups>
-        <push state="string"/>
+        <push state="string" />
      </rule>
      <rule pattern="(L?)(&#39;)(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|[^\\\&#39;\n])(&#39;)">
        <bygroups>
-          <token type="LiteralStringAffix"/>
-          <token type="LiteralStringChar"/>
-          <token type="LiteralStringChar"/>
-          <token type="LiteralStringChar"/>
+          <token type="LiteralStringAffix" />
+          <token type="LiteralStringChar" />
+          <token type="LiteralStringChar" />
+          <token type="LiteralStringChar" />
        </bygroups>
      </rule>
      <rule pattern="(\d+\.\d*|\.\d+|\d+)[eE][+-]?\d+[LlUu]*">
-        <token type="LiteralNumberFloat"/>
+        <token type="LiteralNumberFloat" />
      </rule>
      <rule pattern="(\d+\.\d*|\.\d+|\d+[fF])[fF]?">
-        <token type="LiteralNumberFloat"/>
+        <token type="LiteralNumberFloat" />
      </rule>
      <rule pattern="0x[0-9a-fA-F]+[LlUu]*">
-        <token type="LiteralNumberHex"/>
+        <token type="LiteralNumberHex" />
      </rule>
      <rule pattern="0[0-7]+[LlUu]*">
-        <token type="LiteralNumberOct"/>
+        <token type="LiteralNumberOct" />
      </rule>
      <rule pattern="\d+[LlUu]*">
-        <token type="LiteralNumberInteger"/>
+        <token type="LiteralNumberInteger" />
      </rule>
      <rule pattern="\*/">
-        <token type="Error"/>
+        <token type="Error" />
      </rule>
      <rule pattern="[~!%^&amp;*+=|?:&lt;&gt;/-]">
-        <token type="Operator"/>
+        <token type="Operator" />
      </rule>
      <rule pattern="[()\[\],.]">
-        <token type="Punctuation"/>
+        <token type="Punctuation" />
      </rule>
-      <rule pattern="(restricted|volatile|continue|register|default|typedef|struct|extern|switch|sizeof|static|return|union|while|const|break|goto|enum|else|case|auto|for|asm|if|do)\b">
-        <token type="Keyword"/>
+      <rule
+        pattern="(restricted|volatile|continue|register|default|typedef|struct|extern|switch|sizeof|static|return|union|while|const|break|goto|enum|else|case|auto|for|asm|if|do)\b"
+      >
+        <token type="Keyword" />
      </rule>
-      <rule pattern="(_Bool|_Complex|_Imaginary|array|atomic_bool|atomic_char|atomic_int|atomic_llong|atomic_long|atomic_schar|atomic_short|atomic_uchar|atomic_uint|atomic_ullong|atomic_ulong|atomic_ushort|auto|bool|boolean|BooleanVariables|Byte|byte|Char|char|char16_t|char32_t|class|complex|Const|const|const_cast|delete|double|dynamic_cast|enum|explicit|extern|Float|float|friend|inline|Int|int|int16_t|int32_t|int64_t|int8_t|Long|long|new|NULL|null|operator|private|PROGMEM|protected|public|register|reinterpret_cast|short|signed|sizeof|Static|static|static_cast|String|struct|typedef|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|virtual|Void|void|Volatile|volatile|word)\b">
-        <token type="KeywordType"/>
+      <rule
+        pattern="(_Bool|_Complex|_Imaginary|array|atomic_bool|atomic_char|atomic_int|atomic_llong|atomic_long|atomic_schar|atomic_short|atomic_uchar|atomic_uint|atomic_ullong|atomic_ulong|atomic_ushort|auto|bool|boolean|BooleanVariables|Byte|byte|Char|char|char16_t|char32_t|class|complex|Const|const|const_cast|delete|double|dynamic_cast|enum|explicit|extern|Float|float|friend|inline|Int|int|int16_t|int32_t|int64_t|int8_t|Long|long|new|NULL|null|operator|private|PROGMEM|protected|public|register|reinterpret_cast|short|signed|sizeof|Static|static|static_cast|String|struct|typedef|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|virtual|Void|void|Volatile|volatile|word)\b"
+      >
+        <token type="KeywordType" />
      </rule>
      <rule pattern="(and|final|If|Loop|loop|not|or|override|setup|Setup|throw|try|xor)\b">
-        <token type="Keyword"/>
+        <token type="Keyword" />
      </rule>
-      <rule pattern="(ANALOG_MESSAGE|BIN|CHANGE|DEC|DEFAULT|DIGITAL_MESSAGE|EXTERNAL|FALLING|FIRMATA_STRING|HALF_PI|HEX|HIGH|INPUT|INPUT_PULLUP|INTERNAL|INTERNAL1V1|INTERNAL1V1|INTERNAL2V56|INTERNAL2V56|LED_BUILTIN|LED_BUILTIN_RX|LED_BUILTIN_TX|LOW|LSBFIRST|MSBFIRST|OCT|OUTPUT|PI|REPORT_ANALOG|REPORT_DIGITAL|RISING|SET_PIN_MODE|SYSEX_START|SYSTEM_RESET|TWO_PI)\b">
-        <token type="KeywordConstant"/>
+      <rule
+        pattern="(ANALOG_MESSAGE|BIN|CHANGE|DEC|DEFAULT|DIGITAL_MESSAGE|EXTERNAL|FALLING|FIRMATA_STRING|HALF_PI|HEX|HIGH|INPUT|INPUT_PULLUP|INTERNAL|INTERNAL1V1|INTERNAL1V1|INTERNAL2V56|INTERNAL2V56|LED_BUILTIN|LED_BUILTIN_RX|LED_BUILTIN_TX|LOW|LSBFIRST|MSBFIRST|OCT|OUTPUT|PI|REPORT_ANALOG|REPORT_DIGITAL|RISING|SET_PIN_MODE|SYSEX_START|SYSTEM_RESET|TWO_PI)\b"
+      >
+        <token type="KeywordConstant" />
      </rule>
      <rule pattern="(boolean|const|byte|word|string|String|array)\b">
-        <token type="NameVariable"/>
+        <token type="NameVariable" />
      </rule>
-      <rule pattern="(Keyboard|KeyboardController|MouseController|SoftwareSerial|EthernetServer|EthernetClient|LiquidCrystal|RobotControl|GSMVoiceCall|EthernetUDP|EsploraTFT|HttpClient|RobotMotor|WiFiClient|GSMScanner|FileSystem|Scheduler|GSMServer|YunClient|YunServer|IPAddress|GSMClient|GSMModem|Keyboard|Ethernet|Console|GSMBand|Esplora|Stepper|Process|WiFiUDP|GSM_SMS|Mailbox|USBHost|Firmata|PImage|Client|Server|GSMPIN|FileIO|Bridge|Serial|EEPROM|Stream|Mouse|Audio|Servo|File|Task|GPRS|WiFi|Wire|TFT|GSM|SPI|SD)\b">
-        <token type="NameClass"/>
+      <rule
+        pattern="(Keyboard|KeyboardController|MouseController|SoftwareSerial|EthernetServer|EthernetClient|LiquidCrystal|RobotControl|GSMVoiceCall|EthernetUDP|EsploraTFT|HttpClient|RobotMotor|WiFiClient|GSMScanner|FileSystem|Scheduler|GSMServer|YunClient|YunServer|IPAddress|GSMClient|GSMModem|Keyboard|Ethernet|Console|GSMBand|Esplora|Stepper|Process|WiFiUDP|GSM_SMS|Mailbox|USBHost|Firmata|PImage|Client|Server|GSMPIN|FileIO|Bridge|Serial|EEPROM|Stream|Mouse|Audio|Servo|File|Task|GPRS|WiFi|Wire|TFT|GSM|SPI|SD)\b"
+      >
+        <token type="NameClass" />
      </rule>
-      <rule pattern="(abs|Abs|accept|ACos|acos|acosf|addParameter|analogRead|AnalogRead|analogReadResolution|AnalogReadResolution|analogReference|AnalogReference|analogWrite|AnalogWrite|analogWriteResolution|AnalogWriteResolution|answerCall|asin|ASin|asinf|atan|ATan|atan2|ATan2|atan2f|atanf|attach|attached|attachGPRS|attachInterrupt|AttachInterrupt|autoscroll|available|availableForWrite|background|beep|begin|beginPacket|beginSD|beginSMS|beginSpeaker|beginTFT|beginTransmission|beginWrite|bit|Bit|BitClear|bitClear|bitRead|BitRead|bitSet|BitSet|BitWrite|bitWrite|blink|blinkVersion|BSSID|buffer|byte|cbrt|cbrtf|Ceil|ceil|ceilf|changePIN|char|charAt|checkPIN|checkPUK|checkReg|circle|cityNameRead|cityNameWrite|clear|clearScreen|click|close|compareTo|compassRead|concat|config|connect|connected|constrain|Constrain|copysign|copysignf|cos|Cos|cosf|cosh|coshf|countryNameRead|countryNameWrite|createChar|cursor|debugPrint|degrees|Delay|delay|DelayMicroseconds|delayMicroseconds|detach|DetachInterrupt|detachInterrupt|DigitalPinToInterrupt|digitalPinToInterrupt|DigitalRead|digitalRead|DigitalWrite|digitalWrite|disconnect|display|displayLogos|drawBMP|drawCompass|encryptionType|end|endPacket|endSMS|endsWith|endTransmission|endWrite|equals|equalsIgnoreCase|exists|exitValue|Exp|exp|expf|fabs|fabsf|fdim|fdimf|fill|find|findUntil|float|floor|Floor|floorf|flush|fma|fmaf|fmax|fmaxf|fmin|fminf|fmod|fmodf|gatewayIP|get|getAsynchronously|getBand|getButton|getBytes|getCurrentCarrier|getIMEI|getKey|getModifiers|getOemKey|getPINUsed|getResult|getSignalStrength|getSocket|getVoiceCallStatus|getXChange|getYChange|hangCall|height|highByte|HighByte|home|hypot|hypotf|image|indexOf|int|interrupts|IPAddress|IRread|isActionDone|isAlpha|isAlphaNumeric|isAscii|isControl|isDigit|isDirectory|isfinite|isGraph|isHexadecimalDigit|isinf|isListening|isLowerCase|isnan|isPIN|isPressed|isPrintable|isPunct|isSpace|isUpperCase|isValid|isWhitespace|keyboardRead|keyPressed|keyReleased|knobRead|lastIndexOf|ldexp|ldexpf|leftToRight|length|line|lineFollowConfig|listen|listenOnLocalhost|loadImage|localIP|log|Log|log10|log10f|logf|long|lowByte|LowByte|lrint|lrintf|lround|lroundf|macAddress|maintain|map|Map|Max|max|messageAvailable|Micros|micros|millis|Millis|Min|min|mkdir|motorsStop|motorsWrite|mouseDragged|mouseMoved|mousePressed|mouseReleased|move|noAutoscroll|noBlink|noBuffer|noCursor|noDisplay|noFill|noInterrupts|NoInterrupts|noListenOnLocalhost|noStroke|noTone|NoTone|onReceive|onRequest|open|openNextFile|overflow|parseCommand|parseFloat|parseInt|parsePacket|pauseMode|peek|PinMode|pinMode|playFile|playMelody|point|pointTo|position|Pow|pow|powf|prepare|press|print|printFirmwareVersion|println|printVersion|process|processInput|PulseIn|pulseIn|pulseInLong|PulseInLong|put|radians|random|Random|randomSeed|RandomSeed|read|readAccelerometer|readBlue|readButton|readBytes|readBytesUntil|readGreen|readJoystickButton|readJoystickSwitch|readJoystickX|readJoystickY|readLightSensor|readMessage|readMicrophone|readNetworks|readRed|readSlider|readString|readStringUntil|readTemperature|ready|rect|release|releaseAll|remoteIP|remoteNumber|remotePort|remove|replace|requestFrom|retrieveCallingNumber|rewindDirectory|rightToLeft|rmdir|robotNameRead|robotNameWrite|round|roundf|RSSI|run|runAsynchronously|running|runShellCommand|runShellCommandAsynchronously|scanNetworks|scrollDisplayLeft|scrollDisplayRight|seek|sendAnalog|sendDigitalPortPair|sendDigitalPorts|sendString|sendSysex|Serial_Available|Serial_Begin|Serial_End|Serial_Flush|Serial_Peek|Serial_Print|Serial_Println|Serial_Read|serialEvent|setBand|setBitOrder|setCharAt|setClockDivider|setCursor|setDataMode|setDNS|setFirmwareVersion|setMode|setPINUsed|setSpeed|setTextSize|setTimeout|ShiftIn|shiftIn|ShiftOut|shiftOut|shutdown|signbit|sin|Sin|sinf|sinh|sinhf|size|sizeof|Sq|sq|Sqrt|sqrt|sqrtf|SSID|startLoop|startsWith|step|stop|stroke|subnetMask|substring|switchPIN|tan|Tan|tanf|tanh|tanhf|tempoWrite|text|toCharArray|toInt|toLowerCase|tone|Tone|toUpperCase|transfer|trim|trunc|truncf|tuneWrite|turn|updateIR|userNameRead|userNameWrite|voiceCall|waitContinue|width|WiFiServer|word|write|writeBlue|writeGreen|writeJSON|writeMessage|writeMicroseconds|writeRed|writeRGB|yield|Yield)\b">
-        <token type="NameFunction"/>
+      <rule
+        pattern="(abs|Abs|accept|ACos|acos|acosf|addParameter|analogRead|AnalogRead|analogReadResolution|AnalogReadResolution|analogReference|AnalogReference|analogWrite|AnalogWrite|analogWriteResolution|AnalogWriteResolution|answerCall|asin|ASin|asinf|atan|ATan|atan2|ATan2|atan2f|atanf|attach|attached|attachGPRS|attachInterrupt|AttachInterrupt|autoscroll|available|availableForWrite|background|beep|begin|beginPacket|beginSD|beginSMS|beginSpeaker|beginTFT|beginTransmission|beginWrite|bit|Bit|BitClear|bitClear|bitRead|BitRead|bitSet|BitSet|BitWrite|bitWrite|blink|blinkVersion|BSSID|buffer|byte|cbrt|cbrtf|Ceil|ceil|ceilf|changePIN|char|charAt|checkPIN|checkPUK|checkReg|circle|cityNameRead|cityNameWrite|clear|clearScreen|click|close|compareTo|compassRead|concat|config|connect|connected|constrain|Constrain|copysign|copysignf|cos|Cos|cosf|cosh|coshf|countryNameRead|countryNameWrite|createChar|cursor|debugPrint|degrees|Delay|delay|DelayMicroseconds|delayMicroseconds|detach|DetachInterrupt|detachInterrupt|DigitalPinToInterrupt|digitalPinToInterrupt|DigitalRead|digitalRead|DigitalWrite|digitalWrite|disconnect|display|displayLogos|drawBMP|drawCompass|encryptionType|end|endPacket|endSMS|endsWith|endTransmission|endWrite|equals|equalsIgnoreCase|exists|exitValue|Exp|exp|expf|fabs|fabsf|fdim|fdimf|fill|find|findUntil|float|floor|Floor|floorf|flush|fma|fmaf|fmax|fmaxf|fmin|fminf|fmod|fmodf|gatewayIP|get|getAsynchronously|getBand|getButton|getBytes|getCurrentCarrier|getIMEI|getKey|getModifiers|getOemKey|getPINUsed|getResult|getSignalStrength|getSocket|getVoiceCallStatus|getXChange|getYChange|hangCall|height|highByte|HighByte|home|hypot|hypotf|image|indexOf|int|interrupts|IPAddress|IRread|isActionDone|isAlpha|isAlphaNumeric|isAscii|isControl|isDigit|isDirectory|isfinite|isGraph|isHexadecimalDigit|isinf|isListening|isLowerCase|isnan|isPIN|isPressed|isPrintable|isPunct|isSpace|isUpperCase|isValid|isWhitespace|keyboardRead|keyPressed|keyReleased|knobRead|lastIndexOf|ldexp|ldexpf|leftToRight|length|line|lineFollowConfig|listen|listenOnLocalhost|loadImage|localIP|log|Log|log10|log10f|logf|long|lowByte|LowByte|lrint|lrintf|lround|lroundf|macAddress|maintain|map|Map|Max|max|messageAvailable|Micros|micros|millis|Millis|Min|min|mkdir|motorsStop|motorsWrite|mouseDragged|mouseMoved|mousePressed|mouseReleased|move|noAutoscroll|noBlink|noBuffer|noCursor|noDisplay|noFill|noInterrupts|NoInterrupts|noListenOnLocalhost|noStroke|noTone|NoTone|onReceive|onRequest|open|openNextFile|overflow|parseCommand|parseFloat|parseInt|parsePacket|pauseMode|peek|PinMode|pinMode|playFile|playMelody|point|pointTo|position|Pow|pow|powf|prepare|press|print|printFirmwareVersion|println|printVersion|process|processInput|PulseIn|pulseIn|pulseInLong|PulseInLong|put|radians|random|Random|randomSeed|RandomSeed|read|readAccelerometer|readBlue|readButton|readBytes|readBytesUntil|readGreen|readJoystickButton|readJoystickSwitch|readJoystickX|readJoystickY|readLightSensor|readMessage|readMicrophone|readNetworks|readRed|readSlider|readString|readStringUntil|readTemperature|ready|rect|release|releaseAll|remoteIP|remoteNumber|remotePort|remove|replace|requestFrom|retrieveCallingNumber|rewindDirectory|rightToLeft|rmdir|robotNameRead|robotNameWrite|round|roundf|RSSI|run|runAsynchronously|running|runShellCommand|runShellCommandAsynchronously|scanNetworks|scrollDisplayLeft|scrollDisplayRight|seek|sendAnalog|sendDigitalPortPair|sendDigitalPorts|sendString|sendSysex|Serial_Available|Serial_Begin|Serial_End|Serial_Flush|Serial_Peek|Serial_Print|Serial_Println|Serial_Read|serialEvent|setBand|setBitOrder|setCharAt|setClockDivider|setCursor|setDataMode|setDNS|setFirmwareVersion|setMode|setPINUsed|setSpeed|setTextSize|setTimeout|ShiftIn|shiftIn|ShiftOut|shiftOut|shutdown|signbit|sin|Sin|sinf|sinh|sinhf|size|sizeof|Sq|sq|Sqrt|sqrt|sqrtf|SSID|startLoop|startsWith|step|stop|stroke|subnetMask|substring|switchPIN|tan|Tan|tanf|tanh|tanhf|tempoWrite|text|toCharArray|toInt|toLowerCase|tone|Tone|toUpperCase|transfer|trim|trunc|truncf|tuneWrite|turn|updateIR|userNameRead|userNameWrite|voiceCall|waitContinue|width|WiFiServer|word|write|writeBlue|writeGreen|writeJSON|writeMessage|writeMicroseconds|writeRed|writeRGB|yield|Yield)\b"
+      >
+        <token type="NameFunction" />
      </rule>
      <rule pattern="(typename|__inline|restrict|_inline|thread|inline|naked)\b">
-        <token type="KeywordReserved"/>
+        <token type="KeywordReserved" />
      </rule>
      <rule pattern="(__m(128i|128d|128|64))\b">
-        <token type="KeywordReserved"/>
+        <token type="KeywordReserved" />
      </rule>
-      <rule pattern="__(forceinline|identifier|unaligned|declspec|fastcall|finally|stdcall|wchar_t|assume|except|int32|cdecl|int16|leave|based|raise|int64|noop|int8|w64|try|asm)\b">
-        <token type="KeywordReserved"/>
+      <rule
+        pattern="__(forceinline|identifier|unaligned|declspec|fastcall|finally|stdcall|wchar_t|assume|except|int32|cdecl|int16|leave|based|raise|int64|noop|int8|w64|try|asm)\b"
+      >
+        <token type="KeywordReserved" />
      </rule>
      <rule pattern="(true|false|NULL)\b">
-        <token type="NameBuiltin"/>
+        <token type="NameBuiltin" />
      </rule>
      <rule pattern="([a-zA-Z_]\w*)(\s*)(:)(?!:)">
        <bygroups>
-          <token type="NameLabel"/>
-          <token type="Text"/>
-          <token type="Punctuation"/>
+          <token type="NameLabel" />
+          <token type="Text" />
+          <token type="Punctuation" />
        </bygroups>
      </rule>
      <rule pattern="[a-zA-Z_]\w*">
-        <token type="Name"/>
+        <token type="Name" />
      </rule>
    </state>
    <state name="function">
      <rule>
-        <include state="whitespace"/>
+        <include state="whitespace" />
      </rule>
      <rule>
-        <include state="statements"/>
+        <include state="statements" />
      </rule>
      <rule pattern=";">
-        <token type="Punctuation"/>
+        <token type="Punctuation" />
      </rule>
      <rule pattern="\{">
-        <token type="Punctuation"/>
-        <push/>
+        <token type="Punctuation" />
+        <push />
      </rule>
      <rule pattern="\}">
-        <token type="Punctuation"/>
-        <pop depth="1"/>
+        <token type="Punctuation" />
+        <pop depth="1" />
      </rule>
    </state>
    <state name="if0">
      <rule pattern="^\s*#if.*?(?&lt;!\\)\n">
-        <token type="CommentPreproc"/>
-        <push/>
+        <token type="CommentPreproc" />
+        <push />
      </rule>
      <rule pattern="^\s*#el(?:se|if).*\n">
-        <token type="CommentPreproc"/>
-        <pop depth="1"/>
+        <token type="CommentPreproc" />
+        <pop depth="1" />
      </rule>
      <rule pattern="^\s*#endif.*?(?&lt;!\\)\n">
-        <token type="CommentPreproc"/>
-        <pop depth="1"/>
+        <token type="CommentPreproc" />
+        <pop depth="1" />
      </rule>
      <rule pattern=".*?\n">
-        <token type="Comment"/>
+        <token type="Comment" />
      </rule>
    </state>
    <state name="classname">
      <rule pattern="[a-zA-Z_]\w*">
-        <token type="NameClass"/>
-        <pop depth="1"/>
+        <token type="NameClass" />
+        <pop depth="1" />
      </rule>
      <rule pattern="\s*(?=&gt;)">
-        <token type="Text"/>
-        <pop depth="1"/>
+        <token type="Text" />
+        <pop depth="1" />
      </rule>
    </state>
    <state name="statement">
      <rule>
-        <include state="whitespace"/>
+        <include state="whitespace" />
      </rule>
      <rule>
-        <include state="statements"/>
+        <include state="statements" />
      </rule>
      <rule pattern="[{}]">
-        <token type="Punctuation"/>
+        <token type="Punctuation" />
      </rule>
      <rule pattern=";">
-        <token type="Punctuation"/>
-        <pop depth="1"/>
+        <token type="Punctuation" />
+        <pop depth="1" />
      </rule>
    </state>
    <state name="root">
      <rule>
-        <include state="whitespace"/>
+        <include state="whitespace" />
      </rule>
      <rule pattern="((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;{]*)(\{)">
        <bygroups>
-          <usingself state="root"/>
-          <token type="NameFunction"/>
-          <usingself state="root"/>
-          <usingself state="root"/>
-          <token type="Punctuation"/>
+          <usingself state="root" />
+          <token type="NameFunction" />
+          <usingself state="root" />
+          <usingself state="root" />
+          <token type="Punctuation" />
        </bygroups>
-        <push state="function"/>
+        <push state="function" />
      </rule>
      <rule pattern="((?:[\w*\s])+?(?:\s|[*]))([a-zA-Z_]\w*)(\s*\([^;]*?\))([^;]*)(;)">
        <bygroups>
-          <usingself state="root"/>
-          <token type="NameFunction"/>
-          <usingself state="root"/>
-          <usingself state="root"/>
-          <token type="Punctuation"/>
+          <usingself state="root" />
+          <token type="NameFunction" />
+          <usingself state="root" />
+          <usingself state="root" />
+          <token type="Punctuation" />
        </bygroups>
      </rule>
      <rule>
-        <push state="statement"/>
+        <push state="statement" />
      </rule>
      <rule pattern="__(multiple_inheritance|virtual_inheritance|single_inheritance|interface|uuidof|super|event)\b">
-        <token type="KeywordReserved"/>
+        <token type="KeywordReserved" />
      </rule>
      <rule pattern="__(offload|blockingoffload|outer)\b">
-        <token type="KeywordPseudo"/>
+        <token type="KeywordPseudo" />
      </rule>
    </state>
  </rules>
-</lexer>
+</lexer>
@@ -11,116 +11,116 @@
  <rules>
    <state name="root">
      <rule>
-        <include state="commentsandwhitespace"/>
+        <include state="commentsandwhitespace" />
      </rule>
      <rule pattern="(\.\w+)([ \t]+\w+\s+?)?">
        <bygroups>
-          <token type="KeywordNamespace"/>
-          <token type="NameLabel"/>
+          <token type="KeywordNamespace" />
+          <token type="NameLabel" />
        </bygroups>
      </rule>
      <rule pattern="(\w+)(:)(\s+\.\w+\s+)">
        <bygroups>
-          <token type="NameLabel"/>
-          <token type="Punctuation"/>
-          <token type="KeywordNamespace"/>
+          <token type="NameLabel" />
+          <token type="Punctuation" />
+          <token type="KeywordNamespace" />
        </bygroups>
-        <push state="literal"/>
+        <push state="literal" />
      </rule>
      <rule pattern="(\w+)(:)">
        <bygroups>
-          <token type="NameLabel"/>
-          <token type="Punctuation"/>
+          <token type="NameLabel" />
+          <token type="Punctuation" />
        </bygroups>
      </rule>
      <rule pattern="svc\s+\w+">
-        <token type="NameNamespace"/>
+        <token type="NameNamespace" />
      </rule>
      <rule pattern="[a-zA-Z]+">
-        <token type="Text"/>
-        <push state="opcode"/>
+        <token type="Text" />
+        <push state="opcode" />
      </rule>
    </state>
    <state name="commentsandwhitespace">
      <rule pattern="\s+">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="[@;].*?\n">
-        <token type="CommentSingle"/>
+        <token type="CommentSingle" />
      </rule>
      <rule pattern="/\*.*?\*/">
-        <token type="CommentMultiline"/>
+        <token type="CommentMultiline" />
      </rule>
    </state>
    <state name="literal">
      <rule pattern="0b[01]+">
-        <token type="LiteralNumberBin"/>
-        <pop depth="1"/>
+        <token type="LiteralNumberBin" />
+        <pop depth="1" />
      </rule>
      <rule pattern="0x\w{1,8}">
-        <token type="LiteralNumberHex"/>
-        <pop depth="1"/>
+        <token type="LiteralNumberHex" />
+        <pop depth="1" />
      </rule>
      <rule pattern="0\d+">
-        <token type="LiteralNumberOct"/>
-        <pop depth="1"/>
+        <token type="LiteralNumberOct" />
+        <pop depth="1" />
      </rule>
      <rule pattern="\d+?\.\d+?">
-        <token type="LiteralNumberFloat"/>
-        <pop depth="1"/>
+        <token type="LiteralNumberFloat" />
+        <pop depth="1" />
      </rule>
      <rule pattern="\d+">
-        <token type="LiteralNumberInteger"/>
-        <pop depth="1"/>
+        <token type="LiteralNumberInteger" />
+        <pop depth="1" />
      </rule>
      <rule pattern="(&#34;)(.+)(&#34;)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="LiteralStringDouble"/>
-          <token type="Punctuation"/>
+          <token type="Punctuation" />
+          <token type="LiteralStringDouble" />
+          <token type="Punctuation" />
        </bygroups>
-        <pop depth="1"/>
+        <pop depth="1" />
      </rule>
      <rule pattern="(&#39;)(.{1}|\\.{1})(&#39;)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="LiteralStringChar"/>
-          <token type="Punctuation"/>
+          <token type="Punctuation" />
+          <token type="LiteralStringChar" />
+          <token type="Punctuation" />
        </bygroups>
-        <pop depth="1"/>
+        <pop depth="1" />
      </rule>
    </state>
    <state name="opcode">
      <rule pattern="\n">
-        <token type="Text"/>
-        <pop depth="1"/>
+        <token type="Text" />
+        <pop depth="1" />
      </rule>
      <rule pattern="(@|;).*\n">
-        <token type="CommentSingle"/>
-        <pop depth="1"/>
+        <token type="CommentSingle" />
+        <pop depth="1" />
      </rule>
      <rule pattern="(\s+|,)">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="[rapcfxwbhsdqv]\d{1,2}">
-        <token type="NameClass"/>
+        <token type="NameClass" />
      </rule>
-      <rule pattern="=0x\w+">
+      <rule pattern="(=)(0x\w+)">
        <bygroups>
-          <token type="Text"/>
-          <token type="NameLabel"/>
+          <token type="Text" />
+          <token type="NameLabel" />
        </bygroups>
      </rule>
      <rule pattern="(=)(\w+)">
        <bygroups>
-          <token type="Text"/>
-          <token type="NameLabel"/>
+          <token type="Text" />
+          <token type="NameLabel" />
        </bygroups>
      </rule>
      <rule pattern="#">
-        <token type="Text"/>
-        <push state="literal"/>
+        <token type="Text" />
+        <push state="literal" />
      </rule>
    </state>
  </rules>
-</lexer>
+</lexer>
@@ -0,0 +1,79 @@
+<lexer>
+  <config>
+    <name>Core</name>
+    <alias>core</alias>
+    <filename>*.core</filename>
+    <mime_type>text/x-core</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="//(.*?)\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="(const|class|value|union|enum|trait|impl|annotation)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(fun|let|var)\b">
+        <token type="KeywordDeclaration"/>
+      </rule>
+      <rule pattern="(mod|use)\b">
+        <token type="KeywordNamespace"/>
+      </rule>
+      <rule pattern="(if|else|is|for|in|while|return)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(true|false|self)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="0[b][01](_?[01])*(i32|i64|u8|f32|f64)?">
+        <token type="LiteralNumberBin"/>
+      </rule>
+      <rule pattern="0[x][\da-fA-F](_?[\dA-Fa-f])*(i32|i64|u8|f32|f64)?">
+        <token type="LiteralNumberHex"/>
+      </rule>
+      <rule pattern="\d(_?\d)*\.\d(_?\d)*([eE][-+]?\d(_?\d)*)?(f32|f64)?">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="\d(_?\d)*(i32|i64|u8|f32|f64)?">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <push state="string"/>
+      </rule>
+      <rule pattern="@([a-z_]\w*[!?]?)">
+        <token type="NameAttribute"/>
+      </rule>
+      <rule pattern="===|!==|==|!=|&gt;=|&lt;=|[&gt;&lt;*/+-=&amp;|^]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[A-Z][A-Za-z0-9_]*">
+        <token type="NameClass"/>
+      </rule>
+      <rule pattern="([a-z_]\w*[!?]?)">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[(){}\[\],.;]">
+        <token type="Punctuation"/>
+      </rule>
+    </state>
+    <state name="string">
+      <rule pattern="&#34;">
+        <token type="LiteralString"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\\[&#34;\\fnrt]|\\u\{[\da-fA-F]{1,6}\}">
+        <token type="LiteralStringEscape"/>
+      </rule>
+      <rule pattern="[^\\&#34;]+">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="\\">
+        <token type="LiteralString"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>
@@ -3,55 +3,66 @@
    <name>Docker</name>
    <alias>docker</alias>
    <alias>dockerfile</alias>
+    <alias>containerfile</alias>
    <filename>Dockerfile</filename>
    <filename>Dockerfile.*</filename>
    <filename>*.Dockerfile</filename>
    <filename>*.docker</filename>
+    <filename>Containerfile</filename>
+    <filename>Containerfile.*</filename>
+    <filename>*.Containerfile</filename>
    <mime_type>text/x-dockerfile-config</mime_type>
    <case_insensitive>true</case_insensitive>
  </config>
  <rules>
    <state name="root">
      <rule pattern="#.*">
-        <token type="Comment"/>
+        <token type="Comment" />
      </rule>
      <rule pattern="(ONBUILD)((?:\s*\\?\s*))">
        <bygroups>
-          <token type="Keyword"/>
-          <using lexer="Bash"/>
+          <token type="Keyword" />
+          <using lexer="Bash" />
        </bygroups>
      </rule>
-      <rule pattern="(HEALTHCHECK)(((?:\s*\\?\s*)--\w+=\w+(?:\s*\\?\s*))*)">
+      <rule pattern="(HEALTHCHECK)((?:(?:\s*\\?\s*)--\w+=\w+(?:\s*\\?\s*))*)">
        <bygroups>
-          <token type="Keyword"/>
-          <using lexer="Bash"/>
+          <token type="Keyword" />
+          <using lexer="Bash" />
        </bygroups>
      </rule>
      <rule pattern="(VOLUME|ENTRYPOINT|CMD|SHELL)((?:\s*\\?\s*))(\[.*?\])">
        <bygroups>
-          <token type="Keyword"/>
-          <using lexer="Bash"/>
-          <using lexer="JSON"/>
+          <token type="Keyword" />
+          <using lexer="Bash" />
+          <using lexer="JSON" />
        </bygroups>
      </rule>
      <rule pattern="(LABEL|ENV|ARG)((?:(?:\s*\\?\s*)\w+=\w+(?:\s*\\?\s*))*)">
        <bygroups>
-          <token type="Keyword"/>
-          <using lexer="Bash"/>
+          <token type="Keyword" />
+          <using lexer="Bash" />
        </bygroups>
      </rule>
-      <rule pattern="((?:FROM|MAINTAINER|EXPOSE|WORKDIR|USER|STOPSIGNAL)|VOLUME)\b(.*)">
+      <rule
+        pattern="((?:FROM|MAINTAINER|EXPOSE|WORKDIR|USER|STOPSIGNAL)|VOLUME)\b(\s)([\S]*)\b(?:(\s)(AS)\b(\s)([\S]*))?\b"
+      >
        <bygroups>
-          <token type="Keyword"/>
-          <token type="LiteralString"/>
+          <token type="Keyword" />
+          <token type="TextWhitespace" />
+          <token type="LiteralString" />
+          <token type="TextWhitespace" />
+          <token type="Keyword" />
+          <token type="TextWhitespace" />
+          <token type="LiteralString" />
        </bygroups>
      </rule>
      <rule pattern="((?:RUN|CMD|ENTRYPOINT|ENV|ARG|LABEL|ADD|COPY))">
-        <token type="Keyword"/>
+        <token type="Keyword" />
      </rule>
      <rule pattern="(.*\\\n)*.+">
-        <using lexer="Bash"/>
+        <using lexer="Bash" />
      </rule>
    </state>
  </rules>
-</lexer>
+</lexer>
@@ -33,7 +33,6 @@
      </rule>
      <rule pattern="(type)\b">
        <token type="Keyword"/>
-        <push state="typename"/>
      </rule>
      <rule pattern="(True|False)\b">
        <token type="KeywordConstant"/>
@@ -63,12 +62,11 @@
      <rule pattern="[{}()\[\],]|[#(]|\.\.|&lt;&gt;|&lt;&lt;|&gt;&gt;">
        <token type="Punctuation"/>
      </rule>
-      <rule pattern="[+\-*/%!=&lt;&gt;&amp;|.]|&lt;-">
-        <token type="Operator"/>
-      </rule>
      <rule pattern=":|-&gt;">
        <token type="Operator"/>
-        <push state="typename"/>
+      </rule>
+      <rule pattern="[+\-*/%!=&lt;&gt;&amp;|.]|&lt;-">
+        <token type="Operator"/>
      </rule>
      <rule pattern="([a-z_][A-Za-z0-9_]*)(\()">
        <bygroups>
@@ -76,28 +74,13 @@
          <token type="Punctuation"/>
        </bygroups>
      </rule>
-      <rule pattern="([A-Z][A-Za-z0-9_]*)(\()">
-        <bygroups>
-          <token type="NameClass"/>
-          <token type="Punctuation"/>
-        </bygroups>
+      <rule pattern="[A-Z][A-Za-z0-9_]*">
+        <token type="NameClass"/>
      </rule>
      <rule pattern="([a-z_]\w*[!?]?)">
        <token type="Name"/>
      </rule>
    </state>
-    <state name="typename">
-      <rule pattern="\s+">
-        <token type="TextWhitespace"/>
-      </rule>
-      <rule pattern="[A-Z][A-Za-z0-9_]*">
-        <token type="NameClass"/>
-        <pop depth="1"/>
-      </rule>
-      <rule>
-        <pop depth="1"/>
-      </rule>
-    </state>
    <state name="string">
      <rule pattern="&#34;">
        <token type="LiteralString"/>
@@ -7,143 +7,125 @@
  <rules>
    <state name="root">
      <rule pattern="(#.*)">
-        <bygroups>
-          <token type="CommentSingle"/>
-        </bygroups>
+        <token type="CommentSingle" />
      </rule>
      <rule pattern="((\b(0(b|B|o|O|x|X)[a-fA-F0-9]+)\b)|(\b(0|[1-9][0-9]*)\b))">
-        <bygroups>
-          <token type="LiteralNumber"/>
-        </bygroups>
+        <token type="LiteralNumber" />
      </rule>
      <rule pattern="((\b(true|false)\b))">
-        <bygroups>
-          <token type="NameBuiltin"/>
-        </bygroups>
+        <token type="NameBuiltin" />
      </rule>
      <rule pattern="(\bstring\b|\bint\b|\bbool\b|\bfs\b|\boption\b)">
-        <bygroups>
-          <token type="KeywordType"/>
-        </bygroups>
+        <token type="KeywordType" />
      </rule>
      <rule pattern="(\b[a-zA-Z_][a-zA-Z0-9]*\b)(\()">
        <bygroups>
-          <token type="NameFunction"/>
-          <token type="Punctuation"/>
+          <token type="NameFunction" />
+          <token type="Punctuation" />
        </bygroups>
-        <push state="params"/>
+        <push state="params" />
      </rule>
      <rule pattern="(\{)">
-        <bygroups>
-          <token type="Punctuation"/>
-        </bygroups>
-        <push state="block"/>
+        <token type="Punctuation" />
+        <push state="block" />
      </rule>
      <rule pattern="(\n|\r|\r\n)">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern=".">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
    </state>
    <state name="string">
      <rule pattern="&#34;">
-        <token type="LiteralString"/>
-        <pop depth="1"/>
+        <token type="LiteralString" />
+        <pop depth="1" />
      </rule>
      <rule pattern="\\&#34;">
-        <token type="LiteralString"/>
+        <token type="LiteralString" />
      </rule>
      <rule pattern="[^\\&#34;]+">
-        <token type="LiteralString"/>
+        <token type="LiteralString" />
      </rule>
    </state>
    <state name="block">
      <rule pattern="(\})">
-        <bygroups>
-          <token type="Punctuation"/>
-        </bygroups>
-        <pop depth="1"/>
+        <token type="Punctuation" />
+        <pop depth="1" />
      </rule>
      <rule pattern="(#.*)">
-        <bygroups>
-          <token type="CommentSingle"/>
-        </bygroups>
+        <token type="CommentSingle" />
      </rule>
      <rule pattern="((\b(0(b|B|o|O|x|X)[a-fA-F0-9]+)\b)|(\b(0|[1-9][0-9]*)\b))">
-        <bygroups>
-          <token type="LiteralNumber"/>
-        </bygroups>
+        <token type="LiteralNumber" />
      </rule>
      <rule pattern="((\b(true|false)\b))">
-        <bygroups>
-          <token type="KeywordConstant"/>
-        </bygroups>
+        <token type="KeywordConstant" />
      </rule>
      <rule pattern="&#34;">
-        <token type="LiteralString"/>
-        <push state="string"/>
+        <token type="LiteralString" />
+        <push state="string" />
      </rule>
      <rule pattern="(with)">
-        <bygroups>
-          <token type="KeywordReserved"/>
-        </bygroups>
+        <token type="KeywordReserved" />
      </rule>
      <rule pattern="(as)([\t ]+)(\b[a-zA-Z_][a-zA-Z0-9]*\b)">
        <bygroups>
-          <token type="KeywordReserved"/>
-          <token type="Text"/>
-          <token type="NameFunction"/>
+          <token type="KeywordReserved" />
+          <token type="Text" />
+          <token type="NameFunction" />
        </bygroups>
      </rule>
      <rule pattern="(\bstring\b|\bint\b|\bbool\b|\bfs\b|\boption\b)([\t ]+)(\{)">
        <bygroups>
-          <token type="KeywordType"/>
-          <token type="Text"/>
-          <token type="Punctuation"/>
+          <token type="KeywordType" />
+          <token type="Text" />
+          <token type="Punctuation" />
        </bygroups>
-        <push state="block"/>
+        <push state="block" />
      </rule>
-      <rule pattern="(?!\b(?:scratch|image|resolve|http|checksum|chmod|filename|git|keepGitDir|local|includePatterns|excludePatterns|followPaths|generate|frontendInput|shell|run|readonlyRootfs|env|dir|user|network|security|host|ssh|secret|mount|target|localPath|uid|gid|mode|readonly|tmpfs|sourcePath|cache|mkdir|createParents|chown|createdTime|mkfile|rm|allowNotFound|allowWildcards|copy|followSymlinks|contentsOnly|unpack|createDestPath)\b)(\b[a-zA-Z_][a-zA-Z0-9]*\b)">
+      <rule
+        pattern="(?!\b(?:scratch|image|resolve|http|checksum|chmod|filename|git|keepGitDir|local|includePatterns|excludePatterns|followPaths|generate|frontendInput|shell|run|readonlyRootfs|env|dir|user|network|security|host|ssh|secret|mount|target|localPath|uid|gid|mode|readonly|tmpfs|sourcePath|cache|mkdir|createParents|chown|createdTime|mkfile|rm|allowNotFound|allowWildcards|copy|followSymlinks|contentsOnly|unpack|createDestPath)\b)(\b[a-zA-Z_][a-zA-Z0-9]*\b)"
+      >
        <bygroups>
-          <token type="NameOther"/>
+          <token type="NameOther" />
        </bygroups>
      </rule>
      <rule pattern="(\n|\r|\r\n)">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern=".">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
    </state>
    <state name="params">
      <rule pattern="(\))">
        <bygroups>
-          <token type="Punctuation"/>
+          <token type="Punctuation" />
        </bygroups>
-        <pop depth="1"/>
+        <pop depth="1" />
      </rule>
      <rule pattern="(variadic)">
        <bygroups>
-          <token type="Keyword"/>
+          <token type="Keyword" />
        </bygroups>
      </rule>
      <rule pattern="(\bstring\b|\bint\b|\bbool\b|\bfs\b|\boption\b)">
        <bygroups>
-          <token type="KeywordType"/>
+          <token type="KeywordType" />
        </bygroups>
      </rule>
      <rule pattern="(\b[a-zA-Z_][a-zA-Z0-9]*\b)">
        <bygroups>
-          <token type="NameOther"/>
+          <token type="NameOther" />
        </bygroups>
      </rule>
      <rule pattern="(\n|\r|\r\n)">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern=".">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
    </state>
  </rules>
-</lexer>
+</lexer>
@@ -3,6 +3,7 @@
    <name>Kotlin</name>
    <alias>kotlin</alias>
    <filename>*.kt</filename>
+    <filename>*.kts</filename>
    <mime_type>text/x-kotlin</mime_type>
    <dot_all>true</dot_all>
  </config>
@@ -0,0 +1,56 @@
+<lexer>
+  <config>
+    <name>Lean4</name>
+    <alias>lean4</alias>
+    <alias>lean</alias>
+    <filename>*.lean</filename>
+    <mime_type>text/x-lean4</mime_type>
+    <mime_type>text/x-lean</mime_type>
+  </config>
+  <rules>
+    <state name="expression">
+      <rule pattern="\s+"><token type="TextWhitespace"/></rule>
+      <rule pattern="/--"><token type="LiteralStringDoc"/><push state="docstring"/></rule>
+      <rule pattern="/-"><token type="Comment"/><push state="comment"/></rule>
+      <rule pattern="--.*$"><token type="CommentSingle"/></rule>
+      <rule pattern="\b(Type|Prop|Sort)\b"><token type="KeywordType"/></rule>
+      <rule pattern="\b(sorry|admit)\b"><token type="GenericError"/></rule>
+      <rule pattern="(!=|\#|\&amp;|\&amp;\&amp;|\*|\+|\-|/|@|!|\-\.|\-&gt;|\.|\.\.|\.\.\.|::|:&gt;|;|;;|&lt;|&lt;\-|=|==|&gt;|_|\||\|\||\~|=&gt;|&lt;=|&gt;=|/\\|\\/|∀|Π|λ|↔|∧|∨|≠|≤|≥|¬|⁻¹|⬝|▸|→|∃|≈|×|⌞|⌟|≡|⟨|⟩|↦)"><token type="NameBuiltinPseudo"/></rule>
+      <rule pattern="(\(|\)|:|\{|\}|\[|\]|⦃|⦄|:=|,)"><token type="Operator"/></rule>
+      <rule pattern="(?![λΠΣ])[_a-zA-Zα-ωΑ-Ωϊ-ϻἀ-῾℀-⅏𝒜-𝖟](?:(?![λΠΣ])[_a-zA-Zα-ωΑ-Ωϊ-ϻἀ-῾℀-⅏𝒜-𝖟0-9&#x27;ⁿ-₉ₐ-ₜᵢ-ᵪ!?])*"><token type="Name"/></rule>
+      <rule pattern="``?(?![λΠΣ])[_a-zA-Zα-ωΑ-Ωϊ-ϻἀ-῾℀-⅏𝒜-𝖟](?:(?![λΠΣ])[_a-zA-Zα-ωΑ-Ωϊ-ϻἀ-῾℀-⅏𝒜-𝖟0-9&#x27;ⁿ-₉ₐ-ₜᵢ-ᵪ!?])*(\.(?![λΠΣ])[_a-zA-Zα-ωΑ-Ωϊ-ϻἀ-῾℀-⅏𝒜-𝖟](?:(?![λΠΣ])[_a-zA-Zα-ωΑ-Ωϊ-ϻἀ-῾℀-⅏𝒜-𝖟0-9&#x27;ⁿ-₉ₐ-ₜᵢ-ᵪ!?])*)*"><token type="LiteralStringSymbol"/></rule>
+      <rule pattern="(?&lt;=\.)\d+"><token type="LiteralNumber"/></rule>
+      <rule pattern="(\d+\.\d*)([eE][+-]?[0-9]+)?"><token type="LiteralNumberFloat"/></rule>
+      <rule pattern="\d+"><token type="LiteralNumberInteger"/></rule>
+      <rule pattern="&quot;"><token type="LiteralStringDouble"/><push state="string"/></rule>
+      <rule pattern="[~?][a-z][\w\&#x27;]*:"><token type="NameVariable"/></rule>
+      <rule pattern="\S"><token type="NameBuiltinPseudo"/></rule>
+    </state>
+    <state name="root">
+      <rule pattern="\b(import|unif_hint|renaming|inline|hiding|lemma|variable|theorem|axiom|inductive|structure|universe|alias|\#help|precedence|postfix|prefix|infix|infixl|infixr|notation|\#eval|\#check|\#reduce|\#exit|end|private|using|namespace|instance|section|protected|export|set_option|extends|open|example|\#print|opaque|def|macro|elab|syntax|macro_rules|\#reduce|where|abbrev|noncomputable|class|attribute|\#synth|mutual|scoped|local)\b"><token type="KeywordNamespace"/></rule>
+      <rule pattern="\b(forall|fun|obtain|from|have|show|assume|let|if|else|then|by|in|with|calc|match|nomatch|do|at)\b"><token type="Keyword"/></rule>
+      <rule pattern="@\["><token type="KeywordDeclaration"/><push state="attribute"/></rule>
+      <rule><include state="expression"/></rule>
+    </state>
+    <state name="attribute">
+      <rule pattern="\]"><token type="KeywordDeclaration"/><pop depth="1"/></rule>
+      <rule><include state="expression"/></rule>
+    </state>
+    <state name="comment">
+      <rule pattern="[^/-]+"><token type="CommentMultiline"/></rule>
+      <rule pattern="/-"><token type="CommentMultiline"/><push/></rule>
+      <rule pattern="-/"><token type="CommentMultiline"/><pop depth="1"/></rule>
+      <rule pattern="[/-]"><token type="CommentMultiline"/></rule>
+    </state>
+    <state name="docstring">
+      <rule pattern="[^/-]+"><token type="LiteralStringDoc"/></rule>
+      <rule pattern="-/"><token type="LiteralStringDoc"/><pop depth="1"/></rule>
+      <rule pattern="[/-]"><token type="LiteralStringDoc"/></rule>
+    </state>
+    <state name="string">
+      <rule pattern="[^\\&quot;]+"><token type="LiteralStringDouble"/></rule>
+      <rule pattern="\\[n&quot;\\\n]"><token type="LiteralStringEscape"/></rule>
+      <rule pattern="&quot;"><token type="LiteralStringDouble"/><pop depth="1"/></rule>
+    </state>
+  </rules>
+</lexer>
@@ -0,0 +1,83 @@
+<lexer>
+  <config>
+    <name>lox</name>
+    <filename>*.lox</filename>
+    <dot_all>true</dot_all>
+    <ensure_nl>true</ensure_nl>
+  </config>
+  <rules>
+    <state name="classname">
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="NameClass"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="funname">
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="NameFunction"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="varname">
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="NameVariable"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="whitespace">
+      <rule pattern="\n">
+        <token type="Text"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="root">
+      <rule>
+        <include state="whitespace"/>
+      </rule>
+      <rule pattern="//.*?\n">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="(and|else|for|if|or|print|return|super|this|while)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(false|nil|true)\b">
+        <token type="KeywordConstant"/>
+      </rule>
+      <rule pattern="(class)(\s*)">
+        <token type="KeywordDeclaration"/>
+        <push state="classname"/>
+      </rule>
+      <rule pattern="(fun)(\s*)">
+        <token type="KeywordDeclaration"/>
+        <push state="funname"/>
+      </rule>
+      <rule pattern="(var)(\s*)">
+        <token type="KeywordDeclaration"/>
+        <push state="varname"/>
+      </rule>
+      <rule pattern="\d+(\.\d*|[eE][+\-]?\d+)">
+        <token type="LiteralNumberFloat"/>
+      </rule>
+      <rule pattern="[0-9][0-9]*">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="!|\+|-|\*|/|&lt;|&gt;|=">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[{(;,]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[}).]">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="[a-zA-Z_]\w*">
+        <token type="NameVariable"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>
@@ -2,8 +2,10 @@
  <config>
    <name>Lua</name>
    <alias>lua</alias>
+    <alias>luau</alias>
    <filename>*.lua</filename>
    <filename>*.wlua</filename>
+    <filename>*.luau</filename>
    <mime_type>text/x-lua</mime_type>
    <mime_type>application/x-lua</mime_type>
  </config>
@@ -0,0 +1,228 @@
+<lexer>
+  <config>
+    <name>Mojo</name>
+    <alias>mojo</alias>
+    <alias>🔥</alias>
+    <filename>*.mojo</filename>
+    <filename>*.🔥</filename>
+    <mime_type>text/x-mojo</mime_type>
+    <mime_type>application/x-mojo</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\s+"><token type="TextWhitespace"/></rule>
+      <rule pattern="^(\s*)([rRuUbB]{,2})(&quot;&quot;&quot;(?:.|\n)*?&quot;&quot;&quot;)"><bygroups><token type="TextWhitespace"/><token type="LiteralStringAffix"/><token type="LiteralStringDoc"/></bygroups></rule>
+      <rule pattern="^(\s*)([rRuUbB]{,2})(&#x27;&#x27;&#x27;(?:.|\n)*?&#x27;&#x27;&#x27;)"><bygroups><token type="TextWhitespace"/><token type="LiteralStringAffix"/><token type="LiteralStringDoc"/></bygroups></rule>
+      <rule pattern="\A#!.+$"><token type="CommentHashbang"/></rule>
+      <rule pattern="#.*$"><token type="CommentSingle"/></rule>
+      <rule pattern="\\\n"><token type="TextWhitespace"/></rule>
+      <rule pattern="\\"><token type="TextWhitespace"/></rule>
+      <rule><include state="keywords"/></rule>
+      <rule><include state="soft-keywords"/></rule>
+      <rule pattern="(alias)(\s+)"><bygroups><token type="Keyword"/><token type="TextWhitespace"/></bygroups><push state="varname"/></rule>
+      <rule pattern="(var)(\s+)"><bygroups><token type="Keyword"/><token type="TextWhitespace"/></bygroups><push state="varname"/></rule>
+      <rule pattern="(def)(\s+)"><bygroups><token type="Keyword"/><token type="TextWhitespace"/></bygroups><push state="funcname"/></rule>
+      <rule pattern="(fn)(\s+)"><bygroups><token type="Keyword"/><token type="TextWhitespace"/></bygroups><push state="funcname"/></rule>
+      <rule pattern="(class)(\s+)"><bygroups><token type="Keyword"/><token type="TextWhitespace"/></bygroups><push state="classname"/></rule>
+      <rule pattern="(struct)(\s+)"><bygroups><token type="Keyword"/><token type="TextWhitespace"/></bygroups><push state="structname"/></rule>
+      <rule pattern="(trait)(\s+)"><bygroups><token type="Keyword"/><token type="TextWhitespace"/></bygroups><push state="structname"/></rule>
+      <rule pattern="(from)(\s+)"><bygroups><token type="KeywordNamespace"/><token type="TextWhitespace"/></bygroups><push state="fromimport"/></rule>
+      <rule pattern="(import)(\s+)"><bygroups><token type="KeywordNamespace"/><token type="TextWhitespace"/></bygroups><push state="import"/></rule>
+      <rule><include state="expr"/></rule>
+    </state>
+    <state name="expr">
+      <rule pattern="(?i)(rf|fr)(&quot;&quot;&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><combined state="rfstringescape" state="tdqf"/></rule>
+      <rule pattern="(?i)(rf|fr)(&#x27;&#x27;&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><combined state="rfstringescape" state="tsqf"/></rule>
+      <rule pattern="(?i)(rf|fr)(&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><combined state="rfstringescape" state="dqf"/></rule>
+      <rule pattern="(?i)(rf|fr)(&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><combined state="rfstringescape" state="sqf"/></rule>
+      <rule pattern="([fF])(&quot;&quot;&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><combined state="fstringescape" state="tdqf"/></rule>
+      <rule pattern="([fF])(&#x27;&#x27;&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><combined state="fstringescape" state="tsqf"/></rule>
+      <rule pattern="([fF])(&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><combined state="fstringescape" state="dqf"/></rule>
+      <rule pattern="([fF])(&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><combined state="fstringescape" state="sqf"/></rule>
+      <rule pattern="(?i)(rb|br|r)(&quot;&quot;&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><push state="tdqs"/></rule>
+      <rule pattern="(?i)(rb|br|r)(&#x27;&#x27;&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><push state="tsqs"/></rule>
+      <rule pattern="(?i)(rb|br|r)(&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><push state="dqs"/></rule>
+      <rule pattern="(?i)(rb|br|r)(&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><push state="sqs"/></rule>
+      <rule pattern="([uU]?)(&quot;&quot;&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><combined state="stringescape" state="tdqs"/></rule>
+      <rule pattern="([uU]?)(&#x27;&#x27;&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><combined state="stringescape" state="tsqs"/></rule>
+      <rule pattern="([uU]?)(&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><combined state="stringescape" state="dqs"/></rule>
+      <rule pattern="([uU]?)(&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><combined state="stringescape" state="sqs"/></rule>
+      <rule pattern="([bB])(&quot;&quot;&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><combined state="bytesescape" state="tdqs"/></rule>
+      <rule pattern="([bB])(&#x27;&#x27;&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><combined state="bytesescape" state="tsqs"/></rule>
+      <rule pattern="([bB])(&quot;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringDouble"/></bygroups><combined state="bytesescape" state="dqs"/></rule>
+      <rule pattern="([bB])(&#x27;)"><bygroups><token type="LiteralStringAffix"/><token type="LiteralStringSingle"/></bygroups><combined state="bytesescape" state="sqs"/></rule>
+      <rule pattern="[^\S\n]+"><token type="Text"/></rule>
+      <rule><include state="numbers"/></rule>
+      <rule pattern="!=|==|&lt;&lt;|&gt;&gt;|:=|[-~+/*%=&lt;&gt;&amp;^|.]"><token type="Operator"/></rule>
+      <rule pattern="([]{}:\(\),;[])+"><token type="Punctuation"/></rule>
+      <rule pattern="(in|is|and|or|not)\b"><token type="OperatorWord"/></rule>
+      <rule><include state="expr-keywords"/></rule>
+      <rule><include state="builtins"/></rule>
+      <rule><include state="magicfuncs"/></rule>
+      <rule><include state="magicvars"/></rule>
+      <rule><include state="name"/></rule>
+    </state>
+    <state name="expr-inside-fstring">
+      <rule pattern="[{([]"><token type="Punctuation"/><push state="expr-inside-fstring-inner"/></rule>
+      <rule pattern="(=\s*)?(\![sraf])?\}"><token type="LiteralStringInterpol"/><pop depth="1"/></rule>
+      <rule pattern="(=\s*)?(\![sraf])?:"><token type="LiteralStringInterpol"/><pop depth="1"/></rule>
+      <rule pattern="\s+"><token type="TextWhitespace"/></rule>
+      <rule><include state="expr"/></rule>
+    </state>
+    <state name="expr-inside-fstring-inner">
+      <rule pattern="[{([]"><token type="Punctuation"/><push state="expr-inside-fstring-inner"/></rule>
+      <rule pattern="[])}]"><token type="Punctuation"/><pop depth="1"/></rule>
+      <rule pattern="\s+"><token type="TextWhitespace"/></rule>
+      <rule><include state="expr"/></rule>
+    </state>
+    <state name="expr-keywords">
+      <rule pattern="(async\ for|async\ with|await|else|for|if|lambda|yield|yield\ from)\b"><token type="Keyword"/></rule>
+      <rule pattern="(True|False|None)\b"><token type="KeywordConstant"/></rule>
+    </state>
+    <state name="keywords">
+      <rule pattern="(assert|async|await|borrowed|break|continue|del|elif|else|except|finally|for|global|if|lambda|pass|raise|nonlocal|return|try|while|yield|yield\ from|as|with)\b"><token type="Keyword"/></rule>
+      <rule pattern="(True|False|None)\b"><token type="KeywordConstant"/></rule>
+    </state>
+    <state name="soft-keywords">
+      <rule pattern="(^[ \t]*)(match|case)\b(?![ \t]*(?:[:,;=^&amp;|@~)\]}]|(?:and|as|assert|async|await|break|class|continue|def|del|elif|else|except|finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)\b))"><bygroups><token type="TextWhitespace"/><token type="Keyword"/></bygroups><push state="soft-keywords-inner"/></rule>
+    </state>
+    <state name="soft-keywords-inner">
+      <rule pattern="(\s+)([^\n_]*)(_\b)"><bygroups><token type="TextWhitespace"/><usingself state="root"/><token type="Keyword"/></bygroups></rule>
+      <rule><pop depth="1"/></rule>
+    </state>
+    <state name="builtins">
+      <rule pattern="(?&lt;!\.)(__import__|abs|aiter|all|any|bin|bool|bytearray|breakpoint|bytes|callable|chr|classmethod|compile|complex|delattr|dict|dir|divmod|enumerate|eval|filter|float|format|frozenset|getattr|globals|hasattr|hash|hex|id|input|int|isinstance|issubclass|iter|len|list|locals|map|max|memoryview|min|next|object|oct|open|ord|pow|print|property|range|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|vars|zip|AnyType|Coroutine|DType|Error|Int|List|ListLiteral|Scalar|Int8|UInt8|Int16|UInt16|Int32|UInt32|Int64|UInt64|BFloat16|Float16|Float32|Float64|SIMD|String|Tensor|Tuple|Movable|Copyable|CollectionElement)\b"><token type="NameBuiltin"/></rule>
+      <rule pattern="(?&lt;!\.)(self|Ellipsis|NotImplemented|cls)\b"><token type="NameBuiltinPseudo"/></rule>
+      <rule pattern="(?&lt;!\.)(Error)\b"><token type="NameException"/></rule>
+    </state>
+    <state name="magicfuncs">
+      <rule pattern="(__abs__|__add__|__aenter__|__aexit__|__aiter__|__and__|__anext__|__await__|__bool__|__bytes__|__call__|__complex__|__contains__|__del__|__delattr__|__delete__|__delitem__|__dir__|__divmod__|__enter__|__eq__|__exit__|__float__|__floordiv__|__format__|__ge__|__get__|__getattr__|__getattribute__|__getitem__|__gt__|__hash__|__iadd__|__iand__|__ifloordiv__|__ilshift__|__imatmul__|__imod__|__imul__|__index__|__init__|__instancecheck__|__int__|__invert__|__ior__|__ipow__|__irshift__|__isub__|__iter__|__itruediv__|__ixor__|__le__|__len__|__length_hint__|__lshift__|__lt__|__matmul__|__missing__|__mod__|__mul__|__ne__|__neg__|__new__|__next__|__or__|__pos__|__pow__|__prepare__|__radd__|__rand__|__rdivmod__|__repr__|__reversed__|__rfloordiv__|__rlshift__|__rmatmul__|__rmod__|__rmul__|__ror__|__round__|__rpow__|__rrshift__|__rshift__|__rsub__|__rtruediv__|__rxor__|__set__|__setattr__|__setitem__|__str__|__sub__|__subclasscheck__|__truediv__|__xor__)\b"><token type="NameFunctionMagic"/></rule>
+    </state>
+    <state name="magicvars">
+      <rule pattern="(__annotations__|__bases__|__class__|__closure__|__code__|__defaults__|__dict__|__doc__|__file__|__func__|__globals__|__kwdefaults__|__module__|__mro__|__name__|__objclass__|__qualname__|__self__|__slots__|__weakref__)\b"><token type="NameVariableMagic"/></rule>
+    </state>
+    <state name="numbers">
+      <rule pattern="(\d(?:_?\d)*\.(?:\d(?:_?\d)*)?|(?:\d(?:_?\d)*)?\.\d(?:_?\d)*)([eE][+-]?\d(?:_?\d)*)?"><token type="LiteralNumberFloat"/></rule>
+      <rule pattern="\d(?:_?\d)*[eE][+-]?\d(?:_?\d)*j?"><token type="LiteralNumberFloat"/></rule>
+      <rule pattern="0[oO](?:_?[0-7])+"><token type="LiteralNumberOct"/></rule>
+      <rule pattern="0[bB](?:_?[01])+"><token type="LiteralNumberBin"/></rule>
+      <rule pattern="0[xX](?:_?[a-fA-F0-9])+"><token type="LiteralNumberHex"/></rule>
+      <rule pattern="\d(?:_?\d)*"><token type="LiteralNumberInteger"/></rule>
+    </state>
+    <state name="name">
+      <rule pattern="@[_\p{L}][_\p{L}\p{N}]*(\s*\.\s*[_\p{L}][_\p{L}\p{N}]*)*"><token type="NameDecorator"/></rule>
+      <rule pattern="@"><token type="Operator"/></rule>
+      <rule pattern="[_\p{L}][_\p{L}\p{N}]*(\s*\.\s*[_\p{L}][_\p{L}\p{N}]*)*"><token type="Name"/></rule>
+    </state>
+    <state name="varname">
+      <rule pattern="[_\p{L}][_\p{L}\p{N}]*(\s*\.\s*[_\p{L}][_\p{L}\p{N}]*)*"><token type="NameVariable"/><pop depth="1"/></rule>
+    </state>
+    <state name="funcname">
+      <rule><include state="magicfuncs"/></rule>
+      <rule pattern="[_\p{L}][_\p{L}\p{N}]*(\s*\.\s*[_\p{L}][_\p{L}\p{N}]*)*"><token type="NameFunction"/><pop depth="1"/></rule>
+      <rule><pop depth="1"/></rule>
+    </state>
+    <state name="classname">
+      <rule pattern="[_\p{L}][_\p{L}\p{N}]*(\s*\.\s*[_\p{L}][_\p{L}\p{N}]*)*"><token type="NameClass"/><pop depth="1"/></rule>
+    </state>
+    <state name="structname">
+      <rule pattern="[_\p{L}][_\p{L}\p{N}]*(\s*\.\s*[_\p{L}][_\p{L}\p{N}]*)*"><token type="NameClass"/><pop depth="1"/></rule>
+    </state>
+    <state name="import">
+      <rule pattern="(\s+)(as)(\s+)"><bygroups><token type="TextWhitespace"/><token type="Keyword"/><token type="TextWhitespace"/></bygroups></rule>
+      <rule pattern="\."><token type="NameNamespace"/></rule>
+      <rule pattern="[_\p{L}][_\p{L}\p{N}]*(\s*\.\s*[_\p{L}][_\p{L}\p{N}]*)*"><token type="NameNamespace"/></rule>
+      <rule pattern="(\s*)(,)(\s*)"><bygroups><token type="TextWhitespace"/><token type="Operator"/><token type="TextWhitespace"/></bygroups></rule>
+      <rule><pop depth="1"/></rule>
+    </state>
+    <state name="fromimport">
+      <rule pattern="(\s+)(import)\b"><bygroups><token type="TextWhitespace"/><token type="KeywordNamespace"/></bygroups><pop depth="1"/></rule>
+      <rule pattern="\."><token type="NameNamespace"/></rule>
+      <rule pattern="None\b"><token type="KeywordConstant"/><pop depth="1"/></rule>
+      <rule pattern="[_\p{L}][_\p{L}\p{N}]*(\s*\.\s*[_\p{L}][_\p{L}\p{N}]*)*"><token type="NameNamespace"/></rule>
+      <rule><pop depth="1"/></rule>
+    </state>
+    <state name="rfstringescape">
+      <rule pattern="\{\{"><token type="LiteralStringEscape"/></rule>
+      <rule pattern="\}\}"><token type="LiteralStringEscape"/></rule>
+    </state>
+    <state name="fstringescape">
+      <rule><include state="rfstringescape"/></rule>
+      <rule><include state="stringescape"/></rule>
+    </state>
+    <state name="bytesescape">
+      <rule pattern="\\([\\abfnrtv&quot;\&#x27;]|\n|x[a-fA-F0-9]{2}|[0-7]{1,3})"><token type="LiteralStringEscape"/></rule>
+    </state>
+    <state name="stringescape">
+      <rule pattern="\\(N\{.*?\}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{8})"><token type="LiteralStringEscape"/></rule>
+      <rule><include state="bytesescape"/></rule>
+    </state>
+    <state name="fstrings-single">
+      <rule pattern="\}"><token type="LiteralStringInterpol"/></rule>
+      <rule pattern="\{"><token type="LiteralStringInterpol"/><push state="expr-inside-fstring"/></rule>
+      <rule pattern="[^\\\&#x27;&quot;{}\n]+"><token type="LiteralStringSingle"/></rule>
+      <rule pattern="[\&#x27;&quot;\\]"><token type="LiteralStringSingle"/></rule>
+    </state>
+    <state name="fstrings-double">
+      <rule pattern="\}"><token type="LiteralStringInterpol"/></rule>
+      <rule pattern="\{"><token type="LiteralStringInterpol"/><push state="expr-inside-fstring"/></rule>
+      <rule pattern="[^\\\&#x27;&quot;{}\n]+"><token type="LiteralStringDouble"/></rule>
+      <rule pattern="[\&#x27;&quot;\\]"><token type="LiteralStringDouble"/></rule>
+    </state>
+    <state name="strings-single">
+      <rule pattern="%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsaux%]"><token type="LiteralStringInterpol"/></rule>
+      <rule pattern="\{((\w+)((\.\w+)|(\[[^\]]+\]))*)?(\![sra])?(\:(.?[&lt;&gt;=\^])?[-+ ]?#?0?(\d+)?,?(\.\d+)?[E-GXb-gnosx%]?)?\}"><token type="LiteralStringInterpol"/></rule>
+      <rule pattern="[^\\\&#x27;&quot;%{\n]+"><token type="LiteralStringSingle"/></rule>
+      <rule pattern="[\&#x27;&quot;\\]"><token type="LiteralStringSingle"/></rule>
+      <rule pattern="%|(\{{1,2})"><token type="LiteralStringSingle"/></rule>
+    </state>
+    <state name="strings-double">
+      <rule pattern="%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?[hlL]?[E-GXc-giorsaux%]"><token type="LiteralStringInterpol"/></rule>
+      <rule pattern="\{((\w+)((\.\w+)|(\[[^\]]+\]))*)?(\![sra])?(\:(.?[&lt;&gt;=\^])?[-+ ]?#?0?(\d+)?,?(\.\d+)?[E-GXb-gnosx%]?)?\}"><token type="LiteralStringInterpol"/></rule>
+      <rule pattern="[^\\\&#x27;&quot;%{\n]+"><token type="LiteralStringDouble"/></rule>
+      <rule pattern="[\&#x27;&quot;\\]"><token type="LiteralStringDouble"/></rule>
+      <rule pattern="%|(\{{1,2})"><token type="LiteralStringDouble"/></rule>
+    </state>
+    <state name="dqf">
+      <rule pattern="&quot;"><token type="LiteralStringDouble"/><pop depth="1"/></rule>
+      <rule pattern="\\\\|\\&quot;|\\\n"><token type="LiteralStringEscape"/></rule>
+      <rule><include state="fstrings-double"/></rule>
+    </state>
+    <state name="sqf">
+      <rule pattern="&#x27;"><token type="LiteralStringSingle"/><pop depth="1"/></rule>
+      <rule pattern="\\\\|\\&#x27;|\\\n"><token type="LiteralStringEscape"/></rule>
+      <rule><include state="fstrings-single"/></rule>
+    </state>
+    <state name="dqs">
+      <rule pattern="&quot;"><token type="LiteralStringDouble"/><pop depth="1"/></rule>
+      <rule pattern="\\\\|\\&quot;|\\\n"><token type="LiteralStringEscape"/></rule>
+      <rule><include state="strings-double"/></rule>
+    </state>
+    <state name="sqs">
+      <rule pattern="&#x27;"><token type="LiteralStringSingle"/><pop depth="1"/></rule>
+      <rule pattern="\\\\|\\&#x27;|\\\n"><token type="LiteralStringEscape"/></rule>
+      <rule><include state="strings-single"/></rule>
+    </state>
+    <state name="tdqf">
+      <rule pattern="&quot;&quot;&quot;"><token type="LiteralStringDouble"/><pop depth="1"/></rule>
+      <rule><include state="fstrings-double"/></rule>
+      <rule pattern="\n"><token type="LiteralStringDouble"/></rule>
+    </state>
+    <state name="tsqf">
+      <rule pattern="&#x27;&#x27;&#x27;"><token type="LiteralStringSingle"/><pop depth="1"/></rule>
+      <rule><include state="fstrings-single"/></rule>
+      <rule pattern="\n"><token type="LiteralStringSingle"/></rule>
+    </state>
+    <state name="tdqs">
+      <rule pattern="&quot;&quot;&quot;"><token type="LiteralStringDouble"/><pop depth="1"/></rule>
+      <rule><include state="strings-double"/></rule>
+      <rule pattern="\n"><token type="LiteralStringDouble"/></rule>
+    </state>
+    <state name="tsqs">
+      <rule pattern="&#x27;&#x27;&#x27;"><token type="LiteralStringSingle"/><pop depth="1"/></rule>
+      <rule><include state="strings-single"/></rule>
+      <rule pattern="\n"><token type="LiteralStringSingle"/></rule>
+    </state>
+  </rules>
+</lexer>
+
@@ -0,0 +1,83 @@
+
+<lexer>
+  <config>
+    <name>MoonScript</name>
+    <alias>moonscript</alias>
+    <alias>moon</alias>
+    <filename>*.moon</filename>
+    <mime_type>text/x-moonscript</mime_type>
+    <mime_type>application/x-moonscript</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="#!(.*?)$"><token type="CommentPreproc"/></rule>
+      <rule><push state="base"/></rule>
+    </state>
+    <state name="base">
+      <rule pattern="--.*$"><token type="CommentSingle"/></rule>
+      <rule pattern="(?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?"><token type="LiteralNumberFloat"/></rule>
+      <rule pattern="(?i)\d+e[+-]?\d+"><token type="LiteralNumberFloat"/></rule>
+      <rule pattern="(?i)0x[0-9a-f]*"><token type="LiteralNumberHex"/></rule>
+      <rule pattern="\d+"><token type="LiteralNumberInteger"/></rule>
+      <rule pattern="\n"><token type="TextWhitespace"/></rule>
+      <rule pattern="[^\S\n]+"><token type="Text"/></rule>
+      <rule pattern="(?s)\[(=*)\[.*?\]\1\]"><token type="LiteralString"/></rule>
+      <rule pattern="(-&gt;|=&gt;)"><token type="NameFunction"/></rule>
+      <rule pattern=":[a-zA-Z_]\w*"><token type="NameVariable"/></rule>
+      <rule pattern="(==|!=|~=|&lt;=|&gt;=|\.\.\.|\.\.|[=+\-*/%^&lt;&gt;#!.\\:])"><token type="Operator"/></rule>
+      <rule pattern="[;,]"><token type="Punctuation"/></rule>
+      <rule pattern="[\[\]{}()]"><token type="KeywordType"/></rule>
+      <rule pattern="[a-zA-Z_]\w*:"><token type="NameVariable"/></rule>
+      <rule pattern="(class|extends|if|then|super|do|with|import|export|while|elseif|return|for|in|from|when|using|else|switch|break)\b"><token type="Keyword"/></rule>
+      <rule pattern="(true|false|nil)\b"><token type="KeywordConstant"/></rule>
+      <rule pattern="(and|or|not)\b"><token type="OperatorWord"/></rule>
+      <rule pattern="(self)\b"><token type="NameBuiltinPseudo"/></rule>
+      <rule pattern="@@?([a-zA-Z_]\w*)?"><token type="NameVariableClass"/></rule>
+      <rule pattern="[A-Z]\w*"><token type="NameClass"/></rule>
+      <rule pattern="(_G|_VERSION|assert|collectgarbage|dofile|error|getmetatable|ipairs|load|loadfile|next|pairs|pcall|print|rawequal|rawget|rawlen|rawset|select|setmetatable|tonumber|tostring|type|warn|xpcall|bit32\.arshift|bit32\.band|bit32\.bnot|bit32\.bor|bit32\.btest|bit32\.bxor|bit32\.extract|bit32\.lrotate|bit32\.lshift|bit32\.replace|bit32\.rrotate|bit32\.rshift|coroutine\.close|coroutine\.create|coroutine\.isyieldable|coroutine\.resume|coroutine\.running|coroutine\.status|coroutine\.wrap|coroutine\.yield|debug\.debug|debug\.gethook|debug\.getinfo|debug\.getlocal|debug\.getmetatable|debug\.getregistry|debug\.getupvalue|debug\.getuservalue|debug\.sethook|debug\.setlocal|debug\.setmetatable|debug\.setupvalue|debug\.setuservalue|debug\.traceback|debug\.upvalueid|debug\.upvaluejoin|io\.close|io\.flush|io\.input|io\.lines|io\.open|io\.output|io\.popen|io\.read|io\.stderr|io\.stdin|io\.stdout|io\.tmpfile|io\.type|io\.write|math\.abs|math\.acos|math\.asin|math\.atan|math\.atan2|math\.ceil|math\.cos|math\.cosh|math\.deg|math\.exp|math\.floor|math\.fmod|math\.frexp|math\.huge|math\.ldexp|math\.log|math\.max|math\.maxinteger|math\.min|math\.mininteger|math\.modf|math\.pi|math\.pow|math\.rad|math\.random|math\.randomseed|math\.sin|math\.sinh|math\.sqrt|math\.tan|math\.tanh|math\.tointeger|math\.type|math\.ult|package\.config|package\.cpath|package\.loaded|package\.loadlib|package\.path|package\.preload|package\.searchers|package\.searchpath|require|os\.clock|os\.date|os\.difftime|os\.execute|os\.exit|os\.getenv|os\.remove|os\.rename|os\.setlocale|os\.time|os\.tmpname|string\.byte|string\.char|string\.dump|string\.find|string\.format|string\.gmatch|string\.gsub|string\.len|string\.lower|string\.match|string\.pack|string\.packsize|string\.rep|string\.reverse|string\.sub|string\.unpack|string\.upper|table\.concat|table\.insert|table\.move|table\.pack|table\.remove|table\.sort|table\.unpack|utf8\.char|utf8\.charpattern|utf8\.codepoint|utf8\.codes|utf8\.len|utf8\.offset)\b"><token type="NameBuiltin"/></rule>
+      <rule pattern="[A-Za-z_]\w*"><token type="Name"/></rule>
+      <rule pattern="&#x27;"><token type="LiteralStringSingle"/><combined state="stringescape" state="sqs"/></rule>
+      <rule pattern="&quot;"><token type="LiteralStringDouble"/><combined state="stringescape" state="dqs"/></rule>
+    </state>
+    <state name="stringescape">
+      <rule pattern="\\([abfnrtv\\&quot;\&#x27;]|\d{1,3})"><token type="LiteralStringEscape"/></rule>
+    </state>
+    <state name="sqs">
+      <rule pattern="&#x27;"><token type="LiteralStringSingle"/><pop depth="1"/></rule>
+      <rule pattern="[^\\&#x27;]+"><token type="LiteralString"/></rule>
+    </state>
+    <state name="dqs">
+      <rule pattern="&quot;"><token type="LiteralStringDouble"/><pop depth="1"/></rule>
+      <rule pattern="[^\\&quot;]+"><token type="LiteralString"/></rule>
+    </state>
+    <state name="ws">
+      <rule pattern="(?:--\[(?&lt;level&gt;=*)\[[\w\W]*?\](\k&lt;level&gt;)\])"><token type="CommentMultiline"/></rule>
+      <rule pattern="(?:--.*$)"><token type="CommentSingle"/></rule>
+      <rule pattern="(?:\s+)"><token type="TextWhitespace"/></rule>
+    </state>
+    <state name="varname">
+      <rule><include state="ws"/></rule>
+      <rule pattern="\.\."><token type="Operator"/><pop depth="1"/></rule>
+      <rule pattern="[.:]"><token type="Punctuation"/></rule>
+      <rule pattern="(?:[^\W\d]\w*)(?=(?:(?:--\[(?&lt;level&gt;=*)\[[\w\W]*?\](\k&lt;level&gt;)\])|(?:--.*$)|(?:\s+))*[.:])"><token type="NameProperty"/></rule>
+      <rule pattern="(?:[^\W\d]\w*)(?=(?:(?:--\[(?&lt;level&gt;=*)\[[\w\W]*?\](\k&lt;level&gt;)\])|(?:--.*$)|(?:\s+))*\()"><token type="NameFunction"/><pop depth="1"/></rule>
+      <rule pattern="(?:[^\W\d]\w*)"><token type="NameProperty"/><pop depth="1"/></rule>
+    </state>
+    <state name="funcname">
+      <rule><include state="ws"/></rule>
+      <rule pattern="[.:]"><token type="Punctuation"/></rule>
+      <rule pattern="(?:[^\W\d]\w*)(?=(?:(?:--\[(?&lt;level&gt;=*)\[[\w\W]*?\](\k&lt;level&gt;)\])|(?:--.*$)|(?:\s+))*[.:])"><token type="NameClass"/></rule>
+      <rule pattern="(?:[^\W\d]\w*)"><token type="NameFunction"/><pop depth="1"/></rule>
+      <rule pattern="\("><token type="Punctuation"/><pop depth="1"/></rule>
+    </state>
+    <state name="goto">
+      <rule><include state="ws"/></rule>
+      <rule pattern="(?:[^\W\d]\w*)"><token type="NameLabel"/><pop depth="1"/></rule>
+    </state>
+    <state name="label">
+      <rule><include state="ws"/></rule>
+      <rule pattern="::"><token type="Punctuation"/><pop depth="1"/></rule>
+      <rule pattern="(?:[^\W\d]\w*)"><token type="NameLabel"/></rule>
+    </state>
+  </rules>
+</lexer>
@@ -58,6 +58,9 @@
      <rule pattern="\$[^\s;#()]+">
        <token type="NameVariable"/>
      </rule>
+      <rule pattern="(\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b)">
+        <token type="Name"/>
+      </rule>
      <rule pattern="([a-z0-9.-]+)(:)([0-9]+)">
        <bygroups>
          <token type="Name"/>
@@ -0,0 +1,121 @@
+<lexer>
+  <config>
+    <name>Nu</name>
+    <alias>nu</alias>
+    <filename>*.nu</filename>
+    <mime_type>text/plain</mime_type>
+  </config>
+  <rules>
+    <state name="root">
+      <rule><include state="basic" /></rule>
+      <rule><include state="data" /></rule>
+    </state>
+    <state name="basic">
+      <rule
+        pattern="\b(alias|all|ansi|ansi gradient|ansi link|ansi strip|any|append|ast|attr category|attr deprecated|attr example|attr search-terms|banner|bits|bits and|bits not|bits or|bits rol|bits ror|bits shl|bits shr|bits xor|break|bytes|bytes add|bytes at|bytes build|bytes collect|bytes ends-with|bytes index-of|bytes length|bytes remove|bytes replace|bytes reverse|bytes split|bytes starts-with|cal|cd|char|chunk-by|chunks|clear|collect|columns|commandline|commandline edit|commandline get-cursor|commandline set-cursor|compact|complete|config|config env|config flatten|config nu|config reset|config use-colors|const|continue|cp|date|date format|date from-human|date humanize|date list-timezone|date now|date to-timezone|debug|debug env|debug info|debug profile|decode|decode base32|decode base32hex|decode base64|decode hex|def|default|describe|detect columns|do|drop|drop column|drop nth|du|each|each while|echo|encode|encode base32|encode base32hex|encode base64|encode hex|enumerate|error make|every|exec|exit|explain|explore|export|export alias|export const|export def|export extern|export module|export use|export-env|extern|fill|filter|find|first|flatten|for|format|format bits|format date|format duration|format filesize|format number|format pattern|from|from csv|from json|from msgpack|from msgpackz|from nuon|from ods|from ssv|from toml|from tsv|from url|from xlsx|from xml|from yaml|from yml|generate|get|glob|grid|group-by|hash|hash md5|hash sha256|headers|help|help aliases|help commands|help escapes|help externs|help modules|help operators|help pipe-and-redirect|hide|hide-env|histogram|history|history import|history session|http|http delete|http get|http head|http options|http patch|http post|http put|if|ignore|input|input list|input listen|insert|inspect|interleave|into|into binary|into bool|into cell-path|into datetime|into duration|into filesize|into float|into glob|into int|into record|into sqlite|into string|into value|is-admin|is-empty|is-not-empty|is-terminal|items|job|job flush|job id|job kill|job list|job recv|job send|job spawn|job tag|job unfreeze|join|keybindings|keybindings default|keybindings list|keybindings listen|kill|last|length|let|let-env|lines|load-env|loop|ls|match|math|math abs|math arccos|math arccosh|math arcsin|math arcsinh|math arctan|math arctanh|math avg|math ceil|math cos|math cosh|math exp|math floor|math ln|math log|math max|math median|math min|math mode|math product|math round|math sin|math sinh|math sqrt|math stddev|math sum|math tan|math tanh|math variance|merge|merge deep|metadata|metadata access|metadata set|mkdir|mktemp|module|move|mut|mv|nu-check|nu-highlight|open|overlay|overlay hide|overlay list|overlay new|overlay use|panic|par-each|parse|path|path basename|path dirname|path exists|path expand|path join|path parse|path relative-to|path self|path split|path type|plugin|plugin add|plugin list|plugin rm|plugin stop|plugin use|port|prepend|print|ps|pwd|query db|random|random binary|random bool|random chars|random dice|random float|random int|random uuid|reduce|reject|rename|return|reverse|rm|roll|roll down|roll left|roll right|roll up|rotate|run-external|save|schema|scope|scope aliases|scope commands|scope engine-stats|scope externs|scope modules|scope variables|select|seq|seq char|seq date|shuffle|skip|skip until|skip while|sleep|slice|sort|sort-by|source|source-env|split|split cell-path|split chars|split column|split list|split row|split words|start|stor|stor create|stor delete|stor export|stor import|stor insert|stor open|stor reset|stor update|str|str camel-case|str capitalize|str contains|str distance|str downcase|str ends-with|str expand|str index-of|str join|str kebab-case|str length|str pascal-case|str replace|str reverse|str screaming-snake-case|str snake-case|str starts-with|str stats|str substring|str title-case|str trim|str upcase|sys|sys cpu|sys disks|sys host|sys mem|sys net|sys temp|sys users|table|take|take until|take while|tee|term|term query|term size|timeit|to|to csv|to html|to json|to md|to msgpack|to msgpackz|to nuon|to text|to toml|to tsv|to xml|to yaml|to yml|touch|transpose|try|tutor|ulimit|uname|uniq|uniq-by|update|update cells|upsert|url|url build-query|url decode|url encode|url join|url parse|url split-query|use|values|version|version check|view|view blocks|view files|view ir|view source|view span|watch|where|which|while|whoami|window|with-env|wrap|zip)(\s*)\b"
+      ><bygroups><token type="Keyword" /><token
+            type="TextWhitespace"
+          /></bygroups></rule>
+      <rule pattern="\A#!.+\n"><token type="CommentHashbang" /></rule>
+      <rule pattern="#.*\n"><token type="CommentSingle" /></rule>
+      <rule pattern="\\[\w\W]"><token type="LiteralStringEscape" /></rule>
+      <rule pattern="(\b\w+)(\s*)(\+?=)"><bygroups><token
+            type="NameVariable"
+          /><token type="TextWhitespace" /><token
+            type="Operator"
+          /></bygroups></rule>
+      <rule pattern="[\[\]{}()=]"><token type="Operator" /></rule>
+      <rule pattern="&lt;&lt;&lt;"><token type="Operator" /></rule>
+      <rule pattern="&lt;&lt;-?\s*(\&#x27;?)\\?(\w+)[\w\W]+?\2"><token
+          type="LiteralString"
+        /></rule>
+      <rule pattern="&amp;&amp;|\|\|"><token type="Operator" /></rule>
+      <rule pattern="\$[a-zA-Z_]\w*"><token type="NameVariable" /></rule>
+    </state>
+    <state name="data">
+      <rule pattern="\$&quot;"><token type="LiteralStringDouble" /><push
+          state="interpolated_string"
+        /></rule>
+      <rule pattern="(?s)&quot;(\\.|[^&quot;\\])*&quot;"><token
+          type="LiteralStringDouble"
+        /></rule>
+      <rule pattern="&quot;"><token type="LiteralStringDouble" /><push
+          state="string"
+        /></rule>
+      <rule pattern="(?s)\$&#x27;(\\\\|\\[0-7]+|\\.|[^&#x27;\\])*&#x27;"><token
+          type="LiteralStringSingle"
+        /></rule>
+      <rule pattern="(?s)&#x27;.*?&#x27;"><token
+          type="LiteralStringSingle"
+        /></rule>
+      <rule pattern=";"><token type="Punctuation" /></rule>
+      <rule pattern="&amp;"><token type="Punctuation" /></rule>
+      <rule pattern="\|"><token type="Punctuation" /></rule>
+      <rule pattern="\s+"><token type="TextWhitespace" /></rule>
+      <rule pattern="\d+\b"><token type="LiteralNumber" /></rule>
+      <rule pattern="[^=\s\[\]{}()$&quot;\&#x27;`\\&lt;&amp;|;]+"><token
+          type="Text"
+        /></rule>
+      <rule pattern="&lt;"><token type="Text" /></rule>
+    </state>
+    <state name="string">
+      <rule pattern="&quot;"><token type="LiteralStringDouble" /><pop
+          depth="1"
+        /></rule>
+      <rule pattern="(?s)(\\\\|\\[0-7]+|\\.|[^&quot;\\$])+"><token
+          type="LiteralStringDouble"
+        /></rule>
+    </state>
+    <state name="interpolated_string">
+      <rule pattern="&quot;"><token type="LiteralStringDouble" /><pop
+          depth="1"
+        /></rule>
+      <rule pattern="\("><token type="LiteralStringInterpol" /><push
+          state="interpolation"
+        /></rule>
+      <rule pattern="(?s)(\\\\|\\[0-7]+|\\.|[^&quot;\\(])+"><token
+          type="LiteralStringDouble"
+        /></rule>
+    </state>
+    <state name="interpolation">
+      <rule pattern="\)"><token type="LiteralStringInterpol" /><pop
+          depth="1"
+        /></rule>
+      <rule><include state="root" /></rule>
+    </state>
+    <state name="curly">
+      <rule pattern="\}"><token type="LiteralStringInterpol" /><pop
+          depth="1"
+        /></rule>
+      <rule pattern=":-"><token type="Keyword" /></rule>
+      <rule pattern="\w+"><token type="NameVariable" /></rule>
+      <rule pattern="[^}:&quot;\&#x27;`$\\]+"><token
+          type="Punctuation"
+        /></rule>
+      <rule pattern=":"><token type="Punctuation" /></rule>
+      <rule><include state="root" /></rule>
+    </state>
+    <state name="paren">
+      <rule pattern="\)"><token type="Keyword" /><pop depth="1" /></rule>
+      <rule><include state="root" /></rule>
+    </state>
+    <state name="math">
+      <rule pattern="\)\)"><token type="Keyword" /><pop depth="1" /></rule>
+      <rule pattern="\*\*|\|\||&lt;&lt;|&gt;&gt;|[-+*/%^|&amp;&lt;&gt;]"><token
+          type="Operator"
+        /></rule>
+      <rule pattern="\d+#[\da-zA-Z]+"><token type="LiteralNumber" /></rule>
+      <rule pattern="\d+#(?! )"><token type="LiteralNumber" /></rule>
+      <rule pattern="0[xX][\da-fA-F]+"><token type="LiteralNumber" /></rule>
+      <rule pattern="\d+"><token type="LiteralNumber" /></rule>
+      <rule pattern="[a-zA-Z_]\w*"><token type="NameVariable" /></rule>
+      <rule><include state="root" /></rule>
+    </state>
+    <state name="backticks">
+      <rule pattern="`"><token type="LiteralStringBacktick" /><pop
+          depth="1"
+        /></rule>
+      <rule><include state="root" /></rule>
+    </state>
+  </rules>
+</lexer>
@@ -31,12 +31,9 @@
      <rule pattern="\{[$].*?\}|\{[-](NOD|EXT|OBJ).*?\}|\([*][$].*?[*]\)">
        <token type="CommentPreproc" />
      </rule>
-      <!-- Comment Single -->
-      <rule pattern="(//.*?)(\n)">
-        <bygroups>
-          <token type="CommentSingle" />
-          <token type="TextWhitespace" />
-        </bygroups>
+      <!-- Comment -->
+      <rule pattern="//.*">
+        <token type="CommentSingle" />
      </rule>
      <!-- Comment Multiline Block -->
      <rule pattern="\([*](.|\n)*?[*]\)">
@@ -41,6 +41,14 @@
      <rule pattern="\b(as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|false|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|object|of|open|private|raise|rec|sig|struct|then|to|true|try|type|value|val|virtual|when|while|with)\b">
        <token type="Keyword"/>
      </rule>
+      <rule pattern="({([a-z_]*)\|)([\s\S]+?)(?=\|\2})(\|\2})">
+        <bygroups>
+          <token type="LiteralStringAffix"/>
+          <token type="Ignore"/>
+          <token type="LiteralString"/>
+          <token type="LiteralStringAffix"/>
+        </bygroups>
+      </rule>
      <rule pattern="(~|\}|\|]|\||\{&lt;|\{|`|_|]|\[\||\[&gt;|\[&lt;|\[|\?\?|\?|&gt;\}|&gt;]|&gt;|=|&lt;-|&lt;|;;|;|:&gt;|:=|::|:|\.\.|\.|-&gt;|-\.|-|,|\+|\*|\)|\(|&amp;&amp;|&amp;|#|!=)">
        <token type="Operator"/>
      </rule>
@@ -51,6 +51,20 @@
        <rule pattern = "\#[a-zA-Z_]+\b">
            <token type = "NameDecorator"/>
        </rule>
+        <rule pattern = "^\#\+\w+\s*$">
+            <token type = "NameAttribute"/>
+        </rule>
+        <rule pattern = "^(\#\+\w+)(\s+)(\!)?([A-Za-z0-9-_!]+)(?:(,)(\!)?([A-Za-z0-9-_!]+))*\s*$">
+            <bygroups>
+                <token type = "NameAttribute"/>
+                <token type = "TextWhitespace"/>
+                <token type = "Operator"/>
+                <token type = "Name"/>
+                <token type = "Punctuation"/>
+                <token type = "Operator"/>
+                <token type = "Name"/>
+            </bygroups>
+        </rule>
        <rule pattern = "\@(\([a-zA-Z_]+\b\s*.*\)|\(?[a-zA-Z_]+\)?)">
            <token type = "NameAttribute"/>
        </rule>
@@ -0,0 +1,176 @@
+<lexer>
+  <config>
+    <name>RPGLE</name>
+    <alias>SQLRPGLE</alias>
+    <alias>RPG IV</alias>
+    <filename>*.RPGLE</filename>
+    <filename>*.rpgle</filename>
+    <filename>*.SQLRPGLE</filename>
+    <filename>*.sqlrpgle</filename>
+    <mime_type>text/x-rpgle</mime_type>
+    <mime_type>text/x-sqlrpgle</mime_type>
+    <case_insensitive>true</case_insensitive>
+    <analyse>
+      <regex pattern="^\*\*free$" score="0.9"/>
+      <regex pattern="ctl-opt" score="0.9"/>
+      <regex pattern="dcl-(ds|s|f|proc|pr|pi)" score="0.9"/>
+      <regex pattern="\*in[0-9][0-9]" score="0.5"/>
+    </analyse>
+  </config>
+  <rules>
+    <state name="root">
+      <rule pattern="\/\/.*">
+        <token type="Comment"/>
+      </rule>
+      <rule pattern="^\*\*free$">
+        <token type="CommentSpecial"/>
+      </rule>
+      <rule pattern="\*\*((ctdata|ftrans|altseq)(\s+\w+)?)?(\r|\n|\r\n)">
+        <token type="CommentSpecial"/> <!-- compile-time arrays at the end of the file, introduced by ** -->
+        <push state="compile-time-array"/>
+      </rule>
+      <rule pattern="(\*(all(g|oc|ow|sep|thread|u|x)?|altseq|alwblanknum|ascii|astfill|aut[lo]|basic|blank(s)?|caller|cancl|cdmy(0)?|change|char|cl|cmd(y|y0)?|cnowiden|cntrld|col|comp(at)?|concurrent|constants|constructor|convert|copyright|crt(bndrpg|rpgmod)|ct(data|lbdy|lspec)|cur(lib|sym)|cvt(data)?|cwiden|cymd(0)?|data|date(time)?|day(s)?|dclcase|ddm|debugio|dec|delete|det[cl]|dft|diag|dmy|dtaara|dump|end|entry(exit)?|equate|escape|eur(0)?|exact|exclude|excp|exp(dds|include)|ext(desc|dft)?|file(s)?|first|ftrans|full|gen|getin|graph(ic)?|hex|hival|hms|hours|ignore|ilerpg|in([0-9]{2}|H[1-9]|K[A-Y]|L[1-9]|LR|O[AGV]|U[1-8])?|INFO|INHERIT|INIT|INP(UT(ONLY|PACKED)?)?|INZ(OFL|SR)|ISO(0)?|JAVA|JIS|JOB(RUN(0|MIX|_DBCS|_JAVA|_MIXED)?)?|JUL|KEEP|KEY|LANGID(SHR|UNQ)|LDA|LGL|LIB(L|RCRTAUT)|LIKE(DS)?|LIST|LOCK|LONG(JOBRUN(0)?|JUL(0)?)|LOVAL|LVL[12]|MAX(DIGITS)?|MDY(0)?|MINUTES|MIXED(ASCII|EBCDIC)|MN|MODE|MODULE|MONTH(S)?|MS(ECONDS)?|M[A-Z]{3}[0-9]{4}|NATURAL|NEW|NEXT|NO(ALLOW|CHGDSLEN|COL|CVT(DATA)?|DATETIME|DEBUGIO|EXACT|EXPDDS|EXPINCLUDE|EXT|GEN|GRAPHIC|IND|INPUTPACKED|INZOFL|KEY|PASS|RMVCOMMENT|SECLVL|SHOWCPY|SHOWSKP|SRCSTMT|UNREF|VARCHAR|VARGRAPHIC|XREF|ZONED)?|NONE|NOTIFY|NULL(IND)?|OFF|OFL|OMIT|ON(EXIT|LY)?|OPCODE|OUT(PUT)?|OWNER|PARM(S)?|PCML|PDA|PEP|PGM(BDY)?|PLACE|PROC|PROGRAM|PSSR|RECORD|REQUIRE|RESDECPOS|RETVAL|RIGHTADJ|RMVCOMMENT|ROUTINE|SECLVL|SECONDS|SELF|SERIALIZE|SHOW(CPY|SKP)|SIZE|SNGLVL|SRC(MBRTXT|STMT)?|START|STATUS|STDCHARSIZE|STGMDL|STRICTKEYS|STRING|SYS|TBL|TERASPACE|TERM|THREAD_(CONCURRENT|SERIALIZE)|TOT[CL]|TRIM|UCS2|UNIQUE|UNREF|UNSET|UPDATE|USA(0)?|USE(DECEDIT)?|USER|USR(CTL|SPC)|UTF(8|16)?|V[0-9]R[0-9]M[0-9]|V[678]|VAR(CHAR|GRAPHIC|SIZE)?|WARN|XMLSAX|XML_(ATTR_(CHARS|NAME|PREDEF_REF|UCS2_REF)|CHARS|COMMENT|DOCTYPE_DECL|ENCODING_DECL|END_(ATTR|CDATA|DOCUMENT|ELEMENT)|EXCEPTION|PI_(DATA|TARGET)|PREDEF_REF|STANDALONE_DECL|START_(CDATA|DOCUMENT|ELEMENT)|UCS2_REF|UNKNOWN_(ATTR_REF|REF)|VERSION_INFO)|XREF|YEAR(S)?|YES|YMD(0)?|ZERO(S)?|ZONED|[DHMNSY]))\b">
+        <token type="Literal"/> <!-- Special values -->
+      </rule>
+      <rule pattern="\bexec\s+sql\b"> <!-- embedded SQL -->
+        <token type="Keyword"/>
+        <push state="exec-sql"/>
+      </rule>
+      <rule pattern="(%(abs|addr|alloc|bitand|bitnot|bitor|bitxor|char|charcount|check|checkr|concat|concatarr|data|date|days|dec|dech|decpos|diff|div|editc|editflt|editw|elem|eof|equal|error|fields|float|found|gen|graph|handler|hival|hours|int|inth|kds|left|len|list|lookup(lt|ge|gt|le)?|loval|lower|max|maxarr|min|minutes|minarr|months|mseconds|msg|nullind|occur|omitted|open|paddr|parms|parmnum|parser|passed|proc|range|realloc|rem|replace|right|scan|scanr|scanrpl|seconds|shtdn|size|split|sqrt|status|str|subarr|subdt|subst|target|this|time|timestamp|tlookup(lt|ge|gt|le)?|trim(l|r)?|ucs2|uns|unsh|upper|xfoot|xlate|xml|years))\b">
+        <token type="NameFunctionMagic"/> <!-- builtin functions -->
+      </rule>
+      <rule pattern="\b(ind|int|uns|(var)?char|bindec|float|packed|zoned|time(stamp)?|date|pointer|clob|blob|(var)?graph|object|(var)?ucs2)\b">
+        <token type="KeywordType"/> <!-- variable types -->
+      </rule>
+      <rule pattern="\b(dcl\-(ds|pi|proc|pr|[csf])|end\-(ds|pi|proc|pr)|ctl\-opt|const|value|to|downto|not)\b">
+        <token type="Keyword"/> <!-- Syntax keywords -->
+      </rule>
+      <rule pattern="\b(acq|add|adddur|alloc|and(gt|lt|eq|ne|ge|le)?|begsr|bitoff|biton|cab(gt|lt|eq|ne|ge|le)?|call(b|p)?|cas(gt|lt|eq|ne|ge|le)?|cat|chain|check|checkr|clear|close|commit|comp|data-gen|data-into|dealloc|define|delete|div|do((u|w)(gt|lt|eq|ne|ge|le)?)?|dsply|dump|else(if)?|end(cs|do|for|if|mon|sl|sr)?|eval(r|-corr)?|except|exfmt|exsr|extrct|feod|for(-each)?|force|goto|if(gt|lt|eq|ne|ge|le)?|in|iter|kfld|klist|leave(sr)?|lookup|m(hh|hl|lh|ll)zo|monitor|move[al]?|mult|mvr|next|occur|on-(error|excp|exit)|open|or(gt|lt|eq|ne|ge|le)?|other|out|parm|plist|post|read(c|e|p|pe)?|realloc|rel|reset|return|rolbk|scan|select|set(gt|ll|off|on)|shtdn|snd-msg|sorta|sqrt|sub(dur|st)?|tag|test[bnz]?|time|unlock|update|when(gt|lt|eq|ne|ge|le)?|when-i[ns]|write|xfoot|slate|xml-(into|sax)|z-(add|sub))\b">
+        <token type="Keyword"/> <!-- Operation codes -->
+      </rule>
+      <rule pattern="\b(alloc|altseq|ccsid|copy(nest|right)|cursym|dat(edit|fmt)|debug|dec(edit|prec)|dftname|expropts|extbinint|fltdiv|formsalign|ftrans|intprec|(no)?main|openopt|thread|timfmt|actgrp|alwnull|aut|bnddir|cvtopt|dateyy|dftactgrp|enbpfrcol|fixnbr|genlvl|indent|langid|optimize|option|pgminfo|prfdta|reqprexp|strseq|stgmdl|text|truncnbr|usrprf)\b">
+        <token type="KeywordReserved"/> <!-- ctl-opt (former H spec) -->
+      </rule>
+      <rule pattern="\b(alias|block|commit|charcount|data|datfmt|devid|disk|ext(desc|file|ind|mbr)|form(len|ofl)|handler|ignore|include|in(dds|fds|fsr)|keyed|keyloc|likefile|maxdev|oflind|pass|pgmname|plist|prefix|printer|prtctl|qualified|rafdata|recno|rename|save(ds|ind)|seq|sfile|sln|special|static|template|timfmt|usage|usropn|workstn)\b">
+        <token type="KeywordReserved"/> <!-- dcl-f (former F spec) -->
+      </rule>
+      <rule pattern="\b(\*(yes|no|natural|stdcharsize|(no)?cvt|ext(desc)?|inu[1-8]|char|only|file|noind|ext|compat|input|output|update|delete))\b">
+        <token type="Literal"/> <!-- F spec special values-->
+      </rule>
+      <rule pattern="\b(alias|align|alt|altseq|ascend|based|ccsid|class|const|ctdata|datfmt|descend|dim|dtaara|export|ext(fld|fmt|name|pgm|proc)?|fromfile|import|inz|len|like(ds|file|rec)?|noopt|nullind|occurs|opdesc|options|overlay|overload|packeven|perrcd|pos|prefix|procptr|psds|qualified|reqproto|rtnparm|samepos|static|template|timfmt|tofile|value|varying)\b">
+        <token type="KeywordReserved"/> <!-- Other keywords (not operation codes nor ctl-opt/H spec) -> mostly used with variables -->
+      </rule>
+      <rule pattern="(/(copy|define|eject|else|elseif|end-exec|end-free|endif|eof|exec|free|if|include|restore|set|space|title|undefine))\b">
+        <token type="CommentPreproc"/> <!-- Preprocessor instructions -->
+      </rule>
+      <rule pattern="\b([0-9]+((\.[0-9]?)(e[+-][0-9]+)?)?)\b">
+        <token type="LiteralNumber"/>
+      </rule>
+      <rule pattern="\bx'[0-9a-fA-F]*'">
+        <token type="LiteralString"/> <!-- Hex string -->
+      </rule>
+      <rule pattern="'(''|[^'])*'">
+        <token type="LiteralString"/>
+      </rule>
+      <rule pattern="[,:;\(\)\.]+">
+        <token type="Punctuation"/>
+      </rule>
+      <rule pattern="((\*\*)|(&lt;&gt;)|=|([&lt;&gt;\+\-\*\/]=?))+">
+        <token type="Operator"/> <!-- Arithmetic operators -->
+      </rule>
+      <rule pattern="\s">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern=".">
+        <token type="Text"/>
+      </rule>
+    </state>
+    <state name="exec-sql">
+      <rule pattern=';'>
+        <token type="Punctuation"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="\s+">
+        <token type="TextWhitespace"/>
+      </rule>
+      <rule pattern="--.*\n?">
+        <token type="CommentSingle"/>
+      </rule>
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push state="sql-multiline-comments"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <push state="sql-string"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <push state="sql-double-string"/>
+      </rule>
+      <rule pattern="(DATETIME_INTERVAL_PRECISION|PARAMETER_SPECIFIC_CATALOG|PARAMATER_ORDINAL_POSITION|USER_DEFINED_TYPE_CATALOG|PARAMATER_SPECIFIC_SCHEMA|TRANSACTIONS_ROLLED_BACK|USER_DEFINED_TYPE_SCHEMA|PARAMETER_SPECIFIC_NAME|DATETIME_INTERVAL_CODE|TRANSACTIONS_COMMITTED|USER_DEFINED_TYPE_NAME|CHARACTER_SET_CATALOG|DYNAMIC_FUNCTION_CODE|COMMAND_FUNCTION_CODE|RETURNED_OCTET_LENGTH|MESSAGE_OCTET_LENGTH|CHARACTER_SET_SCHEMA|CONSTRAINT_CATALOG|TRANSACTION_ACTIVE|CHARACTER_SET_NAME|CURRENT_TIMESTAMP|CONSTRAINT_SCHEMA|COLLATION_CATALOG|RETURNED_SQLSTATE|DYNAMIC_FUNCTION|CONDITION_NUMBER|CHARACTER_LENGTH|COMMAND_FUNCTION|COLLATION_SCHEMA|CHARACTERISTICS|TRIGGER_CATALOG|CONNECTION_NAME|SUBCLASS_ORIGIN|RETURNED_LENGTH|TIMEZONE_MINUTE|CONSTRAINT_NAME|ROUTINE_CATALOG|TRIGGER_SCHEMA|ROUTINE_SCHEMA|LOCALTIMESTAMP|IMPLEMENTATION|PARAMATER_NAME|MESSAGE_LENGTH|PARAMETER_MODE|COLLATION_NAME|TIMEZONE_HOUR|SPECIFIC_NAME|DETERMINISTIC|CORRESPONTING|AUTHORIZATION|INSTANTIABLE|CURRENT_TIME|CURRENT_USER|ROUTINE_NAME|NOCREATEUSER|MESSAGE_TEXT|SQLEXCEPTION|CATALOG_NAME|SESSION_USER|CLASS_ORIGIN|CURRENT_ROLE|SPECIFICTYPE|SERIALIZABLE|CURRENT_DATE|OCTET_LENGTH|CURRENT_PATH|TRIGGER_NAME|CHAR_LENGTH|SYSTEM_USER|REFERENCING|UNENCRYPTED|COLUMN_NAME|SQLWARNINIG|DIAGNOSTICS|CURSOR_NAME|SERVER_NAME|INSENSITIVE|SCHEMA_NAME|UNCOMMITTED|TRANSACTION|CONSTRUCTOR|LANCOMPILER|CARDINALITY|CONSTRAINTS|TRANSLATION|CHECKPOINT|CONSTRAINT|CONNECTION|PRIVILEGES|COMPLETION|CONVERSION|DELIMITERS|TABLE_NAME|INDITCATOR|INITIALIZE|DESCRIPTOR|REPEATABLE|CREATEUSER|DEFERRABLE|DESTRUCTOR|PROCEDURAL|DICTIONARY|DISCONNECT|TRANSFORMS|KEY_MEMBER|BIT_LENGTH|ASYMMETRIC|ASSIGNMENT|ASENSITIVE|OVERRIDING|PARAMETERS|REFERENCES|ORDINALITY|NOCREATEDB|STATISTICS|DEALLOCATE|SAVE_POINT|RECURSIVE|STRUCTURE|SUBSTRING|IMMEDIATE|GENERATED|SYMMETRIC|STATEMENT|INCREMENT|IMMUTABLE|INCLUDING|COMMITTED|TEMPORARY|INITIALLY|TERMINATE|PRECISION|DELIMITER|TIMESTAMP|INTERSECT|ISOLATION|TRANSFORM|TRANSLATE|ROW_COUNT|ASSERTION|PARAMETER|EXCLUSIVE|LOCALTIME|VALIDATOR|AGGREGATE|EXCLUDING|SENSITIVE|EXCEPTION|ENCRYPTED|OPERATION|HIERARCHY|COLLATION|PROCEDURE|CONTINUE|ENCODING|MINVALUE|SPECIFIC|ABSOLUTE|SECURITY|WHENEVER|EXISTING|VOLATILE|MAXVALUE|EXTERNAL|NULLABLE|VARIABLE|SQLERROR|DISTINCT|DISPATCH|END-EXEC|LOCATION|ALLOCATE|OVERLAPS|UNLISTEN|ROLLBACK|TRUNCATE|DESCRIBE|SQLSTATE|BACKWARD|FUNCTION|LANGUAGE|KEY_TYPE|CASCADED|POSITION|TRAILING|DEFERRED|RELATIVE|DEFAULTS|COALSECE|PREORDER|GROUPING|MODIFIES|INHERITS|PRESERVE|DATABASE|RESTRICT|IDENTITY|TEMPLATE|NATIONAL|CONTAINS|CREATEDB|IMPLICIT|OPERATOR|CONVERT|CURRENT|CONNECT|RECHECK|PRIMARY|STORAGE|DECLARE|DEFAULT|HANDLER|COLLATE|PREPARE|REINDEX|GRANTED|CHECKED|POSTFIX|REPLACE|INSTEAD|CATALOG|RESTART|INVOKER|PLACING|PENDANT|DEFINED|ITERATE|PARTIAL|CASCADE|BREADTH|GENERAL|TRIGGER|SESSION|BETWEEN|DEFINER|LATERAL|LEADING|RETURNS|TRUSTED|UNKNOWN|FORWARD|UNNAMED|OVERLAY|FORTRAN|ANALYZE|OPTIONS|ANALYSE|FOREIGN|ROUTINE|LOCATOR|DESTROY|SUBLIST|VERBOSE|EXTRACT|NOTNULL|EXPLAIN|VERSION|SQLCODE|EXECUTE|NOTHING|DYNAMIC|WITHOUT|SIMILAR|NATURAL|COMMENT|CLUSTER|PASCAL|SOURCE|EQUALS|CALLED|ESCAPE|EXCEPT|SELECT|ISNULL|DOMAIN|SEARCH|SCROLL|SIMPLE|BITVAR|MINUTE|EXISTS|SCHEMA|ATOMIC|METHOD|NOTIFY|ACCESS|UNIQUE|ROLLUP|NULLIF|OBJECT|STABLE|COLUMN|REVOKE|OFFSET|COMMIT|MODIFY|FREEZE|DELETE|RETURN|RESULT|UNNEST|OPTION|GLOBAL|VALUES|RENAME|SYSTEM|STATIC|UPDATE|OUTPUT|LISTEN|STDOUT|STRICT|PUBLIC|IGNORE|PREFIX|SECOND|CREATE|LENGTH|BEFORE|HAVING|INSERT|VACUUM|CURSOR|ELSIF|USING|ALTER|STYPE|CYCLE|LARGE|INPUT|CROSS|INOUT|INNER|INFIX|INDEX|LEVEL|USAGE|ILIKE|VALID|OWNER|GRANT|READS|UPPER|LIMIT|OUTER|STDIN|SYSID|GROUP|ALIAS|ORDER|UNTIL|LOCAL|RESET|START|COUNT|LOWER|TABLE| TEMP|PRIOR|AFTER|STATE|ADMIN|RIGHT|COBOL|FOUND|MATCH|FORCE|ABORT|FIRST|FINAL|CLOSE|DEREF|FETCH|WHERE|FALSE|SCALE|BEGIN|CLASS|TOAST|WRITE|NCLOB|NCHAR|CHECK|CHAIN|SPACE|NAMES|EVERY|MUMPS|CACHE|UNION|UNDER|SETOF|MONTH|SHARE|SCOPE|TREAT|SHOW|SIZE|SOME|SETS|SELF|ELSE|EACH|DROP|TYPE|FROM|RULE|DESC|ROWS|ZONE|ROLE|TRUE|FREE|FULL|GOTO|TRIM|HOLD|HOST|DATA|READ|INTO|USER|JOIN|CUBE|LAST|LEFT|LESS|LIKE|LOAD|LOCK|OPEN|COPY|ONLY|OIDS|VIEW|WHEN|THAN|THEN|NULL|NONE|WITH|WORK|NEXT|YEAR|MODE|CAST|CASE|MOVE|CALL|MORE|BOTH|EXEC|CLOB|OUT|MOD|ARE|SUM|DAY|GET|AVG|NEW|SQL|ABS|MIN|ASC|END|ROW|NOT|FOR|ANY|PLI|MAX|REF|MAP|ADA|KEY|AND|ADD|ALL|OLD|OFF|PAD|SET|OR|ON|TO|IS|OF|IN|IF|GO|AS|DO|AT|NO|BY|C|G)\b">
+        <token type="Keyword"/>
+      </rule>
+      <rule pattern="(CHARACTER|SMALLINT|INTERVAL|DECIMAL|SERIAL8|VARYING|BOOLEAN|VARCHAR|INTEGER|NUMERIC|SERIAL|BINARY|BIGINT|NUMBER|FLOAT|ARRAY|TEXT|REAL|INT8|DATE|CHAR|BLOB|DEC|BIT|INT)\b">
+        <token type="NameBuiltin"/>
+      </rule>
+      <rule pattern="[+*/&lt;&gt;=~!@#%^&amp;|`?-]">
+        <token type="Operator"/>
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger"/>
+      </rule>
+      <rule pattern="[a-z_][\w$]*">
+        <token type="Name"/>
+      </rule>
+      <rule pattern="[;:()\[\],.]">
+        <token type="Punctuation"/>
+      </rule>
+    </state>
+    <state name="sql-multiline-comments">
+      <rule pattern="/\*">
+        <token type="CommentMultiline"/>
+        <push state="sql-multiline-comments"/>
+      </rule>
+      <rule pattern="\*/">
+        <token type="CommentMultiline"/>
+        <pop depth="1"/>
+      </rule>
+      <rule pattern="[^/*]+">
+        <token type="CommentMultiline"/>
+      </rule>
+      <rule pattern="[/*]">
+        <token type="CommentMultiline"/>
+      </rule>
+    </state>
+    <state name="sql-string">
+      <rule pattern="[^&#39;]+">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="&#39;&#39;">
+        <token type="LiteralStringSingle"/>
+      </rule>
+      <rule pattern="&#39;">
+        <token type="LiteralStringSingle"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="sql-double-string">
+      <rule pattern="[^&#34;]+">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;&#34;">
+        <token type="LiteralStringDouble"/>
+      </rule>
+      <rule pattern="&#34;">
+        <token type="LiteralStringDouble"/>
+        <pop depth="1"/>
+      </rule>
+    </state>
+    <state name="compile-time-array">
+      <rule pattern="[^\r\n]*(\r|\n|\r\n)?">
+        <token type="CommentSpecial"/>
+      </rule>
+    </state>
+  </rules>
+</lexer>
@@ -1,3 +1,4 @@
+<?xml version="1.0" ?>
 <lexer>
  <config>
    <name>Sed</name>
@@ -10,19 +11,82 @@
  </config>
  <rules>
    <state name="root">
-      <rule pattern="\s+"><token type="TextWhitespace"/></rule>
-      <rule pattern="#.*$"><token type="CommentSingle"/></rule>
-      <rule pattern="[0-9]+"><token type="LiteralNumberInteger"/></rule>
-      <rule pattern="\$"><token type="Operator"/></rule>
-      <rule pattern="[{};,!]"><token type="Punctuation"/></rule>
-      <rule pattern="[dDFgGhHlnNpPqQxz=]"><token type="Keyword"/></rule>
-      <rule pattern="([berRtTvwW:])([^;\n]*)"><bygroups><token type="Keyword"/><token type="LiteralStringSingle"/></bygroups></rule>
-      <rule pattern="([aci])((?:.*?\\\n)*(?:.*?[^\\]$))"><bygroups><token type="Keyword"/><token type="LiteralStringDouble"/></bygroups></rule>
-      <rule pattern="([qQ])([0-9]*)"><bygroups><token type="Keyword"/><token type="LiteralNumberInteger"/></bygroups></rule>
-      <rule pattern="(/)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(/)"><bygroups><token type="Punctuation"/><token type="LiteralStringRegex"/><token type="Punctuation"/></bygroups></rule>
-      <rule pattern="(\\(.))((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)"><bygroups><token type="Punctuation"/>None<token type="LiteralStringRegex"/><token type="Punctuation"/></bygroups></rule>
-      <rule pattern="(y)(.)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)"><bygroups><token type="Keyword"/><token type="Punctuation"/><token type="LiteralStringSingle"/><token type="Punctuation"/><token type="LiteralStringSingle"/><token type="Punctuation"/></bygroups></rule>
-      <rule pattern="(s)(.)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)((?:[gpeIiMm]|[0-9])*)"><bygroups><token type="Keyword"/><token type="Punctuation"/><token type="LiteralStringRegex"/><token type="Punctuation"/><token type="LiteralStringSingle"/><token type="Punctuation"/><token type="Keyword"/></bygroups></rule>
+      <rule pattern="\s+">
+        <token type="TextWhitespace" />
+      </rule>
+      <rule pattern="#.*$">
+        <token type="CommentSingle" />
+      </rule>
+      <rule pattern="[0-9]+">
+        <token type="LiteralNumberInteger" />
+      </rule>
+      <rule pattern="\$">
+        <token type="Operator" />
+      </rule>
+      <rule pattern="[{};,!]">
+        <token type="Punctuation" />
+      </rule>
+      <rule pattern="[dDFgGhHlnNpPqQxz=]">
+        <token type="Keyword" />
+      </rule>
+      <rule pattern="([berRtTvwW:])([^;\n]*)">
+        <bygroups>
+          <token type="Keyword" />
+          <token type="LiteralStringSingle" />
+        </bygroups>
+      </rule>
+      <rule pattern="([aci])((?:.*?\\\n)*(?:.*?[^\\]$))">
+        <bygroups>
+          <token type="Keyword" />
+          <token type="LiteralStringDouble" />
+        </bygroups>
+      </rule>
+      <rule pattern="([qQ])([0-9]*)">
+        <bygroups>
+          <token type="Keyword" />
+          <token type="LiteralNumberInteger" />
+        </bygroups>
+      </rule>
+      <rule pattern="(/)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(/)">
+        <bygroups>
+          <token type="Punctuation" />
+          <token type="LiteralStringRegex" />
+          <token type="Punctuation" />
+        </bygroups>
+      </rule>
+      <rule pattern="(\\(.))((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)">
+        <bygroups>
+          <token type="Punctuation" />
+          <token type="Text" />
+          <token type="LiteralStringRegex" />
+          <token type="Punctuation" />
+        </bygroups>
+      </rule>
+      <rule
+        pattern="(y)(.)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)"
+      >
+        <bygroups>
+          <token type="Keyword" />
+          <token type="Punctuation" />
+          <token type="LiteralStringSingle" />
+          <token type="Punctuation" />
+          <token type="LiteralStringSingle" />
+          <token type="Punctuation" />
+        </bygroups>
+      </rule>
+      <rule
+        pattern="(s)(.)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)((?:(?:\\[^\n]|[^\\])*?\\\n)*?(?:\\.|[^\\])*?)(\2)((?:[gpeIiMm]|[0-9])*)"
+      >
+        <bygroups>
+          <token type="Keyword" />
+          <token type="Punctuation" />
+          <token type="LiteralStringRegex" />
+          <token type="Punctuation" />
+          <token type="LiteralStringSingle" />
+          <token type="Punctuation" />
+          <token type="Keyword" />
+        </bygroups>
+      </rule>
    </state>
  </rules>
 </lexer>
@@ -157,8 +157,20 @@
      <rule pattern="(continue|returns|storage|memory|delete|return|throw|break|catch|while|else|from|new|try|for|if|is|as|do|in|_)\b">
        <token type="Keyword"/>
      </rule>
-      <rule pattern="assembly\b">
-        <token type="Keyword"/>
+      <rule pattern="(assembly)(\s+\()(.+)(\)\s+{)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+          <token type="LiteralString"/>
+          <token type="Text"/>
+        </bygroups>
+        <push state="assembly"/>
+      </rule>
+      <rule pattern="(assembly)(\s+{)">
+        <bygroups>
+          <token type="Keyword"/>
+          <token type="Text"/>
+        </bygroups>
        <push state="assembly"/>
      </rule>
      <rule pattern="(contract|interface|enum|event|struct)(\s+)([a-zA-Z_]\w*)">
@@ -235,7 +247,7 @@
        <token type="Punctuation"/>
        <pop depth="1"/>
      </rule>
-      <rule pattern="[(),]">
+      <rule pattern="[(),.]">
        <token type="Punctuation"/>
      </rule>
      <rule pattern=":=|=:">
@@ -276,4 +288,4 @@
      </rule>
    </state>
  </rules>
-</lexer>
+</lexer>
@@ -3,138 +3,147 @@
    <name>Terraform</name>
    <alias>terraform</alias>
    <alias>tf</alias>
+    <alias>hcl</alias>
    <filename>*.tf</filename>
+    <filename>*.hcl</filename>
    <mime_type>application/x-tf</mime_type>
    <mime_type>application/x-terraform</mime_type>
  </config>
  <rules>
    <state name="string">
      <rule pattern="&#34;">
-        <token type="LiteralStringDouble"/>
-        <pop depth="1"/>
-      </rule>
-      <rule pattern="\\\\">
-        <token type="LiteralStringDouble"/>
+        <token type="LiteralStringDouble" />
+        <pop depth="1" />
      </rule>
      <rule pattern="\\\\&#34;">
-        <token type="LiteralStringDouble"/>
-      </rule>
-      <rule pattern="\$\{">
-        <token type="LiteralStringInterpol"/>
-        <push state="interp-inside"/>
-      </rule>
-      <rule pattern="\$">
-        <token type="LiteralStringDouble"/>
+        <token type="LiteralStringDouble" />
      </rule>
      <rule pattern="[^&#34;\\\\$]+">
-        <token type="LiteralStringDouble"/>
+        <token type="LiteralStringDouble" />
+      </rule>
+      <rule pattern="[^\\\\&#34;$]+">
+        <token type="LiteralStringDouble" />
+      </rule>
+      <rule pattern="\$\{">
+        <token type="LiteralStringInterpol" />
+        <push state="interp-inside" />
      </rule>
    </state>
    <state name="interp-inside">
      <rule pattern="\}">
-        <token type="LiteralStringInterpol"/>
-        <pop depth="1"/>
+        <token type="LiteralStringInterpol" />
+        <pop depth="1" />
      </rule>
      <rule>
-        <include state="root"/>
+        <include state="root" />
      </rule>
    </state>
    <state name="root">
      <rule pattern="[\[\](),.{}]">
-        <token type="Punctuation"/>
-      </rule>
-      <rule pattern="-?[0-9]+">
-        <token type="LiteralNumber"/>
-      </rule>
-      <rule pattern="=&gt;">
-        <token type="Punctuation"/>
-      </rule>
-      <rule pattern="(false|true)\b">
-        <token type="KeywordConstant"/>
-      </rule>
-      <rule pattern="/(?s)\*(((?!\*/).)*)\*/">
-        <token type="CommentMultiline"/>
-      </rule>
-      <rule pattern="\s*(#|//).*\n">
-        <token type="CommentSingle"/>
-      </rule>
-      <rule pattern="([a-zA-Z]\w*)(\s*)(=(?!&gt;))">
-        <bygroups>
-          <token type="NameAttribute"/>
-          <token type="Text"/>
-          <token type="Text"/>
-        </bygroups>
-      </rule>
-      <rule pattern="^\s*(provisioner|variable|resource|provider|module|output|data)\b">
-        <token type="KeywordReserved"/>
-      </rule>
-      <rule pattern="(for|in)\b">
-        <token type="Keyword"/>
-      </rule>
-      <rule pattern="(module|count|data|each|var)">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="(parseint|signum|floor|ceil|log|max|min|abs|pow)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="(trimsuffix|formatlist|trimprefix|trimspace|regexall|replace|indent|strrev|format|substr|chomp|split|title|regex|lower|upper|trim|join)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="[^.](setintersection|coalescelist|setsubtract|setproduct|matchkeys|chunklist|transpose|contains|distinct|coalesce|setunion|reverse|flatten|element|compact|lookup|length|concat|values|zipmap|range|merge|slice|index|list|sort|keys|map)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="[^.](base64decode|base64encode|base64gzip|jsondecode|jsonencode|yamldecode|yamlencode|csvdecode|urlencode)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="(templatefile|filebase64|fileexists|pathexpand|basename|abspath|fileset|dirname|file)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="(formatdate|timestamp|timeadd)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="(filebase64sha256|filebase64sha512|base64sha512|base64sha256|filesha256|rsadecrypt|filesha512|filesha1|filemd5|uuidv5|bcrypt|sha256|sha512|sha1|uuid|md5)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="(cidrnetmask|cidrsubnet|cidrhost)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="(tostring|tonumber|tobool|tolist|tomap|toset|can|try)\b">
-        <token type="NameBuiltin"/>
-      </rule>
-      <rule pattern="=(?!&gt;)|\+|-|\*|\/|:|!|%|&gt;|&lt;(?!&lt;)|&gt;=|&lt;=|==|!=|&amp;&amp;|\||\?">
-        <token type="Operator"/>
-      </rule>
-      <rule pattern="\n|\s+|\\\n">
-        <token type="Text"/>
-      </rule>
-      <rule pattern="[a-zA-Z]\w*">
-        <token type="NameOther"/>
+        <token type="Punctuation" />
      </rule>
      <rule pattern="&#34;">
-        <token type="LiteralStringDouble"/>
-        <push state="string"/>
+        <token type="LiteralStringDouble" />
+        <push state="string" />
+      </rule>
+      <rule pattern="-?[0-9]+">
+        <token type="LiteralNumber" />
+      </rule>
+      <rule pattern="=&gt;">
+        <token type="Punctuation" />
+      </rule>
+      <rule pattern="(false|true)\b">
+        <token type="KeywordConstant" />
+      </rule>
+      <rule pattern="/(?s)\*(((?!\*/).)*)\*/">
+        <token type="CommentMultiline" />
+      </rule>
+      <rule pattern="\s*(#|//).*\n">
+        <token type="CommentSingle" />
+      </rule>
+      <rule pattern="(?!\s*)(variable)(\s*)">
+        <bygroups>
+          <token type="Name" />
+          <token type="Text" />
+        </bygroups>
+      </rule>
+      <rule pattern="^(provisioner|variable|resource|provider|module|output|data)(?!\.)\b">
+        <token type="KeywordReserved" />
+      </rule>
+      <rule pattern="(for|in)\b">
+        <token type="Keyword" />
+      </rule>
+      <rule pattern="(module|count|data|each|var)\b">
+        <token type="NameBuiltin" />
+      </rule>
+      <rule pattern="(parseint|signum|floor|ceil|log|max|min|abs|pow)\b">
+        <token type="NameBuiltin" />
+      </rule>
+      <rule
+        pattern="(trimsuffix|formatlist|trimprefix|trimspace|regexall|replace|indent|strrev|format|substr|chomp|split|title|regex|lower|upper|trim|join)\b"
+      >
+        <token type="NameBuiltin" />
+      </rule>
+      <rule
+        pattern="[^.](setintersection|coalescelist|setsubtract|setproduct|matchkeys|chunklist|transpose|contains|distinct|coalesce|setunion|reverse|flatten|element|compact|lookup|length|concat|values|zipmap|range|merge|slice|index|list|sort|keys|map)\b"
+      >
+        <token type="NameBuiltin" />
+      </rule>
+      <rule
+        pattern="[^.](base64decode|base64encode|base64gzip|jsondecode|jsonencode|yamldecode|yamlencode|csvdecode|urlencode)\b"
+      >
+        <token type="NameBuiltin" />
+      </rule>
+      <rule pattern="(templatefile|filebase64|fileexists|pathexpand|basename|abspath|fileset|dirname|file)\b">
+        <token type="NameBuiltin" />
+      </rule>
+      <rule pattern="(formatdate|timestamp|timeadd)\b">
+        <token type="NameBuiltin" />
+      </rule>
+      <rule
+        pattern="(filebase64sha256|filebase64sha512|base64sha512|base64sha256|filesha256|rsadecrypt|filesha512|filesha1|filemd5|uuidv5|bcrypt|sha256|sha512|sha1|uuid|md5)\b"
+      >
+        <token type="NameBuiltin" />
+      </rule>
+      <rule pattern="(cidrnetmask|cidrsubnet|cidrhost)\b">
+        <token type="NameBuiltin" />
+      </rule>
+      <rule pattern="(tostring|tonumber|tobool|tolist|tomap|toset|can|try)\b">
+        <token type="NameBuiltin" />
+      </rule>
+      <rule pattern="(^|[^.\w])(name|x|default|type|description|value)(_[a-zA-Z]\w*)*">
+        <token type="NameAttribute" />
+      </rule>
+      <rule pattern="=(?!&gt;)|\+|-|\*|\/|:|!|%|&gt;|&lt;(?!&lt;)|&gt;=|&lt;=|==|!=|&amp;&amp;|\||\?">
+        <token type="Operator" />
+      </rule>
+      <rule pattern="\n|\s+|\\\n">
+        <token type="Text" />
+      </rule>
+      <rule pattern="[a-zA-Z]\w*">
+        <token type="NameOther" />
      </rule>
      <rule pattern="(?s)(&lt;&lt;-?)(\w+)(\n\s*(?:(?!\2).)*\s*\n\s*)(\2)">
        <bygroups>
-          <token type="Operator"/>
-          <token type="Operator"/>
-          <token type="LiteralString"/>
-          <token type="Operator"/>
+          <token type="Operator" />
+          <token type="Operator" />
+          <token type="LiteralString" />
+          <token type="Operator" />
        </bygroups>
      </rule>
    </state>
    <state name="declaration">
      <rule pattern="(\s*)(&#34;(?:\\\\|\\&#34;|[^&#34;])*&#34;)(\s*)">
        <bygroups>
-          <token type="Text"/>
-          <token type="NameVariable"/>
-          <token type="Text"/>
+          <token type="Text" />
+          <token type="NameAttribute" />
+          <token type="Text" />
        </bygroups>
      </rule>
      <rule pattern="\{">
-        <token type="Punctuation"/>
-        <pop depth="1"/>
+        <token type="Punctuation" />
+        <pop depth="1" />
      </rule>
    </state>
  </rules>
-</lexer>
+</lexer>
@@ -5,6 +5,7 @@
    <filename>*.toml</filename>
    <filename>Pipfile</filename>
    <filename>poetry.lock</filename>
+    <filename>uv.lock</filename>
    <mime_type>text/x-toml</mime_type>
  </config>
  <rules>
@@ -15,280 +15,287 @@
  <rules>
    <state name="expression">
      <rule pattern="{">
-        <token type="Punctuation"/>
-        <push/>
+        <token type="Punctuation" />
+        <push />
      </rule>
      <rule pattern="}">
-        <token type="Punctuation"/>
-        <pop depth="1"/>
+        <token type="Punctuation" />
+        <pop depth="1" />
      </rule>
      <rule>
-        <include state="root"/>
+        <include state="root" />
      </rule>
    </state>
    <state name="jsx">
      <rule pattern="(&lt;)(/?)(&gt;)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="Punctuation"/>
-          <token type="Punctuation"/>
+          <token type="Punctuation" />
+          <token type="Punctuation" />
+          <token type="Punctuation" />
        </bygroups>
      </rule>
      <rule pattern="(&lt;)([\w\.]+)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="NameTag"/>
+          <token type="Punctuation" />
+          <token type="NameTag" />
        </bygroups>
-        <push state="tag"/>
+        <push state="tag" />
      </rule>
      <rule pattern="(&lt;)(/)([\w\.]*)(&gt;)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="Punctuation"/>
-          <token type="NameTag"/>
-          <token type="Punctuation"/>
+          <token type="Punctuation" />
+          <token type="Punctuation" />
+          <token type="NameTag" />
+          <token type="Punctuation" />
        </bygroups>
      </rule>
    </state>
    <state name="tag">
      <rule>
-        <include state="jsx"/>
+        <include state="jsx" />
      </rule>
      <rule pattern=",">
-        <token type="Punctuation"/>
+        <token type="Punctuation" />
      </rule>
      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
-        <token type="LiteralStringDouble"/>
+        <token type="LiteralStringDouble" />
      </rule>
      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
-        <token type="LiteralStringSingle"/>
+        <token type="LiteralStringSingle" />
      </rule>
      <rule pattern="`">
-        <token type="LiteralStringBacktick"/>
-        <push state="interp"/>
+        <token type="LiteralStringBacktick" />
+        <push state="interp" />
      </rule>
      <rule>
-        <include state="commentsandwhitespace"/>
+        <include state="commentsandwhitespace" />
      </rule>
      <rule pattern="\s+">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="([\w-]+\s*)(=)(\s*)">
        <bygroups>
-          <token type="NameAttribute"/>
-          <token type="Operator"/>
-          <token type="Text"/>
+          <token type="NameAttribute" />
+          <token type="Operator" />
+          <token type="Text" />
        </bygroups>
-        <push state="attr"/>
+        <push state="attr" />
      </rule>
      <rule pattern="[{}]+">
-        <token type="Punctuation"/>
+        <token type="Punctuation" />
      </rule>
      <rule pattern="[\w\.]+">
-        <token type="NameAttribute"/>
+        <token type="NameAttribute" />
      </rule>
      <rule pattern="(/?)(\s*)(&gt;)">
        <bygroups>
-          <token type="Punctuation"/>
-          <token type="Text"/>
-          <token type="Punctuation"/>
+          <token type="Punctuation" />
+          <token type="Text" />
+          <token type="Punctuation" />
        </bygroups>
-        <pop depth="1"/>
+        <pop depth="1" />
      </rule>
    </state>
   <state name="comment">
      <rule pattern="[^-]+">
-        <token type="Comment"/>
+        <token type="Comment" />
      </rule>
      <rule pattern="--&gt;">
-        <token type="Comment"/>
-        <pop depth="1"/>
+        <token type="Comment" />
+        <pop depth="1" />
      </rule>
      <rule pattern="-">
-        <token type="Comment"/>
+        <token type="Comment" />
      </rule>
    </state>
    <state name="commentsandwhitespace">
      <rule pattern="\s+">
-        <token type="Text"/>
+        <token type="Text" />
      </rule>
      <rule pattern="&lt;!--">
-        <token type="Comment"/>
-        <push state="comment"/>
+        <token type="Comment" />
+        <push state="comment" />
      </rule>
      <rule pattern="//.*?\n">
-        <token type="CommentSingle"/>
+        <token type="CommentSingle" />
      </rule>
      <rule pattern="/\*.*?\*/">
-        <token type="CommentMultiline"/>
+        <token type="CommentMultiline" />
      </rule>
    </state>
    <state name="badregex">
      <rule pattern="\n">
-        <token type="Text"/>
-        <pop depth="1"/>
+        <token type="Text" />
+        <pop depth="1" />
      </rule>
    </state>
    <state name="interp">
      <rule pattern="`">
-        <token type="LiteralStringBacktick"/>
-        <pop depth="1"/>
+        <token type="LiteralStringBacktick" />
+        <pop depth="1" />
      </rule>
      <rule pattern="\\\\">
-        <token type="LiteralStringBacktick"/>
+        <token type="LiteralStringBacktick" />
      </rule>
      <rule pattern="\\`">
-        <token type="LiteralStringBacktick"/>
+        <token type="LiteralStringBacktick" />
      </rule>
      <rule pattern="\$\{">
-        <token type="LiteralStringInterpol"/>
-        <push state="interp-inside"/>
+        <token type="LiteralStringInterpol" />
+        <push state="interp-inside" />
      </rule>
      <rule pattern="\$">
-        <token type="LiteralStringBacktick"/>
+        <token type="LiteralStringBacktick" />
      </rule>
      <rule pattern="[^`\\$]+">
-        <token type="LiteralStringBacktick"/>
+        <token type="LiteralStringBacktick" />
      </rule>
    </state>
    <state name="attr">
      <rule pattern="{">
-        <token type="Punctuation"/>
-        <push state="expression"/>
+        <token type="Punctuation" />
+        <push state="expression" />
      </rule>
      <rule pattern="&#34;.*?&#34;">
-        <token type="LiteralString"/>
-        <pop depth="1"/>
+        <token type="LiteralString" />
+        <pop depth="1" />
      </rule>
      <rule pattern="&#39;.*?&#39;">
-        <token type="LiteralString"/>
-        <pop depth="1"/>
+        <token type="LiteralString" />
+        <pop depth="1" />
      </rule>
      <rule>
-        <pop depth="1"/>
+        <pop depth="1" />
      </rule>
    </state>
    <state name="interp-inside">
      <rule pattern="\}">
-        <token type="LiteralStringInterpol"/>
-        <pop depth="1"/>
+        <token type="LiteralStringInterpol" />
+        <pop depth="1" />
      </rule>
      <rule>
-        <include state="root"/>
+        <include state="root" />
      </rule>
    </state>
    <state name="slashstartsregex">
      <rule>
-        <include state="commentsandwhitespace"/>
+        <include state="commentsandwhitespace" />
      </rule>
      <rule pattern="/(\\.|[^[/\\\n]|\[(\\.|[^\]\\\n])*])+/([gim]+\b|\B)">
-        <token type="LiteralStringRegex"/>
-        <pop depth="1"/>
+        <token type="LiteralStringRegex" />
+        <pop depth="1" />
      </rule>
      <rule pattern="(?=/)">
-        <token type="Text"/>
-        <push state="badregex"/>
+        <token type="Text" />
+        <push state="badregex" />
      </rule>
      <rule>
-        <pop depth="1"/>
+        <pop depth="1" />
      </rule>
    </state>
    <state name="root">
      <rule>
-        <include state="jsx"/>
+        <include state="jsx" />
      </rule>
      <rule pattern="^(?=\s|/|&lt;!--)">
-        <token type="Text"/>
-        <push state="slashstartsregex"/>
+        <token type="Text" />
+        <push state="slashstartsregex" />
      </rule>
      <rule>
-        <include state="commentsandwhitespace"/>
+        <include state="commentsandwhitespace" />
      </rule>
      <rule pattern="\+\+|--|~|&amp;&amp;|\?|:|\|\||\\(?=\n)|(&lt;&lt;|&gt;&gt;&gt;?|==?|!=?|[-&lt;&gt;+*%&amp;|^/])=?">
-        <token type="Operator"/>
-        <push state="slashstartsregex"/>
+        <token type="Operator" />
+        <push state="slashstartsregex" />
      </rule>
      <rule pattern="[{(\[;,]">
-        <token type="Punctuation"/>
-        <push state="slashstartsregex"/>
+        <token type="Punctuation" />
+        <push state="slashstartsregex" />
      </rule>
      <rule pattern="[})\].]">
-        <token type="Punctuation"/>
+        <token type="Punctuation" />
      </rule>
-      <rule pattern="(for|in|of|while|do|break|return|yield|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|keyof|asserts|is|infer|await|void|this)\b">
-        <token type="Keyword"/>
-        <push state="slashstartsregex"/>
+      <rule
+        pattern="(for|in|of|while|do|break|return|yield|continue|switch|case|default|if|else|throw|try|catch|finally|new|delete|typeof|instanceof|keyof|asserts|is|infer|await|void|this)\b"
+      >
+        <token type="Keyword" />
+        <push state="slashstartsregex" />
      </rule>
      <rule pattern="(var|let|with|function)\b">
-        <token type="KeywordDeclaration"/>
-        <push state="slashstartsregex"/>
+        <token type="KeywordDeclaration" />
+        <push state="slashstartsregex" />
      </rule>
-      <rule pattern="(abstract|async|boolean|class|const|debugger|enum|export|extends|from|get|global|goto|implements|import|interface|namespace|package|private|protected|public|readonly|require|set|static|super|type)\b">
-        <token type="KeywordReserved"/>
+      <rule
+        pattern="(abstract|async|boolean|class|const|debugger|enum|export|extends|from|get|global|goto|implements|import|interface|namespace|package|private|protected|public|readonly|require|set|static|super|type)\b"
+      >
+        <token type="KeywordReserved" />
      </rule>
      <rule pattern="(true|false|null|NaN|Infinity|undefined)\b">
-        <token type="KeywordConstant"/>
+        <token type="KeywordConstant" />
      </rule>
-      <rule pattern="(Array|Boolean|Date|Error|Function|Math|Number|Object|Packages|RegExp|String|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|isNaN|parseFloat|parseInt|document|this|window)\b">
-        <token type="NameBuiltin"/>
+      <rule
+        pattern="(Array|Boolean|Date|Error|Function|Math|Number|Object|Packages|RegExp|String|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|isNaN|parseFloat|parseInt|document|this|window)\b"
+      >
+        <token type="NameBuiltin" />
      </rule>
      <rule pattern="\b(module)(\s+)(&quot;[\w\./@]+&quot;)(\s+)">
        <bygroups>
-          <token type="KeywordReserved"/>
-          <token type="Text"/>
-          <token type="NameOther"/>
-          <token type="Text"/>
+          <token type="KeywordReserved" />
+          <token type="Text" />
+          <token type="NameOther" />
+          <token type="Text" />
        </bygroups>
-        <push state="slashstartsregex"/>
+        <push state="slashstartsregex" />
      </rule>
      <rule pattern="\b(string|bool|number|any|never|object|symbol|unique|unknown|bigint)\b">
-        <token type="KeywordType"/>
+        <token type="KeywordType" />
      </rule>
      <rule pattern="\b(constructor|declare|interface|as)\b">
-        <token type="KeywordReserved"/>
+        <token type="KeywordReserved" />
      </rule>
      <rule pattern="(super)(\s*)(\([\w,?.$\s]+\s*\))">
        <bygroups>
-          <token type="KeywordReserved"/>
-          <token type="Text"/>
+          <token type="KeywordReserved" />
+          <token type="TextWhitespace" />
+          <token type="Text" />
        </bygroups>
-        <push state="slashstartsregex"/>
+        <push state="slashstartsregex" />
      </rule>
      <rule pattern="([a-zA-Z_?.$][\w?.$]*)\(\) \{">
-        <token type="NameOther"/>
-        <push state="slashstartsregex"/>
+        <token type="NameOther" />
+        <push state="slashstartsregex" />
      </rule>
      <rule pattern="([\w?.$][\w?.$]*)(\s*:\s*)([\w?.$][\w?.$]*)">
        <bygroups>
-          <token type="NameOther"/>
-          <token type="Text"/>
-          <token type="KeywordType"/>
+          <token type="NameOther" />
+          <token type="Text" />
+          <token type="KeywordType" />
        </bygroups>
      </rule>
      <rule pattern="[$a-zA-Z_]\w*">
-        <token type="NameOther"/>
+        <token type="NameOther" />
      </rule>
      <rule pattern="[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?">
-        <token type="LiteralNumberFloat"/>
+        <token type="LiteralNumberFloat" />
      </rule>
      <rule pattern="0x[0-9a-fA-F]+">
-        <token type="LiteralNumberHex"/>
+        <token type="LiteralNumberHex" />
      </rule>
      <rule pattern="[0-9]+">
-        <token type="LiteralNumberInteger"/>
+        <token type="LiteralNumberInteger" />
      </rule>
      <rule pattern="&#34;(\\\\|\\&#34;|[^&#34;])*&#34;">
-        <token type="LiteralStringDouble"/>
+        <token type="LiteralStringDouble" />
      </rule>
      <rule pattern="&#39;(\\\\|\\&#39;|[^&#39;])*&#39;">
-        <token type="LiteralStringSingle"/>
+        <token type="LiteralStringSingle" />
      </rule>
      <rule pattern="`">
-        <token type="LiteralStringBacktick"/>
-        <push state="interp"/>
+        <token type="LiteralStringBacktick" />
+        <push state="interp" />
      </rule>
      <rule pattern="@\w+">
-        <token type="KeywordDeclaration"/>
+        <token type="KeywordDeclaration" />
      </rule>
    </state>
  </rules>
@@ -64,25 +64,13 @@
      <rule pattern="(-)([\w]+)">
        <token type="NameTag"/>
      </rule>
-      <rule pattern="(@[\w]+)(=&#34;[\S]+&#34;)(&gt;)">
+      <rule pattern="(@[\w.]+)(=&#34;.*?&#34;)?(\/?&gt;|\s)">
        <bygroups>
          <token type="NameTag"/>
          <token type="LiteralString"/>
          <token type="Punctuation"/>
        </bygroups>
      </rule>
-      <rule pattern="(@[\w]+)(=&#34;[\S]+&#34;)">
-        <bygroups>
-          <token type="NameTag"/>
-          <token type="LiteralString"/>
-        </bygroups>
-      </rule>
-      <rule pattern="(@[\S]+)(=&#34;[\S]+&#34;)">
-        <bygroups>
-          <token type="NameTag"/>
-          <token type="LiteralString"/>
-        </bygroups>
-      </rule>
      <rule pattern="(:[\S]+)(=)(&#34;[\S]+&#34;)">
        <bygroups>
          <token type="NameTag"/>
@@ -96,16 +84,7 @@
      <rule pattern="(v-b-[\S]+)">
        <token type="NameTag"/>
      </rule>
-      <rule pattern="(v-[\w]+)(=&#34;.+)([:][\w]+)(=&#34;[\w]+&#34;)(&gt;)">
-        <bygroups>
-          <token type="NameTag"/>
-          <token type="LiteralString"/>
-          <token type="NameTag"/>
-          <token type="LiteralString"/>
-          <token type="Punctuation"/>
-        </bygroups>
-      </rule>
-      <rule pattern="(v-[\w]+)(=)(&#34;[\S ]+&#34;)(&gt;|\s)">
+      <rule pattern="(v-[\w-]+)(=)(&#34;[\S ]+&#34;)(\/?&gt;|\s)">
        <bygroups>
          <token type="NameTag"/>
          <token type="Operator"/>
@@ -113,19 +92,28 @@
          <token type="Punctuation"/>
        </bygroups>
      </rule>
-      <rule pattern="(v-[\w]+)(&gt;)">
+      <rule pattern="(v-[\w-]+)(\/?&gt;|\s)">
        <bygroups>
          <token type="NameTag"/>
          <token type="Punctuation"/>
        </bygroups>
      </rule>
-      <rule pattern="(v-[\w]+)(=&#34;.+&#34;)(&gt;)">
+      <rule pattern="(v-[\w-]+)(=&#34;.+&#34;)(\/?&gt;|\s)">
        <bygroups>
          <token type="NameTag"/>
          <token type="LiteralString"/>
          <token type="Punctuation"/>
        </bygroups>
      </rule>
+      <rule pattern="(v-[\w-]+)(=&#34;.+)([:][\w]+)(=&#34;[\w]+&#34;)(\/?&gt;|\s)">
+        <bygroups>
+          <token type="NameTag"/>
+          <token type="LiteralString"/>
+          <token type="NameTag"/>
+          <token type="LiteralString"/>
+          <token type="Punctuation"/>
+        </bygroups>
+      </rule>
      <rule pattern="(&lt;)([\w]+)">
        <bygroups>
          <token type="Punctuation"/>
@@ -3,6 +3,7 @@
    <name>Zig</name>
    <alias>zig</alias>
    <filename>*.zig</filename>
+    <filename>*.zon</filename>
    <mime_type>text/zig</mime_type>
  </config>
  <rules>
@@ -76,6 +77,9 @@
      <rule pattern="(?:_?[0-9])+">
        <token type="LiteralNumberInteger"/>
      </rule>
+      <rule pattern="\b[A-Za-z_]\w*(?=\s*\()">
+        <token type="NameFunction"/>
+      </rule>
      <rule pattern="@[a-zA-Z_]\w*">
        <token type="NameBuiltin"/>
      </rule>
@@ -0,0 +1,37 @@
+package lexers
+
+import (
+	. "github.com/alecthomas/chroma/v2" // nolint
+)
+
+// Gemtext lexer.
+var Gemtext = Register(MustNewLexer(
+	&Config{
+		Name:      "Gemtext",
+		Aliases:   []string{"gemtext", "gmi", "gmni", "gemini"},
+		Filenames: []string{"*.gmi", "*.gmni", "*.gemini"},
+		MimeTypes: []string{"text/gemini"},
+	},
+	gemtextRules,
+))
+
+func gemtextRules() Rules {
+	return Rules{
+		"root": {
+			{`^(#[^#].+\r?\n)`, ByGroups(GenericHeading), nil},
+			{`^(#{2,3}.+\r?\n)`, ByGroups(GenericSubheading), nil},
+			{`^(\* )(.+\r?\n)`, ByGroups(Keyword, Text), nil},
+			{`^(>)(.+\r?\n)`, ByGroups(Keyword, GenericEmph), nil},
+			{"^(```\\r?\\n)([\\w\\W]*?)(^```)(.+\\r?\\n)?", ByGroups(String, Text, String, Comment), nil},
+			{
+				"^(```)(\\w+)(\\r?\\n)([\\w\\W]*?)(^```)(.+\\r?\\n)?",
+				UsingByGroup(2, 4, String, String, String, Text, String, Comment),
+				nil,
+			},
+			{"^(```)(.+\\r?\\n)([\\w\\W]*?)(^```)(.+\\r?\\n)?", ByGroups(String, String, Text, String, Comment), nil},
+			{`^(=>)(\s*)([^\s]+)(\s*)$`, ByGroups(Keyword, Text, NameAttribute, Text), nil},
+			{`^(=>)(\s*)([^\s]+)(\s+)(.+)$`, ByGroups(Keyword, Text, NameAttribute, Text, NameTag), nil},
+			{`(.|(?:\r?\n))`, ByGroups(Text), nil},
+		},
+	}
+}
@@ -28,10 +28,10 @@ var Go = Register(MustNewLexer(
 func goRules() Rules {
 	return Rules{
 		"root": {
-			{`\n`, Text, nil},
-			{`\s+`, Text, nil},
-			{`\\\n`, Text, nil},
-			{`//[^\n\r]*`, CommentSingle, nil},
+			{`\n`, TextWhitespace, nil},
+			{`\s+`, TextWhitespace, nil},
+			{`//[^\s][^\n\r]*`, CommentPreproc, nil},
+			{`//\s+[^\n\r]*`, CommentSingle, nil},
 			{`/(\\\n)?[*](.|\n)*?[*](\\\n)?/`, CommentMultiline, nil},
 			{`(import|package)\b`, KeywordNamespace, nil},
 			{`(var|func|struct|map|chan|type|interface|const)\b`, KeywordDeclaration, nil},
@@ -29,6 +29,12 @@ func Names(withAliases bool) []string {
 	return GlobalLexerRegistry.Names(withAliases)
 }

+// Aliases of all the lexers, and skip those lexers who do not have any aliases,
+// or show their name instead
+func Aliases(skipWithoutAliases bool) []string {
+	return GlobalLexerRegistry.Aliases(skipWithoutAliases)
+}
+
 // Get a Lexer by name, alias or file extension.
 //
 // Note that this if there isn't an exact match on name or alias, this will
@@ -5,7 +5,7 @@ import (
 )

 // Markdown lexer.
-var Markdown = Register(DelegatingLexer(HTML, MustNewLexer(
+var Markdown = Register(MustNewLexer(
 	&Config{
 		Name:      "markdown",
 		Aliases:   []string{"md", "mkd"},
@@ -13,7 +13,7 @@ var Markdown = Register(DelegatingLexer(HTML, MustNewLexer(
 		MimeTypes: []string{"text/x-markdown"},
 	},
 	markdownRules,
-)))
+))

 func markdownRules() Rules {
 	return Rules{
@@ -40,7 +40,7 @@ func markdownRules() Rules {
 			{"`[^`]+`", LiteralStringBacktick, nil},
 			{`[@#][\w/:]+`, NameEntity, nil},
 			{`(!?\[)([^]]+)(\])(\()([^)]+)(\))`, ByGroups(Text, NameTag, Text, Text, NameAttribute, Text), nil},
-			{`.|\n`, Other, nil},
+			{`.|\n`, Text, nil},
 		},
 	}
 }
@@ -2,6 +2,7 @@ package lexers

 import (
 	"regexp"
+	"slices"
 	"strings"
 	"unicode/utf8"

@@ -1318,21 +1319,11 @@ func indexAt(str []rune, substr []rune, pos int) int {
 	return idx
 }

-// Tells if an array of string contains a string
-func contains(s []string, e string) bool {
-	for _, value := range s {
-		if value == e {
-			return true
-		}
-	}
-	return false
-}
-
 type rulePosition int

 const (
-	topRule    rulePosition = 0
-	bottomRule              = -1
+	topRule rulePosition = 0 - iota
+	bottomRule
 )

 type ruleMakingConfig struct {
@@ -1625,15 +1616,15 @@ func quote(groups []string, state *LexerState) Iterator {
 	var tokenState string

 	switch {
-	case keyword == "qq" || contains(tokenStates, "qq"):
+	case keyword == "qq" || slices.Contains(tokenStates, "qq"):
 		tokenState = "qq"
-	case adverbsStr == "ww" || contains(tokenStates, "ww"):
+	case adverbsStr == "ww" || slices.Contains(tokenStates, "ww"):
 		tokenState = "ww"
-	case contains(tokenStates, "Q-closure") && contains(tokenStates, "Q-variable"):
+	case slices.Contains(tokenStates, "Q-closure") && slices.Contains(tokenStates, "Q-variable"):
 		tokenState = "qq"
-	case contains(tokenStates, "Q-closure"):
+	case slices.Contains(tokenStates, "Q-closure"):
 		tokenState = "Q-closure"
-	case contains(tokenStates, "Q-variable"):
+	case slices.Contains(tokenStates, "Q-variable"):
 		tokenState = "Q-variable"
 	default:
 		tokenState = "Q"
@@ -1,322 +1,605 @@
 Generated with:

-  g 'class.*RegexLexer' | pawk --strict -F: '"pygments.lexers.%s.%s" % (f[0].split(".")[0], f[2].split()[1].split("(")[0])' > lexers.txt
+  import pygments.lexers  # v2.19.1
+
+  for x in pygments.lexers.get_all_lexers(plugins=False):
+      if len(x[1]):
+          lexer = pygments.lexers.get_lexer_by_name(x[1][0])
+          print(f"{lexer.__module__}.{lexer.__class__.__name__}")

-kotlin:
-  invalid unicode escape sequences
-  FIXED: Have to disable wide Unicode characters in unistring.py

-pygments.lexers.ambient.AmbientTalkLexer
-pygments.lexers.ampl.AmplLexer
-pygments.lexers.actionscript.ActionScriptLexer
 pygments.lexers.actionscript.ActionScript3Lexer
+pygments.lexers.actionscript.ActionScriptLexer
 pygments.lexers.actionscript.MxmlLexer
+pygments.lexers.ada.AdaLexer
+pygments.lexers.algebra.BCLexer
+pygments.lexers.algebra.GAPConsoleLexer
 pygments.lexers.algebra.GAPLexer
 pygments.lexers.algebra.MathematicaLexer
 pygments.lexers.algebra.MuPADLexer
-pygments.lexers.algebra.BCLexer
+pygments.lexers.ambient.AmbientTalkLexer
+pygments.lexers.amdgpu.AMDGPULexer
+pygments.lexers.ampl.AmplLexer
+pygments.lexers.apdlexer.apdlexer
 pygments.lexers.apl.APLLexer
-pygments.lexers.bibtex.BibTeXLexer
-pygments.lexers.bibtex.BSTLexer
-pygments.lexers.basic.BlitzMaxLexer
-pygments.lexers.basic.BlitzBasicLexer
-pygments.lexers.basic.MonkeyLexer
-pygments.lexers.basic.CbmBasicV2Lexer
-pygments.lexers.basic.QBasicLexer
-pygments.lexers.automation.AutohotkeyLexer
-pygments.lexers.automation.AutoItLexer
-pygments.lexers.archetype.AtomsLexer
-pygments.lexers.c_like.ClayLexer
-pygments.lexers.c_like.ValaLexer
+pygments.lexers.archetype.AdlLexer
+pygments.lexers.archetype.CadlLexer
+pygments.lexers.archetype.OdinLexer
+pygments.lexers.arrow.ArrowLexer
+pygments.lexers.arturo.ArturoLexer
+pygments.lexers.asc.AscLexer
+pygments.lexers.asm.Ca65Lexer
+pygments.lexers.asm.CObjdumpLexer
+pygments.lexers.asm.CppObjdumpLexer
+pygments.lexers.asm.Dasm16Lexer
+pygments.lexers.asm.DObjdumpLexer
 pygments.lexers.asm.GasLexer
-pygments.lexers.asm.ObjdumpLexer
 pygments.lexers.asm.HsailLexer
 pygments.lexers.asm.LlvmLexer
+pygments.lexers.asm.LlvmMirBodyLexer
+pygments.lexers.asm.LlvmMirLexer
 pygments.lexers.asm.NasmLexer
+pygments.lexers.asm.NasmObjdumpLexer
+pygments.lexers.asm.ObjdumpLexer
 pygments.lexers.asm.TasmLexer
-pygments.lexers.asm.Ca65Lexer
-pygments.lexers.business.CobolLexer
+pygments.lexers.asn1.Asn1Lexer
+pygments.lexers.automation.AutohotkeyLexer
+pygments.lexers.automation.AutoItLexer
+pygments.lexers.bare.BareLexer
+pygments.lexers.basic.BBCBasicLexer
+pygments.lexers.basic.BlitzBasicLexer
+pygments.lexers.basic.BlitzMaxLexer
+pygments.lexers.basic.CbmBasicV2Lexer
+pygments.lexers.basic.MonkeyLexer
+pygments.lexers.basic.QBasicLexer
+pygments.lexers.basic.VBScriptLexer
+pygments.lexers.bdd.BddLexer
+pygments.lexers.berry.BerryLexer
+pygments.lexers.bibtex.BibTeXLexer
+pygments.lexers.bibtex.BSTLexer
+pygments.lexers.blueprint.BlueprintLexer
+pygments.lexers.boa.BoaLexer
+pygments.lexers.bqn.BQNLexer
 pygments.lexers.business.ABAPLexer
-pygments.lexers.business.OpenEdgeLexer
+pygments.lexers.business.CobolFreeformatLexer
+pygments.lexers.business.CobolLexer
 pygments.lexers.business.GoodDataCLLexer
 pygments.lexers.business.MaqlLexer
+pygments.lexers.business.OpenEdgeLexer
+pygments.lexers.c_cpp.CLexer
+pygments.lexers.c_cpp.CppLexer
+pygments.lexers.c_like.ArduinoLexer
+pygments.lexers.c_like.CharmciLexer
+pygments.lexers.c_like.ClayLexer
+pygments.lexers.c_like.CudaLexer
+pygments.lexers.c_like.ECLexer
+pygments.lexers.c_like.MqlLexer
+pygments.lexers.c_like.NesCLexer
+pygments.lexers.c_like.OmgIdlLexer
+pygments.lexers.c_like.PikeLexer
+pygments.lexers.c_like.PromelaLexer
+pygments.lexers.c_like.SwigLexer
+pygments.lexers.c_like.ValaLexer
 pygments.lexers.capnproto.CapnProtoLexer
+pygments.lexers.carbon.CarbonLexer
+pygments.lexers.cddl.CddlLexer
 pygments.lexers.chapel.ChapelLexer
 pygments.lexers.clean.CleanLexer
-pygments.lexers.c_cpp.CFamilyLexer
-pygments.lexers.console.VCTreeStatusLexer
-pygments.lexers.console.PyPyLogLexer
-pygments.lexers.csound.CsoundLexer
-pygments.lexers.csound.CsoundDocumentLexer
-pygments.lexers.csound.CsoundDocumentLexer
-pygments.lexers.crystal.CrystalLexer
-pygments.lexers.dalvik.SmaliLexer
-pygments.lexers.css.CssLexer
-pygments.lexers.css.SassLexer
-pygments.lexers.css.ScssLexer
-pygments.lexers.configs.IniLexer
-pygments.lexers.configs.RegeditLexer
-pygments.lexers.configs.PropertiesLexer
-pygments.lexers.configs.KconfigLexer
-pygments.lexers.configs.Cfengine3Lexer
+pygments.lexers.codeql.CodeQLLexer
+pygments.lexers.comal.Comal80Lexer
 pygments.lexers.configs.ApacheConfLexer
-pygments.lexers.configs.SquidConfLexer
-pygments.lexers.configs.NginxConfLexer
-pygments.lexers.configs.LighttpdConfLexer
+pygments.lexers.configs.AugeasLexer
+pygments.lexers.configs.Cfengine3Lexer
+pygments.lexers.configs.DesktopLexer
 pygments.lexers.configs.DockerLexer
-pygments.lexers.configs.TerraformLexer
+pygments.lexers.configs.IniLexer
+pygments.lexers.configs.KconfigLexer
+pygments.lexers.configs.LighttpdConfLexer
+pygments.lexers.configs.NestedTextLexer
+pygments.lexers.configs.NginxConfLexer
+pygments.lexers.configs.PacmanConfLexer
+pygments.lexers.configs.PkgConfigLexer
+pygments.lexers.configs.PropertiesLexer
+pygments.lexers.configs.RegeditLexer
+pygments.lexers.configs.SingularityLexer
+pygments.lexers.configs.SquidConfLexer
+pygments.lexers.configs.SystemdLexer
 pygments.lexers.configs.TermcapLexer
 pygments.lexers.configs.TerminfoLexer
-pygments.lexers.configs.PkgConfigLexer
-pygments.lexers.configs.PacmanConfLexer
-pygments.lexers.data.YamlLexer
+pygments.lexers.configs.TerraformLexer
+pygments.lexers.configs.TOMLLexer
+pygments.lexers.configs.UnixConfigLexer
+pygments.lexers.console.PyPyLogLexer
+pygments.lexers.console.VCTreeStatusLexer
+pygments.lexers.cplint.CplintLexer
+pygments.lexers.crystal.CrystalLexer
+pygments.lexers.csound.CsoundDocumentLexer
+pygments.lexers.csound.CsoundOrchestraLexer
+pygments.lexers.csound.CsoundScoreLexer
+pygments.lexers.css.CssLexer
+pygments.lexers.css.LessCssLexer
+pygments.lexers.css.SassLexer
+pygments.lexers.css.ScssLexer
+pygments.lexers.d.CrocLexer
+pygments.lexers.d.DLexer
+pygments.lexers.d.MiniDLexer
+pygments.lexers.dalvik.SmaliLexer
+pygments.lexers.data.JsonLdLexer
 pygments.lexers.data.JsonLexer
-pygments.lexers.diff.DiffLexer
+pygments.lexers.data.YamlLexer
+pygments.lexers.dax.DaxLexer
+pygments.lexers.devicetree.DevicetreeLexer
 pygments.lexers.diff.DarcsPatchLexer
+pygments.lexers.diff.DiffLexer
 pygments.lexers.diff.WDiffLexer
-pygments.lexers.dotnet.CSharpLexer
-pygments.lexers.dotnet.NemerleLexer
+pygments.lexers.dns.DnsZoneLexer
 pygments.lexers.dotnet.BooLexer
-pygments.lexers.dotnet.VbNetLexer
-pygments.lexers.dotnet.GenericAspxLexer
+pygments.lexers.dotnet.CSharpAspxLexer
+pygments.lexers.dotnet.CSharpLexer
 pygments.lexers.dotnet.FSharpLexer
+pygments.lexers.dotnet.NemerleLexer
+pygments.lexers.dotnet.VbNetAspxLexer
+pygments.lexers.dotnet.VbNetLexer
+pygments.lexers.dotnet.XppLexer
+pygments.lexers.dsls.AlloyLexer
+pygments.lexers.dsls.CrmshLexer
+pygments.lexers.dsls.FlatlineLexer
+pygments.lexers.dsls.MscgenLexer
+pygments.lexers.dsls.PanLexer
+pygments.lexers.dsls.ProtoBufLexer
+pygments.lexers.dsls.PuppetLexer
+pygments.lexers.dsls.RslLexer
+pygments.lexers.dsls.SnowballLexer
+pygments.lexers.dsls.ThriftLexer
+pygments.lexers.dsls.VGLLexer
+pygments.lexers.dsls.ZeekLexer
+pygments.lexers.dylan.DylanConsoleLexer
 pygments.lexers.dylan.DylanLexer
 pygments.lexers.dylan.DylanLidLexer
 pygments.lexers.ecl.ECLLexer
 pygments.lexers.eiffel.EiffelLexer
-pygments.lexers.dsls.ProtoBufLexer
-pygments.lexers.dsls.ThriftLexer
-pygments.lexers.dsls.BroLexer
-pygments.lexers.dsls.PuppetLexer
-pygments.lexers.dsls.RslLexer
-pygments.lexers.dsls.MscgenLexer
-pygments.lexers.dsls.VGLLexer
-pygments.lexers.dsls.AlloyLexer
-pygments.lexers.dsls.PanLexer
-pygments.lexers.dsls.CrmshLexer
-pygments.lexers.dsls.FlatlineLexer
-pygments.lexers.dsls.SnowballLexer
 pygments.lexers.elm.ElmLexer
-pygments.lexers.erlang.ErlangLexer
+pygments.lexers.elpi.ElpiLexer
+pygments.lexers.email.EmailLexer
+pygments.lexers.erlang.ElixirConsoleLexer
 pygments.lexers.erlang.ElixirLexer
-pygments.lexers.ezhil.EzhilLexer
-pygments.lexers.esoteric.BrainfuckLexer
+pygments.lexers.erlang.ErlangLexer
+pygments.lexers.erlang.ErlangShellLexer
+pygments.lexers.esoteric.AheuiLexer
 pygments.lexers.esoteric.BefungeLexer
+pygments.lexers.esoteric.BrainfuckLexer
 pygments.lexers.esoteric.CAmkESLexer
 pygments.lexers.esoteric.CapDLLexer
 pygments.lexers.esoteric.RedcodeLexer
-pygments.lexers.esoteric.AheuiLexer
+pygments.lexers.ezhil.EzhilLexer
 pygments.lexers.factor.FactorLexer
 pygments.lexers.fantom.FantomLexer
 pygments.lexers.felix.FelixLexer
+pygments.lexers.fift.FiftLexer
+pygments.lexers.floscript.FloScriptLexer
 pygments.lexers.forth.ForthLexer
-pygments.lexers.fortran.FortranLexer
 pygments.lexers.fortran.FortranFixedLexer
-pygments.lexers.go.GoLexer
+pygments.lexers.fortran.FortranLexer
 pygments.lexers.foxpro.FoxProLexer
-pygments.lexers.graph.CypherLexer
-pygments.lexers.grammar_notation.BnfLexer
+pygments.lexers.freefem.FreeFemLexer
+pygments.lexers.func.FuncLexer
+pygments.lexers.futhark.FutharkLexer
+pygments.lexers.gcodelexer.GcodeLexer
+pygments.lexers.gdscript.GDScriptLexer
+pygments.lexers.gleam.GleamLexer
+pygments.lexers.go.GoLexer
 pygments.lexers.grammar_notation.AbnfLexer
+pygments.lexers.grammar_notation.BnfLexer
 pygments.lexers.grammar_notation.JsgfLexer
-pygments.lexers.graphics.GLShaderLexer
-pygments.lexers.graphics.PostScriptLexer
+pygments.lexers.grammar_notation.PegLexer
+pygments.lexers.graph.CypherLexer
 pygments.lexers.graphics.AsymptoteLexer
+pygments.lexers.graphics.GLShaderLexer
 pygments.lexers.graphics.GnuplotLexer
+pygments.lexers.graphics.HLSLShaderLexer
+pygments.lexers.graphics.PostScriptLexer
 pygments.lexers.graphics.PovrayLexer
-pygments.lexers.hexdump.HexdumpLexer
-pygments.lexers.haskell.HaskellLexer
-pygments.lexers.haskell.IdrisLexer
+pygments.lexers.graphql.GraphQLLexer
+pygments.lexers.graphviz.GraphvizLexer
+pygments.lexers.gsql.GSQLLexer
+pygments.lexers.hare.HareLexer
 pygments.lexers.haskell.AgdaLexer
 pygments.lexers.haskell.CryptolLexer
+pygments.lexers.haskell.HaskellLexer
+pygments.lexers.haskell.HspecLexer
+pygments.lexers.haskell.IdrisLexer
 pygments.lexers.haskell.KokaLexer
+pygments.lexers.haskell.LiterateAgdaLexer
+pygments.lexers.haskell.LiterateCryptolLexer
+pygments.lexers.haskell.LiterateHaskellLexer
+pygments.lexers.haskell.LiterateIdrisLexer
 pygments.lexers.haxe.HaxeLexer
 pygments.lexers.haxe.HxmlLexer
-pygments.lexers.hdl.VerilogLexer
 pygments.lexers.hdl.SystemVerilogLexer
+pygments.lexers.hdl.VerilogLexer
 pygments.lexers.hdl.VhdlLexer
-pygments.lexers.idl.IDLLexer
-pygments.lexers.inferno.LimboLexer
-pygments.lexers.igor.IgorLexer
-pygments.lexers.html.HtmlLexer
+pygments.lexers.hexdump.HexdumpLexer
 pygments.lexers.html.DtdLexer
-pygments.lexers.html.XmlLexer
 pygments.lexers.html.HamlLexer
-pygments.lexers.html.ScamlLexer
+pygments.lexers.html.HtmlLexer
 pygments.lexers.html.PugLexer
+pygments.lexers.html.ScamlLexer
+pygments.lexers.html.UrlEncodedLexer
+pygments.lexers.html.VueLexer
+pygments.lexers.html.XmlLexer
+pygments.lexers.html.XsltLexer
+pygments.lexers.idl.IDLLexer
+pygments.lexers.igor.IgorLexer
+pygments.lexers.inferno.LimboLexer
+pygments.lexers.installers.DebianControlLexer
+pygments.lexers.installers.DebianSourcesLexer
 pygments.lexers.installers.NSISLexer
 pygments.lexers.installers.RPMSpecLexer
 pygments.lexers.installers.SourcesListLexer
-pygments.lexers.installers.DebianControlLexer
-pygments.lexers.iolang.IoLexer
-pygments.lexers.julia.JuliaLexer
 pygments.lexers.int_fiction.Inform6Lexer
+pygments.lexers.int_fiction.Inform6TemplateLexer
 pygments.lexers.int_fiction.Inform7Lexer
 pygments.lexers.int_fiction.Tads3Lexer
-pygments.lexers.make.BaseMakefileLexer
-pygments.lexers.make.CMakeLexer
-pygments.lexers.javascript.JavascriptLexer
-pygments.lexers.javascript.KalLexer
-pygments.lexers.javascript.LiveScriptLexer
-pygments.lexers.javascript.DartLexer
-pygments.lexers.javascript.TypeScriptLexer
-pygments.lexers.javascript.LassoLexer
-pygments.lexers.javascript.ObjectiveJLexer
+pygments.lexers.iolang.IoLexer
+pygments.lexers.j.JLexer
 pygments.lexers.javascript.CoffeeScriptLexer
-pygments.lexers.javascript.MaskLexer
+pygments.lexers.javascript.DartLexer
 pygments.lexers.javascript.EarlGreyLexer
+pygments.lexers.javascript.JavascriptLexer
 pygments.lexers.javascript.JuttleLexer
-pygments.lexers.jvm.JavaLexer
-pygments.lexers.jvm.ScalaLexer
+pygments.lexers.javascript.KalLexer
+pygments.lexers.javascript.LassoLexer
+pygments.lexers.javascript.LiveScriptLexer
+pygments.lexers.javascript.MaskLexer
+pygments.lexers.javascript.NodeConsoleLexer
+pygments.lexers.javascript.ObjectiveJLexer
+pygments.lexers.javascript.TypeScriptLexer
+pygments.lexers.jmespath.JMESPathLexer
+pygments.lexers.jslt.JSLTLexer
+pygments.lexers.json5.Json5Lexer
+pygments.lexers.jsonnet.JsonnetLexer
+pygments.lexers.jsx.JsxLexer
+pygments.lexers.jsx.TsxLexer
+pygments.lexers.julia.JuliaConsoleLexer
+pygments.lexers.julia.JuliaLexer
+pygments.lexers.jvm.AspectJLexer
+pygments.lexers.jvm.CeylonLexer
+pygments.lexers.jvm.ClojureLexer
+pygments.lexers.jvm.ClojureScriptLexer
+pygments.lexers.jvm.GoloLexer
 pygments.lexers.jvm.GosuLexer
+pygments.lexers.jvm.GosuTemplateLexer
 pygments.lexers.jvm.GroovyLexer
 pygments.lexers.jvm.IokeLexer
-pygments.lexers.jvm.ClojureLexer
-pygments.lexers.jvm.TeaLangLexer
-pygments.lexers.jvm.CeylonLexer
-pygments.lexers.jvm.KotlinLexer
-pygments.lexers.jvm.XtendLexer
-pygments.lexers.jvm.PigLexer
-pygments.lexers.jvm.GoloLexer
 pygments.lexers.jvm.JasminLexer
-pygments.lexers.markup.BBCodeLexer
-pygments.lexers.markup.MoinWikiLexer
-pygments.lexers.markup.RstLexer
-pygments.lexers.markup.TexLexer
-pygments.lexers.markup.GroffLexer
-pygments.lexers.markup.MozPreprocHashLexer
-pygments.lexers.markup.MarkdownLexer
-pygments.lexers.ml.SMLLexer
-pygments.lexers.ml.OcamlLexer
-pygments.lexers.ml.OpaLexer
-pygments.lexers.modeling.ModelicaLexer
-pygments.lexers.modeling.BugsLexer
-pygments.lexers.modeling.JagsLexer
-pygments.lexers.modeling.StanLexer
-pygments.lexers.matlab.MatlabLexer
-pygments.lexers.matlab.OctaveLexer
-pygments.lexers.matlab.ScilabLexer
-pygments.lexers.monte.MonteLexer
-pygments.lexers.lisp.SchemeLexer
+pygments.lexers.jvm.JavaLexer
+pygments.lexers.jvm.KotlinLexer
+pygments.lexers.jvm.PigLexer
+pygments.lexers.jvm.SarlLexer
+pygments.lexers.jvm.ScalaLexer
+pygments.lexers.jvm.XtendLexer
+pygments.lexers.kuin.KuinLexer
+pygments.lexers.kusto.KustoLexer
+pygments.lexers.ldap.LdaprcLexer
+pygments.lexers.ldap.LdifLexer
+pygments.lexers.lean.Lean3Lexer
+pygments.lexers.lean.Lean4Lexer
+pygments.lexers.lilypond.LilyPondLexer
 pygments.lexers.lisp.CommonLispLexer
-pygments.lexers.lisp.HyLexer
-pygments.lexers.lisp.RacketLexer
-pygments.lexers.lisp.NewLispLexer
+pygments.lexers.lisp.CPSALexer
 pygments.lexers.lisp.EmacsLispLexer
+pygments.lexers.lisp.FennelLexer
+pygments.lexers.lisp.HyLexer
+pygments.lexers.lisp.JanetLexer
+pygments.lexers.lisp.NewLispLexer
+pygments.lexers.lisp.RacketLexer
+pygments.lexers.lisp.SchemeLexer
 pygments.lexers.lisp.ShenLexer
 pygments.lexers.lisp.XtlangLexer
+pygments.lexers.macaulay2.Macaulay2Lexer
+pygments.lexers.make.BaseMakefileLexer
+pygments.lexers.make.CMakeLexer
+pygments.lexers.make.MakefileLexer
+pygments.lexers.maple.MapleLexer
+pygments.lexers.markup.BBCodeLexer
+pygments.lexers.markup.GroffLexer
+pygments.lexers.markup.MarkdownLexer
+pygments.lexers.markup.MoinWikiLexer
+pygments.lexers.markup.MozPreprocCssLexer
+pygments.lexers.markup.MozPreprocHashLexer
+pygments.lexers.markup.MozPreprocJavascriptLexer
+pygments.lexers.markup.MozPreprocPercentLexer
+pygments.lexers.markup.MozPreprocXulLexer
+pygments.lexers.markup.OrgLexer
+pygments.lexers.markup.RstLexer
+pygments.lexers.markup.TexLexer
+pygments.lexers.markup.TiddlyWiki5Lexer
+pygments.lexers.markup.WikitextLexer
+pygments.lexers.matlab.MatlabLexer
+pygments.lexers.matlab.MatlabSessionLexer
+pygments.lexers.matlab.OctaveLexer
+pygments.lexers.matlab.ScilabLexer
+pygments.lexers.maxima.MaximaLexer
+pygments.lexers.meson.MesonLexer
+pygments.lexers.mime.MIMELexer
+pygments.lexers.minecraft.MCFunctionLexer
+pygments.lexers.minecraft.MCSchemaLexer
+pygments.lexers.minecraft.SNBTLexer
+pygments.lexers.mips.MIPSLexer
+pygments.lexers.ml.FStarLexer
+pygments.lexers.ml.OcamlLexer
+pygments.lexers.ml.OpaLexer
+pygments.lexers.ml.ReasonLexer
+pygments.lexers.ml.SMLLexer
+pygments.lexers.modeling.BugsLexer
+pygments.lexers.modeling.JagsLexer
+pygments.lexers.modeling.ModelicaLexer
+pygments.lexers.modeling.StanLexer
 pygments.lexers.modula2.Modula2Lexer
+pygments.lexers.mojo.MojoLexer
+pygments.lexers.monte.MonteLexer
+pygments.lexers.mosel.MoselLexer
 pygments.lexers.ncl.NCLLexer
-pygments.lexers.nim.NimLexer
+pygments.lexers.nimrod.NimrodLexer
 pygments.lexers.nit.NitLexer
 pygments.lexers.nix.NixLexer
+pygments.lexers.numbair.NumbaIRLexer
 pygments.lexers.oberon.ComponentPascalLexer
-pygments.lexers.ooc.OocLexer
+pygments.lexers.objective.LogosLexer
+pygments.lexers.objective.ObjectiveCLexer
+pygments.lexers.objective.ObjectiveCppLexer
 pygments.lexers.objective.SwiftLexer
+pygments.lexers.ooc.OocLexer
+pygments.lexers.openscad.OpenScadLexer
 pygments.lexers.parasail.ParaSailLexer
-pygments.lexers.pawn.SourcePawnLexer
-pygments.lexers.pawn.PawnLexer
-pygments.lexers.pascal.AdaLexer
-pygments.lexers.parsers.RagelLexer
-pygments.lexers.parsers.RagelEmbeddedLexer
+pygments.lexers.parsers.AntlrActionScriptLexer
+pygments.lexers.parsers.AntlrCppLexer
+pygments.lexers.parsers.AntlrCSharpLexer
+pygments.lexers.parsers.AntlrJavaLexer
 pygments.lexers.parsers.AntlrLexer
-pygments.lexers.parsers.TreetopBaseLexer
+pygments.lexers.parsers.AntlrObjectiveCLexer
+pygments.lexers.parsers.AntlrPerlLexer
+pygments.lexers.parsers.AntlrPythonLexer
+pygments.lexers.parsers.AntlrRubyLexer
 pygments.lexers.parsers.EbnfLexer
-pygments.lexers.php.ZephirLexer
-pygments.lexers.php.PhpLexer
-pygments.lexers.perl.PerlLexer
+pygments.lexers.parsers.RagelCLexer
+pygments.lexers.parsers.RagelCppLexer
+pygments.lexers.parsers.RagelDLexer
+pygments.lexers.parsers.RagelEmbeddedLexer
+pygments.lexers.parsers.RagelJavaLexer
+pygments.lexers.parsers.RagelLexer
+pygments.lexers.parsers.RagelObjectiveCLexer
+pygments.lexers.parsers.RagelRubyLexer
+pygments.lexers.parsers.TreetopLexer
+pygments.lexers.pascal.DelphiLexer
+pygments.lexers.pascal.PortugolLexer
+pygments.lexers.pawn.PawnLexer
+pygments.lexers.pawn.SourcePawnLexer
+pygments.lexers.pddl.PddlLexer
 pygments.lexers.perl.Perl6Lexer
+pygments.lexers.perl.PerlLexer
+pygments.lexers.phix.PhixLexer
+pygments.lexers.php.PhpLexer
+pygments.lexers.php.PsyshConsoleLexer
+pygments.lexers.php.ZephirLexer
+pygments.lexers.pointless.PointlessLexer
+pygments.lexers.pony.PonyLexer
 pygments.lexers.praat.PraatLexer
-pygments.lexers.prolog.PrologLexer
+pygments.lexers.procfile.ProcfileLexer
 pygments.lexers.prolog.LogtalkLexer
-pygments.lexers.qvt.QVToLexer
-pygments.lexers.rdf.SparqlLexer
-pygments.lexers.rdf.TurtleLexer
-pygments.lexers.python.PythonLexer
-pygments.lexers.python.Python3Lexer
-pygments.lexers.python.PythonTracebackLexer
-pygments.lexers.python.Python3TracebackLexer
+pygments.lexers.prolog.PrologLexer
+pygments.lexers.promql.PromQLLexer
+pygments.lexers.prql.PrqlLexer
+pygments.lexers.ptx.PtxLexer
 pygments.lexers.python.CythonLexer
 pygments.lexers.python.DgLexer
+pygments.lexers.python.NumPyLexer
+pygments.lexers.python.Python2Lexer
+pygments.lexers.python.Python2TracebackLexer
+pygments.lexers.python.PythonConsoleLexer
+pygments.lexers.python.PythonLexer
+pygments.lexers.python.PythonTracebackLexer
+pygments.lexers.q.KLexer
+pygments.lexers.q.QLexer
+pygments.lexers.qlik.QlikLexer
+pygments.lexers.qvt.QVToLexer
+pygments.lexers.r.RConsoleLexer
+pygments.lexers.r.RdLexer
+pygments.lexers.r.SLexer
+pygments.lexers.rdf.ShExCLexer
+pygments.lexers.rdf.SparqlLexer
+pygments.lexers.rdf.TurtleLexer
 pygments.lexers.rebol.RebolLexer
 pygments.lexers.rebol.RedLexer
+pygments.lexers.rego.RegoLexer
 pygments.lexers.resource.ResourceLexer
+pygments.lexers.ride.RideLexer
+pygments.lexers.rita.RitaLexer
 pygments.lexers.rnc.RNCCompactLexer
 pygments.lexers.roboconf.RoboconfGraphLexer
 pygments.lexers.roboconf.RoboconfInstancesLexer
-pygments.lexers.rust.RustLexer
-pygments.lexers.ruby.RubyLexer
+pygments.lexers.robotframework.RobotFrameworkLexer
 pygments.lexers.ruby.FancyLexer
+pygments.lexers.ruby.RubyConsoleLexer
+pygments.lexers.ruby.RubyLexer
+pygments.lexers.rust.RustLexer
 pygments.lexers.sas.SASLexer
-pygments.lexers.smalltalk.SmalltalkLexer
-pygments.lexers.smalltalk.NewspeakLexer
-pygments.lexers.smv.NuSMVLexer
-pygments.lexers.shell.BashLexer
-pygments.lexers.shell.BatchLexer
-pygments.lexers.shell.TcshLexer
-pygments.lexers.shell.PowerShellLexer
-pygments.lexers.shell.FishShellLexer
-pygments.lexers.snobol.SnobolLexer
-pygments.lexers.scripting.LuaLexer
-pygments.lexers.scripting.ChaiscriptLexer
-pygments.lexers.scripting.LSLLexer
+pygments.lexers.savi.SaviLexer
+pygments.lexers.scdoc.ScdocLexer
 pygments.lexers.scripting.AppleScriptLexer
-pygments.lexers.scripting.RexxLexer
-pygments.lexers.scripting.MOOCodeLexer
-pygments.lexers.scripting.HybrisLexer
+pygments.lexers.scripting.ChaiscriptLexer
 pygments.lexers.scripting.EasytrieveLexer
+pygments.lexers.scripting.HybrisLexer
 pygments.lexers.scripting.JclLexer
-pygments.lexers.supercollider.SuperColliderLexer
-pygments.lexers.stata.StataLexer
-pygments.lexers.tcl.TclLexer
-pygments.lexers.sql.PostgresLexer
+pygments.lexers.scripting.LSLLexer
+pygments.lexers.scripting.LuaLexer
+pygments.lexers.scripting.LuauLexer
+pygments.lexers.scripting.MiniScriptLexer
+pygments.lexers.scripting.MOOCodeLexer
+pygments.lexers.scripting.MoonScriptLexer
+pygments.lexers.scripting.RexxLexer
+pygments.lexers.sgf.SmartGameFormatLexer
+pygments.lexers.shell.BashLexer
+pygments.lexers.shell.BashSessionLexer
+pygments.lexers.shell.BatchLexer
+pygments.lexers.shell.ExeclineLexer
+pygments.lexers.shell.FishShellLexer
+pygments.lexers.shell.MSDOSSessionLexer
+pygments.lexers.shell.PowerShellLexer
+pygments.lexers.shell.PowerShellSessionLexer
+pygments.lexers.shell.SlurmBashLexer
+pygments.lexers.shell.TcshLexer
+pygments.lexers.shell.TcshSessionLexer
+pygments.lexers.sieve.SieveLexer
+pygments.lexers.slash.SlashLexer
+pygments.lexers.smalltalk.NewspeakLexer
+pygments.lexers.smalltalk.SmalltalkLexer
+pygments.lexers.smithy.SmithyLexer
+pygments.lexers.smv.NuSMVLexer
+pygments.lexers.snobol.SnobolLexer
+pygments.lexers.solidity.SolidityLexer
+pygments.lexers.soong.SoongLexer
+pygments.lexers.sophia.SophiaLexer
+pygments.lexers.special.OutputLexer
+pygments.lexers.special.TextLexer
+pygments.lexers.spice.SpiceLexer
+pygments.lexers.sql.GoogleSqlLexer
+pygments.lexers.sql.MySqlLexer
 pygments.lexers.sql.PlPgsqlLexer
-pygments.lexers.sql.PsqlRegexLexer
+pygments.lexers.sql.PostgresConsoleLexer
+pygments.lexers.sql.PostgresExplainLexer
+pygments.lexers.sql.PostgresLexer
+pygments.lexers.sql.RqlLexer
+pygments.lexers.sql.SqliteConsoleLexer
 pygments.lexers.sql.SqlLexer
 pygments.lexers.sql.TransactSqlLexer
-pygments.lexers.sql.MySqlLexer
-pygments.lexers.sql.RqlLexer
+pygments.lexers.srcinfo.SrcinfoLexer
+pygments.lexers.stata.StataLexer
+pygments.lexers.supercollider.SuperColliderLexer
+pygments.lexers.tablegen.TableGenLexer
+pygments.lexers.tact.TactLexer
+pygments.lexers.tal.TalLexer
+pygments.lexers.tcl.TclLexer
+pygments.lexers.teal.TealLexer
+pygments.lexers.templates.Angular2HtmlLexer
+pygments.lexers.templates.Angular2Lexer
+pygments.lexers.templates.CheetahHtmlLexer
+pygments.lexers.templates.CheetahJavascriptLexer
+pygments.lexers.templates.CheetahLexer
+pygments.lexers.templates.CheetahXmlLexer
+pygments.lexers.templates.ColdfusionCFCLexer
+pygments.lexers.templates.ColdfusionHtmlLexer
+pygments.lexers.templates.ColdfusionLexer
+pygments.lexers.templates.CssDjangoLexer
+pygments.lexers.templates.CssErbLexer
+pygments.lexers.templates.CssGenshiLexer
+pygments.lexers.templates.CssPhpLexer
+pygments.lexers.templates.CssSmartyLexer
+pygments.lexers.templates.DjangoLexer
+pygments.lexers.templates.ErbLexer
+pygments.lexers.templates.EvoqueHtmlLexer
+pygments.lexers.templates.EvoqueLexer
+pygments.lexers.templates.EvoqueXmlLexer
+pygments.lexers.templates.GenshiLexer
+pygments.lexers.templates.GenshiTextLexer
+pygments.lexers.templates.HandlebarsHtmlLexer
+pygments.lexers.templates.HandlebarsLexer
+pygments.lexers.templates.HtmlDjangoLexer
+pygments.lexers.templates.HtmlGenshiLexer
+pygments.lexers.templates.HtmlPhpLexer
+pygments.lexers.templates.HtmlSmartyLexer
+pygments.lexers.templates.JavascriptDjangoLexer
+pygments.lexers.templates.JavascriptErbLexer
+pygments.lexers.templates.JavascriptGenshiLexer
+pygments.lexers.templates.JavascriptPhpLexer
+pygments.lexers.templates.JavascriptSmartyLexer
+pygments.lexers.templates.JspLexer
+pygments.lexers.templates.LassoCssLexer
+pygments.lexers.templates.LassoHtmlLexer
+pygments.lexers.templates.LassoJavascriptLexer
+pygments.lexers.templates.LassoXmlLexer
+pygments.lexers.templates.LiquidLexer
+pygments.lexers.templates.MakoCssLexer
+pygments.lexers.templates.MakoHtmlLexer
+pygments.lexers.templates.MakoJavascriptLexer
+pygments.lexers.templates.MakoLexer
+pygments.lexers.templates.MakoXmlLexer
+pygments.lexers.templates.MasonLexer
+pygments.lexers.templates.MyghtyCssLexer
+pygments.lexers.templates.MyghtyHtmlLexer
+pygments.lexers.templates.MyghtyJavascriptLexer
+pygments.lexers.templates.MyghtyLexer
+pygments.lexers.templates.MyghtyXmlLexer
+pygments.lexers.templates.RhtmlLexer
+pygments.lexers.templates.SmartyLexer
+pygments.lexers.templates.SqlJinjaLexer
+pygments.lexers.templates.SspLexer
+pygments.lexers.templates.TeaTemplateLexer
+pygments.lexers.templates.TwigHtmlLexer
+pygments.lexers.templates.TwigLexer
+pygments.lexers.templates.VelocityHtmlLexer
+pygments.lexers.templates.VelocityLexer
+pygments.lexers.templates.VelocityXmlLexer
+pygments.lexers.templates.XmlDjangoLexer
+pygments.lexers.templates.XmlErbLexer
+pygments.lexers.templates.XmlPhpLexer
+pygments.lexers.templates.XmlSmartyLexer
+pygments.lexers.templates.YamlJinjaLexer
+pygments.lexers.teraterm.TeraTermLexer
 pygments.lexers.testing.GherkinLexer
 pygments.lexers.testing.TAPLexer
 pygments.lexers.textedit.AwkLexer
+pygments.lexers.textedit.SedLexer
 pygments.lexers.textedit.VimLexer
-pygments.lexers.textfmts.IrcLogsLexer
 pygments.lexers.textfmts.GettextLexer
 pygments.lexers.textfmts.HttpLexer
+pygments.lexers.textfmts.IrcLogsLexer
+pygments.lexers.textfmts.KernelLogLexer
+pygments.lexers.textfmts.NotmuchLexer
 pygments.lexers.textfmts.TodotxtLexer
-pygments.lexers.trafficscript.RtsLexer
 pygments.lexers.theorem.CoqLexer
 pygments.lexers.theorem.IsabelleLexer
-pygments.lexers.theorem.LeanLexer
-pygments.lexers.templates.SmartyLexer
-pygments.lexers.templates.VelocityLexer
-pygments.lexers.templates.DjangoLexer
-pygments.lexers.templates.MyghtyLexer
-pygments.lexers.templates.MasonLexer
-pygments.lexers.templates.MakoLexer
-pygments.lexers.templates.CheetahLexer
-pygments.lexers.templates.GenshiTextLexer
-pygments.lexers.templates.GenshiMarkupLexer
-pygments.lexers.templates.JspRootLexer
-pygments.lexers.templates.EvoqueLexer
-pygments.lexers.templates.ColdfusionLexer
-pygments.lexers.templates.ColdfusionMarkupLexer
-pygments.lexers.templates.TeaTemplateRootLexer
-pygments.lexers.templates.HandlebarsLexer
-pygments.lexers.templates.LiquidLexer
-pygments.lexers.templates.TwigLexer
-pygments.lexers.templates.Angular2Lexer
-pygments.lexers.urbi.UrbiscriptLexer
+pygments.lexers.thingsdb.ThingsDBLexer
+pygments.lexers.tlb.TlbLexer
+pygments.lexers.tls.TlsLexer
+pygments.lexers.tnt.TNTLexer
+pygments.lexers.trafficscript.RtsLexer
 pygments.lexers.typoscript.TypoScriptCssDataLexer
 pygments.lexers.typoscript.TypoScriptHtmlDataLexer
 pygments.lexers.typoscript.TypoScriptLexer
+pygments.lexers.typst.TypstLexer
+pygments.lexers.ul4.CSSUL4Lexer
+pygments.lexers.ul4.HTMLUL4Lexer
+pygments.lexers.ul4.JavascriptUL4Lexer
+pygments.lexers.ul4.PythonUL4Lexer
+pygments.lexers.ul4.UL4Lexer
+pygments.lexers.ul4.XMLUL4Lexer
+pygments.lexers.unicon.IconLexer
+pygments.lexers.unicon.UcodeLexer
+pygments.lexers.unicon.UniconLexer
+pygments.lexers.urbi.UrbiscriptLexer
+pygments.lexers.usd.UsdLexer
 pygments.lexers.varnish.VCLLexer
+pygments.lexers.varnish.VCLSnippetLexer
 pygments.lexers.verification.BoogieLexer
 pygments.lexers.verification.SilverLexer
-pygments.lexers.x10.X10Lexer
-pygments.lexers.whiley.WhileyLexer
-pygments.lexers.xorg.XorgLexer
-pygments.lexers.webmisc.DuelLexer
-pygments.lexers.webmisc.XQueryLexer
-pygments.lexers.webmisc.QmlLexer
+pygments.lexers.verifpal.VerifpalLexer
+pygments.lexers.vip.VisualPrologGrammarLexer
+pygments.lexers.vip.VisualPrologLexer
+pygments.lexers.vyper.VyperLexer
+pygments.lexers.webassembly.WatLexer
+pygments.lexers.webidl.WebIDLLexer
 pygments.lexers.webmisc.CirruLexer
+pygments.lexers.webmisc.DuelLexer
+pygments.lexers.webmisc.QmlLexer
 pygments.lexers.webmisc.SlimLexer
+pygments.lexers.webmisc.XQueryLexer
+pygments.lexers.wgsl.WgslLexer
+pygments.lexers.whiley.WhileyLexer
+pygments.lexers.wowtoc.WoWTocLexer
+pygments.lexers.wren.WrenLexer
+pygments.lexers.x10.X10Lexer
+pygments.lexers.xorg.XorgLexer
+pygments.lexers.yang.YangLexer
+pygments.lexers.yara.YaraLexer
+pygments.lexers.zig.ZigLexer
@@ -1,6 +1,7 @@
 package chroma

 import (
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -135,11 +136,20 @@ func NewLexer(config *Config, rulesFunc func() Rules) (*RegexLexer, error) {
 }

 // Trace enables debug tracing.
+//
+// Deprecated: Use SetTracing instead.
 func (r *RegexLexer) Trace(trace bool) *RegexLexer {
 	r.trace = trace
 	return r
 }

+// SetTracing enables debug tracing.
+//
+// This complies with the [TracingLexer] interface.
+func (r *RegexLexer) SetTracing(trace bool) {
+	r.trace = trace
+}
+
 // A CompiledRule is a Rule with a pre-compiled regex.
 //
 // Note that regular expressions are lazily compiled on first use of the lexer.
@@ -185,6 +195,7 @@ func (l *LexerState) Get(key interface{}) interface{} {

 // Iterator returns the next Token from the lexer.
 func (l *LexerState) Iterator() Token { // nolint: gocognit
+	trace := json.NewEncoder(os.Stderr)
 	end := len(l.Text)
 	if l.newlineAdded {
 		end--
@@ -205,14 +216,33 @@ func (l *LexerState) Iterator() Token { // nolint: gocognit
 		}

 		l.State = l.Stack[len(l.Stack)-1]
-		if l.Lexer.trace {
-			fmt.Fprintf(os.Stderr, "%s: pos=%d, text=%q\n", l.State, l.Pos, string(l.Text[l.Pos:]))
-		}
 		selectedRule, ok := l.Rules[l.State]
 		if !ok {
 			panic("unknown state " + l.State)
 		}
+		var start time.Time
+		if l.Lexer.trace {
+			start = time.Now()
+		}
 		ruleIndex, rule, groups, namedGroups := matchRules(l.Text, l.Pos, selectedRule)
+		if l.Lexer.trace {
+			var length int
+			if groups != nil {
+				length = len(groups[0])
+			} else {
+				length = -1
+			}
+			_ = trace.Encode(Trace{ //nolint
+				Lexer:   l.Lexer.config.Name,
+				State:   l.State,
+				Rule:    ruleIndex,
+				Pattern: rule.Pattern,
+				Pos:     l.Pos,
+				Length:  length,
+				Elapsed: float64(time.Since(start)) / float64(time.Millisecond),
+			})
+			// fmt.Fprintf(os.Stderr, "%s: pos=%d, text=%q, elapsed=%s\n", l.State, l.Pos, string(l.Text[l.Pos:]), time.Since(start))
+		}
 		// No match.
 		if groups == nil {
 			// From Pygments :\
@@ -349,7 +379,7 @@ func (r *RegexLexer) maybeCompile() (err error) {
 restart:
 	seen := map[LexerMutator]bool{}
 	for state := range r.rules {
-		for i := 0; i < len(r.rules[state]); i++ {
+		for i := range len(r.rules[state]) {
 			rule := r.rules[state][i]
 			if compile, ok := rule.Mutator.(LexerMutator); ok {
 				if seen[compile] {
@@ -366,6 +396,17 @@ restart:
 			}
 		}
 	}
+	// Validate emitters
+	for state := range r.rules {
+		for i := range len(r.rules[state]) {
+			rule := r.rules[state][i]
+			if validate, ok := rule.Type.(ValidatingEmitter); ok {
+				if err := validate.ValidateEmitter(rule); err != nil {
+					return fmt.Errorf("%s: %s: %s: %w", r.config.Name, state, rule.Pattern, err)
+				}
+			}
+		}
+	}
 	r.compiled = true
 	return nil
 }
@@ -474,7 +515,7 @@ func matchRules(text []rune, pos int, rules []*CompiledRule) (int, *CompiledRule
 func ensureLF(text string) string {
 	buf := make([]byte, len(text))
 	var j int
-	for i := 0; i < len(text); i++ {
+	for i := range len(text) {
 		c := text[i]
 		if c == '\r' {
 			if i < len(text)-1 && text[i+1] == '\n' {
@@ -48,6 +48,24 @@ func (l *LexerRegistry) Names(withAliases bool) []string {
 	return out
 }

+// Aliases of all the lexers, and skip those lexers who do not have any aliases,
+// or show their name instead
+func (l *LexerRegistry) Aliases(skipWithoutAliases bool) []string {
+	out := []string{}
+	for _, lexer := range l.Lexers {
+		config := lexer.Config()
+		if len(config.Aliases) == 0 {
+			if skipWithoutAliases {
+				continue
+			}
+			out = append(out, config.Name)
+		}
+		out = append(out, config.Aliases...)
+	}
+	sort.Strings(out)
+	return out
+}
+
 // Get a Lexer by name, alias or file extension.
 func (l *LexerRegistry) Get(name string) Lexer {
 	if lexer := l.byName[name]; lexer != nil {
@@ -1,18 +1,24 @@
 {
-	$schema: "https://docs.renovatebot.com/renovate-schema.json",
-	extends: [
+	"$schema": "https://docs.renovatebot.com/renovate-schema.json",
+	"extends": [
 		"config:recommended",
 		":semanticCommits",
 		":semanticCommitTypeAll(chore)",
 		":semanticCommitScope(deps)",
 		"group:allNonMajor",
 		"schedule:earlyMondays", // Run once a week.
+		'helpers:pinGitHubActionDigests',
 	],
-	packageRules: [
+	"packageRules": [
 		{
-			matchPackageNames: ["golangci-lint"],
-			matchManagers: ["hermit"],
-			enabled: false,
+			"matchPackageNames": ["golangci-lint"],
+			"matchManagers": ["hermit"],
+			"enabled": false
 		},
-	],
+		{
+			"matchPackageNames": ["github.com/gorilla/csrf"],
+			"matchManagers": ["gomod"],
+			"enabled": false
+		}
+	]
 }
@@ -65,12 +65,12 @@
  <entry type="CommentSingle" style="italic #737994"/>
  <entry type="CommentMultiline" style="italic #737994"/>
  <entry type="CommentSpecial" style="italic #737994"/>
-  <entry type="CommentHashbang" style="italic #737994"/>
+  <entry type="CommentHashbang" style="italic #626880"/>
  <entry type="CommentPreproc" style="italic #737994"/>
  <entry type="CommentPreprocFile" style="bold #737994"/>
  <entry type="Generic" style="#c6d0f5"/>
  <entry type="GenericInserted" style="bg:#414559 #a6d189"/>
-  <entry type="GenericDeleted" style="#e78284 bg:#414559"/>
+  <entry type="GenericDeleted" style="bg:#414559 #e78284"/>
  <entry type="GenericEmph" style="italic #c6d0f5"/>
  <entry type="GenericStrong" style="bold #c6d0f5"/>
  <entry type="GenericUnderline" style="underline #c6d0f5"/>
@@ -80,4 +80,4 @@
  <entry type="GenericPrompt" style="#c6d0f5"/>
  <entry type="GenericError" style="#e78284"/>
  <entry type="GenericTraceback" style="#e78284"/>
-</style>
+</style>
@@ -65,12 +65,12 @@
  <entry type="CommentSingle" style="italic #9ca0b0"/>
  <entry type="CommentMultiline" style="italic #9ca0b0"/>
  <entry type="CommentSpecial" style="italic #9ca0b0"/>
-  <entry type="CommentHashbang" style="italic #9ca0b0"/>
+  <entry type="CommentHashbang" style="italic #acb0be"/>
  <entry type="CommentPreproc" style="italic #9ca0b0"/>
  <entry type="CommentPreprocFile" style="bold #9ca0b0"/>
  <entry type="Generic" style="#4c4f69"/>
  <entry type="GenericInserted" style="bg:#ccd0da #40a02b"/>
-  <entry type="GenericDeleted" style="#d20f39 bg:#ccd0da"/>
+  <entry type="GenericDeleted" style="bg:#ccd0da #d20f39"/>
  <entry type="GenericEmph" style="italic #4c4f69"/>
  <entry type="GenericStrong" style="bold #4c4f69"/>
  <entry type="GenericUnderline" style="underline #4c4f69"/>
@@ -80,4 +80,4 @@
  <entry type="GenericPrompt" style="#4c4f69"/>
  <entry type="GenericError" style="#d20f39"/>
  <entry type="GenericTraceback" style="#d20f39"/>
-</style>
+</style>
@@ -65,12 +65,12 @@
  <entry type="CommentSingle" style="italic #6e738d"/>
  <entry type="CommentMultiline" style="italic #6e738d"/>
  <entry type="CommentSpecial" style="italic #6e738d"/>
-  <entry type="CommentHashbang" style="italic #6e738d"/>
+  <entry type="CommentHashbang" style="italic #5b6078"/>
  <entry type="CommentPreproc" style="italic #6e738d"/>
  <entry type="CommentPreprocFile" style="bold #6e738d"/>
  <entry type="Generic" style="#cad3f5"/>
  <entry type="GenericInserted" style="bg:#363a4f #a6da95"/>
-  <entry type="GenericDeleted" style="#ed8796 bg:#363a4f"/>
+  <entry type="GenericDeleted" style="bg:#363a4f #ed8796"/>
  <entry type="GenericEmph" style="italic #cad3f5"/>
  <entry type="GenericStrong" style="bold #cad3f5"/>
  <entry type="GenericUnderline" style="underline #cad3f5"/>
@@ -80,4 +80,4 @@
  <entry type="GenericPrompt" style="#cad3f5"/>
  <entry type="GenericError" style="#ed8796"/>
  <entry type="GenericTraceback" style="#ed8796"/>
-</style>
+</style>
@@ -65,12 +65,12 @@
  <entry type="CommentSingle" style="italic #6c7086"/>
  <entry type="CommentMultiline" style="italic #6c7086"/>
  <entry type="CommentSpecial" style="italic #6c7086"/>
-  <entry type="CommentHashbang" style="italic #6c7086"/>
+  <entry type="CommentHashbang" style="italic #585b70"/>
  <entry type="CommentPreproc" style="italic #6c7086"/>
  <entry type="CommentPreprocFile" style="bold #6c7086"/>
  <entry type="Generic" style="#cdd6f4"/>
  <entry type="GenericInserted" style="bg:#313244 #a6e3a1"/>
-  <entry type="GenericDeleted" style="#f38ba8 bg:#313244"/>
+  <entry type="GenericDeleted" style="bg:#313244 #f38ba8"/>
  <entry type="GenericEmph" style="italic #cdd6f4"/>
  <entry type="GenericStrong" style="bold #cdd6f4"/>
  <entry type="GenericUnderline" style="underline #cdd6f4"/>
@@ -80,4 +80,4 @@
  <entry type="GenericPrompt" style="#cdd6f4"/>
  <entry type="GenericError" style="#f38ba8"/>
  <entry type="GenericTraceback" style="#f38ba8"/>
-</style>
+</style>
@@ -0,0 +1,30 @@
+<style name="RPGLE">
+  <entry type="Error" style="#960050 bg:#1e0010"/>
+  <entry type="Background" style="bg:#fafafa"/>
+  <entry type="Keyword" style="#00a8c8"/>
+  <entry type="KeywordNamespace" style="#f92672"/>
+  <entry type="KeywordReserved" style="#0000ff"/>
+  <entry type="KeywordType" style="#800000"/>
+  <entry type="Name" style="#111111"/>
+  <entry type="NameAttribute" style="#75af00"/>
+  <entry type="NameClass" style="#75af00"/>
+  <entry type="NameConstant" style="#00a8c8"/>
+  <entry type="NameDecorator" style="#75af00"/>
+  <entry type="NameException" style="#75af00"/>
+  <entry type="NameFunction" style="#75af00"/>
+  <entry type="NameOther" style="#75af00"/>
+  <entry type="NameTag" style="#f92672"/>
+  <entry type="Literal" style="#ae81ff"/>
+  <entry type="LiteralDate" style="#d88200"/>
+  <entry type="LiteralString" style="#d88200"/>
+  <entry type="LiteralStringEscape" style="#8045ff"/>
+  <entry type="LiteralNumber" style="#ae81ff"/>
+  <entry type="Operator" style="#f92672"/>
+  <entry type="Punctuation" style="#ff0000"/>
+  <entry type="Comment" style="#75715e"/>
+  <entry type="CommentPreproc" style="#2e7d32"/>
+  <entry type="CommentSpecial" style="#ffbf00"/>
+  <entry type="GenericEmph" style="italic"/>
+  <entry type="GenericStrong" style="bold"/>
+  <entry type="Text" style="#272822"/>
+</style>
@@ -10,4 +10,10 @@
  <entry type="LiteralNumber" style="#ff6600"/>
  <entry type="Comment" style="#00ff00"/>
  <entry type="CommentPreproc" style="#e5e5e5"/>
+  <entry type="GenericDeleted" style="#f00"/>
+  <entry type="GenericEmph" style="italic"/>
+  <entry type="GenericHeading" style="bold #ff0"/>
+  <entry type="GenericInserted" style="#0f0"/>
+  <entry type="GenericStrong" style="bold"/>
+  <entry type="GenericSubheading" style="bold #87ceeb"/>
 </style>
@@ -7,8 +7,8 @@ import (
 	"strings"
 )

-const _TokenTypeName = "IgnoreNoneOtherErrorCodeLineLineLinkLineTableTDLineTableLineHighlightLineNumbersTableLineNumbersLinePreWrapperBackgroundEOFTypeKeywordKeywordConstantKeywordDeclarationKeywordNamespaceKeywordPseudoKeywordReservedKeywordTypeNameNameAttributeNameBuiltinNameBuiltinPseudoNameClassNameConstantNameDecoratorNameEntityNameExceptionNameFunctionNameFunctionMagicNameKeywordNameLabelNameNamespaceNameOperatorNameOtherNamePseudoNamePropertyNameTagNameVariableNameVariableAnonymousNameVariableClassNameVariableGlobalNameVariableInstanceNameVariableMagicLiteralLiteralDateLiteralOtherLiteralStringLiteralStringAffixLiteralStringAtomLiteralStringBacktickLiteralStringBooleanLiteralStringCharLiteralStringDelimiterLiteralStringDocLiteralStringDoubleLiteralStringEscapeLiteralStringHeredocLiteralStringInterpolLiteralStringNameLiteralStringOtherLiteralStringRegexLiteralStringSingleLiteralStringSymbolLiteralNumberLiteralNumberBinLiteralNumberFloatLiteralNumberHexLiteralNumberIntegerLiteralNumberIntegerLongLiteralNumberOctLiteralNumberByteOperatorOperatorWordPunctuationCommentCommentHashbangCommentMultilineCommentSingleCommentSpecialCommentPreprocCommentPreprocFileGenericGenericDeletedGenericEmphGenericErrorGenericHeadingGenericInsertedGenericOutputGenericPromptGenericStrongGenericSubheadingGenericTracebackGenericUnderlineTextTextWhitespaceTextSymbolTextPunctuation"
-const _TokenTypeLowerName = "ignorenoneothererrorcodelinelinelinklinetabletdlinetablelinehighlightlinenumberstablelinenumberslineprewrapperbackgroundeoftypekeywordkeywordconstantkeyworddeclarationkeywordnamespacekeywordpseudokeywordreservedkeywordtypenamenameattributenamebuiltinnamebuiltinpseudonameclassnameconstantnamedecoratornameentitynameexceptionnamefunctionnamefunctionmagicnamekeywordnamelabelnamenamespacenameoperatornameothernamepseudonamepropertynametagnamevariablenamevariableanonymousnamevariableclassnamevariableglobalnamevariableinstancenamevariablemagicliteralliteraldateliteralotherliteralstringliteralstringaffixliteralstringatomliteralstringbacktickliteralstringbooleanliteralstringcharliteralstringdelimiterliteralstringdocliteralstringdoubleliteralstringescapeliteralstringheredocliteralstringinterpolliteralstringnameliteralstringotherliteralstringregexliteralstringsingleliteralstringsymbolliteralnumberliteralnumberbinliteralnumberfloatliteralnumberhexliteralnumberintegerliteralnumberintegerlongliteralnumberoctliteralnumberbyteoperatoroperatorwordpunctuationcommentcommenthashbangcommentmultilinecommentsinglecommentspecialcommentpreproccommentpreprocfilegenericgenericdeletedgenericemphgenericerrorgenericheadinggenericinsertedgenericoutputgenericpromptgenericstronggenericsubheadinggenerictracebackgenericunderlinetexttextwhitespacetextsymboltextpunctuation"
+const _TokenTypeName = "IgnoreNoneOtherErrorCodeLineLineLinkLineTableTDLineTableLineHighlightLineNumbersTableLineNumbersLinePreWrapperBackgroundEOFTypeKeywordKeywordConstantKeywordDeclarationKeywordNamespaceKeywordPseudoKeywordReservedKeywordTypeNameNameAttributeNameClassNameConstantNameDecoratorNameEntityNameExceptionNameKeywordNameLabelNameNamespaceNameOperatorNameOtherNamePseudoNamePropertyNameTagNameBuiltinNameBuiltinPseudoNameVariableNameVariableAnonymousNameVariableClassNameVariableGlobalNameVariableInstanceNameVariableMagicNameFunctionNameFunctionMagicLiteralLiteralDateLiteralOtherLiteralStringLiteralStringAffixLiteralStringAtomLiteralStringBacktickLiteralStringBooleanLiteralStringCharLiteralStringDelimiterLiteralStringDocLiteralStringDoubleLiteralStringEscapeLiteralStringHeredocLiteralStringInterpolLiteralStringNameLiteralStringOtherLiteralStringRegexLiteralStringSingleLiteralStringSymbolLiteralNumberLiteralNumberBinLiteralNumberFloatLiteralNumberHexLiteralNumberIntegerLiteralNumberIntegerLongLiteralNumberOctLiteralNumberByteOperatorOperatorWordPunctuationCommentCommentHashbangCommentMultilineCommentSingleCommentSpecialCommentPreprocCommentPreprocFileGenericGenericDeletedGenericEmphGenericErrorGenericHeadingGenericInsertedGenericOutputGenericPromptGenericStrongGenericSubheadingGenericTracebackGenericUnderlineTextTextWhitespaceTextSymbolTextPunctuation"
+const _TokenTypeLowerName = "ignorenoneothererrorcodelinelinelinklinetabletdlinetablelinehighlightlinenumberstablelinenumberslineprewrapperbackgroundeoftypekeywordkeywordconstantkeyworddeclarationkeywordnamespacekeywordpseudokeywordreservedkeywordtypenamenameattributenameclassnameconstantnamedecoratornameentitynameexceptionnamekeywordnamelabelnamenamespacenameoperatornameothernamepseudonamepropertynametagnamebuiltinnamebuiltinpseudonamevariablenamevariableanonymousnamevariableclassnamevariableglobalnamevariableinstancenamevariablemagicnamefunctionnamefunctionmagicliteralliteraldateliteralotherliteralstringliteralstringaffixliteralstringatomliteralstringbacktickliteralstringbooleanliteralstringcharliteralstringdelimiterliteralstringdocliteralstringdoubleliteralstringescapeliteralstringheredocliteralstringinterpolliteralstringnameliteralstringotherliteralstringregexliteralstringsingleliteralstringsymbolliteralnumberliteralnumberbinliteralnumberfloatliteralnumberhexliteralnumberintegerliteralnumberintegerlongliteralnumberoctliteralnumberbyteoperatoroperatorwordpunctuationcommentcommenthashbangcommentmultilinecommentsinglecommentspecialcommentpreproccommentpreprocfilegenericgenericdeletedgenericemphgenericerrorgenericheadinggenericinsertedgenericoutputgenericpromptgenericstronggenericsubheadinggenerictracebackgenericunderlinetexttextwhitespacetextsymboltextpunctuation"

 var _TokenTypeMap = map[TokenType]string{
 	-14:  _TokenTypeName[0:6],
@@ -35,29 +35,29 @@ var _TokenTypeMap = map[TokenType]string{
 	1006: _TokenTypeName[211:222],
 	2000: _TokenTypeName[222:226],
 	2001: _TokenTypeName[226:239],
-	2002: _TokenTypeName[239:250],
-	2003: _TokenTypeName[250:267],
-	2004: _TokenTypeName[267:276],
-	2005: _TokenTypeName[276:288],
-	2006: _TokenTypeName[288:301],
-	2007: _TokenTypeName[301:311],
-	2008: _TokenTypeName[311:324],
-	2009: _TokenTypeName[324:336],
-	2010: _TokenTypeName[336:353],
-	2011: _TokenTypeName[353:364],
-	2012: _TokenTypeName[364:373],
-	2013: _TokenTypeName[373:386],
-	2014: _TokenTypeName[386:398],
-	2015: _TokenTypeName[398:407],
-	2016: _TokenTypeName[407:417],
-	2017: _TokenTypeName[417:429],
-	2018: _TokenTypeName[429:436],
-	2019: _TokenTypeName[436:448],
-	2020: _TokenTypeName[448:469],
-	2021: _TokenTypeName[469:486],
-	2022: _TokenTypeName[486:504],
-	2023: _TokenTypeName[504:524],
-	2024: _TokenTypeName[524:541],
+	2002: _TokenTypeName[239:248],
+	2003: _TokenTypeName[248:260],
+	2004: _TokenTypeName[260:273],
+	2005: _TokenTypeName[273:283],
+	2006: _TokenTypeName[283:296],
+	2007: _TokenTypeName[296:307],
+	2008: _TokenTypeName[307:316],
+	2009: _TokenTypeName[316:329],
+	2010: _TokenTypeName[329:341],
+	2011: _TokenTypeName[341:350],
+	2012: _TokenTypeName[350:360],
+	2013: _TokenTypeName[360:372],
+	2014: _TokenTypeName[372:379],
+	2100: _TokenTypeName[379:390],
+	2101: _TokenTypeName[390:407],
+	2200: _TokenTypeName[407:419],
+	2201: _TokenTypeName[419:440],
+	2202: _TokenTypeName[440:457],
+	2203: _TokenTypeName[457:475],
+	2204: _TokenTypeName[475:495],
+	2205: _TokenTypeName[495:512],
+	2300: _TokenTypeName[512:524],
+	2301: _TokenTypeName[524:541],
 	3000: _TokenTypeName[541:548],
 	3001: _TokenTypeName[548:559],
 	3002: _TokenTypeName[559:571],
@@ -149,29 +149,29 @@ func _TokenTypeNoOp() {
 	_ = x[KeywordType-(1006)]
 	_ = x[Name-(2000)]
 	_ = x[NameAttribute-(2001)]
-	_ = x[NameBuiltin-(2002)]
-	_ = x[NameBuiltinPseudo-(2003)]
-	_ = x[NameClass-(2004)]
-	_ = x[NameConstant-(2005)]
-	_ = x[NameDecorator-(2006)]
-	_ = x[NameEntity-(2007)]
-	_ = x[NameException-(2008)]
-	_ = x[NameFunction-(2009)]
-	_ = x[NameFunctionMagic-(2010)]
-	_ = x[NameKeyword-(2011)]
-	_ = x[NameLabel-(2012)]
-	_ = x[NameNamespace-(2013)]
-	_ = x[NameOperator-(2014)]
-	_ = x[NameOther-(2015)]
-	_ = x[NamePseudo-(2016)]
-	_ = x[NameProperty-(2017)]
-	_ = x[NameTag-(2018)]
-	_ = x[NameVariable-(2019)]
-	_ = x[NameVariableAnonymous-(2020)]
-	_ = x[NameVariableClass-(2021)]
-	_ = x[NameVariableGlobal-(2022)]
-	_ = x[NameVariableInstance-(2023)]
-	_ = x[NameVariableMagic-(2024)]
+	_ = x[NameClass-(2002)]
+	_ = x[NameConstant-(2003)]
+	_ = x[NameDecorator-(2004)]
+	_ = x[NameEntity-(2005)]
+	_ = x[NameException-(2006)]
+	_ = x[NameKeyword-(2007)]
+	_ = x[NameLabel-(2008)]
+	_ = x[NameNamespace-(2009)]
+	_ = x[NameOperator-(2010)]
+	_ = x[NameOther-(2011)]
+	_ = x[NamePseudo-(2012)]
+	_ = x[NameProperty-(2013)]
+	_ = x[NameTag-(2014)]
+	_ = x[NameBuiltin-(2100)]
+	_ = x[NameBuiltinPseudo-(2101)]
+	_ = x[NameVariable-(2200)]
+	_ = x[NameVariableAnonymous-(2201)]
+	_ = x[NameVariableClass-(2202)]
+	_ = x[NameVariableGlobal-(2203)]
+	_ = x[NameVariableInstance-(2204)]
+	_ = x[NameVariableMagic-(2205)]
+	_ = x[NameFunction-(2300)]
+	_ = x[NameFunctionMagic-(2301)]
 	_ = x[Literal-(3000)]
 	_ = x[LiteralDate-(3001)]
 	_ = x[LiteralOther-(3002)]
@@ -228,7 +228,7 @@ func _TokenTypeNoOp() {
 	_ = x[TextPunctuation-(8003)]
 }

-var _TokenTypeValues = []TokenType{Ignore, None, Other, Error, CodeLine, LineLink, LineTableTD, LineTable, LineHighlight, LineNumbersTable, LineNumbers, Line, PreWrapper, Background, EOFType, Keyword, KeywordConstant, KeywordDeclaration, KeywordNamespace, KeywordPseudo, KeywordReserved, KeywordType, Name, NameAttribute, NameBuiltin, NameBuiltinPseudo, NameClass, NameConstant, NameDecorator, NameEntity, NameException, NameFunction, NameFunctionMagic, NameKeyword, NameLabel, NameNamespace, NameOperator, NameOther, NamePseudo, NameProperty, NameTag, NameVariable, NameVariableAnonymous, NameVariableClass, NameVariableGlobal, NameVariableInstance, NameVariableMagic, Literal, LiteralDate, LiteralOther, LiteralString, LiteralStringAffix, LiteralStringAtom, LiteralStringBacktick, LiteralStringBoolean, LiteralStringChar, LiteralStringDelimiter, LiteralStringDoc, LiteralStringDouble, LiteralStringEscape, LiteralStringHeredoc, LiteralStringInterpol, LiteralStringName, LiteralStringOther, LiteralStringRegex, LiteralStringSingle, LiteralStringSymbol, LiteralNumber, LiteralNumberBin, LiteralNumberFloat, LiteralNumberHex, LiteralNumberInteger, LiteralNumberIntegerLong, LiteralNumberOct, LiteralNumberByte, Operator, OperatorWord, Punctuation, Comment, CommentHashbang, CommentMultiline, CommentSingle, CommentSpecial, CommentPreproc, CommentPreprocFile, Generic, GenericDeleted, GenericEmph, GenericError, GenericHeading, GenericInserted, GenericOutput, GenericPrompt, GenericStrong, GenericSubheading, GenericTraceback, GenericUnderline, Text, TextWhitespace, TextSymbol, TextPunctuation}
+var _TokenTypeValues = []TokenType{Ignore, None, Other, Error, CodeLine, LineLink, LineTableTD, LineTable, LineHighlight, LineNumbersTable, LineNumbers, Line, PreWrapper, Background, EOFType, Keyword, KeywordConstant, KeywordDeclaration, KeywordNamespace, KeywordPseudo, KeywordReserved, KeywordType, Name, NameAttribute, NameClass, NameConstant, NameDecorator, NameEntity, NameException, NameKeyword, NameLabel, NameNamespace, NameOperator, NameOther, NamePseudo, NameProperty, NameTag, NameBuiltin, NameBuiltinPseudo, NameVariable, NameVariableAnonymous, NameVariableClass, NameVariableGlobal, NameVariableInstance, NameVariableMagic, NameFunction, NameFunctionMagic, Literal, LiteralDate, LiteralOther, LiteralString, LiteralStringAffix, LiteralStringAtom, LiteralStringBacktick, LiteralStringBoolean, LiteralStringChar, LiteralStringDelimiter, LiteralStringDoc, LiteralStringDouble, LiteralStringEscape, LiteralStringHeredoc, LiteralStringInterpol, LiteralStringName, LiteralStringOther, LiteralStringRegex, LiteralStringSingle, LiteralStringSymbol, LiteralNumber, LiteralNumberBin, LiteralNumberFloat, LiteralNumberHex, LiteralNumberInteger, LiteralNumberIntegerLong, LiteralNumberOct, LiteralNumberByte, Operator, OperatorWord, Punctuation, Comment, CommentHashbang, CommentMultiline, CommentSingle, CommentSpecial, CommentPreproc, CommentPreprocFile, Generic, GenericDeleted, GenericEmph, GenericError, GenericHeading, GenericInserted, GenericOutput, GenericPrompt, GenericStrong, GenericSubheading, GenericTraceback, GenericUnderline, Text, TextWhitespace, TextSymbol, TextPunctuation}

 var _TokenTypeNameToValueMap = map[string]TokenType{
 	_TokenTypeName[0:6]:            Ignore,
@@ -279,52 +279,52 @@ var _TokenTypeNameToValueMap = map[string]TokenType{
 	_TokenTypeLowerName[222:226]:   Name,
 	_TokenTypeName[226:239]:        NameAttribute,
 	_TokenTypeLowerName[226:239]:   NameAttribute,
-	_TokenTypeName[239:250]:        NameBuiltin,
-	_TokenTypeLowerName[239:250]:   NameBuiltin,
-	_TokenTypeName[250:267]:        NameBuiltinPseudo,
-	_TokenTypeLowerName[250:267]:   NameBuiltinPseudo,
-	_TokenTypeName[267:276]:        NameClass,
-	_TokenTypeLowerName[267:276]:   NameClass,
-	_TokenTypeName[276:288]:        NameConstant,
-	_TokenTypeLowerName[276:288]:   NameConstant,
-	_TokenTypeName[288:301]:        NameDecorator,
-	_TokenTypeLowerName[288:301]:   NameDecorator,
-	_TokenTypeName[301:311]:        NameEntity,
-	_TokenTypeLowerName[301:311]:   NameEntity,
-	_TokenTypeName[311:324]:        NameException,
-	_TokenTypeLowerName[311:324]:   NameException,
-	_TokenTypeName[324:336]:        NameFunction,
-	_TokenTypeLowerName[324:336]:   NameFunction,
-	_TokenTypeName[336:353]:        NameFunctionMagic,
-	_TokenTypeLowerName[336:353]:   NameFunctionMagic,
-	_TokenTypeName[353:364]:        NameKeyword,
-	_TokenTypeLowerName[353:364]:   NameKeyword,
-	_TokenTypeName[364:373]:        NameLabel,
-	_TokenTypeLowerName[364:373]:   NameLabel,
-	_TokenTypeName[373:386]:        NameNamespace,
-	_TokenTypeLowerName[373:386]:   NameNamespace,
-	_TokenTypeName[386:398]:        NameOperator,
-	_TokenTypeLowerName[386:398]:   NameOperator,
-	_TokenTypeName[398:407]:        NameOther,
-	_TokenTypeLowerName[398:407]:   NameOther,
-	_TokenTypeName[407:417]:        NamePseudo,
-	_TokenTypeLowerName[407:417]:   NamePseudo,
-	_TokenTypeName[417:429]:        NameProperty,
-	_TokenTypeLowerName[417:429]:   NameProperty,
-	_TokenTypeName[429:436]:        NameTag,
-	_TokenTypeLowerName[429:436]:   NameTag,
-	_TokenTypeName[436:448]:        NameVariable,
-	_TokenTypeLowerName[436:448]:   NameVariable,
-	_TokenTypeName[448:469]:        NameVariableAnonymous,
-	_TokenTypeLowerName[448:469]:   NameVariableAnonymous,
-	_TokenTypeName[469:486]:        NameVariableClass,
-	_TokenTypeLowerName[469:486]:   NameVariableClass,
-	_TokenTypeName[486:504]:        NameVariableGlobal,
-	_TokenTypeLowerName[486:504]:   NameVariableGlobal,
-	_TokenTypeName[504:524]:        NameVariableInstance,
-	_TokenTypeLowerName[504:524]:   NameVariableInstance,
-	_TokenTypeName[524:541]:        NameVariableMagic,
-	_TokenTypeLowerName[524:541]:   NameVariableMagic,
+	_TokenTypeName[239:248]:        NameClass,
+	_TokenTypeLowerName[239:248]:   NameClass,
+	_TokenTypeName[248:260]:        NameConstant,
+	_TokenTypeLowerName[248:260]:   NameConstant,
+	_TokenTypeName[260:273]:        NameDecorator,
+	_TokenTypeLowerName[260:273]:   NameDecorator,
+	_TokenTypeName[273:283]:        NameEntity,
+	_TokenTypeLowerName[273:283]:   NameEntity,
+	_TokenTypeName[283:296]:        NameException,
+	_TokenTypeLowerName[283:296]:   NameException,
+	_TokenTypeName[296:307]:        NameKeyword,
+	_TokenTypeLowerName[296:307]:   NameKeyword,
+	_TokenTypeName[307:316]:        NameLabel,
+	_TokenTypeLowerName[307:316]:   NameLabel,
+	_TokenTypeName[316:329]:        NameNamespace,
+	_TokenTypeLowerName[316:329]:   NameNamespace,
+	_TokenTypeName[329:341]:        NameOperator,
+	_TokenTypeLowerName[329:341]:   NameOperator,
+	_TokenTypeName[341:350]:        NameOther,
+	_TokenTypeLowerName[341:350]:   NameOther,
+	_TokenTypeName[350:360]:        NamePseudo,
+	_TokenTypeLowerName[350:360]:   NamePseudo,
+	_TokenTypeName[360:372]:        NameProperty,
+	_TokenTypeLowerName[360:372]:   NameProperty,
+	_TokenTypeName[372:379]:        NameTag,
+	_TokenTypeLowerName[372:379]:   NameTag,
+	_TokenTypeName[379:390]:        NameBuiltin,
+	_TokenTypeLowerName[379:390]:   NameBuiltin,
+	_TokenTypeName[390:407]:        NameBuiltinPseudo,
+	_TokenTypeLowerName[390:407]:   NameBuiltinPseudo,
+	_TokenTypeName[407:419]:        NameVariable,
+	_TokenTypeLowerName[407:419]:   NameVariable,
+	_TokenTypeName[419:440]:        NameVariableAnonymous,
+	_TokenTypeLowerName[419:440]:   NameVariableAnonymous,
+	_TokenTypeName[440:457]:        NameVariableClass,
+	_TokenTypeLowerName[440:457]:   NameVariableClass,
+	_TokenTypeName[457:475]:        NameVariableGlobal,
+	_TokenTypeLowerName[457:475]:   NameVariableGlobal,
+	_TokenTypeName[475:495]:        NameVariableInstance,
+	_TokenTypeLowerName[475:495]:   NameVariableInstance,
+	_TokenTypeName[495:512]:        NameVariableMagic,
+	_TokenTypeLowerName[495:512]:   NameVariableMagic,
+	_TokenTypeName[512:524]:        NameFunction,
+	_TokenTypeLowerName[512:524]:   NameFunction,
+	_TokenTypeName[524:541]:        NameFunctionMagic,
+	_TokenTypeLowerName[524:541]:   NameFunctionMagic,
 	_TokenTypeName[541:548]:        Literal,
 	_TokenTypeLowerName[541:548]:   Literal,
 	_TokenTypeName[548:559]:        LiteralDate,
@@ -460,28 +460,28 @@ var _TokenTypeNames = []string{
 	_TokenTypeName[211:222],
 	_TokenTypeName[222:226],
 	_TokenTypeName[226:239],
-	_TokenTypeName[239:250],
-	_TokenTypeName[250:267],
-	_TokenTypeName[267:276],
-	_TokenTypeName[276:288],
-	_TokenTypeName[288:301],
-	_TokenTypeName[301:311],
-	_TokenTypeName[311:324],
-	_TokenTypeName[324:336],
-	_TokenTypeName[336:353],
-	_TokenTypeName[353:364],
-	_TokenTypeName[364:373],
-	_TokenTypeName[373:386],
-	_TokenTypeName[386:398],
-	_TokenTypeName[398:407],
-	_TokenTypeName[407:417],
-	_TokenTypeName[417:429],
-	_TokenTypeName[429:436],
-	_TokenTypeName[436:448],
-	_TokenTypeName[448:469],
-	_TokenTypeName[469:486],
-	_TokenTypeName[486:504],
-	_TokenTypeName[504:524],
+	_TokenTypeName[239:248],
+	_TokenTypeName[248:260],
+	_TokenTypeName[260:273],
+	_TokenTypeName[273:283],
+	_TokenTypeName[283:296],
+	_TokenTypeName[296:307],
+	_TokenTypeName[307:316],
+	_TokenTypeName[316:329],
+	_TokenTypeName[329:341],
+	_TokenTypeName[341:350],
+	_TokenTypeName[350:360],
+	_TokenTypeName[360:372],
+	_TokenTypeName[372:379],
+	_TokenTypeName[379:390],
+	_TokenTypeName[390:407],
+	_TokenTypeName[407:419],
+	_TokenTypeName[419:440],
+	_TokenTypeName[440:457],
+	_TokenTypeName[457:475],
+	_TokenTypeName[475:495],
+	_TokenTypeName[495:512],
+	_TokenTypeName[512:524],
 	_TokenTypeName[524:541],
 	_TokenTypeName[541:548],
 	_TokenTypeName[548:559],
@@ -62,15 +62,11 @@ const (
 const (
 	Name TokenType = 2000 + iota
 	NameAttribute
-	NameBuiltin
-	NameBuiltinPseudo
 	NameClass
 	NameConstant
 	NameDecorator
 	NameEntity
 	NameException
-	NameFunction
-	NameFunctionMagic
 	NameKeyword
 	NameLabel
 	NameNamespace
@@ -79,7 +75,17 @@ const (
 	NamePseudo
 	NameProperty
 	NameTag
-	NameVariable
+)
+
+// Builtin names.
+const (
+	NameBuiltin TokenType = 2100 + iota
+	NameBuiltinPseudo
+)
+
+// Variable names.
+const (
+	NameVariable TokenType = 2200 + iota
 	NameVariableAnonymous
 	NameVariableClass
 	NameVariableGlobal
@@ -87,6 +93,12 @@ const (
 	NameVariableMagic
 )

+// Function names.
+const (
+	NameFunction TokenType = 2300 + iota
+	NameFunctionMagic
+)
+
 // Literals.
 const (
 	Literal TokenType = 3000 + iota