The ANSI pieces the built-in :terminal formatter is assembled from.

A module implementing Lumis.Formatter gets an event stream and has to turn it into output; these helpers apply the same colors, text decorations, and reset behavior as the built-in formatter.

Example

defmodule MyTerminalFormatter do
  @behaviour Lumis.Formatter

  alias Lumis.Formatter.ANSI

  @impl true
  def render(source, events, options) do
    theme = Keyword.get(options, :theme)

    {output, _scopes, _tables} =
      Enum.reduce(events, {[], [], %{}}, fn
        {:start, %{scope: scope, language: language}}, {output, scopes, tables} ->
          {output, [{scope, language} | scopes], tables}

        :end, {output, [_scope | scopes], tables} ->
          {output, scopes, tables}

        {:source, %{start: start, end: stop}}, {output, scopes, tables} ->
          text = binary_part(source, start, stop - start)

          case scopes do
            [] ->
              {[text | output], scopes, tables}

            [{scope, language} | _rest] ->
              # One table per language, built once and read per token.
              tables =
                Map.put_new_lazy(tables, language, fn ->
                  ANSI.styles(theme: theme, language: language)
                end)

              painted = ANSI.paint(text, ANSI.style_for(tables[language], scope))
              {[painted | output], scopes, tables}
          end

        # Lumis adds event kinds as it grows. Render the ones you know and
        # skip the rest, or a newer Lumis raises FunctionClauseError here.
        _event, state ->
          state
      end)

    Enum.reverse(output)
  end
end

Lumis.highlight!("defmodule App do\nend",
  formatter: {MyTerminalFormatter, language: "elixir", theme: "dracula"}
)