pub mod options;
pub mod span;
pub mod theme;
pub mod math;
pub mod highlight;
pub mod html;
pub mod plain;
pub mod spans_renderer;
pub mod stream;
pub mod ffi;
pub use options::{HtmlMode, MarkdownOptions, MathMode};
pub use theme::ThemeConfig;
pub use span::{
Span, SpanOutput, SpanDelta, SpanDeltaKind,
FLAG_BOLD, FLAG_ITALIC, FLAG_STRIKETHROUGH, FLAG_INLINE_CODE,
FLAG_LINK, FLAG_IMAGE, FLAG_MATH, FLAG_SUBSCRIPT, FLAG_SUPERSCRIPT,
BLOCK_PARAGRAPH, BLOCK_HEADING_H1, BLOCK_HEADING_H2, BLOCK_HEADING_H3,
BLOCK_HEADING_H4, BLOCK_HEADING_H5, BLOCK_HEADING_H6,
BLOCK_CODE, BLOCK_BLOCKQUOTE, BLOCK_LIST_ITEM_ORDERED,
BLOCK_LIST_ITEM_UNORDERED, BLOCK_TABLE_CELL, BLOCK_TABLE_HEADER_CELL,
BLOCK_HORIZONTAL_RULE, BLOCK_MATH_BLOCK, BLOCK_IMAGE,
EXTRA_KIND_LINK_URL, EXTRA_KIND_IMAGE_URL,
EXTRA_KIND_CODE_LANGUAGE, EXTRA_KIND_TABLE_METADATA,
EXTRA_KIND_CODE_HIGHLIGHT, EXTRA_KIND_LIST_META,
};
pub use highlight::{
TOKEN_OTHER, TOKEN_KEYWORD, TOKEN_STRING, TOKEN_COMMENT, TOKEN_NUMBER,
TOKEN_FUNCTION, TOKEN_TYPE, TOKEN_OPERATOR, TOKEN_PUNCTUATION,
TOKEN_VARIABLE, TOKEN_CONSTANT, TOKEN_BUILTIN,
TOKEN_ENTITY, TOKEN_MARKUP, TOKEN_REGEX,
TOKEN_TYPE_COUNT, HighlightToken,
};
pub use stream::StreamRenderer;
pub use spans_renderer::OwnedSpanOutput;
pub(crate) fn strip_html_tags(html: &str) -> String {
let mut result = String::with_capacity(html.len());
let mut in_tag = false;
for c in html.chars() {
match c {
'<' => in_tag = true,
'>' => in_tag = false,
_ if !in_tag => result.push(c),
_ => {}
}
}
result
}
pub fn to_html(md: &str) -> String {
html::markdown_to_html(md, &MarkdownOptions::default())
}
pub fn to_html_with_options(md: &str, options: &MarkdownOptions) -> String {
html::markdown_to_html(md, options)
}
pub fn to_spans(md: &str) -> SpanOutput {
spans_renderer::markdown_to_spans(md, &MarkdownOptions::default())
}
pub fn to_spans_with_options(md: &str, options: &MarkdownOptions) -> SpanOutput {
spans_renderer::markdown_to_spans(md, options)
}
pub fn to_spans_owned(md: &str) -> OwnedSpanOutput {
spans_renderer::markdown_to_spans_owned(md, &MarkdownOptions::default())
}
pub fn to_spans_owned_with_options(md: &str, options: &MarkdownOptions) -> OwnedSpanOutput {
spans_renderer::markdown_to_spans_owned(md, options)
}
pub fn to_plain_text(md: &str) -> String {
plain::markdown_to_plain_text(md, &MarkdownOptions::default())
}
pub unsafe fn free_spans(output: SpanOutput) {
if output.text.is_null() {
return;
}
if output.text_len > 0 {
let fat = std::ptr::slice_from_raw_parts_mut(
output.text as *mut u8,
output.text_len as usize,
);
drop(Box::from_raw(fat));
}
if output.span_count > 0 {
let fat = std::ptr::slice_from_raw_parts_mut(
output.spans as *mut Span,
output.span_count as usize,
);
drop(Box::from_raw(fat));
}
if output.extra_data_len > 0 {
let fat = std::ptr::slice_from_raw_parts_mut(
output.extra_data as *mut u8,
output.extra_data_len as usize,
);
drop(Box::from_raw(fat));
}
if output.utf16_offsets_len > 0 {
let fat = std::ptr::slice_from_raw_parts_mut(
output.utf16_offsets as *mut u32,
output.utf16_offsets_len as usize,
);
drop(Box::from_raw(fat));
}
}
#[cfg(feature = "highlight")]
pub fn highlight_code_serialized(code: &str, language: &str) -> Option<Vec<u8>> {
let tokens = highlight::highlight_code(code, language)?;
let count = tokens.len() as u16;
let mut data: Vec<u8> = Vec::with_capacity(2 + count as usize * 3);
data.extend_from_slice(&count.to_le_bytes());
for t in &tokens {
data.push(t.token_type);
data.extend_from_slice(&t.len.to_le_bytes());
}
Some(data)
}
#[cfg(not(feature = "highlight"))]
pub fn highlight_code_serialized(_code: &str, _language: &str) -> Option<Vec<u8>> {
None
}
pub fn version() -> &'static str {
env!("CARGO_PKG_VERSION")
}