Caching Performance

Explore how the built-in TokenCache optimizes re-renders by caching parsed markdown tokens.

Controls

Statistics

Render count 0

Average time 0ms

Cache size size() { this.prune(); return this.cache.size; }

Render Log

Click "Render" to start tracking performance.

Markdown Input

1498 characters

# Token Caching Performance

Svelte Markdown includes a built-in **LRU token cache** that dramatically speeds up re-renders.

## How It Works

When markdown is first parsed, the resulting tokens are stored in a cache keyed by content hash. Subsequent renders of the *same content* skip parsing entirely and use cached tokens.

### Performance Characteristics

| Metric | First Render | Cached Render |
|--------|:------------:|:-------------:|
| Parse time | 50-200ms | <1ms |
| Memory | ~5MB/50 docs | Same |
| Hash computation | ~0.05ms/10KB | ~0.05ms/10KB |

### Features

1. **LRU eviction** - Oldest entries removed when cache is full
2. **TTL support** - Entries expire after a configurable duration
3. **FNV-1a hashing** - Fast, non-cryptographic hash for cache keys
4. **Configurable** - Set maxSize and TTL to match your needs

```typescript
import { TokenCache } from '@humanspeak/svelte-markdown'

const cache = new TokenCache({
    maxSize: 100,       // Cache up to 100 documents
    ttl: 5 * 60 * 1000  // 5-minute TTL
})
```

> Token caching provides 50-200x faster re-renders for previously parsed content.

### Supported Token Types

- Paragraphs, headings, and text
- **Bold**, *italic*, and ~~strikethrough~~
- [Links](https://markdown.svelte.page) and images
- Code blocks and `inline code`
- Lists (ordered and unordered)
- Tables and blockquotes
- HTML elements within markdown

---

This demo renders the above markdown and tracks timing to show the caching effect in action.

Rendered Output

Click "Render" to see the markdown output.

How Token Caching Works

First render parses markdown into tokens and stores them in an LRU cache.
Subsequent renders of the same content skip parsing and use cached tokens (50-200x faster).
The cache uses LRU eviction and TTL expiration to manage memory automatically.