Compare 5313419 ... +78 ... 63a5f76

/**

 * @typedef {import('hast').Root} Root

 * @typedef {import('hast').Element} Element

 *

 * @typedef {[string, string]} MathNotation

 *   Markers to use for math.

 *   See: <http://docs.mathjax.org/en/latest/options/input/tex.html#the-configuration-block>

 *

 * @typedef OutputSvgOptions

 *   <http://docs.mathjax.org/en/latest/options/output/svg.html#the-configuration-block>

 * @property {number} [scale]

 * @property {number} [minScale]

 * @property {boolean} [mtextInheritFont]

 * @property {boolean} [merrorInheritFont]

 * @property {boolean} [mathmlSpacing]

 * @property {Record<string, boolean>} [skipAttributes]

 * @property {number} [exFactor]

 * @property {'left'|'center'|'right'} [displayAlign]

 * @property {string} [displayIndent]

 * @property {'local'|'global'} [fontCache]

 * @property {string|null} [localID]

 * @property {boolean} [internalSpeechTitles]

 * @property {number} [titleID]

 *

 * @typedef OutputCHtmlOptions

 *   <http://docs.mathjax.org/en/latest/options/output/chtml.html#the-configuration-block>

 * @property {number} [scale]

 * @property {number} [minScale]

 * @property {boolean} [matchFontHeight]

 * @property {boolean} [mtextInheritFont]

 * @property {boolean} [merrorInheritFont]

 * @property {boolean} [mathmlSpacing]

 * @property {Record<string, boolean>} [skipAttributes]

 * @property {number} [exFactor]

 * @property {'left'|'center'|'right'} [displayAlign]

 * @property {string} [displayIndent]

 * @property {string} fontURL

 * @property {boolean} [adaptiveCSS]

 *

 * @typedef InputTexOptions

 *   <http://docs.mathjax.org/en/latest/options/input/tex.html#the-configuration-block>

 * @property {string[]} [packages]

 * @property {MathNotation[]} [inlineMath]

 * @property {MathNotation[]} [displayMath]

 * @property {boolean} [processEscapes]

 * @property {boolean} [processEnvironments]

 * @property {boolean} [processRefs]

 * @property {RegExp} [digits]

 * @property {'none'|'ams'|'all'} [tags]

 * @property {'left'|'right'} [tagSide]

 * @property {string} [tagIndent]

 * @property {boolean} [useLabelIds]

 * @property {string} [multlineWidth]

 * @property {number} [maxMacros]

 * @property {number} [maxBuffer]

 * @property {string} [baseURL]

 * @property {(jax: any, error: any) => string} [formatError]

 *

 * @typedef Options

 *   Configuration.

 * @property {InputTexOptions} [tex]

 *   Configuration for the input TeX.

 * @property {OutputCHtmlOptions} [chtml]

 *   Configuration for the output (when CHTML).

 * @property {OutputSvgOptions} [svg]

 *   Configuration for the output (when SVG).

 *

 * @typedef Renderer

 * @property {(node: Element, options: {display: boolean}) => void} render

 * @property {() => Element} [styleSheet]

 *

 * @callback CreateRenderer

 * @param {Options} options

 * @returns {Renderer}

 */

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

/**

 * @param {CreateRenderer} createRenderer

 */

export function createPlugin(createRenderer) {

  /** @type {import('unified').Plugin<[Options?]|void[], Root>} */

  return (options = {}) =>

    (tree) => {

      const renderer = createRenderer(options)

      let found = false

      /** @type {Root|Element} */

      let context = tree

      visit(tree, 'element', (node) => {

        const classes =

          node.properties && Array.isArray(node.properties.className)

            ? node.properties.className

            : []

        const inline = classes.includes('math-inline')

        const display = classes.includes('math-display')

        if (node.tagName === 'head') {

          context = node

        }

        if (!inline && !display) {

          return

        }

        found = true

        renderer.render(node, {display})

        return SKIP

      })

      if (found && renderer.styleSheet) {

        context.children.push(renderer.styleSheet())

      }

    }

}

/**

 * @typedef {import('mdast').Root} Root

 * @typedef {import('mdast-util-math').ToOptions} Options

 *

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

 */

import {math} from 'micromark-extension-math'

import {mathFromMarkdown, mathToMarkdown} from 'mdast-util-math'

/**

 * Plugin to support math.

 *

 * @type {import('unified').Plugin<[Options?] | void[], Root, Root>}

 */

export default function remarkMath(options = {}) {

  const data = this.data()

  add('micromarkExtensions', math(options))

  add('fromMarkdownExtensions', mathFromMarkdown())

  add('toMarkdownExtensions', mathToMarkdown(options))

  /**

   * @param {string} field

   * @param {unknown} value

   */

  function add(field, value) {

    const list = /** @type {unknown[]} */ (

      // Other extensions

      /* c8 ignore next 2 */

      data[field] ? data[field] : (data[field] = [])

    )

    list.push(value)

  }

/**

 * @typedef {import('hast').Element} Element

 * @typedef {import('mathjax-full/js/core/OutputJax').OutputJax<HTMLElement, Text, Document>} OutputJax

 * @typedef {import('mathjax-full/js/core/MathDocument.js').MathDocument<HTMLElement, Text, Document>} MathDocument

 * @typedef {import('mathjax-full/js/input/tex.js').TeX<HTMLElement, Text, Document>} TeX_

 * @typedef {import('./create-plugin.js').Options} Options

 * @typedef {import('./create-plugin.js').Renderer} Renderer

 */

import {mathjax} from 'mathjax-full/js/mathjax.js'

import {RegisterHTMLHandler} from 'mathjax-full/js/handlers/html.js'

import {TeX} from 'mathjax-full/js/input/tex.js'

import {AllPackages} from 'mathjax-full/js/input/tex/AllPackages.js'

import {fromDom} from 'hast-util-from-dom'

import {toText} from 'hast-util-to-text'

import {createAdaptor} from './create-adaptor.js'

const adaptor = createAdaptor()

// To do next major: Keep resultant HTML handler from `register(adaptor)` to

// allow registering the `AssistiveMmlHandler` as in this demo:

// <https://github.com/mathjax/MathJax-demos-node/tree/master/direct>

//

// To do next major: If registering `AssistiveMmlHandler` is supported through

// configuration, move HTML handler registration to beginning of transformer and

// unregister at the end of transformer with

// `mathjax.handlers.unregister(handler)`.

// That is to prevent memory leak in `mathjax.handlers` whenever a new instance

// of the plugin is used.

/* eslint-disable-next-line new-cap */

RegisterHTMLHandler(adaptor)

/**

 * @param {Options} options

 * @param {OutputJax} output

 * @returns {Renderer}

 */

export function createRenderer(options, output) {

  const input = new TeX(Object.assign({packages: AllPackages}, options.tex))

  /** @type {MathDocument} */

  const doc = mathjax.document('', {InputJax: input, OutputJax: output})

  return {

    render(node, options) {

      const domNode = fromDom(

        // @ts-expect-error: assume mathml nodes can be handled by

        // `hast-util-from-dom`.

        doc.convert(toText(node, {whitespace: 'pre'}), options)

      )

      // @ts-expect-error: `fromDom` returns an element for a given element.

      node.children = [domNode]

    },

    styleSheet() {

      const value = adaptor.textContent(output.styleSheet(doc))

      return {

        type: 'element',

        tagName: 'style',

        properties: {},

        children: [{type: 'text', value}]

      }

    }

  }

}

import {JSDOM} from 'jsdom'

import {jsdomAdaptor} from 'mathjax-full/js/adaptors/jsdomAdaptor.js'

export function createAdaptor() {

  return jsdomAdaptor(JSDOM)

}

/**

 * @typedef {import('./lib/create-plugin.js').Options} Options

 */

import {SVG} from 'mathjax-full/js/output/svg.js'

import {createRenderer} from './lib/create-renderer.js'

import {createPlugin} from './lib/create-plugin.js'

const rehypeMathJaxSvg = createPlugin((options) =>

  createRenderer(options, new SVG(options.svg))

)

export default rehypeMathJaxSvg