mdast-util-math

What is mdast-util-math?

The `mdast-util-math` package is a utility for working with math content in Markdown Abstract Syntax Trees (MDAST). It provides tools to parse and serialize math content, making it easier to handle mathematical expressions within Markdown documents.

What are mdast-util-math's main functionalities?

Parse Math Content

This feature allows you to parse Markdown content that includes inline and block math expressions. The code sample demonstrates how to use `mdast-util-math` with `remark-parse` and `remark-math` to parse a Markdown string containing a math expression.

const { fromMarkdown } = require('mdast-util-math');
const { unified } = require('unified');
const markdown = require('remark-parse');
const math = require('remark-math');

const processor = unified()
  .use(markdown)
  .use(math);

const tree = processor.parse('Here is some math: $E=mc^2$');
console.log(tree);

Serialize Math Content

This feature allows you to serialize MDAST containing math expressions back into Markdown. The code sample shows how to convert an MDAST tree with an inline math node back into a Markdown string.

const { toMarkdown } = require('mdast-util-math');
const { unified } = require('unified');
const markdown = require('remark-stringify');
const math = require('remark-math');

const tree = {
  type: 'root',
  children: [
    { type: 'paragraph', children: [
      { type: 'text', value: 'Here is some math: ' },
      { type: 'inlineMath', value: 'E=mc^2' }
    ]}
  ]
};

const processor = unified()
  .use(markdown)
  .use(math);

const result = processor.stringify(tree);
console.log(result);

Other packages similar to mdast-util-math

remark-math

The `remark-math` package is a plugin for `remark` that adds support for parsing and rendering math in Markdown. It works well with `mdast-util-math` but can also be used independently to handle math content in Markdown documents. Compared to `mdast-util-math`, `remark-math` focuses more on integrating math parsing and rendering into the `remark` ecosystem.

rehype-katex

The `rehype-katex` package is a plugin for `rehype` that renders math using KaTeX. It is used to convert math content in HTML documents into beautifully rendered math expressions. While `mdast-util-math` focuses on parsing and serializing math in MDAST, `rehype-katex` is more about rendering math in HTML.

README

mdast-util-math

mdast extensions to parse and serialize math ($C_L$).

Contents

• What is this?
• When to use this
• Install
• Use
• API
  • mathFromMarkdown()
  • mathToMarkdown(options?)
  • InlineMath
  • Math
  • ToOptions
• HTML
• Syntax
• Syntax tree
  • Nodes
  • Content model
• Types
• Compatibility
• Related
• Contribute
• License

What is this?

This package contains two extensions that add support for math syntax in markdown to mdast. These extensions plug into mdast-util-from-markdown (to support parsing math in markdown into a syntax tree) and mdast-util-to-markdown (to support serializing math in syntax trees to markdown).

When to use this

This project is useful when you want to support math in markdown. Extending markdown with a syntax extension makes the markdown less portable. LaTeX equations are also quite hard. But this mechanism works well when you want authors, that have some LaTeX experience, to be able to embed rich diagrams of math in scientific text.

You can use these extensions when you are working with mdast-util-from-markdown and mdast-util-to-markdown already.

When working with mdast-util-from-markdown, you must combine this package with micromark-extension-math.

When you don’t need a syntax tree, you can use micromark directly with micromark-extension-math.

All these packages are used remark-math, which focusses on making it easier to transform content by abstracting these internals away.

This utility adds fields on nodes so that the utility responsible for turning mdast (markdown) nodes into hast (HTML) nodes, mdast-util-to-hast, turns text (inline) math nodes into <code class="language-math math-inline">…</code> and flow (block) math nodes into <pre><code class="language-math math-display">…</code></pre>.

Install

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

npm install mdast-util-math

In Deno with esm.sh:

import {mathFromMarkdown, mathToMarkdown} from 'https://esm.sh/mdast-util-math@3'

In browsers with esm.sh:

<script type="module">
  import {mathFromMarkdown, mathToMarkdown} from 'https://esm.sh/mdast-util-math@3?bundle'
</script>

Use

Say our document example.md contains:

Lift($L$) can be determined by Lift Coefficient ($C_L$) like the following
equation.

$$
L = \frac{1}{2} \rho v^2 S C_L
$$

…and our module example.js looks as follows:

import fs from 'node:fs/promises'
import {math} from 'micromark-extension-math'
import {fromMarkdown} from 'mdast-util-from-markdown'
import {mathFromMarkdown, mathToMarkdown} from 'mdast-util-math'
import {toMarkdown} from 'mdast-util-to-markdown'

const doc = await fs.readFile('example.md')

const tree = fromMarkdown(doc, {
  extensions: [math()],
  mdastExtensions: [mathFromMarkdown()]
})

console.log(tree)

const out = toMarkdown(tree, {extensions: [mathToMarkdown()]})

console.log(out)

…now running node example.js yields (positional info and data removed for brevity):

{
  type: 'root',
  children: [
    {
      type: 'paragraph',
      children: [
        {type: 'text', value: 'Lift('},
        {type: 'inlineMath', value: 'L', data: {/* … */}},
        {type: 'text', value: ') can be determined by Lift Coefficient ('},
        {type: 'inlineMath', value: 'C_L', data: {/* … */}},
        {type: 'text', value: ') like the following\nequation.'}
      ]
    },
    {type: 'math', meta: null, value: 'L = \\frac{1}{2} \\rho v^2 S C_L', data: {/* … */}}
  ]
}

Lift($L$) can be determined by Lift Coefficient ($C_L$) like the following
equation.

$$
L = \frac{1}{2} \rho v^2 S C_L
$$

API

This package exports the identifiers mathFromMarkdown and mathToMarkdown. There is no default export.

mathFromMarkdown()

Create an extension for mdast-util-from-markdown.

Returns

Extension for mdast-util-from-markdown (FromMarkdownExtension).

mathToMarkdown(options?)

Create an extension for mdast-util-to-markdown.

Parameters

• options (ToOptions, optional) — configuration

Returns

Extension for mdast-util-to-markdown (ToMarkdownExtension).

InlineMath

Math (text) (TypeScript type).

Type

import type {Data, Literal} from 'mdast'

interface InlineMath extends Literal {
  type: 'inlineMath'
  data?: InlineMathData | undefined
}

export interface InlineMathData extends Data {}

Math

Math (flow) (TypeScript type).

Type

import type {Data, Literal} from 'mdast'

interface Math extends Literal {
  type: 'math'
  meta?: string | null | undefined
  data?: MathData | undefined
}

export interface MathData extends Data {}

ToOptions

Configuration (TypeScript type).

Fields

• singleDollarTextMath (boolean, default: true) — whether to support math (text) with a single dollar. Single dollars work in Pandoc and many other places, but often interfere with “normal” dollars in text. If you turn this off, you can still use two or more dollars for text math

HTML

This plugin integrates with mdast-util-to-hast. When mdast is turned into hast the math nodes are turned into <code class="language-math math-inline">…</code> and <pre><code class="language-math math-display">…</code></pre> elements.

Syntax

See Syntax in micromark-extension-frontmatter.

Syntax tree

The following interfaces are added to mdast by this utility.

Nodes

Math

interface Math <: Literal {
  type: 'code'
  meta: string?
}

Math (Literal) represents a block of math, such as LaTeX mathematical expressions.

Math can be used where flow content is expected. Its content is represented by its value field.

This node relates to the phrasing content concept InlineMath.

A meta field can be present. It represents custom information relating to the node.

For example, the following markdown:

$$
L = \frac{1}{2} \rho v^2 S C_L
$$

Yields:

{
  type: 'math',
  meta: null,
  value: 'L = \\frac{1}{2} \\rho v^2 S C_L',
  data: {/* … */}
}

InlineMath

interface InlineMath <: Literal {
  type: 'inlineMath'
}

InlineMath (Literal) represents a fragment of computer code, such as a file name, computer program, or anything a computer could parse.

InlineMath can be used where phrasing content is expected. Its content is represented by its value field.

This node relates to the flow content concept Math.

For example, the following markdown:

$L$

Yields:

{type: 'inlineMath', value: 'L', data: {/* … */}}

Content model

FlowContent (math)

type FlowContentMath = Math | FlowContent

PhrasingContent (math)

type PhrasingContentMath = InlineMath | PhrasingContent

Types

This package is fully typed with TypeScript. It exports the additional types InlineMath, Math, and ToOptions.

It also registers the node types with @types/mdast. If you’re working with the syntax tree, make sure to import this utility somewhere in your types, as that registers the new node types in the tree.

/**
 * @typedef {import('mdast-util-math')}
 */

import {visit} from 'unist-util-visit'

/** @type {import('mdast').Root} */
const tree = getMdastNodeSomeHow()

visit(tree, function (node) {
  // `node` can now be one of the nodes for math.
})

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, mdast-util-math@^3, compatible with Node.js 16.

This plugin works with mdast-util-from-markdown version 2+ and mdast-util-to-markdown version 2+.

Related

• remark-math — remark plugin to support math
• micromark-extension-math — micromark extension to parse math

Contribute

See contributing.md in syntax-tree/.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