Struct Highlight 

pub struct Highlight {

    pub themes: Option<Map<String, Value>>,
    pub theme: Option<String>,
    pub default_language: Option<String>,
    pub fallback_language: Option<String>,
    pub color_replacements: BTreeMap<String, ColorReplacement>,
    pub add_language_class: bool,
    pub inline: Option<InlineCode>,
    pub meta_property: Option<String>,
    pub transformers: Vec<HighlightTransformer>,
    pub tokenize_max_line_length: Option<usize>,
    pub line_attributes: BTreeMap<String, LineMark>,
    pub word_attribute: Option<String>,
    pub line_number_attribute: Option<String>,
    pub skip_elements: bool,
    pub keep_properties: bool,
}

html.highlight: code blocks colored as Shiki colors them, natively by giallo; options named as @shikijs/rehype names them.

Fields

themes: Option<Map<String, Value>>

The theme of each color mode, light first, as {"light": …, "dark": …}.

theme: Option<String>

The one theme, when themes is not given.

default_language: Option<String>

The language of a block that names none; such a block is left alone without it.

fallback_language: Option<String>

The language of a block naming one Shiki does not know; left alone without it.

color_replacements: BTreeMap<String, ColorReplacement>

Colors to replace, by their lowercase spelling: a color for every theme, or a theme’s name to a map of its own.

add_language_class: bool

Add language-<name> to each highlighted <code>.

inline: Option<InlineCode>

Highlight inline code too, by how it names its language: tailing-curly-colon reads `a(){:js}`.

meta_property: Option<String>

The <pre> property that gets a block’s meta, the text after its language; the JSON stand-in for parseMetaString: meta => ({ [name]: meta }).

transformers: Vec<HighlightTransformer>

The transformers of @shikijs/transformers to run, in order, by name or with options.

tokenize_max_line_length: Option<usize>

Lines at least this long, in UTF-16 units, are left one plain token as Shiki’s own option leaves them; 2,000 when left out, where Shiki has no limit, since a grammar’s time grows with the square of a line’s length. 0 lifts it.

line_attributes: BTreeMap<String, LineMark>

Attributes of a block’s <code> or <pre> listing lines, 2,4-5, each to the classes those lines get, or to {line, pre}, the second for the <pre>: {"data-focus": {"line": "focused", "pre": "has-focused"}}.

word_attribute: Option<String>

The attribute of a block’s <code> or <pre> listing words, separated by commas, marked at every place as metaWordHighlight marks a meta’s /word/.

line_number_attribute: Option<String>

The attribute of a block’s <code> or <pre> that numbers its lines as renderLineNumber does, from its value, or 1 when it is empty.

skip_elements: bool

Leave a block alone when its code holds elements, such as <mark>, which highlighting would flatten into text.

keep_properties: bool

Keep the properties of a block’s <pre> and <code>, such as data-title, on the ones Shiki makes, merging classes; Shiki’s own win where both set one.

Trait Implementations

impl Clone for Highlight

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Highlight

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Highlight

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Highlight

where Highlight: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Plugin for Highlight

fn attach(&self, context: &mut Attach) -> Result<(), Error>

impl Transform for Highlight

fn input(&self) -> TreeKind

fn output(&self) -> TreeKind

fn run<'a>( &self, tree: Tree<'a>, _file: &mut File, alloc: &'a Allocator, ) -> Result<Tree<'a>, Error>

fn start<'a>( &self, tree: Tree<'a>, file: &mut File, alloc: &'a Bump, ) -> Result<Step<'a>, Error>

Start the stage: a finished tree, or a job when its work is asynchronous.

fn host(&self) -> Option<u32>

The id of the binding function this stage stands for, which takes and returns whatever tree reaches it; None for a stage the crate runs.

fn html_writer(&self, _target: HtmlTarget) -> Option<Box<dyn HtmlWriter>>

Something that writes, from this stage’s input, the HTML a compiler aiming at target would write from its output, when the stage can skip building that tree.