micromark-extension-directive

What is micromark-extension-directive?

The micromark-extension-directive package is an extension for micromark, a Markdown parser, that allows for the use of custom directives within Markdown content. This can be useful for adding custom syntax or functionality to Markdown documents.

What are micromark-extension-directive's main functionalities?

Custom Block Directives

This feature allows you to define custom block directives in your Markdown content. The example shows how to use a custom block directive and convert it to HTML using micromark.

const micromark = require('micromark');
const directive = require('micromark-extension-directive');

const content = ':::{custom-block}
This is a custom block directive.
:::';

const html = micromark(content, {
  extensions: [directive()]
});

console.log(html);

Custom Leaf Directives

This feature allows you to define custom leaf directives in your Markdown content. The example shows how to use a custom leaf directive and convert it to HTML using micromark.

const micromark = require('micromark');
const directive = require('micromark-extension-directive');

const content = '::custom-leaf[This is a custom leaf directive.]';

const html = micromark(content, {
  extensions: [directive()]
});

console.log(html);

Custom Text Directives

This feature allows you to define custom text directives in your Markdown content. The example shows how to use a custom text directive and convert it to HTML using micromark.

const micromark = require('micromark');
const directive = require('micromark-extension-directive');

const content = 'This is a text with a ::custom-text[custom text directive].';

const html = micromark(content, {
  extensions: [directive()]
});

console.log(html);

Other packages similar to micromark-extension-directive

remark-directive

remark-directive is a plugin for remark, another Markdown processor, that provides similar functionality for custom directives. It allows you to define custom syntax and behavior in Markdown documents. Compared to micromark-extension-directive, remark-directive is used within the remark ecosystem and offers similar capabilities for handling custom directives.

markdown-it-container

markdown-it-container is a plugin for markdown-it, a different Markdown parser, that allows for custom containers in Markdown. It provides a way to define custom block-level containers with specific syntax. While it doesn't offer the same granularity as micromark-extension-directive, it is useful for creating custom block elements in Markdown.

markdown-it-directive

markdown-it-directive is another plugin for markdown-it that provides support for custom directives. It allows you to define custom syntax and behavior for both block and inline directives. This package is similar to micromark-extension-directive but is designed to work with the markdown-it parser.

README

micromark-extension-directive

micromark extension to support the generic directives proposal (:cite[smith04], ::youtube[Video of a cat in a box]{v=01ab2cd3efg}, and such).

Generic directives solve the need for an infinite number of potential extensions to markdown in a single markdown-esque way. However, it’s just a proposal and may never be specced.

This package provides the low-level modules for integrating with the micromark tokenizer and the micromark HTML compiler.

You probably shouldn’t use the HTML parts of this package directly, but instead use mdast-util-directive with mdast or remark-directive with remark

Install

npm:

npm install micromark-extension-directive

Use

Say we have the following file, example.md:

A lovely language know as :abbr[HTML]{title="HyperText Markup Language"}.

And our script, example.js, looks as follows:

var fs = require('fs')
var micromark = require('micromark')
var syntax = require('micromark-extension-directive')
var html = require('micromark-extension-directive/html')

var doc = fs.readFileSync('example.md')

var result = micromark(doc, {
  extensions: [syntax()],
  htmlExtensions: [html({abbr: abbr})]
})

console.log(result)

function abbr(d) {
  if (d.type !== 'textDirective') return false

  this.tag('<abbr')

  if (d.attributes && 'title' in d.attributes) {
    this.tag(' title="' + this.encode(d.attributes.title) + '"')
  }

  this.tag('>')
  this.raw(d.label || '')
  this.tag('</abbr>')
}

Now, running node example yields (abbreviated):

<p>A lovely language know as <abbr title="HyperText Markup Language">HTML</abbr>.</p>

API

html(htmlOptions?)

syntax(syntaxOptions?)

Note: syntax is the default export of this module, html is available at micromark-extension-directive/html.

Support the generic directives proposal. The export of syntax is a function that can be called with options and returns an extension for the micromark parser (to tokenize directives in text, flow, and as a container; can be passed in extensions). The export of html is a function that can be called with options and returns an extension for the default HTML compiler (to compile directives a certain way; can be passed in htmlExtensions).

syntaxOptions

None yet, but might be added in the future.

htmlOptions

An object mapping names of directives to handlers (Object.<Handle>). The special name '*' is the fallback to handle all unhandled directives.

function handle(directive)

How to handle a directive (Directive).

Returns

boolean — false can be used to signal that the directive could not be handled, in which case the fallback is used (when given).

Directive

An object representing a directive.

Fields

• type (enum, either 'textDirective', 'leafDirective', or 'containerDirective')
• name (string) — name of directive
• label (string?) — compiled HTML content in brackets
• attributes (Object.<string>?) — optional object w/ HTML attributes
• content (string?) — compiled HTML content when container

Syntax

The syntax looks like this:

Directives in text can form with a single colon, such as :cite[smith04].
Their syntax is `:name[label]{attributes}`.

Leafs (block without content) can form by using two colons:

::youtube[Video of a cat in a box]{vid=01ab2cd3efg}

Their syntax is `::name[label]{attributes}` on its own line.

Containers (blocks with content) can form by using three colons:

:::spoiler
He dies.
:::

The `name` part is required.  The first character must be a letter, other
characters can be alphanumerical and `-`.

The `[label]` part is optional (`:x` and `:x[]` are equivalent).
When used, it can include text constructs such as emphasis and so on: `x[a *b*
c]`.

The `{attributes}` part is optional (`:x` and `:x{}` are equivalent).
When used, it is handled like HTML attributes, such as that `{a}`, `{a=""}`,
, `{a=''}` but also `{a=b}`, `{a="b"}`, and `{a='b'}` are equivalent.
Shortcuts are available for `id=` (`{#readme}` for `{id=readme}`) and
`class` (`{.big}` for `{class=big}`).
When multiple ids are found, the last is used; when multiple classes are found,
they are combined: `{.red class=green .blue}` is equivalent to
`{.red .green .blue}` and `{class="red green blue"}`.

Containers can be nested by using more colons outside:

::::spoiler
He dies.

:::spoiler
She is born.
:::
::::

The closing fence must include the same or more colons as the opening.
If no closing is found, the container runs to the end of its parent container
(block quote, list item, document, or other container).

::::spoiler
These three are not enough to close
:::
So this line is also part of the container.

Note that while other implementations are sometimes loose in what they allow, this implementation mimics CommonMark as closely as possible:

• Whitespace is not allowed between colons and name (: a), name and label (:a []), name and attributes (:a {}), or label and attributes (:a[] {}) — because it’s not allowed in links either ([] ())
• No trailing colons allowed on the opening fence of a container (:::a:::) — because it’s not allowed in fenced code either
• The label and attributes in a leaf or container cannot include line endings (::a[b\nc]) — because it’s not allowed in fenced code either

Related

• remarkjs/remark — markdown processor powered by plugins
• micromark/micromark — the smallest commonmark-compliant markdown parser that exists
• syntax-tree/mdast-util-directive — mdast utility to support generic directives
• syntax-tree/mdast-util-from-markdown — mdast parser using micromark to create mdast from markdown
• syntax-tree/mdast-util-to-markdown — mdast serializer to create markdown from mdast

Contribute

See contributing.md in micromark/.github for ways to get started. See support.md for ways to get help.

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

License

MIT © Titus Wormer