Untitledss

Welcome to MarkdownToPrettyPDF

A modern markdown editor with live preview, 25+ diagram types, math equations, and PDF export.

Tip

Edit this markdown to see the live preview update in real-time. Use Ctrl+S / Cmd+S to save.

Features

Live Preview — rendered output as you type
Syntax Highlighting — 190+ languages
Diagrams — Mermaid, PlantUML, Graphviz, D2, Chart.js & more
Math — KaTeX inline & block equations
Share — generate shareable links instantly
Export — download as HTML or PDF

Mermaid Diagrams

Flowchart

Sequence Diagram

Entity Relationship Diagram

State Diagram

Gantt Chart

Pie Chart

Git Graph

Class Diagram

PlantUML (Kroki)

Graphviz / DOT (Kroki)

D2 Diagram (Kroki)

Nomnoml (Kroki)

Ditaa (Kroki)

SVG Bob (Kroki)

BlockDiag (Kroki)

WaveDrom (Kroki)

Pikchr (Kroki)

Chart.js

Line Chart

Chart

Doughnut Chart

Chart

Bar Chart

Chart

KaTeX / Math Equations

Inline Math

Einstein’s famous equation $E = mc^2$ changed physics forever. The quadratic formula $x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$ solves any second-degree polynomial.

Block Equations

\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}

\mathbf{F} = m\mathbf{a} = m\frac{d^2\mathbf{r}}{dt^2}

Maxwell’s Equations

\begin{aligned} \nabla \cdot \mathbf{E} &= \frac{\rho}{\varepsilon_0} \\[6pt] \nabla \cdot \mathbf{B} &= 0 \\[6pt] \nabla \times \mathbf{E} &= -\frac{\partial \mathbf{B}}{\partial t} \\[6pt] \nabla \times \mathbf{B} &= \mu_0 \mathbf{J} + \mu_0 \varepsilon_0 \frac{\partial \mathbf{E}}{\partial t} \end{aligned}

Matrix Operations

\begin{bmatrix} a_{11} & a_{12} & a_{13} \\ a_{21} & a_{22} & a_{23} \\ a_{31} & a_{32} & a_{33} \end{bmatrix} \begin{bmatrix} x \\ y \\ z \end{bmatrix} = \begin{bmatrix} b_1 \\ b_2 \\ b_3 \end{bmatrix}

Softmax Function

\sigma(z_i) = \frac{e^{z_i}}{\displaystyle\sum_{j=1}^{K} e^{z_j}} \quad \text{for } i = 1, \ldots, K

Vega-Lite Chart (Kroki)

Excalidraw (Kroki)

ERD — Entity Relationship (Kroki)

C4 Architecture (Kroki)

SeqDiag (Kroki)

ActDiag (Kroki)

NwDiag — Network (Kroki)

PacketDiag — Packet Structure (Kroki)

RackDiag — Server Rack (Kroki)

Tables

Feature	Status	Priority
User Auth	✅ Done	High
Dashboard	✅ Done	High
Search	🔄 WIP	Medium
Notifications	📋 TODO	Low
Dark Mode	✅ Done	Medium

Criteria	PostgreSQL	MongoDB	Redis
Type	Relational	Document	Key-Value
ACID	Full	Per-document	Partial
Scale	Vertical	Horizontal	In-memory
Best For	Complex queries	Flexible schema	Caching

Code Blocks

TypeScript

typescript

interface User {
  id: string;
  email: string;
  name: string;
  role: 'admin' | 'user' | 'moderator';
}

async function findUserByEmail(email: string): Promise<User | null> {
  const cached = await redis.get(\`user:\${email}\`);
  if (cached) return JSON.parse(cached);

  const user = await db.query<User>(
    'SELECT * FROM users WHERE email = $1',
    [email]
  );
  if (user) {
    await redis.setex(\`user:\${email}\`, 300, JSON.stringify(user));
  }
  return user;
}

Python

python

from dataclasses import dataclass
from typing import Optional

@dataclass
class PipelineResult:
    stage: str
    success: bool
    duration_ms: float
    output: Optional[str] = None

async def run_pipeline(stages: list[str]) -> list[PipelineResult]:
    results = []
    for stage in stages:
        try:
            output = await execute_stage(stage)
            results.append(PipelineResult(stage, True, 0, output))
        except Exception as e:
            results.append(PipelineResult(stage, False, 0, str(e)))
            break
    return results

SQL

sql

WITH monthly_revenue AS (
    SELECT
        DATE_TRUNC('month', o.created_at) AS month,
        SUM(li.quantity * li.unit_price)   AS revenue,
        COUNT(DISTINCT o.id)              AS order_count
    FROM orders o
    JOIN line_items li ON li.order_id = o.id
    WHERE o.status = 'completed'
    GROUP BY 1
)
SELECT
    month,
    revenue,
    order_count,
    revenue / NULLIF(order_count, 0) AS avg_order_value
FROM monthly_revenue
ORDER BY month;

Rust

rust

use std::collections::HashMap;
use tokio::sync::RwLock;

pub struct RateLimiter {
    limits: HashMap<String, u32>,
    counters: RwLock<HashMap<String, (u32, std::time::Instant)>>,
    window: std::time::Duration,
}

impl RateLimiter {
    pub async fn check(&self, key: &str) -> Result<(), RateLimitError> {
        let limit = self.limits.get(key).copied().unwrap_or(100);
        let mut counters = self.counters.write().await;
        let entry = counters.entry(key.to_string())
            .or_insert((0, std::time::Instant::now()));

        if entry.1.elapsed() > self.window {
            *entry = (1, std::time::Instant::now());
            return Ok(());
        }
        entry.0 += 1;
        if entry.0 > limit {
            Err(RateLimitError { retry_after: self.window - entry.1.elapsed() })
        } else {
            Ok(())
        }
    }
}

Admonitions

Note

This is a note admonition providing additional context.

Tip

Use Ctrl+S / Cmd+S to save, and the share button to generate a link.

Warning

Kroki diagram rendering requires network access to reach `kroki.io`.

Important

All diagram types support intelligent contrast adjustment for PDF generation.

Caution

Changing themes affects HTML display. The PDF pipeline automatically uses a light theme.

Task Lists

Mixed Content

The time complexity of merge sort is $O(n \log n)$ in all cases.

python

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

The recurrence relation:

T(n) = 2T\!\left(\frac{n}{2}\right) + O(n)

Algorithm	Best	Average	Worst	Stable
Merge Sort	$O(n \log n)$	$O(n \log n)$	$O(n \log n)$	Yes
Quick Sort	$O(n \log n)$	$O(n \log n)$	$O(n^2)$	No
Tim Sort	$O(n)$	$O(n \log n)$	$O(n \log n)$	Yes

MarkdownToPrettyPDF — Edit, preview, and export beautiful documents.