[](https://renovatebot.com) This PR contains the following updates: | Package | Update | Change | |---|---|---| | [esbuild](https://togithub.com/evanw/esbuild) | patch | `0.23.0` -> `0.23.1` | | [svu](https://togithub.com/caarlos0/svu) | minor | `2.1.0` -> `2.2.0` | --- ### Release Notes <details> <summary>evanw/esbuild (esbuild)</summary> ### [`v0.23.1`](https://togithub.com/evanw/esbuild/blob/HEAD/CHANGELOG.md#0231) [Compare Source](https://togithub.com/evanw/esbuild/compare/v0.23.0...v0.23.1) - Allow using the `node:` import prefix with `es*` targets ([#​3821](https://togithub.com/evanw/esbuild/issues/3821)) The [`node:` prefix on imports](https://nodejs.org/api/esm.html#node-imports) is an alternate way to import built-in node modules. For example, `import fs from "fs"` can also be written `import fs from "node:fs"`. This only works with certain newer versions of node, so esbuild removes it when you target older versions of node such as with `--target=node14` so that your code still works. With the way esbuild's platform-specific feature compatibility table works, this was added by saying that only newer versions of node support this feature. However, that means that a target such as `--target=node18,es2022` removes the `node:` prefix because none of the `es*` targets are known to support this feature. This release adds the support for the `node:` flag to esbuild's internal compatibility table for `es*` to allow you to use compound targets like this: ```js // Original code import fs from 'node:fs' fs.open // Old output (with --bundle --format=esm --platform=node --target=node18,es2022) import fs from "fs"; fs.open; // New output (with --bundle --format=esm --platform=node --target=node18,es2022) import fs from "node:fs"; fs.open; ``` - Fix a panic when using the CLI with invalid build flags if `--analyze` is present ([#​3834](https://togithub.com/evanw/esbuild/issues/3834)) Previously esbuild's CLI could crash if it was invoked with flags that aren't valid for a "build" API call and the `--analyze` flag is present. This was caused by esbuild's internals attempting to add a Go plugin (which is how `--analyze` is implemented) to a null build object. The panic has been fixed in this release. - Fix incorrect location of certain error messages ([#​3845](https://togithub.com/evanw/esbuild/issues/3845)) This release fixes a regression that caused certain errors relating to variable declarations to be reported at an incorrect location. The regression was introduced in version 0.18.7 of esbuild. - Print comments before case clauses in switch statements ([#​3838](https://togithub.com/evanw/esbuild/issues/3838)) With this release, esbuild will attempt to print comments that come before case clauses in switch statements. This is similar to what esbuild already does for comments inside of certain types of expressions. Note that these types of comments are not printed if minification is enabled (specifically whitespace minification). - Fix a memory leak with `pluginData` ([#​3825](https://togithub.com/evanw/esbuild/issues/3825)) With this release, the build context's internal `pluginData` cache will now be cleared when starting a new build. This should fix a leak of memory from plugins that return `pluginData` objects from `onResolve` and/or `onLoad` callbacks. </details> <details> <summary>caarlos0/svu (svu)</summary> ### [`v2.2.0`](https://togithub.com/caarlos0/svu/releases/tag/v2.2.0) #### Changelog ##### New Features - [`8e1fe56`](8e1fe5609c
): Revert "feat: try to infer sub-package tag ([#​161](https://togithub.com/caarlos0/svu/issues/161))" ([@​caarlos0](https://togithub.com/caarlos0)) ##### Bug fixes - [`fc3e2dc`](fc3e2dce4b
): Revert "fix: normalise path separators on Windows to fix sub-package tags ([#​165](https://togithub.com/caarlos0/svu/issues/165))" ([@​caarlos0](https://togithub.com/caarlos0)) *** *Released with [GoReleaser Pro](https://goreleaser.com/pro)!* ### [`v2.1.1`](https://togithub.com/caarlos0/svu/releases/tag/v2.1.1) #### Changelog ##### Bug fixes - [`6862035`](6862035746
): fix: normalise path separators on Windows to fix sub-package tags ([#​165](https://togithub.com/caarlos0/svu/issues/165)) ([@​doug-fitzmaurice-rowden](https://togithub.com/doug-fitzmaurice-rowden)) *** *Released with [GoReleaser Pro](https://goreleaser.com/pro)!* </details> --- ### Configuration 📅 **Schedule**: Branch creation - "before 4am on Monday" (UTC), Automerge - At any time (no schedule defined). 🚦 **Automerge**: Disabled by config. Please merge this manually once you are satisfied. ♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox. 👻 **Immortal**: This PR will be recreated if closed unmerged. Get [config help](https://togithub.com/renovatebot/renovate/discussions) if that's undesired. --- - [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check this box --- This PR was generated by [Mend Renovate](https://www.mend.io/free-developer-tools/renovate/). View the [repository job log](https://developer.mend.io/github/alecthomas/chroma). <!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOC4yMC4xIiwidXBkYXRlZEluVmVyIjoiMzguMjYuMSIsInRhcmdldEJyYW5jaCI6Im1hc3RlciIsImxhYmVscyI6W119--> Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Chroma — A general purpose syntax highlighter in pure Go
Chroma takes source code and other structured text and converts it into syntax highlighted HTML, ANSI-coloured text, etc.
Chroma is based heavily on Pygments, and includes translators for Pygments lexers and styles.
Table of Contents
- Supported languages
- Try it
- Using the library
- More detail
- Command-line interface
- Testing lexers
- What's missing compared to Pygments?
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, 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 |
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 |
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 |
I will attempt to keep this section up to date, but an authoritative list can be
displayed with chroma --list
.
Try it
Try out various languages and styles on the Chroma Playground.
Using the library
This is version 2 of Chroma, use the import path:
import "github.com/alecthomas/chroma/v2"
Chroma, like Pygments, has the concepts of lexers, formatters and styles.
Lexers convert source text into a stream of tokens, styles specify how token types are mapped to colours, and formatters convert tokens and styles into formatted output.
A package exists for each of these, containing a global Registry
variable
with all of the registered implementations. There are also helper functions
for using the registry in each package, such as looking up lexers by name or
matching filenames, etc.
In all cases, if a lexer, formatter or style can not be determined, nil
will
be returned. In this situation you may want to default to the Fallback
value in each respective package, which provides sane defaults.
Quick start
A convenience function exists that can be used to simply format some source text, without any effort:
err := quick.Highlight(os.Stdout, someSourceCode, "go", "html", "monokai")
Identifying the language
To highlight code, you'll first have to identify what language the code is written in. There are three primary ways to do that:
-
Detect the language from its filename.
lexer := lexers.Match("foo.go")
-
Explicitly specify the language by its Chroma syntax ID (a full list is available from
lexers.Names()
).lexer := lexers.Get("go")
-
Detect the language from its content.
lexer := lexers.Analyse("package main\n\nfunc main()\n{\n}\n")
In all cases, nil
will be returned if the language can not be identified.
if lexer == nil {
lexer = lexers.Fallback
}
At this point, it should be noted that some lexers can be extremely chatty. To mitigate this, you can use the coalescing lexer to coalesce runs of identical token types into a single token:
lexer = chroma.Coalesce(lexer)
Formatting the output
Once a language is identified you will need to pick a formatter and a style (theme).
style := styles.Get("swapoff")
if style == nil {
style = styles.Fallback
}
formatter := formatters.Get("html")
if formatter == nil {
formatter = formatters.Fallback
}
Then obtain an iterator over the tokens:
contents, err := ioutil.ReadAll(r)
iterator, err := lexer.Tokenise(nil, string(contents))
And finally, format the tokens from the iterator:
err := formatter.Format(w, style, iterator)
The HTML formatter
By default the html
registered formatter generates standalone HTML with
embedded CSS. More flexibility is available through the formatters/html
package.
Firstly, the output generated by the formatter can be customised with the following constructor options:
Standalone()
- generate standalone HTML with embedded CSS.WithClasses()
- use classes rather than inlined style attributes.ClassPrefix(prefix)
- prefix each generated CSS class.TabWidth(width)
- Set the rendered tab width, in characters.WithLineNumbers()
- Render line numbers (style withLineNumbers
).WithLinkableLineNumbers()
- Make the line numbers linkable and be a link to themselves.HighlightLines(ranges)
- Highlight lines in these ranges (style withLineHighlight
).LineNumbersInTable()
- Use a table for formatting line numbers and code, rather than spans.
If WithClasses()
is used, the corresponding CSS can be obtained from the formatter with:
formatter := html.New(html.WithClasses(true))
err := formatter.WriteCSS(w, style)
More detail
Lexers
See the Pygments documentation for details on implementing lexers. Most concepts apply directly to Chroma, but see existing lexer implementations for real examples.
In many cases lexers can be automatically converted directly from Pygments by
using the included Python 3 script pygments2chroma_xml.py
. I use something like
the following:
python3 _tools/pygments2chroma_xml.py \
pygments.lexers.jvm.KotlinLexer \
> lexers/embedded/kotlin.xml
See notes in pygments-lexers.txt for a list of lexers, and notes on some of the issues importing them.
Formatters
Chroma supports HTML output, as well as terminal output in 8 colour, 256 colour, and true-colour.
A noop
formatter is included that outputs the token text only, and a tokens
formatter outputs raw tokens. The latter is useful for debugging lexers.
Styles
Chroma styles are defined in XML. The style entries use the same syntax as Pygments.
All Pygments styles have been converted to Chroma using the _tools/style.py
script.
When you work with one of Chroma's styles,
know that the Background
token type provides the default style for tokens. It does so
by defining a foreground color and background color.
For example, this gives each token name not defined in the style a default color
of #f8f8f8
and uses #000000
for the highlighted code block's background:
<entry type="Background" style="#f8f8f2 bg:#000000"/>
Also, token types in a style file are hierarchical. For instance, when CommentSpecial
is not defined, Chroma uses the token style from Comment
. So when several comment tokens use the same color, you'll only need to define Comment
and override the one that has a different color.
For a quick overview of the available styles and how they look, check out the Chroma Style Gallery.
Command-line interface
A command-line interface to Chroma is included.
Binaries are available to install from the releases page.
The CLI can be used as a preprocessor to colorise output of less(1)
,
see documentation for the LESSOPEN
environment variable.
The --fail
flag can be used to suppress output and return with exit status
1 to facilitate falling back to some other preprocessor in case chroma
does not resolve a specific lexer to use for the given file. For example:
export LESSOPEN='| p() { chroma --fail "$1" || cat "$1"; }; p "%s"'
Replace cat
with your favourite fallback preprocessor.
When invoked as .lessfilter
, the --fail
flag is automatically turned
on under the hood for easy integration with lesspipe shipping with
Debian and derivatives;
for that setup the chroma
executable can be just symlinked to ~/.lessfilter
.
Testing lexers
If you edit some lexers and want to try it, open a shell in cmd/chromad
and run:
go run . --csrf-key=securekey
A Link will be printed. Open it in your Browser. Now you can test on the Playground with your local changes.
If you want to run the tests and the lexers, open a shell in the root directory and run:
go test ./lexers
When updating or adding a lexer, please add tests. See lexers/README.md for more.
What's missing compared to Pygments?
- Quite a few lexers, for various reasons (pull-requests welcome):
- Pygments lexers for complex languages often include custom code to handle certain aspects, such as Raku's ability to nest code inside regular expressions. These require time and effort to convert.
- I mostly only converted languages I had heard of, to reduce the porting cost.
- Some more esoteric features of Pygments are omitted for simplicity.
- Though the Chroma API supports content detection, very few languages support them. I have plans to implement a statistical analyser at some point, but not enough time.