Ironmark

https://docs.rs/ironmark/2.0.7/ironmark/
Admin
Ironmark is a fast, CommonMark 0.31.2 compliant Markdown-to-HTML parser and renderer for Rust with...
Tokens:5,002
Snippets:59
Trust Score:9.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### Customizing ParseOptions

Source: https://docs.rs/ironmark/2.0.7/ironmark/struct.ParseOptions.html

Example of initializing ParseOptions with default values and overriding specific fields for custom rendering behavior.

```rust
use ironmark::{render_html, ParseOptions};

let html = render_html("~~strike~~ ==highlight==", &ParseOptions {
    enable_strikethrough: true,
    enable_highlight: true,
    ..Default::default()
});
```

--------------------------------

### Access Table Cells

Source: https://docs.rs/ironmark/2.0.7/ironmark/ast/struct.TableData.html

Example demonstrating how to parse Markdown into a table and access specific cells using row-major indexing.

```rust
let ast = parse_markdown("| A | B |\n|---|---|\n| 1 | 2 |", &ParseOptions::default());
if let Block::Document { children } = ast {
    if let Block::Table(t) = &children[0] {
        assert_eq!(t.header[0], "A");
        assert_eq!(t.rows[0 * t.num_cols + 1], "2"); // row 0, col 1
    }
}
```

--------------------------------

### Render Markdown to HTML with ironmark

Source: https://docs.rs/ironmark/2.0.7/ironmark/index.html

Demonstrates basic usage with default settings and how to disable specific extensions using ParseOptions.

```rust
use ironmark::{render_html, ParseOptions};

// With defaults (all extensions enabled)
let html = render_html("# Hello, **world**!", &ParseOptions::default());

// Disable specific extensions
let opts = ParseOptions {
    enable_strikethrough: false,
    enable_tables: false,
    ..Default::default()
};
let html = render_html("Plain CommonMark only.", &opts);
```

--------------------------------

### Initialize AnsiOptions with Defaults

Source: https://docs.rs/ironmark/2.0.7/ironmark/struct.AnsiOptions.html

Demonstrates creating an AnsiOptions instance using the Default trait and verifying its initial state.

```rust
use ironmark::AnsiOptions;
let opts = AnsiOptions::default();
assert_eq!(opts.width, 80);
assert!(opts.color);
assert!(!opts.line_numbers);
```

--------------------------------

### pub fn render_html(markdown: &str, options: &ParseOptions) -> String

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.render_html.html

Renders a markdown string into HTML using the specified parsing options.

```APIDOC
## render_html

### Description
Converts a provided markdown string into an HTML string. This function requires a reference to a markdown string and a set of ParseOptions.

### Signature
`pub fn render_html(markdown: &str, options: &ParseOptions) -> String`

### Parameters
- **markdown** (&str) - The markdown content to be rendered.
- **options** (&ParseOptions) - Configuration options for the markdown parser.

### Returns
- **String** - The resulting HTML output.
```

--------------------------------

### Render Markdown to ANSI Terminal Output

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.render_ansi_terminal.html

Demonstrates rendering markdown with default settings, disabling color, and enabling line numbers in code blocks.

```rust
use ironmark::{render_ansi_terminal, AnsiOptions, ParseOptions};

// Defaults
let out = render_ansi_terminal("# Hello\n\n**bold**", &ParseOptions::default(), None);
assert!(out.contains("Hello"));
assert!(out.contains('\x1b'));

// Plain text (no ANSI escapes)
let opts = AnsiOptions { color: false, ..AnsiOptions::default() };
let plain = render_ansi_terminal("# Hello\n\n> quote", &ParseOptions::default(), Some(&opts));
assert!(!plain.contains('\x1b'));

// Line numbers in code blocks
let opts = AnsiOptions { line_numbers: true, ..AnsiOptions::default() };
let out = render_ansi_terminal("```rust\nfn main() {}\n```", &ParseOptions::default(), Some(&opts));
assert!(out.contains('1'));
```

--------------------------------

### render_ansi_terminal(markdown: &str, options: &ParseOptions, aopts: Option<&AnsiOptions>) -> String

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.render_ansi_terminal.html

Parses markdown and renders it as ANSI-colored terminal output. Pass Some(&AnsiOptions) to control terminal width, color, or line numbers, or None to use default settings.

```APIDOC
## Function: render_ansi_terminal

### Description
Parses a markdown string and converts it into a string containing ANSI escape sequences for terminal rendering.

### Signature
`pub fn render_ansi_terminal(markdown: &str, options: &ParseOptions, aopts: Option<&AnsiOptions>) -> String`

### Parameters
- **markdown** (&str) - The markdown content to be rendered.
- **options** (&ParseOptions) - Configuration options for the markdown parser.
- **aopts** (Option<&AnsiOptions>) - Optional configuration for ANSI output, including terminal width, color settings, and line number toggles. Pass `None` for default settings (width 80, color enabled, no line numbers).

### Returns
- **String** - The rendered ANSI-formatted string.

### Example
```rust
use ironmark::{render_ansi_terminal, AnsiOptions, ParseOptions};

// Render with default settings
let out = render_ansi_terminal("# Hello\n\n**bold**", &ParseOptions::default(), None);

// Render with custom ANSI options
let opts = AnsiOptions { color: false, ..AnsiOptions::default() };
let plain = render_ansi_terminal("# Hello", &ParseOptions::default(), Some(&opts));
```
```

--------------------------------

### render_ansi_terminal(markdown: &str) -> String

Source: https://docs.rs/ironmark

Parses Markdown and renders it as ANSI-coloured terminal output.

```APIDOC
## render_ansi_terminal

### Description
Parses a Markdown string and renders it as an ANSI-coloured string suitable for terminal output.

### Signature
`pub fn render_ansi_terminal(markdown: &str) -> String`

### Parameters
- **markdown** (&str) - The input Markdown string to be rendered.
```

--------------------------------

### Convert HTML to Markdown in Rust

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.html_to_markdown.html

Demonstrates the basic usage of html_to_markdown to convert a simple HTML string into Markdown.

```rust
use ironmark::{html_to_markdown, HtmlParseOptions};

let md = html_to_markdown(
    "<p><strong>Bold</strong> and <em>italic</em></p>",
    &HtmlParseOptions::default()
);
assert_eq!(md.trim(), "**Bold** and *italic*");
```

--------------------------------

### ironmark_render_html

Source: https://docs.rs/ironmark/2.0.7/ironmark/ffi/index.html

Parses markdown input and returns a heap-allocated HTML string.

```APIDOC
## ironmark_render_html

### Description
Parses markdown input and returns a heap-allocated HTML string.

### Signature
`char* ironmark_render_html(const char* input)`
```

--------------------------------

### Render Markdown from AST

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.render_markdown.html

Converts a parsed AST back into a Markdown string. Requires the ironmark crate with parse_markdown and render_markdown imports.

```rust
use ironmark::{parse_markdown, ParseOptions};
use ironmark::render_markdown;

let ast = parse_markdown("# Hello\n\n**world**", &ParseOptions::default());
let md = render_markdown(&ast);
assert!(md.contains("# Hello"));
```

--------------------------------

### render_html Function Signature

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.render_html.html

The function signature for rendering markdown to HTML within the ironmark crate.

```rust
pub fn render_html(markdown: &str, options: &ParseOptions) -> String
```

--------------------------------

### ParseOptions Struct Definition

Source: https://docs.rs/ironmark/2.0.7/ironmark/struct.ParseOptions.html

The full definition of the ParseOptions struct showing all available configuration fields.

```rust
pub struct ParseOptions {Show 20 fields
    pub hard_breaks: bool,
    pub enable_highlight: bool,
    pub enable_strikethrough: bool,
    pub enable_underline: bool,
    pub enable_tables: bool,
    pub enable_autolink: bool,
    pub enable_task_lists: bool,
    pub disable_raw_html: bool,
    pub max_nesting_depth: usize,
    pub max_input_size: usize,
    pub enable_heading_ids: bool,
    pub enable_heading_anchors: bool,
    pub enable_indented_code_blocks: bool,
    pub no_html_blocks: bool,
    pub no_html_spans: bool,
    pub tag_filter: bool,
    pub collapse_whitespace: bool,
    pub permissive_atx_headers: bool,
    pub enable_wiki_links: bool,
    pub enable_latex_math: bool,
}
```

--------------------------------

### pub fn html_to_markdown(html: &str, options: &HtmlParseOptions) -> String

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.html_to_markdown.html

Parses an HTML string and converts it into a Markdown string based on the provided HtmlParseOptions.

```APIDOC
## html_to_markdown

### Description
Parses HTML and renders it directly to Markdown. This is a convenience function combining `parse_html_to_ast` and `render_markdown`.

### Signature
`pub fn html_to_markdown(html: &str, options: &HtmlParseOptions) -> String`

### Parameters
- **html** (&str) - The HTML content to be converted.
- **options** (&HtmlParseOptions) - Configuration options for the HTML parsing process.

### Returns
- **String** - The resulting Markdown representation of the input HTML.

### Example
```rust
use ironmark::{html_to_markdown, HtmlParseOptions};

let md = html_to_markdown(
    "<p><strong>Bold</strong> and <em>italic</em></p>",
    &HtmlParseOptions::default()
);
assert_eq!(md.trim(), "**Bold** and *italic*");
```
```

--------------------------------

### render_markdown(root: &Block) -> String

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.render_markdown.html

Renders a parsed AST back into a Markdown string. This function is used to convert an AST structure (generated by parse_markdown or parse_html_to_ast) back into valid Markdown syntax.

```APIDOC
## render_markdown

### Description
Converts a parsed AST (from `parse_markdown` or `parse_html_to_ast`) back into a Markdown string.

### Signature
`pub fn render_markdown(root: &Block) -> String`

### Parameters
- **root** (&Block) - The root node of the AST to be rendered.

### Returns
- **String** - The resulting Markdown formatted string.

### Example
```rust
use ironmark::{parse_markdown, ParseOptions};
use ironmark::render_markdown;

let ast = parse_markdown("# Hello\n\n**world**", &ParseOptions::default());
let md = render_markdown(&ast);
assert!(md.contains("# Hello"));
```
```

--------------------------------

### Parse Markdown to AST

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.parse_markdown.html

Parses a Markdown string into a Block AST using default options and verifies the document structure.

```rust
use ironmark::{parse_markdown, ParseOptions, Block};

let ast = parse_markdown("# Hello", &ParseOptions::default());
match &ast {
    Block::Document { children } => {
        assert_eq!(children.len(), 1);
    }
    _ => panic!("expected Document"),
}
```

--------------------------------

### Secure Markdown Rendering

Source: https://docs.rs/ironmark/2.0.7/ironmark/index.html

Configures ParseOptions to disable raw HTML and limit input size when processing untrusted content.

```rust
use ironmark::{render_html, ParseOptions};

let opts = ParseOptions {
    disable_raw_html: true,  // escape HTML blocks & inline HTML
    max_input_size: 1_000_000, // limit input to 1 MB
    ..Default::default()
};
let html = render_html("<script>alert(1)</script>", &opts);
assert!(!html.contains("<script>"));
```

--------------------------------

### ironmark_free

Source: https://docs.rs/ironmark/2.0.7/ironmark/ffi/index.html

Frees a string previously returned by ironmark_render_html.

```APIDOC
## ironmark_free

### Description
Frees a string previously returned by `ironmark_render_html`.

### Signature
`void ironmark_free(char* ptr)`
```

--------------------------------

### Parse HTML to AST

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.parse_html_to_ast.html

Converts an HTML string into a Block AST structure using default parsing options.

```rust
use ironmark::{parse_html_to_ast, HtmlParseOptions, Block};

let ast = parse_html_to_ast("<h1>Hello</h1><p>World</p>", &HtmlParseOptions::default());
match ast {
    Block::Document { children } => {
        assert_eq!(children.len(), 2);
    }
    _ => panic!("expected Document"),
}
```

--------------------------------

### parse_markdown

Source: https://docs.rs/ironmark/2.0.7/ironmark/index.html

Parses a Markdown string and returns the block-level AST.

```APIDOC
## parse_markdown(markdown: &str) -> Vec<Block>

### Description
Parses a Markdown string and returns the block-level Abstract Syntax Tree (AST) representation.

### Parameters
- **markdown** (&str) - Required - The Markdown input string to be parsed.
```

--------------------------------

### Deallocate memory with ironmark_free

Source: https://docs.rs/ironmark/2.0.7/ironmark/ffi/fn.ironmark_free.html

Use this function to free a pointer previously returned by ironmark_render_html. The pointer must be valid or null.

```rust
#[unsafe(no_mangle)]
pub unsafe extern "C" fn ironmark_free(ptr: *mut c_char)
```

--------------------------------

### Define AnsiOptions Struct

Source: https://docs.rs/ironmark/2.0.7/ironmark/struct.AnsiOptions.html

The structure definition for AnsiOptions, containing fields for terminal rendering configuration.

```rust
pub struct AnsiOptions {
    pub width: usize,
    pub color: bool,
    pub line_numbers: bool,
    pub padding: usize,
}
```

--------------------------------

### parse_html_to_ast(html: &str, options: &HtmlParseOptions) -> Block

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.parse_html_to_ast.html

Parses an HTML string into a block-level AST structure.

```APIDOC
## Function: parse_html_to_ast

### Description
Parses an HTML string and returns the block-level AST. This function is used to convert HTML into the same `Block` AST structure used by the markdown parser.

### Signature
`pub fn parse_html_to_ast(html: &str, options: &HtmlParseOptions) -> Block`

### Parameters
- **html** (&str) - The HTML string to be parsed.
- **options** (&HtmlParseOptions) - Configuration options for the HTML parsing process.

### Returns
- **Block** - The resulting block-level AST structure.

### Example
```rust
use ironmark::{parse_html_to_ast, HtmlParseOptions, Block};

let ast = parse_html_to_ast("<h1>Hello</h1><p>World</p>", &HtmlParseOptions::default());
match ast {
    Block::Document { children } => {
        assert_eq!(children.len(), 2);
    }
    _ => panic!("expected Document"),
}
```
```

--------------------------------

### ironmark_render_html function signature

Source: https://docs.rs/ironmark/2.0.7/ironmark/ffi/fn.ironmark_render_html.html

The function signature for the FFI-exposed markdown renderer. The caller is responsible for freeing the returned pointer using ironmark_free.

```rust
#[unsafe(no_mangle)]
pub unsafe extern "C" fn ironmark_render_html(
    input: *const c_char,
) -> *mut c_char
```

--------------------------------

### pub fn parse_markdown(markdown: &str, options: &ParseOptions) -> Block

Source: https://docs.rs/ironmark/2.0.7/ironmark/fn.parse_markdown.html

Parses a Markdown string and returns the block-level AST. This function is useful for programmatic inspection or transformation of the document structure without rendering to HTML.

```APIDOC
## parse_markdown

### Description
Parses a Markdown string and returns the block-level AST. This returns the raw AST without rendering to HTML, useful for programmatic inspection or transformation of the document structure.

### Signature
`pub fn parse_markdown(markdown: &str, options: &ParseOptions) -> Block`

### Parameters
- **markdown** (&str) - The input Markdown string to be parsed.
- **options** (&ParseOptions) - Configuration options for the parsing process.

### Returns
- **Block** - The root block-level AST node representing the parsed document.

### Example
```rust
use ironmark::{parse_markdown, ParseOptions, Block};

let ast = parse_markdown("# Hello", &ParseOptions::default());
match &ast {
    Block::Document { children } => {
        assert_eq!(children.len(), 1);
    }
    _ => panic!("expected Document"),
}
```
```

--------------------------------

### TableAlignment Enum Definition

Source: https://docs.rs/ironmark/2.0.7/ironmark/ast/enum.TableAlignment.html

The core enum definition representing possible alignment states for table columns.

```rust
pub enum TableAlignment {
    None,
    Left,
    Center,
    Right,
}
```

--------------------------------

### Define UnknownInlineHandling Enum

Source: https://docs.rs/ironmark/2.0.7/ironmark/enum.UnknownInlineHandling.html

The enum structure used to specify how unknown inline HTML elements are processed.

```rust
pub enum UnknownInlineHandling {
    StripTags,
    PreserveAsHtml,
}
```

--------------------------------

### Block Enum Definition

Source: https://docs.rs/ironmark/2.0.7/ironmark/ast/enum.Block.html

The structure of the Block enum, which represents different types of block-level Markdown elements.

```rust
pub enum Block {
    Document {
        children: Vec<Block>,
    },
    BlockQuote {
        children: Vec<Block>,
    },
    List {
        kind: ListKind,
        start: u32,
        tight: bool,
        children: Vec<Block>,
    },
    ListItem {
        children: Vec<Block>,
        checked: Option<bool>,
    },
    Paragraph {
        raw: String,
    },
    Heading {
        level: u8,
        raw: String,
    },
    CodeBlock {
        info: CompactString,
        literal: String,
    },
    HtmlBlock {
        literal: String,
    },
    ThematicBreak,
    Table(Box<TableData>),
}
```

--------------------------------

### Define TableData Structure

Source: https://docs.rs/ironmark/2.0.7/ironmark/ast/struct.TableData.html

The internal structure of the TableData struct, showing fields for alignments, column count, header, and rows.

```rust
pub struct TableData {
    pub alignments: Vec<TableAlignment>,
    pub num_cols: usize,
    pub header: Vec<CompactString>,
    pub rows: Vec<CompactString>,
}
```

--------------------------------

### Define ListKind Enum

Source: https://docs.rs/ironmark/2.0.7/ironmark/ast/enum.ListKind.html

The structure of the ListKind enum, used to categorize list types in the AST.

```rust
pub enum ListKind {
    Bullet(u8),
    Ordered(u8),
}
```
Tokens:
Raw