Enum Mark 

pub enum Mark {
    Bold,
    Italic,
    Underline,
    Strikethrough,
    Code,
    Superscript,
    Subscript,
    Link {
        href: String,
        title: Option<String>,
    },
    Anchor {
        id: String,
    },
    Footnote {
        number: u32,
        id: Option<String>,
    },
    Math {
        format: MathFormat,
        source: String,
    },
    Extension(ExtensionMark),
}

Formatting marks that can be applied to text.

Marks represent inline formatting such as bold, italic, links, etc. Multiple marks can be applied to the same text node.

Serialization

Simple marks (Bold, Italic, etc.) serialize as plain strings: "bold". Complex marks (Link, Math, etc.) serialize as objects with a "type" field. Extension marks serialize with their namespaced type as "type".

Variants

Bold

Bold/strong text.

Italic

Italic/emphasized text.

Underline

Underlined text.

Strikethrough

Strikethrough text.

Code

Inline code (monospace).

Superscript

Superscript text.

Subscript

Subscript text.

Link

Hyperlink.

Fields

href: String

Link destination URL.

title: Option<String>

Optional link title.

Anchor

Named anchor mark for creating anchor points in text.

Fields

id: String

Unique identifier for this anchor.

Footnote

Footnote reference mark (semantic extension).

Links text to a footnote block elsewhere in the document.

Fields

number: u32

Sequential footnote number.

id: Option<String>

Optional unique identifier for cross-referencing.

Math

Inline mathematical expression.

Fields

format: MathFormat

Math format (latex or mathml).

source: String

The mathematical expression source.

Extension(ExtensionMark)

Extension mark for custom/unknown mark types.

Extension marks use namespaced types like “semantic:citation” or “legal:cite”. This enables extensions to add custom inline marks without modifying the core Mark enum.

Implementations

impl Mark

pub fn mark_type(&self) -> MarkType

Get the type of this mark.

pub fn is_extension(&self) -> bool

Check if this mark is an extension mark.

pub fn as_extension(&self) -> Option<&ExtensionMark>

Get the extension mark if this is one.

Trait Implementations

impl Clone for Mark

fn clone(&self) -> Mark

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mark

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Mark

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl PartialEq for Mark

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

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

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 Serialize for Mark

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for Mark

impl StructuralPartialEq for Mark