Markdown Fast Editor

Markdown Fast Editor is a VS Code extension for editing Markdown directly in a rendered preview while keeping the .md file as the source of truth.

It is built for large Markdown files, GitHub Flavored Markdown tables, mixed Markdown/HTML documents, and source-preserving edits where untouched blocks should not be rewritten.

Features

• Editable rendered preview for headings, paragraphs, block quotes, lists, task lists, fenced code blocks, embedded HTML, and tables.
• Embedded HTML renders as a sanitized preview plus a collapsible editable raw-source block, so tags and attributes are preserved when saved.
• Cursor-aware table insertion in the editable preview.
• Preview/source cursor sync for open source editors, plus a toolbar action to reveal the matching source range.
• Paste tables from TSV, CSV, and HTML table clipboard data.
• Table row, column, move, delete, and alignment editing from the focused cell.
• Text-editor table commands for users who prefer source editing, including converting selected CSV/TSV text into a Markdown table.
• Configurable large-file and large-table thresholds.
• Safe diagnostics copy command that omits file paths and document contents.
• Relative local images render through VS Code webview resource URIs without allowing remote tracking images.
• Parser-backed block mapping using remark, remark-gfm, and remark-frontmatter.
• Sanitized webview rendering with a strict Content Security Policy.
• Version-validated block edits so stale preview edits do not overwrite the wrong source range.
• Stable <details> interaction across table-cell saves and preview refreshes, including user-expanded and user-collapsed state.
• Durable local recovery for edits that cannot be replayed safely after a concurrent source change.
• Large table and very large document safeguards to avoid rendering massive editable DOM trees.

Usage

Open a .md or .markdown file, then run:

• Markdown Fast: Open Editable Preview
• Markdown Fast: Open Text + Preview

You can also right-click a Markdown file in Explorer and choose Open Editable Preview.

In the editable preview:

• Click rendered Markdown text to edit it directly.
• Place the caret in a paragraph and click Table to insert a table at that caret.
• Focus a table cell and use the row, column, delete, or alignment toolbar controls.
• Paste from spreadsheets, CSV, TSV, or copied HTML tables to create or fill Markdown tables.
• Use Tab and Shift+Tab to move between table cells.
• Use Cmd/Ctrl+Enter for a row below, Cmd/Ctrl+Shift+Enter for a row above, Cmd/Ctrl+] for a column right, and Cmd/Ctrl+[ for a column left.
• Edit raw HTML tags and content in the embedded HTML source block; saves use that raw source text, not sanitized preview DOM.
• Use Source to reveal the matching Markdown source range and Format HTML to lightly format the focused HTML source block.

Source Preservation

The extension edits the smallest Markdown block it can map back to the source document. Untouched front matter, reference definitions, images, nested lists, raw HTML, fenced code blocks, and large tables are preserved by range rather than being regenerated.

When you directly edit a rendered block, only that block is serialized back to Markdown.

Rendered table cells support bold, italic, strike-through, nested formatting, inline code, and links without exposing Markdown delimiters while you type. Caret positions remain stable through saves and preview refreshes, including rapid edits at the beginning, middle, or end of formatted content.

Tables inside sanitized HTML containers such as <details> remain source-mapped to their exact Markdown table island. Expanding or collapsing a disclosure is a preview-only interaction; editing a mapped cell updates only that table source and preserves the current disclosure, focus, and caret state when the refreshed structure can be proven equivalent.

If a table cell contains syntax that cannot be reconstructed byte-for-byte from rendered HTML, such as a multi-backtick code span or source-only metadata, that cell stays read-only in the preview. Edit it from the Markdown source instead; neighboring safe cells remain directly editable.

Raw HTML blocks render in two layers: a sanitized preview and an editable raw-source block. The webview sanitizer protects the preview, but sanitizer output is never written back over the raw HTML source.

Blocks with source-sensitive Markdown, such as reference links, image references, inline HTML, and footnotes, use a raw-source editor in the preview so those constructs are not simplified into lower-fidelity Markdown.

Very large tables are rendered as compact summaries instead of unbounded editable DOM tables. Documents above the configured full-parser threshold switch to a scanner-backed, block-bounded preview when possible. Oversized or structurally excessive blocks become bounded read-only source previews, and very large authoritative documents omit their full source from the webview. The complete Markdown remains in the source file for normal text-editor access.

The status shows Unsaved changes after edits reach the VS Code document and Saved after the document is saved. Command-S / Control-S in the preview flushes pending edits before saving; manual saves also request a pending-edit flush. Use VS Code’s normal Auto Save setting if desired. Saving changes updates the status without rebuilding the preview.

Preview parsing runs in background workers with bounded time, memory, and queued work. If a document cannot finish safely, the preview shows a read-only source excerpt; the complete file stays intact. Edits that cannot be validated are retained for recovery instead of being applied against an uncertain preview.

Table commands process only the table around the cursor. Very uneven tables use compact spacing to avoid creating huge padding, and oversized operations are refused before changing the source. Tabular paste into a partial table preview is also refused so hidden rows and columns are preserved.

Raw HTML warnings use bounded scans, and Format HTML leaves the source unchanged if safe depth or output limits would be exceeded.

The fallback thresholds are configurable under markdownFastEditor.* settings for users who want stricter or more permissive large-file behavior.

Commands

• Markdown Fast: Open Editable Preview
• Markdown Fast: Open Text + Preview
• Markdown Fast: Insert Table...
• Markdown Fast: Convert Selection to Table
• Markdown Fast: Copy Diagnostics
• Markdown Fast: Format Table
• Markdown Fast: Add Table Row Below
• Markdown Fast: Add Table Column Right
• Markdown Fast: Delete Table Row
• Markdown Fast: Delete Table Column

Security

Markdown is rendered inside a VS Code webview with:

• default-src 'none'
• extension-local styles and scripts only
• nonce-gated JavaScript
• sanitized rendered HTML
• no remote image requests from rendered Markdown
• relative local images rewritten through VS Code webview resource URIs
• no javascript: or data: links
• scanner-backed and bounded read-only fallbacks for oversized documents, blocks, and tables

Raw HTML remains in the source file unless the user edits that HTML block directly. The diagnostics command copies only extension/runtime metadata, document size/counts, and configured thresholds; it does not copy file paths or Markdown contents.

Support

Use the public issue tracker for support, bugs, and feature requests:

https://github.com/loredan1994/markdown-fast-editor-issues/issues

Do not include private documents, credentials, secrets, personal data, or exploit details in public issues.

For vulnerabilities, use GitHub private vulnerability reporting:

https://github.com/loredan1994/markdown-fast-editor-issues/security/advisories/new

License

Proprietary. See LICENSE.