### Usage example for all

Source: https://docs.rs/unidown/latest/unidown/fn.all.html

Demonstrates the output of the all function when provided with the input string 'Text'.

```rust
assert_eq!(
    unidown::all("Text"),
    "
        𝘛𝘦𝘹𝘵
        𝐓𝐞𝐱𝐭
        𝚃𝚎𝚡𝚝
        T̶e̶x̶t̶
        𝑻𝒆𝒙𝒕
        𝒯ℯ𝓍𝓉
        𝓣𝓮𝔁𝓽
        Ⓣⓔⓧⓣ
        𝘛̶𝘦̶𝘹̶𝘵̶
        𝐓̶𝐞̶𝐱̶𝐭̶
        𝑻̶𝒆̶𝘹̶𝒕̶
        𝚃̶𝚎̶𝚡̶𝚝̶
        𝔗𝔢𝔵𝔱
        𝕿𝖊𝖝𝖙
        𝕋𝕖𝕩𝕥

    ",
);
```

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

### Example usage of unidown::demo with assertion

Source: https://docs.rs/unidown/latest/unidown/fn.demo.html

Shows how to call `unidown::demo` with a sample string and asserts the expected output. The output is a multi-line table with columns for input, result, and style, demonstrating various text formatting styles.

```rust
assert_eq!(
    unidown::demo("Your text here"),
    "\
        | Input                            | Result         | Style              |\n\
        |----------------------------------|----------------|--------------------|\n\
        | `` *Your text here* ``           | 𝘠𝘰𝘶𝘳 𝘵𝘦𝘹𝘵 𝘩𝘦𝘳𝘦 | italic             |\n\
        | `` **Your text here** ``         | 𝐘𝐨𝐮𝐫 𝐭𝐞𝐱𝐭 𝐡𝐞𝐫𝐞 | bold               |\n\
        | `` `Your text here` ``           | 𝚈𝚘𝚞𝚛 𝚝𝚎𝚡𝚝 𝚑𝚎𝚛𝚎 | monospace          |\n\
        | `` ~~Your text here~~ ``         | Y̶o̶u̶r̶ ̶t̶e̶x̶t̶ ̶h̶e̶r̶e̶ | strike             |\n\
        | `` ***Your text here*** ``       | 𝒀𝒐𝒖𝒓 𝒕𝒆𝒙𝒕 𝒉𝒆𝒓𝒆 | bold-italic        |\n\
        | `` *`Your text here`* ``         | 𝒴ℴ𝓊𝓇 𝓉ℯ𝓍𝓉 𝒽ℯ𝓇ℯ | script             |\n\
        | `` **`Your text here`** ``       | 𝓨𝓸𝓾𝓻 𝓽𝓮𝔁𝓽 𝓱𝓮𝓻𝓮 | bold-script        |\n\
        | `` ***`Your text here`*** ``     | Ⓨⓞⓤⓡ ⓣⓔⓧⓣ ⓗⓔⓡⓔ | circled            |\n\
        | `` ~~*Your text here*~~ ``       | 𝘠̶𝘰̶𝘶̶𝘳̶ ̶𝘵̶𝘦̶𝘹̶𝘵̶ ̶𝘩̶𝘦̶𝘳̶𝘦̶ | strike-italic      |\n\
        | `` ~~**Your text here**~~ ``     | 𝐘̶𝐨̶𝐮̶𝐫̶ ̶𝐭̶𝐞̶𝐱̶𝐭̶ ̶𝐡̶𝐞̶𝐫̶𝐞̶ | strike-bold        |\n\
        | `` ~~***Your text here***~~ ``   | 𝒀̶𝒐̶𝒖̶𝒓̶ ̶𝒕̶𝒆̶𝒙̶𝒕̶ ̶𝒉̶𝒆̶𝒓̶𝒆̶ | strike-bold-italic |\n\
        | `` ~~`Your text here`~~ ``       | 𝚈̶𝚘̶𝚞̶𝚛̶ ̶𝚝̶𝚎̶𝚡̶𝚝̶ ̶𝚑̶𝚎̶𝚛̶𝚎̶ | strike-monospace   |\n\
        | `` ~~*`Your text here`*~~ ``     | 𝔜𝔬𝔲𝔯 𝔱𝔢𝔵𝔱 𝔥𝔢𝔯𝔢 | fraktur            |\n\
        | `` ~~**`Your text here`**~~ ``   | 𝖄𝖔𝖚𝖗 𝖙𝖊𝖝𝖙 𝖍𝖊𝖗𝖊 | bold-fraktur       |\n\
        | `` ~~***`Your text here`***~~ `` | 𝕐𝕠𝕦𝕣 𝕥𝕖𝕩𝕥 𝕙𝕖𝕣𝕖 | double-struck      |\n\n\
    "
);
```

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

### Start Tag Logic

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Determines the start of an HTML tag, handling paragraph and heading structures.

```rust
fn start_tag(&mut self, tag: Tag<'a>) -> Result<(), W::Error> {
        match tag {
            Tag::Paragraph => {
                if self.end_newline {
                    Ok(())
                } else {
                    self.write("\n")
                }
            }
            Tag::Heading {
                level,
                id: _,
                classes: _,
                attrs: _,
            } => {
                if self.end_newline {

```

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

### Example usage with assertions for Markdown-to-Unicode conversion

Source: https://docs.rs/unidown/latest/unidown/fn.convert.html

Illustrates usage of `convert` in a test with a table of markdown and expected Unicode strings, asserting equality. Covers emphasis, strong, code, strike, and math expressions.

```rust
for (markdown, unicode) in &[
    ("*Emphasis*\n\n", "𝘌𝘮𝘱𝘩𝘢𝘴𝘪𝘴\n\n"),
    ("**Strong**\n\n", "𝐒𝐭𝐫𝐨𝐧𝐠\n\n"),
    ("`Code`\n\n", "𝙲𝚘𝚍𝚎\n\n"),
    ("~~Strike~~\n\n", "S̶t̶r̶i̶k̶e̶\n\n"),
    ("***Emphasis strong***\n\n", "𝑬𝒮𝒮𝒯𝒶𝓈𝒾𝓈 𝒔𝒕𝒓𝒐𝒏𝒈\n\n"),
    ("***Emphasis* strong**\n\n", "𝑬𝒮𝒮𝒯𝒶𝓈𝒾𝓈 𝐒𝐭𝐫𝐨𝐧𝐠\n\n"),
    ("***Strong** emphasis*\n\n", "𝑬𝒮𝒮𝒯𝒶𝓈𝒾𝓈 𝒔𝒕𝒓𝒐𝒏𝒈\n\n"),
    ("*`Emphasis code`*\n\n", "ℰ𝓂𝓅𝒽𝒶𝓈𝒾𝓈 𝒸ℴ𝒹ℯ\n\n"),
    ("**`Strong code`**\n\n", "𝓝𝓽𝓻𝓸𝓷𝓰 𝓬𝓸𝓭𝓮\n\n"),
    ("***`Emphasis strong code`***\n\n", "Ⓔⓜⓟⓗⓐⓢⓘⓢ ⓢⓣⓡⓞⓝⓖ ⓒⓞⓓⓔ\n\n"),
    ("~~*Strike emphasis*~~\n\n", "𝘚̶𝘵̶𝘳̶𝘪̶𝘬̶𝘦̶ ̶𝘦̶𝘮̶𝘱̶𝘩̶𝘢̶𝘴̶𝘪̶𝘴̶\n\n"),
    ("~~**Strike strong**~~\n\n", "𝐒̶𝐭̶𝐫̶𝐢̶𝐤̶𝐤̶𝐞̶ ̶𝐬̶𝐭̶𝐫̶𝐨̶𝐧̶𝐠̶\n\n"),
    ("~~***Strike emphasis strong***~~\n\n", "𝑺̶𝒕̶𝒓̶𝒊̶𝒌̶𝒆̶ ̶𝒆̶𝒎̶𝒑̶𝒉̶𝒂̶𝒔̶𝒊̶𝒔̶ ̶𝒔̶𝒕̶𝒓̶𝒐̶𝒏̶𝒈̶\n\n"),
    ("~~`Strike code`~~\n\n", "Ñζ 𝙨̶ ̶ 𝙛̶ 𝙗̶ 𝙨̶ 𝙚̶ ̶ 𝙨̶\n\n"),
    ("~~*`Strike emphasis code`*~~\n\n", "𝔖𝔱𝔯𝔦𝔨𝔢 𝔢𝔪𝔭𝔥𝔞𝔰𝔦𝔰 𝔠𝔬𝔡𝔢\n\n"),
    ("~~**`Strike strong code`**~~\n\n", "𝕾𝖙𝖗𝖎𝖐𝖊 𝖘𝖙𝖗𝖔𝖓𝖌 𝖈𝖔𝖉𝖊\n\n"),
    ("~~***`Strike emphasis strong code`***~~\n\n", "𝕊𝕥𝕣𝕚𝕜𝕖 𝕖𝕞𝕡𝕙𝕒𝕤𝕚𝕤 𝕤𝕥𝕣𝕠𝕟𝕘 𝕔𝕠𝕕𝕖\n\n"),
    ("$f(x)=x^2$", "$f(x)=x^2$\n\n"),
    ("$$f(x)=x^2$$", "$$f(x)=x^2$$\n\n"),
] {
    assert_eq!(unidown::convert(markdown), *unicode);
}
```

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

### Convert Markdown to Unicode with unidown::convert

Source: https://docs.rs/unidown/latest/unidown/index.html

Example usage of the unidown::convert function, demonstrating conversion of Markdown text with emphasis, strong, strong emphasis, strike, and code to Unicode. The output shows the converted Unicode string.

```rust
assert_eq!(
   unidown::convert("\
      Here is some *emphasis*, **strong**, ***strong emphasis***, ~~strike~~, \
      and `code` text.\n\n\
   "),
   "Here is some 𝘦𝘮𝘱𝘩𝘢𝘴𝘪𝘴, 𝐬𝐭𝐫𝐨𝐧𝐠, 𝒔𝒕𝒓𝒐𝒏𝒈 𝒆𝒎𝒑𝒉𝒂𝒔𝒊𝒔, s̶t̶r̶i̶k̶e̶, and 𝚌𝚘𝚍𝚎 text.\n\n",
);
```

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

### all

Source: https://docs.rs/unidown

Runs all mode of the unidown crate.

```APIDOC
## all

### Description
All mode.

### Method
Function

### Endpoint
`unidown::all`

### Parameters
None

### Request Example
```rust
unidown::all();
```

### Response
#### Success Response
No return value.

#### Response Example
```rust
()
```
```

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

### Generate a demonstration table of styles

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

The demo function creates a markdown table showing various input syntax patterns and their corresponding Unicode style outputs.

```rust
#[allow(clippy::missing_panics_doc)]
#[must_use]
pub fn demo(s: &str) -> String {
    let mut t = Veg::table("Input|Result|Style\n-|-|-");
    for (syntax, style) in [
        ("*", "italic"),
        ("**", "bold"),
        ("`", "monospace"),
        ("~~", "strike"),
        ("***", "bold-italic"),
        ("*`", "script"),
        ("**`", "bold-script"),
        ("***`", "circled"),
        ("~~*", "strike-italic"),
        ("~~**", "strike-bold"),
        ("~~***", "strike-bold-italic"),
        ("~~`", "strike-monospace"),
        ("~~*`", "fraktur"),
        ("~~**`", "bold-fraktur"),
        ("~~***`", "double-struck"),
    ] {
        let input = format!("{syntax}{s}{}", syntax.chars().rev().collect::<String>());
        t.push(Box::new(Row::new(
            &format!("`` {input} ``"),
            &convert(&input).replace("\n\n", ""),
            style,
        )));
    }
    format!("{}\n", t.markdown().unwrap())
}
```

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

### demo

Source: https://docs.rs/unidown

Runs a demo mode of the unidown crate.

```APIDOC
## demo

### Description
Demo mode.

### Method
Function

### Endpoint
`unidown::demo`

### Parameters
None

### Request Example
```rust
unidown::demo();
```

### Response
#### Success Response
No return value.

#### Response Example
```rust
()
```
```

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

### Demo mode usage

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Shows how to use the unidown::demo function to generate a table of supported Unicode styles for a given input string.

```rust
assert_eq!(
    unidown::demo("Your text here"),
    "\
        | Input                            | Result         | Style              |\n\
        |----------------------------------|----------------|--------------------|\n\
        | `` *Your text here* ``           | 𝘠𝘰𝘶𝘳 𝘵𝘦𝘹𝘵 𝘩𝘦𝘳𝘦 | italic             |\n\
        | `` **Your text here** ``         | 𝐘𝐨𝐮𝐫 𝐭𝐞𝐱𝐭 𝐡𝐞𝐫𝐞 | bold               |\n\
        | `` `Your text here` ``           | 𝚈𝚘𝚞𝚛 𝚝𝚎𝚡𝚝 𝚑𝚎𝘳𝚎 | monospace          |\n\
        | `` ~~Your text here~~ ``         | Y̶o̶u̶r̶ ̶t̶e̶x̶t̶ ̶h̶e̶r̶e̶ | strike             |\n\
        | `` ***Your text here*** ``       | 𝒀𝒐𝒖𝒓 𝒕𝒆𝒘𝒕 𝒉𝒆𝒓𝒆 | bold-italic        |\n\
        | `` *`Your text here`* ``         | 𝒴ℴ𝓊𝓇 𝓉ℯ𝓍𝓉 𝒽ℯ𝓇ℯ | script             |\n\
        | `` **`Your text here`** ``       | 𝓨𝓸𝓾𝓻 𝓽𝓮𝔁𝓽 𝓱𝓮𝓻𝓮 | bold-script        |\n"
```

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

### unidown::demo

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Returns a formatted table showing how given input text would appear in various Unicode styles, as a demonstration of supported formatting. The output includes columns for input, result, and style.

```APIDOC
## demo

### Description
Generates a demo table for a given input text, displaying its Unicode representation in multiple Markdown styles (e.g., bold, italic, code, strikethrough). Returns a newline-separated string formatted as a table.

### Function Signature
pub fn demo("Your text here") -> String

### Parameters
- **s** (string) - Required - The input text used to demonstrate available styles.

### Returns
String - A formatted table with columns for Input, Result, and Style.

### Example

```rust
let output = unidown::demo("Your text here");
assert!(output.contains("Your text here"));
```
```

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

### Function signature: pub fn demo(s: &str) -> String

Source: https://docs.rs/unidown/latest/unidown/fn.demo.html

Declares the `demo` function, which accepts a string slice and returns a `String`. This is the public API for the demo mode.

```rust
pub fn demo(s: &str) -> String
```

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

### convert

Source: https://docs.rs/unidown

Converts Markdown text to Unicode using the unidown crate.

```APIDOC
## convert

### Description
Convert Markdown to Unicode.

### Method
Function

### Endpoint
`unidown::convert`

### Parameters
- **input** (string) - Required - The Markdown text to convert.

### Request Example
```rust
let result = unidown::convert("*Emphasis*");
```

### Response
#### Success Response
- **output** (string) - The converted Unicode text.

#### Response Example
```rust
"𝘌𝘮𝘱𝘩𝘢𝘴𝘪𝘴"
```
```

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

### Apply all Unicode styles

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

The all function applies every available Unicode style to the provided input string.

```rust
assert_eq!(
    unidown::all("Text"),
    "\
        𝘛𝘦𝘹𝘵\n\
        𝐓𝐞𝐱𝐭\n\
        𝚃𝚎𝚡𝚝\n\
        T̶e̶x̶t̶\n\
        𝑻𝒆𝒙𝒕\n\
        𝒯ℯ𝓍𝓉\n\
        𝓣𝓮𝔁𝓽\n\
        Ⓣⓔⓧⓣ\n\
        𝘛̶𝘦̶𝘹̶𝘵̶\n\
        𝐓̶𝐞̶𝐱̶𝐭̶\n\
        𝑻̶𝒆̶𝒙̶𝐭̶\n\
        𝚃̶𝚎̶𝚡̶𝚝̶\n\
        𝔗𝔢𝔵𝔱\n\
        𝕿𝖊𝖝𝖙\n\
        𝕋𝕖𝕩𝕥\n\n\
    ",
);
```

```rust
#[must_use]
pub fn all(s: &str) -> String {
    format!(
        "{}\n",
        [
            "*", "**", "`", "~~", "***", "*`", "**`", "***`", "~~*", "~~**", "~~***", "~~`",
            "~~*`", "~~**`", "~~***`",
        ]
        .iter()
        .map(|a| {
            convert(&format!("{a}{s}{}", a.chars().rev().collect::<String>())).replace("\n\n", "\n")
        })
        .collect::<String>()
    )
}
```

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

### Function signature: pub fn convert(s: &str) -> String

Source: https://docs.rs/unidown/latest/unidown/fn.convert.html

Shows the signature of the `convert` function, taking a string slice and returning a `String`. This is the API entry point for converting Markdown to Unicode.

```rust
pub fn convert(s: &str) -> String
```

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

### all

Source: https://docs.rs/unidown/latest/unidown/fn.all.html

The `all` function converts a string into all available Unicode text styles, returning a newline-separated string containing each style variant. It is the primary entry point for the unidown library's all-mode conversion.

```APIDOC
## Function: all

### Description
Converts a string into all available Unicode text styles, returning a newline-separated string containing each style variant. This is the "all mode" of the unidown library.

### Signature
```rust
pub fn all(s: &str) -> String
```

### Parameters
- **s** (`&str`) - Required - The input string to be converted.

### Returns
- **String** - A string containing each style variant separated by newlines, with a trailing newline.

### Example
```rust
assert_eq!(
    unidown::all("Text"),
    "\
        𝘛𝘦𝘹𝘵\n\
        𝐓𝐞𝐱𝐭\n\
        𝚃𝚎𝚡𝚝\n\
        T̶e̶x̶t̶\n\
        𝑻𝒆𝒙𝒕\n\
        𝒯ℯ𝓍𝓉\n\
        𝓣𝓮𝔁𝓽\n\
        Ⓣⓔⓧⓣ\n\
        𝘛̶𝘦̶𝘹̶𝘵̶\n\
        𝐓̶𝐞̶𝐱̶𝐭̶\n\
        𝑻̶𝒆̶𝒙̶𝒕̶\n\
        𝚃̶𝚎̶𝚡̶𝚝̶\n\
        𝔗𝔢𝔵𝔱\n\
        𝕿𝖊𝖝𝖙\n\
        𝕋𝕖𝕩𝕥\n\n\
    ",
);
```
```

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

### Function signature for all

Source: https://docs.rs/unidown/latest/unidown/fn.all.html

The signature of the all function, which accepts a string slice and returns a String.

```rust
pub fn all(s: &str) -> String
```

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

### unidown::convert

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Converts a Markdown string into Unicode text, applying formatting such as emphasis, bold, code, strikethrough, and combinations. Returns the converted Unicode string.

```APIDOC
## convert

### Description
Converts Markdown string to Unicode equivalents for supported styles. Does not convert math formulas ($...$), preserving them as-is.

### Function Signature
pub fn convert(s: &str) -> String

### Parameters
- **s** (str) - Required - The Markdown string to be converted to Unicode.

### Returns
- **String** - The Unicode-converted text with styles applied.

### Example

```rust
let result = unidown::convert("**Bold** and *italic*");
```
```

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

### push_unicode

Source: https://docs.rs/unidown/latest/unidown/fn.push_unicode.html

Iterate over an iterator of Events, generate Unicode for each Event, and push it to a String. Panics if unable to write to the given string.

```APIDOC
## push_unicode

### Description
Iterate over an `Iterator` of `Event`s, generate Unicode for each `Event`, and push it to a `String`.

### Function Signature
```rust
pub fn push_unicode<'a, I>(s: &mut String, iter: I)
where
    I: Iterator<Item = Event<'a>>,
```

### Parameters
- **s** (`&mut String`) - The string to which the generated Unicode will be pushed.
- **iter** (`I`) - An iterator over `Event`s. Each event is processed to generate Unicode.

### Panics
Panics if not able to write to the given `&mut String`.
```

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

### Text Styling Logic

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Handles text styling based on strong and emphasis flags, mapping characters to specific alphabets.

```rust
let alphabet: &HashMap<usize, char> = match (self.strong, self.emphasis) {
                            (true, true) => &BOLD_ITALIC_C,
                            (true, false) => &BOLD_C,
                            (false, true) => &ITALIC_C,
                            (false, false) => &REGULAR_C,
                        };
                        let u = t
                            .chars()
                            .map(|c| {
                                if let Some(i) = ALL_I.get(&c) {
                                    alphabet[i]
                                } else {
                                    c
                                }
                            })
                            .collect::<String>();
                        let u = if self.strike { strike(&u) } else { u };
                        self.write(&u)?;
                        self.end_newline = text.ends_with('\n');
                    }
                }
```

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

### Push Unicode events to a String

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Iterates over an iterator of Events, generates Unicode for each, and pushes the result to a String. Panics if writing to the string fails.

```rust
pub fn push_unicode<'a, I>(s: &mut String, iter: I)
where
    I: Iterator<Item = Event<'a>>,
{
    write_unicode_fmt(s, iter).unwrap();
}
```

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

### Crate Imports

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Required imports for the Unidown library, including clap, pulldown-cmark for Markdown parsing, and utility crates for character escaping and data structures.

```rust
use {
    clap::ValueEnum,
    pulldown_cmark::{
        Alignment, CowStr, Event,
        Event::{
            Code, DisplayMath, End, FootnoteReference, HardBreak, Html, InlineHtml, InlineMath,
            Rule, SoftBreak, Start, TaskListMarker, Text,
        },
        HeadingLevel, Options, Parser, Tag, TagEnd,
    },
    pulldown_cmark_escape::{
        FmtWriter, IoWriter, StrWrite, escape_href, escape_html, escape_html_body_text,
    },
    std::{collections::HashMap, fmt, io, sync::LazyLock},
    veg::Veg,
};
```

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

### convert(s: &str) -> String

Source: https://docs.rs/unidown/latest/unidown/fn.convert.html

Converts Markdown text to Unicode. This function processes Markdown formatting such as emphasis, strong, code, strike, and their combinations, returning the Unicode equivalent.

```APIDOC
## Function: convert

### Description
Converts Markdown text to Unicode. This function processes Markdown formatting such as emphasis, strong, code, strike, and their combinations, returning the Unicode equivalent.

### Signature
pub fn convert(s: &str) -> String

### Parameters
- **s** (&str) - Required - The Markdown string to convert.

### Return Value
- **String** - The Unicode-converted string.

### Example
```rust
for (markdown, unicode) in &[
    ("*Emphasis*\n\n", "𝘌𝘮𝘱𝘩𝘢𝘴𝘪𝘴\n\n"),
    ("**Strong**\n\n", "𝐒𝐭𝐫𝐨𝐧𝐠\n\n"),
    ("`Code`\n\n", "𝙲𝚘𝚍𝚎\n\n"),
    ("~~Strike~~\n\n", "S̶t̶r̶i̶k̶e̶\n\n"),
    ("***Emphasis strong***\n\n", "𝑬𝒎𝒑𝒉𝒂𝒔𝒊𝒔 𝒔𝒕𝒓𝒐𝒏𝒈\n\n"),
    ("***Emphasis* strong**\n\n", "𝑬𝒎𝒑𝒉𝒂𝒔𝒊𝒔 𝐬𝐭𝐫𝐨𝐧𝐠\n\n"),
    ("***Strong** emphasis*\n\n", "𝑺𝒕𝒓𝒐𝒏𝒈 𝘦𝘮𝘱𝘩𝘢𝘴𝘪𝘴\n\n"),
    ("*`Emphasis code`*\n\n", "ℰ𝓂𝓅𝒽𝒶𝓈𝒾𝓈 𝒸ℴ𝒹ℯ\n\n"),
    ("**`Strong code`**\n\n", "𝓢𝓽𝓻𝓸𝓷𝓰 𝓬𝓸𝓭𝓮\n\n"),
    ("***`Emphasis strong code`***\n\n", "Ⓔⓜⓟⓗⓐⓢⓘⓢ ⓢⓣⓡⓞⓝⓖ ⓒⓞⓓⓔ\n\n"),
    ("~~*Strike emphasis*~~\n\n", "𝘚̶𝘵̶𝘳̶𝘪̶𝘬̶𝘦̶ ̶𝘦̶𝘮̶𝘱̶𝘩̶𝘢̶𝘴̶𝘪̶𝘴̶\n\n"),
    ("~~**Strike strong**~~\n\n", "𝐒̶𝐭̶𝐫̶𝐢̶𝐤̶𝐞̶ ̶𝐬̶𝐭̶𝐫̶𝐨̶𝐧̶𝐠̶\n\n"),
    ("~~***Strike emphasis strong***~~\n\n", "𝑺̶𝒕̶𝒓̶𝒊̶𝒌̶𝒆̶ ̶𝒆̶𝒎̶𝒑̶𝒉̶𝒂̶𝒔̶𝒊̶𝒔̶ ̶𝒔̶𝒕̶𝒓̶𝒐̶𝒏̶𝒈̶\n\n"),
    ("~~`Strike code`~~\n\n", "𝚂̶𝚝̶𝚛̶𝚒̶𝚔̶𝚎̶ ̶𝚌̶𝚘̶𝚍̶𝚎̶\n\n"),
    ("~~*`Strike emphasis code`*~~\n\n", "𝔖𝔱𝔯𝔦𝔨𝔢 𝔢𝔪𝔭𝔥𝔞𝔰𝔦𝔰 𝔠𝔬𝔡𝔢\n\n"),
    ("~~**`Strike strong code`**~~\n\n", "𝕾𝖙𝖗𝖎𝖐𝖊 𝖘𝖙𝖗𝖔𝖓𝖌 𝖈𝖔𝖉𝖊\n\n"),
    ("~~***`Strike emphasis strong code`***~~\n\n", "𝕊𝕥𝕣𝕚𝕜𝕖 𝕖𝕞𝕡𝕙𝕒𝕤𝕚𝕤 𝕤𝕥𝕣𝕠𝕟𝕘 𝕔𝕠𝕕𝕖\n\n"),
    ("$f(x)=x^2$", "$f(x)=x^2$\n\n"),
    ("$$f(x)=x^2$$", "$$f(x)=x^2$$\n\n"),
] {
    assert_eq!(unidown::convert(markdown), *unicode);
}
```
```

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

### Structural Element Handling

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Handles various structural elements like HTML, breaks, rules, footnotes, task lists, and math blocks.

```rust
Html(html) | InlineHtml(html) => {
                    self.write(&html)?;
                }
                SoftBreak => {
                    self.write_newline()?;
                }
                HardBreak => {
                    self.write("\n")?;
                }
                Rule => {
                    if !self.end_newline {
                        self.write("\n")?;
                    }
                    self.write("---\n\n")?;
                }
                FootnoteReference(name) => {
                    let len = self.numbers.len() + 1;
                    let number = *self.numbers.entry(name.clone()).or_insert(len);
                    write!(&mut self.writer, "[{number}][^")?;
                    escape_html(&mut self.writer, &name)?;
                    self.write("]")?;
                }
                TaskListMarker(true) => {
                    self.write("• [X] ")?;
                }
                TaskListMarker(false) => {
                    self.write("• [ ] ")?;
                }
                InlineMath(text) => {
                    self.write("$")?;
                    escape_html(&mut self.writer, &text)?;
                    self.write("$")?;
                }
                DisplayMath(text) => {
                    self.write("$$")?;
                    escape_html(&mut self.writer, &text)?;
                    self.write("$$")?;
                }
            }
        }
        if !self.end_newline {
            self.write("\n")?;
        }
        Ok(())
```

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

### pulldown-cmark License Notice

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

The MIT license notice required for the modified copies of code from the pulldown-cmark crate.

```text
The MIT License

Copyright 2015 Google Inc. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
```

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

### write_unicode_fmt

Source: https://docs.rs/unidown/latest/unidown/fn.write_unicode_fmt.html

Iterate over an `Iterator` of `Event`s, generate Unicode for each `Event`, and write it into a Unicode-accepting buffer or stream. Returns an error if not able to write to the given writer.

```APIDOC
## write_unicode_fmt

### Description
Iterate over an `Iterator` of `Event`s, generate Unicode for each `Event`, and write it into a Unicode-accepting buffer or stream.

### Signature
```rust
pub fn write_unicode_fmt<'a, I, W>(writer: W, iter: I) -> Result
where
    I: Iterator<Item = Event<'a>>,
    W: Write,
```

### Parameters
- **writer** (`W`) - Required - The Unicode-accepting buffer or stream to write the generated Unicode to.
- **iter** (`I`) - Required - An iterator of `Event`s to process and write.

### Errors
Returns an error if not able to write to the given writer.
```

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

### Write Unicode events to a formatter

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Iterates over an iterator of Events, generates Unicode for each, and writes the output to a Unicode-accepting formatter. Returns an error if writing fails.

```rust
pub fn write_unicode_fmt<'a, I, W>(writer: W, iter: I) -> fmt::Result
where
    I: Iterator<Item = Event<'a>>,
    W: fmt::Write,
{
    UnicodeWriter::new(iter, FmtWriter(writer)).run()
}
```

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

### Write Unicode events to an I/O stream

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Iterates over an iterator of Events, generates Unicode for each, and writes the output to an I/O stream. Returns an error if writing fails.

```rust
pub fn write_unicode_io<'a, I, W>(writer: W, iter: I) -> io::Result<()>
where
    I: Iterator<Item = Event<'a>>,
    W: io::Write,
{
    UnicodeWriter::new(iter, IoWriter(writer)).run()
}
```

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

### Static Character Mapping

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Static LazyLock HashMaps used to map characters to their index within the defined Unicode alphabets, facilitating character transformation.

```rust
static REGULAR_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(REGULAR));
static BOLD_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(BOLD));
static ITALIC_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(ITALIC));
static BOLD_ITALIC_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(BOLD_ITALIC));
static MONO_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(MONO));
static CURSIVE_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(CURSIVE));
static BOLD_CURSIVE_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(BOLD_CURSIVE));
static FRAKTUR_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(FRAKTUR));
static BOLD_FRAKTUR_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(BOLD_FRAKTUR));
static DOUBLE_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(DOUBLE));
static CIRCLE_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| c2i(CIRCLE));

static ALL_I: LazyLock<HashMap<char, usize>> = LazyLock::new(|| {
    REGULAR_I
        .iter()
        .chain(BOLD_I.iter())
        .chain(ITALIC_I.iter())
        .chain(BOLD_ITALIC_I.iter())
        .chain(MONO_I.iter())
        .chain(CURSIVE_I.iter())
        .chain(BOLD_CURSIVE_I.iter())
        .chain(FRAKTUR_I.iter())
        .chain(BOLD_FRAKTUR_I.iter())
        .chain(DOUBLE_I.iter())
        .chain(CIRCLE_I.iter())
        .map(|(c, i)| (*c, *i))
        .collect()
});
```

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

### Convert Text to Unicode Style

Source: https://docs.rs/unidown/latest/unidown/enum.Style.html

The convert method applies the selected Unicode style to a given string slice.

```rust
assert_eq!(
    unidown::Style::Fraktur.convert("Your text here"),
    "𝔜𝔬𝔲𝔯 𝔱𝔢𝔵𝔱 𝔥𝔢𝔯𝔢\n\n",
);
```

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

### Process raw text

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Consumes events until the corresponding end tag is reached, used primarily for generating content for attributes like alt.

```rust
975    fn raw_text(&mut self) -> Result<(), W::Error> {
976        let mut nest = 0;
977        while let Some(event) = self.iter.next() {
978            match event {
979                Start(_) => nest += 1,
980                End(_) => {
981                    if nest == 0 {
982                        break;
983                    }
984                    nest -= 1;
985                }
986                Html(_) => {}
987                InlineHtml(text) | Code(text) | Text(text) => {
988                    // Don't use escape_html_body_text here.
989                    // The output of this function is used in the `alt` attribute.
990                    escape_html(&mut self.writer, &text)?;
991                    self.end_newline = text.ends_with('\n');
992                }
993                SoftBreak | HardBreak | Rule => {
994                    self.write(" ")?;
995                }
996                FootnoteReference(name) => {
997                    let len = self.numbers.len() + 1;
998                    let number = *self.numbers.entry(name).or_insert(len);
999                    write!(&mut self.writer, "[{number}]")?;
1000                }
1001                TaskListMarker(true) => self.write("[x]")?,
1002                TaskListMarker(false) => self.write("[ ]")?,
1003                InlineMath(text) => {
1004                    self.write("$")?;
1005                    escape_html(&mut self.writer, &text)?;
1006                    self.write("$")?;
1007                }
1008                DisplayMath(text) => {
1009                    self.write("$$")?;
1010                    escape_html(&mut self.writer, &text)?;
1011                    self.write("$$")?;
1012                }
1013            }
1014        }
1015        Ok(())
1016    }
```

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

### Handle TagEnd events

Source: https://docs.rs/unidown/latest/src/unidown/lib.rs.html

Matches TagEnd variants to perform appropriate cleanup or formatting, such as closing tags or updating state variables.

```rust
905            TagEnd::Paragraph => {
906                self.write("\n\n")?;
907            }
908            TagEnd::Heading(_level) => {
909                self.strong = false;
910                self.write("\n\n")?;
911            }
912            TagEnd::Table
913            | TagEnd::BlockQuote(_)
914            | TagEnd::List(_)
915            | TagEnd::Item
916            | TagEnd::FootnoteDefinition => {
917                self.write("\n")?;
918            }
919            TagEnd::TableHead => {
920                self.table_state = TableState::Body;
921                write!(
922                    &mut self.writer,
923                    "|\n|{}|\n",
924                    self.table_alignments
925                        .iter()
926                        .map(|x| TableAlign::from(*x).as_str().to_owned())
927                        .collect::<Vec<String>>()
928                        .join("|")
929                )?;
930            }
931            TagEnd::TableRow => {
932                self.write("|\n")?;
933            }
934            TagEnd::TableCell => {
935                self.write(" ")?;
936                self.table_cell_index += 1;
937            }
938            TagEnd::CodeBlock => {
939                self.code = false;
940                self.write("\n")?;
941            }
942            TagEnd::Emphasis => {
943                self.emphasis = false;
944            }
945            TagEnd::Strong => {
946                self.strong = false;
947            }
948            TagEnd::Strikethrough => {
949                self.strike = false;
950            }
951            TagEnd::Link => {
952                let link = self.link.take().unwrap();
953                escape_href(&mut self.writer, &link.dest_url)?;
954                if !link.title.is_empty() {
955                    self.write(" \"")?;
956                    escape_html(&mut self.writer, &link.title)?;
957                }
958                self.write("\"]")?;
959            }
960            TagEnd::Image => (), // shouldn't happen, handled in start
961            TagEnd::MetadataBlock(_) => {
962                self.in_non_writing_block = false;
963            }
964            TagEnd::HtmlBlock
965            | TagEnd::DefinitionList
966            | TagEnd::DefinitionListTitle
967            | TagEnd::DefinitionListDefinition
968            | TagEnd::Subscript
969            | TagEnd::Superscript => {}
970        }
971        Ok(())
972    }
```