Markdown Rendering Simplified
Features
- Removes the remark / unified complexity and easy to use.
- Powered by the unified processor for an extensible plugin pipeline.
- Built in caching 💥 making it render very fast when there isn't a change
- Frontmatter support built in by default. 🎉
- Easily Render to
ReactorHTML. - Generates a Table of Contents for your markdown files (remark-toc).
- Slug generation for your markdown files (rehype-slug).
- Code Highlighting (rehype-highlight).
- Math Support (rehype-katex).
- Markdown to HTML (rehype-stringify).
- Github Flavor Markdown (remark-gfm).
- Emoji Support (remark-emoji).
- MDX Support (remark-mdx).
- Raw HTML Passthrough (rehype-raw).
- Built in Hooks for adding code to render pipeline.
- AI-powered metadata generation, SEO, and translation via the Vercel AI SDK.
Table of Contents
- Getting Started
- API
new Writr(arg?: string | WritrOptions, options?: WritrOptions).content.body.options.frontmatter.frontMatterRaw.cache.engine.render(options?: RenderOptions).renderSync(options?: RenderOptions).renderToFile(filePath: string, options?: RenderOptions).renderToFileSync(filePath: string, options?: RenderOptions).renderReact(options?: RenderOptions, reactOptions?: HTMLReactParserOptions).renderReactSync( options?: RenderOptions, reactOptions?: HTMLReactParserOptions).validate(content?: string, options?: RenderOptions).validateSync(content?: string, options?: RenderOptions).loadFromFile(filePath: string).loadFromFileSync(filePath: string).saveToFile(filePath: string).saveToFileSync(filePath: string)
- Caching On Render
- GitHub Flavored Markdown (GFM)
- Hooks
- Emitters
- AI
- Migrating to v6
- Unified Processor Engine
- Benchmarks
- ESM and Node Version Support
- Code of Conduct and Contributing
- License
Getting Started
> npm install writr
Then you can use it like this:
import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
const html = await writr.render(); // Hello World 🙂
This is a test.
Its just that simple. Want to add some options? No problem.
import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
const options = {
emoji: false
}
const html = await writr.render(options); // Hello World ::-):
This is a test.
An example passing in the options also via the constructor:
import { Writr, WritrOptions } from 'writr';
const writrOptions = {
renderOptions: {
emoji: true,
toc: true,
slug: true,
highlight: true,
gfm: true,
math: true,
mdx: true,
rawHtml: false,
caching: true,
}
};
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`, writrOptions);
const html = await writr.render(options); // Hello World ::-):
This is a test.
API
new Writr(arg?: string | WritrOptions, options?: WritrOptions)
By default the constructor takes in a markdown string or WritrOptions in the first parameter. You can also send in nothing and set the markdown via .content property. If you want to pass in your markdown and options you can easily do this with new Writr('## Your Markdown Here', { ...options here}). You can access the WritrOptions from the instance of Writr. Here is an example of WritrOptions.
import { Writr, WritrOptions } from 'writr';
const writrOptions = {
renderOptions: {
emoji: true,
toc: true,
slug: true,
highlight: true,
gfm: true,
math: true,
mdx: true,
rawHtml: false,
caching: true,
}
};
const writr = new Writr(writrOptions);
.content
Setting the markdown content for the instance of Writr. This can be set via the constructor or directly on the instance and can even handle frontmatter.
import { Writr } from 'writr';
const writr = new Writr();
writr.content = `---
title: Hello World
---
# Hello World ::-):\n\n This is a test.`;
.body
gets the body of the markdown content. This is the content without the frontmatter.
import { Writr } from 'writr';
const writr = new Writr();
writr.content = `---
title: Hello World
---
# Hello World ::-):\n\n This is a test.`;
console.log(writr.body); // '# Hello World ::-):\n\n This is a test.'
.options
Accessing the default options for this instance of Writr. Here is the default settings for WritrOptions. These are the default settings for the WritrOptions:
{
renderOptions: {
emoji: true,
toc: true,
slug: true,
highlight: true,
gfm: true,
math: true,
mdx: false,
rawHtml: false,
caching: true,
}
}
By default, raw HTML in markdown (such as Note: Setting Accessing the frontmatter for this instance of Writr. This is a you can also set the front matter directly like this: Accessing the raw frontmatter for this instance of Writr. This is a Accessing the cache for this instance of Writr. By default this is an in memory cache and is disabled (set to false) by default. You can enable this by setting This is a test. Accessing the underlying engine for this instance of Writr. This is a Rendering markdown to HTML. the options are based on RenderOptions. Which you can access from the Writr instance. This is a test. This is a test. Rendering markdown to HTML synchronously. the options are based on RenderOptions. Which you can access from the Writr instance. The parameters are the same as the This is a test. Rendering markdown to a file. The options are based on RenderOptions. Rendering markdown to a file synchronously. The options are based on RenderOptions. Rendering markdown to React. The options are based on RenderOptions and now HTMLReactParserOptions from Rendering markdown to React. The options are based on RenderOptions and now HTMLReactParserOptions from Validate markdown content by attempting to render it. Returns a Synchronously validate markdown content by attempting to render it. Returns a This is the synchronous version of Load your markdown content from a file path. Load your markdown content from a file path synchronously. Save your markdown and frontmatter (if included) content to a file path. Save your markdown and frontmatter (if included) content to a file path synchronously. Caching is built into Writr and is an in-memory cache using or via If you want to set the caching options for the instance of Writr you can do so like this: Writr includes full support for GitHub Flavored Markdown (GFM) through the When GFM is enabled (which it is by default), you get access to the following features: Create tables using pipes and hyphens: Use Create interactive checkboxes: URLs are automatically converted to clickable links: GitHub-style alerts are supported to emphasize critical information. These are blockquote-based admonitions that render with special styling: GFM is enabled by default. Here's an example: If you need to disable GFM features, you can set ~~strikethrough~~ text Note: When GFM is disabled, GitHub blockquote alerts will not be processed and will render as regular blockquotes. Hooks are a way to add additional parsing to the render pipeline. You can add hooks to the the Writr instance. Here is an example of adding a hook to the instance of Writr: For For For This is called when you call For This is called when you call For This is called when you call Writr extends the Hookified class, which provides event emitter capabilities. This means you can listen to events emitted by Writr during its lifecycle, particularly error events. Writr emits an You can listen to error events using the All methods use an emit-only error pattern — they call Rendering Methods — emit error, return Validation Methods: File Operations — emit error, return void: Front Matter Operations — emit error, return fallback: Example 1: Global Error Handler Example 2: Validation with Error Listening Example 3: File Operations Without Try/Catch Since Writr extends Hookified, you have access to standard event emitter methods: For more information about event handling capabilities, see the Hookified documentation. Writr includes built-in AI capabilities for metadata generation, SEO, and translation powered by the Vercel AI SDK. Plug in any supported model provider (OpenAI, Anthropic, Google, etc.) via the Pass By default, the provider imports read API keys from environment variables: To set API keys programmatically, use the provider factory functions instead: Generate metadata from your document content using Generated fields: By default, The The mapping applies to all behaviors — field existence checks, overwrites, and skips all use the mapped key when checking frontmatter. Generate SEO metadata using Available fields: Translate the document into another language using Writr v6 upgrades hookified from v1 to v2 and removes The Before (v5): After (v6): All methods now use an emit-only pattern — errors are emitted via How errors propagate: Other changes: Writr now uses hookified v2 which introduces several new options available through See the hookified documentation for full details. Writr builds on top of the open source unified processor – the core project that powers
remark, rehype, and many other content tools. Unified
provides a pluggable pipeline where each plugin transforms a syntax tree. Writr configures a default set of plugins to turn
Markdown into HTML, but you can access the processor through the This is a comparison with minimal configuration where we have disabled all rendering pipeline and just did straight caching + rendering to compare it against the fastest: As you can see this module is performant with The benchmark shows rendering performance via Sync and Async methods with caching enabled and disabled and all features. This package is ESM only and tested on the current lts version and its previous. Please don't open issues for questions regarding CommonJS / ESM or previous Nodejs versions. Please use our Code of Conduct and Contributing guidelines for development and testing. We appreciate your contributions! MIT & © Jared Wray Full Changelog: https://github.com/jaredwray/writr/compare/v6.0.1...v6.1.0 Full Changelog: https://github.com/jaredwray/writr/compare/v6.0.0...v6.0.1 Full Changelog: https://github.com/jaredwray/writr/compare/v5.0.4...v6.0.0, , or rawHtml: true to preserve raw HTML elements and their attributes in the rendered output. This is useful for embedding videos, widgets, or custom HTML in your markdown content.
mdx: true also enables raw HTML passthrough as part of the MDX specification. The rawHtml option is for enabling raw HTML in standard markdown without using MDX..frontmatterRecord and can be set via the .content property.import { Writr } from 'writr';
const writr = new Writr();
writr.content = `---
title: Hello World
---
# Hello World ::-):\n\n This is a test.`;
console.log(writr.frontmatter); // { title: 'Hello World' }
import { Writr } from 'writr';
const writr = new Writr();
writr.frontmatter = { title: 'Hello World' };
.frontMatterRawstring and can be set via the .content property.import { Writr } from 'writr';
const writr = new Writr();
writr.content = `---
title: Hello World
---
# Hello World ::-):\n\n This is a test.`;
console.log(writr.frontMatterRaw); // '---\ntitle: Hello World\n---'
.cachecaching: true in the RenderOptions of the WritrOptions or when calling render passing the RenderOptions like here:import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
const options = {
caching: true
}
const html = await writr.render(options); // Hello World ::-):
.engineProcessor from the core unified project and uses the familiar .use() plugin pattern. You can chain additional unified plugins on this processor to customize the render pipeline. Learn more about the unified engine at unifiedjs.com and check out the getting started guide for examples..render(options?: RenderOptions)import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
const html = await writr.render(); // Hello World 🙂
Hello World ::-):
.renderSync(options?: RenderOptions).render() function.import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
const html = writr.renderSync(); // Hello World 🙂
.renderToFile(filePath: string, options?: RenderOptions)import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
await writr.renderToFile('path/to/file.html');
.renderToFileSync(filePath: string, options?: RenderOptions)import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
writr.renderToFileSync('path/to/file.html');
.renderReact(options?: RenderOptions, reactOptions?: HTMLReactParserOptions)html-react-parser.import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
const reactElement = await writr.renderReact(); // Will return a React.JSX.Element
.renderReactSync( options?: RenderOptions, reactOptions?: HTMLReactParserOptions)html-react-parser.import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
const reactElement = writr.renderReactSync(); // Will return a React.JSX.Element
.validate(content?: string, options?: RenderOptions)WritrValidateResult object with a valid boolean and optional error property. Note that this will disable caching on render to ensure accurate validation.import { Writr } from 'writr';
const writr = new Writr(`# Hello World\n\nThis is a test.`);
// Validate current content
const result = await writr.validate();
console.log(result.valid); // true
// Validate external content without changing the instance
const externalResult = await writr.validate('## Different Content');
console.log(externalResult.valid); // true
console.log(writr.content); // Still "# Hello World\n\nThis is a test."
// Handle validation errors
const invalidWritr = new Writr('Put invalid markdown here');
const errorResult = await invalidWritr.validate();
console.log(errorResult.valid); // false
console.log(errorResult.error?.message); // "Invalid plugin"
.validateSync(content?: string, options?: RenderOptions)WritrValidateResult object with a valid boolean and optional error property..validate() with the same parameters and behavior.import { Writr } from 'writr';
const writr = new Writr(`# Hello World\n\nThis is a test.`);
// Validate current content synchronously
const result = writr.validateSync();
console.log(result.valid); // true
// Validate external content without changing the instance
const externalResult = writr.validateSync('## Different Content');
console.log(externalResult.valid); // true
console.log(writr.content); // Still "# Hello World\n\nThis is a test."
.loadFromFile(filePath: string)import { Writr } from 'writr';
const writr = new Writr();
await writr.loadFromFile('path/to/file.md');
.loadFromFileSync(filePath: string)import { Writr } from 'writr';
const writr = new Writr();
writr.loadFromFileSync('path/to/file.md');
.saveToFile(filePath: string)import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
await writr.saveToFile('path/to/file.md');
.saveToFileSync(filePath: string)import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
writr.saveToFileSync('path/to/file.md');
Caching On Render
CacheableMemory from Cacheable. It is turned off by default and can be enabled by setting caching: true in the RenderOptions of the WritrOptions or when calling render passing the RenderOptions like here:import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`, { renderOptions: { caching: true } });
RenderOptions such as:import { Writr } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
await writr.render({ caching: true});
// we will set the lruSize of the cache and the default ttl
import {Writr} from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`, { renderOptions: { caching: true } });
writr.cache.store.lruSize = 100;
writr.cache.store.ttl = '5m'; // setting it to 5 minutes
GitHub Flavored Markdown (GFM)
remark-gfm and remark-github-blockquote-alert plugins. GFM is enabled by default and adds several powerful features to standard Markdown.GFM Features
Tables
| Feature | Supported |
|---------|-----------|
| Tables | Yes |
| Alerts | Yes |
Strikethrough
~~ to create strikethrough text:~~This text is crossed out~~
Task Lists
- [x] Completed task
- [ ] Incomplete task
- [ ] Another task
Autolinks
https://github.com
GitHub Blockquote Alerts
> [!NOTE]
> Useful information that users should know, even when skimming content.
> [!TIP]
> Helpful advice for doing things better or more easily.
> [!IMPORTANT]
> Key information users need to know to achieve their goal.
> [!WARNING]
> Urgent info that needs immediate user attention to avoid problems.
> [!CAUTION]
> Advises about risks or negative outcomes of certain actions.
Using GFM
import { Writr } from 'writr';
const markdown = `
# Task List Example
- [x] Learn Writr basics
- [ ] Master GFM features
> [!NOTE]
> GitHub Flavored Markdown is enabled by default!
| Feature | Status |
|---------|--------|
| GFM | ✓ |
`;
const writr = new Writr(markdown);
const html = await writr.render(); // Renders with full GFM support
Disabling GFM
gfm: false in the render options:import { Writr } from 'writr';
const writr = new Writr('~~strikethrough~~ text');
// Disable GFM
const html = await writr.render({ gfm: false });
// Output: strikethrough textHooks
import { Writr, WritrHooks } from 'writr';
const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
writr.onHook(WritrHooks.beforeRender, data => {
data.body = 'Hello, Universe!';
});
const result = await writr.render();
console.log(result); // Hello, Universe!
beforeRender the data object is a renderData object. Here is the interface for renderData:export type renderData = {
body: string
options: RenderOptions;
}
afterRender the data object is a resultData object. Here is the interface for resultData:export type resultData = {
result: string;
}
saveToFile the data object is an object with the filePath and content. Here is the interface for saveToFileData:export type saveToFileData = {
filePath: string;
content: string;
}
saveToFile, saveToFileSync.renderToFile the data object is an object with the filePath and content. Here is the interface for renderToFileData:export type renderToFileData = {
filePath: string;
content: string;
}
renderToFile, renderToFileSync.loadFromFile the data object is an object with content so you can change before it is set on writr.content. Here is the interface for loadFromFileData:export type loadFromFileData = {
content: string;
}
loadFromFile, loadFromFileSync.Emitters
Error Events
error event whenever an error occurs in any of its methods. This provides a centralized way to handle errors without wrapping every method call in a try/catch block.Listening to Error Events
.on() method:import { Writr } from 'writr';
const writr = new Writr('# Hello World');
// Listen for any errors
writr.on('error', (error) => {
console.error('An error occurred:', error.message);
// Handle the error appropriately
// Log to error tracking service, display to user, etc.
});
// With a listener registered, errors are emitted to the listener
// and the method returns its fallback value (e.g. "" for render)
const html = await writr.render();
Methods that Emit Errors
this.emit('error', error) but never explicitly re-throw. If no error listener is registered and throwOnEmptyListeners is true (the default), the emit('error') call itself will throw, following standard Node.js EventEmitter behavior."":
render() - Emits error when markdown rendering fails, returns empty stringrenderSync() - Emits error when markdown rendering fails, returns empty stringrenderReact() - Emits error when React rendering fails, returns empty stringrenderReactSync() - Emits error when React rendering fails, returns empty string
validate() - Does not emit errors. Returns { valid: false, error } on failurevalidateSync() - Emits error and returns { valid: false, error } on failure
renderToFile() - Emits error when rendering or file writing failsrenderToFileSync() - Emits error when rendering or file writing failsloadFromFile() - Emits error when file reading failsloadFromFileSync() - Emits error when file reading failssaveToFile() - Emits error when file writing failssaveToFileSync() - Emits error when file writing fails
frontMatter getter - Emits error when YAML parsing fails, returns {}frontMatter setter - Emits error when YAML serialization failsError Event Examples
import { Writr } from 'writr';
const writr = new Writr();
// Set up a global error handler
writr.on('error', (error) => {
// Log to your monitoring service
console.error('Writr error:', error);
// Send to error tracking (e.g., Sentry, Rollbar)
// errorTracker.captureException(error);
});
// All errors will be emitted to the listener above
await writr.loadFromFile('./content.md');
const html = await writr.render();
import { Writr } from 'writr';
const writr = new Writr('# My Content');
let lastError = null;
writr.on('error', (error) => {
lastError = error;
});
const result = await writr.validate();
if (!result.valid) {
console.log('Validation failed');
console.log('Error details:', lastError);
// result.error is also available
}
import { Writr } from 'writr';
const writr = new Writr('# Content');
writr.on('error', (error) => {
console.error('File operation failed:', error.message);
// Handle gracefully - maybe use default content
});
// With a listener registered, errors are emitted and the method returns normally
await writr.loadFromFile('./maybe-missing.md');
// Note: without a listener, this will throw by default (throwOnEmptyListeners is true)
Event Emitter Methods
writr.on(event, handler) - Add an event listenerwritr.once(event, handler) - Add a one-time event listenerwritr.off(event, handler) - Remove an event listenerwritr.emit(event, data) - Emit an event (used internally)AI
ai option.import { Writr } from 'writr';
import { openai } from '@ai-sdk/openai';
const writr = new Writr('# My Document\n\nSome markdown content here.', {
ai: { model: openai('gpt-4.1-mini') },
});
// Generate metadata
const metadata = await writr.ai.getMetadata();
// Generate only specific fields
const metadata = await writr.ai.getMetadata({ title: true, description: true });
// Generate SEO metadata
const seo = await writr.ai.getSEO();
// Translate to Spanish
const translated = await writr.ai.getTranslation({ to: 'es' });
// Apply generated metadata to frontmatter
const result = await writr.ai.applyMetadata({
generate: { description: true, category: true },
overwrite: true,
});
AI Options
ai in the WritrOptions to enable AI features:
Property
Type
Required
Description
modelLanguageModelYes
The AI SDK model instance (e.g.
openai("gpt-4.1-mini")).
cachebooleanNo
Enables in-memory caching of AI results.
promptsWritrAIPromptsNo
Custom prompt overrides for metadata, SEO, and translation.
const writr = new Writr('# My Document', {
ai: {
model: openai('gpt-4.1-mini'),
cache: true,
},
});
AI Provider Configuration
Provider
Import
Environment Variable
OpenAI
openai from @ai-sdk/openaiOPENAI_API_KEY
Anthropic
anthropic from @ai-sdk/anthropicANTHROPIC_API_KEY
Google
google from @ai-sdk/googleGOOGLE_GENERATIVE_AI_API_KEY// Uses OPENAI_API_KEY from environment
import { openai } from '@ai-sdk/openai';
const writr = new Writr('# Hello', { ai: { model: openai('gpt-4.1-mini') } });
import { Writr } from 'writr';
import { createOpenAI } from '@ai-sdk/openai';
import { createAnthropic } from '@ai-sdk/anthropic';
import { createGoogleGenerativeAI } from '@ai-sdk/google';
// OpenAI
const openai = createOpenAI({ apiKey: 'your-openai-key' });
const writr = new Writr('# Hello', { ai: { model: openai('gpt-4.1-mini') } });
// Anthropic
const anthropic = createAnthropic({ apiKey: 'your-anthropic-key' });
const writr = new Writr('# Hello', { ai: { model: anthropic('claude-sonnet-4-20250514') } });
// Google
const google = createGoogleGenerativeAI({ apiKey: 'your-google-key' });
const writr = new Writr('# Hello', { ai: { model: google('gemini-2.0-flash') } });
Metadata
writr.ai.getMetadata(), or generate and apply it directly to frontmatter with writr.ai.applyMetadata().Generating Metadata
getMetadata() analyzes the document and returns a WritrMetadata object. By default all fields are generated. Pass options to select specific fields.// Generate all metadata fields
const metadata = await writr.ai.getMetadata();
console.log(metadata.title); // "Getting Started with Writr"
console.log(metadata.tags); // ["markdown", "rendering", "typescript"]
console.log(metadata.description); // "A guide to using Writr for markdown processing."
console.log(metadata.readingTime); // 3 (minutes)
console.log(metadata.wordCount); // 450
// Generate only specific fields
const partial = await writr.ai.getMetadata({
title: true,
description: true,
tags: true,
});
Field
Type
Description
titlestringThe best-fit title for the document.
descriptionstringA concise meta-style description of the document.
tagsstring[]Human-friendly labels for organizing the document.
keywordsstring[]Search-oriented terms related to the document content.
previewstringA short teaser or preview snippet of the content.
summarystringA slightly longer overview of the document.
categorystringA broad grouping such as "docs", "guide", or "blog".
topicstringThe primary subject the document is about.
audiencestringThe intended audience for the document.
difficulty"beginner" | "intermediate" | "advanced"The estimated skill level required.
readingTimenumberEstimated reading time in minutes (computed, not AI-generated).
wordCountnumberTotal word count of the document (computed, not AI-generated).
Applying Metadata to Frontmatter
applyMetadata() generates metadata and writes it into the document's frontmatter. The result tells you exactly what happened:
applied — fields that were newly written because they were missing from frontmatter.skipped — fields that already existed and were not overwritten.overwritten — fields that replaced existing frontmatter values.const result = await writr.ai.applyMetadata();
console.log(result.applied); // ["description", "tags", "category"]
console.log(result.skipped); // ["title"] (already existed)
console.log(result.overwritten); // []
Overwrite
applyMetadata() only fills in missing fields — existing frontmatter values are never touched. The overwrite option changes this behavior:
overwrite: true: All generated fields replace existing frontmatter values.overwrite: ['field1', 'field2']: Only the listed fields are overwritten. Other existing values are preserved.// Overwrite all generated fields, even if they already exist
const result = await writr.ai.applyMetadata({
generate: { title: true, description: true },
overwrite: true,
});
// Only overwrite title, leave description alone if it already exists
const result = await writr.ai.applyMetadata({
generate: { title: true, description: true, category: true },
overwrite: ['title'],
});
Field Mapping
fieldMap option maps generated metadata keys to different frontmatter field names. This is useful when your frontmatter schema uses different naming conventions than the default metadata keys.const result = await writr.ai.applyMetadata({
generate: { description: true, tags: true },
fieldMap: {
description: 'meta_description',
tags: 'labels',
},
});
// writr.frontMatter.meta_description === "A guide to..."
// writr.frontMatter.labels === ["markdown", "rendering"]
SEO
writr.ai.getSEO(). By default all fields are generated. Pass options to select specific fields.const seo = await writr.ai.getSEO();
console.log(seo.slug); // "getting-started-with-writr"
console.log(seo.openGraph?.title); // "Getting Started with Writr"
// Generate only a slug
const seo = await writr.ai.getSEO({ slug: true });
slug, openGraph (includes title, description, image).Translation
writr.ai.getTranslation(). Returns a new Writr instance with the translated content.const spanish = await writr.ai.getTranslation({ to: 'es' });
console.log(spanish.body); // Spanish markdown
// With source language and frontmatter translation
const french = await writr.ai.getTranslation({
to: 'fr',
from: 'en',
translateFrontMatter: true,
});
Option
Type
Required
Description
tostringYes
Target language or locale.
fromstringNo
Source language or locale.
translateFrontMatterbooleanNo
Also translate frontmatter string values.
Using WritrAI Directly
WritrAI is exported as a named export and can be instantiated independently from the Writr constructor. This is useful when you want to configure the AI instance separately or swap models on the fly.import { Writr, WritrAI } from 'writr';
import { openai } from '@ai-sdk/openai';
const writr = new Writr('# My Document\n\nSome markdown content here.');
const ai = new WritrAI(writr, {
model: openai('gpt-4.1-mini'),
cache: true,
});
// Generate metadata
const metadata = await ai.getMetadata();
console.log(metadata.title);
console.log(metadata.tags);
// Generate SEO data
const seo = await ai.getSEO();
console.log(seo.slug);
// Translate
const translated = await ai.getTranslation({ to: 'es' });
console.log(translated.body);
// Apply metadata to frontmatter
const result = await ai.applyMetadata({
generate: { title: true, description: true, tags: true },
overwrite: true,
});
Migrating to v6
throwErrors in favor of hookified's built-in error handling options.Breaking Changes
throwErrors removedthrowErrors option has been removed from WritrOptions. Use throwOnEmitError instead, which is provided by hookified's HookifiedOptions (now spread into WritrOptions).const writr = new Writr('# Hello', { throwErrors: true });
const writr = new Writr('# Hello', { throwOnEmitError: true });
Error handling redesign
emit('error', error) but never explicitly re-thrown. Methods return fallback values on error ("" for render methods, {} for frontMatter getter, { valid: false, error } for validate).
throwOnEmptyListeners defaults to true, the emit('error') call itself throws, following standard Node.js EventEmitter behavior. This means unhandled errors will still surface as exceptions.throwOnEmitError: true: Every emit('error') call throws, even when listeners are registered. This affects all methods that emit errors.
render() and renderSync() no longer throw wrapped "Failed to render markdown: ..." errors. They emit the original error and return "".validate() (async) no longer emits errors — it only returns { valid: false, error }. validateSync() still emits.hookified v2
WritrOptions:
throwOnEmitError — Throw when emit("error") is called, even with listeners (default: false)throwOnHookError — Throw when a hook handler throws (default: false)throwOnEmptyListeners — Throw when emitting error with no listeners (default: true)eventLogger — Logger instance for event loggingUnified Processor Engine
.engine property to add your own behavior with
writr.engine.use(myPlugin). The unified documentation has more details and guides for building
plugins and working with the processor directly.Benchmarks
name
summary
ops/sec
time/op
margin
samples
Writr (Sync) (Caching)
🥇
83K
14µs
±0.27%
74K
Writr (Async) (Caching)
-3%
80K
14µs
±0.27%
71K
markdown-it
-30%
58K
20µs
±0.37%
50K
marked
-33%
56K
25µs
±0.50%
40K
Writr (Sync)
-94%
5K
225µs
±0.88%
10K
Writr (Async)
-94%
5K
229µs
±0.89%
10K
caching enabled but was built to be performant enough but with all the features added in. If you are just wanting performance and not features then markdown-it or marked is the solution unless you use Writr with caching.
name
summary
ops/sec
time/op
margin
samples
Writr (Async) (Caching)
🥇
26K
39µs
±0.12%
25K
Writr (Sync) (Caching)
-0.92%
26K
40µs
±0.15%
25K
Writr (Sync)
-93%
2K
630µs
±0.97%
10K
Writr (Async)
-93%
2K
649µs
±0.96%
10K
ESM and Node Version Support
Code of Conduct and Contributing
License
Latest's Releases
What's Changed
New Contributors
What's Changed
What's Changed