feat: use go tool
This commit is contained in:
+61
@@ -0,0 +1,61 @@
|
||||
import type {KatexOptions} from 'katex'
|
||||
|
||||
export {mathHtml} from './lib/html.js'
|
||||
export {math} from './lib/syntax.js'
|
||||
|
||||
/**
|
||||
* Configuration for HTML output.
|
||||
*
|
||||
* > 👉 **Note**: passed to `katex.renderToString`.
|
||||
* > `displayMode` is overwritten by this plugin, to `false` for math in
|
||||
* > text (inline), and `true` for math in flow (block).
|
||||
*/
|
||||
export interface HtmlOptions extends KatexOptions {
|
||||
/**
|
||||
* The field `displayMode` cannot be passed to `micromark-extension-math`.
|
||||
* It is overwritten by it,
|
||||
* to `false` for math in text (inline) and `true` for math in flow (block).
|
||||
*/
|
||||
displayMode?: never
|
||||
}
|
||||
|
||||
/**
|
||||
* Configuration.
|
||||
*/
|
||||
export interface Options {
|
||||
/**
|
||||
* Whether to support math (text) with a single dollar (default: `true`).
|
||||
*
|
||||
* Single dollars work in Pandoc and many other places, but often interfere
|
||||
* with “normal” dollars in text.
|
||||
* If you turn this off, you can use two or more dollars for text math.
|
||||
*/
|
||||
singleDollarTextMath?: boolean | null | undefined
|
||||
}
|
||||
|
||||
/**
|
||||
* Augment types.
|
||||
*/
|
||||
declare module 'micromark-util-types' {
|
||||
/**
|
||||
* Compile data.
|
||||
*/
|
||||
interface CompileData {
|
||||
mathFlowOpen?: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* Token types.
|
||||
*/
|
||||
interface TokenTypeMap {
|
||||
mathFlow: 'mathFlow'
|
||||
mathFlowFence: 'mathFlowFence'
|
||||
mathFlowFenceMeta: 'mathFlowFenceMeta'
|
||||
mathFlowFenceSequence: 'mathFlowFenceSequence'
|
||||
mathFlowValue: 'mathFlowValue'
|
||||
mathText: 'mathText'
|
||||
mathTextData: 'mathTextData'
|
||||
mathTextPadding: 'mathTextPadding'
|
||||
mathTextSequence: 'mathTextSequence'
|
||||
}
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
// Note: types exported from `index.d.ts`.
|
||||
export {math} from './lib/syntax.js'
|
||||
export {mathHtml} from './lib/html.js'
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
/**
|
||||
* Create an extension for `micromark` to support math when serializing to
|
||||
* HTML.
|
||||
*
|
||||
* > 👉 **Note**: this uses KaTeX to render math.
|
||||
*
|
||||
* @param {Options | null | undefined} [options={}]
|
||||
* Configuration (default: `{}`).
|
||||
* @returns {HtmlExtension}
|
||||
* Extension for `micromark` that can be passed in `htmlExtensions`, to
|
||||
* support math when serializing to HTML.
|
||||
*/
|
||||
export function mathHtml(options?: Options | null | undefined): HtmlExtension;
|
||||
import type { HtmlOptions as Options } from 'micromark-extension-math';
|
||||
import type { HtmlExtension } from 'micromark-util-types';
|
||||
+82
@@ -0,0 +1,82 @@
|
||||
/**
|
||||
* @import {HtmlOptions as Options} from 'micromark-extension-math'
|
||||
* @import {HtmlExtension} from 'micromark-util-types'
|
||||
*/
|
||||
|
||||
import katex from 'katex'
|
||||
|
||||
const renderToString = katex.renderToString
|
||||
|
||||
/**
|
||||
* Create an extension for `micromark` to support math when serializing to
|
||||
* HTML.
|
||||
*
|
||||
* > 👉 **Note**: this uses KaTeX to render math.
|
||||
*
|
||||
* @param {Options | null | undefined} [options={}]
|
||||
* Configuration (default: `{}`).
|
||||
* @returns {HtmlExtension}
|
||||
* Extension for `micromark` that can be passed in `htmlExtensions`, to
|
||||
* support math when serializing to HTML.
|
||||
*/
|
||||
export function mathHtml(options) {
|
||||
return {
|
||||
enter: {
|
||||
mathFlow() {
|
||||
this.lineEndingIfNeeded()
|
||||
this.tag('<div class="math math-display">')
|
||||
},
|
||||
mathFlowFenceMeta() {
|
||||
this.buffer()
|
||||
},
|
||||
mathText() {
|
||||
// Double?
|
||||
this.tag('<span class="math math-inline">')
|
||||
this.buffer()
|
||||
}
|
||||
},
|
||||
exit: {
|
||||
mathFlow() {
|
||||
const value = this.resume()
|
||||
this.tag(math(value.replace(/(?:\r?\n|\r)$/, ''), true))
|
||||
this.tag('</div>')
|
||||
this.setData('mathFlowOpen')
|
||||
this.setData('slurpOneLineEnding')
|
||||
},
|
||||
mathFlowFence() {
|
||||
// After the first fence.
|
||||
if (!this.getData('mathFlowOpen')) {
|
||||
this.setData('mathFlowOpen', true)
|
||||
this.setData('slurpOneLineEnding', true)
|
||||
this.buffer()
|
||||
}
|
||||
},
|
||||
mathFlowFenceMeta() {
|
||||
this.resume()
|
||||
},
|
||||
mathFlowValue(token) {
|
||||
this.raw(this.sliceSerialize(token))
|
||||
},
|
||||
mathText() {
|
||||
const value = this.resume()
|
||||
this.tag(math(value, false))
|
||||
this.tag('</span>')
|
||||
},
|
||||
mathTextData(token) {
|
||||
this.raw(this.sliceSerialize(token))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {string} value
|
||||
* Math text.
|
||||
* @param {boolean} displayMode
|
||||
* Whether the math is in display mode.
|
||||
* @returns {string}
|
||||
* HTML.
|
||||
*/
|
||||
function math(value, displayMode) {
|
||||
return renderToString(value, {...options, displayMode})
|
||||
}
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
/** @type {Construct} */
|
||||
export const mathFlow: Construct;
|
||||
import type { Construct } from 'micromark-util-types';
|
||||
+394
@@ -0,0 +1,394 @@
|
||||
/**
|
||||
* @import {Construct, State, TokenizeContext, Tokenizer} from 'micromark-util-types'
|
||||
*/
|
||||
|
||||
import {ok as assert} from 'devlop'
|
||||
import {factorySpace} from 'micromark-factory-space'
|
||||
import {markdownLineEnding} from 'micromark-util-character'
|
||||
import {codes, constants, types} from 'micromark-util-symbol'
|
||||
|
||||
/** @type {Construct} */
|
||||
export const mathFlow = {
|
||||
tokenize: tokenizeMathFenced,
|
||||
concrete: true,
|
||||
name: 'mathFlow'
|
||||
}
|
||||
|
||||
/** @type {Construct} */
|
||||
const nonLazyContinuation = {
|
||||
tokenize: tokenizeNonLazyContinuation,
|
||||
partial: true
|
||||
}
|
||||
|
||||
/**
|
||||
* @this {TokenizeContext}
|
||||
* @type {Tokenizer}
|
||||
*/
|
||||
function tokenizeMathFenced(effects, ok, nok) {
|
||||
const self = this
|
||||
const tail = self.events[self.events.length - 1]
|
||||
const initialSize =
|
||||
tail && tail[1].type === types.linePrefix
|
||||
? tail[2].sliceSerialize(tail[1], true).length
|
||||
: 0
|
||||
let sizeOpen = 0
|
||||
|
||||
return start
|
||||
|
||||
/**
|
||||
* Start of math.
|
||||
*
|
||||
* ```markdown
|
||||
* > | $$
|
||||
* ^
|
||||
* | \frac{1}{2}
|
||||
* | $$
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function start(code) {
|
||||
assert(code === codes.dollarSign, 'expected `$`')
|
||||
effects.enter('mathFlow')
|
||||
effects.enter('mathFlowFence')
|
||||
effects.enter('mathFlowFenceSequence')
|
||||
return sequenceOpen(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* In opening fence sequence.
|
||||
*
|
||||
* ```markdown
|
||||
* > | $$
|
||||
* ^
|
||||
* | \frac{1}{2}
|
||||
* | $$
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function sequenceOpen(code) {
|
||||
if (code === codes.dollarSign) {
|
||||
effects.consume(code)
|
||||
sizeOpen++
|
||||
return sequenceOpen
|
||||
}
|
||||
|
||||
if (sizeOpen < 2) {
|
||||
return nok(code)
|
||||
}
|
||||
|
||||
effects.exit('mathFlowFenceSequence')
|
||||
return factorySpace(effects, metaBefore, types.whitespace)(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* In opening fence, before meta.
|
||||
*
|
||||
* ```markdown
|
||||
* > | $$asciimath
|
||||
* ^
|
||||
* | x < y
|
||||
* | $$
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
|
||||
function metaBefore(code) {
|
||||
if (code === codes.eof || markdownLineEnding(code)) {
|
||||
return metaAfter(code)
|
||||
}
|
||||
|
||||
effects.enter('mathFlowFenceMeta')
|
||||
effects.enter(types.chunkString, {contentType: constants.contentTypeString})
|
||||
return meta(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* In meta.
|
||||
*
|
||||
* ```markdown
|
||||
* > | $$asciimath
|
||||
* ^
|
||||
* | x < y
|
||||
* | $$
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function meta(code) {
|
||||
if (code === codes.eof || markdownLineEnding(code)) {
|
||||
effects.exit(types.chunkString)
|
||||
effects.exit('mathFlowFenceMeta')
|
||||
return metaAfter(code)
|
||||
}
|
||||
|
||||
if (code === codes.dollarSign) {
|
||||
return nok(code)
|
||||
}
|
||||
|
||||
effects.consume(code)
|
||||
return meta
|
||||
}
|
||||
|
||||
/**
|
||||
* After meta.
|
||||
*
|
||||
* ```markdown
|
||||
* > | $$
|
||||
* ^
|
||||
* | \frac{1}{2}
|
||||
* | $$
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function metaAfter(code) {
|
||||
// Guaranteed to be eol/eof.
|
||||
effects.exit('mathFlowFence')
|
||||
|
||||
if (self.interrupt) {
|
||||
return ok(code)
|
||||
}
|
||||
|
||||
return effects.attempt(
|
||||
nonLazyContinuation,
|
||||
beforeNonLazyContinuation,
|
||||
after
|
||||
)(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* After eol/eof in math, at a non-lazy closing fence or content.
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* > | \frac{1}{2}
|
||||
* ^
|
||||
* > | $$
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function beforeNonLazyContinuation(code) {
|
||||
return effects.attempt(
|
||||
{tokenize: tokenizeClosingFence, partial: true},
|
||||
after,
|
||||
contentStart
|
||||
)(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* Before math content, definitely not before a closing fence.
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* > | \frac{1}{2}
|
||||
* ^
|
||||
* | $$
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function contentStart(code) {
|
||||
return (
|
||||
initialSize
|
||||
? factorySpace(
|
||||
effects,
|
||||
beforeContentChunk,
|
||||
types.linePrefix,
|
||||
initialSize + 1
|
||||
)
|
||||
: beforeContentChunk
|
||||
)(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* Before math content, after optional prefix.
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* > | \frac{1}{2}
|
||||
* ^
|
||||
* | $$
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function beforeContentChunk(code) {
|
||||
if (code === codes.eof) {
|
||||
return after(code)
|
||||
}
|
||||
|
||||
if (markdownLineEnding(code)) {
|
||||
return effects.attempt(
|
||||
nonLazyContinuation,
|
||||
beforeNonLazyContinuation,
|
||||
after
|
||||
)(code)
|
||||
}
|
||||
|
||||
effects.enter('mathFlowValue')
|
||||
return contentChunk(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* In math content.
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* > | \frac{1}{2}
|
||||
* ^
|
||||
* | $$
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function contentChunk(code) {
|
||||
if (code === codes.eof || markdownLineEnding(code)) {
|
||||
effects.exit('mathFlowValue')
|
||||
return beforeContentChunk(code)
|
||||
}
|
||||
|
||||
effects.consume(code)
|
||||
return contentChunk
|
||||
}
|
||||
|
||||
/**
|
||||
* After math (ha!).
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* | \frac{1}{2}
|
||||
* > | $$
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function after(code) {
|
||||
effects.exit('mathFlow')
|
||||
return ok(code)
|
||||
}
|
||||
|
||||
/** @type {Tokenizer} */
|
||||
function tokenizeClosingFence(effects, ok, nok) {
|
||||
let size = 0
|
||||
|
||||
assert(self.parser.constructs.disable.null, 'expected `disable.null`')
|
||||
/**
|
||||
* Before closing fence, at optional whitespace.
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* | \frac{1}{2}
|
||||
* > | $$
|
||||
* ^
|
||||
* ```
|
||||
*/
|
||||
return factorySpace(
|
||||
effects,
|
||||
beforeSequenceClose,
|
||||
types.linePrefix,
|
||||
self.parser.constructs.disable.null.includes('codeIndented')
|
||||
? undefined
|
||||
: constants.tabSize
|
||||
)
|
||||
|
||||
/**
|
||||
* In closing fence, after optional whitespace, at sequence.
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* | \frac{1}{2}
|
||||
* > | $$
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function beforeSequenceClose(code) {
|
||||
effects.enter('mathFlowFence')
|
||||
effects.enter('mathFlowFenceSequence')
|
||||
return sequenceClose(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* In closing fence sequence.
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* | \frac{1}{2}
|
||||
* > | $$
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function sequenceClose(code) {
|
||||
if (code === codes.dollarSign) {
|
||||
size++
|
||||
effects.consume(code)
|
||||
return sequenceClose
|
||||
}
|
||||
|
||||
if (size < sizeOpen) {
|
||||
return nok(code)
|
||||
}
|
||||
|
||||
effects.exit('mathFlowFenceSequence')
|
||||
return factorySpace(effects, afterSequenceClose, types.whitespace)(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* After closing fence sequence, after optional whitespace.
|
||||
*
|
||||
* ```markdown
|
||||
* | $$
|
||||
* | \frac{1}{2}
|
||||
* > | $$
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function afterSequenceClose(code) {
|
||||
if (code === codes.eof || markdownLineEnding(code)) {
|
||||
effects.exit('mathFlowFence')
|
||||
return ok(code)
|
||||
}
|
||||
|
||||
return nok(code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @this {TokenizeContext}
|
||||
* @type {Tokenizer}
|
||||
*/
|
||||
function tokenizeNonLazyContinuation(effects, ok, nok) {
|
||||
const self = this
|
||||
|
||||
return start
|
||||
|
||||
/** @type {State} */
|
||||
function start(code) {
|
||||
if (code === null) {
|
||||
return ok(code)
|
||||
}
|
||||
|
||||
assert(markdownLineEnding(code), 'expected eol')
|
||||
effects.enter(types.lineEnding)
|
||||
effects.consume(code)
|
||||
effects.exit(types.lineEnding)
|
||||
return lineStart
|
||||
}
|
||||
|
||||
/** @type {State} */
|
||||
function lineStart(code) {
|
||||
return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
|
||||
}
|
||||
}
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
/**
|
||||
* @param {Options | null | undefined} [options={}]
|
||||
* Configuration (default: `{}`).
|
||||
* @returns {Construct}
|
||||
* Construct.
|
||||
*/
|
||||
export function mathText(options?: Options | null | undefined): Construct;
|
||||
import type { Options } from 'micromark-extension-math';
|
||||
import type { Construct } from 'micromark-util-types';
|
||||
+267
@@ -0,0 +1,267 @@
|
||||
/**
|
||||
* @import {Options} from 'micromark-extension-math'
|
||||
* @import {Construct, Previous, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
|
||||
*/
|
||||
|
||||
// To do: next major: clean spaces in HTML compiler.
|
||||
// This has to be coordinated together with `mdast-util-math`.
|
||||
|
||||
import {ok as assert} from 'devlop'
|
||||
import {markdownLineEnding} from 'micromark-util-character'
|
||||
import {codes, types} from 'micromark-util-symbol'
|
||||
|
||||
/**
|
||||
* @param {Options | null | undefined} [options={}]
|
||||
* Configuration (default: `{}`).
|
||||
* @returns {Construct}
|
||||
* Construct.
|
||||
*/
|
||||
export function mathText(options) {
|
||||
const options_ = options || {}
|
||||
let single = options_.singleDollarTextMath
|
||||
|
||||
if (single === null || single === undefined) {
|
||||
single = true
|
||||
}
|
||||
|
||||
return {
|
||||
tokenize: tokenizeMathText,
|
||||
resolve: resolveMathText,
|
||||
previous,
|
||||
name: 'mathText'
|
||||
}
|
||||
|
||||
/**
|
||||
* @this {TokenizeContext}
|
||||
* @type {Tokenizer}
|
||||
*/
|
||||
function tokenizeMathText(effects, ok, nok) {
|
||||
const self = this
|
||||
let sizeOpen = 0
|
||||
/** @type {number} */
|
||||
let size
|
||||
/** @type {Token} */
|
||||
let token
|
||||
|
||||
return start
|
||||
|
||||
/**
|
||||
* Start of math (text).
|
||||
*
|
||||
* ```markdown
|
||||
* > | $a$
|
||||
* ^
|
||||
* > | \$a$
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function start(code) {
|
||||
assert(code === codes.dollarSign, 'expected `$`')
|
||||
assert(previous.call(self, self.previous), 'expected correct previous')
|
||||
effects.enter('mathText')
|
||||
effects.enter('mathTextSequence')
|
||||
return sequenceOpen(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* In opening sequence.
|
||||
*
|
||||
* ```markdown
|
||||
* > | $a$
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
|
||||
function sequenceOpen(code) {
|
||||
if (code === codes.dollarSign) {
|
||||
effects.consume(code)
|
||||
sizeOpen++
|
||||
return sequenceOpen
|
||||
}
|
||||
|
||||
// Not enough markers in the sequence.
|
||||
if (sizeOpen < 2 && !single) {
|
||||
return nok(code)
|
||||
}
|
||||
|
||||
effects.exit('mathTextSequence')
|
||||
return between(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* Between something and something else.
|
||||
*
|
||||
* ```markdown
|
||||
* > | $a$
|
||||
* ^^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function between(code) {
|
||||
if (code === codes.eof) {
|
||||
return nok(code)
|
||||
}
|
||||
|
||||
if (code === codes.dollarSign) {
|
||||
token = effects.enter('mathTextSequence')
|
||||
size = 0
|
||||
return sequenceClose(code)
|
||||
}
|
||||
|
||||
// Tabs don’t work, and virtual spaces don’t make sense.
|
||||
if (code === codes.space) {
|
||||
effects.enter('space')
|
||||
effects.consume(code)
|
||||
effects.exit('space')
|
||||
return between
|
||||
}
|
||||
|
||||
if (markdownLineEnding(code)) {
|
||||
effects.enter(types.lineEnding)
|
||||
effects.consume(code)
|
||||
effects.exit(types.lineEnding)
|
||||
return between
|
||||
}
|
||||
|
||||
// Data.
|
||||
effects.enter('mathTextData')
|
||||
return data(code)
|
||||
}
|
||||
|
||||
/**
|
||||
* In data.
|
||||
*
|
||||
* ```markdown
|
||||
* > | $a$
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
function data(code) {
|
||||
if (
|
||||
code === codes.eof ||
|
||||
code === codes.space ||
|
||||
code === codes.dollarSign ||
|
||||
markdownLineEnding(code)
|
||||
) {
|
||||
effects.exit('mathTextData')
|
||||
return between(code)
|
||||
}
|
||||
|
||||
effects.consume(code)
|
||||
return data
|
||||
}
|
||||
|
||||
/**
|
||||
* In closing sequence.
|
||||
*
|
||||
* ```markdown
|
||||
* > | `a`
|
||||
* ^
|
||||
* ```
|
||||
*
|
||||
* @type {State}
|
||||
*/
|
||||
|
||||
function sequenceClose(code) {
|
||||
// More.
|
||||
if (code === codes.dollarSign) {
|
||||
effects.consume(code)
|
||||
size++
|
||||
return sequenceClose
|
||||
}
|
||||
|
||||
// Done!
|
||||
if (size === sizeOpen) {
|
||||
effects.exit('mathTextSequence')
|
||||
effects.exit('mathText')
|
||||
return ok(code)
|
||||
}
|
||||
|
||||
// More or less accents: mark as data.
|
||||
token.type = 'mathTextData'
|
||||
return data(code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** @type {Resolver} */
|
||||
function resolveMathText(events) {
|
||||
let tailExitIndex = events.length - 4
|
||||
let headEnterIndex = 3
|
||||
/** @type {number} */
|
||||
let index
|
||||
/** @type {number | undefined} */
|
||||
let enter
|
||||
|
||||
// If we start and end with an EOL or a space.
|
||||
if (
|
||||
(events[headEnterIndex][1].type === types.lineEnding ||
|
||||
events[headEnterIndex][1].type === 'space') &&
|
||||
(events[tailExitIndex][1].type === types.lineEnding ||
|
||||
events[tailExitIndex][1].type === 'space')
|
||||
) {
|
||||
index = headEnterIndex
|
||||
|
||||
// And we have data.
|
||||
while (++index < tailExitIndex) {
|
||||
if (events[index][1].type === 'mathTextData') {
|
||||
// Then we have padding.
|
||||
events[tailExitIndex][1].type = 'mathTextPadding'
|
||||
events[headEnterIndex][1].type = 'mathTextPadding'
|
||||
headEnterIndex += 2
|
||||
tailExitIndex -= 2
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Merge adjacent spaces and data.
|
||||
index = headEnterIndex - 1
|
||||
tailExitIndex++
|
||||
|
||||
while (++index <= tailExitIndex) {
|
||||
if (enter === undefined) {
|
||||
if (
|
||||
index !== tailExitIndex &&
|
||||
events[index][1].type !== types.lineEnding
|
||||
) {
|
||||
enter = index
|
||||
}
|
||||
} else if (
|
||||
index === tailExitIndex ||
|
||||
events[index][1].type === types.lineEnding
|
||||
) {
|
||||
events[enter][1].type = 'mathTextData'
|
||||
|
||||
if (index !== enter + 2) {
|
||||
events[enter][1].end = events[index - 1][1].end
|
||||
events.splice(enter + 2, index - enter - 2)
|
||||
tailExitIndex -= index - enter - 2
|
||||
index = enter + 2
|
||||
}
|
||||
|
||||
enter = undefined
|
||||
}
|
||||
}
|
||||
|
||||
return events
|
||||
}
|
||||
|
||||
/**
|
||||
* @this {TokenizeContext}
|
||||
* @type {Previous}
|
||||
*/
|
||||
function previous(code) {
|
||||
// If there is a previous code, there will always be a tail.
|
||||
return (
|
||||
code !== codes.dollarSign ||
|
||||
this.events[this.events.length - 1][1].type === types.characterEscape
|
||||
)
|
||||
}
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
/**
|
||||
* Create an extension for `micromark` to enable math syntax.
|
||||
*
|
||||
* @param {Options | null | undefined} [options={}]
|
||||
* Configuration (default: `{}`).
|
||||
* @returns {Extension}
|
||||
* Extension for `micromark` that can be passed in `extensions`, to
|
||||
* enable math syntax.
|
||||
*/
|
||||
export function math(options?: Options | null | undefined): Extension;
|
||||
import type { Options } from 'micromark-extension-math';
|
||||
import type { Extension } from 'micromark-util-types';
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
/**
|
||||
* @import {Options} from 'micromark-extension-math'
|
||||
* @import {Extension} from 'micromark-util-types'
|
||||
*/
|
||||
|
||||
import {codes} from 'micromark-util-symbol'
|
||||
import {mathFlow} from './math-flow.js'
|
||||
import {mathText} from './math-text.js'
|
||||
|
||||
/**
|
||||
* Create an extension for `micromark` to enable math syntax.
|
||||
*
|
||||
* @param {Options | null | undefined} [options={}]
|
||||
* Configuration (default: `{}`).
|
||||
* @returns {Extension}
|
||||
* Extension for `micromark` that can be passed in `extensions`, to
|
||||
* enable math syntax.
|
||||
*/
|
||||
export function math(options) {
|
||||
return {
|
||||
flow: {[codes.dollarSign]: mathFlow},
|
||||
text: {[codes.dollarSign]: mathText(options)}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user