remark-parse vs remark-gfm vs remark-slug vs remark-heading-id vs remark-autolink-headings
Markdown Processing and Enhancements
remark-parseremark-gfmremark-slugremark-heading-idremark-autolink-headingsSimilar Packages:
Markdown Processing and Enhancements

Markdown Processing and Enhancements libraries are tools that parse, transform, and enhance Markdown content in web applications. These libraries provide functionalities such as converting Markdown to HTML, adding custom features like auto-linking headings, supporting GitHub Flavored Markdown (GFM), and managing heading IDs. They are essential for applications that need to render Markdown content dynamically, offering flexibility and extensibility for developers to customize the parsing and rendering processes. These libraries are often used in content management systems, static site generators, and any application that handles user-generated Markdown content.

Npm Package Weekly Downloads Trend
3 Years
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
remark-parse16,379,8878,63619.5 kB42 years agoMIT
remark-gfm9,066,4431,09622 kB210 months agoMIT
remark-slug1,899,31989528 B0a year ago-
remark-heading-id34,4603810.9 kB32 years agoMIT
remark-autolink-headings26,44962686 B0a year ago-
Feature Comparison: remark-parse vs remark-gfm vs remark-slug vs remark-heading-id vs remark-autolink-headings

Heading Linking

  • remark-heading-id:

    remark-heading-id generates unique IDs for headings in your Markdown content without adding links. It focuses on improving the structure of your content by providing IDs that can be used for linking or styling, but it does not create visible anchor links.

  • remark-autolink-headings:

    remark-autolink-headings automatically adds anchor links to headings in your Markdown content, making them easily shareable. It enhances the usability of your documents by allowing users to link directly to specific sections.

GitHub Flavored Markdown Support

  • remark-parse:

    remark-parse is a Markdown parser that focuses on converting Markdown content into an abstract syntax tree (AST). While it does not specifically support GitHub Flavored Markdown, it is extensible and can be combined with other plugins to add GFM features as needed.

  • remark-gfm:

    remark-gfm provides full support for GitHub Flavored Markdown, including features like strikethrough, task lists, and tables. It ensures that your Markdown content is rendered correctly and consistently with GitHub's Markdown engine, making it ideal for collaborative projects.

Slug Generation

  • remark-slug:

    remark-slug automatically generates slugs for your Markdown headings, creating URL-friendly IDs that can be used for linking. This package is useful for ensuring that your headings have consistent and readable IDs, which can improve navigation and accessibility.

  • remark-heading-id:

    remark-heading-id generates unique IDs for headings in your Markdown content, but it does not create slugs. It focuses on providing unique identifiers for each heading, which can be used for linking or styling, but does not ensure URL-friendliness.

Customization and Extensibility

  • remark-parse:

    remark-parse is highly extensible, allowing developers to create custom Markdown parsers and plugins. It provides a flexible architecture for building specialized parsing logic, making it suitable for projects that require tailored Markdown processing.

  • remark-gfm:

    remark-gfm is designed to be used as a plugin within the Remark ecosystem, and while it is extensible, it is primarily focused on adding GFM features. Developers can customize its behavior, but it is not as flexible as a standalone parsing library.

  • remark-autolink-headings:

    remark-autolink-headings allows for some customization, such as modifying the link text and the way links are generated. However, it is primarily focused on the specific task of adding links to headings, so its extensibility is limited to that functionality.

Ease of Use: Code Examples

  • remark-gfm:
    import { unified } from 'unified';
    import remarkParse from 'remark-parse';
    import remarkGfm from 'remark-gfm';
    import remarkStringify from 'remark-stringify';
    
    const markdown = `# Heading 1\n\n## Task List\n- [ ] Item 1\n- [x] Item 2\n\n| Table | Header |\n|-------|--------|\n| Row 1 | Data   |`;
    
    unified()
      .use(remarkParse)
      .use(remarkGfm)
      .use(remarkStringify)
      .process(markdown)
      .then((file) => {
        console.log(String(file));
      });
    

    This example demonstrates how to use remark-gfm to parse and render GitHub Flavored Markdown, including task lists and tables. The output will correctly format these elements according to GFM specifications.

  • remark-slug:
    import { unified } from 'unified';
    import remarkParse from 'remark-parse';
    import remarkSlug from 'remark-slug';
    import remarkStringify from 'remark-stringify';
    
    const markdown = `# Heading 1\n\n## Heading 2`;
    
    unified()
      .use(remarkParse)
      .use(remarkSlug)
      .use(remarkStringify)
      .process(markdown)
      .then((file) => {
        console.log(String(file));
      });
    

    This example demonstrates how to use remark-slug to automatically generate slugs for your Markdown headings. The output will include the headings with their corresponding slugged IDs, which can be used for linking.

  • remark-heading-id:
    import { unified } from 'unified';
    import remarkParse from 'remark-parse';
    import remarkHeadingId from 'remark-heading-id';
    import remarkStringify from 'remark-stringify';
    
    const markdown = `# Heading 1\n\n## Heading 2`;
    
    unified()
      .use(remarkParse)
      .use(remarkHeadingId)
      .use(remarkStringify)
      .process(markdown)
      .then((file) => {
        console.log(String(file));
      });
    

    This example shows how to use remark-heading-id to generate unique IDs for headings in your Markdown content. The output will include the headings with their corresponding IDs, which can be used for linking or styling.

  • remark-autolink-headings:
    import { unified } from 'unified';
    import remarkParse from 'remark-parse';
    import remarkAutolinkHeadings from 'remark-autolink-headings';
    import remarkStringify from 'remark-stringify';
    
    const markdown = `# Heading 1\n\n## Heading 2`;
    
    unified()
      .use(remarkParse)
      .use(remarkAutolinkHeadings)
      .use(remarkStringify)
      .process(markdown)
      .then((file) => {
        console.log(String(file));
      });
    

    This example shows how to use remark-autolink-headings to automatically add links to headings in your Markdown content. The output will include anchor links for each heading, making them easily shareable.

How to Choose: remark-parse vs remark-gfm vs remark-slug vs remark-heading-id vs remark-autolink-headings
  • remark-parse:

    Opt for remark-parse if you need a fast and extensible Markdown parser that follows the CommonMark specification. This package is the foundation for building custom Markdown processing pipelines, allowing you to parse Markdown content into an abstract syntax tree (AST) for further manipulation.

  • remark-gfm:

    Select remark-gfm if you need comprehensive support for GitHub Flavored Markdown, including features like strikethrough, task lists, and tables. This package is ideal for projects that require compatibility with GitHub's Markdown rendering, making it a must-have for collaborative platforms.

  • remark-slug:

    Choose remark-slug if you want to automatically generate slugs (URL-friendly strings) for your Markdown headings. This package is helpful for creating consistent and SEO-friendly IDs for headings, which can be used for linking and navigation within your content.

  • remark-heading-id:

    Use remark-heading-id if you want to generate unique IDs for your Markdown headings without additional linking. This package is useful for improving the structure of your content and enabling easier navigation, especially in long documents.

  • remark-autolink-headings:

    Choose remark-autolink-headings if you want to automatically add links to your Markdown headings, making them easily shareable. This package is great for enhancing the accessibility and usability of your content by providing anchor links for each heading.

README for remark-parse

remark-parse

Build Coverage Downloads Size Sponsors Backers Chat

remark plugin to add support for parsing from markdown.

Contents

What is this?

This package is a unified (remark) plugin that defines how to take markdown as input and turn it into a syntax tree.

See the monorepo readme for info on what the remark ecosystem is.

When should I use this?

This plugin adds support to unified for parsing markdown. If you also need to serialize markdown, you can alternatively use remark, which combines unified, this plugin, and remark-stringify.

If you just want to turn markdown into HTML (with maybe a few extensions), we recommend micromark instead. If you don’t use plugins and want to access the syntax tree, you can directly use mdast-util-from-markdown. remark focusses on making it easier to transform content by abstracting these internals away.

You can combine this plugin with other plugins to add syntax extensions. Notable examples that deeply integrate with it are remark-gfm, remark-mdx, remark-frontmatter, remark-math, and remark-directive. You can also use any other remark plugin after remark-parse.

Install

This package is ESM only. In Node.js (version 16+), install with npm:

npm install remark-parse

In Deno with esm.sh:

import remarkParse from 'https://esm.sh/remark-parse@11'

In browsers with esm.sh:

<script type="module">
  import remarkParse from 'https://esm.sh/remark-parse@11?bundle'
</script>

Use

Say we have the following module example.js:

import rehypeStringify from 'rehype-stringify'
import remarkGfm from 'remark-gfm'
import remarkParse from 'remark-parse'
import remarkRehype from 'remark-rehype'
import {unified} from 'unified'

const doc = `
# Mercury

**Mercury** is the first planet from the [Sun](https://en.wikipedia.org/wiki/Sun)
and the smallest planet in the Solar System.
`

const file = await unified()
  .use(remarkParse)
  .use(remarkGfm)
  .use(remarkRehype)
  .use(rehypeStringify)
  .process(doc)

console.log(String(file))

…then running node example.js yields:

<h1>Mercury</h1>
<p><strong>Mercury</strong> is the first planet from the <a href="https://en.wikipedia.org/wiki/Sun">Sun</a>
and the smallest planet in the Solar System.</p>

API

This package exports no identifiers. The default export is remarkParse.

unified().use(remarkParse)

Add support for parsing from markdown.

Parameters

There are no parameters.

Returns

Nothing (undefined).

Examples

Example: support GFM and frontmatter

We support CommonMark by default. Non-standard markdown extensions can be enabled with plugins.

This example shows how to support GFM features (autolink literals, footnotes, strikethrough, tables, tasklists) and frontmatter (YAML):

import rehypeStringify from 'rehype-stringify'
import remarkFrontmatter from 'remark-frontmatter'
import remarkGfm from 'remark-gfm'
import remarkParse from 'remark-parse'
import remarkRehype from 'remark-rehype'
import {unified} from 'unified'

const doc = `---
layout: solar-system
---

# Hi ~~Mars~~Venus!
`

const file = await unified()
  .use(remarkParse)
  .use(remarkFrontmatter)
  .use(remarkGfm)
  .use(remarkRehype)
  .use(rehypeStringify)
  .process(doc)

console.log(String(file))

Yields:

<h1>Hi <del>Mars</del>Venus!</h1>

Example: turning markdown into a man page

Man pages (short for manual pages) are a way to document CLIs (example: type man git-log in your terminal). They use an old markup format called roff. There’s a remark plugin, remark-man, that can serialize as roff.

This example shows how to turn markdown into man pages by using unified with remark-parse and remark-man:

import remarkMan from 'remark-man'
import remarkParse from 'remark-parse'
import {unified} from 'unified'

const doc = `
# titan(7) -- largest moon of saturn

Titan is the largest moon…
`

const file = await unified().use(remarkParse).use(remarkMan).process(doc)

console.log(String(file))

Yields:

.TH "TITAN" "7" "September 2023" "" ""
.SH "NAME"
\fBtitan\fR - largest moon of saturn
.P
Titan is the largest moon…

Syntax

Markdown is parsed according to CommonMark. Other plugins can add support for syntax extensions. If you’re interested in extending markdown, more information is available in micromark’s readme.

Syntax tree

The syntax tree used in remark is mdast.

Types

This package is fully typed with TypeScript. It exports the additional type Options (which is currently empty).

Compatibility

Projects maintained by the unified collective are compatible with maintained versions of Node.js.

When we cut a new major release, we drop support for unmaintained versions of Node. This means we try to keep the current release line, remark-parse@^11, compatible with Node.js 16.

Security

As markdown can be turned into HTML and improper use of HTML can open you up to cross-site scripting (XSS) attacks, use of remark can be unsafe. When going to HTML, you will combine remark with rehype, in which case you should use rehype-sanitize.

Use of remark plugins could also open you up to other attacks. Carefully assess each plugin and the risks involved in using them.

For info on how to submit a report, see our security policy.

Contribute

See contributing.md in remarkjs/.github for ways to get started. See support.md for ways to get help. Join us in Discussions to chat with the community and contributors.

This project has a code of conduct. By interacting with this repository, organization, or community you agree to abide by its terms.

Sponsor

Support this effort and give back by sponsoring on OpenCollective!

Vercel

Motif

HashiCorp

GitBook

Gatsby

Netlify

Coinbase

ThemeIsle

Expo

Boost Note

Markdown Space

Holloway


You?

License

MIT © Titus Wormer