typewriter

goldmark-typewriter

A goldmark extension that converts typographic ("smart") Unicode characters — and Unicode style variants like bold and italic — back to their plain ASCII equivalents.

Built on github.com/client9/typewriter.

See also github.com/client9/demoji and github.com/client9/goldmark-demoji for emoji conversion and normalization.

Install

go get github.com/client9/goldmark-typewriter

Quick start

import typewriter "github.com/client9/goldmark-typewriter"

md := goldmark.New(goldmark.WithExtensions(typewriter.New()))

With options:

md := goldmark.New(goldmark.WithExtensions(
    typewriter.New(
        typewriter.WithoutCategory(typewriter.Math),
        typewriter.WithBold("**", "**"),
        typewriter.WithItalic("_", "_"),
    ),
))

What it converts

Character substitutions (all active by default)

Unicode style variants (opt-in)

Runs of styled Unicode characters — common in copy-pasted LinkedIn posts, Twitter formatting tricks, and AI-generated content — are detected and wrapped.

Prose vs code content

The extension preserves code content because goldmark's HTML renderer reads code spans and fenced blocks directly from the original source bytes — AST-level replacement is not possible there. This is a constraint of goldmark's architecture, not a policy choice.

To also normalise code content (e.g., smart quotes inside a pasted shell command), use typewriter.ReplaceBytes on raw source before parsing:

import tw "github.com/client9/typewriter"

clean := tw.ReplaceBytes(src)
md.Convert(clean, &buf)

Configuration

Enable only specific categories

// Only convert dashes and ellipses.
typewriter.New(typewriter.WithCategory(typewriter.Dashes | typewriter.Ellipsis))

Disable specific categories

typewriter.New(typewriter.WithoutCategory(typewriter.Math))

Override or exclude individual characters

typewriter.New(
    typewriter.WithMapping("—", "--"),  // prefer -- over --- for em dash
    typewriter.WithMapping("×", ""),    // leave × unchanged (empty = pass through)
    typewriter.WithMapping("°", "deg"), // add a mapping not in builtins
)

Convert Unicode bold/italic to markdown

typewriter.New(
    typewriter.WithBold("**", "**"),
    typewriter.WithItalic("_", "_"),
)

Convert Unicode bold/italic to HTML

typewriter.New(
    typewriter.WithBold("<b>", "</b>"),
    typewriter.WithItalic("<i>", "</i>"),
)

Superscripts and subscripts

typewriter.New(
    typewriter.WithSuperscript("^", ""),  // E=mc² → E=mc^2
    typewriter.WithSubscript("", ""),     // H₂O  → H2O
)

Using with the typographer

goldmark's typographer and this extension cannot be meaningfully combined in a single goldmark instance. The typographer is an inline parser (priority 9999) that fires during tokenisation — before any AST transformer runs. It converts ASCII → typographic as ast.String nodes; the typewriter transformer walks only ast.KindText and cannot undo that.

For consistent smart-typography output from mixed-source input, use a two-pass approach:

import (
    tw "github.com/client9/typewriter"
    "github.com/yuin/goldmark/extension"
)

// Step 1: strip all typographic characters from the raw markdown source.
clean := tw.ReplaceBytes(src)

// Step 2: render with the typographer — consistent output regardless of input source.
md := goldmark.New(goldmark.WithExtensions(extension.Typographer))
md.Convert(clean, &buf)

Related

• github.com/client9/typewriter — the core package; use directly for non-goldmark pipelines or raw-byte preprocessing

License

MIT