Struct RawElem

pub struct RawElem {
    pub text: RawContent,
    /* private fields */
}

Raw text with optional syntax highlighting.

Displays the text verbatim and in a monospace font. This is typically used to embed computer code into your document.

Example

Adding `rbx` to `rcx` gives
the desired result.

What is ```rust fn main()``` in Rust
would be ```c int main()``` in C.

```rust
fn main() {
    println!("Hello World!");
}
```

This has ``` `backticks` ``` in it
(but the spaces are trimmed). And
``` here``` the leading space is
also trimmed.

You can also construct a [raw] element programmatically from a string (and provide the language tag via the optional lang argument).

#raw("fn " + "main() {}", lang: "rust")

Syntax

This function also has dedicated syntax. You can enclose text in 1 or 3+ backticks (`) to make it raw. Two backticks produce empty raw text. This works both in markup and code.

When you use three or more backticks, you can additionally specify a language tag for syntax highlighting directly after the opening backticks. Within raw blocks, everything (except for the language tag, if applicable) is rendered as is, in particular, there are no escape sequences.

The language tag is an identifier that directly follows the opening backticks only if there are three or more backticks. If your text starts with something that looks like an identifier, but no syntax highlighting is needed, start the text with a single space (which will be trimmed) or use the single backtick syntax. If your text should start or end with a backtick, put a space before or after it (it will be trimmed).

Fields

text: RawContent

Implementations

impl RawElem

pub fn new(text: RawContent) -> Self

Create a new instance of the element.

pub fn with_block(self, block: bool) -> Self

Builder-style setter for the block field.

pub fn with_lang(self, lang: Option<EcoString>) -> Self

Builder-style setter for the lang field.

pub fn with_align(self, align: HAlignment) -> Self

Builder-style setter for the align field.

pub fn with_syntaxes( self, syntaxes: Derived<OneOrMultiple<DataSource>, Vec<RawSyntax>>, ) -> Self

Builder-style setter for the syntaxes field.

pub fn with_theme( self, theme: Smart<Option<Derived<DataSource, RawTheme>>>, ) -> Self

Builder-style setter for the theme field.

pub fn with_tab_size(self, tab_size: usize) -> Self

Builder-style setter for the tab-size field.

pub fn with_lines(self, lines: Vec<Packed<RawLine>>) -> Self

Builder-style setter for the lines field.

pub fn push_block(&mut self, block: bool)

Setter for the block field.

pub fn push_lang(&mut self, lang: Option<EcoString>)

Setter for the lang field.

pub fn push_align(&mut self, align: HAlignment)

Setter for the align field.

pub fn push_syntaxes( &mut self, syntaxes: Derived<OneOrMultiple<DataSource>, Vec<RawSyntax>>, )

Setter for the syntaxes field.

pub fn push_theme( &mut self, theme: Smart<Option<Derived<DataSource, RawTheme>>>, )

Setter for the theme field.

pub fn push_tab_size(&mut self, tab_size: usize)

Setter for the tab-size field.

pub fn push_lines(&mut self, lines: Vec<Packed<RawLine>>)

Setter for the lines field.

pub fn block(&self, styles: StyleChain<'_>) -> bool

Whether the raw text is displayed as a separate block.

In markup mode, using one-backtick notation makes this {false}. Using three-backtick notation makes it {true} if the enclosed content contains at least one line break.

// Display inline code in a small box
// that retains the correct baseline.
#show raw.where(block: false): box.with(
  fill: luma(240),
  inset: (x: 3pt, y: 0pt),
  outset: (y: 3pt),
  radius: 2pt,
)

// Display block code in a larger block
// with more padding.
#show raw.where(block: true): block.with(
  fill: luma(240),
  inset: 10pt,
  radius: 4pt,
)

With `rg`, you can search through your files quickly.
This example searches the current directory recursively
for the text `Hello World`:

```bash
rg "Hello World"
```

pub fn lang<'a>(&'a self, styles: StyleChain<'a>) -> &'a Option<EcoString>

The language to syntax-highlight in.

Apart from typical language tags known from Markdown, this supports the {"typ"}, {"typc"}, and {"typm"} tags for Typst markup, Typst code, and Typst math, respectively.

```typ
This is *Typst!*
```

This is ```typ also *Typst*```, but inline!

pub fn align(&self, styles: StyleChain<'_>) -> HAlignment

The horizontal alignment that each line in a raw block should have. This option is ignored if this is not a raw block (if specified block: false or single backticks were used in markup mode).

By default, this is set to {start}, meaning that raw text is aligned towards the start of the text direction inside the block by default, regardless of the current context’s alignment (allowing you to center the raw block itself without centering the text inside it, for example).

#set raw(align: center)

```typc
let f(x) = x
code = "centered"
```

pub fn syntaxes( &self, styles: StyleChain<'_>, ) -> Derived<OneOrMultiple<DataSource>, Vec<RawSyntax>>

Additional syntax definitions to load. The syntax definitions should be in the sublime-syntax file format.

You can pass any of the following values:

• A path string to load a syntax file from the given path. For more details about paths, see the Paths section.
• Raw bytes from which the syntax should be decoded.
• An array where each item is one the above.

#set raw(syntaxes: "SExpressions.sublime-syntax")

```sexp
(defun factorial (x)
  (if (zerop x)
    ; with a comment
    1
    (* x (factorial (- x 1)))))
```

pub fn theme<'a>( &'a self, styles: StyleChain<'a>, ) -> &'a Smart<Option<Derived<DataSource, RawTheme>>>

The theme to use for syntax highlighting. Themes should be in the tmTheme file format.

You can pass any of the following values:

• {none}: Disables syntax highlighting.
• {auto}: Highlights with Typst’s default theme.
• A path string to load a theme file from the given path. For more details about paths, see the Paths section.
• Raw bytes from which the theme should be decoded.

Applying a theme only affects the color of specifically highlighted text. It does not consider the theme’s foreground and background properties, so that you retain control over the color of raw text. You can apply the foreground color yourself with the [text] function and the background with a filled block. You could also use the [xml] function to extract these properties from the theme.

#set raw(theme: "halcyon.tmTheme")
#show raw: it => block(
  fill: rgb("#1d2433"),
  inset: 8pt,
  radius: 5pt,
  text(fill: rgb("#a2aabc"), it)
)

```typ
= Chapter 1
#let hi = "Hello World"
```

pub fn tab_size(&self, styles: StyleChain<'_>) -> usize

The size for a tab stop in spaces. A tab is replaced with enough spaces to align with the next multiple of the size.

#set raw(tab-size: 8)
```tsv
Year	Month	Day
2000	2	3
2001	2	1
2002	3	10
```

pub fn lines(&self) -> Option<&Vec<Packed<RawLine>>>

The stylized lines of raw text.

Made accessible for the raw.line element. Allows more styling control in show rules.

pub fn block_in(styles: StyleChain<'_>) -> bool

Access the block field in the given style chain.

pub fn lang_in(styles: StyleChain<'_>) -> &Option<EcoString>

Access the lang field in the given style chain.

pub fn align_in(styles: StyleChain<'_>) -> HAlignment

Access the align field in the given style chain.

pub fn syntaxes_in( styles: StyleChain<'_>, ) -> Derived<OneOrMultiple<DataSource>, Vec<RawSyntax>>

Access the syntaxes field in the given style chain.

pub fn theme_in( styles: StyleChain<'_>, ) -> &Smart<Option<Derived<DataSource, RawTheme>>>

Access the theme field in the given style chain.

pub fn tab_size_in(styles: StyleChain<'_>) -> usize

Access the tab-size field in the given style chain.

pub fn set_block(block: bool) -> Property

Create a style property for the block field.

pub fn set_lang(lang: Option<EcoString>) -> Property

Create a style property for the lang field.

pub fn set_align(align: HAlignment) -> Property

Create a style property for the align field.

pub fn set_syntaxes( syntaxes: Derived<OneOrMultiple<DataSource>, Vec<RawSyntax>>, ) -> Property

Create a style property for the syntaxes field.

pub fn set_theme( theme: Smart<Option<Derived<DataSource, RawTheme>>>, ) -> Property

Create a style property for the theme field.

pub fn set_tab_size(tab_size: usize) -> Property

Create a style property for the tab-size field.

impl RawElem

pub fn languages() -> Vec<(&'static str, Vec<&'static str>)>

The supported language names and tags.

Trait Implementations

impl Capable for RawElem

fn vtable(capability: TypeId) -> Option<NonNull<()>>

Get the pointer to the vtable for the given capability / trait.

impl Clone for RawElem

fn clone(&self) -> RawElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for RawElem

fn construct(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Content>

Construct an element from the arguments.

impl Debug for RawElem

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

Formats the value using the given formatter.

impl Fields for RawElem

type Enum = Fields

An enum with the fields of the element.

fn has(&self, id: u8) -> bool

Whether the element has the given field set.

fn field(&self, id: u8) -> Result<Value, FieldAccessError>

Get the field with the given field ID.

fn field_with_styles( &self, id: u8, styles: StyleChain<'_>, ) -> Result<Value, FieldAccessError>

Get the field with the given ID in the presence of styles.

fn field_from_styles( id: u8, styles: StyleChain<'_>, ) -> Result<Value, FieldAccessError>

Get the field with the given ID from the styles.

fn materialize(&mut self, styles: StyleChain<'_>)

Resolve all fields with the styles and save them in-place.

fn fields(&self) -> Dict

Get the fields of the element.

impl Hash for RawElem

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoValue for RawElem

fn into_value(self) -> Value

Cast this type into a value.

impl NativeElement for RawElem

fn data() -> &'static NativeElementData

Get the element data for the native Rust element.

fn elem() -> Element

where Self: Sized,

Get the element for the native Rust element.

fn pack(self) -> Content

where Self: Sized,

Pack the element into type-erased content.

impl NativeScope for RawElem

fn constructor() -> Option<&'static NativeFuncData>

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl PartialEq for RawElem

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Repr for RawElem

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Set for RawElem

fn set(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Styles>

Parse relevant arguments into style properties for this element.