Convert HTML to Clean Markdown (GFM)

Sanitisation: what DOMPurify removes before conversion

DOMPurify parses the input into an inert document, walks every node, and deletes anything outside an allow-list before the markup is serialised back. This build runs it with the standard HTML profile plus a narrow set of additions, and the important part is what is explicitly forbidden: style, form, input and button elements are removed outright, and the style attribute is stripped from every element that carries one.

Those exclusions are deliberate and each has a reason. A stylesheet or style attribute has no Markdown representation at all, so keeping it would only leak presentational noise into the output or, worse, into a preview where it could reposition the surrounding interface. Form controls are interactive elements whose behaviour cannot survive conversion, and a stray submit button rendered inside a document preview is a genuine clickjacking surface rather than a cosmetic wart. Script and event-handler attributes are removed by the sanitiser's own defaults, and the permitted URL schemes are constrained to a small set, which is what neutralises a link whose target is a javascript-scheme payload.

Turndown is additionally told to discard script, style, noscript and frame elements outright, so even markup that survives sanitisation as an empty shell contributes nothing to the output. The practical consequence: you can paste markup from an email, a scraped page or a customer-supplied template into the editor and read the result without having executed any of it.

Tables: the GFM rules this converter actually uses

Pipe tables are not part of CommonMark; they are a GitHub-Flavored Markdown extension, and getting them right from arbitrary HTML takes more than mapping cells to pipes. This build implements its table handling as explicit rules rather than relying on a plugin, and three of those rules exist because of specific failures observed in real documents.

First, the first row of a table is always treated as the header row, whether its cells are header cells or ordinary ones. Real-world markup — particularly markup generated from Word documents — frequently omits a table head entirely, and a pipe table without a delimiter row beneath its first line is not a valid GFM table. Emitting one used to hang the preview renderer, so the first row is promoted unconditionally and a delimiter row is synthesised from its cell count.

Second, literal pipe characters inside cell values are escaped, and newlines inside a cell are collapsed to spaces. Without both, a single cell containing a pipe silently splits its row into extra columns and misaligns every value after it — the kind of corruption that looks like valid output and quietly changes your data. Third, table section elements are passed through untouched, because their default block-level treatment inserted a blank line between the header and the body, which terminates a table in GFM and leaves the remaining rows orphaned as a second, headerless table.

What is not attempted is spanning. Cells that span rows or columns have no GFM equivalent whatsoever; they are emitted as ordinary cells, so a table built on merged headers will need manual repair. Nested tables flatten for the same reason.

Element-by-element mapping, and the gaps

Heading levels one through six become the corresponding number of hash marks. Paragraphs become blank-line-separated blocks. Strong and bold become double asterisks; emphasis and italic become underscores. Anchors become inline links with their href preserved; images become image syntax with their alt text and source. Unordered and ordered lists become hyphen and numbered items, nesting by indentation to arbitrary depth. Blockquotes become angle-bracket prefixes and nest correctly. Horizontal rules become three hyphens. Line-break elements become the two-trailing-space hard break, which is the only way CommonMark expresses a break inside a paragraph.

Code is the case worth understanding. Inline code elements become backtick spans. A code element inside a preformatted element becomes a fenced block, and the language label is lifted from the code element's class name when it follows the conventional language prefix — so markup produced by a syntax highlighter keeps its language tag, which matters because that tag is what drives highlighting wherever the Markdown lands. A preformatted block with no code element inside it is still fenced, but without a language hint.

The gaps are honest and short. Description lists have no Markdown form and flatten to plain lines. Superscript, subscript, keyboard and abbreviation elements lose their semantics, retaining only their text. Details and summary disclosure widgets flatten. Definition semantics, ruby annotations and figure captions become ordinary text adjacent to the content they described. Anything genuinely unmappable is passed through as raw HTML rather than deleted, which keeps the document lossless at the cost of leaving some tags visible in the output — a trade in favour of never silently discarding content.

Local execution, whitespace and document fragments

Both libraries are ordinary browser JavaScript, so the entire conversion happens inside your tab. There is no request to any endpoint, no temporary file on a server, and nothing to retain, which is what makes the tool usable for internal templates, proprietary email markup and documents under a confidentiality obligation. Working offline is a corollary rather than a feature: once the page is loaded, conversion continues to function with the network disconnected.

Input does not need to be a complete document. A fragment — a single article element, a table pulled out of DevTools, a snippet copied from an editor — converts exactly as well as a full page, because the sanitiser builds a document around whatever it is given. A complete document works too; head content and metadata carry no convertible text and simply produce nothing.

Whitespace handling follows the HTML rules rather than the source formatting, which is usually what surprises people first. Runs of spaces and newlines inside a block element collapse to a single space, because that is what HTML says they mean, so hand-indented markup does not leak its indentation into the Markdown. Preformatted content is the exception and is preserved byte-for-byte. If your output has lost line breaks you expected to keep, they were almost certainly source formatting rather than break elements, and the fix is to mark them up as breaks or paragraphs.