10690 lines
245 KiB
JavaScript
10690 lines
245 KiB
JavaScript
"use strict";
|
||
(self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] = self["webpackChunk_JUPYTERLAB_CORE_OUTPUT"] || []).push([[4780],{
|
||
|
||
/***/ 14780:
|
||
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
|
||
|
||
|
||
// EXPORTS
|
||
__webpack_require__.d(__webpack_exports__, {
|
||
a: () => (/* binding */ createText),
|
||
c: () => (/* binding */ computeDimensionOfText)
|
||
});
|
||
|
||
// NAMESPACE OBJECT: ../node_modules/micromark/lib/constructs.js
|
||
var constructs_namespaceObject = {};
|
||
__webpack_require__.r(constructs_namespaceObject);
|
||
__webpack_require__.d(constructs_namespaceObject, {
|
||
attentionMarkers: () => (attentionMarkers),
|
||
contentInitial: () => (contentInitial),
|
||
disable: () => (disable),
|
||
document: () => (constructs_document),
|
||
flow: () => (constructs_flow),
|
||
flowInitial: () => (flowInitial),
|
||
insideSpan: () => (insideSpan),
|
||
string: () => (constructs_string),
|
||
text: () => (constructs_text)
|
||
});
|
||
|
||
// EXTERNAL MODULE: ../node_modules/mermaid/dist/mermaid-04fb0060.js + 8 modules
|
||
var mermaid_04fb0060 = __webpack_require__(24028);
|
||
;// CONCATENATED MODULE: ../node_modules/mdast-util-to-string/lib/index.js
|
||
/**
|
||
* @typedef {import('mdast').Root|import('mdast').Content} Node
|
||
*
|
||
* @typedef Options
|
||
* Configuration (optional).
|
||
* @property {boolean | null | undefined} [includeImageAlt=true]
|
||
* Whether to use `alt` for `image`s.
|
||
* @property {boolean | null | undefined} [includeHtml=true]
|
||
* Whether to use `value` of HTML.
|
||
*/
|
||
|
||
/** @type {Options} */
|
||
const emptyOptions = {}
|
||
|
||
/**
|
||
* Get the text content of a node or list of nodes.
|
||
*
|
||
* Prefers the node’s plain-text fields, otherwise serializes its children,
|
||
* and if the given value is an array, serialize the nodes in it.
|
||
*
|
||
* @param {unknown} value
|
||
* Thing to serialize, typically `Node`.
|
||
* @param {Options | null | undefined} [options]
|
||
* Configuration (optional).
|
||
* @returns {string}
|
||
* Serialized `value`.
|
||
*/
|
||
function lib_toString(value, options) {
|
||
const settings = options || emptyOptions
|
||
const includeImageAlt =
|
||
typeof settings.includeImageAlt === 'boolean'
|
||
? settings.includeImageAlt
|
||
: true
|
||
const includeHtml =
|
||
typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true
|
||
|
||
return one(value, includeImageAlt, includeHtml)
|
||
}
|
||
|
||
/**
|
||
* One node or several nodes.
|
||
*
|
||
* @param {unknown} value
|
||
* Thing to serialize.
|
||
* @param {boolean} includeImageAlt
|
||
* Include image `alt`s.
|
||
* @param {boolean} includeHtml
|
||
* Include HTML.
|
||
* @returns {string}
|
||
* Serialized node.
|
||
*/
|
||
function one(value, includeImageAlt, includeHtml) {
|
||
if (node(value)) {
|
||
if ('value' in value) {
|
||
return value.type === 'html' && !includeHtml ? '' : value.value
|
||
}
|
||
|
||
if (includeImageAlt && 'alt' in value && value.alt) {
|
||
return value.alt
|
||
}
|
||
|
||
if ('children' in value) {
|
||
return lib_all(value.children, includeImageAlt, includeHtml)
|
||
}
|
||
}
|
||
|
||
if (Array.isArray(value)) {
|
||
return lib_all(value, includeImageAlt, includeHtml)
|
||
}
|
||
|
||
return ''
|
||
}
|
||
|
||
/**
|
||
* Serialize a list of nodes.
|
||
*
|
||
* @param {Array<unknown>} values
|
||
* Thing to serialize.
|
||
* @param {boolean} includeImageAlt
|
||
* Include image `alt`s.
|
||
* @param {boolean} includeHtml
|
||
* Include HTML.
|
||
* @returns {string}
|
||
* Serialized nodes.
|
||
*/
|
||
function lib_all(values, includeImageAlt, includeHtml) {
|
||
/** @type {Array<string>} */
|
||
const result = []
|
||
let index = -1
|
||
|
||
while (++index < values.length) {
|
||
result[index] = one(values[index], includeImageAlt, includeHtml)
|
||
}
|
||
|
||
return result.join('')
|
||
}
|
||
|
||
/**
|
||
* Check if `value` looks like a node.
|
||
*
|
||
* @param {unknown} value
|
||
* Thing.
|
||
* @returns {value is Node}
|
||
* Whether `value` is a node.
|
||
*/
|
||
function node(value) {
|
||
return Boolean(value && typeof value === 'object')
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-chunked/index.js
|
||
/**
|
||
* Like `Array#splice`, but smarter for giant arrays.
|
||
*
|
||
* `Array#splice` takes all items to be inserted as individual argument which
|
||
* causes a stack overflow in V8 when trying to insert 100k items for instance.
|
||
*
|
||
* Otherwise, this does not return the removed items, and takes `items` as an
|
||
* array instead of rest parameters.
|
||
*
|
||
* @template {unknown} T
|
||
* Item type.
|
||
* @param {Array<T>} list
|
||
* List to operate on.
|
||
* @param {number} start
|
||
* Index to remove/insert at (can be negative).
|
||
* @param {number} remove
|
||
* Number of items to remove.
|
||
* @param {Array<T>} items
|
||
* Items to inject into `list`.
|
||
* @returns {void}
|
||
* Nothing.
|
||
*/
|
||
function splice(list, start, remove, items) {
|
||
const end = list.length
|
||
let chunkStart = 0
|
||
/** @type {Array<unknown>} */
|
||
let parameters
|
||
|
||
// Make start between zero and `end` (included).
|
||
if (start < 0) {
|
||
start = -start > end ? 0 : end + start
|
||
} else {
|
||
start = start > end ? end : start
|
||
}
|
||
remove = remove > 0 ? remove : 0
|
||
|
||
// No need to chunk the items if there’s only a couple (10k) items.
|
||
if (items.length < 10000) {
|
||
parameters = Array.from(items)
|
||
parameters.unshift(start, remove)
|
||
// @ts-expect-error Hush, it’s fine.
|
||
list.splice(...parameters)
|
||
} else {
|
||
// Delete `remove` items starting from `start`
|
||
if (remove) list.splice(start, remove)
|
||
|
||
// Insert the items in chunks to not cause stack overflows.
|
||
while (chunkStart < items.length) {
|
||
parameters = items.slice(chunkStart, chunkStart + 10000)
|
||
parameters.unshift(start, 0)
|
||
// @ts-expect-error Hush, it’s fine.
|
||
list.splice(...parameters)
|
||
chunkStart += 10000
|
||
start += 10000
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Append `items` (an array) at the end of `list` (another array).
|
||
* When `list` was empty, returns `items` instead.
|
||
*
|
||
* This prevents a potentially expensive operation when `list` is empty,
|
||
* and adds items in batches to prevent V8 from hanging.
|
||
*
|
||
* @template {unknown} T
|
||
* Item type.
|
||
* @param {Array<T>} list
|
||
* List to operate on.
|
||
* @param {Array<T>} items
|
||
* Items to add to `list`.
|
||
* @returns {Array<T>}
|
||
* Either `list` or `items`.
|
||
*/
|
||
function push(list, items) {
|
||
if (list.length > 0) {
|
||
splice(list, list.length, 0, items)
|
||
return list
|
||
}
|
||
return items
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-combine-extensions/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Extension} Extension
|
||
* @typedef {import('micromark-util-types').Handles} Handles
|
||
* @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
|
||
* @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension
|
||
*/
|
||
|
||
|
||
|
||
const micromark_util_combine_extensions_hasOwnProperty = {}.hasOwnProperty
|
||
|
||
/**
|
||
* Combine multiple syntax extensions into one.
|
||
*
|
||
* @param {Array<Extension>} extensions
|
||
* List of syntax extensions.
|
||
* @returns {NormalizedExtension}
|
||
* A single combined extension.
|
||
*/
|
||
function combineExtensions(extensions) {
|
||
/** @type {NormalizedExtension} */
|
||
const all = {}
|
||
let index = -1
|
||
|
||
while (++index < extensions.length) {
|
||
syntaxExtension(all, extensions[index])
|
||
}
|
||
|
||
return all
|
||
}
|
||
|
||
/**
|
||
* Merge `extension` into `all`.
|
||
*
|
||
* @param {NormalizedExtension} all
|
||
* Extension to merge into.
|
||
* @param {Extension} extension
|
||
* Extension to merge.
|
||
* @returns {void}
|
||
*/
|
||
function syntaxExtension(all, extension) {
|
||
/** @type {keyof Extension} */
|
||
let hook
|
||
|
||
for (hook in extension) {
|
||
const maybe = micromark_util_combine_extensions_hasOwnProperty.call(all, hook) ? all[hook] : undefined
|
||
/** @type {Record<string, unknown>} */
|
||
const left = maybe || (all[hook] = {})
|
||
/** @type {Record<string, unknown> | undefined} */
|
||
const right = extension[hook]
|
||
/** @type {string} */
|
||
let code
|
||
|
||
if (right) {
|
||
for (code in right) {
|
||
if (!micromark_util_combine_extensions_hasOwnProperty.call(left, code)) left[code] = []
|
||
const value = right[code]
|
||
constructs(
|
||
// @ts-expect-error Looks like a list.
|
||
left[code],
|
||
Array.isArray(value) ? value : value ? [value] : []
|
||
)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Merge `list` into `existing` (both lists of constructs).
|
||
* Mutates `existing`.
|
||
*
|
||
* @param {Array<unknown>} existing
|
||
* @param {Array<unknown>} list
|
||
* @returns {void}
|
||
*/
|
||
function constructs(existing, list) {
|
||
let index = -1
|
||
/** @type {Array<unknown>} */
|
||
const before = []
|
||
|
||
while (++index < list.length) {
|
||
// @ts-expect-error Looks like an object.
|
||
;(list[index].add === 'after' ? existing : before).push(list[index])
|
||
}
|
||
|
||
splice(existing, 0, 0, before)
|
||
}
|
||
|
||
/**
|
||
* Combine multiple HTML extensions into one.
|
||
*
|
||
* @param {Array<HtmlExtension>} htmlExtensions
|
||
* List of HTML extensions.
|
||
* @returns {HtmlExtension}
|
||
* A single combined HTML extension.
|
||
*/
|
||
function combineHtmlExtensions(htmlExtensions) {
|
||
/** @type {HtmlExtension} */
|
||
const handlers = {}
|
||
let index = -1
|
||
|
||
while (++index < htmlExtensions.length) {
|
||
htmlExtension(handlers, htmlExtensions[index])
|
||
}
|
||
|
||
return handlers
|
||
}
|
||
|
||
/**
|
||
* Merge `extension` into `all`.
|
||
*
|
||
* @param {HtmlExtension} all
|
||
* Extension to merge into.
|
||
* @param {HtmlExtension} extension
|
||
* Extension to merge.
|
||
* @returns {void}
|
||
*/
|
||
function htmlExtension(all, extension) {
|
||
/** @type {keyof HtmlExtension} */
|
||
let hook
|
||
|
||
for (hook in extension) {
|
||
const maybe = micromark_util_combine_extensions_hasOwnProperty.call(all, hook) ? all[hook] : undefined
|
||
const left = maybe || (all[hook] = {})
|
||
const right = extension[hook]
|
||
/** @type {keyof Handles} */
|
||
let type
|
||
|
||
if (right) {
|
||
for (type in right) {
|
||
// @ts-expect-error assume document vs regular handler are managed correctly.
|
||
left[type] = right[type]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-character/lib/unicode-punctuation-regex.js
|
||
// This module is generated by `script/`.
|
||
//
|
||
// CommonMark handles attention (emphasis, strong) markers based on what comes
|
||
// before or after them.
|
||
// One such difference is if those characters are Unicode punctuation.
|
||
// This script is generated from the Unicode data.
|
||
|
||
/**
|
||
* Regular expression that matches a unicode punctuation character.
|
||
*/
|
||
const unicodePunctuationRegex =
|
||
/[!-\/:-@\[-`\{-~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-character/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
*/
|
||
|
||
|
||
|
||
/**
|
||
* Check whether the character code represents an ASCII alpha (`a` through `z`,
|
||
* case insensitive).
|
||
*
|
||
* An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
|
||
*
|
||
* An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
|
||
* to U+005A (`Z`).
|
||
*
|
||
* An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
|
||
* to U+007A (`z`).
|
||
*
|
||
* @param code
|
||
* Code.
|
||
* @returns
|
||
* Whether it matches.
|
||
*/
|
||
const asciiAlpha = regexCheck(/[A-Za-z]/)
|
||
|
||
/**
|
||
* Check whether the character code represents an ASCII alphanumeric (`a`
|
||
* through `z`, case insensitive, or `0` through `9`).
|
||
*
|
||
* An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
|
||
* (see `asciiAlpha`).
|
||
*
|
||
* @param code
|
||
* Code.
|
||
* @returns
|
||
* Whether it matches.
|
||
*/
|
||
const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/)
|
||
|
||
/**
|
||
* Check whether the character code represents an ASCII atext.
|
||
*
|
||
* atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
|
||
* the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
|
||
* U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
|
||
* SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
|
||
* CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
|
||
* (`{`) to U+007E TILDE (`~`).
|
||
*
|
||
* See:
|
||
* **\[RFC5322]**:
|
||
* [Internet Message Format](https://tools.ietf.org/html/rfc5322).
|
||
* P. Resnick.
|
||
* IETF.
|
||
*
|
||
* @param code
|
||
* Code.
|
||
* @returns
|
||
* Whether it matches.
|
||
*/
|
||
const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/)
|
||
|
||
/**
|
||
* Check whether a character code is an ASCII control character.
|
||
*
|
||
* An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
|
||
* to U+001F (US), or U+007F (DEL).
|
||
*
|
||
* @param {Code} code
|
||
* Code.
|
||
* @returns {boolean}
|
||
* Whether it matches.
|
||
*/
|
||
function asciiControl(code) {
|
||
return (
|
||
// Special whitespace codes (which have negative values), C0 and Control
|
||
// character DEL
|
||
code !== null && (code < 32 || code === 127)
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Check whether the character code represents an ASCII digit (`0` through `9`).
|
||
*
|
||
* An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
|
||
* U+0039 (`9`).
|
||
*
|
||
* @param code
|
||
* Code.
|
||
* @returns
|
||
* Whether it matches.
|
||
*/
|
||
const asciiDigit = regexCheck(/\d/)
|
||
|
||
/**
|
||
* Check whether the character code represents an ASCII hex digit (`a` through
|
||
* `f`, case insensitive, or `0` through `9`).
|
||
*
|
||
* An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
|
||
* digit, or an ASCII lower hex digit.
|
||
*
|
||
* An **ASCII upper hex digit** is a character in the inclusive range U+0041
|
||
* (`A`) to U+0046 (`F`).
|
||
*
|
||
* An **ASCII lower hex digit** is a character in the inclusive range U+0061
|
||
* (`a`) to U+0066 (`f`).
|
||
*
|
||
* @param code
|
||
* Code.
|
||
* @returns
|
||
* Whether it matches.
|
||
*/
|
||
const asciiHexDigit = regexCheck(/[\dA-Fa-f]/)
|
||
|
||
/**
|
||
* Check whether the character code represents ASCII punctuation.
|
||
*
|
||
* An **ASCII punctuation** is a character in the inclusive ranges U+0021
|
||
* EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
|
||
* SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
|
||
* (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
|
||
*
|
||
* @param code
|
||
* Code.
|
||
* @returns
|
||
* Whether it matches.
|
||
*/
|
||
const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)
|
||
|
||
/**
|
||
* Check whether a character code is a markdown line ending.
|
||
*
|
||
* A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
|
||
* LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
|
||
*
|
||
* In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
|
||
* RETURN (CR) are replaced by these virtual characters depending on whether
|
||
* they occurred together.
|
||
*
|
||
* @param {Code} code
|
||
* Code.
|
||
* @returns {boolean}
|
||
* Whether it matches.
|
||
*/
|
||
function markdownLineEnding(code) {
|
||
return code !== null && code < -2
|
||
}
|
||
|
||
/**
|
||
* Check whether a character code is a markdown line ending (see
|
||
* `markdownLineEnding`) or markdown space (see `markdownSpace`).
|
||
*
|
||
* @param {Code} code
|
||
* Code.
|
||
* @returns {boolean}
|
||
* Whether it matches.
|
||
*/
|
||
function markdownLineEndingOrSpace(code) {
|
||
return code !== null && (code < 0 || code === 32)
|
||
}
|
||
|
||
/**
|
||
* Check whether a character code is a markdown space.
|
||
*
|
||
* A **markdown space** is the concrete character U+0020 SPACE (SP) and the
|
||
* virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
|
||
*
|
||
* In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
|
||
* replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
|
||
* SPACE (VS) characters, depending on the column at which the tab occurred.
|
||
*
|
||
* @param {Code} code
|
||
* Code.
|
||
* @returns {boolean}
|
||
* Whether it matches.
|
||
*/
|
||
function markdownSpace(code) {
|
||
return code === -2 || code === -1 || code === 32
|
||
}
|
||
|
||
// Size note: removing ASCII from the regex and using `asciiPunctuation` here
|
||
// In fact adds to the bundle size.
|
||
/**
|
||
* Check whether the character code represents Unicode punctuation.
|
||
*
|
||
* A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
|
||
* Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
|
||
* (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
|
||
* (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
|
||
* punctuation (see `asciiPunctuation`).
|
||
*
|
||
* See:
|
||
* **\[UNICODE]**:
|
||
* [The Unicode Standard](https://www.unicode.org/versions/).
|
||
* Unicode Consortium.
|
||
*
|
||
* @param code
|
||
* Code.
|
||
* @returns
|
||
* Whether it matches.
|
||
*/
|
||
const unicodePunctuation = regexCheck(unicodePunctuationRegex)
|
||
|
||
/**
|
||
* Check whether the character code represents Unicode whitespace.
|
||
*
|
||
* Note that this does handle micromark specific markdown whitespace characters.
|
||
* See `markdownLineEndingOrSpace` to check that.
|
||
*
|
||
* A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
|
||
* Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
|
||
* U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
|
||
*
|
||
* See:
|
||
* **\[UNICODE]**:
|
||
* [The Unicode Standard](https://www.unicode.org/versions/).
|
||
* Unicode Consortium.
|
||
*
|
||
* @param code
|
||
* Code.
|
||
* @returns
|
||
* Whether it matches.
|
||
*/
|
||
const unicodeWhitespace = regexCheck(/\s/)
|
||
|
||
/**
|
||
* Create a code check from a regex.
|
||
*
|
||
* @param {RegExp} regex
|
||
* @returns {(code: Code) => boolean}
|
||
*/
|
||
function regexCheck(regex) {
|
||
return check
|
||
|
||
/**
|
||
* Check whether a code matches the bound regex.
|
||
*
|
||
* @param {Code} code
|
||
* Character code.
|
||
* @returns {boolean}
|
||
* Whether the character code matches the bound regex.
|
||
*/
|
||
function check(code) {
|
||
return code !== null && regex.test(String.fromCharCode(code))
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-factory-space/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Effects} Effects
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenType} TokenType
|
||
*/
|
||
|
||
|
||
|
||
// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.
|
||
|
||
/**
|
||
* Parse spaces and tabs.
|
||
*
|
||
* There is no `nok` parameter:
|
||
*
|
||
* * spaces in markdown are often optional, in which case this factory can be
|
||
* used and `ok` will be switched to whether spaces were found or not
|
||
* * one line ending or space can be detected with `markdownSpace(code)` right
|
||
* before using `factorySpace`
|
||
*
|
||
* ###### Examples
|
||
*
|
||
* Where `␉` represents a tab (plus how much it expands) and `␠` represents a
|
||
* single space.
|
||
*
|
||
* ```markdown
|
||
* ␉
|
||
* ␠␠␠␠
|
||
* ␉␠
|
||
* ```
|
||
*
|
||
* @param {Effects} effects
|
||
* Context.
|
||
* @param {State} ok
|
||
* State switched to when successful.
|
||
* @param {TokenType} type
|
||
* Type (`' \t'`).
|
||
* @param {number | undefined} [max=Infinity]
|
||
* Max (exclusive).
|
||
* @returns
|
||
* Start state.
|
||
*/
|
||
function factorySpace(effects, ok, type, max) {
|
||
const limit = max ? max - 1 : Number.POSITIVE_INFINITY
|
||
let size = 0
|
||
return start
|
||
|
||
/** @type {State} */
|
||
function start(code) {
|
||
if (markdownSpace(code)) {
|
||
effects.enter(type)
|
||
return prefix(code)
|
||
}
|
||
return ok(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function prefix(code) {
|
||
if (markdownSpace(code) && size++ < limit) {
|
||
effects.consume(code)
|
||
return prefix
|
||
}
|
||
effects.exit(type)
|
||
return ok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/initialize/content.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
|
||
* @typedef {import('micromark-util-types').Initializer} Initializer
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
*/
|
||
|
||
|
||
|
||
/** @type {InitialConstruct} */
|
||
const content = {
|
||
tokenize: initializeContent
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Initializer}
|
||
*/
|
||
function initializeContent(effects) {
|
||
const contentStart = effects.attempt(
|
||
this.parser.constructs.contentInitial,
|
||
afterContentStartConstruct,
|
||
paragraphInitial
|
||
)
|
||
/** @type {Token} */
|
||
let previous
|
||
return contentStart
|
||
|
||
/** @type {State} */
|
||
function afterContentStartConstruct(code) {
|
||
if (code === null) {
|
||
effects.consume(code)
|
||
return
|
||
}
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return factorySpace(effects, contentStart, 'linePrefix')
|
||
}
|
||
|
||
/** @type {State} */
|
||
function paragraphInitial(code) {
|
||
effects.enter('paragraph')
|
||
return lineStart(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function lineStart(code) {
|
||
const token = effects.enter('chunkText', {
|
||
contentType: 'text',
|
||
previous
|
||
})
|
||
if (previous) {
|
||
previous.next = token
|
||
}
|
||
previous = token
|
||
return data(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function data(code) {
|
||
if (code === null) {
|
||
effects.exit('chunkText')
|
||
effects.exit('paragraph')
|
||
effects.consume(code)
|
||
return
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
effects.consume(code)
|
||
effects.exit('chunkText')
|
||
return lineStart
|
||
}
|
||
|
||
// Data.
|
||
effects.consume(code)
|
||
return data
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/initialize/document.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').ContainerState} ContainerState
|
||
* @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
|
||
* @typedef {import('micromark-util-types').Initializer} Initializer
|
||
* @typedef {import('micromark-util-types').Point} Point
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
/**
|
||
* @typedef {[Construct, ContainerState]} StackItem
|
||
*/
|
||
|
||
|
||
|
||
|
||
/** @type {InitialConstruct} */
|
||
const document_document = {
|
||
tokenize: initializeDocument
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const containerConstruct = {
|
||
tokenize: tokenizeContainer
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Initializer}
|
||
*/
|
||
function initializeDocument(effects) {
|
||
const self = this
|
||
/** @type {Array<StackItem>} */
|
||
const stack = []
|
||
let continued = 0
|
||
/** @type {TokenizeContext | undefined} */
|
||
let childFlow
|
||
/** @type {Token | undefined} */
|
||
let childToken
|
||
/** @type {number} */
|
||
let lineStartOffset
|
||
return start
|
||
|
||
/** @type {State} */
|
||
function start(code) {
|
||
// First we iterate through the open blocks, starting with the root
|
||
// document, and descending through last children down to the last open
|
||
// block.
|
||
// Each block imposes a condition that the line must satisfy if the block is
|
||
// to remain open.
|
||
// For example, a block quote requires a `>` character.
|
||
// A paragraph requires a non-blank line.
|
||
// In this phase we may match all or just some of the open blocks.
|
||
// But we cannot close unmatched blocks yet, because we may have a lazy
|
||
// continuation line.
|
||
if (continued < stack.length) {
|
||
const item = stack[continued]
|
||
self.containerState = item[1]
|
||
return effects.attempt(
|
||
item[0].continuation,
|
||
documentContinue,
|
||
checkNewContainers
|
||
)(code)
|
||
}
|
||
|
||
// Done.
|
||
return checkNewContainers(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function documentContinue(code) {
|
||
continued++
|
||
|
||
// Note: this field is called `_closeFlow` but it also closes containers.
|
||
// Perhaps a good idea to rename it but it’s already used in the wild by
|
||
// extensions.
|
||
if (self.containerState._closeFlow) {
|
||
self.containerState._closeFlow = undefined
|
||
if (childFlow) {
|
||
closeFlow()
|
||
}
|
||
|
||
// Note: this algorithm for moving events around is similar to the
|
||
// algorithm when dealing with lazy lines in `writeToChild`.
|
||
const indexBeforeExits = self.events.length
|
||
let indexBeforeFlow = indexBeforeExits
|
||
/** @type {Point | undefined} */
|
||
let point
|
||
|
||
// Find the flow chunk.
|
||
while (indexBeforeFlow--) {
|
||
if (
|
||
self.events[indexBeforeFlow][0] === 'exit' &&
|
||
self.events[indexBeforeFlow][1].type === 'chunkFlow'
|
||
) {
|
||
point = self.events[indexBeforeFlow][1].end
|
||
break
|
||
}
|
||
}
|
||
exitContainers(continued)
|
||
|
||
// Fix positions.
|
||
let index = indexBeforeExits
|
||
while (index < self.events.length) {
|
||
self.events[index][1].end = Object.assign({}, point)
|
||
index++
|
||
}
|
||
|
||
// Inject the exits earlier (they’re still also at the end).
|
||
splice(
|
||
self.events,
|
||
indexBeforeFlow + 1,
|
||
0,
|
||
self.events.slice(indexBeforeExits)
|
||
)
|
||
|
||
// Discard the duplicate exits.
|
||
self.events.length = index
|
||
return checkNewContainers(code)
|
||
}
|
||
return start(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function checkNewContainers(code) {
|
||
// Next, after consuming the continuation markers for existing blocks, we
|
||
// look for new block starts (e.g. `>` for a block quote).
|
||
// If we encounter a new block start, we close any blocks unmatched in
|
||
// step 1 before creating the new block as a child of the last matched
|
||
// block.
|
||
if (continued === stack.length) {
|
||
// No need to `check` whether there’s a container, of `exitContainers`
|
||
// would be moot.
|
||
// We can instead immediately `attempt` to parse one.
|
||
if (!childFlow) {
|
||
return documentContinued(code)
|
||
}
|
||
|
||
// If we have concrete content, such as block HTML or fenced code,
|
||
// we can’t have containers “pierce” into them, so we can immediately
|
||
// start.
|
||
if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
|
||
return flowStart(code)
|
||
}
|
||
|
||
// If we do have flow, it could still be a blank line,
|
||
// but we’d be interrupting it w/ a new container if there’s a current
|
||
// construct.
|
||
// To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer
|
||
// needed in micromark-extension-gfm-table@1.0.6).
|
||
self.interrupt = Boolean(
|
||
childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack
|
||
)
|
||
}
|
||
|
||
// Check if there is a new container.
|
||
self.containerState = {}
|
||
return effects.check(
|
||
containerConstruct,
|
||
thereIsANewContainer,
|
||
thereIsNoNewContainer
|
||
)(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function thereIsANewContainer(code) {
|
||
if (childFlow) closeFlow()
|
||
exitContainers(continued)
|
||
return documentContinued(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function thereIsNoNewContainer(code) {
|
||
self.parser.lazy[self.now().line] = continued !== stack.length
|
||
lineStartOffset = self.now().offset
|
||
return flowStart(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function documentContinued(code) {
|
||
// Try new containers.
|
||
self.containerState = {}
|
||
return effects.attempt(
|
||
containerConstruct,
|
||
containerContinue,
|
||
flowStart
|
||
)(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function containerContinue(code) {
|
||
continued++
|
||
stack.push([self.currentConstruct, self.containerState])
|
||
// Try another.
|
||
return documentContinued(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function flowStart(code) {
|
||
if (code === null) {
|
||
if (childFlow) closeFlow()
|
||
exitContainers(0)
|
||
effects.consume(code)
|
||
return
|
||
}
|
||
childFlow = childFlow || self.parser.flow(self.now())
|
||
effects.enter('chunkFlow', {
|
||
contentType: 'flow',
|
||
previous: childToken,
|
||
_tokenizer: childFlow
|
||
})
|
||
return flowContinue(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function flowContinue(code) {
|
||
if (code === null) {
|
||
writeToChild(effects.exit('chunkFlow'), true)
|
||
exitContainers(0)
|
||
effects.consume(code)
|
||
return
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
effects.consume(code)
|
||
writeToChild(effects.exit('chunkFlow'))
|
||
// Get ready for the next line.
|
||
continued = 0
|
||
self.interrupt = undefined
|
||
return start
|
||
}
|
||
effects.consume(code)
|
||
return flowContinue
|
||
}
|
||
|
||
/**
|
||
* @param {Token} token
|
||
* @param {boolean | undefined} [eof]
|
||
* @returns {void}
|
||
*/
|
||
function writeToChild(token, eof) {
|
||
const stream = self.sliceStream(token)
|
||
if (eof) stream.push(null)
|
||
token.previous = childToken
|
||
if (childToken) childToken.next = token
|
||
childToken = token
|
||
childFlow.defineSkip(token.start)
|
||
childFlow.write(stream)
|
||
|
||
// Alright, so we just added a lazy line:
|
||
//
|
||
// ```markdown
|
||
// > a
|
||
// b.
|
||
//
|
||
// Or:
|
||
//
|
||
// > ~~~c
|
||
// d
|
||
//
|
||
// Or:
|
||
//
|
||
// > | e |
|
||
// f
|
||
// ```
|
||
//
|
||
// The construct in the second example (fenced code) does not accept lazy
|
||
// lines, so it marked itself as done at the end of its first line, and
|
||
// then the content construct parses `d`.
|
||
// Most constructs in markdown match on the first line: if the first line
|
||
// forms a construct, a non-lazy line can’t “unmake” it.
|
||
//
|
||
// The construct in the third example is potentially a GFM table, and
|
||
// those are *weird*.
|
||
// It *could* be a table, from the first line, if the following line
|
||
// matches a condition.
|
||
// In this case, that second line is lazy, which “unmakes” the first line
|
||
// and turns the whole into one content block.
|
||
//
|
||
// We’ve now parsed the non-lazy and the lazy line, and can figure out
|
||
// whether the lazy line started a new flow block.
|
||
// If it did, we exit the current containers between the two flow blocks.
|
||
if (self.parser.lazy[token.start.line]) {
|
||
let index = childFlow.events.length
|
||
while (index--) {
|
||
if (
|
||
// The token starts before the line ending…
|
||
childFlow.events[index][1].start.offset < lineStartOffset &&
|
||
// …and either is not ended yet…
|
||
(!childFlow.events[index][1].end ||
|
||
// …or ends after it.
|
||
childFlow.events[index][1].end.offset > lineStartOffset)
|
||
) {
|
||
// Exit: there’s still something open, which means it’s a lazy line
|
||
// part of something.
|
||
return
|
||
}
|
||
}
|
||
|
||
// Note: this algorithm for moving events around is similar to the
|
||
// algorithm when closing flow in `documentContinue`.
|
||
const indexBeforeExits = self.events.length
|
||
let indexBeforeFlow = indexBeforeExits
|
||
/** @type {boolean | undefined} */
|
||
let seen
|
||
/** @type {Point | undefined} */
|
||
let point
|
||
|
||
// Find the previous chunk (the one before the lazy line).
|
||
while (indexBeforeFlow--) {
|
||
if (
|
||
self.events[indexBeforeFlow][0] === 'exit' &&
|
||
self.events[indexBeforeFlow][1].type === 'chunkFlow'
|
||
) {
|
||
if (seen) {
|
||
point = self.events[indexBeforeFlow][1].end
|
||
break
|
||
}
|
||
seen = true
|
||
}
|
||
}
|
||
exitContainers(continued)
|
||
|
||
// Fix positions.
|
||
index = indexBeforeExits
|
||
while (index < self.events.length) {
|
||
self.events[index][1].end = Object.assign({}, point)
|
||
index++
|
||
}
|
||
|
||
// Inject the exits earlier (they’re still also at the end).
|
||
splice(
|
||
self.events,
|
||
indexBeforeFlow + 1,
|
||
0,
|
||
self.events.slice(indexBeforeExits)
|
||
)
|
||
|
||
// Discard the duplicate exits.
|
||
self.events.length = index
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {number} size
|
||
* @returns {void}
|
||
*/
|
||
function exitContainers(size) {
|
||
let index = stack.length
|
||
|
||
// Exit open containers.
|
||
while (index-- > size) {
|
||
const entry = stack[index]
|
||
self.containerState = entry[1]
|
||
entry[0].exit.call(self, effects)
|
||
}
|
||
stack.length = size
|
||
}
|
||
function closeFlow() {
|
||
childFlow.write([null])
|
||
childToken = undefined
|
||
childFlow = undefined
|
||
self.containerState._closeFlow = undefined
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeContainer(effects, ok, nok) {
|
||
// Always populated by defaults.
|
||
|
||
return factorySpace(
|
||
effects,
|
||
effects.attempt(this.parser.constructs.document, ok, nok),
|
||
'linePrefix',
|
||
this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4
|
||
)
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/blank-line.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const blankLine = {
|
||
tokenize: tokenizeBlankLine,
|
||
partial: true
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeBlankLine(effects, ok, nok) {
|
||
return start
|
||
|
||
/**
|
||
* Start of blank line.
|
||
*
|
||
* > 👉 **Note**: `␠` represents a space character.
|
||
*
|
||
* ```markdown
|
||
* > | ␠␠␊
|
||
* ^
|
||
* > | ␊
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
return markdownSpace(code)
|
||
? factorySpace(effects, after, 'linePrefix')(code)
|
||
: after(code)
|
||
}
|
||
|
||
/**
|
||
* At eof/eol, after optional whitespace.
|
||
*
|
||
* > 👉 **Note**: `␠` represents a space character.
|
||
*
|
||
* ```markdown
|
||
* > | ␠␠␊
|
||
* ^
|
||
* > | ␊
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
return code === null || markdownLineEnding(code) ? ok(code) : nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-subtokenize/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Chunk} Chunk
|
||
* @typedef {import('micromark-util-types').Event} Event
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
*/
|
||
|
||
|
||
/**
|
||
* Tokenize subcontent.
|
||
*
|
||
* @param {Array<Event>} events
|
||
* List of events.
|
||
* @returns {boolean}
|
||
* Whether subtokens were found.
|
||
*/
|
||
function subtokenize(events) {
|
||
/** @type {Record<string, number>} */
|
||
const jumps = {}
|
||
let index = -1
|
||
/** @type {Event} */
|
||
let event
|
||
/** @type {number | undefined} */
|
||
let lineIndex
|
||
/** @type {number} */
|
||
let otherIndex
|
||
/** @type {Event} */
|
||
let otherEvent
|
||
/** @type {Array<Event>} */
|
||
let parameters
|
||
/** @type {Array<Event>} */
|
||
let subevents
|
||
/** @type {boolean | undefined} */
|
||
let more
|
||
while (++index < events.length) {
|
||
while (index in jumps) {
|
||
index = jumps[index]
|
||
}
|
||
event = events[index]
|
||
|
||
// Add a hook for the GFM tasklist extension, which needs to know if text
|
||
// is in the first content of a list item.
|
||
if (
|
||
index &&
|
||
event[1].type === 'chunkFlow' &&
|
||
events[index - 1][1].type === 'listItemPrefix'
|
||
) {
|
||
subevents = event[1]._tokenizer.events
|
||
otherIndex = 0
|
||
if (
|
||
otherIndex < subevents.length &&
|
||
subevents[otherIndex][1].type === 'lineEndingBlank'
|
||
) {
|
||
otherIndex += 2
|
||
}
|
||
if (
|
||
otherIndex < subevents.length &&
|
||
subevents[otherIndex][1].type === 'content'
|
||
) {
|
||
while (++otherIndex < subevents.length) {
|
||
if (subevents[otherIndex][1].type === 'content') {
|
||
break
|
||
}
|
||
if (subevents[otherIndex][1].type === 'chunkText') {
|
||
subevents[otherIndex][1]._isInFirstContentOfListItem = true
|
||
otherIndex++
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Enter.
|
||
if (event[0] === 'enter') {
|
||
if (event[1].contentType) {
|
||
Object.assign(jumps, subcontent(events, index))
|
||
index = jumps[index]
|
||
more = true
|
||
}
|
||
}
|
||
// Exit.
|
||
else if (event[1]._container) {
|
||
otherIndex = index
|
||
lineIndex = undefined
|
||
while (otherIndex--) {
|
||
otherEvent = events[otherIndex]
|
||
if (
|
||
otherEvent[1].type === 'lineEnding' ||
|
||
otherEvent[1].type === 'lineEndingBlank'
|
||
) {
|
||
if (otherEvent[0] === 'enter') {
|
||
if (lineIndex) {
|
||
events[lineIndex][1].type = 'lineEndingBlank'
|
||
}
|
||
otherEvent[1].type = 'lineEnding'
|
||
lineIndex = otherIndex
|
||
}
|
||
} else {
|
||
break
|
||
}
|
||
}
|
||
if (lineIndex) {
|
||
// Fix position.
|
||
event[1].end = Object.assign({}, events[lineIndex][1].start)
|
||
|
||
// Switch container exit w/ line endings.
|
||
parameters = events.slice(lineIndex, index)
|
||
parameters.unshift(event)
|
||
splice(events, lineIndex, index - lineIndex + 1, parameters)
|
||
}
|
||
}
|
||
}
|
||
return !more
|
||
}
|
||
|
||
/**
|
||
* Tokenize embedded tokens.
|
||
*
|
||
* @param {Array<Event>} events
|
||
* @param {number} eventIndex
|
||
* @returns {Record<string, number>}
|
||
*/
|
||
function subcontent(events, eventIndex) {
|
||
const token = events[eventIndex][1]
|
||
const context = events[eventIndex][2]
|
||
let startPosition = eventIndex - 1
|
||
/** @type {Array<number>} */
|
||
const startPositions = []
|
||
const tokenizer =
|
||
token._tokenizer || context.parser[token.contentType](token.start)
|
||
const childEvents = tokenizer.events
|
||
/** @type {Array<[number, number]>} */
|
||
const jumps = []
|
||
/** @type {Record<string, number>} */
|
||
const gaps = {}
|
||
/** @type {Array<Chunk>} */
|
||
let stream
|
||
/** @type {Token | undefined} */
|
||
let previous
|
||
let index = -1
|
||
/** @type {Token | undefined} */
|
||
let current = token
|
||
let adjust = 0
|
||
let start = 0
|
||
const breaks = [start]
|
||
|
||
// Loop forward through the linked tokens to pass them in order to the
|
||
// subtokenizer.
|
||
while (current) {
|
||
// Find the position of the event for this token.
|
||
while (events[++startPosition][1] !== current) {
|
||
// Empty.
|
||
}
|
||
startPositions.push(startPosition)
|
||
if (!current._tokenizer) {
|
||
stream = context.sliceStream(current)
|
||
if (!current.next) {
|
||
stream.push(null)
|
||
}
|
||
if (previous) {
|
||
tokenizer.defineSkip(current.start)
|
||
}
|
||
if (current._isInFirstContentOfListItem) {
|
||
tokenizer._gfmTasklistFirstContentOfListItem = true
|
||
}
|
||
tokenizer.write(stream)
|
||
if (current._isInFirstContentOfListItem) {
|
||
tokenizer._gfmTasklistFirstContentOfListItem = undefined
|
||
}
|
||
}
|
||
|
||
// Unravel the next token.
|
||
previous = current
|
||
current = current.next
|
||
}
|
||
|
||
// Now, loop back through all events (and linked tokens), to figure out which
|
||
// parts belong where.
|
||
current = token
|
||
while (++index < childEvents.length) {
|
||
if (
|
||
// Find a void token that includes a break.
|
||
childEvents[index][0] === 'exit' &&
|
||
childEvents[index - 1][0] === 'enter' &&
|
||
childEvents[index][1].type === childEvents[index - 1][1].type &&
|
||
childEvents[index][1].start.line !== childEvents[index][1].end.line
|
||
) {
|
||
start = index + 1
|
||
breaks.push(start)
|
||
// Help GC.
|
||
current._tokenizer = undefined
|
||
current.previous = undefined
|
||
current = current.next
|
||
}
|
||
}
|
||
|
||
// Help GC.
|
||
tokenizer.events = []
|
||
|
||
// If there’s one more token (which is the cases for lines that end in an
|
||
// EOF), that’s perfect: the last point we found starts it.
|
||
// If there isn’t then make sure any remaining content is added to it.
|
||
if (current) {
|
||
// Help GC.
|
||
current._tokenizer = undefined
|
||
current.previous = undefined
|
||
} else {
|
||
breaks.pop()
|
||
}
|
||
|
||
// Now splice the events from the subtokenizer into the current events,
|
||
// moving back to front so that splice indices aren’t affected.
|
||
index = breaks.length
|
||
while (index--) {
|
||
const slice = childEvents.slice(breaks[index], breaks[index + 1])
|
||
const start = startPositions.pop()
|
||
jumps.unshift([start, start + slice.length - 1])
|
||
splice(events, start, 2, slice)
|
||
}
|
||
index = -1
|
||
while (++index < jumps.length) {
|
||
gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]
|
||
adjust += jumps[index][1] - jumps[index][0] - 1
|
||
}
|
||
return gaps
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/content.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
|
||
/**
|
||
* No name because it must not be turned off.
|
||
* @type {Construct}
|
||
*/
|
||
const content_content = {
|
||
tokenize: tokenizeContent,
|
||
resolve: resolveContent
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const continuationConstruct = {
|
||
tokenize: tokenizeContinuation,
|
||
partial: true
|
||
}
|
||
|
||
/**
|
||
* Content is transparent: it’s parsed right now. That way, definitions are also
|
||
* parsed right now: before text in paragraphs (specifically, media) are parsed.
|
||
*
|
||
* @type {Resolver}
|
||
*/
|
||
function resolveContent(events) {
|
||
subtokenize(events)
|
||
return events
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeContent(effects, ok) {
|
||
/** @type {Token | undefined} */
|
||
let previous
|
||
return chunkStart
|
||
|
||
/**
|
||
* Before a content chunk.
|
||
*
|
||
* ```markdown
|
||
* > | abc
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function chunkStart(code) {
|
||
effects.enter('content')
|
||
previous = effects.enter('chunkContent', {
|
||
contentType: 'content'
|
||
})
|
||
return chunkInside(code)
|
||
}
|
||
|
||
/**
|
||
* In a content chunk.
|
||
*
|
||
* ```markdown
|
||
* > | abc
|
||
* ^^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function chunkInside(code) {
|
||
if (code === null) {
|
||
return contentEnd(code)
|
||
}
|
||
|
||
// To do: in `markdown-rs`, each line is parsed on its own, and everything
|
||
// is stitched together resolving.
|
||
if (markdownLineEnding(code)) {
|
||
return effects.check(
|
||
continuationConstruct,
|
||
contentContinue,
|
||
contentEnd
|
||
)(code)
|
||
}
|
||
|
||
// Data.
|
||
effects.consume(code)
|
||
return chunkInside
|
||
}
|
||
|
||
/**
|
||
*
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function contentEnd(code) {
|
||
effects.exit('chunkContent')
|
||
effects.exit('content')
|
||
return ok(code)
|
||
}
|
||
|
||
/**
|
||
*
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function contentContinue(code) {
|
||
effects.consume(code)
|
||
effects.exit('chunkContent')
|
||
previous.next = effects.enter('chunkContent', {
|
||
contentType: 'content',
|
||
previous
|
||
})
|
||
previous = previous.next
|
||
return chunkInside
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeContinuation(effects, ok, nok) {
|
||
const self = this
|
||
return startLookahead
|
||
|
||
/**
|
||
*
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function startLookahead(code) {
|
||
effects.exit('chunkContent')
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return factorySpace(effects, prefixed, 'linePrefix')
|
||
}
|
||
|
||
/**
|
||
*
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function prefixed(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
return nok(code)
|
||
}
|
||
|
||
// Always populated by defaults.
|
||
|
||
const tail = self.events[self.events.length - 1]
|
||
if (
|
||
!self.parser.constructs.disable.null.includes('codeIndented') &&
|
||
tail &&
|
||
tail[1].type === 'linePrefix' &&
|
||
tail[2].sliceSerialize(tail[1], true).length >= 4
|
||
) {
|
||
return ok(code)
|
||
}
|
||
return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/initialize/flow.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
|
||
* @typedef {import('micromark-util-types').Initializer} Initializer
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
*/
|
||
|
||
|
||
|
||
|
||
/** @type {InitialConstruct} */
|
||
const flow = {
|
||
tokenize: initializeFlow
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Initializer}
|
||
*/
|
||
function initializeFlow(effects) {
|
||
const self = this
|
||
const initial = effects.attempt(
|
||
// Try to parse a blank line.
|
||
blankLine,
|
||
atBlankEnding,
|
||
// Try to parse initial flow (essentially, only code).
|
||
effects.attempt(
|
||
this.parser.constructs.flowInitial,
|
||
afterConstruct,
|
||
factorySpace(
|
||
effects,
|
||
effects.attempt(
|
||
this.parser.constructs.flow,
|
||
afterConstruct,
|
||
effects.attempt(content_content, afterConstruct)
|
||
),
|
||
'linePrefix'
|
||
)
|
||
)
|
||
)
|
||
return initial
|
||
|
||
/** @type {State} */
|
||
function atBlankEnding(code) {
|
||
if (code === null) {
|
||
effects.consume(code)
|
||
return
|
||
}
|
||
effects.enter('lineEndingBlank')
|
||
effects.consume(code)
|
||
effects.exit('lineEndingBlank')
|
||
self.currentConstruct = undefined
|
||
return initial
|
||
}
|
||
|
||
/** @type {State} */
|
||
function afterConstruct(code) {
|
||
if (code === null) {
|
||
effects.consume(code)
|
||
return
|
||
}
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
self.currentConstruct = undefined
|
||
return initial
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/initialize/text.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
|
||
* @typedef {import('micromark-util-types').Initializer} Initializer
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
*/
|
||
|
||
const resolver = {
|
||
resolveAll: createResolver()
|
||
}
|
||
const string = initializeFactory('string')
|
||
const text_text = initializeFactory('text')
|
||
|
||
/**
|
||
* @param {'string' | 'text'} field
|
||
* @returns {InitialConstruct}
|
||
*/
|
||
function initializeFactory(field) {
|
||
return {
|
||
tokenize: initializeText,
|
||
resolveAll: createResolver(
|
||
field === 'text' ? resolveAllLineSuffixes : undefined
|
||
)
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Initializer}
|
||
*/
|
||
function initializeText(effects) {
|
||
const self = this
|
||
const constructs = this.parser.constructs[field]
|
||
const text = effects.attempt(constructs, start, notText)
|
||
return start
|
||
|
||
/** @type {State} */
|
||
function start(code) {
|
||
return atBreak(code) ? text(code) : notText(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function notText(code) {
|
||
if (code === null) {
|
||
effects.consume(code)
|
||
return
|
||
}
|
||
effects.enter('data')
|
||
effects.consume(code)
|
||
return data
|
||
}
|
||
|
||
/** @type {State} */
|
||
function data(code) {
|
||
if (atBreak(code)) {
|
||
effects.exit('data')
|
||
return text(code)
|
||
}
|
||
|
||
// Data.
|
||
effects.consume(code)
|
||
return data
|
||
}
|
||
|
||
/**
|
||
* @param {Code} code
|
||
* @returns {boolean}
|
||
*/
|
||
function atBreak(code) {
|
||
if (code === null) {
|
||
return true
|
||
}
|
||
const list = constructs[code]
|
||
let index = -1
|
||
if (list) {
|
||
// Always populated by defaults.
|
||
|
||
while (++index < list.length) {
|
||
const item = list[index]
|
||
if (!item.previous || item.previous.call(self, self.previous)) {
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {Resolver | undefined} [extraResolver]
|
||
* @returns {Resolver}
|
||
*/
|
||
function createResolver(extraResolver) {
|
||
return resolveAllText
|
||
|
||
/** @type {Resolver} */
|
||
function resolveAllText(events, context) {
|
||
let index = -1
|
||
/** @type {number | undefined} */
|
||
let enter
|
||
|
||
// A rather boring computation (to merge adjacent `data` events) which
|
||
// improves mm performance by 29%.
|
||
while (++index <= events.length) {
|
||
if (enter === undefined) {
|
||
if (events[index] && events[index][1].type === 'data') {
|
||
enter = index
|
||
index++
|
||
}
|
||
} else if (!events[index] || events[index][1].type !== 'data') {
|
||
// Don’t do anything if there is one data token.
|
||
if (index !== enter + 2) {
|
||
events[enter][1].end = events[index - 1][1].end
|
||
events.splice(enter + 2, index - enter - 2)
|
||
index = enter + 2
|
||
}
|
||
enter = undefined
|
||
}
|
||
}
|
||
return extraResolver ? extraResolver(events, context) : events
|
||
}
|
||
}
|
||
|
||
/**
|
||
* A rather ugly set of instructions which again looks at chunks in the input
|
||
* stream.
|
||
* The reason to do this here is that it is *much* faster to parse in reverse.
|
||
* And that we can’t hook into `null` to split the line suffix before an EOF.
|
||
* To do: figure out if we can make this into a clean utility, or even in core.
|
||
* As it will be useful for GFMs literal autolink extension (and maybe even
|
||
* tables?)
|
||
*
|
||
* @type {Resolver}
|
||
*/
|
||
function resolveAllLineSuffixes(events, context) {
|
||
let eventIndex = 0 // Skip first.
|
||
|
||
while (++eventIndex <= events.length) {
|
||
if (
|
||
(eventIndex === events.length ||
|
||
events[eventIndex][1].type === 'lineEnding') &&
|
||
events[eventIndex - 1][1].type === 'data'
|
||
) {
|
||
const data = events[eventIndex - 1][1]
|
||
const chunks = context.sliceStream(data)
|
||
let index = chunks.length
|
||
let bufferIndex = -1
|
||
let size = 0
|
||
/** @type {boolean | undefined} */
|
||
let tabs
|
||
while (index--) {
|
||
const chunk = chunks[index]
|
||
if (typeof chunk === 'string') {
|
||
bufferIndex = chunk.length
|
||
while (chunk.charCodeAt(bufferIndex - 1) === 32) {
|
||
size++
|
||
bufferIndex--
|
||
}
|
||
if (bufferIndex) break
|
||
bufferIndex = -1
|
||
}
|
||
// Number
|
||
else if (chunk === -2) {
|
||
tabs = true
|
||
size++
|
||
} else if (chunk === -1) {
|
||
// Empty
|
||
} else {
|
||
// Replacement character, exit.
|
||
index++
|
||
break
|
||
}
|
||
}
|
||
if (size) {
|
||
const token = {
|
||
type:
|
||
eventIndex === events.length || tabs || size < 2
|
||
? 'lineSuffix'
|
||
: 'hardBreakTrailing',
|
||
start: {
|
||
line: data.end.line,
|
||
column: data.end.column - size,
|
||
offset: data.end.offset - size,
|
||
_index: data.start._index + index,
|
||
_bufferIndex: index
|
||
? bufferIndex
|
||
: data.start._bufferIndex + bufferIndex
|
||
},
|
||
end: Object.assign({}, data.end)
|
||
}
|
||
data.end = Object.assign({}, token.start)
|
||
if (data.start.offset === data.end.offset) {
|
||
Object.assign(data, token)
|
||
} else {
|
||
events.splice(
|
||
eventIndex,
|
||
0,
|
||
['enter', token, context],
|
||
['exit', token, context]
|
||
)
|
||
eventIndex += 2
|
||
}
|
||
}
|
||
eventIndex++
|
||
}
|
||
}
|
||
return events
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-resolve-all/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Event} Event
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
*/
|
||
|
||
/**
|
||
* Call all `resolveAll`s.
|
||
*
|
||
* @param {Array<{resolveAll?: Resolver | undefined}>} constructs
|
||
* List of constructs, optionally with `resolveAll`s.
|
||
* @param {Array<Event>} events
|
||
* List of events.
|
||
* @param {TokenizeContext} context
|
||
* Context used by `tokenize`.
|
||
* @returns {Array<Event>}
|
||
* Changed events.
|
||
*/
|
||
function resolveAll(constructs, events, context) {
|
||
/** @type {Array<Resolver>} */
|
||
const called = []
|
||
let index = -1
|
||
|
||
while (++index < constructs.length) {
|
||
const resolve = constructs[index].resolveAll
|
||
|
||
if (resolve && !called.includes(resolve)) {
|
||
events = resolve(events, context)
|
||
called.push(resolve)
|
||
}
|
||
}
|
||
|
||
return events
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/create-tokenizer.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Chunk} Chunk
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
|
||
* @typedef {import('micromark-util-types').Effects} Effects
|
||
* @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
|
||
* @typedef {import('micromark-util-types').ParseContext} ParseContext
|
||
* @typedef {import('micromark-util-types').Point} Point
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenType} TokenType
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
*/
|
||
|
||
/**
|
||
* @callback Restore
|
||
* @returns {void}
|
||
*
|
||
* @typedef Info
|
||
* @property {Restore} restore
|
||
* @property {number} from
|
||
*
|
||
* @callback ReturnHandle
|
||
* Handle a successful run.
|
||
* @param {Construct} construct
|
||
* @param {Info} info
|
||
* @returns {void}
|
||
*/
|
||
|
||
|
||
|
||
|
||
/**
|
||
* Create a tokenizer.
|
||
* Tokenizers deal with one type of data (e.g., containers, flow, text).
|
||
* The parser is the object dealing with it all.
|
||
* `initialize` works like other constructs, except that only its `tokenize`
|
||
* function is used, in which case it doesn’t receive an `ok` or `nok`.
|
||
* `from` can be given to set the point before the first character, although
|
||
* when further lines are indented, they must be set with `defineSkip`.
|
||
*
|
||
* @param {ParseContext} parser
|
||
* @param {InitialConstruct} initialize
|
||
* @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]
|
||
* @returns {TokenizeContext}
|
||
*/
|
||
function createTokenizer(parser, initialize, from) {
|
||
/** @type {Point} */
|
||
let point = Object.assign(
|
||
from
|
||
? Object.assign({}, from)
|
||
: {
|
||
line: 1,
|
||
column: 1,
|
||
offset: 0
|
||
},
|
||
{
|
||
_index: 0,
|
||
_bufferIndex: -1
|
||
}
|
||
)
|
||
/** @type {Record<string, number>} */
|
||
const columnStart = {}
|
||
/** @type {Array<Construct>} */
|
||
const resolveAllConstructs = []
|
||
/** @type {Array<Chunk>} */
|
||
let chunks = []
|
||
/** @type {Array<Token>} */
|
||
let stack = []
|
||
/** @type {boolean | undefined} */
|
||
let consumed = true
|
||
|
||
/**
|
||
* Tools used for tokenizing.
|
||
*
|
||
* @type {Effects}
|
||
*/
|
||
const effects = {
|
||
consume,
|
||
enter,
|
||
exit,
|
||
attempt: constructFactory(onsuccessfulconstruct),
|
||
check: constructFactory(onsuccessfulcheck),
|
||
interrupt: constructFactory(onsuccessfulcheck, {
|
||
interrupt: true
|
||
})
|
||
}
|
||
|
||
/**
|
||
* State and tools for resolving and serializing.
|
||
*
|
||
* @type {TokenizeContext}
|
||
*/
|
||
const context = {
|
||
previous: null,
|
||
code: null,
|
||
containerState: {},
|
||
events: [],
|
||
parser,
|
||
sliceStream,
|
||
sliceSerialize,
|
||
now,
|
||
defineSkip,
|
||
write
|
||
}
|
||
|
||
/**
|
||
* The state function.
|
||
*
|
||
* @type {State | void}
|
||
*/
|
||
let state = initialize.tokenize.call(context, effects)
|
||
|
||
/**
|
||
* Track which character we expect to be consumed, to catch bugs.
|
||
*
|
||
* @type {Code}
|
||
*/
|
||
let expectedCode
|
||
if (initialize.resolveAll) {
|
||
resolveAllConstructs.push(initialize)
|
||
}
|
||
return context
|
||
|
||
/** @type {TokenizeContext['write']} */
|
||
function write(slice) {
|
||
chunks = push(chunks, slice)
|
||
main()
|
||
|
||
// Exit if we’re not done, resolve might change stuff.
|
||
if (chunks[chunks.length - 1] !== null) {
|
||
return []
|
||
}
|
||
addResult(initialize, 0)
|
||
|
||
// Otherwise, resolve, and exit.
|
||
context.events = resolveAll(resolveAllConstructs, context.events, context)
|
||
return context.events
|
||
}
|
||
|
||
//
|
||
// Tools.
|
||
//
|
||
|
||
/** @type {TokenizeContext['sliceSerialize']} */
|
||
function sliceSerialize(token, expandTabs) {
|
||
return serializeChunks(sliceStream(token), expandTabs)
|
||
}
|
||
|
||
/** @type {TokenizeContext['sliceStream']} */
|
||
function sliceStream(token) {
|
||
return sliceChunks(chunks, token)
|
||
}
|
||
|
||
/** @type {TokenizeContext['now']} */
|
||
function now() {
|
||
// This is a hot path, so we clone manually instead of `Object.assign({}, point)`
|
||
const {line, column, offset, _index, _bufferIndex} = point
|
||
return {
|
||
line,
|
||
column,
|
||
offset,
|
||
_index,
|
||
_bufferIndex
|
||
}
|
||
}
|
||
|
||
/** @type {TokenizeContext['defineSkip']} */
|
||
function defineSkip(value) {
|
||
columnStart[value.line] = value.column
|
||
accountForPotentialSkip()
|
||
}
|
||
|
||
//
|
||
// State management.
|
||
//
|
||
|
||
/**
|
||
* Main loop (note that `_index` and `_bufferIndex` in `point` are modified by
|
||
* `consume`).
|
||
* Here is where we walk through the chunks, which either include strings of
|
||
* several characters, or numerical character codes.
|
||
* The reason to do this in a loop instead of a call is so the stack can
|
||
* drain.
|
||
*
|
||
* @returns {void}
|
||
*/
|
||
function main() {
|
||
/** @type {number} */
|
||
let chunkIndex
|
||
while (point._index < chunks.length) {
|
||
const chunk = chunks[point._index]
|
||
|
||
// If we’re in a buffer chunk, loop through it.
|
||
if (typeof chunk === 'string') {
|
||
chunkIndex = point._index
|
||
if (point._bufferIndex < 0) {
|
||
point._bufferIndex = 0
|
||
}
|
||
while (
|
||
point._index === chunkIndex &&
|
||
point._bufferIndex < chunk.length
|
||
) {
|
||
go(chunk.charCodeAt(point._bufferIndex))
|
||
}
|
||
} else {
|
||
go(chunk)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Deal with one code.
|
||
*
|
||
* @param {Code} code
|
||
* @returns {void}
|
||
*/
|
||
function go(code) {
|
||
consumed = undefined
|
||
expectedCode = code
|
||
state = state(code)
|
||
}
|
||
|
||
/** @type {Effects['consume']} */
|
||
function consume(code) {
|
||
if (markdownLineEnding(code)) {
|
||
point.line++
|
||
point.column = 1
|
||
point.offset += code === -3 ? 2 : 1
|
||
accountForPotentialSkip()
|
||
} else if (code !== -1) {
|
||
point.column++
|
||
point.offset++
|
||
}
|
||
|
||
// Not in a string chunk.
|
||
if (point._bufferIndex < 0) {
|
||
point._index++
|
||
} else {
|
||
point._bufferIndex++
|
||
|
||
// At end of string chunk.
|
||
// @ts-expect-error Points w/ non-negative `_bufferIndex` reference
|
||
// strings.
|
||
if (point._bufferIndex === chunks[point._index].length) {
|
||
point._bufferIndex = -1
|
||
point._index++
|
||
}
|
||
}
|
||
|
||
// Expose the previous character.
|
||
context.previous = code
|
||
|
||
// Mark as consumed.
|
||
consumed = true
|
||
}
|
||
|
||
/** @type {Effects['enter']} */
|
||
function enter(type, fields) {
|
||
/** @type {Token} */
|
||
// @ts-expect-error Patch instead of assign required fields to help GC.
|
||
const token = fields || {}
|
||
token.type = type
|
||
token.start = now()
|
||
context.events.push(['enter', token, context])
|
||
stack.push(token)
|
||
return token
|
||
}
|
||
|
||
/** @type {Effects['exit']} */
|
||
function exit(type) {
|
||
const token = stack.pop()
|
||
token.end = now()
|
||
context.events.push(['exit', token, context])
|
||
return token
|
||
}
|
||
|
||
/**
|
||
* Use results.
|
||
*
|
||
* @type {ReturnHandle}
|
||
*/
|
||
function onsuccessfulconstruct(construct, info) {
|
||
addResult(construct, info.from)
|
||
}
|
||
|
||
/**
|
||
* Discard results.
|
||
*
|
||
* @type {ReturnHandle}
|
||
*/
|
||
function onsuccessfulcheck(_, info) {
|
||
info.restore()
|
||
}
|
||
|
||
/**
|
||
* Factory to attempt/check/interrupt.
|
||
*
|
||
* @param {ReturnHandle} onreturn
|
||
* @param {{interrupt?: boolean | undefined} | undefined} [fields]
|
||
*/
|
||
function constructFactory(onreturn, fields) {
|
||
return hook
|
||
|
||
/**
|
||
* Handle either an object mapping codes to constructs, a list of
|
||
* constructs, or a single construct.
|
||
*
|
||
* @param {Array<Construct> | Construct | ConstructRecord} constructs
|
||
* @param {State} returnState
|
||
* @param {State | undefined} [bogusState]
|
||
* @returns {State}
|
||
*/
|
||
function hook(constructs, returnState, bogusState) {
|
||
/** @type {Array<Construct>} */
|
||
let listOfConstructs
|
||
/** @type {number} */
|
||
let constructIndex
|
||
/** @type {Construct} */
|
||
let currentConstruct
|
||
/** @type {Info} */
|
||
let info
|
||
return Array.isArray(constructs) /* c8 ignore next 1 */
|
||
? handleListOfConstructs(constructs)
|
||
: 'tokenize' in constructs
|
||
? // @ts-expect-error Looks like a construct.
|
||
handleListOfConstructs([constructs])
|
||
: handleMapOfConstructs(constructs)
|
||
|
||
/**
|
||
* Handle a list of construct.
|
||
*
|
||
* @param {ConstructRecord} map
|
||
* @returns {State}
|
||
*/
|
||
function handleMapOfConstructs(map) {
|
||
return start
|
||
|
||
/** @type {State} */
|
||
function start(code) {
|
||
const def = code !== null && map[code]
|
||
const all = code !== null && map.null
|
||
const list = [
|
||
// To do: add more extension tests.
|
||
/* c8 ignore next 2 */
|
||
...(Array.isArray(def) ? def : def ? [def] : []),
|
||
...(Array.isArray(all) ? all : all ? [all] : [])
|
||
]
|
||
return handleListOfConstructs(list)(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Handle a list of construct.
|
||
*
|
||
* @param {Array<Construct>} list
|
||
* @returns {State}
|
||
*/
|
||
function handleListOfConstructs(list) {
|
||
listOfConstructs = list
|
||
constructIndex = 0
|
||
if (list.length === 0) {
|
||
return bogusState
|
||
}
|
||
return handleConstruct(list[constructIndex])
|
||
}
|
||
|
||
/**
|
||
* Handle a single construct.
|
||
*
|
||
* @param {Construct} construct
|
||
* @returns {State}
|
||
*/
|
||
function handleConstruct(construct) {
|
||
return start
|
||
|
||
/** @type {State} */
|
||
function start(code) {
|
||
// To do: not needed to store if there is no bogus state, probably?
|
||
// Currently doesn’t work because `inspect` in document does a check
|
||
// w/o a bogus, which doesn’t make sense. But it does seem to help perf
|
||
// by not storing.
|
||
info = store()
|
||
currentConstruct = construct
|
||
if (!construct.partial) {
|
||
context.currentConstruct = construct
|
||
}
|
||
|
||
// Always populated by defaults.
|
||
|
||
if (
|
||
construct.name &&
|
||
context.parser.constructs.disable.null.includes(construct.name)
|
||
) {
|
||
return nok(code)
|
||
}
|
||
return construct.tokenize.call(
|
||
// If we do have fields, create an object w/ `context` as its
|
||
// prototype.
|
||
// This allows a “live binding”, which is needed for `interrupt`.
|
||
fields ? Object.assign(Object.create(context), fields) : context,
|
||
effects,
|
||
ok,
|
||
nok
|
||
)(code)
|
||
}
|
||
}
|
||
|
||
/** @type {State} */
|
||
function ok(code) {
|
||
consumed = true
|
||
onreturn(currentConstruct, info)
|
||
return returnState
|
||
}
|
||
|
||
/** @type {State} */
|
||
function nok(code) {
|
||
consumed = true
|
||
info.restore()
|
||
if (++constructIndex < listOfConstructs.length) {
|
||
return handleConstruct(listOfConstructs[constructIndex])
|
||
}
|
||
return bogusState
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {Construct} construct
|
||
* @param {number} from
|
||
* @returns {void}
|
||
*/
|
||
function addResult(construct, from) {
|
||
if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
|
||
resolveAllConstructs.push(construct)
|
||
}
|
||
if (construct.resolve) {
|
||
splice(
|
||
context.events,
|
||
from,
|
||
context.events.length - from,
|
||
construct.resolve(context.events.slice(from), context)
|
||
)
|
||
}
|
||
if (construct.resolveTo) {
|
||
context.events = construct.resolveTo(context.events, context)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Store state.
|
||
*
|
||
* @returns {Info}
|
||
*/
|
||
function store() {
|
||
const startPoint = now()
|
||
const startPrevious = context.previous
|
||
const startCurrentConstruct = context.currentConstruct
|
||
const startEventsIndex = context.events.length
|
||
const startStack = Array.from(stack)
|
||
return {
|
||
restore,
|
||
from: startEventsIndex
|
||
}
|
||
|
||
/**
|
||
* Restore state.
|
||
*
|
||
* @returns {void}
|
||
*/
|
||
function restore() {
|
||
point = startPoint
|
||
context.previous = startPrevious
|
||
context.currentConstruct = startCurrentConstruct
|
||
context.events.length = startEventsIndex
|
||
stack = startStack
|
||
accountForPotentialSkip()
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Move the current point a bit forward in the line when it’s on a column
|
||
* skip.
|
||
*
|
||
* @returns {void}
|
||
*/
|
||
function accountForPotentialSkip() {
|
||
if (point.line in columnStart && point.column < 2) {
|
||
point.column = columnStart[point.line]
|
||
point.offset += columnStart[point.line] - 1
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get the chunks from a slice of chunks in the range of a token.
|
||
*
|
||
* @param {Array<Chunk>} chunks
|
||
* @param {Pick<Token, 'end' | 'start'>} token
|
||
* @returns {Array<Chunk>}
|
||
*/
|
||
function sliceChunks(chunks, token) {
|
||
const startIndex = token.start._index
|
||
const startBufferIndex = token.start._bufferIndex
|
||
const endIndex = token.end._index
|
||
const endBufferIndex = token.end._bufferIndex
|
||
/** @type {Array<Chunk>} */
|
||
let view
|
||
if (startIndex === endIndex) {
|
||
// @ts-expect-error `_bufferIndex` is used on string chunks.
|
||
view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]
|
||
} else {
|
||
view = chunks.slice(startIndex, endIndex)
|
||
if (startBufferIndex > -1) {
|
||
const head = view[0]
|
||
if (typeof head === 'string') {
|
||
view[0] = head.slice(startBufferIndex)
|
||
} else {
|
||
view.shift()
|
||
}
|
||
}
|
||
if (endBufferIndex > 0) {
|
||
// @ts-expect-error `_bufferIndex` is used on string chunks.
|
||
view.push(chunks[endIndex].slice(0, endBufferIndex))
|
||
}
|
||
}
|
||
return view
|
||
}
|
||
|
||
/**
|
||
* Get the string value of a slice of chunks.
|
||
*
|
||
* @param {Array<Chunk>} chunks
|
||
* @param {boolean | undefined} [expandTabs=false]
|
||
* @returns {string}
|
||
*/
|
||
function serializeChunks(chunks, expandTabs) {
|
||
let index = -1
|
||
/** @type {Array<string>} */
|
||
const result = []
|
||
/** @type {boolean | undefined} */
|
||
let atTab
|
||
while (++index < chunks.length) {
|
||
const chunk = chunks[index]
|
||
/** @type {string} */
|
||
let value
|
||
if (typeof chunk === 'string') {
|
||
value = chunk
|
||
} else
|
||
switch (chunk) {
|
||
case -5: {
|
||
value = '\r'
|
||
break
|
||
}
|
||
case -4: {
|
||
value = '\n'
|
||
break
|
||
}
|
||
case -3: {
|
||
value = '\r' + '\n'
|
||
break
|
||
}
|
||
case -2: {
|
||
value = expandTabs ? ' ' : '\t'
|
||
break
|
||
}
|
||
case -1: {
|
||
if (!expandTabs && atTab) continue
|
||
value = ' '
|
||
break
|
||
}
|
||
default: {
|
||
// Currently only replacement character.
|
||
value = String.fromCharCode(chunk)
|
||
}
|
||
}
|
||
atTab = chunk === -2
|
||
result.push(value)
|
||
}
|
||
return result.join('')
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/thematic-break.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const thematicBreak = {
|
||
name: 'thematicBreak',
|
||
tokenize: tokenizeThematicBreak
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeThematicBreak(effects, ok, nok) {
|
||
let size = 0
|
||
/** @type {NonNullable<Code>} */
|
||
let marker
|
||
return start
|
||
|
||
/**
|
||
* Start of thematic break.
|
||
*
|
||
* ```markdown
|
||
* > | ***
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('thematicBreak')
|
||
// To do: parse indent like `markdown-rs`.
|
||
return before(code)
|
||
}
|
||
|
||
/**
|
||
* After optional whitespace, at marker.
|
||
*
|
||
* ```markdown
|
||
* > | ***
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function before(code) {
|
||
marker = code
|
||
return atBreak(code)
|
||
}
|
||
|
||
/**
|
||
* After something, before something else.
|
||
*
|
||
* ```markdown
|
||
* > | ***
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function atBreak(code) {
|
||
if (code === marker) {
|
||
effects.enter('thematicBreakSequence')
|
||
return sequence(code)
|
||
}
|
||
if (size >= 3 && (code === null || markdownLineEnding(code))) {
|
||
effects.exit('thematicBreak')
|
||
return ok(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In sequence.
|
||
*
|
||
* ```markdown
|
||
* > | ***
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequence(code) {
|
||
if (code === marker) {
|
||
effects.consume(code)
|
||
size++
|
||
return sequence
|
||
}
|
||
effects.exit('thematicBreakSequence')
|
||
return markdownSpace(code)
|
||
? factorySpace(effects, atBreak, 'whitespace')(code)
|
||
: atBreak(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/list.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').ContainerState} ContainerState
|
||
* @typedef {import('micromark-util-types').Exiter} Exiter
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const list = {
|
||
name: 'list',
|
||
tokenize: tokenizeListStart,
|
||
continuation: {
|
||
tokenize: tokenizeListContinuation
|
||
},
|
||
exit: tokenizeListEnd
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const listItemPrefixWhitespaceConstruct = {
|
||
tokenize: tokenizeListItemPrefixWhitespace,
|
||
partial: true
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const indentConstruct = {
|
||
tokenize: tokenizeIndent,
|
||
partial: true
|
||
}
|
||
|
||
// To do: `markdown-rs` parses list items on their own and later stitches them
|
||
// together.
|
||
|
||
/**
|
||
* @type {Tokenizer}
|
||
* @this {TokenizeContext}
|
||
*/
|
||
function tokenizeListStart(effects, ok, nok) {
|
||
const self = this
|
||
const tail = self.events[self.events.length - 1]
|
||
let initialSize =
|
||
tail && tail[1].type === 'linePrefix'
|
||
? tail[2].sliceSerialize(tail[1], true).length
|
||
: 0
|
||
let size = 0
|
||
return start
|
||
|
||
/** @type {State} */
|
||
function start(code) {
|
||
const kind =
|
||
self.containerState.type ||
|
||
(code === 42 || code === 43 || code === 45
|
||
? 'listUnordered'
|
||
: 'listOrdered')
|
||
if (
|
||
kind === 'listUnordered'
|
||
? !self.containerState.marker || code === self.containerState.marker
|
||
: asciiDigit(code)
|
||
) {
|
||
if (!self.containerState.type) {
|
||
self.containerState.type = kind
|
||
effects.enter(kind, {
|
||
_container: true
|
||
})
|
||
}
|
||
if (kind === 'listUnordered') {
|
||
effects.enter('listItemPrefix')
|
||
return code === 42 || code === 45
|
||
? effects.check(thematicBreak, nok, atMarker)(code)
|
||
: atMarker(code)
|
||
}
|
||
if (!self.interrupt || code === 49) {
|
||
effects.enter('listItemPrefix')
|
||
effects.enter('listItemValue')
|
||
return inside(code)
|
||
}
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function inside(code) {
|
||
if (asciiDigit(code) && ++size < 10) {
|
||
effects.consume(code)
|
||
return inside
|
||
}
|
||
if (
|
||
(!self.interrupt || size < 2) &&
|
||
(self.containerState.marker
|
||
? code === self.containerState.marker
|
||
: code === 41 || code === 46)
|
||
) {
|
||
effects.exit('listItemValue')
|
||
return atMarker(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* @type {State}
|
||
**/
|
||
function atMarker(code) {
|
||
effects.enter('listItemMarker')
|
||
effects.consume(code)
|
||
effects.exit('listItemMarker')
|
||
self.containerState.marker = self.containerState.marker || code
|
||
return effects.check(
|
||
blankLine,
|
||
// Can’t be empty when interrupting.
|
||
self.interrupt ? nok : onBlank,
|
||
effects.attempt(
|
||
listItemPrefixWhitespaceConstruct,
|
||
endOfPrefix,
|
||
otherPrefix
|
||
)
|
||
)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function onBlank(code) {
|
||
self.containerState.initialBlankLine = true
|
||
initialSize++
|
||
return endOfPrefix(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function otherPrefix(code) {
|
||
if (markdownSpace(code)) {
|
||
effects.enter('listItemPrefixWhitespace')
|
||
effects.consume(code)
|
||
effects.exit('listItemPrefixWhitespace')
|
||
return endOfPrefix
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function endOfPrefix(code) {
|
||
self.containerState.size =
|
||
initialSize +
|
||
self.sliceSerialize(effects.exit('listItemPrefix'), true).length
|
||
return ok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @type {Tokenizer}
|
||
* @this {TokenizeContext}
|
||
*/
|
||
function tokenizeListContinuation(effects, ok, nok) {
|
||
const self = this
|
||
self.containerState._closeFlow = undefined
|
||
return effects.check(blankLine, onBlank, notBlank)
|
||
|
||
/** @type {State} */
|
||
function onBlank(code) {
|
||
self.containerState.furtherBlankLines =
|
||
self.containerState.furtherBlankLines ||
|
||
self.containerState.initialBlankLine
|
||
|
||
// We have a blank line.
|
||
// Still, try to consume at most the items size.
|
||
return factorySpace(
|
||
effects,
|
||
ok,
|
||
'listItemIndent',
|
||
self.containerState.size + 1
|
||
)(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function notBlank(code) {
|
||
if (self.containerState.furtherBlankLines || !markdownSpace(code)) {
|
||
self.containerState.furtherBlankLines = undefined
|
||
self.containerState.initialBlankLine = undefined
|
||
return notInCurrentItem(code)
|
||
}
|
||
self.containerState.furtherBlankLines = undefined
|
||
self.containerState.initialBlankLine = undefined
|
||
return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)
|
||
}
|
||
|
||
/** @type {State} */
|
||
function notInCurrentItem(code) {
|
||
// While we do continue, we signal that the flow should be closed.
|
||
self.containerState._closeFlow = true
|
||
// As we’re closing flow, we’re no longer interrupting.
|
||
self.interrupt = undefined
|
||
// Always populated by defaults.
|
||
|
||
return factorySpace(
|
||
effects,
|
||
effects.attempt(list, ok, nok),
|
||
'linePrefix',
|
||
self.parser.constructs.disable.null.includes('codeIndented')
|
||
? undefined
|
||
: 4
|
||
)(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @type {Tokenizer}
|
||
* @this {TokenizeContext}
|
||
*/
|
||
function tokenizeIndent(effects, ok, nok) {
|
||
const self = this
|
||
return factorySpace(
|
||
effects,
|
||
afterPrefix,
|
||
'listItemIndent',
|
||
self.containerState.size + 1
|
||
)
|
||
|
||
/** @type {State} */
|
||
function afterPrefix(code) {
|
||
const tail = self.events[self.events.length - 1]
|
||
return tail &&
|
||
tail[1].type === 'listItemIndent' &&
|
||
tail[2].sliceSerialize(tail[1], true).length === self.containerState.size
|
||
? ok(code)
|
||
: nok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @type {Exiter}
|
||
* @this {TokenizeContext}
|
||
*/
|
||
function tokenizeListEnd(effects) {
|
||
effects.exit(this.containerState.type)
|
||
}
|
||
|
||
/**
|
||
* @type {Tokenizer}
|
||
* @this {TokenizeContext}
|
||
*/
|
||
function tokenizeListItemPrefixWhitespace(effects, ok, nok) {
|
||
const self = this
|
||
|
||
// Always populated by defaults.
|
||
|
||
return factorySpace(
|
||
effects,
|
||
afterPrefix,
|
||
'listItemPrefixWhitespace',
|
||
self.parser.constructs.disable.null.includes('codeIndented')
|
||
? undefined
|
||
: 4 + 1
|
||
)
|
||
|
||
/** @type {State} */
|
||
function afterPrefix(code) {
|
||
const tail = self.events[self.events.length - 1]
|
||
return !markdownSpace(code) &&
|
||
tail &&
|
||
tail[1].type === 'listItemPrefixWhitespace'
|
||
? ok(code)
|
||
: nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/block-quote.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Exiter} Exiter
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const blockQuote = {
|
||
name: 'blockQuote',
|
||
tokenize: tokenizeBlockQuoteStart,
|
||
continuation: {
|
||
tokenize: tokenizeBlockQuoteContinuation
|
||
},
|
||
exit
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeBlockQuoteStart(effects, ok, nok) {
|
||
const self = this
|
||
return start
|
||
|
||
/**
|
||
* Start of block quote.
|
||
*
|
||
* ```markdown
|
||
* > | > a
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
if (code === 62) {
|
||
const state = self.containerState
|
||
if (!state.open) {
|
||
effects.enter('blockQuote', {
|
||
_container: true
|
||
})
|
||
state.open = true
|
||
}
|
||
effects.enter('blockQuotePrefix')
|
||
effects.enter('blockQuoteMarker')
|
||
effects.consume(code)
|
||
effects.exit('blockQuoteMarker')
|
||
return after
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `>`, before optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | > a
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
if (markdownSpace(code)) {
|
||
effects.enter('blockQuotePrefixWhitespace')
|
||
effects.consume(code)
|
||
effects.exit('blockQuotePrefixWhitespace')
|
||
effects.exit('blockQuotePrefix')
|
||
return ok
|
||
}
|
||
effects.exit('blockQuotePrefix')
|
||
return ok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Start of block quote continuation.
|
||
*
|
||
* ```markdown
|
||
* | > a
|
||
* > | > b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeBlockQuoteContinuation(effects, ok, nok) {
|
||
const self = this
|
||
return contStart
|
||
|
||
/**
|
||
* Start of block quote continuation.
|
||
*
|
||
* Also used to parse the first block quote opening.
|
||
*
|
||
* ```markdown
|
||
* | > a
|
||
* > | > b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function contStart(code) {
|
||
if (markdownSpace(code)) {
|
||
// Always populated by defaults.
|
||
|
||
return factorySpace(
|
||
effects,
|
||
contBefore,
|
||
'linePrefix',
|
||
self.parser.constructs.disable.null.includes('codeIndented')
|
||
? undefined
|
||
: 4
|
||
)(code)
|
||
}
|
||
return contBefore(code)
|
||
}
|
||
|
||
/**
|
||
* At `>`, after optional whitespace.
|
||
*
|
||
* Also used to parse the first block quote opening.
|
||
*
|
||
* ```markdown
|
||
* | > a
|
||
* > | > b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function contBefore(code) {
|
||
return effects.attempt(blockQuote, ok, nok)(code)
|
||
}
|
||
}
|
||
|
||
/** @type {Exiter} */
|
||
function exit(effects) {
|
||
effects.exit('blockQuote')
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-factory-destination/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Effects} Effects
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenType} TokenType
|
||
*/
|
||
|
||
|
||
/**
|
||
* Parse destinations.
|
||
*
|
||
* ###### Examples
|
||
*
|
||
* ```markdown
|
||
* <a>
|
||
* <a\>b>
|
||
* <a b>
|
||
* <a)>
|
||
* a
|
||
* a\)b
|
||
* a(b)c
|
||
* a(b)
|
||
* ```
|
||
*
|
||
* @param {Effects} effects
|
||
* Context.
|
||
* @param {State} ok
|
||
* State switched to when successful.
|
||
* @param {State} nok
|
||
* State switched to when unsuccessful.
|
||
* @param {TokenType} type
|
||
* Type for whole (`<a>` or `b`).
|
||
* @param {TokenType} literalType
|
||
* Type when enclosed (`<a>`).
|
||
* @param {TokenType} literalMarkerType
|
||
* Type for enclosing (`<` and `>`).
|
||
* @param {TokenType} rawType
|
||
* Type when not enclosed (`b`).
|
||
* @param {TokenType} stringType
|
||
* Type for the value (`a` or `b`).
|
||
* @param {number | undefined} [max=Infinity]
|
||
* Depth of nested parens (inclusive).
|
||
* @returns {State}
|
||
* Start state.
|
||
*/ // eslint-disable-next-line max-params
|
||
function factoryDestination(
|
||
effects,
|
||
ok,
|
||
nok,
|
||
type,
|
||
literalType,
|
||
literalMarkerType,
|
||
rawType,
|
||
stringType,
|
||
max
|
||
) {
|
||
const limit = max || Number.POSITIVE_INFINITY
|
||
let balance = 0
|
||
return start
|
||
|
||
/**
|
||
* Start of destination.
|
||
*
|
||
* ```markdown
|
||
* > | <aa>
|
||
* ^
|
||
* > | aa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
if (code === 60) {
|
||
effects.enter(type)
|
||
effects.enter(literalType)
|
||
effects.enter(literalMarkerType)
|
||
effects.consume(code)
|
||
effects.exit(literalMarkerType)
|
||
return enclosedBefore
|
||
}
|
||
|
||
// ASCII control, space, closing paren.
|
||
if (code === null || code === 32 || code === 41 || asciiControl(code)) {
|
||
return nok(code)
|
||
}
|
||
effects.enter(type)
|
||
effects.enter(rawType)
|
||
effects.enter(stringType)
|
||
effects.enter('chunkString', {
|
||
contentType: 'string'
|
||
})
|
||
return raw(code)
|
||
}
|
||
|
||
/**
|
||
* After `<`, at an enclosed destination.
|
||
*
|
||
* ```markdown
|
||
* > | <aa>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function enclosedBefore(code) {
|
||
if (code === 62) {
|
||
effects.enter(literalMarkerType)
|
||
effects.consume(code)
|
||
effects.exit(literalMarkerType)
|
||
effects.exit(literalType)
|
||
effects.exit(type)
|
||
return ok
|
||
}
|
||
effects.enter(stringType)
|
||
effects.enter('chunkString', {
|
||
contentType: 'string'
|
||
})
|
||
return enclosed(code)
|
||
}
|
||
|
||
/**
|
||
* In enclosed destination.
|
||
*
|
||
* ```markdown
|
||
* > | <aa>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function enclosed(code) {
|
||
if (code === 62) {
|
||
effects.exit('chunkString')
|
||
effects.exit(stringType)
|
||
return enclosedBefore(code)
|
||
}
|
||
if (code === null || code === 60 || markdownLineEnding(code)) {
|
||
return nok(code)
|
||
}
|
||
effects.consume(code)
|
||
return code === 92 ? enclosedEscape : enclosed
|
||
}
|
||
|
||
/**
|
||
* After `\`, at a special character.
|
||
*
|
||
* ```markdown
|
||
* > | <a\*a>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function enclosedEscape(code) {
|
||
if (code === 60 || code === 62 || code === 92) {
|
||
effects.consume(code)
|
||
return enclosed
|
||
}
|
||
return enclosed(code)
|
||
}
|
||
|
||
/**
|
||
* In raw destination.
|
||
*
|
||
* ```markdown
|
||
* > | aa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function raw(code) {
|
||
if (
|
||
!balance &&
|
||
(code === null || code === 41 || markdownLineEndingOrSpace(code))
|
||
) {
|
||
effects.exit('chunkString')
|
||
effects.exit(stringType)
|
||
effects.exit(rawType)
|
||
effects.exit(type)
|
||
return ok(code)
|
||
}
|
||
if (balance < limit && code === 40) {
|
||
effects.consume(code)
|
||
balance++
|
||
return raw
|
||
}
|
||
if (code === 41) {
|
||
effects.consume(code)
|
||
balance--
|
||
return raw
|
||
}
|
||
|
||
// ASCII control (but *not* `\0`) and space and `(`.
|
||
// Note: in `markdown-rs`, `\0` exists in codes, in `micromark-js` it
|
||
// doesn’t.
|
||
if (code === null || code === 32 || code === 40 || asciiControl(code)) {
|
||
return nok(code)
|
||
}
|
||
effects.consume(code)
|
||
return code === 92 ? rawEscape : raw
|
||
}
|
||
|
||
/**
|
||
* After `\`, at special character.
|
||
*
|
||
* ```markdown
|
||
* > | a\*a
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function rawEscape(code) {
|
||
if (code === 40 || code === 41 || code === 92) {
|
||
effects.consume(code)
|
||
return raw
|
||
}
|
||
return raw(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-factory-label/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Effects} Effects
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').TokenType} TokenType
|
||
*/
|
||
|
||
|
||
/**
|
||
* Parse labels.
|
||
*
|
||
* > 👉 **Note**: labels in markdown are capped at 999 characters in the string.
|
||
*
|
||
* ###### Examples
|
||
*
|
||
* ```markdown
|
||
* [a]
|
||
* [a
|
||
* b]
|
||
* [a\]b]
|
||
* ```
|
||
*
|
||
* @this {TokenizeContext}
|
||
* Tokenize context.
|
||
* @param {Effects} effects
|
||
* Context.
|
||
* @param {State} ok
|
||
* State switched to when successful.
|
||
* @param {State} nok
|
||
* State switched to when unsuccessful.
|
||
* @param {TokenType} type
|
||
* Type of the whole label (`[a]`).
|
||
* @param {TokenType} markerType
|
||
* Type for the markers (`[` and `]`).
|
||
* @param {TokenType} stringType
|
||
* Type for the identifier (`a`).
|
||
* @returns {State}
|
||
* Start state.
|
||
*/ // eslint-disable-next-line max-params
|
||
function factoryLabel(effects, ok, nok, type, markerType, stringType) {
|
||
const self = this
|
||
let size = 0
|
||
/** @type {boolean} */
|
||
let seen
|
||
return start
|
||
|
||
/**
|
||
* Start of label.
|
||
*
|
||
* ```markdown
|
||
* > | [a]
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter(type)
|
||
effects.enter(markerType)
|
||
effects.consume(code)
|
||
effects.exit(markerType)
|
||
effects.enter(stringType)
|
||
return atBreak
|
||
}
|
||
|
||
/**
|
||
* In label, at something, before something else.
|
||
*
|
||
* ```markdown
|
||
* > | [a]
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function atBreak(code) {
|
||
if (
|
||
size > 999 ||
|
||
code === null ||
|
||
code === 91 ||
|
||
(code === 93 && !seen) ||
|
||
// To do: remove in the future once we’ve switched from
|
||
// `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,
|
||
// which doesn’t need this.
|
||
// Hidden footnotes hook.
|
||
/* c8 ignore next 3 */
|
||
(code === 94 &&
|
||
!size &&
|
||
'_hiddenFootnoteSupport' in self.parser.constructs)
|
||
) {
|
||
return nok(code)
|
||
}
|
||
if (code === 93) {
|
||
effects.exit(stringType)
|
||
effects.enter(markerType)
|
||
effects.consume(code)
|
||
effects.exit(markerType)
|
||
effects.exit(type)
|
||
return ok
|
||
}
|
||
|
||
// To do: indent? Link chunks and EOLs together?
|
||
if (markdownLineEnding(code)) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return atBreak
|
||
}
|
||
effects.enter('chunkString', {
|
||
contentType: 'string'
|
||
})
|
||
return labelInside(code)
|
||
}
|
||
|
||
/**
|
||
* In label, in text.
|
||
*
|
||
* ```markdown
|
||
* > | [a]
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function labelInside(code) {
|
||
if (
|
||
code === null ||
|
||
code === 91 ||
|
||
code === 93 ||
|
||
markdownLineEnding(code) ||
|
||
size++ > 999
|
||
) {
|
||
effects.exit('chunkString')
|
||
return atBreak(code)
|
||
}
|
||
effects.consume(code)
|
||
if (!seen) seen = !markdownSpace(code)
|
||
return code === 92 ? labelEscape : labelInside
|
||
}
|
||
|
||
/**
|
||
* After `\`, at a special character.
|
||
*
|
||
* ```markdown
|
||
* > | [a\*a]
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function labelEscape(code) {
|
||
if (code === 91 || code === 92 || code === 93) {
|
||
effects.consume(code)
|
||
size++
|
||
return labelInside
|
||
}
|
||
return labelInside(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-factory-title/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Effects} Effects
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenType} TokenType
|
||
*/
|
||
|
||
|
||
|
||
/**
|
||
* Parse titles.
|
||
*
|
||
* ###### Examples
|
||
*
|
||
* ```markdown
|
||
* "a"
|
||
* 'b'
|
||
* (c)
|
||
* "a
|
||
* b"
|
||
* 'a
|
||
* b'
|
||
* (a\)b)
|
||
* ```
|
||
*
|
||
* @param {Effects} effects
|
||
* Context.
|
||
* @param {State} ok
|
||
* State switched to when successful.
|
||
* @param {State} nok
|
||
* State switched to when unsuccessful.
|
||
* @param {TokenType} type
|
||
* Type of the whole title (`"a"`, `'b'`, `(c)`).
|
||
* @param {TokenType} markerType
|
||
* Type for the markers (`"`, `'`, `(`, and `)`).
|
||
* @param {TokenType} stringType
|
||
* Type for the value (`a`).
|
||
* @returns {State}
|
||
* Start state.
|
||
*/ // eslint-disable-next-line max-params
|
||
function factoryTitle(effects, ok, nok, type, markerType, stringType) {
|
||
/** @type {NonNullable<Code>} */
|
||
let marker
|
||
return start
|
||
|
||
/**
|
||
* Start of title.
|
||
*
|
||
* ```markdown
|
||
* > | "a"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
if (code === 34 || code === 39 || code === 40) {
|
||
effects.enter(type)
|
||
effects.enter(markerType)
|
||
effects.consume(code)
|
||
effects.exit(markerType)
|
||
marker = code === 40 ? 41 : code
|
||
return begin
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After opening marker.
|
||
*
|
||
* This is also used at the closing marker.
|
||
*
|
||
* ```markdown
|
||
* > | "a"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function begin(code) {
|
||
if (code === marker) {
|
||
effects.enter(markerType)
|
||
effects.consume(code)
|
||
effects.exit(markerType)
|
||
effects.exit(type)
|
||
return ok
|
||
}
|
||
effects.enter(stringType)
|
||
return atBreak(code)
|
||
}
|
||
|
||
/**
|
||
* At something, before something else.
|
||
*
|
||
* ```markdown
|
||
* > | "a"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function atBreak(code) {
|
||
if (code === marker) {
|
||
effects.exit(stringType)
|
||
return begin(marker)
|
||
}
|
||
if (code === null) {
|
||
return nok(code)
|
||
}
|
||
|
||
// Note: blank lines can’t exist in content.
|
||
if (markdownLineEnding(code)) {
|
||
// To do: use `space_or_tab_eol_with_options`, connect.
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return factorySpace(effects, atBreak, 'linePrefix')
|
||
}
|
||
effects.enter('chunkString', {
|
||
contentType: 'string'
|
||
})
|
||
return inside(code)
|
||
}
|
||
|
||
/**
|
||
*
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function inside(code) {
|
||
if (code === marker || code === null || markdownLineEnding(code)) {
|
||
effects.exit('chunkString')
|
||
return atBreak(code)
|
||
}
|
||
effects.consume(code)
|
||
return code === 92 ? escape : inside
|
||
}
|
||
|
||
/**
|
||
* After `\`, at a special character.
|
||
*
|
||
* ```markdown
|
||
* > | "a\*b"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function escape(code) {
|
||
if (code === marker || code === 92) {
|
||
effects.consume(code)
|
||
return inside
|
||
}
|
||
return inside(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-factory-whitespace/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Effects} Effects
|
||
* @typedef {import('micromark-util-types').State} State
|
||
*/
|
||
|
||
|
||
|
||
/**
|
||
* Parse spaces and tabs.
|
||
*
|
||
* There is no `nok` parameter:
|
||
*
|
||
* * line endings or spaces in markdown are often optional, in which case this
|
||
* factory can be used and `ok` will be switched to whether spaces were found
|
||
* or not
|
||
* * one line ending or space can be detected with
|
||
* `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`
|
||
*
|
||
* @param {Effects} effects
|
||
* Context.
|
||
* @param {State} ok
|
||
* State switched to when successful.
|
||
* @returns
|
||
* Start state.
|
||
*/
|
||
function factoryWhitespace(effects, ok) {
|
||
/** @type {boolean} */
|
||
let seen
|
||
return start
|
||
|
||
/** @type {State} */
|
||
function start(code) {
|
||
if (markdownLineEnding(code)) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
seen = true
|
||
return start
|
||
}
|
||
if (markdownSpace(code)) {
|
||
return factorySpace(
|
||
effects,
|
||
start,
|
||
seen ? 'linePrefix' : 'lineSuffix'
|
||
)(code)
|
||
}
|
||
return ok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-normalize-identifier/index.js
|
||
/**
|
||
* Normalize an identifier (as found in references, definitions).
|
||
*
|
||
* Collapses markdown whitespace, trim, and then lower- and uppercase.
|
||
*
|
||
* Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their
|
||
* lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different
|
||
* uppercase character (U+0398 (`Θ`)).
|
||
* So, to get a canonical form, we perform both lower- and uppercase.
|
||
*
|
||
* Using uppercase last makes sure keys will never interact with default
|
||
* prototypal values (such as `constructor`): nothing in the prototype of
|
||
* `Object` is uppercase.
|
||
*
|
||
* @param {string} value
|
||
* Identifier to normalize.
|
||
* @returns {string}
|
||
* Normalized identifier.
|
||
*/
|
||
function normalizeIdentifier(value) {
|
||
return (
|
||
value
|
||
// Collapse markdown whitespace.
|
||
.replace(/[\t\n\r ]+/g, ' ')
|
||
// Trim.
|
||
.replace(/^ | $/g, '')
|
||
// Some characters are considered “uppercase”, but if their lowercase
|
||
// counterpart is uppercased will result in a different uppercase
|
||
// character.
|
||
// Hence, to get that form, we perform both lower- and uppercase.
|
||
// Upper case makes sure keys will not interact with default prototypal
|
||
// methods: no method is uppercase.
|
||
.toLowerCase()
|
||
.toUpperCase()
|
||
)
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/definition.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const definition = {
|
||
name: 'definition',
|
||
tokenize: tokenizeDefinition
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const titleBefore = {
|
||
tokenize: tokenizeTitleBefore,
|
||
partial: true
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeDefinition(effects, ok, nok) {
|
||
const self = this
|
||
/** @type {string} */
|
||
let identifier
|
||
return start
|
||
|
||
/**
|
||
* At start of a definition.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
// Do not interrupt paragraphs (but do follow definitions).
|
||
// To do: do `interrupt` the way `markdown-rs` does.
|
||
// To do: parse whitespace the way `markdown-rs` does.
|
||
effects.enter('definition')
|
||
return before(code)
|
||
}
|
||
|
||
/**
|
||
* After optional whitespace, at `[`.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function before(code) {
|
||
// To do: parse whitespace the way `markdown-rs` does.
|
||
|
||
return factoryLabel.call(
|
||
self,
|
||
effects,
|
||
labelAfter,
|
||
// Note: we don’t need to reset the way `markdown-rs` does.
|
||
nok,
|
||
'definitionLabel',
|
||
'definitionLabelMarker',
|
||
'definitionLabelString'
|
||
)(code)
|
||
}
|
||
|
||
/**
|
||
* After label.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function labelAfter(code) {
|
||
identifier = normalizeIdentifier(
|
||
self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
|
||
)
|
||
if (code === 58) {
|
||
effects.enter('definitionMarker')
|
||
effects.consume(code)
|
||
effects.exit('definitionMarker')
|
||
return markerAfter
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After marker.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function markerAfter(code) {
|
||
// Note: whitespace is optional.
|
||
return markdownLineEndingOrSpace(code)
|
||
? factoryWhitespace(effects, destinationBefore)(code)
|
||
: destinationBefore(code)
|
||
}
|
||
|
||
/**
|
||
* Before destination.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function destinationBefore(code) {
|
||
return factoryDestination(
|
||
effects,
|
||
destinationAfter,
|
||
// Note: we don’t need to reset the way `markdown-rs` does.
|
||
nok,
|
||
'definitionDestination',
|
||
'definitionDestinationLiteral',
|
||
'definitionDestinationLiteralMarker',
|
||
'definitionDestinationRaw',
|
||
'definitionDestinationString'
|
||
)(code)
|
||
}
|
||
|
||
/**
|
||
* After destination.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function destinationAfter(code) {
|
||
return effects.attempt(titleBefore, after, after)(code)
|
||
}
|
||
|
||
/**
|
||
* After definition.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b
|
||
* ^
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
return markdownSpace(code)
|
||
? factorySpace(effects, afterWhitespace, 'whitespace')(code)
|
||
: afterWhitespace(code)
|
||
}
|
||
|
||
/**
|
||
* After definition, after optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b
|
||
* ^
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function afterWhitespace(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('definition')
|
||
|
||
// Note: we don’t care about uniqueness.
|
||
// It’s likely that that doesn’t happen very frequently.
|
||
// It is more likely that it wastes precious time.
|
||
self.parser.defined.push(identifier)
|
||
|
||
// To do: `markdown-rs` interrupt.
|
||
// // You’d be interrupting.
|
||
// tokenizer.interrupt = true
|
||
return ok(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeTitleBefore(effects, ok, nok) {
|
||
return titleBefore
|
||
|
||
/**
|
||
* After destination, at whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b
|
||
* ^
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function titleBefore(code) {
|
||
return markdownLineEndingOrSpace(code)
|
||
? factoryWhitespace(effects, beforeMarker)(code)
|
||
: nok(code)
|
||
}
|
||
|
||
/**
|
||
* At title.
|
||
*
|
||
* ```markdown
|
||
* | [a]: b
|
||
* > | "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function beforeMarker(code) {
|
||
return factoryTitle(
|
||
effects,
|
||
titleAfter,
|
||
nok,
|
||
'definitionTitle',
|
||
'definitionTitleMarker',
|
||
'definitionTitleString'
|
||
)(code)
|
||
}
|
||
|
||
/**
|
||
* After title.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function titleAfter(code) {
|
||
return markdownSpace(code)
|
||
? factorySpace(effects, titleAfterOptionalWhitespace, 'whitespace')(code)
|
||
: titleAfterOptionalWhitespace(code)
|
||
}
|
||
|
||
/**
|
||
* After title, after optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | [a]: b "c"
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function titleAfterOptionalWhitespace(code) {
|
||
return code === null || markdownLineEnding(code) ? ok(code) : nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/code-indented.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const codeIndented = {
|
||
name: 'codeIndented',
|
||
tokenize: tokenizeCodeIndented
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const furtherStart = {
|
||
tokenize: tokenizeFurtherStart,
|
||
partial: true
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeCodeIndented(effects, ok, nok) {
|
||
const self = this
|
||
return start
|
||
|
||
/**
|
||
* Start of code (indented).
|
||
*
|
||
* > **Parsing note**: it is not needed to check if this first line is a
|
||
* > filled line (that it has a non-whitespace character), because blank lines
|
||
* > are parsed already, so we never run into that.
|
||
*
|
||
* ```markdown
|
||
* > | aaa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
// To do: manually check if interrupting like `markdown-rs`.
|
||
|
||
effects.enter('codeIndented')
|
||
// To do: use an improved `space_or_tab` function like `markdown-rs`,
|
||
// so that we can drop the next state.
|
||
return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)
|
||
}
|
||
|
||
/**
|
||
* At start, after 1 or 4 spaces.
|
||
*
|
||
* ```markdown
|
||
* > | aaa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function afterPrefix(code) {
|
||
const tail = self.events[self.events.length - 1]
|
||
return tail &&
|
||
tail[1].type === 'linePrefix' &&
|
||
tail[2].sliceSerialize(tail[1], true).length >= 4
|
||
? atBreak(code)
|
||
: nok(code)
|
||
}
|
||
|
||
/**
|
||
* At a break.
|
||
*
|
||
* ```markdown
|
||
* > | aaa
|
||
* ^ ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function atBreak(code) {
|
||
if (code === null) {
|
||
return after(code)
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
return effects.attempt(furtherStart, atBreak, after)(code)
|
||
}
|
||
effects.enter('codeFlowValue')
|
||
return inside(code)
|
||
}
|
||
|
||
/**
|
||
* In code content.
|
||
*
|
||
* ```markdown
|
||
* > | aaa
|
||
* ^^^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function inside(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('codeFlowValue')
|
||
return atBreak(code)
|
||
}
|
||
effects.consume(code)
|
||
return inside
|
||
}
|
||
|
||
/** @type {State} */
|
||
function after(code) {
|
||
effects.exit('codeIndented')
|
||
// To do: allow interrupting like `markdown-rs`.
|
||
// Feel free to interrupt.
|
||
// tokenizer.interrupt = false
|
||
return ok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeFurtherStart(effects, ok, nok) {
|
||
const self = this
|
||
return furtherStart
|
||
|
||
/**
|
||
* At eol, trying to parse another indent.
|
||
*
|
||
* ```markdown
|
||
* > | aaa
|
||
* ^
|
||
* | bbb
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function furtherStart(code) {
|
||
// To do: improve `lazy` / `pierce` handling.
|
||
// If this is a lazy line, it can’t be code.
|
||
if (self.parser.lazy[self.now().line]) {
|
||
return nok(code)
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return furtherStart
|
||
}
|
||
|
||
// To do: the code here in `micromark-js` is a bit different from
|
||
// `markdown-rs` because there it can attempt spaces.
|
||
// We can’t yet.
|
||
//
|
||
// To do: use an improved `space_or_tab` function like `markdown-rs`,
|
||
// so that we can drop the next state.
|
||
return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)
|
||
}
|
||
|
||
/**
|
||
* At start, after 1 or 4 spaces.
|
||
*
|
||
* ```markdown
|
||
* > | aaa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function afterPrefix(code) {
|
||
const tail = self.events[self.events.length - 1]
|
||
return tail &&
|
||
tail[1].type === 'linePrefix' &&
|
||
tail[2].sliceSerialize(tail[1], true).length >= 4
|
||
? ok(code)
|
||
: markdownLineEnding(code)
|
||
? furtherStart(code)
|
||
: nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/heading-atx.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const headingAtx = {
|
||
name: 'headingAtx',
|
||
tokenize: tokenizeHeadingAtx,
|
||
resolve: resolveHeadingAtx
|
||
}
|
||
|
||
/** @type {Resolver} */
|
||
function resolveHeadingAtx(events, context) {
|
||
let contentEnd = events.length - 2
|
||
let contentStart = 3
|
||
/** @type {Token} */
|
||
let content
|
||
/** @type {Token} */
|
||
let text
|
||
|
||
// Prefix whitespace, part of the opening.
|
||
if (events[contentStart][1].type === 'whitespace') {
|
||
contentStart += 2
|
||
}
|
||
|
||
// Suffix whitespace, part of the closing.
|
||
if (
|
||
contentEnd - 2 > contentStart &&
|
||
events[contentEnd][1].type === 'whitespace'
|
||
) {
|
||
contentEnd -= 2
|
||
}
|
||
if (
|
||
events[contentEnd][1].type === 'atxHeadingSequence' &&
|
||
(contentStart === contentEnd - 1 ||
|
||
(contentEnd - 4 > contentStart &&
|
||
events[contentEnd - 2][1].type === 'whitespace'))
|
||
) {
|
||
contentEnd -= contentStart + 1 === contentEnd ? 2 : 4
|
||
}
|
||
if (contentEnd > contentStart) {
|
||
content = {
|
||
type: 'atxHeadingText',
|
||
start: events[contentStart][1].start,
|
||
end: events[contentEnd][1].end
|
||
}
|
||
text = {
|
||
type: 'chunkText',
|
||
start: events[contentStart][1].start,
|
||
end: events[contentEnd][1].end,
|
||
contentType: 'text'
|
||
}
|
||
splice(events, contentStart, contentEnd - contentStart + 1, [
|
||
['enter', content, context],
|
||
['enter', text, context],
|
||
['exit', text, context],
|
||
['exit', content, context]
|
||
])
|
||
}
|
||
return events
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeHeadingAtx(effects, ok, nok) {
|
||
let size = 0
|
||
return start
|
||
|
||
/**
|
||
* Start of a heading (atx).
|
||
*
|
||
* ```markdown
|
||
* > | ## aa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
// To do: parse indent like `markdown-rs`.
|
||
effects.enter('atxHeading')
|
||
return before(code)
|
||
}
|
||
|
||
/**
|
||
* After optional whitespace, at `#`.
|
||
*
|
||
* ```markdown
|
||
* > | ## aa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function before(code) {
|
||
effects.enter('atxHeadingSequence')
|
||
return sequenceOpen(code)
|
||
}
|
||
|
||
/**
|
||
* In opening sequence.
|
||
*
|
||
* ```markdown
|
||
* > | ## aa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceOpen(code) {
|
||
if (code === 35 && size++ < 6) {
|
||
effects.consume(code)
|
||
return sequenceOpen
|
||
}
|
||
|
||
// Always at least one `#`.
|
||
if (code === null || markdownLineEndingOrSpace(code)) {
|
||
effects.exit('atxHeadingSequence')
|
||
return atBreak(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After something, before something else.
|
||
*
|
||
* ```markdown
|
||
* > | ## aa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function atBreak(code) {
|
||
if (code === 35) {
|
||
effects.enter('atxHeadingSequence')
|
||
return sequenceFurther(code)
|
||
}
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('atxHeading')
|
||
// To do: interrupt like `markdown-rs`.
|
||
// // Feel free to interrupt.
|
||
// tokenizer.interrupt = false
|
||
return ok(code)
|
||
}
|
||
if (markdownSpace(code)) {
|
||
return factorySpace(effects, atBreak, 'whitespace')(code)
|
||
}
|
||
|
||
// To do: generate `data` tokens, add the `text` token later.
|
||
// Needs edit map, see: `markdown.rs`.
|
||
effects.enter('atxHeadingText')
|
||
return data(code)
|
||
}
|
||
|
||
/**
|
||
* In further sequence (after whitespace).
|
||
*
|
||
* Could be normal “visible” hashes in the heading or a final sequence.
|
||
*
|
||
* ```markdown
|
||
* > | ## aa ##
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceFurther(code) {
|
||
if (code === 35) {
|
||
effects.consume(code)
|
||
return sequenceFurther
|
||
}
|
||
effects.exit('atxHeadingSequence')
|
||
return atBreak(code)
|
||
}
|
||
|
||
/**
|
||
* In text.
|
||
*
|
||
* ```markdown
|
||
* > | ## aa
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function data(code) {
|
||
if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {
|
||
effects.exit('atxHeadingText')
|
||
return atBreak(code)
|
||
}
|
||
effects.consume(code)
|
||
return data
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/setext-underline.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const setextUnderline = {
|
||
name: 'setextUnderline',
|
||
tokenize: tokenizeSetextUnderline,
|
||
resolveTo: resolveToSetextUnderline
|
||
}
|
||
|
||
/** @type {Resolver} */
|
||
function resolveToSetextUnderline(events, context) {
|
||
// To do: resolve like `markdown-rs`.
|
||
let index = events.length
|
||
/** @type {number | undefined} */
|
||
let content
|
||
/** @type {number | undefined} */
|
||
let text
|
||
/** @type {number | undefined} */
|
||
let definition
|
||
|
||
// Find the opening of the content.
|
||
// It’ll always exist: we don’t tokenize if it isn’t there.
|
||
while (index--) {
|
||
if (events[index][0] === 'enter') {
|
||
if (events[index][1].type === 'content') {
|
||
content = index
|
||
break
|
||
}
|
||
if (events[index][1].type === 'paragraph') {
|
||
text = index
|
||
}
|
||
}
|
||
// Exit
|
||
else {
|
||
if (events[index][1].type === 'content') {
|
||
// Remove the content end (if needed we’ll add it later)
|
||
events.splice(index, 1)
|
||
}
|
||
if (!definition && events[index][1].type === 'definition') {
|
||
definition = index
|
||
}
|
||
}
|
||
}
|
||
const heading = {
|
||
type: 'setextHeading',
|
||
start: Object.assign({}, events[text][1].start),
|
||
end: Object.assign({}, events[events.length - 1][1].end)
|
||
}
|
||
|
||
// Change the paragraph to setext heading text.
|
||
events[text][1].type = 'setextHeadingText'
|
||
|
||
// If we have definitions in the content, we’ll keep on having content,
|
||
// but we need move it.
|
||
if (definition) {
|
||
events.splice(text, 0, ['enter', heading, context])
|
||
events.splice(definition + 1, 0, ['exit', events[content][1], context])
|
||
events[content][1].end = Object.assign({}, events[definition][1].end)
|
||
} else {
|
||
events[content][1] = heading
|
||
}
|
||
|
||
// Add the heading exit at the end.
|
||
events.push(['exit', heading, context])
|
||
return events
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeSetextUnderline(effects, ok, nok) {
|
||
const self = this
|
||
/** @type {NonNullable<Code>} */
|
||
let marker
|
||
return start
|
||
|
||
/**
|
||
* At start of heading (setext) underline.
|
||
*
|
||
* ```markdown
|
||
* | aa
|
||
* > | ==
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
let index = self.events.length
|
||
/** @type {boolean | undefined} */
|
||
let paragraph
|
||
// Find an opening.
|
||
while (index--) {
|
||
// Skip enter/exit of line ending, line prefix, and content.
|
||
// We can now either have a definition or a paragraph.
|
||
if (
|
||
self.events[index][1].type !== 'lineEnding' &&
|
||
self.events[index][1].type !== 'linePrefix' &&
|
||
self.events[index][1].type !== 'content'
|
||
) {
|
||
paragraph = self.events[index][1].type === 'paragraph'
|
||
break
|
||
}
|
||
}
|
||
|
||
// To do: handle lazy/pierce like `markdown-rs`.
|
||
// To do: parse indent like `markdown-rs`.
|
||
if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {
|
||
effects.enter('setextHeadingLine')
|
||
marker = code
|
||
return before(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After optional whitespace, at `-` or `=`.
|
||
*
|
||
* ```markdown
|
||
* | aa
|
||
* > | ==
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function before(code) {
|
||
effects.enter('setextHeadingLineSequence')
|
||
return inside(code)
|
||
}
|
||
|
||
/**
|
||
* In sequence.
|
||
*
|
||
* ```markdown
|
||
* | aa
|
||
* > | ==
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function inside(code) {
|
||
if (code === marker) {
|
||
effects.consume(code)
|
||
return inside
|
||
}
|
||
effects.exit('setextHeadingLineSequence')
|
||
return markdownSpace(code)
|
||
? factorySpace(effects, after, 'lineSuffix')(code)
|
||
: after(code)
|
||
}
|
||
|
||
/**
|
||
* After sequence, after optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* | aa
|
||
* > | ==
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('setextHeadingLine')
|
||
return ok(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-html-tag-name/index.js
|
||
/**
|
||
* List of lowercase HTML “block” tag names.
|
||
*
|
||
* The list, when parsing HTML (flow), results in more relaxed rules (condition
|
||
* 6).
|
||
* Because they are known blocks, the HTML-like syntax doesn’t have to be
|
||
* strictly parsed.
|
||
* For tag names not in this list, a more strict algorithm (condition 7) is used
|
||
* to detect whether the HTML-like syntax is seen as HTML (flow) or not.
|
||
*
|
||
* This is copied from:
|
||
* <https://spec.commonmark.org/0.30/#html-blocks>.
|
||
*
|
||
* > 👉 **Note**: `search` was added in `CommonMark@0.31`.
|
||
*/
|
||
const htmlBlockNames = [
|
||
'address',
|
||
'article',
|
||
'aside',
|
||
'base',
|
||
'basefont',
|
||
'blockquote',
|
||
'body',
|
||
'caption',
|
||
'center',
|
||
'col',
|
||
'colgroup',
|
||
'dd',
|
||
'details',
|
||
'dialog',
|
||
'dir',
|
||
'div',
|
||
'dl',
|
||
'dt',
|
||
'fieldset',
|
||
'figcaption',
|
||
'figure',
|
||
'footer',
|
||
'form',
|
||
'frame',
|
||
'frameset',
|
||
'h1',
|
||
'h2',
|
||
'h3',
|
||
'h4',
|
||
'h5',
|
||
'h6',
|
||
'head',
|
||
'header',
|
||
'hr',
|
||
'html',
|
||
'iframe',
|
||
'legend',
|
||
'li',
|
||
'link',
|
||
'main',
|
||
'menu',
|
||
'menuitem',
|
||
'nav',
|
||
'noframes',
|
||
'ol',
|
||
'optgroup',
|
||
'option',
|
||
'p',
|
||
'param',
|
||
'search',
|
||
'section',
|
||
'summary',
|
||
'table',
|
||
'tbody',
|
||
'td',
|
||
'tfoot',
|
||
'th',
|
||
'thead',
|
||
'title',
|
||
'tr',
|
||
'track',
|
||
'ul'
|
||
]
|
||
|
||
/**
|
||
* List of lowercase HTML “raw” tag names.
|
||
*
|
||
* The list, when parsing HTML (flow), results in HTML that can include lines
|
||
* without exiting, until a closing tag also in this list is found (condition
|
||
* 1).
|
||
*
|
||
* This module is copied from:
|
||
* <https://spec.commonmark.org/0.30/#html-blocks>.
|
||
*
|
||
* > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.
|
||
*/
|
||
const htmlRawNames = ['pre', 'script', 'style', 'textarea']
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/html-flow.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const htmlFlow = {
|
||
name: 'htmlFlow',
|
||
tokenize: tokenizeHtmlFlow,
|
||
resolveTo: resolveToHtmlFlow,
|
||
concrete: true
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const blankLineBefore = {
|
||
tokenize: tokenizeBlankLineBefore,
|
||
partial: true
|
||
}
|
||
const nonLazyContinuationStart = {
|
||
tokenize: tokenizeNonLazyContinuationStart,
|
||
partial: true
|
||
}
|
||
|
||
/** @type {Resolver} */
|
||
function resolveToHtmlFlow(events) {
|
||
let index = events.length
|
||
while (index--) {
|
||
if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {
|
||
break
|
||
}
|
||
}
|
||
if (index > 1 && events[index - 2][1].type === 'linePrefix') {
|
||
// Add the prefix start to the HTML token.
|
||
events[index][1].start = events[index - 2][1].start
|
||
// Add the prefix start to the HTML line token.
|
||
events[index + 1][1].start = events[index - 2][1].start
|
||
// Remove the line prefix.
|
||
events.splice(index - 2, 2)
|
||
}
|
||
return events
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeHtmlFlow(effects, ok, nok) {
|
||
const self = this
|
||
/** @type {number} */
|
||
let marker
|
||
/** @type {boolean} */
|
||
let closingTag
|
||
/** @type {string} */
|
||
let buffer
|
||
/** @type {number} */
|
||
let index
|
||
/** @type {Code} */
|
||
let markerB
|
||
return start
|
||
|
||
/**
|
||
* Start of HTML (flow).
|
||
*
|
||
* ```markdown
|
||
* > | <x />
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
// To do: parse indent like `markdown-rs`.
|
||
return before(code)
|
||
}
|
||
|
||
/**
|
||
* At `<`, after optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | <x />
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function before(code) {
|
||
effects.enter('htmlFlow')
|
||
effects.enter('htmlFlowData')
|
||
effects.consume(code)
|
||
return open
|
||
}
|
||
|
||
/**
|
||
* After `<`, at tag name or other stuff.
|
||
*
|
||
* ```markdown
|
||
* > | <x />
|
||
* ^
|
||
* > | <!doctype>
|
||
* ^
|
||
* > | <!--xxx-->
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function open(code) {
|
||
if (code === 33) {
|
||
effects.consume(code)
|
||
return declarationOpen
|
||
}
|
||
if (code === 47) {
|
||
effects.consume(code)
|
||
closingTag = true
|
||
return tagCloseStart
|
||
}
|
||
if (code === 63) {
|
||
effects.consume(code)
|
||
marker = 3
|
||
// To do:
|
||
// tokenizer.concrete = true
|
||
// To do: use `markdown-rs` style interrupt.
|
||
// While we’re in an instruction instead of a declaration, we’re on a `?`
|
||
// right now, so we do need to search for `>`, similar to declarations.
|
||
return self.interrupt ? ok : continuationDeclarationInside
|
||
}
|
||
|
||
// ASCII alphabetical.
|
||
if (asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
// @ts-expect-error: not null.
|
||
buffer = String.fromCharCode(code)
|
||
return tagName
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `<!`, at declaration, comment, or CDATA.
|
||
*
|
||
* ```markdown
|
||
* > | <!doctype>
|
||
* ^
|
||
* > | <!--xxx-->
|
||
* ^
|
||
* > | <![CDATA[>&<]]>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function declarationOpen(code) {
|
||
if (code === 45) {
|
||
effects.consume(code)
|
||
marker = 2
|
||
return commentOpenInside
|
||
}
|
||
if (code === 91) {
|
||
effects.consume(code)
|
||
marker = 5
|
||
index = 0
|
||
return cdataOpenInside
|
||
}
|
||
|
||
// ASCII alphabetical.
|
||
if (asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
marker = 4
|
||
// // Do not form containers.
|
||
// tokenizer.concrete = true
|
||
return self.interrupt ? ok : continuationDeclarationInside
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `<!-`, inside a comment, at another `-`.
|
||
*
|
||
* ```markdown
|
||
* > | <!--xxx-->
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function commentOpenInside(code) {
|
||
if (code === 45) {
|
||
effects.consume(code)
|
||
// // Do not form containers.
|
||
// tokenizer.concrete = true
|
||
return self.interrupt ? ok : continuationDeclarationInside
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `<![`, inside CDATA, expecting `CDATA[`.
|
||
*
|
||
* ```markdown
|
||
* > | <![CDATA[>&<]]>
|
||
* ^^^^^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function cdataOpenInside(code) {
|
||
const value = 'CDATA['
|
||
if (code === value.charCodeAt(index++)) {
|
||
effects.consume(code)
|
||
if (index === value.length) {
|
||
// // Do not form containers.
|
||
// tokenizer.concrete = true
|
||
return self.interrupt ? ok : continuation
|
||
}
|
||
return cdataOpenInside
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `</`, in closing tag, at tag name.
|
||
*
|
||
* ```markdown
|
||
* > | </x>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagCloseStart(code) {
|
||
if (asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
// @ts-expect-error: not null.
|
||
buffer = String.fromCharCode(code)
|
||
return tagName
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In tag name.
|
||
*
|
||
* ```markdown
|
||
* > | <ab>
|
||
* ^^
|
||
* > | </ab>
|
||
* ^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagName(code) {
|
||
if (
|
||
code === null ||
|
||
code === 47 ||
|
||
code === 62 ||
|
||
markdownLineEndingOrSpace(code)
|
||
) {
|
||
const slash = code === 47
|
||
const name = buffer.toLowerCase()
|
||
if (!slash && !closingTag && htmlRawNames.includes(name)) {
|
||
marker = 1
|
||
// // Do not form containers.
|
||
// tokenizer.concrete = true
|
||
return self.interrupt ? ok(code) : continuation(code)
|
||
}
|
||
if (htmlBlockNames.includes(buffer.toLowerCase())) {
|
||
marker = 6
|
||
if (slash) {
|
||
effects.consume(code)
|
||
return basicSelfClosing
|
||
}
|
||
|
||
// // Do not form containers.
|
||
// tokenizer.concrete = true
|
||
return self.interrupt ? ok(code) : continuation(code)
|
||
}
|
||
marker = 7
|
||
// Do not support complete HTML when interrupting.
|
||
return self.interrupt && !self.parser.lazy[self.now().line]
|
||
? nok(code)
|
||
: closingTag
|
||
? completeClosingTagAfter(code)
|
||
: completeAttributeNameBefore(code)
|
||
}
|
||
|
||
// ASCII alphanumerical and `-`.
|
||
if (code === 45 || asciiAlphanumeric(code)) {
|
||
effects.consume(code)
|
||
buffer += String.fromCharCode(code)
|
||
return tagName
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After closing slash of a basic tag name.
|
||
*
|
||
* ```markdown
|
||
* > | <div/>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function basicSelfClosing(code) {
|
||
if (code === 62) {
|
||
effects.consume(code)
|
||
// // Do not form containers.
|
||
// tokenizer.concrete = true
|
||
return self.interrupt ? ok : continuation
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After closing slash of a complete tag name.
|
||
*
|
||
* ```markdown
|
||
* > | <x/>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeClosingTagAfter(code) {
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return completeClosingTagAfter
|
||
}
|
||
return completeEnd(code)
|
||
}
|
||
|
||
/**
|
||
* At an attribute name.
|
||
*
|
||
* At first, this state is used after a complete tag name, after whitespace,
|
||
* where it expects optional attributes or the end of the tag.
|
||
* It is also reused after attributes, when expecting more optional
|
||
* attributes.
|
||
*
|
||
* ```markdown
|
||
* > | <a />
|
||
* ^
|
||
* > | <a :b>
|
||
* ^
|
||
* > | <a _b>
|
||
* ^
|
||
* > | <a b>
|
||
* ^
|
||
* > | <a >
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeAttributeNameBefore(code) {
|
||
if (code === 47) {
|
||
effects.consume(code)
|
||
return completeEnd
|
||
}
|
||
|
||
// ASCII alphanumerical and `:` and `_`.
|
||
if (code === 58 || code === 95 || asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
return completeAttributeName
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return completeAttributeNameBefore
|
||
}
|
||
return completeEnd(code)
|
||
}
|
||
|
||
/**
|
||
* In attribute name.
|
||
*
|
||
* ```markdown
|
||
* > | <a :b>
|
||
* ^
|
||
* > | <a _b>
|
||
* ^
|
||
* > | <a b>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeAttributeName(code) {
|
||
// ASCII alphanumerical and `-`, `.`, `:`, and `_`.
|
||
if (
|
||
code === 45 ||
|
||
code === 46 ||
|
||
code === 58 ||
|
||
code === 95 ||
|
||
asciiAlphanumeric(code)
|
||
) {
|
||
effects.consume(code)
|
||
return completeAttributeName
|
||
}
|
||
return completeAttributeNameAfter(code)
|
||
}
|
||
|
||
/**
|
||
* After attribute name, at an optional initializer, the end of the tag, or
|
||
* whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | <a b>
|
||
* ^
|
||
* > | <a b=c>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeAttributeNameAfter(code) {
|
||
if (code === 61) {
|
||
effects.consume(code)
|
||
return completeAttributeValueBefore
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return completeAttributeNameAfter
|
||
}
|
||
return completeAttributeNameBefore(code)
|
||
}
|
||
|
||
/**
|
||
* Before unquoted, double quoted, or single quoted attribute value, allowing
|
||
* whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | <a b=c>
|
||
* ^
|
||
* > | <a b="c">
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeAttributeValueBefore(code) {
|
||
if (
|
||
code === null ||
|
||
code === 60 ||
|
||
code === 61 ||
|
||
code === 62 ||
|
||
code === 96
|
||
) {
|
||
return nok(code)
|
||
}
|
||
if (code === 34 || code === 39) {
|
||
effects.consume(code)
|
||
markerB = code
|
||
return completeAttributeValueQuoted
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return completeAttributeValueBefore
|
||
}
|
||
return completeAttributeValueUnquoted(code)
|
||
}
|
||
|
||
/**
|
||
* In double or single quoted attribute value.
|
||
*
|
||
* ```markdown
|
||
* > | <a b="c">
|
||
* ^
|
||
* > | <a b='c'>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeAttributeValueQuoted(code) {
|
||
if (code === markerB) {
|
||
effects.consume(code)
|
||
markerB = null
|
||
return completeAttributeValueQuotedAfter
|
||
}
|
||
if (code === null || markdownLineEnding(code)) {
|
||
return nok(code)
|
||
}
|
||
effects.consume(code)
|
||
return completeAttributeValueQuoted
|
||
}
|
||
|
||
/**
|
||
* In unquoted attribute value.
|
||
*
|
||
* ```markdown
|
||
* > | <a b=c>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeAttributeValueUnquoted(code) {
|
||
if (
|
||
code === null ||
|
||
code === 34 ||
|
||
code === 39 ||
|
||
code === 47 ||
|
||
code === 60 ||
|
||
code === 61 ||
|
||
code === 62 ||
|
||
code === 96 ||
|
||
markdownLineEndingOrSpace(code)
|
||
) {
|
||
return completeAttributeNameAfter(code)
|
||
}
|
||
effects.consume(code)
|
||
return completeAttributeValueUnquoted
|
||
}
|
||
|
||
/**
|
||
* After double or single quoted attribute value, before whitespace or the
|
||
* end of the tag.
|
||
*
|
||
* ```markdown
|
||
* > | <a b="c">
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeAttributeValueQuotedAfter(code) {
|
||
if (code === 47 || code === 62 || markdownSpace(code)) {
|
||
return completeAttributeNameBefore(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In certain circumstances of a complete tag where only an `>` is allowed.
|
||
*
|
||
* ```markdown
|
||
* > | <a b="c">
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeEnd(code) {
|
||
if (code === 62) {
|
||
effects.consume(code)
|
||
return completeAfter
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `>` in a complete tag.
|
||
*
|
||
* ```markdown
|
||
* > | <x>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function completeAfter(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
// // Do not form containers.
|
||
// tokenizer.concrete = true
|
||
return continuation(code)
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return completeAfter
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In continuation of any HTML kind.
|
||
*
|
||
* ```markdown
|
||
* > | <!--xxx-->
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuation(code) {
|
||
if (code === 45 && marker === 2) {
|
||
effects.consume(code)
|
||
return continuationCommentInside
|
||
}
|
||
if (code === 60 && marker === 1) {
|
||
effects.consume(code)
|
||
return continuationRawTagOpen
|
||
}
|
||
if (code === 62 && marker === 4) {
|
||
effects.consume(code)
|
||
return continuationClose
|
||
}
|
||
if (code === 63 && marker === 3) {
|
||
effects.consume(code)
|
||
return continuationDeclarationInside
|
||
}
|
||
if (code === 93 && marker === 5) {
|
||
effects.consume(code)
|
||
return continuationCdataInside
|
||
}
|
||
if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {
|
||
effects.exit('htmlFlowData')
|
||
return effects.check(
|
||
blankLineBefore,
|
||
continuationAfter,
|
||
continuationStart
|
||
)(code)
|
||
}
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('htmlFlowData')
|
||
return continuationStart(code)
|
||
}
|
||
effects.consume(code)
|
||
return continuation
|
||
}
|
||
|
||
/**
|
||
* In continuation, at eol.
|
||
*
|
||
* ```markdown
|
||
* > | <x>
|
||
* ^
|
||
* | asd
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationStart(code) {
|
||
return effects.check(
|
||
nonLazyContinuationStart,
|
||
continuationStartNonLazy,
|
||
continuationAfter
|
||
)(code)
|
||
}
|
||
|
||
/**
|
||
* In continuation, at eol, before non-lazy content.
|
||
*
|
||
* ```markdown
|
||
* > | <x>
|
||
* ^
|
||
* | asd
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationStartNonLazy(code) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return continuationBefore
|
||
}
|
||
|
||
/**
|
||
* In continuation, before non-lazy content.
|
||
*
|
||
* ```markdown
|
||
* | <x>
|
||
* > | asd
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationBefore(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
return continuationStart(code)
|
||
}
|
||
effects.enter('htmlFlowData')
|
||
return continuation(code)
|
||
}
|
||
|
||
/**
|
||
* In comment continuation, after one `-`, expecting another.
|
||
*
|
||
* ```markdown
|
||
* > | <!--xxx-->
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationCommentInside(code) {
|
||
if (code === 45) {
|
||
effects.consume(code)
|
||
return continuationDeclarationInside
|
||
}
|
||
return continuation(code)
|
||
}
|
||
|
||
/**
|
||
* In raw continuation, after `<`, at `/`.
|
||
*
|
||
* ```markdown
|
||
* > | <script>console.log(1)</script>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationRawTagOpen(code) {
|
||
if (code === 47) {
|
||
effects.consume(code)
|
||
buffer = ''
|
||
return continuationRawEndTag
|
||
}
|
||
return continuation(code)
|
||
}
|
||
|
||
/**
|
||
* In raw continuation, after `</`, in a raw tag name.
|
||
*
|
||
* ```markdown
|
||
* > | <script>console.log(1)</script>
|
||
* ^^^^^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationRawEndTag(code) {
|
||
if (code === 62) {
|
||
const name = buffer.toLowerCase()
|
||
if (htmlRawNames.includes(name)) {
|
||
effects.consume(code)
|
||
return continuationClose
|
||
}
|
||
return continuation(code)
|
||
}
|
||
if (asciiAlpha(code) && buffer.length < 8) {
|
||
effects.consume(code)
|
||
// @ts-expect-error: not null.
|
||
buffer += String.fromCharCode(code)
|
||
return continuationRawEndTag
|
||
}
|
||
return continuation(code)
|
||
}
|
||
|
||
/**
|
||
* In cdata continuation, after `]`, expecting `]>`.
|
||
*
|
||
* ```markdown
|
||
* > | <![CDATA[>&<]]>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationCdataInside(code) {
|
||
if (code === 93) {
|
||
effects.consume(code)
|
||
return continuationDeclarationInside
|
||
}
|
||
return continuation(code)
|
||
}
|
||
|
||
/**
|
||
* In declaration or instruction continuation, at `>`.
|
||
*
|
||
* ```markdown
|
||
* > | <!-->
|
||
* ^
|
||
* > | <?>
|
||
* ^
|
||
* > | <!q>
|
||
* ^
|
||
* > | <!--ab-->
|
||
* ^
|
||
* > | <![CDATA[>&<]]>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationDeclarationInside(code) {
|
||
if (code === 62) {
|
||
effects.consume(code)
|
||
return continuationClose
|
||
}
|
||
|
||
// More dashes.
|
||
if (code === 45 && marker === 2) {
|
||
effects.consume(code)
|
||
return continuationDeclarationInside
|
||
}
|
||
return continuation(code)
|
||
}
|
||
|
||
/**
|
||
* In closed continuation: everything we get until the eol/eof is part of it.
|
||
*
|
||
* ```markdown
|
||
* > | <!doctype>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationClose(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('htmlFlowData')
|
||
return continuationAfter(code)
|
||
}
|
||
effects.consume(code)
|
||
return continuationClose
|
||
}
|
||
|
||
/**
|
||
* Done.
|
||
*
|
||
* ```markdown
|
||
* > | <!doctype>
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function continuationAfter(code) {
|
||
effects.exit('htmlFlow')
|
||
// // Feel free to interrupt.
|
||
// tokenizer.interrupt = false
|
||
// // No longer concrete.
|
||
// tokenizer.concrete = false
|
||
return ok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeNonLazyContinuationStart(effects, ok, nok) {
|
||
const self = this
|
||
return start
|
||
|
||
/**
|
||
* At eol, before continuation.
|
||
*
|
||
* ```markdown
|
||
* > | * ```js
|
||
* ^
|
||
* | b
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
if (markdownLineEnding(code)) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return after
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* A continuation.
|
||
*
|
||
* ```markdown
|
||
* | * ```js
|
||
* > | b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeBlankLineBefore(effects, ok, nok) {
|
||
return start
|
||
|
||
/**
|
||
* Before eol, expecting blank line.
|
||
*
|
||
* ```markdown
|
||
* > | <div>
|
||
* ^
|
||
* |
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return effects.attempt(blankLine, ok, nok)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/code-fenced.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const nonLazyContinuation = {
|
||
tokenize: tokenizeNonLazyContinuation,
|
||
partial: true
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const codeFenced = {
|
||
name: 'codeFenced',
|
||
tokenize: tokenizeCodeFenced,
|
||
concrete: true
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeCodeFenced(effects, ok, nok) {
|
||
const self = this
|
||
/** @type {Construct} */
|
||
const closeStart = {
|
||
tokenize: tokenizeCloseStart,
|
||
partial: true
|
||
}
|
||
let initialPrefix = 0
|
||
let sizeOpen = 0
|
||
/** @type {NonNullable<Code>} */
|
||
let marker
|
||
return start
|
||
|
||
/**
|
||
* Start of code.
|
||
*
|
||
* ```markdown
|
||
* > | ~~~js
|
||
* ^
|
||
* | alert(1)
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
// To do: parse whitespace like `markdown-rs`.
|
||
return beforeSequenceOpen(code)
|
||
}
|
||
|
||
/**
|
||
* In opening fence, after prefix, at sequence.
|
||
*
|
||
* ```markdown
|
||
* > | ~~~js
|
||
* ^
|
||
* | alert(1)
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function beforeSequenceOpen(code) {
|
||
const tail = self.events[self.events.length - 1]
|
||
initialPrefix =
|
||
tail && tail[1].type === 'linePrefix'
|
||
? tail[2].sliceSerialize(tail[1], true).length
|
||
: 0
|
||
marker = code
|
||
effects.enter('codeFenced')
|
||
effects.enter('codeFencedFence')
|
||
effects.enter('codeFencedFenceSequence')
|
||
return sequenceOpen(code)
|
||
}
|
||
|
||
/**
|
||
* In opening fence sequence.
|
||
*
|
||
* ```markdown
|
||
* > | ~~~js
|
||
* ^
|
||
* | alert(1)
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceOpen(code) {
|
||
if (code === marker) {
|
||
sizeOpen++
|
||
effects.consume(code)
|
||
return sequenceOpen
|
||
}
|
||
if (sizeOpen < 3) {
|
||
return nok(code)
|
||
}
|
||
effects.exit('codeFencedFenceSequence')
|
||
return markdownSpace(code)
|
||
? factorySpace(effects, infoBefore, 'whitespace')(code)
|
||
: infoBefore(code)
|
||
}
|
||
|
||
/**
|
||
* In opening fence, after the sequence (and optional whitespace), before info.
|
||
*
|
||
* ```markdown
|
||
* > | ~~~js
|
||
* ^
|
||
* | alert(1)
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function infoBefore(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('codeFencedFence')
|
||
return self.interrupt
|
||
? ok(code)
|
||
: effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)
|
||
}
|
||
effects.enter('codeFencedFenceInfo')
|
||
effects.enter('chunkString', {
|
||
contentType: 'string'
|
||
})
|
||
return info(code)
|
||
}
|
||
|
||
/**
|
||
* In info.
|
||
*
|
||
* ```markdown
|
||
* > | ~~~js
|
||
* ^
|
||
* | alert(1)
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function info(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('chunkString')
|
||
effects.exit('codeFencedFenceInfo')
|
||
return infoBefore(code)
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.exit('chunkString')
|
||
effects.exit('codeFencedFenceInfo')
|
||
return factorySpace(effects, metaBefore, 'whitespace')(code)
|
||
}
|
||
if (code === 96 && code === marker) {
|
||
return nok(code)
|
||
}
|
||
effects.consume(code)
|
||
return info
|
||
}
|
||
|
||
/**
|
||
* In opening fence, after info and whitespace, before meta.
|
||
*
|
||
* ```markdown
|
||
* > | ~~~js eval
|
||
* ^
|
||
* | alert(1)
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function metaBefore(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
return infoBefore(code)
|
||
}
|
||
effects.enter('codeFencedFenceMeta')
|
||
effects.enter('chunkString', {
|
||
contentType: 'string'
|
||
})
|
||
return meta(code)
|
||
}
|
||
|
||
/**
|
||
* In meta.
|
||
*
|
||
* ```markdown
|
||
* > | ~~~js eval
|
||
* ^
|
||
* | alert(1)
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function meta(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('chunkString')
|
||
effects.exit('codeFencedFenceMeta')
|
||
return infoBefore(code)
|
||
}
|
||
if (code === 96 && code === marker) {
|
||
return nok(code)
|
||
}
|
||
effects.consume(code)
|
||
return meta
|
||
}
|
||
|
||
/**
|
||
* At eol/eof in code, before a non-lazy closing fence or content.
|
||
*
|
||
* ```markdown
|
||
* > | ~~~js
|
||
* ^
|
||
* > | alert(1)
|
||
* ^
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function atNonLazyBreak(code) {
|
||
return effects.attempt(closeStart, after, contentBefore)(code)
|
||
}
|
||
|
||
/**
|
||
* Before code content, not a closing fence, at eol.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* > | alert(1)
|
||
* ^
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function contentBefore(code) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return contentStart
|
||
}
|
||
|
||
/**
|
||
* Before code content, not a closing fence.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* > | alert(1)
|
||
* ^
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function contentStart(code) {
|
||
return initialPrefix > 0 && markdownSpace(code)
|
||
? factorySpace(
|
||
effects,
|
||
beforeContentChunk,
|
||
'linePrefix',
|
||
initialPrefix + 1
|
||
)(code)
|
||
: beforeContentChunk(code)
|
||
}
|
||
|
||
/**
|
||
* Before code content, after optional prefix.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* > | alert(1)
|
||
* ^
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function beforeContentChunk(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)
|
||
}
|
||
effects.enter('codeFlowValue')
|
||
return contentChunk(code)
|
||
}
|
||
|
||
/**
|
||
* In code content.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* > | alert(1)
|
||
* ^^^^^^^^
|
||
* | ~~~
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function contentChunk(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('codeFlowValue')
|
||
return beforeContentChunk(code)
|
||
}
|
||
effects.consume(code)
|
||
return contentChunk
|
||
}
|
||
|
||
/**
|
||
* After code.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* | alert(1)
|
||
* > | ~~~
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
effects.exit('codeFenced')
|
||
return ok(code)
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeCloseStart(effects, ok, nok) {
|
||
let size = 0
|
||
return startBefore
|
||
|
||
/**
|
||
*
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function startBefore(code) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return start
|
||
}
|
||
|
||
/**
|
||
* Before closing fence, at optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* | alert(1)
|
||
* > | ~~~
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
// Always populated by defaults.
|
||
|
||
// To do: `enter` here or in next state?
|
||
effects.enter('codeFencedFence')
|
||
return markdownSpace(code)
|
||
? factorySpace(
|
||
effects,
|
||
beforeSequenceClose,
|
||
'linePrefix',
|
||
self.parser.constructs.disable.null.includes('codeIndented')
|
||
? undefined
|
||
: 4
|
||
)(code)
|
||
: beforeSequenceClose(code)
|
||
}
|
||
|
||
/**
|
||
* In closing fence, after optional whitespace, at sequence.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* | alert(1)
|
||
* > | ~~~
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function beforeSequenceClose(code) {
|
||
if (code === marker) {
|
||
effects.enter('codeFencedFenceSequence')
|
||
return sequenceClose(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In closing fence sequence.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* | alert(1)
|
||
* > | ~~~
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceClose(code) {
|
||
if (code === marker) {
|
||
size++
|
||
effects.consume(code)
|
||
return sequenceClose
|
||
}
|
||
if (size >= sizeOpen) {
|
||
effects.exit('codeFencedFenceSequence')
|
||
return markdownSpace(code)
|
||
? factorySpace(effects, sequenceCloseAfter, 'whitespace')(code)
|
||
: sequenceCloseAfter(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After closing fence sequence, after optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* | ~~~js
|
||
* | alert(1)
|
||
* > | ~~~
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceCloseAfter(code) {
|
||
if (code === null || markdownLineEnding(code)) {
|
||
effects.exit('codeFencedFence')
|
||
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 nok(code)
|
||
}
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return lineStart
|
||
}
|
||
|
||
/**
|
||
*
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function lineStart(code) {
|
||
return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/decode-named-character-reference/index.dom.js
|
||
/// <reference lib="dom" />
|
||
|
||
/* eslint-env browser */
|
||
|
||
const index_dom_element = document.createElement('i')
|
||
|
||
/**
|
||
* @param {string} value
|
||
* @returns {string|false}
|
||
*/
|
||
function decodeNamedCharacterReference(value) {
|
||
const characterReference = '&' + value + ';'
|
||
index_dom_element.innerHTML = characterReference
|
||
const char = index_dom_element.textContent
|
||
|
||
// Some named character references do not require the closing semicolon
|
||
// (`¬`, for instance), which leads to situations where parsing the assumed
|
||
// named reference of `¬it;` will result in the string `¬it;`.
|
||
// When we encounter a trailing semicolon after parsing, and the character
|
||
// reference to decode was not a semicolon (`;`), we can assume that the
|
||
// matching was not complete.
|
||
// @ts-expect-error: TypeScript is wrong that `textContent` on elements can
|
||
// yield `null`.
|
||
if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {
|
||
return false
|
||
}
|
||
|
||
// If the decoded string is equal to the input, the character reference was
|
||
// not valid.
|
||
// @ts-expect-error: TypeScript is wrong that `textContent` on elements can
|
||
// yield `null`.
|
||
return char === characterReference ? false : char
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/character-reference.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const characterReference = {
|
||
name: 'characterReference',
|
||
tokenize: tokenizeCharacterReference
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeCharacterReference(effects, ok, nok) {
|
||
const self = this
|
||
let size = 0
|
||
/** @type {number} */
|
||
let max
|
||
/** @type {(code: Code) => boolean} */
|
||
let test
|
||
return start
|
||
|
||
/**
|
||
* Start of character reference.
|
||
*
|
||
* ```markdown
|
||
* > | a&b
|
||
* ^
|
||
* > | a{b
|
||
* ^
|
||
* > | a	b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('characterReference')
|
||
effects.enter('characterReferenceMarker')
|
||
effects.consume(code)
|
||
effects.exit('characterReferenceMarker')
|
||
return open
|
||
}
|
||
|
||
/**
|
||
* After `&`, at `#` for numeric references or alphanumeric for named
|
||
* references.
|
||
*
|
||
* ```markdown
|
||
* > | a&b
|
||
* ^
|
||
* > | a{b
|
||
* ^
|
||
* > | a	b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function open(code) {
|
||
if (code === 35) {
|
||
effects.enter('characterReferenceMarkerNumeric')
|
||
effects.consume(code)
|
||
effects.exit('characterReferenceMarkerNumeric')
|
||
return numeric
|
||
}
|
||
effects.enter('characterReferenceValue')
|
||
max = 31
|
||
test = asciiAlphanumeric
|
||
return value(code)
|
||
}
|
||
|
||
/**
|
||
* After `#`, at `x` for hexadecimals or digit for decimals.
|
||
*
|
||
* ```markdown
|
||
* > | a{b
|
||
* ^
|
||
* > | a	b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function numeric(code) {
|
||
if (code === 88 || code === 120) {
|
||
effects.enter('characterReferenceMarkerHexadecimal')
|
||
effects.consume(code)
|
||
effects.exit('characterReferenceMarkerHexadecimal')
|
||
effects.enter('characterReferenceValue')
|
||
max = 6
|
||
test = asciiHexDigit
|
||
return value
|
||
}
|
||
effects.enter('characterReferenceValue')
|
||
max = 7
|
||
test = asciiDigit
|
||
return value(code)
|
||
}
|
||
|
||
/**
|
||
* After markers (`&#x`, `&#`, or `&`), in value, before `;`.
|
||
*
|
||
* The character reference kind defines what and how many characters are
|
||
* allowed.
|
||
*
|
||
* ```markdown
|
||
* > | a&b
|
||
* ^^^
|
||
* > | a{b
|
||
* ^^^
|
||
* > | a	b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function value(code) {
|
||
if (code === 59 && size) {
|
||
const token = effects.exit('characterReferenceValue')
|
||
if (
|
||
test === asciiAlphanumeric &&
|
||
!decodeNamedCharacterReference(self.sliceSerialize(token))
|
||
) {
|
||
return nok(code)
|
||
}
|
||
|
||
// To do: `markdown-rs` uses a different name:
|
||
// `CharacterReferenceMarkerSemi`.
|
||
effects.enter('characterReferenceMarker')
|
||
effects.consume(code)
|
||
effects.exit('characterReferenceMarker')
|
||
effects.exit('characterReference')
|
||
return ok
|
||
}
|
||
if (test(code) && size++ < max) {
|
||
effects.consume(code)
|
||
return value
|
||
}
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/character-escape.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
/** @type {Construct} */
|
||
const characterEscape = {
|
||
name: 'characterEscape',
|
||
tokenize: tokenizeCharacterEscape
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeCharacterEscape(effects, ok, nok) {
|
||
return start
|
||
|
||
/**
|
||
* Start of character escape.
|
||
*
|
||
* ```markdown
|
||
* > | a\*b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('characterEscape')
|
||
effects.enter('escapeMarker')
|
||
effects.consume(code)
|
||
effects.exit('escapeMarker')
|
||
return inside
|
||
}
|
||
|
||
/**
|
||
* After `\`, at punctuation.
|
||
*
|
||
* ```markdown
|
||
* > | a\*b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function inside(code) {
|
||
// ASCII punctuation.
|
||
if (asciiPunctuation(code)) {
|
||
effects.enter('characterEscapeValue')
|
||
effects.consume(code)
|
||
effects.exit('characterEscapeValue')
|
||
effects.exit('characterEscape')
|
||
return ok
|
||
}
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/line-ending.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const lineEnding = {
|
||
name: 'lineEnding',
|
||
tokenize: tokenizeLineEnding
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeLineEnding(effects, ok) {
|
||
return start
|
||
|
||
/** @type {State} */
|
||
function start(code) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return factorySpace(effects, ok, 'linePrefix')
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/label-end.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Event} Event
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const labelEnd = {
|
||
name: 'labelEnd',
|
||
tokenize: tokenizeLabelEnd,
|
||
resolveTo: resolveToLabelEnd,
|
||
resolveAll: resolveAllLabelEnd
|
||
}
|
||
|
||
/** @type {Construct} */
|
||
const resourceConstruct = {
|
||
tokenize: tokenizeResource
|
||
}
|
||
/** @type {Construct} */
|
||
const referenceFullConstruct = {
|
||
tokenize: tokenizeReferenceFull
|
||
}
|
||
/** @type {Construct} */
|
||
const referenceCollapsedConstruct = {
|
||
tokenize: tokenizeReferenceCollapsed
|
||
}
|
||
|
||
/** @type {Resolver} */
|
||
function resolveAllLabelEnd(events) {
|
||
let index = -1
|
||
while (++index < events.length) {
|
||
const token = events[index][1]
|
||
if (
|
||
token.type === 'labelImage' ||
|
||
token.type === 'labelLink' ||
|
||
token.type === 'labelEnd'
|
||
) {
|
||
// Remove the marker.
|
||
events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)
|
||
token.type = 'data'
|
||
index++
|
||
}
|
||
}
|
||
return events
|
||
}
|
||
|
||
/** @type {Resolver} */
|
||
function resolveToLabelEnd(events, context) {
|
||
let index = events.length
|
||
let offset = 0
|
||
/** @type {Token} */
|
||
let token
|
||
/** @type {number | undefined} */
|
||
let open
|
||
/** @type {number | undefined} */
|
||
let close
|
||
/** @type {Array<Event>} */
|
||
let media
|
||
|
||
// Find an opening.
|
||
while (index--) {
|
||
token = events[index][1]
|
||
if (open) {
|
||
// If we see another link, or inactive link label, we’ve been here before.
|
||
if (
|
||
token.type === 'link' ||
|
||
(token.type === 'labelLink' && token._inactive)
|
||
) {
|
||
break
|
||
}
|
||
|
||
// Mark other link openings as inactive, as we can’t have links in
|
||
// links.
|
||
if (events[index][0] === 'enter' && token.type === 'labelLink') {
|
||
token._inactive = true
|
||
}
|
||
} else if (close) {
|
||
if (
|
||
events[index][0] === 'enter' &&
|
||
(token.type === 'labelImage' || token.type === 'labelLink') &&
|
||
!token._balanced
|
||
) {
|
||
open = index
|
||
if (token.type !== 'labelLink') {
|
||
offset = 2
|
||
break
|
||
}
|
||
}
|
||
} else if (token.type === 'labelEnd') {
|
||
close = index
|
||
}
|
||
}
|
||
const group = {
|
||
type: events[open][1].type === 'labelLink' ? 'link' : 'image',
|
||
start: Object.assign({}, events[open][1].start),
|
||
end: Object.assign({}, events[events.length - 1][1].end)
|
||
}
|
||
const label = {
|
||
type: 'label',
|
||
start: Object.assign({}, events[open][1].start),
|
||
end: Object.assign({}, events[close][1].end)
|
||
}
|
||
const text = {
|
||
type: 'labelText',
|
||
start: Object.assign({}, events[open + offset + 2][1].end),
|
||
end: Object.assign({}, events[close - 2][1].start)
|
||
}
|
||
media = [
|
||
['enter', group, context],
|
||
['enter', label, context]
|
||
]
|
||
|
||
// Opening marker.
|
||
media = push(media, events.slice(open + 1, open + offset + 3))
|
||
|
||
// Text open.
|
||
media = push(media, [['enter', text, context]])
|
||
|
||
// Always populated by defaults.
|
||
|
||
// Between.
|
||
media = push(
|
||
media,
|
||
resolveAll(
|
||
context.parser.constructs.insideSpan.null,
|
||
events.slice(open + offset + 4, close - 3),
|
||
context
|
||
)
|
||
)
|
||
|
||
// Text close, marker close, label close.
|
||
media = push(media, [
|
||
['exit', text, context],
|
||
events[close - 2],
|
||
events[close - 1],
|
||
['exit', label, context]
|
||
])
|
||
|
||
// Reference, resource, or so.
|
||
media = push(media, events.slice(close + 1))
|
||
|
||
// Media close.
|
||
media = push(media, [['exit', group, context]])
|
||
splice(events, open, events.length, media)
|
||
return events
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeLabelEnd(effects, ok, nok) {
|
||
const self = this
|
||
let index = self.events.length
|
||
/** @type {Token} */
|
||
let labelStart
|
||
/** @type {boolean} */
|
||
let defined
|
||
|
||
// Find an opening.
|
||
while (index--) {
|
||
if (
|
||
(self.events[index][1].type === 'labelImage' ||
|
||
self.events[index][1].type === 'labelLink') &&
|
||
!self.events[index][1]._balanced
|
||
) {
|
||
labelStart = self.events[index][1]
|
||
break
|
||
}
|
||
}
|
||
return start
|
||
|
||
/**
|
||
* Start of label end.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b) c
|
||
* ^
|
||
* > | [a][b] c
|
||
* ^
|
||
* > | [a][] b
|
||
* ^
|
||
* > | [a] b
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
// If there is not an okay opening.
|
||
if (!labelStart) {
|
||
return nok(code)
|
||
}
|
||
|
||
// If the corresponding label (link) start is marked as inactive,
|
||
// it means we’d be wrapping a link, like this:
|
||
//
|
||
// ```markdown
|
||
// > | a [b [c](d) e](f) g.
|
||
// ^
|
||
// ```
|
||
//
|
||
// We can’t have that, so it’s just balanced brackets.
|
||
if (labelStart._inactive) {
|
||
return labelEndNok(code)
|
||
}
|
||
defined = self.parser.defined.includes(
|
||
normalizeIdentifier(
|
||
self.sliceSerialize({
|
||
start: labelStart.end,
|
||
end: self.now()
|
||
})
|
||
)
|
||
)
|
||
effects.enter('labelEnd')
|
||
effects.enter('labelMarker')
|
||
effects.consume(code)
|
||
effects.exit('labelMarker')
|
||
effects.exit('labelEnd')
|
||
return after
|
||
}
|
||
|
||
/**
|
||
* After `]`.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b) c
|
||
* ^
|
||
* > | [a][b] c
|
||
* ^
|
||
* > | [a][] b
|
||
* ^
|
||
* > | [a] b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
// Note: `markdown-rs` also parses GFM footnotes here, which for us is in
|
||
// an extension.
|
||
|
||
// Resource (`[asd](fgh)`)?
|
||
if (code === 40) {
|
||
return effects.attempt(
|
||
resourceConstruct,
|
||
labelEndOk,
|
||
defined ? labelEndOk : labelEndNok
|
||
)(code)
|
||
}
|
||
|
||
// Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?
|
||
if (code === 91) {
|
||
return effects.attempt(
|
||
referenceFullConstruct,
|
||
labelEndOk,
|
||
defined ? referenceNotFull : labelEndNok
|
||
)(code)
|
||
}
|
||
|
||
// Shortcut (`[asd]`) reference?
|
||
return defined ? labelEndOk(code) : labelEndNok(code)
|
||
}
|
||
|
||
/**
|
||
* After `]`, at `[`, but not at a full reference.
|
||
*
|
||
* > 👉 **Note**: we only get here if the label is defined.
|
||
*
|
||
* ```markdown
|
||
* > | [a][] b
|
||
* ^
|
||
* > | [a] b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function referenceNotFull(code) {
|
||
return effects.attempt(
|
||
referenceCollapsedConstruct,
|
||
labelEndOk,
|
||
labelEndNok
|
||
)(code)
|
||
}
|
||
|
||
/**
|
||
* Done, we found something.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b) c
|
||
* ^
|
||
* > | [a][b] c
|
||
* ^
|
||
* > | [a][] b
|
||
* ^
|
||
* > | [a] b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function labelEndOk(code) {
|
||
// Note: `markdown-rs` does a bunch of stuff here.
|
||
return ok(code)
|
||
}
|
||
|
||
/**
|
||
* Done, it’s nothing.
|
||
*
|
||
* There was an okay opening, but we didn’t match anything.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b c
|
||
* ^
|
||
* > | [a][b c
|
||
* ^
|
||
* > | [a] b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function labelEndNok(code) {
|
||
labelStart._balanced = true
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeResource(effects, ok, nok) {
|
||
return resourceStart
|
||
|
||
/**
|
||
* At a resource.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b) c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function resourceStart(code) {
|
||
effects.enter('resource')
|
||
effects.enter('resourceMarker')
|
||
effects.consume(code)
|
||
effects.exit('resourceMarker')
|
||
return resourceBefore
|
||
}
|
||
|
||
/**
|
||
* In resource, after `(`, at optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b) c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function resourceBefore(code) {
|
||
return markdownLineEndingOrSpace(code)
|
||
? factoryWhitespace(effects, resourceOpen)(code)
|
||
: resourceOpen(code)
|
||
}
|
||
|
||
/**
|
||
* In resource, after optional whitespace, at `)` or a destination.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b) c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function resourceOpen(code) {
|
||
if (code === 41) {
|
||
return resourceEnd(code)
|
||
}
|
||
return factoryDestination(
|
||
effects,
|
||
resourceDestinationAfter,
|
||
resourceDestinationMissing,
|
||
'resourceDestination',
|
||
'resourceDestinationLiteral',
|
||
'resourceDestinationLiteralMarker',
|
||
'resourceDestinationRaw',
|
||
'resourceDestinationString',
|
||
32
|
||
)(code)
|
||
}
|
||
|
||
/**
|
||
* In resource, after destination, at optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b) c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function resourceDestinationAfter(code) {
|
||
return markdownLineEndingOrSpace(code)
|
||
? factoryWhitespace(effects, resourceBetween)(code)
|
||
: resourceEnd(code)
|
||
}
|
||
|
||
/**
|
||
* At invalid destination.
|
||
*
|
||
* ```markdown
|
||
* > | [a](<<) b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function resourceDestinationMissing(code) {
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In resource, after destination and whitespace, at `(` or title.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b ) c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function resourceBetween(code) {
|
||
if (code === 34 || code === 39 || code === 40) {
|
||
return factoryTitle(
|
||
effects,
|
||
resourceTitleAfter,
|
||
nok,
|
||
'resourceTitle',
|
||
'resourceTitleMarker',
|
||
'resourceTitleString'
|
||
)(code)
|
||
}
|
||
return resourceEnd(code)
|
||
}
|
||
|
||
/**
|
||
* In resource, after title, at optional whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b "c") d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function resourceTitleAfter(code) {
|
||
return markdownLineEndingOrSpace(code)
|
||
? factoryWhitespace(effects, resourceEnd)(code)
|
||
: resourceEnd(code)
|
||
}
|
||
|
||
/**
|
||
* In resource, at `)`.
|
||
*
|
||
* ```markdown
|
||
* > | [a](b) d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function resourceEnd(code) {
|
||
if (code === 41) {
|
||
effects.enter('resourceMarker')
|
||
effects.consume(code)
|
||
effects.exit('resourceMarker')
|
||
effects.exit('resource')
|
||
return ok
|
||
}
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeReferenceFull(effects, ok, nok) {
|
||
const self = this
|
||
return referenceFull
|
||
|
||
/**
|
||
* In a reference (full), at the `[`.
|
||
*
|
||
* ```markdown
|
||
* > | [a][b] d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function referenceFull(code) {
|
||
return factoryLabel.call(
|
||
self,
|
||
effects,
|
||
referenceFullAfter,
|
||
referenceFullMissing,
|
||
'reference',
|
||
'referenceMarker',
|
||
'referenceString'
|
||
)(code)
|
||
}
|
||
|
||
/**
|
||
* In a reference (full), after `]`.
|
||
*
|
||
* ```markdown
|
||
* > | [a][b] d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function referenceFullAfter(code) {
|
||
return self.parser.defined.includes(
|
||
normalizeIdentifier(
|
||
self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
|
||
)
|
||
)
|
||
? ok(code)
|
||
: nok(code)
|
||
}
|
||
|
||
/**
|
||
* In reference (full) that was missing.
|
||
*
|
||
* ```markdown
|
||
* > | [a][b d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function referenceFullMissing(code) {
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeReferenceCollapsed(effects, ok, nok) {
|
||
return referenceCollapsedStart
|
||
|
||
/**
|
||
* In reference (collapsed), at `[`.
|
||
*
|
||
* > 👉 **Note**: we only get here if the label is defined.
|
||
*
|
||
* ```markdown
|
||
* > | [a][] d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function referenceCollapsedStart(code) {
|
||
// We only attempt a collapsed label if there’s a `[`.
|
||
|
||
effects.enter('reference')
|
||
effects.enter('referenceMarker')
|
||
effects.consume(code)
|
||
effects.exit('referenceMarker')
|
||
return referenceCollapsedOpen
|
||
}
|
||
|
||
/**
|
||
* In reference (collapsed), at `]`.
|
||
*
|
||
* > 👉 **Note**: we only get here if the label is defined.
|
||
*
|
||
* ```markdown
|
||
* > | [a][] d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function referenceCollapsedOpen(code) {
|
||
if (code === 93) {
|
||
effects.enter('referenceMarker')
|
||
effects.consume(code)
|
||
effects.exit('referenceMarker')
|
||
effects.exit('reference')
|
||
return ok
|
||
}
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/label-start-image.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const labelStartImage = {
|
||
name: 'labelStartImage',
|
||
tokenize: tokenizeLabelStartImage,
|
||
resolveAll: labelEnd.resolveAll
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeLabelStartImage(effects, ok, nok) {
|
||
const self = this
|
||
return start
|
||
|
||
/**
|
||
* Start of label (image) start.
|
||
*
|
||
* ```markdown
|
||
* > | a ![b] c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('labelImage')
|
||
effects.enter('labelImageMarker')
|
||
effects.consume(code)
|
||
effects.exit('labelImageMarker')
|
||
return open
|
||
}
|
||
|
||
/**
|
||
* After `!`, at `[`.
|
||
*
|
||
* ```markdown
|
||
* > | a ![b] c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function open(code) {
|
||
if (code === 91) {
|
||
effects.enter('labelMarker')
|
||
effects.consume(code)
|
||
effects.exit('labelMarker')
|
||
effects.exit('labelImage')
|
||
return after
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `![`.
|
||
*
|
||
* ```markdown
|
||
* > | a ![b] c
|
||
* ^
|
||
* ```
|
||
*
|
||
* This is needed in because, when GFM footnotes are enabled, images never
|
||
* form when started with a `^`.
|
||
* Instead, links form:
|
||
*
|
||
* ```markdown
|
||
* 
|
||
*
|
||
* ![^a][b]
|
||
*
|
||
* [b]: c
|
||
* ```
|
||
*
|
||
* ```html
|
||
* <p>!<a href=\"b\">^a</a></p>
|
||
* <p>!<a href=\"c\">^a</a></p>
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
// To do: use a new field to do this, this is still needed for
|
||
// `micromark-extension-gfm-footnote`, but the `label-start-link`
|
||
// behavior isn’t.
|
||
// Hidden footnotes hook.
|
||
/* c8 ignore next 3 */
|
||
return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs
|
||
? nok(code)
|
||
: ok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-classify-character/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
*/
|
||
|
||
|
||
/**
|
||
* Classify whether a code represents whitespace, punctuation, or something
|
||
* else.
|
||
*
|
||
* Used for attention (emphasis, strong), whose sequences can open or close
|
||
* based on the class of surrounding characters.
|
||
*
|
||
* > 👉 **Note**: eof (`null`) is seen as whitespace.
|
||
*
|
||
* @param {Code} code
|
||
* Code.
|
||
* @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}
|
||
* Group.
|
||
*/
|
||
function classifyCharacter(code) {
|
||
if (
|
||
code === null ||
|
||
markdownLineEndingOrSpace(code) ||
|
||
unicodeWhitespace(code)
|
||
) {
|
||
return 1
|
||
}
|
||
if (unicodePunctuation(code)) {
|
||
return 2
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/attention.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Event} Event
|
||
* @typedef {import('micromark-util-types').Point} Point
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const attention = {
|
||
name: 'attention',
|
||
tokenize: tokenizeAttention,
|
||
resolveAll: resolveAllAttention
|
||
}
|
||
|
||
/**
|
||
* Take all events and resolve attention to emphasis or strong.
|
||
*
|
||
* @type {Resolver}
|
||
*/
|
||
function resolveAllAttention(events, context) {
|
||
let index = -1
|
||
/** @type {number} */
|
||
let open
|
||
/** @type {Token} */
|
||
let group
|
||
/** @type {Token} */
|
||
let text
|
||
/** @type {Token} */
|
||
let openingSequence
|
||
/** @type {Token} */
|
||
let closingSequence
|
||
/** @type {number} */
|
||
let use
|
||
/** @type {Array<Event>} */
|
||
let nextEvents
|
||
/** @type {number} */
|
||
let offset
|
||
|
||
// Walk through all events.
|
||
//
|
||
// Note: performance of this is fine on an mb of normal markdown, but it’s
|
||
// a bottleneck for malicious stuff.
|
||
while (++index < events.length) {
|
||
// Find a token that can close.
|
||
if (
|
||
events[index][0] === 'enter' &&
|
||
events[index][1].type === 'attentionSequence' &&
|
||
events[index][1]._close
|
||
) {
|
||
open = index
|
||
|
||
// Now walk back to find an opener.
|
||
while (open--) {
|
||
// Find a token that can open the closer.
|
||
if (
|
||
events[open][0] === 'exit' &&
|
||
events[open][1].type === 'attentionSequence' &&
|
||
events[open][1]._open &&
|
||
// If the markers are the same:
|
||
context.sliceSerialize(events[open][1]).charCodeAt(0) ===
|
||
context.sliceSerialize(events[index][1]).charCodeAt(0)
|
||
) {
|
||
// If the opening can close or the closing can open,
|
||
// and the close size *is not* a multiple of three,
|
||
// but the sum of the opening and closing size *is* multiple of three,
|
||
// then don’t match.
|
||
if (
|
||
(events[open][1]._close || events[index][1]._open) &&
|
||
(events[index][1].end.offset - events[index][1].start.offset) % 3 &&
|
||
!(
|
||
(events[open][1].end.offset -
|
||
events[open][1].start.offset +
|
||
events[index][1].end.offset -
|
||
events[index][1].start.offset) %
|
||
3
|
||
)
|
||
) {
|
||
continue
|
||
}
|
||
|
||
// Number of markers to use from the sequence.
|
||
use =
|
||
events[open][1].end.offset - events[open][1].start.offset > 1 &&
|
||
events[index][1].end.offset - events[index][1].start.offset > 1
|
||
? 2
|
||
: 1
|
||
const start = Object.assign({}, events[open][1].end)
|
||
const end = Object.assign({}, events[index][1].start)
|
||
movePoint(start, -use)
|
||
movePoint(end, use)
|
||
openingSequence = {
|
||
type: use > 1 ? 'strongSequence' : 'emphasisSequence',
|
||
start,
|
||
end: Object.assign({}, events[open][1].end)
|
||
}
|
||
closingSequence = {
|
||
type: use > 1 ? 'strongSequence' : 'emphasisSequence',
|
||
start: Object.assign({}, events[index][1].start),
|
||
end
|
||
}
|
||
text = {
|
||
type: use > 1 ? 'strongText' : 'emphasisText',
|
||
start: Object.assign({}, events[open][1].end),
|
||
end: Object.assign({}, events[index][1].start)
|
||
}
|
||
group = {
|
||
type: use > 1 ? 'strong' : 'emphasis',
|
||
start: Object.assign({}, openingSequence.start),
|
||
end: Object.assign({}, closingSequence.end)
|
||
}
|
||
events[open][1].end = Object.assign({}, openingSequence.start)
|
||
events[index][1].start = Object.assign({}, closingSequence.end)
|
||
nextEvents = []
|
||
|
||
// If there are more markers in the opening, add them before.
|
||
if (events[open][1].end.offset - events[open][1].start.offset) {
|
||
nextEvents = push(nextEvents, [
|
||
['enter', events[open][1], context],
|
||
['exit', events[open][1], context]
|
||
])
|
||
}
|
||
|
||
// Opening.
|
||
nextEvents = push(nextEvents, [
|
||
['enter', group, context],
|
||
['enter', openingSequence, context],
|
||
['exit', openingSequence, context],
|
||
['enter', text, context]
|
||
])
|
||
|
||
// Always populated by defaults.
|
||
|
||
// Between.
|
||
nextEvents = push(
|
||
nextEvents,
|
||
resolveAll(
|
||
context.parser.constructs.insideSpan.null,
|
||
events.slice(open + 1, index),
|
||
context
|
||
)
|
||
)
|
||
|
||
// Closing.
|
||
nextEvents = push(nextEvents, [
|
||
['exit', text, context],
|
||
['enter', closingSequence, context],
|
||
['exit', closingSequence, context],
|
||
['exit', group, context]
|
||
])
|
||
|
||
// If there are more markers in the closing, add them after.
|
||
if (events[index][1].end.offset - events[index][1].start.offset) {
|
||
offset = 2
|
||
nextEvents = push(nextEvents, [
|
||
['enter', events[index][1], context],
|
||
['exit', events[index][1], context]
|
||
])
|
||
} else {
|
||
offset = 0
|
||
}
|
||
splice(events, open - 1, index - open + 3, nextEvents)
|
||
index = open + nextEvents.length - offset - 2
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Remove remaining sequences.
|
||
index = -1
|
||
while (++index < events.length) {
|
||
if (events[index][1].type === 'attentionSequence') {
|
||
events[index][1].type = 'data'
|
||
}
|
||
}
|
||
return events
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeAttention(effects, ok) {
|
||
const attentionMarkers = this.parser.constructs.attentionMarkers.null
|
||
const previous = this.previous
|
||
const before = classifyCharacter(previous)
|
||
|
||
/** @type {NonNullable<Code>} */
|
||
let marker
|
||
return start
|
||
|
||
/**
|
||
* Before a sequence.
|
||
*
|
||
* ```markdown
|
||
* > | **
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
marker = code
|
||
effects.enter('attentionSequence')
|
||
return inside(code)
|
||
}
|
||
|
||
/**
|
||
* In a sequence.
|
||
*
|
||
* ```markdown
|
||
* > | **
|
||
* ^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function inside(code) {
|
||
if (code === marker) {
|
||
effects.consume(code)
|
||
return inside
|
||
}
|
||
const token = effects.exit('attentionSequence')
|
||
|
||
// To do: next major: move this to resolver, just like `markdown-rs`.
|
||
const after = classifyCharacter(code)
|
||
|
||
// Always populated by defaults.
|
||
|
||
const open =
|
||
!after || (after === 2 && before) || attentionMarkers.includes(code)
|
||
const close =
|
||
!before || (before === 2 && after) || attentionMarkers.includes(previous)
|
||
token._open = Boolean(marker === 42 ? open : open && (before || !close))
|
||
token._close = Boolean(marker === 42 ? close : close && (after || !open))
|
||
return ok(code)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Move a point a bit.
|
||
*
|
||
* Note: `move` only works inside lines! It’s not possible to move past other
|
||
* chunks (replacement characters, tabs, or line endings).
|
||
*
|
||
* @param {Point} point
|
||
* @param {number} offset
|
||
* @returns {void}
|
||
*/
|
||
function movePoint(point, offset) {
|
||
point.column += offset
|
||
point.offset += offset
|
||
point._bufferIndex += offset
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/autolink.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
/** @type {Construct} */
|
||
const autolink = {
|
||
name: 'autolink',
|
||
tokenize: tokenizeAutolink
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeAutolink(effects, ok, nok) {
|
||
let size = 0
|
||
return start
|
||
|
||
/**
|
||
* Start of an autolink.
|
||
*
|
||
* ```markdown
|
||
* > | a<https://example.com>b
|
||
* ^
|
||
* > | a<user@example.com>b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('autolink')
|
||
effects.enter('autolinkMarker')
|
||
effects.consume(code)
|
||
effects.exit('autolinkMarker')
|
||
effects.enter('autolinkProtocol')
|
||
return open
|
||
}
|
||
|
||
/**
|
||
* After `<`, at protocol or atext.
|
||
*
|
||
* ```markdown
|
||
* > | a<https://example.com>b
|
||
* ^
|
||
* > | a<user@example.com>b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function open(code) {
|
||
if (asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
return schemeOrEmailAtext
|
||
}
|
||
return emailAtext(code)
|
||
}
|
||
|
||
/**
|
||
* At second byte of protocol or atext.
|
||
*
|
||
* ```markdown
|
||
* > | a<https://example.com>b
|
||
* ^
|
||
* > | a<user@example.com>b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function schemeOrEmailAtext(code) {
|
||
// ASCII alphanumeric and `+`, `-`, and `.`.
|
||
if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {
|
||
// Count the previous alphabetical from `open` too.
|
||
size = 1
|
||
return schemeInsideOrEmailAtext(code)
|
||
}
|
||
return emailAtext(code)
|
||
}
|
||
|
||
/**
|
||
* In ambiguous protocol or atext.
|
||
*
|
||
* ```markdown
|
||
* > | a<https://example.com>b
|
||
* ^
|
||
* > | a<user@example.com>b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function schemeInsideOrEmailAtext(code) {
|
||
if (code === 58) {
|
||
effects.consume(code)
|
||
size = 0
|
||
return urlInside
|
||
}
|
||
|
||
// ASCII alphanumeric and `+`, `-`, and `.`.
|
||
if (
|
||
(code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&
|
||
size++ < 32
|
||
) {
|
||
effects.consume(code)
|
||
return schemeInsideOrEmailAtext
|
||
}
|
||
size = 0
|
||
return emailAtext(code)
|
||
}
|
||
|
||
/**
|
||
* After protocol, in URL.
|
||
*
|
||
* ```markdown
|
||
* > | a<https://example.com>b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function urlInside(code) {
|
||
if (code === 62) {
|
||
effects.exit('autolinkProtocol')
|
||
effects.enter('autolinkMarker')
|
||
effects.consume(code)
|
||
effects.exit('autolinkMarker')
|
||
effects.exit('autolink')
|
||
return ok
|
||
}
|
||
|
||
// ASCII control, space, or `<`.
|
||
if (code === null || code === 32 || code === 60 || asciiControl(code)) {
|
||
return nok(code)
|
||
}
|
||
effects.consume(code)
|
||
return urlInside
|
||
}
|
||
|
||
/**
|
||
* In email atext.
|
||
*
|
||
* ```markdown
|
||
* > | a<user.name@example.com>b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function emailAtext(code) {
|
||
if (code === 64) {
|
||
effects.consume(code)
|
||
return emailAtSignOrDot
|
||
}
|
||
if (asciiAtext(code)) {
|
||
effects.consume(code)
|
||
return emailAtext
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In label, after at-sign or dot.
|
||
*
|
||
* ```markdown
|
||
* > | a<user.name@example.com>b
|
||
* ^ ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function emailAtSignOrDot(code) {
|
||
return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)
|
||
}
|
||
|
||
/**
|
||
* In label, where `.` and `>` are allowed.
|
||
*
|
||
* ```markdown
|
||
* > | a<user.name@example.com>b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function emailLabel(code) {
|
||
if (code === 46) {
|
||
effects.consume(code)
|
||
size = 0
|
||
return emailAtSignOrDot
|
||
}
|
||
if (code === 62) {
|
||
// Exit, then change the token type.
|
||
effects.exit('autolinkProtocol').type = 'autolinkEmail'
|
||
effects.enter('autolinkMarker')
|
||
effects.consume(code)
|
||
effects.exit('autolinkMarker')
|
||
effects.exit('autolink')
|
||
return ok
|
||
}
|
||
return emailValue(code)
|
||
}
|
||
|
||
/**
|
||
* In label, where `.` and `>` are *not* allowed.
|
||
*
|
||
* Though, this is also used in `emailLabel` to parse other values.
|
||
*
|
||
* ```markdown
|
||
* > | a<user.name@ex-ample.com>b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function emailValue(code) {
|
||
// ASCII alphanumeric or `-`.
|
||
if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {
|
||
const next = code === 45 ? emailValue : emailLabel
|
||
effects.consume(code)
|
||
return next
|
||
}
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/html-text.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const htmlText = {
|
||
name: 'htmlText',
|
||
tokenize: tokenizeHtmlText
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeHtmlText(effects, ok, nok) {
|
||
const self = this
|
||
/** @type {NonNullable<Code> | undefined} */
|
||
let marker
|
||
/** @type {number} */
|
||
let index
|
||
/** @type {State} */
|
||
let returnState
|
||
return start
|
||
|
||
/**
|
||
* Start of HTML (text).
|
||
*
|
||
* ```markdown
|
||
* > | a <b> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('htmlText')
|
||
effects.enter('htmlTextData')
|
||
effects.consume(code)
|
||
return open
|
||
}
|
||
|
||
/**
|
||
* After `<`, at tag name or other stuff.
|
||
*
|
||
* ```markdown
|
||
* > | a <b> c
|
||
* ^
|
||
* > | a <!doctype> c
|
||
* ^
|
||
* > | a <!--b--> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function open(code) {
|
||
if (code === 33) {
|
||
effects.consume(code)
|
||
return declarationOpen
|
||
}
|
||
if (code === 47) {
|
||
effects.consume(code)
|
||
return tagCloseStart
|
||
}
|
||
if (code === 63) {
|
||
effects.consume(code)
|
||
return instruction
|
||
}
|
||
|
||
// ASCII alphabetical.
|
||
if (asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
return tagOpen
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `<!`, at declaration, comment, or CDATA.
|
||
*
|
||
* ```markdown
|
||
* > | a <!doctype> c
|
||
* ^
|
||
* > | a <!--b--> c
|
||
* ^
|
||
* > | a <![CDATA[>&<]]> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function declarationOpen(code) {
|
||
if (code === 45) {
|
||
effects.consume(code)
|
||
return commentOpenInside
|
||
}
|
||
if (code === 91) {
|
||
effects.consume(code)
|
||
index = 0
|
||
return cdataOpenInside
|
||
}
|
||
if (asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
return declaration
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In a comment, after `<!-`, at another `-`.
|
||
*
|
||
* ```markdown
|
||
* > | a <!--b--> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function commentOpenInside(code) {
|
||
if (code === 45) {
|
||
effects.consume(code)
|
||
return commentEnd
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In comment.
|
||
*
|
||
* ```markdown
|
||
* > | a <!--b--> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function comment(code) {
|
||
if (code === null) {
|
||
return nok(code)
|
||
}
|
||
if (code === 45) {
|
||
effects.consume(code)
|
||
return commentClose
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
returnState = comment
|
||
return lineEndingBefore(code)
|
||
}
|
||
effects.consume(code)
|
||
return comment
|
||
}
|
||
|
||
/**
|
||
* In comment, after `-`.
|
||
*
|
||
* ```markdown
|
||
* > | a <!--b--> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function commentClose(code) {
|
||
if (code === 45) {
|
||
effects.consume(code)
|
||
return commentEnd
|
||
}
|
||
return comment(code)
|
||
}
|
||
|
||
/**
|
||
* In comment, after `--`.
|
||
*
|
||
* ```markdown
|
||
* > | a <!--b--> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function commentEnd(code) {
|
||
return code === 62
|
||
? end(code)
|
||
: code === 45
|
||
? commentClose(code)
|
||
: comment(code)
|
||
}
|
||
|
||
/**
|
||
* After `<![`, in CDATA, expecting `CDATA[`.
|
||
*
|
||
* ```markdown
|
||
* > | a <![CDATA[>&<]]> b
|
||
* ^^^^^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function cdataOpenInside(code) {
|
||
const value = 'CDATA['
|
||
if (code === value.charCodeAt(index++)) {
|
||
effects.consume(code)
|
||
return index === value.length ? cdata : cdataOpenInside
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In CDATA.
|
||
*
|
||
* ```markdown
|
||
* > | a <![CDATA[>&<]]> b
|
||
* ^^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function cdata(code) {
|
||
if (code === null) {
|
||
return nok(code)
|
||
}
|
||
if (code === 93) {
|
||
effects.consume(code)
|
||
return cdataClose
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
returnState = cdata
|
||
return lineEndingBefore(code)
|
||
}
|
||
effects.consume(code)
|
||
return cdata
|
||
}
|
||
|
||
/**
|
||
* In CDATA, after `]`, at another `]`.
|
||
*
|
||
* ```markdown
|
||
* > | a <![CDATA[>&<]]> b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function cdataClose(code) {
|
||
if (code === 93) {
|
||
effects.consume(code)
|
||
return cdataEnd
|
||
}
|
||
return cdata(code)
|
||
}
|
||
|
||
/**
|
||
* In CDATA, after `]]`, at `>`.
|
||
*
|
||
* ```markdown
|
||
* > | a <![CDATA[>&<]]> b
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function cdataEnd(code) {
|
||
if (code === 62) {
|
||
return end(code)
|
||
}
|
||
if (code === 93) {
|
||
effects.consume(code)
|
||
return cdataEnd
|
||
}
|
||
return cdata(code)
|
||
}
|
||
|
||
/**
|
||
* In declaration.
|
||
*
|
||
* ```markdown
|
||
* > | a <!b> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function declaration(code) {
|
||
if (code === null || code === 62) {
|
||
return end(code)
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
returnState = declaration
|
||
return lineEndingBefore(code)
|
||
}
|
||
effects.consume(code)
|
||
return declaration
|
||
}
|
||
|
||
/**
|
||
* In instruction.
|
||
*
|
||
* ```markdown
|
||
* > | a <?b?> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function instruction(code) {
|
||
if (code === null) {
|
||
return nok(code)
|
||
}
|
||
if (code === 63) {
|
||
effects.consume(code)
|
||
return instructionClose
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
returnState = instruction
|
||
return lineEndingBefore(code)
|
||
}
|
||
effects.consume(code)
|
||
return instruction
|
||
}
|
||
|
||
/**
|
||
* In instruction, after `?`, at `>`.
|
||
*
|
||
* ```markdown
|
||
* > | a <?b?> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function instructionClose(code) {
|
||
return code === 62 ? end(code) : instruction(code)
|
||
}
|
||
|
||
/**
|
||
* After `</`, in closing tag, at tag name.
|
||
*
|
||
* ```markdown
|
||
* > | a </b> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagCloseStart(code) {
|
||
// ASCII alphabetical.
|
||
if (asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
return tagClose
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* After `</x`, in a tag name.
|
||
*
|
||
* ```markdown
|
||
* > | a </b> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagClose(code) {
|
||
// ASCII alphanumerical and `-`.
|
||
if (code === 45 || asciiAlphanumeric(code)) {
|
||
effects.consume(code)
|
||
return tagClose
|
||
}
|
||
return tagCloseBetween(code)
|
||
}
|
||
|
||
/**
|
||
* In closing tag, after tag name.
|
||
*
|
||
* ```markdown
|
||
* > | a </b> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagCloseBetween(code) {
|
||
if (markdownLineEnding(code)) {
|
||
returnState = tagCloseBetween
|
||
return lineEndingBefore(code)
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return tagCloseBetween
|
||
}
|
||
return end(code)
|
||
}
|
||
|
||
/**
|
||
* After `<x`, in opening tag name.
|
||
*
|
||
* ```markdown
|
||
* > | a <b> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagOpen(code) {
|
||
// ASCII alphanumerical and `-`.
|
||
if (code === 45 || asciiAlphanumeric(code)) {
|
||
effects.consume(code)
|
||
return tagOpen
|
||
}
|
||
if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
|
||
return tagOpenBetween(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In opening tag, after tag name.
|
||
*
|
||
* ```markdown
|
||
* > | a <b> c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagOpenBetween(code) {
|
||
if (code === 47) {
|
||
effects.consume(code)
|
||
return end
|
||
}
|
||
|
||
// ASCII alphabetical and `:` and `_`.
|
||
if (code === 58 || code === 95 || asciiAlpha(code)) {
|
||
effects.consume(code)
|
||
return tagOpenAttributeName
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
returnState = tagOpenBetween
|
||
return lineEndingBefore(code)
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return tagOpenBetween
|
||
}
|
||
return end(code)
|
||
}
|
||
|
||
/**
|
||
* In attribute name.
|
||
*
|
||
* ```markdown
|
||
* > | a <b c> d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagOpenAttributeName(code) {
|
||
// ASCII alphabetical and `-`, `.`, `:`, and `_`.
|
||
if (
|
||
code === 45 ||
|
||
code === 46 ||
|
||
code === 58 ||
|
||
code === 95 ||
|
||
asciiAlphanumeric(code)
|
||
) {
|
||
effects.consume(code)
|
||
return tagOpenAttributeName
|
||
}
|
||
return tagOpenAttributeNameAfter(code)
|
||
}
|
||
|
||
/**
|
||
* After attribute name, before initializer, the end of the tag, or
|
||
* whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | a <b c> d
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagOpenAttributeNameAfter(code) {
|
||
if (code === 61) {
|
||
effects.consume(code)
|
||
return tagOpenAttributeValueBefore
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
returnState = tagOpenAttributeNameAfter
|
||
return lineEndingBefore(code)
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return tagOpenAttributeNameAfter
|
||
}
|
||
return tagOpenBetween(code)
|
||
}
|
||
|
||
/**
|
||
* Before unquoted, double quoted, or single quoted attribute value, allowing
|
||
* whitespace.
|
||
*
|
||
* ```markdown
|
||
* > | a <b c=d> e
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagOpenAttributeValueBefore(code) {
|
||
if (
|
||
code === null ||
|
||
code === 60 ||
|
||
code === 61 ||
|
||
code === 62 ||
|
||
code === 96
|
||
) {
|
||
return nok(code)
|
||
}
|
||
if (code === 34 || code === 39) {
|
||
effects.consume(code)
|
||
marker = code
|
||
return tagOpenAttributeValueQuoted
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
returnState = tagOpenAttributeValueBefore
|
||
return lineEndingBefore(code)
|
||
}
|
||
if (markdownSpace(code)) {
|
||
effects.consume(code)
|
||
return tagOpenAttributeValueBefore
|
||
}
|
||
effects.consume(code)
|
||
return tagOpenAttributeValueUnquoted
|
||
}
|
||
|
||
/**
|
||
* In double or single quoted attribute value.
|
||
*
|
||
* ```markdown
|
||
* > | a <b c="d"> e
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagOpenAttributeValueQuoted(code) {
|
||
if (code === marker) {
|
||
effects.consume(code)
|
||
marker = undefined
|
||
return tagOpenAttributeValueQuotedAfter
|
||
}
|
||
if (code === null) {
|
||
return nok(code)
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
returnState = tagOpenAttributeValueQuoted
|
||
return lineEndingBefore(code)
|
||
}
|
||
effects.consume(code)
|
||
return tagOpenAttributeValueQuoted
|
||
}
|
||
|
||
/**
|
||
* In unquoted attribute value.
|
||
*
|
||
* ```markdown
|
||
* > | a <b c=d> e
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagOpenAttributeValueUnquoted(code) {
|
||
if (
|
||
code === null ||
|
||
code === 34 ||
|
||
code === 39 ||
|
||
code === 60 ||
|
||
code === 61 ||
|
||
code === 96
|
||
) {
|
||
return nok(code)
|
||
}
|
||
if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
|
||
return tagOpenBetween(code)
|
||
}
|
||
effects.consume(code)
|
||
return tagOpenAttributeValueUnquoted
|
||
}
|
||
|
||
/**
|
||
* After double or single quoted attribute value, before whitespace or the end
|
||
* of the tag.
|
||
*
|
||
* ```markdown
|
||
* > | a <b c="d"> e
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function tagOpenAttributeValueQuotedAfter(code) {
|
||
if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
|
||
return tagOpenBetween(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* In certain circumstances of a tag where only an `>` is allowed.
|
||
*
|
||
* ```markdown
|
||
* > | a <b c="d"> e
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function end(code) {
|
||
if (code === 62) {
|
||
effects.consume(code)
|
||
effects.exit('htmlTextData')
|
||
effects.exit('htmlText')
|
||
return ok
|
||
}
|
||
return nok(code)
|
||
}
|
||
|
||
/**
|
||
* At eol.
|
||
*
|
||
* > 👉 **Note**: we can’t have blank lines in text, so no need to worry about
|
||
* > empty tokens.
|
||
*
|
||
* ```markdown
|
||
* > | a <!--a
|
||
* ^
|
||
* | b-->
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function lineEndingBefore(code) {
|
||
effects.exit('htmlTextData')
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return lineEndingAfter
|
||
}
|
||
|
||
/**
|
||
* After eol, at optional whitespace.
|
||
*
|
||
* > 👉 **Note**: we can’t have blank lines in text, so no need to worry about
|
||
* > empty tokens.
|
||
*
|
||
* ```markdown
|
||
* | a <!--a
|
||
* > | b-->
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function lineEndingAfter(code) {
|
||
// Always populated by defaults.
|
||
|
||
return markdownSpace(code)
|
||
? factorySpace(
|
||
effects,
|
||
lineEndingAfterPrefix,
|
||
'linePrefix',
|
||
self.parser.constructs.disable.null.includes('codeIndented')
|
||
? undefined
|
||
: 4
|
||
)(code)
|
||
: lineEndingAfterPrefix(code)
|
||
}
|
||
|
||
/**
|
||
* After eol, after optional whitespace.
|
||
*
|
||
* > 👉 **Note**: we can’t have blank lines in text, so no need to worry about
|
||
* > empty tokens.
|
||
*
|
||
* ```markdown
|
||
* | a <!--a
|
||
* > | b-->
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function lineEndingAfterPrefix(code) {
|
||
effects.enter('htmlTextData')
|
||
return returnState(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/label-start-link.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
|
||
/** @type {Construct} */
|
||
const labelStartLink = {
|
||
name: 'labelStartLink',
|
||
tokenize: tokenizeLabelStartLink,
|
||
resolveAll: labelEnd.resolveAll
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeLabelStartLink(effects, ok, nok) {
|
||
const self = this
|
||
return start
|
||
|
||
/**
|
||
* Start of label (link) start.
|
||
*
|
||
* ```markdown
|
||
* > | a [b] c
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('labelLink')
|
||
effects.enter('labelMarker')
|
||
effects.consume(code)
|
||
effects.exit('labelMarker')
|
||
effects.exit('labelLink')
|
||
return after
|
||
}
|
||
|
||
/** @type {State} */
|
||
function after(code) {
|
||
// To do: this isn’t needed in `micromark-extension-gfm-footnote`,
|
||
// remove.
|
||
// Hidden footnotes hook.
|
||
/* c8 ignore next 3 */
|
||
return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs
|
||
? nok(code)
|
||
: ok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/hard-break-escape.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
/** @type {Construct} */
|
||
const hardBreakEscape = {
|
||
name: 'hardBreakEscape',
|
||
tokenize: tokenizeHardBreakEscape
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeHardBreakEscape(effects, ok, nok) {
|
||
return start
|
||
|
||
/**
|
||
* Start of a hard break (escape).
|
||
*
|
||
* ```markdown
|
||
* > | a\
|
||
* ^
|
||
* | b
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('hardBreakEscape')
|
||
effects.consume(code)
|
||
return after
|
||
}
|
||
|
||
/**
|
||
* After `\`, at eol.
|
||
*
|
||
* ```markdown
|
||
* > | a\
|
||
* ^
|
||
* | b
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function after(code) {
|
||
if (markdownLineEnding(code)) {
|
||
effects.exit('hardBreakEscape')
|
||
return ok(code)
|
||
}
|
||
return nok(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-core-commonmark/lib/code-text.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Previous} Previous
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
|
||
/** @type {Construct} */
|
||
const codeText = {
|
||
name: 'codeText',
|
||
tokenize: tokenizeCodeText,
|
||
resolve: resolveCodeText,
|
||
previous
|
||
}
|
||
|
||
// To do: next major: don’t resolve, like `markdown-rs`.
|
||
/** @type {Resolver} */
|
||
function resolveCodeText(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 === 'lineEnding' ||
|
||
events[headEnterIndex][1].type === 'space') &&
|
||
(events[tailExitIndex][1].type === 'lineEnding' ||
|
||
events[tailExitIndex][1].type === 'space')
|
||
) {
|
||
index = headEnterIndex
|
||
|
||
// And we have data.
|
||
while (++index < tailExitIndex) {
|
||
if (events[index][1].type === 'codeTextData') {
|
||
// Then we have padding.
|
||
events[headEnterIndex][1].type = 'codeTextPadding'
|
||
events[tailExitIndex][1].type = 'codeTextPadding'
|
||
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 !== 'lineEnding') {
|
||
enter = index
|
||
}
|
||
} else if (
|
||
index === tailExitIndex ||
|
||
events[index][1].type === 'lineEnding'
|
||
) {
|
||
events[enter][1].type = 'codeTextData'
|
||
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 !== 96 ||
|
||
this.events[this.events.length - 1][1].type === 'characterEscape'
|
||
)
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeCodeText(effects, ok, nok) {
|
||
const self = this
|
||
let sizeOpen = 0
|
||
/** @type {number} */
|
||
let size
|
||
/** @type {Token} */
|
||
let token
|
||
return start
|
||
|
||
/**
|
||
* Start of code (text).
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^
|
||
* > | \`a`
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
effects.enter('codeText')
|
||
effects.enter('codeTextSequence')
|
||
return sequenceOpen(code)
|
||
}
|
||
|
||
/**
|
||
* In opening sequence.
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceOpen(code) {
|
||
if (code === 96) {
|
||
effects.consume(code)
|
||
sizeOpen++
|
||
return sequenceOpen
|
||
}
|
||
effects.exit('codeTextSequence')
|
||
return between(code)
|
||
}
|
||
|
||
/**
|
||
* Between something and something else.
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function between(code) {
|
||
// EOF.
|
||
if (code === null) {
|
||
return nok(code)
|
||
}
|
||
|
||
// To do: next major: don’t do spaces in resolve, but when compiling,
|
||
// like `markdown-rs`.
|
||
// Tabs don’t work, and virtual spaces don’t make sense.
|
||
if (code === 32) {
|
||
effects.enter('space')
|
||
effects.consume(code)
|
||
effects.exit('space')
|
||
return between
|
||
}
|
||
|
||
// Closing fence? Could also be data.
|
||
if (code === 96) {
|
||
token = effects.enter('codeTextSequence')
|
||
size = 0
|
||
return sequenceClose(code)
|
||
}
|
||
if (markdownLineEnding(code)) {
|
||
effects.enter('lineEnding')
|
||
effects.consume(code)
|
||
effects.exit('lineEnding')
|
||
return between
|
||
}
|
||
|
||
// Data.
|
||
effects.enter('codeTextData')
|
||
return data(code)
|
||
}
|
||
|
||
/**
|
||
* In data.
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function data(code) {
|
||
if (
|
||
code === null ||
|
||
code === 32 ||
|
||
code === 96 ||
|
||
markdownLineEnding(code)
|
||
) {
|
||
effects.exit('codeTextData')
|
||
return between(code)
|
||
}
|
||
effects.consume(code)
|
||
return data
|
||
}
|
||
|
||
/**
|
||
* In closing sequence.
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceClose(code) {
|
||
// More.
|
||
if (code === 96) {
|
||
effects.consume(code)
|
||
size++
|
||
return sequenceClose
|
||
}
|
||
|
||
// Done!
|
||
if (size === sizeOpen) {
|
||
effects.exit('codeTextSequence')
|
||
effects.exit('codeText')
|
||
return ok(code)
|
||
}
|
||
|
||
// More or less accents: mark as data.
|
||
token.type = 'codeTextData'
|
||
return data(code)
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/constructs.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Extension} Extension
|
||
*/
|
||
|
||
|
||
|
||
|
||
/** @satisfies {Extension['document']} */
|
||
const constructs_document = {
|
||
[42]: list,
|
||
[43]: list,
|
||
[45]: list,
|
||
[48]: list,
|
||
[49]: list,
|
||
[50]: list,
|
||
[51]: list,
|
||
[52]: list,
|
||
[53]: list,
|
||
[54]: list,
|
||
[55]: list,
|
||
[56]: list,
|
||
[57]: list,
|
||
[62]: blockQuote
|
||
}
|
||
|
||
/** @satisfies {Extension['contentInitial']} */
|
||
const contentInitial = {
|
||
[91]: definition
|
||
}
|
||
|
||
/** @satisfies {Extension['flowInitial']} */
|
||
const flowInitial = {
|
||
[-2]: codeIndented,
|
||
[-1]: codeIndented,
|
||
[32]: codeIndented
|
||
}
|
||
|
||
/** @satisfies {Extension['flow']} */
|
||
const constructs_flow = {
|
||
[35]: headingAtx,
|
||
[42]: thematicBreak,
|
||
[45]: [setextUnderline, thematicBreak],
|
||
[60]: htmlFlow,
|
||
[61]: setextUnderline,
|
||
[95]: thematicBreak,
|
||
[96]: codeFenced,
|
||
[126]: codeFenced
|
||
}
|
||
|
||
/** @satisfies {Extension['string']} */
|
||
const constructs_string = {
|
||
[38]: characterReference,
|
||
[92]: characterEscape
|
||
}
|
||
|
||
/** @satisfies {Extension['text']} */
|
||
const constructs_text = {
|
||
[-5]: lineEnding,
|
||
[-4]: lineEnding,
|
||
[-3]: lineEnding,
|
||
[33]: labelStartImage,
|
||
[38]: characterReference,
|
||
[42]: attention,
|
||
[60]: [autolink, htmlText],
|
||
[91]: labelStartLink,
|
||
[92]: [hardBreakEscape, characterEscape],
|
||
[93]: labelEnd,
|
||
[95]: attention,
|
||
[96]: codeText
|
||
}
|
||
|
||
/** @satisfies {Extension['insideSpan']} */
|
||
const insideSpan = {
|
||
null: [attention, resolver]
|
||
}
|
||
|
||
/** @satisfies {Extension['attentionMarkers']} */
|
||
const attentionMarkers = {
|
||
null: [42, 95]
|
||
}
|
||
|
||
/** @satisfies {Extension['disable']} */
|
||
const disable = {
|
||
null: []
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/parse.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Create} Create
|
||
* @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension
|
||
* @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
|
||
* @typedef {import('micromark-util-types').ParseContext} ParseContext
|
||
* @typedef {import('micromark-util-types').ParseOptions} ParseOptions
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/**
|
||
* @param {ParseOptions | null | undefined} [options]
|
||
* @returns {ParseContext}
|
||
*/
|
||
function parse(options) {
|
||
const settings = options || {}
|
||
const constructs =
|
||
/** @type {FullNormalizedExtension} */
|
||
combineExtensions([constructs_namespaceObject, ...(settings.extensions || [])])
|
||
|
||
/** @type {ParseContext} */
|
||
const parser = {
|
||
defined: [],
|
||
lazy: {},
|
||
constructs,
|
||
content: create(content),
|
||
document: create(document_document),
|
||
flow: create(flow),
|
||
string: create(string),
|
||
text: create(text_text)
|
||
}
|
||
return parser
|
||
|
||
/**
|
||
* @param {InitialConstruct} initial
|
||
*/
|
||
function create(initial) {
|
||
return creator
|
||
/** @type {Create} */
|
||
function creator(from) {
|
||
return createTokenizer(parser, initial, from)
|
||
}
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/preprocess.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Chunk} Chunk
|
||
* @typedef {import('micromark-util-types').Code} Code
|
||
* @typedef {import('micromark-util-types').Encoding} Encoding
|
||
* @typedef {import('micromark-util-types').Value} Value
|
||
*/
|
||
|
||
/**
|
||
* @callback Preprocessor
|
||
* @param {Value} value
|
||
* @param {Encoding | null | undefined} [encoding]
|
||
* @param {boolean | null | undefined} [end=false]
|
||
* @returns {Array<Chunk>}
|
||
*/
|
||
|
||
const search = /[\0\t\n\r]/g
|
||
|
||
/**
|
||
* @returns {Preprocessor}
|
||
*/
|
||
function preprocess() {
|
||
let column = 1
|
||
let buffer = ''
|
||
/** @type {boolean | undefined} */
|
||
let start = true
|
||
/** @type {boolean | undefined} */
|
||
let atCarriageReturn
|
||
return preprocessor
|
||
|
||
/** @type {Preprocessor} */
|
||
function preprocessor(value, encoding, end) {
|
||
/** @type {Array<Chunk>} */
|
||
const chunks = []
|
||
/** @type {RegExpMatchArray | null} */
|
||
let match
|
||
/** @type {number} */
|
||
let next
|
||
/** @type {number} */
|
||
let startPosition
|
||
/** @type {number} */
|
||
let endPosition
|
||
/** @type {Code} */
|
||
let code
|
||
|
||
// @ts-expect-error `Buffer` does allow an encoding.
|
||
value = buffer + value.toString(encoding)
|
||
startPosition = 0
|
||
buffer = ''
|
||
if (start) {
|
||
// To do: `markdown-rs` actually parses BOMs (byte order mark).
|
||
if (value.charCodeAt(0) === 65279) {
|
||
startPosition++
|
||
}
|
||
start = undefined
|
||
}
|
||
while (startPosition < value.length) {
|
||
search.lastIndex = startPosition
|
||
match = search.exec(value)
|
||
endPosition =
|
||
match && match.index !== undefined ? match.index : value.length
|
||
code = value.charCodeAt(endPosition)
|
||
if (!match) {
|
||
buffer = value.slice(startPosition)
|
||
break
|
||
}
|
||
if (code === 10 && startPosition === endPosition && atCarriageReturn) {
|
||
chunks.push(-3)
|
||
atCarriageReturn = undefined
|
||
} else {
|
||
if (atCarriageReturn) {
|
||
chunks.push(-5)
|
||
atCarriageReturn = undefined
|
||
}
|
||
if (startPosition < endPosition) {
|
||
chunks.push(value.slice(startPosition, endPosition))
|
||
column += endPosition - startPosition
|
||
}
|
||
switch (code) {
|
||
case 0: {
|
||
chunks.push(65533)
|
||
column++
|
||
break
|
||
}
|
||
case 9: {
|
||
next = Math.ceil(column / 4) * 4
|
||
chunks.push(-2)
|
||
while (column++ < next) chunks.push(-1)
|
||
break
|
||
}
|
||
case 10: {
|
||
chunks.push(-4)
|
||
column = 1
|
||
break
|
||
}
|
||
default: {
|
||
atCarriageReturn = true
|
||
column = 1
|
||
}
|
||
}
|
||
}
|
||
startPosition = endPosition + 1
|
||
}
|
||
if (end) {
|
||
if (atCarriageReturn) chunks.push(-5)
|
||
if (buffer) chunks.push(buffer)
|
||
chunks.push(null)
|
||
}
|
||
return chunks
|
||
}
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark/lib/postprocess.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Event} Event
|
||
*/
|
||
|
||
|
||
|
||
/**
|
||
* @param {Array<Event>} events
|
||
* @returns {Array<Event>}
|
||
*/
|
||
function postprocess(events) {
|
||
while (!subtokenize(events)) {
|
||
// Empty
|
||
}
|
||
return events
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-decode-numeric-character-reference/index.js
|
||
/**
|
||
* Turn the number (in string form as either hexa- or plain decimal) coming from
|
||
* a numeric character reference into a character.
|
||
*
|
||
* Sort of like `String.fromCharCode(Number.parseInt(value, base))`, but makes
|
||
* non-characters and control characters safe.
|
||
*
|
||
* @param {string} value
|
||
* Value to decode.
|
||
* @param {number} base
|
||
* Numeric base.
|
||
* @returns {string}
|
||
* Character.
|
||
*/
|
||
function decodeNumericCharacterReference(value, base) {
|
||
const code = Number.parseInt(value, base)
|
||
if (
|
||
// C0 except for HT, LF, FF, CR, space.
|
||
code < 9 ||
|
||
code === 11 ||
|
||
(code > 13 && code < 32) ||
|
||
// Control character (DEL) of C0, and C1 controls.
|
||
(code > 126 && code < 160) ||
|
||
// Lone high surrogates and low surrogates.
|
||
(code > 55295 && code < 57344) ||
|
||
// Noncharacters.
|
||
(code > 64975 && code < 65008) /* eslint-disable no-bitwise */ ||
|
||
(code & 65535) === 65535 ||
|
||
(code & 65535) === 65534 /* eslint-enable no-bitwise */ ||
|
||
// Out of range
|
||
code > 1114111
|
||
) {
|
||
return '\uFFFD'
|
||
}
|
||
return String.fromCharCode(code)
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/micromark-util-decode-string/index.js
|
||
|
||
|
||
const characterEscapeOrReference =
|
||
/\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi
|
||
|
||
/**
|
||
* Decode markdown strings (which occur in places such as fenced code info
|
||
* strings, destinations, labels, and titles).
|
||
*
|
||
* The “string” content type allows character escapes and -references.
|
||
* This decodes those.
|
||
*
|
||
* @param {string} value
|
||
* Value to decode.
|
||
* @returns {string}
|
||
* Decoded value.
|
||
*/
|
||
function decodeString(value) {
|
||
return value.replace(characterEscapeOrReference, decode)
|
||
}
|
||
|
||
/**
|
||
* @param {string} $0
|
||
* @param {string} $1
|
||
* @param {string} $2
|
||
* @returns {string}
|
||
*/
|
||
function decode($0, $1, $2) {
|
||
if ($1) {
|
||
// Escape.
|
||
return $1
|
||
}
|
||
|
||
// Reference.
|
||
const head = $2.charCodeAt(0)
|
||
if (head === 35) {
|
||
const head = $2.charCodeAt(1)
|
||
const hex = head === 120 || head === 88
|
||
return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)
|
||
}
|
||
return decodeNamedCharacterReference($2) || $0
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/unist-util-stringify-position/lib/index.js
|
||
/**
|
||
* @typedef {import('unist').Node} Node
|
||
* @typedef {import('unist').Point} Point
|
||
* @typedef {import('unist').Position} Position
|
||
*/
|
||
|
||
/**
|
||
* @typedef NodeLike
|
||
* @property {string} type
|
||
* @property {PositionLike | null | undefined} [position]
|
||
*
|
||
* @typedef PositionLike
|
||
* @property {PointLike | null | undefined} [start]
|
||
* @property {PointLike | null | undefined} [end]
|
||
*
|
||
* @typedef PointLike
|
||
* @property {number | null | undefined} [line]
|
||
* @property {number | null | undefined} [column]
|
||
* @property {number | null | undefined} [offset]
|
||
*/
|
||
|
||
/**
|
||
* Serialize the positional info of a point, position (start and end points),
|
||
* or node.
|
||
*
|
||
* @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]
|
||
* Node, position, or point.
|
||
* @returns {string}
|
||
* Pretty printed positional info of a node (`string`).
|
||
*
|
||
* In the format of a range `ls:cs-le:ce` (when given `node` or `position`)
|
||
* or a point `l:c` (when given `point`), where `l` stands for line, `c` for
|
||
* column, `s` for `start`, and `e` for end.
|
||
* An empty string (`''`) is returned if the given value is neither `node`,
|
||
* `position`, nor `point`.
|
||
*/
|
||
function stringifyPosition(value) {
|
||
// Nothing.
|
||
if (!value || typeof value !== 'object') {
|
||
return ''
|
||
}
|
||
|
||
// Node.
|
||
if ('position' in value || 'type' in value) {
|
||
return position(value.position)
|
||
}
|
||
|
||
// Position.
|
||
if ('start' in value || 'end' in value) {
|
||
return position(value)
|
||
}
|
||
|
||
// Point.
|
||
if ('line' in value || 'column' in value) {
|
||
return point(value)
|
||
}
|
||
|
||
// ?
|
||
return ''
|
||
}
|
||
|
||
/**
|
||
* @param {Point | PointLike | null | undefined} point
|
||
* @returns {string}
|
||
*/
|
||
function point(point) {
|
||
return index(point && point.line) + ':' + index(point && point.column)
|
||
}
|
||
|
||
/**
|
||
* @param {Position | PositionLike | null | undefined} pos
|
||
* @returns {string}
|
||
*/
|
||
function position(pos) {
|
||
return point(pos && pos.start) + '-' + point(pos && pos.end)
|
||
}
|
||
|
||
/**
|
||
* @param {number | null | undefined} value
|
||
* @returns {number}
|
||
*/
|
||
function index(value) {
|
||
return value && typeof value === 'number' ? value : 1
|
||
}
|
||
|
||
;// CONCATENATED MODULE: ../node_modules/mdast-util-from-markdown/lib/index.js
|
||
/**
|
||
* @typedef {import('micromark-util-types').Encoding} Encoding
|
||
* @typedef {import('micromark-util-types').Event} Event
|
||
* @typedef {import('micromark-util-types').ParseOptions} ParseOptions
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Value} Value
|
||
*
|
||
* @typedef {import('unist').Parent} UnistParent
|
||
* @typedef {import('unist').Point} Point
|
||
*
|
||
* @typedef {import('mdast').PhrasingContent} PhrasingContent
|
||
* @typedef {import('mdast').StaticPhrasingContent} StaticPhrasingContent
|
||
* @typedef {import('mdast').Content} Content
|
||
* @typedef {import('mdast').Break} Break
|
||
* @typedef {import('mdast').Blockquote} Blockquote
|
||
* @typedef {import('mdast').Code} Code
|
||
* @typedef {import('mdast').Definition} Definition
|
||
* @typedef {import('mdast').Emphasis} Emphasis
|
||
* @typedef {import('mdast').Heading} Heading
|
||
* @typedef {import('mdast').HTML} HTML
|
||
* @typedef {import('mdast').Image} Image
|
||
* @typedef {import('mdast').ImageReference} ImageReference
|
||
* @typedef {import('mdast').InlineCode} InlineCode
|
||
* @typedef {import('mdast').Link} Link
|
||
* @typedef {import('mdast').LinkReference} LinkReference
|
||
* @typedef {import('mdast').List} List
|
||
* @typedef {import('mdast').ListItem} ListItem
|
||
* @typedef {import('mdast').Paragraph} Paragraph
|
||
* @typedef {import('mdast').Root} Root
|
||
* @typedef {import('mdast').Strong} Strong
|
||
* @typedef {import('mdast').Text} Text
|
||
* @typedef {import('mdast').ThematicBreak} ThematicBreak
|
||
* @typedef {import('mdast').ReferenceType} ReferenceType
|
||
* @typedef {import('../index.js').CompileData} CompileData
|
||
*/
|
||
|
||
/**
|
||
* @typedef {Root | Content} Node
|
||
* @typedef {Extract<Node, UnistParent>} Parent
|
||
*
|
||
* @typedef {Omit<UnistParent, 'type' | 'children'> & {type: 'fragment', children: Array<PhrasingContent>}} Fragment
|
||
*/
|
||
|
||
/**
|
||
* @callback Transform
|
||
* Extra transform, to change the AST afterwards.
|
||
* @param {Root} tree
|
||
* Tree to transform.
|
||
* @returns {Root | undefined | null | void}
|
||
* New tree or nothing (in which case the current tree is used).
|
||
*
|
||
* @callback Handle
|
||
* Handle a token.
|
||
* @param {CompileContext} this
|
||
* Context.
|
||
* @param {Token} token
|
||
* Current token.
|
||
* @returns {void}
|
||
* Nothing.
|
||
*
|
||
* @typedef {Record<string, Handle>} Handles
|
||
* Token types mapping to handles
|
||
*
|
||
* @callback OnEnterError
|
||
* Handle the case where the `right` token is open, but it is closed (by the
|
||
* `left` token) or because we reached the end of the document.
|
||
* @param {Omit<CompileContext, 'sliceSerialize'>} this
|
||
* Context.
|
||
* @param {Token | undefined} left
|
||
* Left token.
|
||
* @param {Token} right
|
||
* Right token.
|
||
* @returns {void}
|
||
* Nothing.
|
||
*
|
||
* @callback OnExitError
|
||
* Handle the case where the `right` token is open but it is closed by
|
||
* exiting the `left` token.
|
||
* @param {Omit<CompileContext, 'sliceSerialize'>} this
|
||
* Context.
|
||
* @param {Token} left
|
||
* Left token.
|
||
* @param {Token} right
|
||
* Right token.
|
||
* @returns {void}
|
||
* Nothing.
|
||
*
|
||
* @typedef {[Token, OnEnterError | undefined]} TokenTuple
|
||
* Open token on the stack, with an optional error handler for when
|
||
* that token isn’t closed properly.
|
||
*/
|
||
|
||
/**
|
||
* @typedef Config
|
||
* Configuration.
|
||
*
|
||
* We have our defaults, but extensions will add more.
|
||
* @property {Array<string>} canContainEols
|
||
* Token types where line endings are used.
|
||
* @property {Handles} enter
|
||
* Opening handles.
|
||
* @property {Handles} exit
|
||
* Closing handles.
|
||
* @property {Array<Transform>} transforms
|
||
* Tree transforms.
|
||
*
|
||
* @typedef {Partial<Config>} Extension
|
||
* Change how markdown tokens from micromark are turned into mdast.
|
||
*
|
||
* @typedef CompileContext
|
||
* mdast compiler context.
|
||
* @property {Array<Node | Fragment>} stack
|
||
* Stack of nodes.
|
||
* @property {Array<TokenTuple>} tokenStack
|
||
* Stack of tokens.
|
||
* @property {<Key extends keyof CompileData>(key: Key) => CompileData[Key]} getData
|
||
* Get data from the key/value store.
|
||
* @property {<Key extends keyof CompileData>(key: Key, value?: CompileData[Key]) => void} setData
|
||
* Set data into the key/value store.
|
||
* @property {(this: CompileContext) => void} buffer
|
||
* Capture some of the output data.
|
||
* @property {(this: CompileContext) => string} resume
|
||
* Stop capturing and access the output data.
|
||
* @property {<Kind extends Node>(this: CompileContext, node: Kind, token: Token, onError?: OnEnterError) => Kind} enter
|
||
* Enter a token.
|
||
* @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit
|
||
* Exit a token.
|
||
* @property {TokenizeContext['sliceSerialize']} sliceSerialize
|
||
* Get the string value of a token.
|
||
* @property {Config} config
|
||
* Configuration.
|
||
*
|
||
* @typedef FromMarkdownOptions
|
||
* Configuration for how to build mdast.
|
||
* @property {Array<Extension | Array<Extension>> | null | undefined} [mdastExtensions]
|
||
* Extensions for this utility to change how tokens are turned into a tree.
|
||
*
|
||
* @typedef {ParseOptions & FromMarkdownOptions} Options
|
||
* Configuration.
|
||
*/
|
||
|
||
// To do: micromark: create a registry of tokens?
|
||
// To do: next major: don’t return given `Node` from `enter`.
|
||
// To do: next major: remove setter/getter.
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
const own = {}.hasOwnProperty
|
||
|
||
/**
|
||
* @param value
|
||
* Markdown to parse.
|
||
* @param encoding
|
||
* Character encoding for when `value` is `Buffer`.
|
||
* @param options
|
||
* Configuration.
|
||
* @returns
|
||
* mdast tree.
|
||
*/
|
||
const fromMarkdown =
|
||
/**
|
||
* @type {(
|
||
* ((value: Value, encoding: Encoding, options?: Options | null | undefined) => Root) &
|
||
* ((value: Value, options?: Options | null | undefined) => Root)
|
||
* )}
|
||
*/
|
||
|
||
/**
|
||
* @param {Value} value
|
||
* @param {Encoding | Options | null | undefined} [encoding]
|
||
* @param {Options | null | undefined} [options]
|
||
* @returns {Root}
|
||
*/
|
||
function (value, encoding, options) {
|
||
if (typeof encoding !== 'string') {
|
||
options = encoding
|
||
encoding = undefined
|
||
}
|
||
return compiler(options)(
|
||
postprocess(
|
||
parse(options).document().write(preprocess()(value, encoding, true))
|
||
)
|
||
)
|
||
}
|
||
|
||
/**
|
||
* Note this compiler only understand complete buffering, not streaming.
|
||
*
|
||
* @param {Options | null | undefined} [options]
|
||
*/
|
||
function compiler(options) {
|
||
/** @type {Config} */
|
||
const config = {
|
||
transforms: [],
|
||
canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],
|
||
enter: {
|
||
autolink: opener(link),
|
||
autolinkProtocol: onenterdata,
|
||
autolinkEmail: onenterdata,
|
||
atxHeading: opener(heading),
|
||
blockQuote: opener(blockQuote),
|
||
characterEscape: onenterdata,
|
||
characterReference: onenterdata,
|
||
codeFenced: opener(codeFlow),
|
||
codeFencedFenceInfo: buffer,
|
||
codeFencedFenceMeta: buffer,
|
||
codeIndented: opener(codeFlow, buffer),
|
||
codeText: opener(codeText, buffer),
|
||
codeTextData: onenterdata,
|
||
data: onenterdata,
|
||
codeFlowValue: onenterdata,
|
||
definition: opener(definition),
|
||
definitionDestinationString: buffer,
|
||
definitionLabelString: buffer,
|
||
definitionTitleString: buffer,
|
||
emphasis: opener(emphasis),
|
||
hardBreakEscape: opener(hardBreak),
|
||
hardBreakTrailing: opener(hardBreak),
|
||
htmlFlow: opener(html, buffer),
|
||
htmlFlowData: onenterdata,
|
||
htmlText: opener(html, buffer),
|
||
htmlTextData: onenterdata,
|
||
image: opener(image),
|
||
label: buffer,
|
||
link: opener(link),
|
||
listItem: opener(listItem),
|
||
listItemValue: onenterlistitemvalue,
|
||
listOrdered: opener(list, onenterlistordered),
|
||
listUnordered: opener(list),
|
||
paragraph: opener(paragraph),
|
||
reference: onenterreference,
|
||
referenceString: buffer,
|
||
resourceDestinationString: buffer,
|
||
resourceTitleString: buffer,
|
||
setextHeading: opener(heading),
|
||
strong: opener(strong),
|
||
thematicBreak: opener(thematicBreak)
|
||
},
|
||
exit: {
|
||
atxHeading: closer(),
|
||
atxHeadingSequence: onexitatxheadingsequence,
|
||
autolink: closer(),
|
||
autolinkEmail: onexitautolinkemail,
|
||
autolinkProtocol: onexitautolinkprotocol,
|
||
blockQuote: closer(),
|
||
characterEscapeValue: onexitdata,
|
||
characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,
|
||
characterReferenceMarkerNumeric: onexitcharacterreferencemarker,
|
||
characterReferenceValue: onexitcharacterreferencevalue,
|
||
codeFenced: closer(onexitcodefenced),
|
||
codeFencedFence: onexitcodefencedfence,
|
||
codeFencedFenceInfo: onexitcodefencedfenceinfo,
|
||
codeFencedFenceMeta: onexitcodefencedfencemeta,
|
||
codeFlowValue: onexitdata,
|
||
codeIndented: closer(onexitcodeindented),
|
||
codeText: closer(onexitcodetext),
|
||
codeTextData: onexitdata,
|
||
data: onexitdata,
|
||
definition: closer(),
|
||
definitionDestinationString: onexitdefinitiondestinationstring,
|
||
definitionLabelString: onexitdefinitionlabelstring,
|
||
definitionTitleString: onexitdefinitiontitlestring,
|
||
emphasis: closer(),
|
||
hardBreakEscape: closer(onexithardbreak),
|
||
hardBreakTrailing: closer(onexithardbreak),
|
||
htmlFlow: closer(onexithtmlflow),
|
||
htmlFlowData: onexitdata,
|
||
htmlText: closer(onexithtmltext),
|
||
htmlTextData: onexitdata,
|
||
image: closer(onexitimage),
|
||
label: onexitlabel,
|
||
labelText: onexitlabeltext,
|
||
lineEnding: onexitlineending,
|
||
link: closer(onexitlink),
|
||
listItem: closer(),
|
||
listOrdered: closer(),
|
||
listUnordered: closer(),
|
||
paragraph: closer(),
|
||
referenceString: onexitreferencestring,
|
||
resourceDestinationString: onexitresourcedestinationstring,
|
||
resourceTitleString: onexitresourcetitlestring,
|
||
resource: onexitresource,
|
||
setextHeading: closer(onexitsetextheading),
|
||
setextHeadingLineSequence: onexitsetextheadinglinesequence,
|
||
setextHeadingText: onexitsetextheadingtext,
|
||
strong: closer(),
|
||
thematicBreak: closer()
|
||
}
|
||
}
|
||
configure(config, (options || {}).mdastExtensions || [])
|
||
|
||
/** @type {CompileData} */
|
||
const data = {}
|
||
return compile
|
||
|
||
/**
|
||
* Turn micromark events into an mdast tree.
|
||
*
|
||
* @param {Array<Event>} events
|
||
* Events.
|
||
* @returns {Root}
|
||
* mdast tree.
|
||
*/
|
||
function compile(events) {
|
||
/** @type {Root} */
|
||
let tree = {
|
||
type: 'root',
|
||
children: []
|
||
}
|
||
/** @type {Omit<CompileContext, 'sliceSerialize'>} */
|
||
const context = {
|
||
stack: [tree],
|
||
tokenStack: [],
|
||
config,
|
||
enter,
|
||
exit,
|
||
buffer,
|
||
resume,
|
||
setData,
|
||
getData
|
||
}
|
||
/** @type {Array<number>} */
|
||
const listStack = []
|
||
let index = -1
|
||
while (++index < events.length) {
|
||
// We preprocess lists to add `listItem` tokens, and to infer whether
|
||
// items the list itself are spread out.
|
||
if (
|
||
events[index][1].type === 'listOrdered' ||
|
||
events[index][1].type === 'listUnordered'
|
||
) {
|
||
if (events[index][0] === 'enter') {
|
||
listStack.push(index)
|
||
} else {
|
||
const tail = listStack.pop()
|
||
index = prepareList(events, tail, index)
|
||
}
|
||
}
|
||
}
|
||
index = -1
|
||
while (++index < events.length) {
|
||
const handler = config[events[index][0]]
|
||
if (own.call(handler, events[index][1].type)) {
|
||
handler[events[index][1].type].call(
|
||
Object.assign(
|
||
{
|
||
sliceSerialize: events[index][2].sliceSerialize
|
||
},
|
||
context
|
||
),
|
||
events[index][1]
|
||
)
|
||
}
|
||
}
|
||
|
||
// Handle tokens still being open.
|
||
if (context.tokenStack.length > 0) {
|
||
const tail = context.tokenStack[context.tokenStack.length - 1]
|
||
const handler = tail[1] || defaultOnError
|
||
handler.call(context, undefined, tail[0])
|
||
}
|
||
|
||
// Figure out `root` position.
|
||
tree.position = {
|
||
start: lib_point(
|
||
events.length > 0
|
||
? events[0][1].start
|
||
: {
|
||
line: 1,
|
||
column: 1,
|
||
offset: 0
|
||
}
|
||
),
|
||
end: lib_point(
|
||
events.length > 0
|
||
? events[events.length - 2][1].end
|
||
: {
|
||
line: 1,
|
||
column: 1,
|
||
offset: 0
|
||
}
|
||
)
|
||
}
|
||
|
||
// Call transforms.
|
||
index = -1
|
||
while (++index < config.transforms.length) {
|
||
tree = config.transforms[index](tree) || tree
|
||
}
|
||
return tree
|
||
}
|
||
|
||
/**
|
||
* @param {Array<Event>} events
|
||
* @param {number} start
|
||
* @param {number} length
|
||
* @returns {number}
|
||
*/
|
||
function prepareList(events, start, length) {
|
||
let index = start - 1
|
||
let containerBalance = -1
|
||
let listSpread = false
|
||
/** @type {Token | undefined} */
|
||
let listItem
|
||
/** @type {number | undefined} */
|
||
let lineIndex
|
||
/** @type {number | undefined} */
|
||
let firstBlankLineIndex
|
||
/** @type {boolean | undefined} */
|
||
let atMarker
|
||
while (++index <= length) {
|
||
const event = events[index]
|
||
if (
|
||
event[1].type === 'listUnordered' ||
|
||
event[1].type === 'listOrdered' ||
|
||
event[1].type === 'blockQuote'
|
||
) {
|
||
if (event[0] === 'enter') {
|
||
containerBalance++
|
||
} else {
|
||
containerBalance--
|
||
}
|
||
atMarker = undefined
|
||
} else if (event[1].type === 'lineEndingBlank') {
|
||
if (event[0] === 'enter') {
|
||
if (
|
||
listItem &&
|
||
!atMarker &&
|
||
!containerBalance &&
|
||
!firstBlankLineIndex
|
||
) {
|
||
firstBlankLineIndex = index
|
||
}
|
||
atMarker = undefined
|
||
}
|
||
} else if (
|
||
event[1].type === 'linePrefix' ||
|
||
event[1].type === 'listItemValue' ||
|
||
event[1].type === 'listItemMarker' ||
|
||
event[1].type === 'listItemPrefix' ||
|
||
event[1].type === 'listItemPrefixWhitespace'
|
||
) {
|
||
// Empty.
|
||
} else {
|
||
atMarker = undefined
|
||
}
|
||
if (
|
||
(!containerBalance &&
|
||
event[0] === 'enter' &&
|
||
event[1].type === 'listItemPrefix') ||
|
||
(containerBalance === -1 &&
|
||
event[0] === 'exit' &&
|
||
(event[1].type === 'listUnordered' ||
|
||
event[1].type === 'listOrdered'))
|
||
) {
|
||
if (listItem) {
|
||
let tailIndex = index
|
||
lineIndex = undefined
|
||
while (tailIndex--) {
|
||
const tailEvent = events[tailIndex]
|
||
if (
|
||
tailEvent[1].type === 'lineEnding' ||
|
||
tailEvent[1].type === 'lineEndingBlank'
|
||
) {
|
||
if (tailEvent[0] === 'exit') continue
|
||
if (lineIndex) {
|
||
events[lineIndex][1].type = 'lineEndingBlank'
|
||
listSpread = true
|
||
}
|
||
tailEvent[1].type = 'lineEnding'
|
||
lineIndex = tailIndex
|
||
} else if (
|
||
tailEvent[1].type === 'linePrefix' ||
|
||
tailEvent[1].type === 'blockQuotePrefix' ||
|
||
tailEvent[1].type === 'blockQuotePrefixWhitespace' ||
|
||
tailEvent[1].type === 'blockQuoteMarker' ||
|
||
tailEvent[1].type === 'listItemIndent'
|
||
) {
|
||
// Empty
|
||
} else {
|
||
break
|
||
}
|
||
}
|
||
if (
|
||
firstBlankLineIndex &&
|
||
(!lineIndex || firstBlankLineIndex < lineIndex)
|
||
) {
|
||
listItem._spread = true
|
||
}
|
||
|
||
// Fix position.
|
||
listItem.end = Object.assign(
|
||
{},
|
||
lineIndex ? events[lineIndex][1].start : event[1].end
|
||
)
|
||
events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])
|
||
index++
|
||
length++
|
||
}
|
||
|
||
// Create a new list item.
|
||
if (event[1].type === 'listItemPrefix') {
|
||
listItem = {
|
||
type: 'listItem',
|
||
_spread: false,
|
||
start: Object.assign({}, event[1].start),
|
||
// @ts-expect-error: we’ll add `end` in a second.
|
||
end: undefined
|
||
}
|
||
// @ts-expect-error: `listItem` is most definitely defined, TS...
|
||
events.splice(index, 0, ['enter', listItem, event[2]])
|
||
index++
|
||
length++
|
||
firstBlankLineIndex = undefined
|
||
atMarker = true
|
||
}
|
||
}
|
||
}
|
||
events[start][1]._spread = listSpread
|
||
return length
|
||
}
|
||
|
||
/**
|
||
* Set data.
|
||
*
|
||
* @template {keyof CompileData} Key
|
||
* Field type.
|
||
* @param {Key} key
|
||
* Key of field.
|
||
* @param {CompileData[Key]} [value]
|
||
* New value.
|
||
* @returns {void}
|
||
* Nothing.
|
||
*/
|
||
function setData(key, value) {
|
||
data[key] = value
|
||
}
|
||
|
||
/**
|
||
* Get data.
|
||
*
|
||
* @template {keyof CompileData} Key
|
||
* Field type.
|
||
* @param {Key} key
|
||
* Key of field.
|
||
* @returns {CompileData[Key]}
|
||
* Value.
|
||
*/
|
||
function getData(key) {
|
||
return data[key]
|
||
}
|
||
|
||
/**
|
||
* Create an opener handle.
|
||
*
|
||
* @param {(token: Token) => Node} create
|
||
* Create a node.
|
||
* @param {Handle} [and]
|
||
* Optional function to also run.
|
||
* @returns {Handle}
|
||
* Handle.
|
||
*/
|
||
function opener(create, and) {
|
||
return open
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @param {Token} token
|
||
* @returns {void}
|
||
*/
|
||
function open(token) {
|
||
enter.call(this, create(token), token)
|
||
if (and) and.call(this, token)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @returns {void}
|
||
*/
|
||
function buffer() {
|
||
this.stack.push({
|
||
type: 'fragment',
|
||
children: []
|
||
})
|
||
}
|
||
|
||
/**
|
||
* @template {Node} Kind
|
||
* Node type.
|
||
* @this {CompileContext}
|
||
* Context.
|
||
* @param {Kind} node
|
||
* Node to enter.
|
||
* @param {Token} token
|
||
* Corresponding token.
|
||
* @param {OnEnterError | undefined} [errorHandler]
|
||
* Handle the case where this token is open, but it is closed by something else.
|
||
* @returns {Kind}
|
||
* The given node.
|
||
*/
|
||
function enter(node, token, errorHandler) {
|
||
const parent = this.stack[this.stack.length - 1]
|
||
// @ts-expect-error: Assume `Node` can exist as a child of `parent`.
|
||
parent.children.push(node)
|
||
this.stack.push(node)
|
||
this.tokenStack.push([token, errorHandler])
|
||
// @ts-expect-error: `end` will be patched later.
|
||
node.position = {
|
||
start: lib_point(token.start)
|
||
}
|
||
return node
|
||
}
|
||
|
||
/**
|
||
* Create a closer handle.
|
||
*
|
||
* @param {Handle} [and]
|
||
* Optional function to also run.
|
||
* @returns {Handle}
|
||
* Handle.
|
||
*/
|
||
function closer(and) {
|
||
return close
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @param {Token} token
|
||
* @returns {void}
|
||
*/
|
||
function close(token) {
|
||
if (and) and.call(this, token)
|
||
exit.call(this, token)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* Context.
|
||
* @param {Token} token
|
||
* Corresponding token.
|
||
* @param {OnExitError | undefined} [onExitError]
|
||
* Handle the case where another token is open.
|
||
* @returns {Node}
|
||
* The closed node.
|
||
*/
|
||
function exit(token, onExitError) {
|
||
const node = this.stack.pop()
|
||
const open = this.tokenStack.pop()
|
||
if (!open) {
|
||
throw new Error(
|
||
'Cannot close `' +
|
||
token.type +
|
||
'` (' +
|
||
stringifyPosition({
|
||
start: token.start,
|
||
end: token.end
|
||
}) +
|
||
'): it’s not open'
|
||
)
|
||
} else if (open[0].type !== token.type) {
|
||
if (onExitError) {
|
||
onExitError.call(this, token, open[0])
|
||
} else {
|
||
const handler = open[1] || defaultOnError
|
||
handler.call(this, token, open[0])
|
||
}
|
||
}
|
||
node.position.end = lib_point(token.end)
|
||
return node
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @returns {string}
|
||
*/
|
||
function resume() {
|
||
return lib_toString(this.stack.pop())
|
||
}
|
||
|
||
//
|
||
// Handlers.
|
||
//
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onenterlistordered() {
|
||
setData('expectingFirstListItemValue', true)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onenterlistitemvalue(token) {
|
||
if (getData('expectingFirstListItemValue')) {
|
||
const ancestor = this.stack[this.stack.length - 2]
|
||
ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)
|
||
setData('expectingFirstListItemValue')
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitcodefencedfenceinfo() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.lang = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitcodefencedfencemeta() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.meta = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitcodefencedfence() {
|
||
// Exit if this is the closing fence.
|
||
if (getData('flowCodeInside')) return
|
||
this.buffer()
|
||
setData('flowCodeInside', true)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitcodefenced() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.value = data.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, '')
|
||
setData('flowCodeInside')
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitcodeindented() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.value = data.replace(/(\r?\n|\r)$/g, '')
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitdefinitionlabelstring(token) {
|
||
const label = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.label = label
|
||
node.identifier = normalizeIdentifier(
|
||
this.sliceSerialize(token)
|
||
).toLowerCase()
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitdefinitiontitlestring() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.title = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitdefinitiondestinationstring() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.url = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitatxheadingsequence(token) {
|
||
const node = this.stack[this.stack.length - 1]
|
||
if (!node.depth) {
|
||
const depth = this.sliceSerialize(token).length
|
||
node.depth = depth
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitsetextheadingtext() {
|
||
setData('setextHeadingSlurpLineEnding', true)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitsetextheadinglinesequence(token) {
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitsetextheading() {
|
||
setData('setextHeadingSlurpLineEnding')
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onenterdata(token) {
|
||
const node = this.stack[this.stack.length - 1]
|
||
let tail = node.children[node.children.length - 1]
|
||
if (!tail || tail.type !== 'text') {
|
||
// Add a new text node.
|
||
tail = text()
|
||
// @ts-expect-error: we’ll add `end` later.
|
||
tail.position = {
|
||
start: lib_point(token.start)
|
||
}
|
||
// @ts-expect-error: Assume `parent` accepts `text`.
|
||
node.children.push(tail)
|
||
}
|
||
this.stack.push(tail)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitdata(token) {
|
||
const tail = this.stack.pop()
|
||
tail.value += this.sliceSerialize(token)
|
||
tail.position.end = lib_point(token.end)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitlineending(token) {
|
||
const context = this.stack[this.stack.length - 1]
|
||
// If we’re at a hard break, include the line ending in there.
|
||
if (getData('atHardBreak')) {
|
||
const tail = context.children[context.children.length - 1]
|
||
tail.position.end = lib_point(token.end)
|
||
setData('atHardBreak')
|
||
return
|
||
}
|
||
if (
|
||
!getData('setextHeadingSlurpLineEnding') &&
|
||
config.canContainEols.includes(context.type)
|
||
) {
|
||
onenterdata.call(this, token)
|
||
onexitdata.call(this, token)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexithardbreak() {
|
||
setData('atHardBreak', true)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexithtmlflow() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.value = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexithtmltext() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.value = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitcodetext() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.value = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitlink() {
|
||
const node = this.stack[this.stack.length - 1]
|
||
// Note: there are also `identifier` and `label` fields on this link node!
|
||
// These are used / cleaned here.
|
||
// To do: clean.
|
||
if (getData('inReference')) {
|
||
/** @type {ReferenceType} */
|
||
const referenceType = getData('referenceType') || 'shortcut'
|
||
node.type += 'Reference'
|
||
// @ts-expect-error: mutate.
|
||
node.referenceType = referenceType
|
||
// @ts-expect-error: mutate.
|
||
delete node.url
|
||
delete node.title
|
||
} else {
|
||
// @ts-expect-error: mutate.
|
||
delete node.identifier
|
||
// @ts-expect-error: mutate.
|
||
delete node.label
|
||
}
|
||
setData('referenceType')
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitimage() {
|
||
const node = this.stack[this.stack.length - 1]
|
||
// Note: there are also `identifier` and `label` fields on this link node!
|
||
// These are used / cleaned here.
|
||
// To do: clean.
|
||
if (getData('inReference')) {
|
||
/** @type {ReferenceType} */
|
||
const referenceType = getData('referenceType') || 'shortcut'
|
||
node.type += 'Reference'
|
||
// @ts-expect-error: mutate.
|
||
node.referenceType = referenceType
|
||
// @ts-expect-error: mutate.
|
||
delete node.url
|
||
delete node.title
|
||
} else {
|
||
// @ts-expect-error: mutate.
|
||
delete node.identifier
|
||
// @ts-expect-error: mutate.
|
||
delete node.label
|
||
}
|
||
setData('referenceType')
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitlabeltext(token) {
|
||
const string = this.sliceSerialize(token)
|
||
const ancestor = this.stack[this.stack.length - 2]
|
||
// @ts-expect-error: stash this on the node, as it might become a reference
|
||
// later.
|
||
ancestor.label = decodeString(string)
|
||
// @ts-expect-error: same as above.
|
||
ancestor.identifier = normalizeIdentifier(string).toLowerCase()
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitlabel() {
|
||
const fragment = this.stack[this.stack.length - 1]
|
||
const value = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
// Assume a reference.
|
||
setData('inReference', true)
|
||
if (node.type === 'link') {
|
||
/** @type {Array<StaticPhrasingContent>} */
|
||
// @ts-expect-error: Assume static phrasing content.
|
||
const children = fragment.children
|
||
node.children = children
|
||
} else {
|
||
node.alt = value
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitresourcedestinationstring() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.url = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitresourcetitlestring() {
|
||
const data = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.title = data
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitresource() {
|
||
setData('inReference')
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onenterreference() {
|
||
setData('referenceType', 'collapsed')
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitreferencestring(token) {
|
||
const label = this.resume()
|
||
const node = this.stack[this.stack.length - 1]
|
||
// @ts-expect-error: stash this on the node, as it might become a reference
|
||
// later.
|
||
node.label = label
|
||
// @ts-expect-error: same as above.
|
||
node.identifier = normalizeIdentifier(
|
||
this.sliceSerialize(token)
|
||
).toLowerCase()
|
||
setData('referenceType', 'full')
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
|
||
function onexitcharacterreferencemarker(token) {
|
||
setData('characterReferenceType', token.type)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitcharacterreferencevalue(token) {
|
||
const data = this.sliceSerialize(token)
|
||
const type = getData('characterReferenceType')
|
||
/** @type {string} */
|
||
let value
|
||
if (type) {
|
||
value = decodeNumericCharacterReference(
|
||
data,
|
||
type === 'characterReferenceMarkerNumeric' ? 10 : 16
|
||
)
|
||
setData('characterReferenceType')
|
||
} else {
|
||
const result = decodeNamedCharacterReference(data)
|
||
value = result
|
||
}
|
||
const tail = this.stack.pop()
|
||
tail.value += value
|
||
tail.position.end = lib_point(token.end)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitautolinkprotocol(token) {
|
||
onexitdata.call(this, token)
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.url = this.sliceSerialize(token)
|
||
}
|
||
|
||
/**
|
||
* @this {CompileContext}
|
||
* @type {Handle}
|
||
*/
|
||
function onexitautolinkemail(token) {
|
||
onexitdata.call(this, token)
|
||
const node = this.stack[this.stack.length - 1]
|
||
node.url = 'mailto:' + this.sliceSerialize(token)
|
||
}
|
||
|
||
//
|
||
// Creaters.
|
||
//
|
||
|
||
/** @returns {Blockquote} */
|
||
function blockQuote() {
|
||
return {
|
||
type: 'blockquote',
|
||
children: []
|
||
}
|
||
}
|
||
|
||
/** @returns {Code} */
|
||
function codeFlow() {
|
||
return {
|
||
type: 'code',
|
||
lang: null,
|
||
meta: null,
|
||
value: ''
|
||
}
|
||
}
|
||
|
||
/** @returns {InlineCode} */
|
||
function codeText() {
|
||
return {
|
||
type: 'inlineCode',
|
||
value: ''
|
||
}
|
||
}
|
||
|
||
/** @returns {Definition} */
|
||
function definition() {
|
||
return {
|
||
type: 'definition',
|
||
identifier: '',
|
||
label: null,
|
||
title: null,
|
||
url: ''
|
||
}
|
||
}
|
||
|
||
/** @returns {Emphasis} */
|
||
function emphasis() {
|
||
return {
|
||
type: 'emphasis',
|
||
children: []
|
||
}
|
||
}
|
||
|
||
/** @returns {Heading} */
|
||
function heading() {
|
||
// @ts-expect-error `depth` will be set later.
|
||
return {
|
||
type: 'heading',
|
||
depth: undefined,
|
||
children: []
|
||
}
|
||
}
|
||
|
||
/** @returns {Break} */
|
||
function hardBreak() {
|
||
return {
|
||
type: 'break'
|
||
}
|
||
}
|
||
|
||
/** @returns {HTML} */
|
||
function html() {
|
||
return {
|
||
type: 'html',
|
||
value: ''
|
||
}
|
||
}
|
||
|
||
/** @returns {Image} */
|
||
function image() {
|
||
return {
|
||
type: 'image',
|
||
title: null,
|
||
url: '',
|
||
alt: null
|
||
}
|
||
}
|
||
|
||
/** @returns {Link} */
|
||
function link() {
|
||
return {
|
||
type: 'link',
|
||
title: null,
|
||
url: '',
|
||
children: []
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {Token} token
|
||
* @returns {List}
|
||
*/
|
||
function list(token) {
|
||
return {
|
||
type: 'list',
|
||
ordered: token.type === 'listOrdered',
|
||
start: null,
|
||
spread: token._spread,
|
||
children: []
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {Token} token
|
||
* @returns {ListItem}
|
||
*/
|
||
function listItem(token) {
|
||
return {
|
||
type: 'listItem',
|
||
spread: token._spread,
|
||
checked: null,
|
||
children: []
|
||
}
|
||
}
|
||
|
||
/** @returns {Paragraph} */
|
||
function paragraph() {
|
||
return {
|
||
type: 'paragraph',
|
||
children: []
|
||
}
|
||
}
|
||
|
||
/** @returns {Strong} */
|
||
function strong() {
|
||
return {
|
||
type: 'strong',
|
||
children: []
|
||
}
|
||
}
|
||
|
||
/** @returns {Text} */
|
||
function text() {
|
||
return {
|
||
type: 'text',
|
||
value: ''
|
||
}
|
||
}
|
||
|
||
/** @returns {ThematicBreak} */
|
||
function thematicBreak() {
|
||
return {
|
||
type: 'thematicBreak'
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Copy a point-like value.
|
||
*
|
||
* @param {Point} d
|
||
* Point-like value.
|
||
* @returns {Point}
|
||
* unist point.
|
||
*/
|
||
function lib_point(d) {
|
||
return {
|
||
line: d.line,
|
||
column: d.column,
|
||
offset: d.offset
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {Config} combined
|
||
* @param {Array<Extension | Array<Extension>>} extensions
|
||
* @returns {void}
|
||
*/
|
||
function configure(combined, extensions) {
|
||
let index = -1
|
||
while (++index < extensions.length) {
|
||
const value = extensions[index]
|
||
if (Array.isArray(value)) {
|
||
configure(combined, value)
|
||
} else {
|
||
extension(combined, value)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {Config} combined
|
||
* @param {Extension} extension
|
||
* @returns {void}
|
||
*/
|
||
function extension(combined, extension) {
|
||
/** @type {keyof Extension} */
|
||
let key
|
||
for (key in extension) {
|
||
if (own.call(extension, key)) {
|
||
if (key === 'canContainEols') {
|
||
const right = extension[key]
|
||
if (right) {
|
||
combined[key].push(...right)
|
||
}
|
||
} else if (key === 'transforms') {
|
||
const right = extension[key]
|
||
if (right) {
|
||
combined[key].push(...right)
|
||
}
|
||
} else if (key === 'enter' || key === 'exit') {
|
||
const right = extension[key]
|
||
if (right) {
|
||
Object.assign(combined[key], right)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/** @type {OnEnterError} */
|
||
function defaultOnError(left, right) {
|
||
if (left) {
|
||
throw new Error(
|
||
'Cannot close `' +
|
||
left.type +
|
||
'` (' +
|
||
stringifyPosition({
|
||
start: left.start,
|
||
end: left.end
|
||
}) +
|
||
'): a different token (`' +
|
||
right.type +
|
||
'`, ' +
|
||
stringifyPosition({
|
||
start: right.start,
|
||
end: right.end
|
||
}) +
|
||
') is open'
|
||
)
|
||
} else {
|
||
throw new Error(
|
||
'Cannot close document, a token (`' +
|
||
right.type +
|
||
'`, ' +
|
||
stringifyPosition({
|
||
start: right.start,
|
||
end: right.end
|
||
}) +
|
||
') is still open'
|
||
)
|
||
}
|
||
}
|
||
|
||
// EXTERNAL MODULE: ../node_modules/ts-dedent/esm/index.js
|
||
var esm = __webpack_require__(11464);
|
||
;// CONCATENATED MODULE: ../node_modules/mermaid/dist/createText-a48a4c90.js
|
||
|
||
|
||
|
||
function preprocessMarkdown(markdown) {
|
||
const withoutMultipleNewlines = markdown.replace(/\n{2,}/g, "\n");
|
||
const withoutExtraSpaces = (0,esm/* dedent */.Z)(withoutMultipleNewlines);
|
||
return withoutExtraSpaces;
|
||
}
|
||
function markdownToLines(markdown) {
|
||
const preprocessedMarkdown = preprocessMarkdown(markdown);
|
||
const { children } = fromMarkdown(preprocessedMarkdown);
|
||
const lines = [[]];
|
||
let currentLine = 0;
|
||
function processNode(node, parentType = "normal") {
|
||
if (node.type === "text") {
|
||
const textLines = node.value.split("\n");
|
||
textLines.forEach((textLine, index) => {
|
||
if (index !== 0) {
|
||
currentLine++;
|
||
lines.push([]);
|
||
}
|
||
textLine.split(" ").forEach((word) => {
|
||
if (word) {
|
||
lines[currentLine].push({ content: word, type: parentType });
|
||
}
|
||
});
|
||
});
|
||
} else if (node.type === "strong" || node.type === "emphasis") {
|
||
node.children.forEach((contentNode) => {
|
||
processNode(contentNode, node.type);
|
||
});
|
||
}
|
||
}
|
||
children.forEach((treeNode) => {
|
||
if (treeNode.type === "paragraph") {
|
||
treeNode.children.forEach((contentNode) => {
|
||
processNode(contentNode);
|
||
});
|
||
}
|
||
});
|
||
return lines;
|
||
}
|
||
function markdownToHTML(markdown) {
|
||
const { children } = fromMarkdown(markdown);
|
||
function output(node) {
|
||
if (node.type === "text") {
|
||
return node.value.replace(/\n/g, "<br/>");
|
||
} else if (node.type === "strong") {
|
||
return `<strong>${node.children.map(output).join("")}</strong>`;
|
||
} else if (node.type === "emphasis") {
|
||
return `<em>${node.children.map(output).join("")}</em>`;
|
||
} else if (node.type === "paragraph") {
|
||
return `<p>${node.children.map(output).join("")}</p>`;
|
||
}
|
||
return `Unsupported markdown: ${node.type}`;
|
||
}
|
||
return children.map(output).join("");
|
||
}
|
||
function splitTextToChars(text) {
|
||
if (Intl.Segmenter) {
|
||
return [...new Intl.Segmenter().segment(text)].map((s) => s.segment);
|
||
}
|
||
return [...text];
|
||
}
|
||
function splitWordToFitWidth(checkFit, word) {
|
||
const characters = splitTextToChars(word.content);
|
||
return splitWordToFitWidthRecursion(checkFit, [], characters, word.type);
|
||
}
|
||
function splitWordToFitWidthRecursion(checkFit, usedChars, remainingChars, type) {
|
||
if (remainingChars.length === 0) {
|
||
return [
|
||
{ content: usedChars.join(""), type },
|
||
{ content: "", type }
|
||
];
|
||
}
|
||
const [nextChar, ...rest] = remainingChars;
|
||
const newWord = [...usedChars, nextChar];
|
||
if (checkFit([{ content: newWord.join(""), type }])) {
|
||
return splitWordToFitWidthRecursion(checkFit, newWord, rest, type);
|
||
}
|
||
if (usedChars.length === 0 && nextChar) {
|
||
usedChars.push(nextChar);
|
||
remainingChars.shift();
|
||
}
|
||
return [
|
||
{ content: usedChars.join(""), type },
|
||
{ content: remainingChars.join(""), type }
|
||
];
|
||
}
|
||
function splitLineToFitWidth(line, checkFit) {
|
||
if (line.some(({ content }) => content.includes("\n"))) {
|
||
throw new Error("splitLineToFitWidth does not support newlines in the line");
|
||
}
|
||
return splitLineToFitWidthRecursion(line, checkFit);
|
||
}
|
||
function splitLineToFitWidthRecursion(words, checkFit, lines = [], newLine = []) {
|
||
if (words.length === 0) {
|
||
if (newLine.length > 0) {
|
||
lines.push(newLine);
|
||
}
|
||
return lines.length > 0 ? lines : [];
|
||
}
|
||
let joiner = "";
|
||
if (words[0].content === " ") {
|
||
joiner = " ";
|
||
words.shift();
|
||
}
|
||
const nextWord = words.shift() ?? { content: " ", type: "normal" };
|
||
const lineWithNextWord = [...newLine];
|
||
if (joiner !== "") {
|
||
lineWithNextWord.push({ content: joiner, type: "normal" });
|
||
}
|
||
lineWithNextWord.push(nextWord);
|
||
if (checkFit(lineWithNextWord)) {
|
||
return splitLineToFitWidthRecursion(words, checkFit, lines, lineWithNextWord);
|
||
}
|
||
if (newLine.length > 0) {
|
||
lines.push(newLine);
|
||
words.unshift(nextWord);
|
||
} else if (nextWord.content) {
|
||
const [line, rest] = splitWordToFitWidth(checkFit, nextWord);
|
||
lines.push([line]);
|
||
if (rest.content) {
|
||
words.unshift(rest);
|
||
}
|
||
}
|
||
return splitLineToFitWidthRecursion(words, checkFit, lines);
|
||
}
|
||
function applyStyle(dom, styleFn) {
|
||
if (styleFn) {
|
||
dom.attr("style", styleFn);
|
||
}
|
||
}
|
||
function addHtmlSpan(element, node, width, classes, addBackground = false) {
|
||
const fo = element.append("foreignObject");
|
||
const div = fo.append("xhtml:div");
|
||
const label = node.label;
|
||
const labelClass = node.isNode ? "nodeLabel" : "edgeLabel";
|
||
div.html(
|
||
`
|
||
<span class="${labelClass} ${classes}" ` + (node.labelStyle ? 'style="' + node.labelStyle + '"' : "") + ">" + label + "</span>"
|
||
);
|
||
applyStyle(div, node.labelStyle);
|
||
div.style("display", "table-cell");
|
||
div.style("white-space", "nowrap");
|
||
div.style("max-width", width + "px");
|
||
div.attr("xmlns", "http://www.w3.org/1999/xhtml");
|
||
if (addBackground) {
|
||
div.attr("class", "labelBkg");
|
||
}
|
||
let bbox = div.node().getBoundingClientRect();
|
||
if (bbox.width === width) {
|
||
div.style("display", "table");
|
||
div.style("white-space", "break-spaces");
|
||
div.style("width", width + "px");
|
||
bbox = div.node().getBoundingClientRect();
|
||
}
|
||
fo.style("width", bbox.width);
|
||
fo.style("height", bbox.height);
|
||
return fo.node();
|
||
}
|
||
function createTspan(textElement, lineIndex, lineHeight) {
|
||
return textElement.append("tspan").attr("class", "text-outer-tspan").attr("x", 0).attr("y", lineIndex * lineHeight - 0.1 + "em").attr("dy", lineHeight + "em");
|
||
}
|
||
function computeWidthOfText(parentNode, lineHeight, line) {
|
||
const testElement = parentNode.append("text");
|
||
const testSpan = createTspan(testElement, 1, lineHeight);
|
||
updateTextContentAndStyles(testSpan, line);
|
||
const textLength = testSpan.node().getComputedTextLength();
|
||
testElement.remove();
|
||
return textLength;
|
||
}
|
||
function computeDimensionOfText(parentNode, lineHeight, text) {
|
||
var _a;
|
||
const testElement = parentNode.append("text");
|
||
const testSpan = createTspan(testElement, 1, lineHeight);
|
||
updateTextContentAndStyles(testSpan, [{ content: text, type: "normal" }]);
|
||
const textDimension = (_a = testSpan.node()) == null ? void 0 : _a.getBoundingClientRect();
|
||
if (textDimension) {
|
||
testElement.remove();
|
||
}
|
||
return textDimension;
|
||
}
|
||
function createFormattedText(width, g, structuredText, addBackground = false) {
|
||
const lineHeight = 1.1;
|
||
const labelGroup = g.append("g");
|
||
const bkg = labelGroup.insert("rect").attr("class", "background");
|
||
const textElement = labelGroup.append("text").attr("y", "-10.1");
|
||
let lineIndex = 0;
|
||
for (const line of structuredText) {
|
||
const checkWidth = (line2) => computeWidthOfText(labelGroup, lineHeight, line2) <= width;
|
||
const linesUnderWidth = checkWidth(line) ? [line] : splitLineToFitWidth(line, checkWidth);
|
||
for (const preparedLine of linesUnderWidth) {
|
||
const tspan = createTspan(textElement, lineIndex, lineHeight);
|
||
updateTextContentAndStyles(tspan, preparedLine);
|
||
lineIndex++;
|
||
}
|
||
}
|
||
if (addBackground) {
|
||
const bbox = textElement.node().getBBox();
|
||
const padding = 2;
|
||
bkg.attr("x", -padding).attr("y", -padding).attr("width", bbox.width + 2 * padding).attr("height", bbox.height + 2 * padding);
|
||
return labelGroup.node();
|
||
} else {
|
||
return textElement.node();
|
||
}
|
||
}
|
||
function updateTextContentAndStyles(tspan, wrappedLine) {
|
||
tspan.text("");
|
||
wrappedLine.forEach((word, index) => {
|
||
const innerTspan = tspan.append("tspan").attr("font-style", word.type === "emphasis" ? "italic" : "normal").attr("class", "text-inner-tspan").attr("font-weight", word.type === "strong" ? "bold" : "normal");
|
||
if (index === 0) {
|
||
innerTspan.text(word.content);
|
||
} else {
|
||
innerTspan.text(" " + word.content);
|
||
}
|
||
});
|
||
}
|
||
const createText = (el, text = "", {
|
||
style = "",
|
||
isTitle = false,
|
||
classes = "",
|
||
useHtmlLabels = true,
|
||
isNode = true,
|
||
width = 200,
|
||
addSvgBackground = false
|
||
} = {}) => {
|
||
mermaid_04fb0060.l.info("createText", text, style, isTitle, classes, useHtmlLabels, isNode, addSvgBackground);
|
||
if (useHtmlLabels) {
|
||
const htmlText = markdownToHTML(text);
|
||
const node = {
|
||
isNode,
|
||
label: (0,mermaid_04fb0060.J)(htmlText).replace(
|
||
/fa[blrs]?:fa-[\w-]+/g,
|
||
(s) => `<i class='${s.replace(":", " ")}'></i>`
|
||
),
|
||
labelStyle: style.replace("fill:", "color:")
|
||
};
|
||
const vertexNode = addHtmlSpan(el, node, width, classes, addSvgBackground);
|
||
return vertexNode;
|
||
} else {
|
||
const structuredText = markdownToLines(text);
|
||
const svgLabel = createFormattedText(width, el, structuredText, addSvgBackground);
|
||
return svgLabel;
|
||
}
|
||
};
|
||
|
||
|
||
|
||
/***/ })
|
||
|
||
}]);
|
||
//# sourceMappingURL=4780.9d3fd41ad1c46b2eb050.js.map?v=9d3fd41ad1c46b2eb050
|