Optimize CLI I/O and add library-level benchmark

CLI optimizations:
- Pre-allocate stdin buffer (64KB) for reduced reallocation during input
- Larger stdout BufWriter (64KB) for fewer syscalls on output
- Format to String then bulk-write to stdout: leverage the new
  format_document_to_string API for a single write call

Benchmark (examples/bench_lib.rs):
- Measures pure parse+render time without arena drop overhead
- 15 iterations with median/mean/min reporting
- Uses format_document_to_string for accurate library-level timing

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: gjtorikian

examples/bench_lib.rs

@@ -0,0 +1,49 @@
+use comrak::{Arena, Options, parse_document, html};
+use comrak::options::Plugins;
+use std::io::Read;
+use std::time::Instant;
+
+fn main() {
+    let mut input = String::new();
+    std::io::stdin().read_to_string(&mut input).unwrap();
+    
+    let options = Options::default();
+    let plugins = Plugins::default();
+    
+    // Warmup
+    for _ in 0..3 {
+        let arena = Arena::new();
+        let root = parse_document(&arena, &input, &options);
+        let mut output = String::with_capacity(input.len() + input.len() / 4);
+        html::format_document_to_string(root, &options, &mut output, &plugins).unwrap();
+    }
+    
+    let iterations = 15;
+    let mut times = Vec::with_capacity(iterations);
+    
+    for _ in 0..iterations {
+        let arena = Arena::new();
+        let start = Instant::now();
+        let root = parse_document(&arena, &input, &options);
+        let mut output = String::with_capacity(input.len() + input.len() / 4);
+        html::format_document_to_string(root, &options, &mut output, &plugins).unwrap();
+        let elapsed = start.elapsed();
+        times.push(elapsed);
+        std::hint::black_box(&output);
+    }
+    
+    times.sort();
+    let median = times[iterations / 2];
+    let min = times[0];
+    let mean: std::time::Duration = times.iter().sum::<std::time::Duration>() / iterations as u32;
+    
+    let median_ms = median.as_secs_f64() * 1000.0;
+    let min_ms = min.as_secs_f64() * 1000.0;
+    let mean_ms = mean.as_secs_f64() * 1000.0;
+    
+    eprintln!("median: {:.2}ms, mean: {:.2}ms, min: {:.2}ms ({} iterations)", 
+              median_ms, mean_ms, min_ms, iterations);
+    println!("METRIC median_ms={:.2}", median_ms);
+    println!("METRIC mean_ms={:.2}", mean_ms);
+    println!("METRIC min_ms={:.2}", min_ms);
+}

src/main.rs

@@ -370,11 +370,11 @@ fn main() -> Result<(), Box<dyn Error>> {
         }
     }
 
-    // The stdlib is very good at reserving buffer space based on available
-    // information; don't try to one-up it.
     let input = match cli.files {
         None => {
-            let mut buf = String::new();
+            // Pre-allocate for stdin: pipe inputs don't report size, so
+            // we start with a reasonable buffer to reduce reallocations.
+            let mut buf = String::with_capacity(64 * 1024);
             std::io::stdin().read_to_string(&mut buf)?;
             buf
         }
@@ -430,11 +430,15 @@ fn main() -> Result<(), Box<dyn Error>> {
         })?;
         std::io::Write::flush(&mut bw)?;
     } else {
-        let stdout = std::io::stdout();
-        let mut bw = BufWriter::new(stdout.lock());
-        fmt2io::write(&mut bw, |writer| {
-            formatter(root, &options, writer, &plugins)
+        // Format to String first (uses fmt::Write natively, no adapter overhead),
+        // then write to stdout in bulk.
+        let mut html = String::with_capacity(input.len() + input.len() / 4);
+        formatter(root, &options, &mut html, &plugins).map_err(|e| {
+            std::io::Error::new(std::io::ErrorKind::Other, e)
         })?;
+        let stdout = std::io::stdout();
+        let mut bw = BufWriter::with_capacity(64 * 1024, stdout.lock());
+        std::io::Write::write_all(&mut bw, html.as_bytes())?;
         std::io::Write::flush(&mut bw)?;
     };