///|
pub(all) struct RenderOptions {
  width : Int32
  max_output_chars : Int32
  standalone : Bool
  include_title : Bool
} derive(Eq, Debug)

///|
pub extend RenderOptions with Eq::{equal, not_equal}

///|
pub extend RenderOptions with @debug.Debug::{to_repr}

///|
pub fn RenderOptions::default() -> RenderOptions {
  {
    width: 78,
    max_output_chars: 2000000,
    standalone: false,
    include_title: true,
  }
}

///|
fn RenderOptions::validate(self : RenderOptions) -> Diagnostic? {
  if self.width < 20 || self.width > 240 || self.max_output_chars <= 0 {
    Some(
      diagnostic(
        "invalid-render-options",
        "width must be 20..240 and output limit positive",
        1,
        severity=Error,
      ),
    )
  } else {
    None
  }
}

///|
priv struct Writer {
  out : StringBuilder
  mut remaining : Int32
  mut failed : Bool
}

///|
fn Writer::new(limit : Int32) -> Writer {
  { out: StringBuilder(), remaining: limit, failed: false, }
}

///|
fn Writer::write(self : Writer, text : String) -> Unit {
  if self.failed {
    return
  }
  let mut length = 0
  for _ in text.iter() {
    length = length + 1
    if length > self.remaining {
      self.failed = true
      return
    }
  }
  self.remaining = self.remaining - length
  self.out.write_string(text)
}

///|
fn Writer::finish(self : Writer) -> Result[String, Diagnostic] {
  if self.failed {
    Err(
      diagnostic(
        "output-limit",
        "Rendered output exceeds max_output_chars",
        1,
        severity=Error,
      ),
    )
  } else {
    Ok(self.out.to_string())
  }
}

///|
fn Writer::html_text(
  self : Writer,
  text : String,
  breaks~ : Bool = false,
) -> Unit {
  for c in text.iter() {
    if self.failed {
      return
    }
    match c {
      '&' => self.write("&")
      '<' => self.write("<")
      '>' => self.write(">")
      '"' => self.write(""")
      '\'' => self.write("'")
      '\n' if breaks => self.write("
\n") _ => self.write(c.to_string()) } } } ///| fn Writer::html_inlines( self : Writer, runs : Array[Inline], pre~ : Bool = false, ) -> Unit { let mut active : String? = None for run in runs { let target = match run.target { Some(value) if safe_target(value) => Some(value) _ => None } if active != target { if active is Some(_) { self.write("") } if target is Some(value) { self.write("") } active = target } let (open, close) = match run.font { Bold => ("", "") Italic => ("", "") Code if !pre => ("", "") _ => ("", "") } self.write(open) self.html_text(run.text, breaks=!pre) self.write(close) } if active is Some(_) { self.write("") } } ///| /// Emit escaped, deterministic HTML with no scripts, includes, or raw HTML path. pub fn render_html( doc : Document, options~ : RenderOptions = RenderOptions::default(), ) -> Result[String, Diagnostic] { if options.validate() is Some(d) { return Err(d) } if validate_document(doc) is Err(d) { return Err(d) } let writer = Writer::new(options.max_output_chars) if options.standalone { writer.write( "\n", ) writer.html_text(doc.metadata.title) writer.write("\n") } writer.write("
\n") if options.include_title && doc.metadata.title != "" { writer.write("

") writer.html_text(doc.metadata.title) if doc.metadata.section != "" { writer.write("(") writer.html_text(doc.metadata.section) writer.write(")") } writer.write("

\n") } let headings = outline(doc) let mut heading_index = 0 for block in doc.blocks { if writer.failed { break } if block.indent > 0 { writer.write( "
\n", ) } match block.kind { Heading(level) => { let tag = if level == 1 { "h2" } else { "h3" } writer.write("<" + tag + " id=\"") writer.html_text(headings[heading_index].anchor) heading_index = heading_index + 1 writer.write("\">") writer.html_inlines(block.inlines) writer.write("\n") } Tagged(term) => { writer.write("
") writer.html_inlines(term) writer.write("
") writer.html_inlines(block.inlines) writer.write("
\n") } Literal => { writer.write("
")
        writer.html_inlines(block.inlines, pre=true)
        writer.write("
\n") } Synopsis => { writer.write("
")
        writer.html_inlines(block.inlines, pre=true)
        writer.write("
\n") } Hanging(width) => { writer.write( "

", ) writer.html_inlines(block.inlines) writer.write("

\n") } Rule => writer.write("
\n") Paragraph => { writer.write("

") writer.html_inlines(block.inlines) writer.write("

\n") } } if block.indent > 0 { writer.write("
\n") } } writer.write("
\n") if options.standalone { writer.write("\n") } writer.finish() }