valhrafnaz/homepage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

inital

Browse Source
This commit is contained in:
nihil
2024-11-03 17:16:20 +01:00
commit fd6412d6f2
8090 changed files with 778406 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
node_modules/markdown-it/lib/common/html_blocks.mjs generated vendored Normal file
View File

@@ -0,0 +1,67 @@
// List of valid html blocks names, according to commonmark spec
// https://spec.commonmark.org/0.30/#html-blocks
export default [
'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'
]

25
node_modules/markdown-it/lib/common/html_re.mjs generated vendored Normal file
View File

@@ -0,0 +1,25 @@
// Regexps to match html elements
const attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*'
const unquoted = '[^"\'=<>`\\x00-\\x20]+'
const single_quoted = "'[^']*'"
const double_quoted = '"[^"]*"'
const attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')'
const attribute = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)'
const open_tag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>'
const close_tag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>'
const comment = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->'
const processing = '<[?][\\s\\S]*?[?]>'
const declaration = '<![A-Za-z][^>]*>'
const cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>'
const HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +
'|' + processing + '|' + declaration + '|' + cdata + ')')
const HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')')
export { HTML_TAG_RE, HTML_OPEN_CLOSE_TAG_RE }

304
node_modules/markdown-it/lib/common/utils.mjs generated vendored Normal file
View File

@@ -0,0 +1,304 @@
// Utilities
//
import * as mdurl from 'mdurl'
import * as ucmicro from 'uc.micro'
import { decodeHTML } from 'entities'
function _class (obj) { return Object.prototype.toString.call(obj) }
function isString (obj) { return _class(obj) === '[object String]' }
const _hasOwnProperty = Object.prototype.hasOwnProperty
function has (object, key) {
return _hasOwnProperty.call(object, key)
}
// Merge objects
//
function assign (obj /* from1, from2, from3, ... */) {
const sources = Array.prototype.slice.call(arguments, 1)
sources.forEach(function (source) {
if (!source) { return }
if (typeof source !== 'object') {
throw new TypeError(source + 'must be object')
}
Object.keys(source).forEach(function (key) {
obj[key] = source[key]
})
})
return obj
}
// Remove element from array and put another array at those position.
// Useful for some operations with tokens
function arrayReplaceAt (src, pos, newElements) {
return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1))
}
function isValidEntityCode (c) {
/* eslint no-bitwise:0 */
// broken sequence
if (c >= 0xD800 && c <= 0xDFFF) { return false }
// never used
if (c >= 0xFDD0 && c <= 0xFDEF) { return false }
if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false }
// control codes
if (c >= 0x00 && c <= 0x08) { return false }
if (c === 0x0B) { return false }
if (c >= 0x0E && c <= 0x1F) { return false }
if (c >= 0x7F && c <= 0x9F) { return false }
// out of range
if (c > 0x10FFFF) { return false }
return true
}
function fromCodePoint (c) {
/* eslint no-bitwise:0 */
if (c > 0xffff) {
c -= 0x10000
const surrogate1 = 0xd800 + (c >> 10)
const surrogate2 = 0xdc00 + (c & 0x3ff)
return String.fromCharCode(surrogate1, surrogate2)
}
return String.fromCharCode(c)
}
const UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g
const ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi
const UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi')
const DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i
function replaceEntityPattern (match, name) {
if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {
const code = name[1].toLowerCase() === 'x'
? parseInt(name.slice(2), 16)
: parseInt(name.slice(1), 10)
if (isValidEntityCode(code)) {
return fromCodePoint(code)
}
return match
}
const decoded = decodeHTML(match)
if (decoded !== match) {
return decoded
}
return match
}
/* function replaceEntities(str) {
if (str.indexOf('&') < 0) { return str; }
return str.replace(ENTITY_RE, replaceEntityPattern);
} */
function unescapeMd (str) {
if (str.indexOf('\\') < 0) { return str }
return str.replace(UNESCAPE_MD_RE, '$1')
}
function unescapeAll (str) {
if (str.indexOf('\\') < 0 && str.indexOf('&') < 0) { return str }
return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {
if (escaped) { return escaped }
return replaceEntityPattern(match, entity)
})
}
const HTML_ESCAPE_TEST_RE = /[&<>"]/
const HTML_ESCAPE_REPLACE_RE = /[&<>"]/g
const HTML_REPLACEMENTS = {
'&': '&amp;',
'<': '&lt;',
'>': '&gt;',
'"': '&quot;'
}
function replaceUnsafeChar (ch) {
return HTML_REPLACEMENTS[ch]
}
function escapeHtml (str) {
if (HTML_ESCAPE_TEST_RE.test(str)) {
return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar)
}
return str
}
const REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g
function escapeRE (str) {
return str.replace(REGEXP_ESCAPE_RE, '\\$&')
}
function isSpace (code) {
switch (code) {
case 0x09:
case 0x20:
return true
}
return false
}
// Zs (unicode class) || [\t\f\v\r\n]
function isWhiteSpace (code) {
if (code >= 0x2000 && code <= 0x200A) { return true }
switch (code) {
case 0x09: // \t
case 0x0A: // \n
case 0x0B: // \v
case 0x0C: // \f
case 0x0D: // \r
case 0x20:
case 0xA0:
case 0x1680:
case 0x202F:
case 0x205F:
case 0x3000:
return true
}
return false
}
/* eslint-disable max-len */
// Currently without astral characters support.
function isPunctChar (ch) {
return ucmicro.P.test(ch) || ucmicro.S.test(ch)
}
// Markdown ASCII punctuation characters.
//
// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
// http://spec.commonmark.org/0.15/#ascii-punctuation-character
//
// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
//
function isMdAsciiPunct (ch) {
switch (ch) {
case 0x21/* ! */:
case 0x22/* " */:
case 0x23/* # */:
case 0x24/* $ */:
case 0x25/* % */:
case 0x26/* & */:
case 0x27/* ' */:
case 0x28/* ( */:
case 0x29/* ) */:
case 0x2A/* * */:
case 0x2B/* + */:
case 0x2C/* , */:
case 0x2D/* - */:
case 0x2E/* . */:
case 0x2F/* / */:
case 0x3A/* : */:
case 0x3B/* ; */:
case 0x3C/* < */:
case 0x3D/* = */:
case 0x3E/* > */:
case 0x3F/* ? */:
case 0x40/* @ */:
case 0x5B/* [ */:
case 0x5C/* \ */:
case 0x5D/* ] */:
case 0x5E/* ^ */:
case 0x5F/* _ */:
case 0x60/* ` */:
case 0x7B/* { */:
case 0x7C/* | */:
case 0x7D/* } */:
case 0x7E/* ~ */:
return true
default:
return false
}
}
// Hepler to unify [reference labels].
//
function normalizeReference (str) {
// Trim and collapse whitespace
//
str = str.trim().replace(/\s+/g, ' ')
// In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug
// fixed in v12 (couldn't find any details).
//
// So treat this one as a special case
// (remove this when node v10 is no longer supported).
//
if ('ẞ'.toLowerCase() === 'Ṿ') {
str = str.replace(/ẞ/g, 'ß')
}
// .toLowerCase().toUpperCase() should get rid of all differences
// between letter variants.
//
// Simple .toLowerCase() doesn't normalize 125 code points correctly,
// and .toUpperCase doesn't normalize 6 of them (list of exceptions:
// İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently
// uppercased versions).
//
// Here's an example showing how it happens. Lets take greek letter omega:
// uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)
//
// Unicode entries:
// 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;
// 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398
// 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398
// 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;
//
// Case-insensitive comparison should treat all of them as equivalent.
//
// But .toLowerCase() doesn't change ϑ (it's already lowercase),
// and .toUpperCase() doesn't change ϴ (already uppercase).
//
// Applying first lower then upper case normalizes any character:
// '\u0398\u03f4\u03b8\u03d1'.toLowerCase().toUpperCase() === '\u0398\u0398\u0398\u0398'
//
// Note: this is equivalent to unicode case folding; unicode normalization
// is a different step that is not required here.
//
// Final result should be uppercased, because it's later stored in an object
// (this avoid a conflict with Object.prototype members,
// most notably, `__proto__`)
//
return str.toLowerCase().toUpperCase()
}
// Re-export libraries commonly used in both markdown-it and its plugins,
// so plugins won't have to depend on them explicitly, which reduces their
// bundled size (e.g. a browser build).
//
const lib = { mdurl, ucmicro }
export {
lib,
assign,
isString,
has,
unescapeMd,
unescapeAll,
isValidEntityCode,
fromCodePoint,
escapeHtml,
arrayReplaceAt,
isSpace,
isWhiteSpace,
isMdAsciiPunct,
isPunctChar,
escapeRE,
normalizeReference
}

11
node_modules/markdown-it/lib/helpers/index.mjs generated vendored Normal file
View File

@@ -0,0 +1,11 @@
// Just a shortcut for bulk export
import parseLinkLabel from './parse_link_label.mjs'
import parseLinkDestination from './parse_link_destination.mjs'
import parseLinkTitle from './parse_link_title.mjs'
export {
parseLinkLabel,
parseLinkDestination,
parseLinkTitle
}

77
node_modules/markdown-it/lib/helpers/parse_link_destination.mjs generated vendored Normal file
View File

@@ -0,0 +1,77 @@
// Parse link destination
//
import { unescapeAll } from '../common/utils.mjs'
export default function parseLinkDestination (str, start, max) {
let code
let pos = start
const result = {
ok: false,
pos: 0,
str: ''
}
if (str.charCodeAt(pos) === 0x3C /* < */) {
pos++
while (pos < max) {
code = str.charCodeAt(pos)
if (code === 0x0A /* \n */) { return result }
if (code === 0x3C /* < */) { return result }
if (code === 0x3E /* > */) {
result.pos = pos + 1
result.str = unescapeAll(str.slice(start + 1, pos))
result.ok = true
return result
}
if (code === 0x5C /* \ */ && pos + 1 < max) {
pos += 2
continue
}
pos++
}
// no closing '>'
return result
}
// this should be ... } else { ... branch
let level = 0
while (pos < max) {
code = str.charCodeAt(pos)
if (code === 0x20) { break }
// ascii control characters
if (code < 0x20 || code === 0x7F) { break }
if (code === 0x5C /* \ */ && pos + 1 < max) {
if (str.charCodeAt(pos + 1) === 0x20) { break }
pos += 2
continue
}
if (code === 0x28 /* ( */) {
level++
if (level > 32) { return result }
}
if (code === 0x29 /* ) */) {
if (level === 0) { break }
level--
}
pos++
}
if (start === pos) { return result }
if (level !== 0) { return result }
result.str = unescapeAll(str.slice(start, pos))
result.pos = pos
result.ok = true
return result
}

49
node_modules/markdown-it/lib/helpers/parse_link_label.mjs generated vendored Normal file
View File

@@ -0,0 +1,49 @@
// Parse link label
//
// this function assumes that first character ("[") already matches;
// returns the end of the label
//
export default function parseLinkLabel (state, start, disableNested) {
let level, found, marker, prevPos
const max = state.posMax
const oldPos = state.pos
state.pos = start + 1
level = 1
while (state.pos < max) {
marker = state.src.charCodeAt(state.pos)
if (marker === 0x5D /* ] */) {
level--
if (level === 0) {
found = true
break
}
}
prevPos = state.pos
state.md.inline.skipToken(state)
if (marker === 0x5B /* [ */) {
if (prevPos === state.pos - 1) {
// increase level if we find text `[`, which is not a part of any token
level++
} else if (disableNested) {
state.pos = oldPos
return -1
}
}
}
let labelEnd = -1
if (found) {
labelEnd = state.pos
}
// restore old state
state.pos = oldPos
return labelEnd
}

66
node_modules/markdown-it/lib/helpers/parse_link_title.mjs generated vendored Normal file
View File

@@ -0,0 +1,66 @@
// Parse link title
//
import { unescapeAll } from '../common/utils.mjs'
// Parse link title within `str` in [start, max] range,
// or continue previous parsing if `prev_state` is defined (equal to result of last execution).
//
export default function parseLinkTitle (str, start, max, prev_state) {
let code
let pos = start
const state = {
// if `true`, this is a valid link title
ok: false,
// if `true`, this link can be continued on the next line
can_continue: false,
// if `ok`, it's the position of the first character after the closing marker
pos: 0,
// if `ok`, it's the unescaped title
str: '',
// expected closing marker character code
marker: 0
}
if (prev_state) {
// this is a continuation of a previous parseLinkTitle call on the next line,
// used in reference links only
state.str = prev_state.str
state.marker = prev_state.marker
} else {
if (pos >= max) { return state }
let marker = str.charCodeAt(pos)
if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return state }
start++
pos++
// if opening marker is "(", switch it to closing marker ")"
if (marker === 0x28) { marker = 0x29 }
state.marker = marker
}
while (pos < max) {
code = str.charCodeAt(pos)
if (code === state.marker) {
state.pos = pos + 1
state.str += unescapeAll(str.slice(start, pos))
state.ok = true
return state
} else if (code === 0x28 /* ( */ && state.marker === 0x29 /* ) */) {
return state
} else if (code === 0x5C /* \ */ && pos + 1 < max) {
pos++
}
pos++
}
// no closing marker found, but this link title may continue on the next line (for references)
state.can_continue = true
state.str += unescapeAll(str.slice(start, pos))
return state
}

565
node_modules/markdown-it/lib/index.mjs generated vendored Normal file
View File

@@ -0,0 +1,565 @@
// Main parser class
import * as utils from './common/utils.mjs'
import * as helpers from './helpers/index.mjs'
import Renderer from './renderer.mjs'
import ParserCore from './parser_core.mjs'
import ParserBlock from './parser_block.mjs'
import ParserInline from './parser_inline.mjs'
import LinkifyIt from 'linkify-it'
import * as mdurl from 'mdurl'
import punycode from 'punycode.js'
import cfg_default from './presets/default.mjs'
import cfg_zero from './presets/zero.mjs'
import cfg_commonmark from './presets/commonmark.mjs'
const config = {
default: cfg_default,
zero: cfg_zero,
commonmark: cfg_commonmark
}
//
// This validator can prohibit more than really needed to prevent XSS. It's a
// tradeoff to keep code simple and to be secure by default.
//
// If you need different setup - override validator method as you wish. Or
// replace it with dummy function and use external sanitizer.
//
const BAD_PROTO_RE = /^(vbscript|javascript|file|data):/
const GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/
function validateLink (url) {
// url should be normalized at this point, and existing entities are decoded
const str = url.trim().toLowerCase()
return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : true
}
const RECODE_HOSTNAME_FOR = ['http:', 'https:', 'mailto:']
function normalizeLink (url) {
const parsed = mdurl.parse(url, true)
if (parsed.hostname) {
// Encode hostnames in urls like:
// `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
//
// We don't encode unknown schemas, because it's likely that we encode
// something we shouldn't (e.g. `skype:name` treated as `skype:host`)
//
if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
try {
parsed.hostname = punycode.toASCII(parsed.hostname)
} catch (er) { /**/ }
}
}
return mdurl.encode(mdurl.format(parsed))
}
function normalizeLinkText (url) {
const parsed = mdurl.parse(url, true)
if (parsed.hostname) {
// Encode hostnames in urls like:
// `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
//
// We don't encode unknown schemas, because it's likely that we encode
// something we shouldn't (e.g. `skype:name` treated as `skype:host`)
//
if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {
try {
parsed.hostname = punycode.toUnicode(parsed.hostname)
} catch (er) { /**/ }
}
}
// add '%' to exclude list because of https://github.com/markdown-it/markdown-it/issues/720
return mdurl.decode(mdurl.format(parsed), mdurl.decode.defaultChars + '%')
}
/**
* class MarkdownIt
*
* Main parser/renderer class.
*
* ##### Usage
*
* ```javascript
* // node.js, "classic" way:
* var MarkdownIt = require('markdown-it'),
* md = new MarkdownIt();
* var result = md.render('# markdown-it rulezz!');
*
* // node.js, the same, but with sugar:
* var md = require('markdown-it')();
* var result = md.render('# markdown-it rulezz!');
*
* // browser without AMD, added to "window" on script load
* // Note, there are no dash.
* var md = window.markdownit();
* var result = md.render('# markdown-it rulezz!');
* ```
*
* Single line rendering, without paragraph wrap:
*
* ```javascript
* var md = require('markdown-it')();
* var result = md.renderInline('__markdown-it__ rulezz!');
* ```
**/
/**
* new MarkdownIt([presetName, options])
* - presetName (String): optional, `commonmark` / `zero`
* - options (Object)
*
* Creates parser instanse with given config. Can be called without `new`.
*
* ##### presetName
*
* MarkdownIt provides named presets as a convenience to quickly
* enable/disable active syntax rules and options for common use cases.
*
* - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) -
* configures parser to strict [CommonMark](http://commonmark.org/) mode.
* - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) -
* similar to GFM, used when no preset name given. Enables all available rules,
* but still without html, typographer & autolinker.
* - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) -
* all rules disabled. Useful to quickly setup your config via `.enable()`.
* For example, when you need only `bold` and `italic` markup and nothing else.
*
* ##### options:
*
* - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!
* That's not safe! You may need external sanitizer to protect output from XSS.
* It's better to extend features via plugins, instead of enabling HTML.
* - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags
* (`<br />`). This is needed only for full CommonMark compatibility. In real
* world you will need HTML output.
* - __breaks__ - `false`. Set `true` to convert `\n` in paragraphs into `<br>`.
* - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.
* Can be useful for external highlighters.
* - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.
* - __typographer__ - `false`. Set `true` to enable [some language-neutral
* replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) +
* quotes beautification (smartquotes).
* - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement
* pairs, when typographer enabled and smartquotes on. For example, you can
* use `'«»„“'` for Russian, `'„“‚‘'` for German, and
* `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
* - __highlight__ - `null`. Highlighter function for fenced code blocks.
* Highlighter `function (str, lang)` should return escaped HTML. It can also
* return empty string if the source was not changed and should be escaped
* externaly. If result starts with <pre... internal wrapper is skipped.
*
* ##### Example
*
* ```javascript
* // commonmark mode
* var md = require('markdown-it')('commonmark');
*
* // default mode
* var md = require('markdown-it')();
*
* // enable everything
* var md = require('markdown-it')({
* html: true,
* linkify: true,
* typographer: true
* });
* ```
*
* ##### Syntax highlighting
*
* ```js
* var hljs = require('highlight.js') // https://highlightjs.org/
*
* var md = require('markdown-it')({
* highlight: function (str, lang) {
* if (lang && hljs.getLanguage(lang)) {
* try {
* return hljs.highlight(str, { language: lang, ignoreIllegals: true }).value;
* } catch (__) {}
* }
*
* return ''; // use external default escaping
* }
* });
* ```
*
* Or with full wrapper override (if you need assign class to `<pre>` or `<code>`):
*
* ```javascript
* var hljs = require('highlight.js') // https://highlightjs.org/
*
* // Actual default values
* var md = require('markdown-it')({
* highlight: function (str, lang) {
* if (lang && hljs.getLanguage(lang)) {
* try {
* return '<pre><code class="hljs">' +
* hljs.highlight(str, { language: lang, ignoreIllegals: true }).value +
* '</code></pre>';
* } catch (__) {}
* }
*
* return '<pre><code class="hljs">' + md.utils.escapeHtml(str) + '</code></pre>';
* }
* });
* ```
*
**/
function MarkdownIt (presetName, options) {
if (!(this instanceof MarkdownIt)) {
return new MarkdownIt(presetName, options)
}
if (!options) {
if (!utils.isString(presetName)) {
options = presetName || {}
presetName = 'default'
}
}
/**
* MarkdownIt#inline -> ParserInline
*
* Instance of [[ParserInline]]. You may need it to add new rules when
* writing plugins. For simple rules control use [[MarkdownIt.disable]] and
* [[MarkdownIt.enable]].
**/
this.inline = new ParserInline()
/**
* MarkdownIt#block -> ParserBlock
*
* Instance of [[ParserBlock]]. You may need it to add new rules when
* writing plugins. For simple rules control use [[MarkdownIt.disable]] and
* [[MarkdownIt.enable]].
**/
this.block = new ParserBlock()
/**
* MarkdownIt#core -> Core
*
* Instance of [[Core]] chain executor. You may need it to add new rules when
* writing plugins. For simple rules control use [[MarkdownIt.disable]] and
* [[MarkdownIt.enable]].
**/
this.core = new ParserCore()
/**
* MarkdownIt#renderer -> Renderer
*
* Instance of [[Renderer]]. Use it to modify output look. Or to add rendering
* rules for new token types, generated by plugins.
*
* ##### Example
*
* ```javascript
* var md = require('markdown-it')();
*
* function myToken(tokens, idx, options, env, self) {
* //...
* return result;
* };
*
* md.renderer.rules['my_token'] = myToken
* ```
*
* See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs).
**/
this.renderer = new Renderer()
/**
* MarkdownIt#linkify -> LinkifyIt
*
* [linkify-it](https://github.com/markdown-it/linkify-it) instance.
* Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs)
* rule.
**/
this.linkify = new LinkifyIt()
/**
* MarkdownIt#validateLink(url) -> Boolean
*
* Link validation function. CommonMark allows too much in links. By default
* we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
* except some embedded image types.
*
* You can change this behaviour:
*
* ```javascript
* var md = require('markdown-it')();
* // enable everything
* md.validateLink = function () { return true; }
* ```
**/
this.validateLink = validateLink
/**
* MarkdownIt#normalizeLink(url) -> String
*
* Function used to encode link url to a machine-readable format,
* which includes url-encoding, punycode, etc.
**/
this.normalizeLink = normalizeLink
/**
* MarkdownIt#normalizeLinkText(url) -> String
*
* Function used to decode link url to a human-readable format`
**/
this.normalizeLinkText = normalizeLinkText
// Expose utils & helpers for easy acces from plugins
/**
* MarkdownIt#utils -> utils
*
* Assorted utility functions, useful to write plugins. See details
* [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.mjs).
**/
this.utils = utils
/**
* MarkdownIt#helpers -> helpers
*
* Link components parser functions, useful to write plugins. See details
* [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).
**/
this.helpers = utils.assign({}, helpers)
this.options = {}
this.configure(presetName)
if (options) { this.set(options) }
}
/** chainable
* MarkdownIt.set(options)
*
* Set parser options (in the same format as in constructor). Probably, you
* will never need it, but you can change options after constructor call.
*
* ##### Example
*
* ```javascript
* var md = require('markdown-it')()
* .set({ html: true, breaks: true })
* .set({ typographer, true });
* ```
*
* __Note:__ To achieve the best possible performance, don't modify a
* `markdown-it` instance options on the fly. If you need multiple configurations
* it's best to create multiple instances and initialize each with separate
* config.
**/
MarkdownIt.prototype.set = function (options) {
utils.assign(this.options, options)
return this
}
/** chainable, internal
* MarkdownIt.configure(presets)
*
* Batch load of all options and compenent settings. This is internal method,
* and you probably will not need it. But if you will - see available presets
* and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
*
* We strongly recommend to use presets instead of direct config loads. That
* will give better compatibility with next versions.
**/
MarkdownIt.prototype.configure = function (presets) {
const self = this
if (utils.isString(presets)) {
const presetName = presets
presets = config[presetName]
if (!presets) { throw new Error('Wrong `markdown-it` preset "' + presetName + '", check name') }
}
if (!presets) { throw new Error('Wrong `markdown-it` preset, can\'t be empty') }
if (presets.options) { self.set(presets.options) }
if (presets.components) {
Object.keys(presets.components).forEach(function (name) {
if (presets.components[name].rules) {
self[name].ruler.enableOnly(presets.components[name].rules)
}
if (presets.components[name].rules2) {
self[name].ruler2.enableOnly(presets.components[name].rules2)
}
})
}
return this
}
/** chainable
* MarkdownIt.enable(list, ignoreInvalid)
* - list (String|Array): rule name or list of rule names to enable
* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
*
* Enable list or rules. It will automatically find appropriate components,
* containing rules with given names. If rule not found, and `ignoreInvalid`
* not set - throws exception.
*
* ##### Example
*
* ```javascript
* var md = require('markdown-it')()
* .enable(['sub', 'sup'])
* .disable('smartquotes');
* ```
**/
MarkdownIt.prototype.enable = function (list, ignoreInvalid) {
let result = []
if (!Array.isArray(list)) { list = [list] }
['core', 'block', 'inline'].forEach(function (chain) {
result = result.concat(this[chain].ruler.enable(list, true))
}, this)
result = result.concat(this.inline.ruler2.enable(list, true))
const missed = list.filter(function (name) { return result.indexOf(name) < 0 })
if (missed.length && !ignoreInvalid) {
throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed)
}
return this
}
/** chainable
* MarkdownIt.disable(list, ignoreInvalid)
* - list (String|Array): rule name or list of rule names to disable.
* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
*
* The same as [[MarkdownIt.enable]], but turn specified rules off.
**/
MarkdownIt.prototype.disable = function (list, ignoreInvalid) {
let result = []
if (!Array.isArray(list)) { list = [list] }
['core', 'block', 'inline'].forEach(function (chain) {
result = result.concat(this[chain].ruler.disable(list, true))
}, this)
result = result.concat(this.inline.ruler2.disable(list, true))
const missed = list.filter(function (name) { return result.indexOf(name) < 0 })
if (missed.length && !ignoreInvalid) {
throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed)
}
return this
}
/** chainable
* MarkdownIt.use(plugin, params)
*
* Load specified plugin with given params into current parser instance.
* It's just a sugar to call `plugin(md, params)` with curring.
*
* ##### Example
*
* ```javascript
* var iterator = require('markdown-it-for-inline');
* var md = require('markdown-it')()
* .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
* tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
* });
* ```
**/
MarkdownIt.prototype.use = function (plugin /*, params, ... */) {
const args = [this].concat(Array.prototype.slice.call(arguments, 1))
plugin.apply(plugin, args)
return this
}
/** internal
* MarkdownIt.parse(src, env) -> Array
* - src (String): source string
* - env (Object): environment sandbox
*
* Parse input string and return list of block tokens (special token type
* "inline" will contain list of inline tokens). You should not call this
* method directly, until you write custom renderer (for example, to produce
* AST).
*
* `env` is used to pass data between "distributed" rules and return additional
* metadata like reference info, needed for the renderer. It also can be used to
* inject data in specific cases. Usually, you will be ok to pass `{}`,
* and then pass updated object to renderer.
**/
MarkdownIt.prototype.parse = function (src, env) {
if (typeof src !== 'string') {
throw new Error('Input data should be a String')
}
const state = new this.core.State(src, this, env)
this.core.process(state)
return state.tokens
}
/**
* MarkdownIt.render(src [, env]) -> String
* - src (String): source string
* - env (Object): environment sandbox
*
* Render markdown string into html. It does all magic for you :).
*
* `env` can be used to inject additional metadata (`{}` by default).
* But you will not need it with high probability. See also comment
* in [[MarkdownIt.parse]].
**/
MarkdownIt.prototype.render = function (src, env) {
env = env || {}
return this.renderer.render(this.parse(src, env), this.options, env)
}
/** internal
* MarkdownIt.parseInline(src, env) -> Array
* - src (String): source string
* - env (Object): environment sandbox
*
* The same as [[MarkdownIt.parse]] but skip all block rules. It returns the
* block tokens list with the single `inline` element, containing parsed inline
* tokens in `children` property. Also updates `env` object.
**/
MarkdownIt.prototype.parseInline = function (src, env) {
const state = new this.core.State(src, this, env)
state.inlineMode = true
this.core.process(state)
return state.tokens
}
/**
* MarkdownIt.renderInline(src [, env]) -> String
* - src (String): source string
* - env (Object): environment sandbox
*
* Similar to [[MarkdownIt.render]] but for single paragraph content. Result
* will NOT be wrapped into `<p>` tags.
**/
MarkdownIt.prototype.renderInline = function (src, env) {
env = env || {}
return this.renderer.render(this.parseInline(src, env), this.options, env)
}
export default MarkdownIt

134
node_modules/markdown-it/lib/parser_block.mjs generated vendored Normal file
View File

@@ -0,0 +1,134 @@
/** internal
* class ParserBlock
*
* Block-level tokenizer.
**/
import Ruler from './ruler.mjs'
import StateBlock from './rules_block/state_block.mjs'
import r_table from './rules_block/table.mjs'
import r_code from './rules_block/code.mjs'
import r_fence from './rules_block/fence.mjs'
import r_blockquote from './rules_block/blockquote.mjs'
import r_hr from './rules_block/hr.mjs'
import r_list from './rules_block/list.mjs'
import r_reference from './rules_block/reference.mjs'
import r_html_block from './rules_block/html_block.mjs'
import r_heading from './rules_block/heading.mjs'
import r_lheading from './rules_block/lheading.mjs'
import r_paragraph from './rules_block/paragraph.mjs'
const _rules = [
// First 2 params - rule name & source. Secondary array - list of rules,
// which can be terminated by this one.
['table', r_table, ['paragraph', 'reference']],
['code', r_code],
['fence', r_fence, ['paragraph', 'reference', 'blockquote', 'list']],
['blockquote', r_blockquote, ['paragraph', 'reference', 'blockquote', 'list']],
['hr', r_hr, ['paragraph', 'reference', 'blockquote', 'list']],
['list', r_list, ['paragraph', 'reference', 'blockquote']],
['reference', r_reference],
['html_block', r_html_block, ['paragraph', 'reference', 'blockquote']],
['heading', r_heading, ['paragraph', 'reference', 'blockquote']],
['lheading', r_lheading],
['paragraph', r_paragraph]
]
/**
* new ParserBlock()
**/
function ParserBlock () {
/**
* ParserBlock#ruler -> Ruler
*
* [[Ruler]] instance. Keep configuration of block rules.
**/
this.ruler = new Ruler()
for (let i = 0; i < _rules.length; i++) {
this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() })
}
}
// Generate tokens for input range
//
ParserBlock.prototype.tokenize = function (state, startLine, endLine) {
const rules = this.ruler.getRules('')
const len = rules.length
const maxNesting = state.md.options.maxNesting
let line = startLine
let hasEmptyLines = false
while (line < endLine) {
state.line = line = state.skipEmptyLines(line)
if (line >= endLine) { break }
// Termination condition for nested calls.
// Nested calls currently used for blockquotes & lists
if (state.sCount[line] < state.blkIndent) { break }
// If nesting level exceeded - skip tail to the end. That's not ordinary
// situation and we should not care about content.
if (state.level >= maxNesting) {
state.line = endLine
break
}
// Try all possible rules.
// On success, rule should:
//
// - update `state.line`
// - update `state.tokens`
// - return true
const prevLine = state.line
let ok = false
for (let i = 0; i < len; i++) {
ok = rules[i](state, line, endLine, false)
if (ok) {
if (prevLine >= state.line) {
throw new Error("block rule didn't increment state.line")
}
break
}
}
// this can only happen if user disables paragraph rule
if (!ok) throw new Error('none of the block rules matched')
// set state.tight if we had an empty line before current tag
// i.e. latest empty line should not count
state.tight = !hasEmptyLines
// paragraph might "eat" one newline after it in nested lists
if (state.isEmpty(state.line - 1)) {
hasEmptyLines = true
}
line = state.line
if (line < endLine && state.isEmpty(line)) {
hasEmptyLines = true
line++
state.line = line
}
}
}
/**
* ParserBlock.parse(str, md, env, outTokens)
*
* Process input string and push block tokens into `outTokens`
**/
ParserBlock.prototype.parse = function (src, md, env, outTokens) {
if (!src) { return }
const state = new this.State(src, md, env, outTokens)
this.tokenize(state, state.line, state.lineMax)
}
ParserBlock.prototype.State = StateBlock
export default ParserBlock

62
node_modules/markdown-it/lib/parser_core.mjs generated vendored Normal file
View File

@@ -0,0 +1,62 @@
/** internal
* class Core
*
* Top-level rules executor. Glues block/inline parsers and does intermediate
* transformations.
**/
import Ruler from './ruler.mjs'
import StateCore from './rules_core/state_core.mjs'
import r_normalize from './rules_core/normalize.mjs'
import r_block from './rules_core/block.mjs'
import r_inline from './rules_core/inline.mjs'
import r_linkify from './rules_core/linkify.mjs'
import r_replacements from './rules_core/replacements.mjs'
import r_smartquotes from './rules_core/smartquotes.mjs'
import r_text_join from './rules_core/text_join.mjs'
const _rules = [
['normalize', r_normalize],
['block', r_block],
['inline', r_inline],
['linkify', r_linkify],
['replacements', r_replacements],
['smartquotes', r_smartquotes],
// `text_join` finds `text_special` tokens (for escape sequences)
// and joins them with the rest of the text
['text_join', r_text_join]
]
/**
* new Core()
**/
function Core () {
/**
* Core#ruler -> Ruler
*
* [[Ruler]] instance. Keep configuration of core rules.
**/
this.ruler = new Ruler()
for (let i = 0; i < _rules.length; i++) {
this.ruler.push(_rules[i][0], _rules[i][1])
}
}
/**
* Core.process(state)
*
* Executes core chain rules.
**/
Core.prototype.process = function (state) {
const rules = this.ruler.getRules('')
for (let i = 0, l = rules.length; i < l; i++) {
rules[i](state)
}
}
Core.prototype.State = StateCore
export default Core

197
node_modules/markdown-it/lib/parser_inline.mjs generated vendored Normal file
View File

@@ -0,0 +1,197 @@
/** internal
* class ParserInline
*
* Tokenizes paragraph content.
**/
import Ruler from './ruler.mjs'
import StateInline from './rules_inline/state_inline.mjs'
import r_text from './rules_inline/text.mjs'
import r_linkify from './rules_inline/linkify.mjs'
import r_newline from './rules_inline/newline.mjs'
import r_escape from './rules_inline/escape.mjs'
import r_backticks from './rules_inline/backticks.mjs'
import r_strikethrough from './rules_inline/strikethrough.mjs'
import r_emphasis from './rules_inline/emphasis.mjs'
import r_link from './rules_inline/link.mjs'
import r_image from './rules_inline/image.mjs'
import r_autolink from './rules_inline/autolink.mjs'
import r_html_inline from './rules_inline/html_inline.mjs'
import r_entity from './rules_inline/entity.mjs'
import r_balance_pairs from './rules_inline/balance_pairs.mjs'
import r_fragments_join from './rules_inline/fragments_join.mjs'
// Parser rules
const _rules = [
['text', r_text],
['linkify', r_linkify],
['newline', r_newline],
['escape', r_escape],
['backticks', r_backticks],
['strikethrough', r_strikethrough.tokenize],
['emphasis', r_emphasis.tokenize],
['link', r_link],
['image', r_image],
['autolink', r_autolink],
['html_inline', r_html_inline],
['entity', r_entity]
]
// `rule2` ruleset was created specifically for emphasis/strikethrough
// post-processing and may be changed in the future.
//
// Don't use this for anything except pairs (plugins working with `balance_pairs`).
//
const _rules2 = [
['balance_pairs', r_balance_pairs],
['strikethrough', r_strikethrough.postProcess],
['emphasis', r_emphasis.postProcess],
// rules for pairs separate '**' into its own text tokens, which may be left unused,
// rule below merges unused segments back with the rest of the text
['fragments_join', r_fragments_join]
]
/**
* new ParserInline()
**/
function ParserInline () {
/**
* ParserInline#ruler -> Ruler
*
* [[Ruler]] instance. Keep configuration of inline rules.
**/
this.ruler = new Ruler()
for (let i = 0; i < _rules.length; i++) {
this.ruler.push(_rules[i][0], _rules[i][1])
}
/**
* ParserInline#ruler2 -> Ruler
*
* [[Ruler]] instance. Second ruler used for post-processing
* (e.g. in emphasis-like rules).
**/
this.ruler2 = new Ruler()
for (let i = 0; i < _rules2.length; i++) {
this.ruler2.push(_rules2[i][0], _rules2[i][1])
}
}
// Skip single token by running all rules in validation mode;
// returns `true` if any rule reported success
//
ParserInline.prototype.skipToken = function (state) {
const pos = state.pos
const rules = this.ruler.getRules('')
const len = rules.length
const maxNesting = state.md.options.maxNesting
const cache = state.cache
if (typeof cache[pos] !== 'undefined') {
state.pos = cache[pos]
return
}
let ok = false
if (state.level < maxNesting) {
for (let i = 0; i < len; i++) {
// Increment state.level and decrement it later to limit recursion.
// It's harmless to do here, because no tokens are created. But ideally,
// we'd need a separate private state variable for this purpose.
//
state.level++
ok = rules[i](state, true)
state.level--
if (ok) {
if (pos >= state.pos) { throw new Error("inline rule didn't increment state.pos") }
break
}
}
} else {
// Too much nesting, just skip until the end of the paragraph.
//
// NOTE: this will cause links to behave incorrectly in the following case,
// when an amount of `[` is exactly equal to `maxNesting + 1`:
//
// [[[[[[[[[[[[[[[[[[[[[foo]()
//
// TODO: remove this workaround when CM standard will allow nested links
// (we can replace it by preventing links from being parsed in
// validation mode)
//
state.pos = state.posMax
}
if (!ok) { state.pos++ }
cache[pos] = state.pos
}
// Generate tokens for input range
//
ParserInline.prototype.tokenize = function (state) {
const rules = this.ruler.getRules('')
const len = rules.length
const end = state.posMax
const maxNesting = state.md.options.maxNesting
while (state.pos < end) {
// Try all possible rules.
// On success, rule should:
//
// - update `state.pos`
// - update `state.tokens`
// - return true
const prevPos = state.pos
let ok = false
if (state.level < maxNesting) {
for (let i = 0; i < len; i++) {
ok = rules[i](state, false)
if (ok) {
if (prevPos >= state.pos) { throw new Error("inline rule didn't increment state.pos") }
break
}
}
}
if (ok) {
if (state.pos >= end) { break }
continue
}
state.pending += state.src[state.pos++]
}
if (state.pending) {
state.pushPending()
}
}
/**
* ParserInline.parse(str, md, env, outTokens)
*
* Process input string and push inline tokens into `outTokens`
**/
ParserInline.prototype.parse = function (str, md, env, outTokens) {
const state = new this.State(str, md, env, outTokens)
this.tokenize(state)
const rules = this.ruler2.getRules('')
const len = rules.length
for (let i = 0; i < len; i++) {
rules[i](state)
}
}
ParserInline.prototype.State = StateInline
export default ParserInline

88
node_modules/markdown-it/lib/presets/commonmark.mjs generated vendored Normal file
View File

@@ -0,0 +1,88 @@
// Commonmark default options
export default {
options: {
// Enable HTML tags in source
html: true,
// Use '/' to close single tags (<br />)
xhtmlOut: true,
// Convert '\n' in paragraphs into <br>
breaks: false,
// CSS language prefix for fenced blocks
langPrefix: 'language-',
// autoconvert URL-like texts to links
linkify: false,
// Enable some language-neutral replacements + quotes beautification
typographer: false,
// Double + single quotes replacement pairs, when typographer enabled,
// and smartquotes on. Could be either a String or an Array.
//
// For example, you can use '«»„“' for Russian, '„“‚‘' for German,
// and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
// Highlighter function. Should return escaped HTML,
// or '' if the source string is not changed and should be escaped externaly.
// If result starts with <pre... internal wrapper is skipped.
//
// function (/*str, lang*/) { return ''; }
//
highlight: null,
// Internal protection, recursion limit
maxNesting: 20
},
components: {
core: {
rules: [
'normalize',
'block',
'inline',
'text_join'
]
},
block: {
rules: [
'blockquote',
'code',
'fence',
'heading',
'hr',
'html_block',
'lheading',
'list',
'reference',
'paragraph'
]
},
inline: {
rules: [
'autolink',
'backticks',
'emphasis',
'entity',
'escape',
'html_inline',
'image',
'link',
'newline',
'text'
],
rules2: [
'balance_pairs',
'emphasis',
'fragments_join'
]
}
}
}

47
node_modules/markdown-it/lib/presets/default.mjs generated vendored Normal file
View File

@@ -0,0 +1,47 @@
// markdown-it default options
export default {
options: {
// Enable HTML tags in source
html: false,
// Use '/' to close single tags (<br />)
xhtmlOut: false,
// Convert '\n' in paragraphs into <br>
breaks: false,
// CSS language prefix for fenced blocks
langPrefix: 'language-',
// autoconvert URL-like texts to links
linkify: false,
// Enable some language-neutral replacements + quotes beautification
typographer: false,
// Double + single quotes replacement pairs, when typographer enabled,
// and smartquotes on. Could be either a String or an Array.
//
// For example, you can use '«»„“' for Russian, '„“‚‘' for German,
// and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
// Highlighter function. Should return escaped HTML,
// or '' if the source string is not changed and should be escaped externaly.
// If result starts with <pre... internal wrapper is skipped.
//
// function (/*str, lang*/) { return ''; }
//
highlight: null,
// Internal protection, recursion limit
maxNesting: 100
},
components: {
core: {},
block: {},
inline: {}
}
}

70
node_modules/markdown-it/lib/presets/zero.mjs generated vendored Normal file
View File

@@ -0,0 +1,70 @@
// "Zero" preset, with nothing enabled. Useful for manual configuring of simple
// modes. For example, to parse bold/italic only.
export default {
options: {
// Enable HTML tags in source
html: false,
// Use '/' to close single tags (<br />)
xhtmlOut: false,
// Convert '\n' in paragraphs into <br>
breaks: false,
// CSS language prefix for fenced blocks
langPrefix: 'language-',
// autoconvert URL-like texts to links
linkify: false,
// Enable some language-neutral replacements + quotes beautification
typographer: false,
// Double + single quotes replacement pairs, when typographer enabled,
// and smartquotes on. Could be either a String or an Array.
//
// For example, you can use '«»„“' for Russian, '„“‚‘' for German,
// and ['«\xA0', '\xA0»', '‹\xA0', '\xA0›'] for French (including nbsp).
quotes: '\u201c\u201d\u2018\u2019', /* “”‘’ */
// Highlighter function. Should return escaped HTML,
// or '' if the source string is not changed and should be escaped externaly.
// If result starts with <pre... internal wrapper is skipped.
//
// function (/*str, lang*/) { return ''; }
//
highlight: null,
// Internal protection, recursion limit
maxNesting: 20
},
components: {
core: {
rules: [
'normalize',
'block',
'inline',
'text_join'
]
},
block: {
rules: [
'paragraph'
]
},
inline: {
rules: [
'text'
],
rules2: [
'balance_pairs',
'fragments_join'
]
}
}
}

322
node_modules/markdown-it/lib/renderer.mjs generated vendored Normal file
View File

@@ -0,0 +1,322 @@
/**
* class Renderer
*
* Generates HTML from parsed token stream. Each instance has independent
* copy of rules. Those can be rewritten with ease. Also, you can add new
* rules if you create plugin and adds new token types.
**/
import { assign, unescapeAll, escapeHtml } from './common/utils.mjs'
const default_rules = {}
default_rules.code_inline = function (tokens, idx, options, env, slf) {
const token = tokens[idx]
return '<code' + slf.renderAttrs(token) + '>' +
escapeHtml(token.content) +
'</code>'
}
default_rules.code_block = function (tokens, idx, options, env, slf) {
const token = tokens[idx]
return '<pre' + slf.renderAttrs(token) + '><code>' +
escapeHtml(tokens[idx].content) +
'</code></pre>\n'
}
default_rules.fence = function (tokens, idx, options, env, slf) {
const token = tokens[idx]
const info = token.info ? unescapeAll(token.info).trim() : ''
let langName = ''
let langAttrs = ''
if (info) {
const arr = info.split(/(\s+)/g)
langName = arr[0]
langAttrs = arr.slice(2).join('')
}
let highlighted
if (options.highlight) {
highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content)
} else {
highlighted = escapeHtml(token.content)
}
if (highlighted.indexOf('<pre') === 0) {
return highlighted + '\n'
}
// If language exists, inject class gently, without modifying original token.
// May be, one day we will add .deepClone() for token and simplify this part, but
// now we prefer to keep things local.
if (info) {
const i = token.attrIndex('class')
const tmpAttrs = token.attrs ? token.attrs.slice() : []
if (i < 0) {
tmpAttrs.push(['class', options.langPrefix + langName])
} else {
tmpAttrs[i] = tmpAttrs[i].slice()
tmpAttrs[i][1] += ' ' + options.langPrefix + langName
}
// Fake token just to render attributes
const tmpToken = {
attrs: tmpAttrs
}
return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>\n`
}
return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>\n`
}
default_rules.image = function (tokens, idx, options, env, slf) {
const token = tokens[idx]
// "alt" attr MUST be set, even if empty. Because it's mandatory and
// should be placed on proper position for tests.
//
// Replace content with actual value
token.attrs[token.attrIndex('alt')][1] =
slf.renderInlineAsText(token.children, options, env)
return slf.renderToken(tokens, idx, options)
}
default_rules.hardbreak = function (tokens, idx, options /*, env */) {
return options.xhtmlOut ? '<br />\n' : '<br>\n'
}
default_rules.softbreak = function (tokens, idx, options /*, env */) {
return options.breaks ? (options.xhtmlOut ? '<br />\n' : '<br>\n') : '\n'
}
default_rules.text = function (tokens, idx /*, options, env */) {
return escapeHtml(tokens[idx].content)
}
default_rules.html_block = function (tokens, idx /*, options, env */) {
return tokens[idx].content
}
default_rules.html_inline = function (tokens, idx /*, options, env */) {
return tokens[idx].content
}
/**
* new Renderer()
*
* Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
**/
function Renderer () {
/**
* Renderer#rules -> Object
*
* Contains render rules for tokens. Can be updated and extended.
*
* ##### Example
*
* ```javascript
* var md = require('markdown-it')();
*
* md.renderer.rules.strong_open = function () { return '<b>'; };
* md.renderer.rules.strong_close = function () { return '</b>'; };
*
* var result = md.renderInline(...);
* ```
*
* Each rule is called as independent static function with fixed signature:
*
* ```javascript
* function my_token_render(tokens, idx, options, env, renderer) {
* // ...
* return renderedHTML;
* }
* ```
*
* See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)
* for more details and examples.
**/
this.rules = assign({}, default_rules)
}
/**
* Renderer.renderAttrs(token) -> String
*
* Render token attributes to string.
**/
Renderer.prototype.renderAttrs = function renderAttrs (token) {
let i, l, result
if (!token.attrs) { return '' }
result = ''
for (i = 0, l = token.attrs.length; i < l; i++) {
result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"'
}
return result
}
/**
* Renderer.renderToken(tokens, idx, options) -> String
* - tokens (Array): list of tokens
* - idx (Numbed): token index to render
* - options (Object): params of parser instance
*
* Default token renderer. Can be overriden by custom function
* in [[Renderer#rules]].
**/
Renderer.prototype.renderToken = function renderToken (tokens, idx, options) {
const token = tokens[idx]
let result = ''
// Tight list paragraphs
if (token.hidden) {
return ''
}
// Insert a newline between hidden paragraph and subsequent opening
// block-level tag.
//
// For example, here we should insert a newline before blockquote:
// - a
// >
//
if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
result += '\n'
}
// Add token name, e.g. `<img`
result += (token.nesting === -1 ? '</' : '<') + token.tag
// Encode attributes, e.g. `<img src="foo"`
result += this.renderAttrs(token)
// Add a slash for self-closing tags, e.g. `<img src="foo" /`
if (token.nesting === 0 && options.xhtmlOut) {
result += ' /'
}
// Check if we need to add a newline after this tag
let needLf = false
if (token.block) {
needLf = true
if (token.nesting === 1) {
if (idx + 1 < tokens.length) {
const nextToken = tokens[idx + 1]
if (nextToken.type === 'inline' || nextToken.hidden) {
// Block-level tag containing an inline tag.
//
needLf = false
} else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
// Opening tag + closing tag of the same type. E.g. `<li></li>`.
//
needLf = false
}
}
}
}
result += needLf ? '>\n' : '>'
return result
}
/**
* Renderer.renderInline(tokens, options, env) -> String
* - tokens (Array): list on block tokens to render
* - options (Object): params of parser instance
* - env (Object): additional data from parsed input (references, for example)
*
* The same as [[Renderer.render]], but for single token of `inline` type.
**/
Renderer.prototype.renderInline = function (tokens, options, env) {
let result = ''
const rules = this.rules
for (let i = 0, len = tokens.length; i < len; i++) {
const type = tokens[i].type
if (typeof rules[type] !== 'undefined') {
result += rules[type](tokens, i, options, env, this)
} else {
result += this.renderToken(tokens, i, options)
}
}
return result
}
/** internal
* Renderer.renderInlineAsText(tokens, options, env) -> String
* - tokens (Array): list on block tokens to render
* - options (Object): params of parser instance
* - env (Object): additional data from parsed input (references, for example)
*
* Special kludge for image `alt` attributes to conform CommonMark spec.
* Don't try to use it! Spec requires to show `alt` content with stripped markup,
* instead of simple escaping.
**/
Renderer.prototype.renderInlineAsText = function (tokens, options, env) {
let result = ''
for (let i = 0, len = tokens.length; i < len; i++) {
switch (tokens[i].type) {
case 'text':
result += tokens[i].content
break
case 'image':
result += this.renderInlineAsText(tokens[i].children, options, env)
break
case 'html_inline':
case 'html_block':
result += tokens[i].content
break
case 'softbreak':
case 'hardbreak':
result += '\n'
break
default:
// all other tokens are skipped
}
}
return result
}
/**
* Renderer.render(tokens, options, env) -> String
* - tokens (Array): list on block tokens to render
* - options (Object): params of parser instance
* - env (Object): additional data from parsed input (references, for example)
*
* Takes token stream and generates HTML. Probably, you will never need to call
* this method directly.
**/
Renderer.prototype.render = function (tokens, options, env) {
let result = ''
const rules = this.rules
for (let i = 0, len = tokens.length; i < len; i++) {
const type = tokens[i].type
if (type === 'inline') {
result += this.renderInline(tokens[i].children, options, env)
} else if (typeof rules[type] !== 'undefined') {
result += rules[type](tokens, i, options, env, this)
} else {
result += this.renderToken(tokens, i, options, env)
}
}
return result
}
export default Renderer

340
node_modules/markdown-it/lib/ruler.mjs generated vendored Normal file
View File

@@ -0,0 +1,340 @@
/**
* class Ruler
*
* Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
* [[MarkdownIt#inline]] to manage sequences of functions (rules):
*
* - keep rules in defined order
* - assign the name to each rule
* - enable/disable rules
* - add/replace rules
* - allow assign rules to additional named chains (in the same)
* - cacheing lists of active rules
*
* You will not need use this class directly until write plugins. For simple
* rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
* [[MarkdownIt.use]].
**/
/**
* new Ruler()
**/
function Ruler () {
// List of added rules. Each element is:
//
// {
// name: XXX,
// enabled: Boolean,
// fn: Function(),
// alt: [ name2, name3 ]
// }
//
this.__rules__ = []
// Cached rule chains.
//
// First level - chain name, '' for default.
// Second level - diginal anchor for fast filtering by charcodes.
//
this.__cache__ = null
}
// Helper methods, should not be used directly
// Find rule index by name
//
Ruler.prototype.__find__ = function (name) {
for (let i = 0; i < this.__rules__.length; i++) {
if (this.__rules__[i].name === name) {
return i
}
}
return -1
}
// Build rules lookup cache
//
Ruler.prototype.__compile__ = function () {
const self = this
const chains = ['']
// collect unique names
self.__rules__.forEach(function (rule) {
if (!rule.enabled) { return }
rule.alt.forEach(function (altName) {
if (chains.indexOf(altName) < 0) {
chains.push(altName)
}
})
})
self.__cache__ = {}
chains.forEach(function (chain) {
self.__cache__[chain] = []
self.__rules__.forEach(function (rule) {
if (!rule.enabled) { return }
if (chain && rule.alt.indexOf(chain) < 0) { return }
self.__cache__[chain].push(rule.fn)
})
})
}
/**
* Ruler.at(name, fn [, options])
* - name (String): rule name to replace.
* - fn (Function): new rule function.
* - options (Object): new rule options (not mandatory).
*
* Replace rule by name with new function & options. Throws error if name not
* found.
*
* ##### Options:
*
* - __alt__ - array with names of "alternate" chains.
*
* ##### Example
*
* Replace existing typographer replacement rule with new one:
*
* ```javascript
* var md = require('markdown-it')();
*
* md.core.ruler.at('replacements', function replace(state) {
* //...
* });
* ```
**/
Ruler.prototype.at = function (name, fn, options) {
const index = this.__find__(name)
const opt = options || {}
if (index === -1) { throw new Error('Parser rule not found: ' + name) }
this.__rules__[index].fn = fn
this.__rules__[index].alt = opt.alt || []
this.__cache__ = null
}
/**
* Ruler.before(beforeName, ruleName, fn [, options])
* - beforeName (String): new rule will be added before this one.
* - ruleName (String): name of added rule.
* - fn (Function): rule function.
* - options (Object): rule options (not mandatory).
*
* Add new rule to chain before one with given name. See also
* [[Ruler.after]], [[Ruler.push]].
*
* ##### Options:
*
* - __alt__ - array with names of "alternate" chains.
*
* ##### Example
*
* ```javascript
* var md = require('markdown-it')();
*
* md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
* //...
* });
* ```
**/
Ruler.prototype.before = function (beforeName, ruleName, fn, options) {
const index = this.__find__(beforeName)
const opt = options || {}
if (index === -1) { throw new Error('Parser rule not found: ' + beforeName) }
this.__rules__.splice(index, 0, {
name: ruleName,
enabled: true,
fn,
alt: opt.alt || []
})
this.__cache__ = null
}
/**
* Ruler.after(afterName, ruleName, fn [, options])
* - afterName (String): new rule will be added after this one.
* - ruleName (String): name of added rule.
* - fn (Function): rule function.
* - options (Object): rule options (not mandatory).
*
* Add new rule to chain after one with given name. See also
* [[Ruler.before]], [[Ruler.push]].
*
* ##### Options:
*
* - __alt__ - array with names of "alternate" chains.
*
* ##### Example
*
* ```javascript
* var md = require('markdown-it')();
*
* md.inline.ruler.after('text', 'my_rule', function replace(state) {
* //...
* });
* ```
**/
Ruler.prototype.after = function (afterName, ruleName, fn, options) {
const index = this.__find__(afterName)
const opt = options || {}
if (index === -1) { throw new Error('Parser rule not found: ' + afterName) }
this.__rules__.splice(index + 1, 0, {
name: ruleName,
enabled: true,
fn,
alt: opt.alt || []
})
this.__cache__ = null
}
/**
* Ruler.push(ruleName, fn [, options])
* - ruleName (String): name of added rule.
* - fn (Function): rule function.
* - options (Object): rule options (not mandatory).
*
* Push new rule to the end of chain. See also
* [[Ruler.before]], [[Ruler.after]].
*
* ##### Options:
*
* - __alt__ - array with names of "alternate" chains.
*
* ##### Example
*
* ```javascript
* var md = require('markdown-it')();
*
* md.core.ruler.push('my_rule', function replace(state) {
* //...
* });
* ```
**/
Ruler.prototype.push = function (ruleName, fn, options) {
const opt = options || {}
this.__rules__.push({
name: ruleName,
enabled: true,
fn,
alt: opt.alt || []
})
this.__cache__ = null
}
/**
* Ruler.enable(list [, ignoreInvalid]) -> Array
* - list (String|Array): list of rule names to enable.
* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
*
* Enable rules with given names. If any rule name not found - throw Error.
* Errors can be disabled by second param.
*
* Returns list of found rule names (if no exception happened).
*
* See also [[Ruler.disable]], [[Ruler.enableOnly]].
**/
Ruler.prototype.enable = function (list, ignoreInvalid) {
if (!Array.isArray(list)) { list = [list] }
const result = []
// Search by name and enable
list.forEach(function (name) {
const idx = this.__find__(name)
if (idx < 0) {
if (ignoreInvalid) { return }
throw new Error('Rules manager: invalid rule name ' + name)
}
this.__rules__[idx].enabled = true
result.push(name)
}, this)
this.__cache__ = null
return result
}
/**
* Ruler.enableOnly(list [, ignoreInvalid])
* - list (String|Array): list of rule names to enable (whitelist).
* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
*
* Enable rules with given names, and disable everything else. If any rule name
* not found - throw Error. Errors can be disabled by second param.
*
* See also [[Ruler.disable]], [[Ruler.enable]].
**/
Ruler.prototype.enableOnly = function (list, ignoreInvalid) {
if (!Array.isArray(list)) { list = [list] }
this.__rules__.forEach(function (rule) { rule.enabled = false })
this.enable(list, ignoreInvalid)
}
/**
* Ruler.disable(list [, ignoreInvalid]) -> Array
* - list (String|Array): list of rule names to disable.
* - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
*
* Disable rules with given names. If any rule name not found - throw Error.
* Errors can be disabled by second param.
*
* Returns list of found rule names (if no exception happened).
*
* See also [[Ruler.enable]], [[Ruler.enableOnly]].
**/
Ruler.prototype.disable = function (list, ignoreInvalid) {
if (!Array.isArray(list)) { list = [list] }
const result = []
// Search by name and disable
list.forEach(function (name) {
const idx = this.__find__(name)
if (idx < 0) {
if (ignoreInvalid) { return }
throw new Error('Rules manager: invalid rule name ' + name)
}
this.__rules__[idx].enabled = false
result.push(name)
}, this)
this.__cache__ = null
return result
}
/**
* Ruler.getRules(chainName) -> Array
*
* Return array of active functions (rules) for given chain name. It analyzes
* rules configuration, compiles caches if not exists and returns result.
*
* Default chain name is `''` (empty string). It can't be skipped. That's
* done intentionally, to keep signature monomorphic for high speed.
**/
Ruler.prototype.getRules = function (chainName) {
if (this.__cache__ === null) {
this.__compile__()
}
// Chain can be empty, if rules disabled. But we still have to return Array.
return this.__cache__[chainName] || []
}
export default Ruler

209
node_modules/markdown-it/lib/rules_block/blockquote.mjs generated vendored Normal file
View File

@@ -0,0 +1,209 @@
// Block quotes
import { isSpace } from '../common/utils.mjs'
export default function blockquote (state, startLine, endLine, silent) {
let pos = state.bMarks[startLine] + state.tShift[startLine]
let max = state.eMarks[startLine]
const oldLineMax = state.lineMax
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
// check the block quote marker
if (state.src.charCodeAt(pos) !== 0x3E/* > */) { return false }
// we know that it's going to be a valid blockquote,
// so no point trying to find the end of it in silent mode
if (silent) { return true }
const oldBMarks = []
const oldBSCount = []
const oldSCount = []
const oldTShift = []
const terminatorRules = state.md.block.ruler.getRules('blockquote')
const oldParentType = state.parentType
state.parentType = 'blockquote'
let lastLineEmpty = false
let nextLine
// Search the end of the block
//
// Block ends with either:
// 1. an empty line outside:
// ```
// > test
//
// ```
// 2. an empty line inside:
// ```
// >
// test
// ```
// 3. another tag:
// ```
// > test
// - - -
// ```
for (nextLine = startLine; nextLine < endLine; nextLine++) {
// check if it's outdented, i.e. it's inside list item and indented
// less than said list item:
//
// ```
// 1. anything
// > current blockquote
// 2. checking this line
// ```
const isOutdented = state.sCount[nextLine] < state.blkIndent
pos = state.bMarks[nextLine] + state.tShift[nextLine]
max = state.eMarks[nextLine]
if (pos >= max) {
// Case 1: line is not inside the blockquote, and this line is empty.
break
}
if (state.src.charCodeAt(pos++) === 0x3E/* > */ && !isOutdented) {
// This line is inside the blockquote.
// set offset past spaces and ">"
let initial = state.sCount[nextLine] + 1
let spaceAfterMarker
let adjustTab
// skip one optional space after '>'
if (state.src.charCodeAt(pos) === 0x20 /* space */) {
// ' > test '
// ^ -- position start of line here:
pos++
initial++
adjustTab = false
spaceAfterMarker = true
} else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {
spaceAfterMarker = true
if ((state.bsCount[nextLine] + initial) % 4 === 3) {
// ' >\t test '
// ^ -- position start of line here (tab has width===1)
pos++
initial++
adjustTab = false
} else {
// ' >\t test '
// ^ -- position start of line here + shift bsCount slightly
// to make extra space appear
adjustTab = true
}
} else {
spaceAfterMarker = false
}
let offset = initial
oldBMarks.push(state.bMarks[nextLine])
state.bMarks[nextLine] = pos
while (pos < max) {
const ch = state.src.charCodeAt(pos)
if (isSpace(ch)) {
if (ch === 0x09) {
offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4
} else {
offset++
}
} else {
break
}
pos++
}
lastLineEmpty = pos >= max
oldBSCount.push(state.bsCount[nextLine])
state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0)
oldSCount.push(state.sCount[nextLine])
state.sCount[nextLine] = offset - initial
oldTShift.push(state.tShift[nextLine])
state.tShift[nextLine] = pos - state.bMarks[nextLine]
continue
}
// Case 2: line is not inside the blockquote, and the last line was empty.
if (lastLineEmpty) { break }
// Case 3: another tag found.
let terminate = false
for (let i = 0, l = terminatorRules.length; i < l; i++) {
if (terminatorRules[i](state, nextLine, endLine, true)) {
terminate = true
break
}
}
if (terminate) {
// Quirk to enforce "hard termination mode" for paragraphs;
// normally if you call `tokenize(state, startLine, nextLine)`,
// paragraphs will look below nextLine for paragraph continuation,
// but if blockquote is terminated by another tag, they shouldn't
state.lineMax = nextLine
if (state.blkIndent !== 0) {
// state.blkIndent was non-zero, we now set it to zero,
// so we need to re-calculate all offsets to appear as
// if indent wasn't changed
oldBMarks.push(state.bMarks[nextLine])
oldBSCount.push(state.bsCount[nextLine])
oldTShift.push(state.tShift[nextLine])
oldSCount.push(state.sCount[nextLine])
state.sCount[nextLine] -= state.blkIndent
}
break
}
oldBMarks.push(state.bMarks[nextLine])
oldBSCount.push(state.bsCount[nextLine])
oldTShift.push(state.tShift[nextLine])
oldSCount.push(state.sCount[nextLine])
// A negative indentation means that this is a paragraph continuation
//
state.sCount[nextLine] = -1
}
const oldIndent = state.blkIndent
state.blkIndent = 0
const token_o = state.push('blockquote_open', 'blockquote', 1)
token_o.markup = '>'
const lines = [startLine, 0]
token_o.map = lines
state.md.block.tokenize(state, startLine, nextLine)
const token_c = state.push('blockquote_close', 'blockquote', -1)
token_c.markup = '>'
state.lineMax = oldLineMax
state.parentType = oldParentType
lines[1] = state.line
// Restore original tShift; this might not be necessary since the parser
// has already been here, but just to make sure we can do that.
for (let i = 0; i < oldTShift.length; i++) {
state.bMarks[i + startLine] = oldBMarks[i]
state.tShift[i + startLine] = oldTShift[i]
state.sCount[i + startLine] = oldSCount[i]
state.bsCount[i + startLine] = oldBSCount[i]
}
state.blkIndent = oldIndent
return true
}

30
node_modules/markdown-it/lib/rules_block/code.mjs generated vendored Normal file
View File

@@ -0,0 +1,30 @@
// Code block (4 spaces padded)
export default function code (state, startLine, endLine/*, silent */) {
if (state.sCount[startLine] - state.blkIndent < 4) { return false }
let nextLine = startLine + 1
let last = nextLine
while (nextLine < endLine) {
if (state.isEmpty(nextLine)) {
nextLine++
continue
}
if (state.sCount[nextLine] - state.blkIndent >= 4) {
nextLine++
last = nextLine
continue
}
break
}
state.line = last
const token = state.push('code_block', 'code', 0)
token.content = state.getLines(startLine, last, 4 + state.blkIndent, false) + '\n'
token.map = [startLine, state.line]
return true
}

94
node_modules/markdown-it/lib/rules_block/fence.mjs generated vendored Normal file
View File

@@ -0,0 +1,94 @@
// fences (``` lang, ~~~ lang)
export default function fence (state, startLine, endLine, silent) {
let pos = state.bMarks[startLine] + state.tShift[startLine]
let max = state.eMarks[startLine]
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
if (pos + 3 > max) { return false }
const marker = state.src.charCodeAt(pos)
if (marker !== 0x7E/* ~ */ && marker !== 0x60 /* ` */) {
return false
}
// scan marker length
let mem = pos
pos = state.skipChars(pos, marker)
let len = pos - mem
if (len < 3) { return false }
const markup = state.src.slice(mem, pos)
const params = state.src.slice(pos, max)
if (marker === 0x60 /* ` */) {
if (params.indexOf(String.fromCharCode(marker)) >= 0) {
return false
}
}
// Since start is found, we can report success here in validation mode
if (silent) { return true }
// search end of block
let nextLine = startLine
let haveEndMarker = false
for (;;) {
nextLine++
if (nextLine >= endLine) {
// unclosed block should be autoclosed by end of document.
// also block seems to be autoclosed by end of parent
break
}
pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]
max = state.eMarks[nextLine]
if (pos < max && state.sCount[nextLine] < state.blkIndent) {
// non-empty line with negative indent should stop the list:
// - ```
// test
break
}
if (state.src.charCodeAt(pos) !== marker) { continue }
if (state.sCount[nextLine] - state.blkIndent >= 4) {
// closing fence should be indented less than 4 spaces
continue
}
pos = state.skipChars(pos, marker)
// closing code fence must be at least as long as the opening one
if (pos - mem < len) { continue }
// make sure tail has spaces only
pos = state.skipSpaces(pos)
if (pos < max) { continue }
haveEndMarker = true
// found!
break
}
// If a fence has heading spaces, they should be removed from its inner block
len = state.sCount[startLine]
state.line = nextLine + (haveEndMarker ? 1 : 0)
const token = state.push('fence', 'code', 0)
token.info = params
token.content = state.getLines(startLine + 1, nextLine, len, true)
token.markup = markup
token.map = [startLine, state.line]
return true
}

51
node_modules/markdown-it/lib/rules_block/heading.mjs generated vendored Normal file
View File

@@ -0,0 +1,51 @@
// heading (#, ##, ...)
import { isSpace } from '../common/utils.mjs'
export default function heading (state, startLine, endLine, silent) {
let pos = state.bMarks[startLine] + state.tShift[startLine]
let max = state.eMarks[startLine]
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
let ch = state.src.charCodeAt(pos)
if (ch !== 0x23/* # */ || pos >= max) { return false }
// count heading level
let level = 1
ch = state.src.charCodeAt(++pos)
while (ch === 0x23/* # */ && pos < max && level <= 6) {
level++
ch = state.src.charCodeAt(++pos)
}
if (level > 6 || (pos < max && !isSpace(ch))) { return false }
if (silent) { return true }
// Let's cut tails like ' ### ' from the end of string
max = state.skipSpacesBack(max, pos)
const tmp = state.skipCharsBack(max, 0x23, pos) // #
if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {
max = tmp
}
state.line = startLine + 1
const token_o = state.push('heading_open', 'h' + String(level), 1)
token_o.markup = '########'.slice(0, level)
token_o.map = [startLine, state.line]
const token_i = state.push('inline', '', 0)
token_i.content = state.src.slice(pos, max).trim()
token_i.map = [startLine, state.line]
token_i.children = []
const token_c = state.push('heading_close', 'h' + String(level), -1)
token_c.markup = '########'.slice(0, level)
return true
}

40
node_modules/markdown-it/lib/rules_block/hr.mjs generated vendored Normal file
View File

@@ -0,0 +1,40 @@
// Horizontal rule
import { isSpace } from '../common/utils.mjs'
export default function hr (state, startLine, endLine, silent) {
const max = state.eMarks[startLine]
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
let pos = state.bMarks[startLine] + state.tShift[startLine]
const marker = state.src.charCodeAt(pos++)
// Check hr marker
if (marker !== 0x2A/* * */ &&
marker !== 0x2D/* - */ &&
marker !== 0x5F/* _ */) {
return false
}
// markers can be mixed with spaces, but there should be at least 3 of them
let cnt = 1
while (pos < max) {
const ch = state.src.charCodeAt(pos++)
if (ch !== marker && !isSpace(ch)) { return false }
if (ch === marker) { cnt++ }
}
if (cnt < 3) { return false }
if (silent) { return true }
state.line = startLine + 1
const token = state.push('hr', 'hr', 0)
token.map = [startLine, state.line]
token.markup = Array(cnt + 1).join(String.fromCharCode(marker))
return true
}

69
node_modules/markdown-it/lib/rules_block/html_block.mjs generated vendored Normal file
View File

@@ -0,0 +1,69 @@
// HTML block
import block_names from '../common/html_blocks.mjs'
import { HTML_OPEN_CLOSE_TAG_RE } from '../common/html_re.mjs'
// An array of opening and corresponding closing sequences for html tags,
// last argument defines whether it can terminate a paragraph or not
//
const HTML_SEQUENCES = [
[/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true],
[/^<!--/, /-->/, true],
[/^<\?/, /\?>/, true],
[/^<![A-Z]/, />/, true],
[/^<!\[CDATA\[/, /\]\]>/, true],
[new RegExp('^</?(' + block_names.join('|') + ')(?=(\\s|/?>|$))', 'i'), /^$/, true],
[new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\s*$'), /^$/, false]
]
export default function html_block (state, startLine, endLine, silent) {
let pos = state.bMarks[startLine] + state.tShift[startLine]
let max = state.eMarks[startLine]
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
if (!state.md.options.html) { return false }
if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }
let lineText = state.src.slice(pos, max)
let i = 0
for (; i < HTML_SEQUENCES.length; i++) {
if (HTML_SEQUENCES[i][0].test(lineText)) { break }
}
if (i === HTML_SEQUENCES.length) { return false }
if (silent) {
// true if this sequence can be a terminator, false otherwise
return HTML_SEQUENCES[i][2]
}
let nextLine = startLine + 1
// If we are here - we detected HTML block.
// Let's roll down till block end.
if (!HTML_SEQUENCES[i][1].test(lineText)) {
for (; nextLine < endLine; nextLine++) {
if (state.sCount[nextLine] < state.blkIndent) { break }
pos = state.bMarks[nextLine] + state.tShift[nextLine]
max = state.eMarks[nextLine]
lineText = state.src.slice(pos, max)
if (HTML_SEQUENCES[i][1].test(lineText)) {
if (lineText.length !== 0) { nextLine++ }
break
}
}
}
state.line = nextLine
const token = state.push('html_block', '', 0)
token.map = [startLine, nextLine]
token.content = state.getLines(startLine, nextLine, state.blkIndent, true)
return true
}

82
node_modules/markdown-it/lib/rules_block/lheading.mjs generated vendored Normal file
View File

@@ -0,0 +1,82 @@
// lheading (---, ===)
export default function lheading (state, startLine, endLine/*, silent */) {
const terminatorRules = state.md.block.ruler.getRules('paragraph')
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
const oldParentType = state.parentType
state.parentType = 'paragraph' // use paragraph to match terminatorRules
// jump line-by-line until empty one or EOF
let level = 0
let marker
let nextLine = startLine + 1
for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
// this would be a code block normally, but after paragraph
// it's considered a lazy continuation regardless of what's there
if (state.sCount[nextLine] - state.blkIndent > 3) { continue }
//
// Check for underline in setext header
//
if (state.sCount[nextLine] >= state.blkIndent) {
let pos = state.bMarks[nextLine] + state.tShift[nextLine]
const max = state.eMarks[nextLine]
if (pos < max) {
marker = state.src.charCodeAt(pos)
if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {
pos = state.skipChars(pos, marker)
pos = state.skipSpaces(pos)
if (pos >= max) {
level = (marker === 0x3D/* = */ ? 1 : 2)
break
}
}
}
}
// quirk for blockquotes, this line should already be checked by that rule
if (state.sCount[nextLine] < 0) { continue }
// Some tags can terminate paragraph without empty line.
let terminate = false
for (let i = 0, l = terminatorRules.length; i < l; i++) {
if (terminatorRules[i](state, nextLine, endLine, true)) {
terminate = true
break
}
}
if (terminate) { break }
}
if (!level) {
// Didn't find valid underline
return false
}
const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim()
state.line = nextLine + 1
const token_o = state.push('heading_open', 'h' + String(level), 1)
token_o.markup = String.fromCharCode(marker)
token_o.map = [startLine, state.line]
const token_i = state.push('inline', '', 0)
token_i.content = content
token_i.map = [startLine, state.line - 1]
token_i.children = []
const token_c = state.push('heading_close', 'h' + String(level), -1)
token_c.markup = String.fromCharCode(marker)
state.parentType = oldParentType
return true
}

331
node_modules/markdown-it/lib/rules_block/list.mjs generated vendored Normal file
View File

@@ -0,0 +1,331 @@
// Lists
import { isSpace } from '../common/utils.mjs'
// Search `[-+*][\n ]`, returns next pos after marker on success
// or -1 on fail.
function skipBulletListMarker (state, startLine) {
const max = state.eMarks[startLine]
let pos = state.bMarks[startLine] + state.tShift[startLine]
const marker = state.src.charCodeAt(pos++)
// Check bullet
if (marker !== 0x2A/* * */ &&
marker !== 0x2D/* - */ &&
marker !== 0x2B/* + */) {
return -1
}
if (pos < max) {
const ch = state.src.charCodeAt(pos)
if (!isSpace(ch)) {
// " -test " - is not a list item
return -1
}
}
return pos
}
// Search `\d+[.)][\n ]`, returns next pos after marker on success
// or -1 on fail.
function skipOrderedListMarker (state, startLine) {
const start = state.bMarks[startLine] + state.tShift[startLine]
const max = state.eMarks[startLine]
let pos = start
// List marker should have at least 2 chars (digit + dot)
if (pos + 1 >= max) { return -1 }
let ch = state.src.charCodeAt(pos++)
if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1 }
for (;;) {
// EOL -> fail
if (pos >= max) { return -1 }
ch = state.src.charCodeAt(pos++)
if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {
// List marker should have no more than 9 digits
// (prevents integer overflow in browsers)
if (pos - start >= 10) { return -1 }
continue
}
// found valid marker
if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {
break
}
return -1
}
if (pos < max) {
ch = state.src.charCodeAt(pos)
if (!isSpace(ch)) {
// " 1.test " - is not a list item
return -1
}
}
return pos
}
function markTightParagraphs (state, idx) {
const level = state.level + 2
for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {
state.tokens[i + 2].hidden = true
state.tokens[i].hidden = true
i += 2
}
}
}
export default function list (state, startLine, endLine, silent) {
let max, pos, start, token
let nextLine = startLine
let tight = true
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[nextLine] - state.blkIndent >= 4) { return false }
// Special case:
// - item 1
// - item 2
// - item 3
// - item 4
// - this one is a paragraph continuation
if (state.listIndent >= 0 &&
state.sCount[nextLine] - state.listIndent >= 4 &&
state.sCount[nextLine] < state.blkIndent) {
return false
}
let isTerminatingParagraph = false
// limit conditions when list can interrupt
// a paragraph (validation mode only)
if (silent && state.parentType === 'paragraph') {
// Next list item should still terminate previous list item;
//
// This code can fail if plugins use blkIndent as well as lists,
// but I hope the spec gets fixed long before that happens.
//
if (state.sCount[nextLine] >= state.blkIndent) {
isTerminatingParagraph = true
}
}
// Detect list type and position after marker
let isOrdered
let markerValue
let posAfterMarker
if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {
isOrdered = true
start = state.bMarks[nextLine] + state.tShift[nextLine]
markerValue = Number(state.src.slice(start, posAfterMarker - 1))
// If we're starting a new ordered list right after
// a paragraph, it should start with 1.
if (isTerminatingParagraph && markerValue !== 1) return false
} else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {
isOrdered = false
} else {
return false
}
// If we're starting a new unordered list right after
// a paragraph, first line should not be empty.
if (isTerminatingParagraph) {
if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine]) return false
}
// For validation mode we can terminate immediately
if (silent) { return true }
// We should terminate list on style change. Remember first one to compare.
const markerCharCode = state.src.charCodeAt(posAfterMarker - 1)
// Start list
const listTokIdx = state.tokens.length
if (isOrdered) {
token = state.push('ordered_list_open', 'ol', 1)
if (markerValue !== 1) {
token.attrs = [['start', markerValue]]
}
} else {
token = state.push('bullet_list_open', 'ul', 1)
}
const listLines = [nextLine, 0]
token.map = listLines
token.markup = String.fromCharCode(markerCharCode)
//
// Iterate list items
//
let prevEmptyEnd = false
const terminatorRules = state.md.block.ruler.getRules('list')
const oldParentType = state.parentType
state.parentType = 'list'
while (nextLine < endLine) {
pos = posAfterMarker
max = state.eMarks[nextLine]
const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine])
let offset = initial
while (pos < max) {
const ch = state.src.charCodeAt(pos)
if (ch === 0x09) {
offset += 4 - (offset + state.bsCount[nextLine]) % 4
} else if (ch === 0x20) {
offset++
} else {
break
}
pos++
}
const contentStart = pos
let indentAfterMarker
if (contentStart >= max) {
// trimming space in "- \n 3" case, indent is 1 here
indentAfterMarker = 1
} else {
indentAfterMarker = offset - initial
}
// If we have more than 4 spaces, the indent is 1
// (the rest is just indented code block)
if (indentAfterMarker > 4) { indentAfterMarker = 1 }
// " - test"
// ^^^^^ - calculating total length of this thing
const indent = initial + indentAfterMarker
// Run subparser & write tokens
token = state.push('list_item_open', 'li', 1)
token.markup = String.fromCharCode(markerCharCode)
const itemLines = [nextLine, 0]
token.map = itemLines
if (isOrdered) {
token.info = state.src.slice(start, posAfterMarker - 1)
}
// change current state, then restore it after parser subcall
const oldTight = state.tight
const oldTShift = state.tShift[nextLine]
const oldSCount = state.sCount[nextLine]
// - example list
// ^ listIndent position will be here
// ^ blkIndent position will be here
//
const oldListIndent = state.listIndent
state.listIndent = state.blkIndent
state.blkIndent = indent
state.tight = true
state.tShift[nextLine] = contentStart - state.bMarks[nextLine]
state.sCount[nextLine] = offset
if (contentStart >= max && state.isEmpty(nextLine + 1)) {
// workaround for this case
// (list item is empty, list terminates before "foo"):
// ~~~~~~~~
// -
//
// foo
// ~~~~~~~~
state.line = Math.min(state.line + 2, endLine)
} else {
state.md.block.tokenize(state, nextLine, endLine, true)
}
// If any of list item is tight, mark list as tight
if (!state.tight || prevEmptyEnd) {
tight = false
}
// Item become loose if finish with empty line,
// but we should filter last element, because it means list finish
prevEmptyEnd = (state.line - nextLine) > 1 && state.isEmpty(state.line - 1)
state.blkIndent = state.listIndent
state.listIndent = oldListIndent
state.tShift[nextLine] = oldTShift
state.sCount[nextLine] = oldSCount
state.tight = oldTight
token = state.push('list_item_close', 'li', -1)
token.markup = String.fromCharCode(markerCharCode)
nextLine = state.line
itemLines[1] = nextLine
if (nextLine >= endLine) { break }
//
// Try to check if list is terminated or continued.
//
if (state.sCount[nextLine] < state.blkIndent) { break }
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[nextLine] - state.blkIndent >= 4) { break }
// fail if terminating block found
let terminate = false
for (let i = 0, l = terminatorRules.length; i < l; i++) {
if (terminatorRules[i](state, nextLine, endLine, true)) {
terminate = true
break
}
}
if (terminate) { break }
// fail if list has another type
if (isOrdered) {
posAfterMarker = skipOrderedListMarker(state, nextLine)
if (posAfterMarker < 0) { break }
start = state.bMarks[nextLine] + state.tShift[nextLine]
} else {
posAfterMarker = skipBulletListMarker(state, nextLine)
if (posAfterMarker < 0) { break }
}
if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break }
}
// Finalize list
if (isOrdered) {
token = state.push('ordered_list_close', 'ol', -1)
} else {
token = state.push('bullet_list_close', 'ul', -1)
}
token.markup = String.fromCharCode(markerCharCode)
listLines[1] = nextLine
state.line = nextLine
state.parentType = oldParentType
// mark paragraphs tight if needed
if (tight) {
markTightParagraphs(state, listTokIdx)
}
return true
}

46
node_modules/markdown-it/lib/rules_block/paragraph.mjs generated vendored Normal file
View File

@@ -0,0 +1,46 @@
// Paragraph
export default function paragraph (state, startLine, endLine) {
const terminatorRules = state.md.block.ruler.getRules('paragraph')
const oldParentType = state.parentType
let nextLine = startLine + 1
state.parentType = 'paragraph'
// jump line-by-line until empty one or EOF
for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
// this would be a code block normally, but after paragraph
// it's considered a lazy continuation regardless of what's there
if (state.sCount[nextLine] - state.blkIndent > 3) { continue }
// quirk for blockquotes, this line should already be checked by that rule
if (state.sCount[nextLine] < 0) { continue }
// Some tags can terminate paragraph without empty line.
let terminate = false
for (let i = 0, l = terminatorRules.length; i < l; i++) {
if (terminatorRules[i](state, nextLine, endLine, true)) {
terminate = true
break
}
}
if (terminate) { break }
}
const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim()
state.line = nextLine
const token_o = state.push('paragraph_open', 'p', 1)
token_o.map = [startLine, state.line]
const token_i = state.push('inline', '', 0)
token_i.content = content
token_i.map = [startLine, state.line]
token_i.children = []
state.push('paragraph_close', 'p', -1)
state.parentType = oldParentType
return true
}

212
node_modules/markdown-it/lib/rules_block/reference.mjs generated vendored Normal file
View File

@@ -0,0 +1,212 @@
import { isSpace, normalizeReference } from '../common/utils.mjs'
export default function reference (state, startLine, _endLine, silent) {
let pos = state.bMarks[startLine] + state.tShift[startLine]
let max = state.eMarks[startLine]
let nextLine = startLine + 1
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false }
function getNextLine (nextLine) {
const endLine = state.lineMax
if (nextLine >= endLine || state.isEmpty(nextLine)) {
// empty line or end of input
return null
}
let isContinuation = false
// this would be a code block normally, but after paragraph
// it's considered a lazy continuation regardless of what's there
if (state.sCount[nextLine] - state.blkIndent > 3) { isContinuation = true }
// quirk for blockquotes, this line should already be checked by that rule
if (state.sCount[nextLine] < 0) { isContinuation = true }
if (!isContinuation) {
const terminatorRules = state.md.block.ruler.getRules('reference')
const oldParentType = state.parentType
state.parentType = 'reference'
// Some tags can terminate paragraph without empty line.
let terminate = false
for (let i = 0, l = terminatorRules.length; i < l; i++) {
if (terminatorRules[i](state, nextLine, endLine, true)) {
terminate = true
break
}
}
state.parentType = oldParentType
if (terminate) {
// terminated by another block
return null
}
}
const pos = state.bMarks[nextLine] + state.tShift[nextLine]
const max = state.eMarks[nextLine]
// max + 1 explicitly includes the newline
return state.src.slice(pos, max + 1)
}
let str = state.src.slice(pos, max + 1)
max = str.length
let labelEnd = -1
for (pos = 1; pos < max; pos++) {
const ch = str.charCodeAt(pos)
if (ch === 0x5B /* [ */) {
return false
} else if (ch === 0x5D /* ] */) {
labelEnd = pos
break
} else if (ch === 0x0A /* \n */) {
const lineContent = getNextLine(nextLine)
if (lineContent !== null) {
str += lineContent
max = str.length
nextLine++
}
} else if (ch === 0x5C /* \ */) {
pos++
if (pos < max && str.charCodeAt(pos) === 0x0A) {
const lineContent = getNextLine(nextLine)
if (lineContent !== null) {
str += lineContent
max = str.length
nextLine++
}
}
}
}
if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }
// [label]: destination 'title'
// ^^^ skip optional whitespace here
for (pos = labelEnd + 2; pos < max; pos++) {
const ch = str.charCodeAt(pos)
if (ch === 0x0A) {
const lineContent = getNextLine(nextLine)
if (lineContent !== null) {
str += lineContent
max = str.length
nextLine++
}
} else if (isSpace(ch)) {
/* eslint no-empty:0 */
} else {
break
}
}
// [label]: destination 'title'
// ^^^^^^^^^^^ parse this
const destRes = state.md.helpers.parseLinkDestination(str, pos, max)
if (!destRes.ok) { return false }
const href = state.md.normalizeLink(destRes.str)
if (!state.md.validateLink(href)) { return false }
pos = destRes.pos
// save cursor state, we could require to rollback later
const destEndPos = pos
const destEndLineNo = nextLine
// [label]: destination 'title'
// ^^^ skipping those spaces
const start = pos
for (; pos < max; pos++) {
const ch = str.charCodeAt(pos)
if (ch === 0x0A) {
const lineContent = getNextLine(nextLine)
if (lineContent !== null) {
str += lineContent
max = str.length
nextLine++
}
} else if (isSpace(ch)) {
/* eslint no-empty:0 */
} else {
break
}
}
// [label]: destination 'title'
// ^^^^^^^ parse this
let titleRes = state.md.helpers.parseLinkTitle(str, pos, max)
while (titleRes.can_continue) {
const lineContent = getNextLine(nextLine)
if (lineContent === null) break
str += lineContent
pos = max
max = str.length
nextLine++
titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes)
}
let title
if (pos < max && start !== pos && titleRes.ok) {
title = titleRes.str
pos = titleRes.pos
} else {
title = ''
pos = destEndPos
nextLine = destEndLineNo
}
// skip trailing spaces until the rest of the line
while (pos < max) {
const ch = str.charCodeAt(pos)
if (!isSpace(ch)) { break }
pos++
}
if (pos < max && str.charCodeAt(pos) !== 0x0A) {
if (title) {
// garbage at the end of the line after title,
// but it could still be a valid reference if we roll back
title = ''
pos = destEndPos
nextLine = destEndLineNo
while (pos < max) {
const ch = str.charCodeAt(pos)
if (!isSpace(ch)) { break }
pos++
}
}
}
if (pos < max && str.charCodeAt(pos) !== 0x0A) {
// garbage at the end of the line
return false
}
const label = normalizeReference(str.slice(1, labelEnd))
if (!label) {
// CommonMark 0.20 disallows empty labels
return false
}
// Reference can not terminate anything. This check is for safety only.
/* istanbul ignore if */
if (silent) { return true }
if (typeof state.env.references === 'undefined') {
state.env.references = {}
}
if (typeof state.env.references[label] === 'undefined') {
state.env.references[label] = { title, href }
}
state.line = nextLine
return true
}

220
node_modules/markdown-it/lib/rules_block/state_block.mjs generated vendored Normal file
View File

@@ -0,0 +1,220 @@
// Parser state class
import Token from '../token.mjs'
import { isSpace } from '../common/utils.mjs'
function StateBlock (src, md, env, tokens) {
this.src = src
// link to parser instance
this.md = md
this.env = env
//
// Internal state vartiables
//
this.tokens = tokens
this.bMarks = [] // line begin offsets for fast jumps
this.eMarks = [] // line end offsets for fast jumps
this.tShift = [] // offsets of the first non-space characters (tabs not expanded)
this.sCount = [] // indents for each line (tabs expanded)
// An amount of virtual spaces (tabs expanded) between beginning
// of each line (bMarks) and real beginning of that line.
//
// It exists only as a hack because blockquotes override bMarks
// losing information in the process.
//
// It's used only when expanding tabs, you can think about it as
// an initial tab length, e.g. bsCount=21 applied to string `\t123`
// means first tab should be expanded to 4-21%4 === 3 spaces.
//
this.bsCount = []
// block parser variables
// required block content indent (for example, if we are
// inside a list, it would be positioned after list marker)
this.blkIndent = 0
this.line = 0 // line index in src
this.lineMax = 0 // lines count
this.tight = false // loose/tight mode for lists
this.ddIndent = -1 // indent of the current dd block (-1 if there isn't any)
this.listIndent = -1 // indent of the current list block (-1 if there isn't any)
// can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
// used in lists to determine if they interrupt a paragraph
this.parentType = 'root'
this.level = 0
// Create caches
// Generate markers.
const s = this.src
for (let start = 0, pos = 0, indent = 0, offset = 0, len = s.length, indent_found = false; pos < len; pos++) {
const ch = s.charCodeAt(pos)
if (!indent_found) {
if (isSpace(ch)) {
indent++
if (ch === 0x09) {
offset += 4 - offset % 4
} else {
offset++
}
continue
} else {
indent_found = true
}
}
if (ch === 0x0A || pos === len - 1) {
if (ch !== 0x0A) { pos++ }
this.bMarks.push(start)
this.eMarks.push(pos)
this.tShift.push(indent)
this.sCount.push(offset)
this.bsCount.push(0)
indent_found = false
indent = 0
offset = 0
start = pos + 1
}
}
// Push fake entry to simplify cache bounds checks
this.bMarks.push(s.length)
this.eMarks.push(s.length)
this.tShift.push(0)
this.sCount.push(0)
this.bsCount.push(0)
this.lineMax = this.bMarks.length - 1 // don't count last fake line
}
// Push new token to "stream".
//
StateBlock.prototype.push = function (type, tag, nesting) {
const token = new Token(type, tag, nesting)
token.block = true
if (nesting < 0) this.level-- // closing tag
token.level = this.level
if (nesting > 0) this.level++ // opening tag
this.tokens.push(token)
return token
}
StateBlock.prototype.isEmpty = function isEmpty (line) {
return this.bMarks[line] + this.tShift[line] >= this.eMarks[line]
}
StateBlock.prototype.skipEmptyLines = function skipEmptyLines (from) {
for (let max = this.lineMax; from < max; from++) {
if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
break
}
}
return from
}
// Skip spaces from given position.
StateBlock.prototype.skipSpaces = function skipSpaces (pos) {
for (let max = this.src.length; pos < max; pos++) {
const ch = this.src.charCodeAt(pos)
if (!isSpace(ch)) { break }
}
return pos
}
// Skip spaces from given position in reverse.
StateBlock.prototype.skipSpacesBack = function skipSpacesBack (pos, min) {
if (pos <= min) { return pos }
while (pos > min) {
if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1 }
}
return pos
}
// Skip char codes from given position
StateBlock.prototype.skipChars = function skipChars (pos, code) {
for (let max = this.src.length; pos < max; pos++) {
if (this.src.charCodeAt(pos) !== code) { break }
}
return pos
}
// Skip char codes reverse from given position - 1
StateBlock.prototype.skipCharsBack = function skipCharsBack (pos, code, min) {
if (pos <= min) { return pos }
while (pos > min) {
if (code !== this.src.charCodeAt(--pos)) { return pos + 1 }
}
return pos
}
// cut lines range from source.
StateBlock.prototype.getLines = function getLines (begin, end, indent, keepLastLF) {
if (begin >= end) {
return ''
}
const queue = new Array(end - begin)
for (let i = 0, line = begin; line < end; line++, i++) {
let lineIndent = 0
const lineStart = this.bMarks[line]
let first = lineStart
let last
if (line + 1 < end || keepLastLF) {
// No need for bounds check because we have fake entry on tail.
last = this.eMarks[line] + 1
} else {
last = this.eMarks[line]
}
while (first < last && lineIndent < indent) {
const ch = this.src.charCodeAt(first)
if (isSpace(ch)) {
if (ch === 0x09) {
lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4
} else {
lineIndent++
}
} else if (first - lineStart < this.tShift[line]) {
// patched tShift masked characters to look like spaces (blockquotes, list markers)
lineIndent++
} else {
break
}
first++
}
if (lineIndent > indent) {
// partially expanding tabs in code blocks, e.g '\t\tfoobar'
// with indent=2 becomes ' \tfoobar'
queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last)
} else {
queue[i] = this.src.slice(first, last)
}
}
return queue.join('')
}
// re-export Token class to use in block rules
StateBlock.prototype.Token = Token
export default StateBlock

228
node_modules/markdown-it/lib/rules_block/table.mjs generated vendored Normal file
View File

@@ -0,0 +1,228 @@
// GFM table, https://github.github.com/gfm/#tables-extension-
import { isSpace } from '../common/utils.mjs'
// Limit the amount of empty autocompleted cells in a table,
// see https://github.com/markdown-it/markdown-it/issues/1000,
//
// Both pulldown-cmark and commonmark-hs limit the number of cells this way to ~200k.
// We set it to 65k, which can expand user input by a factor of x370
// (256x256 square is 1.8kB expanded into 650kB).
const MAX_AUTOCOMPLETED_CELLS = 0x10000
function getLine (state, line) {
const pos = state.bMarks[line] + state.tShift[line]
const max = state.eMarks[line]
return state.src.slice(pos, max)
}
function escapedSplit (str) {
const result = []
const max = str.length
let pos = 0
let ch = str.charCodeAt(pos)
let isEscaped = false
let lastPos = 0
let current = ''
while (pos < max) {
if (ch === 0x7c/* | */) {
if (!isEscaped) {
// pipe separating cells, '|'
result.push(current + str.substring(lastPos, pos))
current = ''
lastPos = pos + 1
} else {
// escaped pipe, '\|'
current += str.substring(lastPos, pos - 1)
lastPos = pos
}
}
isEscaped = (ch === 0x5c/* \ */)
pos++
ch = str.charCodeAt(pos)
}
result.push(current + str.substring(lastPos))
return result
}
export default function table (state, startLine, endLine, silent) {
// should have at least two lines
if (startLine + 2 > endLine) { return false }
let nextLine = startLine + 1
if (state.sCount[nextLine] < state.blkIndent) { return false }
// if it's indented more than 3 spaces, it should be a code block
if (state.sCount[nextLine] - state.blkIndent >= 4) { return false }
// first character of the second line should be '|', '-', ':',
// and no other characters are allowed but spaces;
// basically, this is the equivalent of /^[-:|][-:|\s]*$/ regexp
let pos = state.bMarks[nextLine] + state.tShift[nextLine]
if (pos >= state.eMarks[nextLine]) { return false }
const firstCh = state.src.charCodeAt(pos++)
if (firstCh !== 0x7C/* | */ && firstCh !== 0x2D/* - */ && firstCh !== 0x3A/* : */) { return false }
if (pos >= state.eMarks[nextLine]) { return false }
const secondCh = state.src.charCodeAt(pos++)
if (secondCh !== 0x7C/* | */ && secondCh !== 0x2D/* - */ && secondCh !== 0x3A/* : */ && !isSpace(secondCh)) {
return false
}
// if first character is '-', then second character must not be a space
// (due to parsing ambiguity with list)
if (firstCh === 0x2D/* - */ && isSpace(secondCh)) { return false }
while (pos < state.eMarks[nextLine]) {
const ch = state.src.charCodeAt(pos)
if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */ && !isSpace(ch)) { return false }
pos++
}
let lineText = getLine(state, startLine + 1)
let columns = lineText.split('|')
const aligns = []
for (let i = 0; i < columns.length; i++) {
const t = columns[i].trim()
if (!t) {
// allow empty columns before and after table, but not in between columns;
// e.g. allow ` |---| `, disallow ` ---||--- `
if (i === 0 || i === columns.length - 1) {
continue
} else {
return false
}
}
if (!/^:?-+:?$/.test(t)) { return false }
if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {
aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right')
} else if (t.charCodeAt(0) === 0x3A/* : */) {
aligns.push('left')
} else {
aligns.push('')
}
}
lineText = getLine(state, startLine).trim()
if (lineText.indexOf('|') === -1) { return false }
if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
columns = escapedSplit(lineText)
if (columns.length && columns[0] === '') columns.shift()
if (columns.length && columns[columns.length - 1] === '') columns.pop()
// header row will define an amount of columns in the entire table,
// and align row should be exactly the same (the rest of the rows can differ)
const columnCount = columns.length
if (columnCount === 0 || columnCount !== aligns.length) { return false }
if (silent) { return true }
const oldParentType = state.parentType
state.parentType = 'table'
// use 'blockquote' lists for termination because it's
// the most similar to tables
const terminatorRules = state.md.block.ruler.getRules('blockquote')
const token_to = state.push('table_open', 'table', 1)
const tableLines = [startLine, 0]
token_to.map = tableLines
const token_tho = state.push('thead_open', 'thead', 1)
token_tho.map = [startLine, startLine + 1]
const token_htro = state.push('tr_open', 'tr', 1)
token_htro.map = [startLine, startLine + 1]
for (let i = 0; i < columns.length; i++) {
const token_ho = state.push('th_open', 'th', 1)
if (aligns[i]) {
token_ho.attrs = [['style', 'text-align:' + aligns[i]]]
}
const token_il = state.push('inline', '', 0)
token_il.content = columns[i].trim()
token_il.children = []
state.push('th_close', 'th', -1)
}
state.push('tr_close', 'tr', -1)
state.push('thead_close', 'thead', -1)
let tbodyLines
let autocompletedCells = 0
for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
if (state.sCount[nextLine] < state.blkIndent) { break }
let terminate = false
for (let i = 0, l = terminatorRules.length; i < l; i++) {
if (terminatorRules[i](state, nextLine, endLine, true)) {
terminate = true
break
}
}
if (terminate) { break }
lineText = getLine(state, nextLine).trim()
if (!lineText) { break }
if (state.sCount[nextLine] - state.blkIndent >= 4) { break }
columns = escapedSplit(lineText)
if (columns.length && columns[0] === '') columns.shift()
if (columns.length && columns[columns.length - 1] === '') columns.pop()
// note: autocomplete count can be negative if user specifies more columns than header,
// but that does not affect intended use (which is limiting expansion)
autocompletedCells += columnCount - columns.length
if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) { break }
if (nextLine === startLine + 2) {
const token_tbo = state.push('tbody_open', 'tbody', 1)
token_tbo.map = tbodyLines = [startLine + 2, 0]
}
const token_tro = state.push('tr_open', 'tr', 1)
token_tro.map = [nextLine, nextLine + 1]
for (let i = 0; i < columnCount; i++) {
const token_tdo = state.push('td_open', 'td', 1)
if (aligns[i]) {
token_tdo.attrs = [['style', 'text-align:' + aligns[i]]]
}
const token_il = state.push('inline', '', 0)
token_il.content = columns[i] ? columns[i].trim() : ''
token_il.children = []
state.push('td_close', 'td', -1)
}
state.push('tr_close', 'tr', -1)
}
if (tbodyLines) {
state.push('tbody_close', 'tbody', -1)
tbodyLines[1] = nextLine
}
state.push('table_close', 'table', -1)
tableLines[1] = nextLine
state.parentType = oldParentType
state.line = nextLine
return true
}

13
node_modules/markdown-it/lib/rules_core/block.mjs generated vendored Normal file
View File

@@ -0,0 +1,13 @@
export default function block (state) {
let token
if (state.inlineMode) {
token = new state.Token('inline', '', 0)
token.content = state.src
token.map = [0, 1]
token.children = []
state.tokens.push(token)
} else {
state.md.block.parse(state.src, state.md, state.env, state.tokens)
}
}

11
node_modules/markdown-it/lib/rules_core/inline.mjs generated vendored Normal file
View File

@@ -0,0 +1,11 @@
export default function inline (state) {
const tokens = state.tokens
// Parse inlines
for (let i = 0, l = tokens.length; i < l; i++) {
const tok = tokens[i]
if (tok.type === 'inline') {
state.md.inline.parse(tok.content, state.md, state.env, tok.children)
}
}
}

134
node_modules/markdown-it/lib/rules_core/linkify.mjs generated vendored Normal file
View File

@@ -0,0 +1,134 @@
// Replace link-like texts with link nodes.
//
// Currently restricted by `md.validateLink()` to http/https/ftp
//
import { arrayReplaceAt } from '../common/utils.mjs'
function isLinkOpen (str) {
return /^<a[>\s]/i.test(str)
}
function isLinkClose (str) {
return /^<\/a\s*>/i.test(str)
}
export default function linkify (state) {
const blockTokens = state.tokens
if (!state.md.options.linkify) { return }
for (let j = 0, l = blockTokens.length; j < l; j++) {
if (blockTokens[j].type !== 'inline' ||
!state.md.linkify.pretest(blockTokens[j].content)) {
continue
}
let tokens = blockTokens[j].children
let htmlLinkLevel = 0
// We scan from the end, to keep position when new tags added.
// Use reversed logic in links start/end match
for (let i = tokens.length - 1; i >= 0; i--) {
const currentToken = tokens[i]
// Skip content of markdown links
if (currentToken.type === 'link_close') {
i--
while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {
i--
}
continue
}
// Skip content of html tag links
if (currentToken.type === 'html_inline') {
if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
htmlLinkLevel--
}
if (isLinkClose(currentToken.content)) {
htmlLinkLevel++
}
}
if (htmlLinkLevel > 0) { continue }
if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {
const text = currentToken.content
let links = state.md.linkify.match(text)
// Now split string to nodes
const nodes = []
let level = currentToken.level
let lastPos = 0
// forbid escape sequence at the start of the string,
// this avoids http\://example.com/ from being linkified as
// http:<a href="//example.com/">//example.com/</a>
if (links.length > 0 &&
links[0].index === 0 &&
i > 0 &&
tokens[i - 1].type === 'text_special') {
links = links.slice(1)
}
for (let ln = 0; ln < links.length; ln++) {
const url = links[ln].url
const fullUrl = state.md.normalizeLink(url)
if (!state.md.validateLink(fullUrl)) { continue }
let urlText = links[ln].text
// Linkifier might send raw hostnames like "example.com", where url
// starts with domain name. So we prepend http:// in those cases,
// and remove it afterwards.
//
if (!links[ln].schema) {
urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\/\//, '')
} else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {
urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '')
} else {
urlText = state.md.normalizeLinkText(urlText)
}
const pos = links[ln].index
if (pos > lastPos) {
const token = new state.Token('text', '', 0)
token.content = text.slice(lastPos, pos)
token.level = level
nodes.push(token)
}
const token_o = new state.Token('link_open', 'a', 1)
token_o.attrs = [['href', fullUrl]]
token_o.level = level++
token_o.markup = 'linkify'
token_o.info = 'auto'
nodes.push(token_o)
const token_t = new state.Token('text', '', 0)
token_t.content = urlText
token_t.level = level
nodes.push(token_t)
const token_c = new state.Token('link_close', 'a', -1)
token_c.level = --level
token_c.markup = 'linkify'
token_c.info = 'auto'
nodes.push(token_c)
lastPos = links[ln].lastIndex
}
if (lastPos < text.length) {
const token = new state.Token('text', '', 0)
token.content = text.slice(lastPos)
token.level = level
nodes.push(token)
}
// replace current node
blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes)
}
}
}
}

17
node_modules/markdown-it/lib/rules_core/normalize.mjs generated vendored Normal file
View File

@@ -0,0 +1,17 @@
// Normalize input string
// https://spec.commonmark.org/0.29/#line-ending
const NEWLINES_RE = /\r\n?|\n/g
const NULL_RE = /\0/g
export default function normalize (state) {
let str
// Normalize newlines
str = state.src.replace(NEWLINES_RE, '\n')
// Replace NULL characters
str = str.replace(NULL_RE, '\uFFFD')
state.src = str
}

101
node_modules/markdown-it/lib/rules_core/replacements.mjs generated vendored Normal file
View File

@@ -0,0 +1,101 @@
// Simple typographic replacements
//
// (c) (C) → ©
// (tm) (TM) → ™
// (r) (R) → ®
// +- → ±
// ... → … (also ?.... → ?.., !.... → !..)
// ???????? → ???, !!!!! → !!!, `,,` → `,`
// -- → &ndash;, --- → &mdash;
//
// TODO:
// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾
// - multiplications 2 x 4 -> 2 × 4
const RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/
// Workaround for phantomjs - need regex without /g flag,
// or root check will fail every second time
const SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i
const SCOPED_ABBR_RE = /\((c|tm|r)\)/ig
const SCOPED_ABBR = {
c: '©',
r: '®',
tm: '™'
}
function replaceFn (match, name) {
return SCOPED_ABBR[name.toLowerCase()]
}
function replace_scoped (inlineTokens) {
let inside_autolink = 0
for (let i = inlineTokens.length - 1; i >= 0; i--) {
const token = inlineTokens[i]
if (token.type === 'text' && !inside_autolink) {
token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn)
}
if (token.type === 'link_open' && token.info === 'auto') {
inside_autolink--
}
if (token.type === 'link_close' && token.info === 'auto') {
inside_autolink++
}
}
}
function replace_rare (inlineTokens) {
let inside_autolink = 0
for (let i = inlineTokens.length - 1; i >= 0; i--) {
const token = inlineTokens[i]
if (token.type === 'text' && !inside_autolink) {
if (RARE_RE.test(token.content)) {
token.content = token.content
.replace(/\+-/g, '±')
// .., ..., ....... -> …
// but ?..... & !..... -> ?.. & !..
.replace(/\.{2,}/g, '…').replace(/([?!])…/g, '$1..')
.replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')
// em-dash
.replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\u2014')
// en-dash
.replace(/(^|\s)--(?=\s|$)/mg, '$1\u2013')
.replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, '$1\u2013')
}
}
if (token.type === 'link_open' && token.info === 'auto') {
inside_autolink--
}
if (token.type === 'link_close' && token.info === 'auto') {
inside_autolink++
}
}
}
export default function replace (state) {
let blkIdx
if (!state.md.options.typographer) { return }
for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
if (state.tokens[blkIdx].type !== 'inline') { continue }
if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
replace_scoped(state.tokens[blkIdx].children)
}
if (RARE_RE.test(state.tokens[blkIdx].content)) {
replace_rare(state.tokens[blkIdx].children)
}
}
}

193
node_modules/markdown-it/lib/rules_core/smartquotes.mjs generated vendored Normal file
View File

@@ -0,0 +1,193 @@
// Convert straight quotation marks to typographic ones
//
import { isWhiteSpace, isPunctChar, isMdAsciiPunct } from '../common/utils.mjs'
const QUOTE_TEST_RE = /['"]/
const QUOTE_RE = /['"]/g
const APOSTROPHE = '\u2019' /* ’ */
function replaceAt (str, index, ch) {
return str.slice(0, index) + ch + str.slice(index + 1)
}
function process_inlines (tokens, state) {
let j
const stack = []
for (let i = 0; i < tokens.length; i++) {
const token = tokens[i]
const thisLevel = tokens[i].level
for (j = stack.length - 1; j >= 0; j--) {
if (stack[j].level <= thisLevel) { break }
}
stack.length = j + 1
if (token.type !== 'text') { continue }
let text = token.content
let pos = 0
let max = text.length
/* eslint no-labels:0,block-scoped-var:0 */
OUTER:
while (pos < max) {
QUOTE_RE.lastIndex = pos
const t = QUOTE_RE.exec(text)
if (!t) { break }
let canOpen = true
let canClose = true
pos = t.index + 1
const isSingle = (t[0] === "'")
// Find previous character,
// default to space if it's the beginning of the line
//
let lastChar = 0x20
if (t.index - 1 >= 0) {
lastChar = text.charCodeAt(t.index - 1)
} else {
for (j = i - 1; j >= 0; j--) {
if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // lastChar defaults to 0x20
if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'
lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1)
break
}
}
// Find next character,
// default to space if it's the end of the line
//
let nextChar = 0x20
if (pos < max) {
nextChar = text.charCodeAt(pos)
} else {
for (j = i + 1; j < tokens.length; j++) {
if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // nextChar defaults to 0x20
if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'
nextChar = tokens[j].content.charCodeAt(0)
break
}
}
const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar))
const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar))
const isLastWhiteSpace = isWhiteSpace(lastChar)
const isNextWhiteSpace = isWhiteSpace(nextChar)
if (isNextWhiteSpace) {
canOpen = false
} else if (isNextPunctChar) {
if (!(isLastWhiteSpace || isLastPunctChar)) {
canOpen = false
}
}
if (isLastWhiteSpace) {
canClose = false
} else if (isLastPunctChar) {
if (!(isNextWhiteSpace || isNextPunctChar)) {
canClose = false
}
}
if (nextChar === 0x22 /* " */ && t[0] === '"') {
if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {
// special case: 1"" - count first quote as an inch
canClose = canOpen = false
}
}
if (canOpen && canClose) {
// Replace quotes in the middle of punctuation sequence, but not
// in the middle of the words, i.e.:
//
// 1. foo " bar " baz - not replaced
// 2. foo-"-bar-"-baz - replaced
// 3. foo"bar"baz - not replaced
//
canOpen = isLastPunctChar
canClose = isNextPunctChar
}
if (!canOpen && !canClose) {
// middle of word
if (isSingle) {
token.content = replaceAt(token.content, t.index, APOSTROPHE)
}
continue
}
if (canClose) {
// this could be a closing quote, rewind the stack to get a match
for (j = stack.length - 1; j >= 0; j--) {
let item = stack[j]
if (stack[j].level < thisLevel) { break }
if (item.single === isSingle && stack[j].level === thisLevel) {
item = stack[j]
let openQuote
let closeQuote
if (isSingle) {
openQuote = state.md.options.quotes[2]
closeQuote = state.md.options.quotes[3]
} else {
openQuote = state.md.options.quotes[0]
closeQuote = state.md.options.quotes[1]
}
// replace token.content *before* tokens[item.token].content,
// because, if they are pointing at the same token, replaceAt
// could mess up indices when quote length != 1
token.content = replaceAt(token.content, t.index, closeQuote)
tokens[item.token].content = replaceAt(
tokens[item.token].content, item.pos, openQuote)
pos += closeQuote.length - 1
if (item.token === i) { pos += openQuote.length - 1 }
text = token.content
max = text.length
stack.length = j
continue OUTER
}
}
}
if (canOpen) {
stack.push({
token: i,
pos: t.index,
single: isSingle,
level: thisLevel
})
} else if (canClose && isSingle) {
token.content = replaceAt(token.content, t.index, APOSTROPHE)
}
}
}
}
export default function smartquotes (state) {
/* eslint max-depth:0 */
if (!state.md.options.typographer) { return }
for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
if (state.tokens[blkIdx].type !== 'inline' ||
!QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
continue
}
process_inlines(state.tokens[blkIdx].children, state)
}
}

17
node_modules/markdown-it/lib/rules_core/state_core.mjs generated vendored Normal file
View File

@@ -0,0 +1,17 @@
// Core state object
//
import Token from '../token.mjs'
function StateCore (src, md, env) {
this.src = src
this.env = env
this.tokens = []
this.inlineMode = false
this.md = md // link to parser instance
}
// re-export Token class to use in core rules
StateCore.prototype.Token = Token
export default StateCore

43
node_modules/markdown-it/lib/rules_core/text_join.mjs generated vendored Normal file
View File

@@ -0,0 +1,43 @@
// Join raw text tokens with the rest of the text
//
// This is set as a separate rule to provide an opportunity for plugins
// to run text replacements after text join, but before escape join.
//
// For example, `\:)` shouldn't be replaced with an emoji.
//
export default function text_join (state) {
let curr, last
const blockTokens = state.tokens
const l = blockTokens.length
for (let j = 0; j < l; j++) {
if (blockTokens[j].type !== 'inline') continue
const tokens = blockTokens[j].children
const max = tokens.length
for (curr = 0; curr < max; curr++) {
if (tokens[curr].type === 'text_special') {
tokens[curr].type = 'text'
}
}
for (curr = last = 0; curr < max; curr++) {
if (tokens[curr].type === 'text' &&
curr + 1 < max &&
tokens[curr + 1].type === 'text') {
// collapse two adjacent text nodes
tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content
} else {
if (curr !== last) { tokens[last] = tokens[curr] }
last++
}
}
if (curr !== last) {
tokens.length = last
}
}
}

72
node_modules/markdown-it/lib/rules_inline/autolink.mjs generated vendored Normal file
View File

@@ -0,0 +1,72 @@
// Process autolinks '<protocol:...>'
/* eslint max-len:0 */
const EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/
/* eslint-disable-next-line no-control-regex */
const AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/
export default function autolink (state, silent) {
let pos = state.pos
if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }
const start = state.pos
const max = state.posMax
for (;;) {
if (++pos >= max) return false
const ch = state.src.charCodeAt(pos)
if (ch === 0x3C /* < */) return false
if (ch === 0x3E /* > */) break
}
const url = state.src.slice(start + 1, pos)
if (AUTOLINK_RE.test(url)) {
const fullUrl = state.md.normalizeLink(url)
if (!state.md.validateLink(fullUrl)) { return false }
if (!silent) {
const token_o = state.push('link_open', 'a', 1)
token_o.attrs = [['href', fullUrl]]
token_o.markup = 'autolink'
token_o.info = 'auto'
const token_t = state.push('text', '', 0)
token_t.content = state.md.normalizeLinkText(url)
const token_c = state.push('link_close', 'a', -1)
token_c.markup = 'autolink'
token_c.info = 'auto'
}
state.pos += url.length + 2
return true
}
if (EMAIL_RE.test(url)) {
const fullUrl = state.md.normalizeLink('mailto:' + url)
if (!state.md.validateLink(fullUrl)) { return false }
if (!silent) {
const token_o = state.push('link_open', 'a', 1)
token_o.attrs = [['href', fullUrl]]
token_o.markup = 'autolink'
token_o.info = 'auto'
const token_t = state.push('text', '', 0)
token_t.content = state.md.normalizeLinkText(url)
const token_c = state.push('link_close', 'a', -1)
token_c.markup = 'autolink'
token_c.info = 'auto'
}
state.pos += url.length + 2
return true
}
return false
}

60
node_modules/markdown-it/lib/rules_inline/backticks.mjs generated vendored Normal file
View File

@@ -0,0 +1,60 @@
// Parse backticks
export default function backtick (state, silent) {
let pos = state.pos
const ch = state.src.charCodeAt(pos)
if (ch !== 0x60/* ` */) { return false }
const start = pos
pos++
const max = state.posMax
// scan marker length
while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++ }
const marker = state.src.slice(start, pos)
const openerLength = marker.length
if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
if (!silent) state.pending += marker
state.pos += openerLength
return true
}
let matchEnd = pos
let matchStart
// Nothing found in the cache, scan until the end of the line (or until marker is found)
while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {
matchEnd = matchStart + 1
// scan marker length
while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++ }
const closerLength = matchEnd - matchStart
if (closerLength === openerLength) {
// Found matching closer length.
if (!silent) {
const token = state.push('code_inline', 'code', 0)
token.markup = marker
token.content = state.src.slice(pos, matchStart)
.replace(/\n/g, ' ')
.replace(/^ (.+) $/, '$1')
}
state.pos = matchEnd
return true
}
// Some different length found, put it in cache as upper limit of where closer can be found
state.backticks[closerLength] = matchStart
}
// Scanned through the end, didn't find anything
state.backticksScanned = true
if (!silent) state.pending += marker
state.pos += openerLength
return true
}

124
node_modules/markdown-it/lib/rules_inline/balance_pairs.mjs generated vendored Normal file
View File

@@ -0,0 +1,124 @@
// For each opening emphasis-like marker find a matching closing one
//
function processDelimiters (delimiters) {
const openersBottom = {}
const max = delimiters.length
if (!max) return
// headerIdx is the first delimiter of the current (where closer is) delimiter run
let headerIdx = 0
let lastTokenIdx = -2 // needs any value lower than -1
const jumps = []
for (let closerIdx = 0; closerIdx < max; closerIdx++) {
const closer = delimiters[closerIdx]
jumps.push(0)
// markers belong to same delimiter run if:
// - they have adjacent tokens
// - AND markers are the same
//
if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
headerIdx = closerIdx
}
lastTokenIdx = closer.token
// Length is only used for emphasis-specific "rule of 3",
// if it's not defined (in strikethrough or 3rd party plugins),
// we can default it to 0 to disable those checks.
//
closer.length = closer.length || 0
if (!closer.close) continue
// Previously calculated lower bounds (previous fails)
// for each marker, each delimiter length modulo 3,
// and for whether this closer can be an opener;
// https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460
/* eslint-disable-next-line no-prototype-builtins */
if (!openersBottom.hasOwnProperty(closer.marker)) {
openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1]
}
const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length % 3)]
let openerIdx = headerIdx - jumps[headerIdx] - 1
let newMinOpenerIdx = openerIdx
for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
const opener = delimiters[openerIdx]
if (opener.marker !== closer.marker) continue
if (opener.open && opener.end < 0) {
let isOddMatch = false
// from spec:
//
// If one of the delimiters can both open and close emphasis, then the
// sum of the lengths of the delimiter runs containing the opening and
// closing delimiters must not be a multiple of 3 unless both lengths
// are multiples of 3.
//
if (opener.close || closer.open) {
if ((opener.length + closer.length) % 3 === 0) {
if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
isOddMatch = true
}
}
}
if (!isOddMatch) {
// If previous delimiter cannot be an opener, we can safely skip
// the entire sequence in future checks. This is required to make
// sure algorithm has linear complexity (see *_*_*_*_*_... case).
//
const lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open
? jumps[openerIdx - 1] + 1
: 0
jumps[closerIdx] = closerIdx - openerIdx + lastJump
jumps[openerIdx] = lastJump
closer.open = false
opener.end = closerIdx
opener.close = false
newMinOpenerIdx = -1
// treat next token as start of run,
// it optimizes skips in **<...>**a**<...>** pathological case
lastTokenIdx = -2
break
}
}
}
if (newMinOpenerIdx !== -1) {
// If match for this delimiter run failed, we want to set lower bound for
// future lookups. This is required to make sure algorithm has linear
// complexity.
//
// See details here:
// https://github.com/commonmark/cmark/issues/178#issuecomment-270417442
//
openersBottom[closer.marker][(closer.open ? 3 : 0) + ((closer.length || 0) % 3)] = newMinOpenerIdx
}
}
}
export default function link_pairs (state) {
const tokens_meta = state.tokens_meta
const max = state.tokens_meta.length
processDelimiters(state.delimiters)
for (let curr = 0; curr < max; curr++) {
if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
processDelimiters(tokens_meta[curr].delimiters)
}
}
}

123
node_modules/markdown-it/lib/rules_inline/emphasis.mjs generated vendored Normal file
View File

@@ -0,0 +1,123 @@
// Process *this* and _that_
//
// Insert each marker as a separate text token, and add it to delimiter list
//
function emphasis_tokenize (state, silent) {
const start = state.pos
const marker = state.src.charCodeAt(start)
if (silent) { return false }
if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) { return false }
const scanned = state.scanDelims(state.pos, marker === 0x2A)
for (let i = 0; i < scanned.length; i++) {
const token = state.push('text', '', 0)
token.content = String.fromCharCode(marker)
state.delimiters.push({
// Char code of the starting marker (number).
//
marker,
// Total length of these series of delimiters.
//
length: scanned.length,
// A position of the token this delimiter corresponds to.
//
token: state.tokens.length - 1,
// If this delimiter is matched as a valid opener, `end` will be
// equal to its position, otherwise it's `-1`.
//
end: -1,
// Boolean flags that determine if this delimiter could open or close
// an emphasis.
//
open: scanned.can_open,
close: scanned.can_close
})
}
state.pos += scanned.length
return true
}
function postProcess (state, delimiters) {
const max = delimiters.length
for (let i = max - 1; i >= 0; i--) {
const startDelim = delimiters[i]
if (startDelim.marker !== 0x5F/* _ */ && startDelim.marker !== 0x2A/* * */) {
continue
}
// Process only opening markers
if (startDelim.end === -1) {
continue
}
const endDelim = delimiters[startDelim.end]
// If the previous delimiter has the same marker and is adjacent to this one,
// merge those into one strong delimiter.
//
// `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`
//
const isStrong = i > 0 &&
delimiters[i - 1].end === startDelim.end + 1 &&
// check that first two markers match and adjacent
delimiters[i - 1].marker === startDelim.marker &&
delimiters[i - 1].token === startDelim.token - 1 &&
// check that last two markers are adjacent (we can safely assume they match)
delimiters[startDelim.end + 1].token === endDelim.token + 1
const ch = String.fromCharCode(startDelim.marker)
const token_o = state.tokens[startDelim.token]
token_o.type = isStrong ? 'strong_open' : 'em_open'
token_o.tag = isStrong ? 'strong' : 'em'
token_o.nesting = 1
token_o.markup = isStrong ? ch + ch : ch
token_o.content = ''
const token_c = state.tokens[endDelim.token]
token_c.type = isStrong ? 'strong_close' : 'em_close'
token_c.tag = isStrong ? 'strong' : 'em'
token_c.nesting = -1
token_c.markup = isStrong ? ch + ch : ch
token_c.content = ''
if (isStrong) {
state.tokens[delimiters[i - 1].token].content = ''
state.tokens[delimiters[startDelim.end + 1].token].content = ''
i--
}
}
}
// Walk through delimiter list and replace text tokens with tags
//
function emphasis_post_process (state) {
const tokens_meta = state.tokens_meta
const max = state.tokens_meta.length
postProcess(state, state.delimiters)
for (let curr = 0; curr < max; curr++) {
if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
postProcess(state, tokens_meta[curr].delimiters)
}
}
}
export default {
tokenize: emphasis_tokenize,
postProcess: emphasis_post_process
}

51
node_modules/markdown-it/lib/rules_inline/entity.mjs generated vendored Normal file
View File

@@ -0,0 +1,51 @@
// Process html entity - &#123;, &#xAF;, &quot;, ...
import { decodeHTML } from 'entities'
import { isValidEntityCode, fromCodePoint } from '../common/utils.mjs'
const DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i
const NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i
export default function entity (state, silent) {
const pos = state.pos
const max = state.posMax
if (state.src.charCodeAt(pos) !== 0x26/* & */) return false
if (pos + 1 >= max) return false
const ch = state.src.charCodeAt(pos + 1)
if (ch === 0x23 /* # */) {
const match = state.src.slice(pos).match(DIGITAL_RE)
if (match) {
if (!silent) {
const code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10)
const token = state.push('text_special', '', 0)
token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD)
token.markup = match[0]
token.info = 'entity'
}
state.pos += match[0].length
return true
}
} else {
const match = state.src.slice(pos).match(NAMED_RE)
if (match) {
const decoded = decodeHTML(match[0])
if (decoded !== match[0]) {
if (!silent) {
const token = state.push('text_special', '', 0)
token.content = decoded
token.markup = match[0]
token.info = 'entity'
}
state.pos += match[0].length
return true
}
}
}
return false
}

69
node_modules/markdown-it/lib/rules_inline/escape.mjs generated vendored Normal file
View File

@@ -0,0 +1,69 @@
// Process escaped chars and hardbreaks
import { isSpace } from '../common/utils.mjs'
const ESCAPED = []
for (let i = 0; i < 256; i++) { ESCAPED.push(0) }
'\\!"#$%&\'()*+,./:;<=>?@[]^_`{|}~-'
.split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1 })
export default function escape (state, silent) {
let pos = state.pos
const max = state.posMax
if (state.src.charCodeAt(pos) !== 0x5C/* \ */) return false
pos++
// '\' at the end of the inline block
if (pos >= max) return false
let ch1 = state.src.charCodeAt(pos)
if (ch1 === 0x0A) {
if (!silent) {
state.push('hardbreak', 'br', 0)
}
pos++
// skip leading whitespaces from next line
while (pos < max) {
ch1 = state.src.charCodeAt(pos)
if (!isSpace(ch1)) break
pos++
}
state.pos = pos
return true
}
let escapedStr = state.src[pos]
if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {
const ch2 = state.src.charCodeAt(pos + 1)
if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
escapedStr += state.src[pos + 1]
pos++
}
}
const origStr = '\\' + escapedStr
if (!silent) {
const token = state.push('text_special', '', 0)
if (ch1 < 256 && ESCAPED[ch1] !== 0) {
token.content = escapedStr
} else {
token.content = origStr
}
token.markup = origStr
token.info = 'escape'
}
state.pos = pos + 1
return true
}

38
node_modules/markdown-it/lib/rules_inline/fragments_join.mjs generated vendored Normal file
View File

@@ -0,0 +1,38 @@
// Clean up tokens after emphasis and strikethrough postprocessing:
// merge adjacent text nodes into one and re-calculate all token levels
//
// This is necessary because initially emphasis delimiter markers (*, _, ~)
// are treated as their own separate text tokens. Then emphasis rule either
// leaves them as text (needed to merge with adjacent text) or turns them
// into opening/closing tags (which messes up levels inside).
//
export default function fragments_join (state) {
let curr, last
let level = 0
const tokens = state.tokens
const max = state.tokens.length
for (curr = last = 0; curr < max; curr++) {
// re-calculate levels after emphasis/strikethrough turns some text nodes
// into opening/closing tags
if (tokens[curr].nesting < 0) level-- // closing tag
tokens[curr].level = level
if (tokens[curr].nesting > 0) level++ // opening tag
if (tokens[curr].type === 'text' &&
curr + 1 < max &&
tokens[curr + 1].type === 'text') {
// collapse two adjacent text nodes
tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content
} else {
if (curr !== last) { tokens[last] = tokens[curr] }
last++
}
}
if (curr !== last) {
tokens.length = last
}
}

50
node_modules/markdown-it/lib/rules_inline/html_inline.mjs generated vendored Normal file
View File

@@ -0,0 +1,50 @@
// Process html tags
import { HTML_TAG_RE } from '../common/html_re.mjs'
function isLinkOpen (str) {
return /^<a[>\s]/i.test(str)
}
function isLinkClose (str) {
return /^<\/a\s*>/i.test(str)
}
function isLetter (ch) {
/* eslint no-bitwise:0 */
const lc = ch | 0x20 // to lower case
return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */)
}
export default function html_inline (state, silent) {
if (!state.md.options.html) { return false }
// Check start
const max = state.posMax
const pos = state.pos
if (state.src.charCodeAt(pos) !== 0x3C/* < */ ||
pos + 2 >= max) {
return false
}
// Quick fail on second char
const ch = state.src.charCodeAt(pos + 1)
if (ch !== 0x21/* ! */ &&
ch !== 0x3F/* ? */ &&
ch !== 0x2F/* / */ &&
!isLetter(ch)) {
return false
}
const match = state.src.slice(pos).match(HTML_TAG_RE)
if (!match) { return false }
if (!silent) {
const token = state.push('html_inline', '', 0)
token.content = match[0]
if (isLinkOpen(token.content)) state.linkLevel++
if (isLinkClose(token.content)) state.linkLevel--
}
state.pos += match[0].length
return true
}

138
node_modules/markdown-it/lib/rules_inline/image.mjs generated vendored Normal file
View File

@@ -0,0 +1,138 @@
// Process ![image](<src> "title")
import { normalizeReference, isSpace } from '../common/utils.mjs'
export default function image (state, silent) {
let code, content, label, pos, ref, res, title, start
let href = ''
const oldPos = state.pos
const max = state.posMax
if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false }
if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false }
const labelStart = state.pos + 2
const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false)
// parser failed to find ']', so it's not a valid link
if (labelEnd < 0) { return false }
pos = labelEnd + 1
if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
//
// Inline link
//
// [link]( <href> "title" )
// ^^ skipping these spaces
pos++
for (; pos < max; pos++) {
code = state.src.charCodeAt(pos)
if (!isSpace(code) && code !== 0x0A) { break }
}
if (pos >= max) { return false }
// [link]( <href> "title" )
// ^^^^^^ parsing link destination
start = pos
res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)
if (res.ok) {
href = state.md.normalizeLink(res.str)
if (state.md.validateLink(href)) {
pos = res.pos
} else {
href = ''
}
}
// [link]( <href> "title" )
// ^^ skipping these spaces
start = pos
for (; pos < max; pos++) {
code = state.src.charCodeAt(pos)
if (!isSpace(code) && code !== 0x0A) { break }
}
// [link]( <href> "title" )
// ^^^^^^^ parsing link title
res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)
if (pos < max && start !== pos && res.ok) {
title = res.str
pos = res.pos
// [link]( <href> "title" )
// ^^ skipping these spaces
for (; pos < max; pos++) {
code = state.src.charCodeAt(pos)
if (!isSpace(code) && code !== 0x0A) { break }
}
} else {
title = ''
}
if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
state.pos = oldPos
return false
}
pos++
} else {
//
// Link reference
//
if (typeof state.env.references === 'undefined') { return false }
if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
start = pos + 1
pos = state.md.helpers.parseLinkLabel(state, pos)
if (pos >= 0) {
label = state.src.slice(start, pos++)
} else {
pos = labelEnd + 1
}
} else {
pos = labelEnd + 1
}
// covers label === '' and label === undefined
// (collapsed reference link and shortcut reference link respectively)
if (!label) { label = state.src.slice(labelStart, labelEnd) }
ref = state.env.references[normalizeReference(label)]
if (!ref) {
state.pos = oldPos
return false
}
href = ref.href
title = ref.title
}
//
// We found the end of the link, and know for a fact it's a valid link;
// so all that's left to do is to call tokenizer.
//
if (!silent) {
content = state.src.slice(labelStart, labelEnd)
const tokens = []
state.md.inline.parse(
content,
state.md,
state.env,
tokens
)
const token = state.push('image', 'img', 0)
const attrs = [['src', href], ['alt', '']]
token.attrs = attrs
token.children = tokens
token.content = content
if (title) {
attrs.push(['title', title])
}
}
state.pos = pos
state.posMax = max
return true
}

139
node_modules/markdown-it/lib/rules_inline/link.mjs generated vendored Normal file
View File

@@ -0,0 +1,139 @@
// Process [link](<to> "stuff")
import { normalizeReference, isSpace } from '../common/utils.mjs'
export default function link (state, silent) {
let code, label, res, ref
let href = ''
let title = ''
let start = state.pos
let parseReference = true
if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false }
const oldPos = state.pos
const max = state.posMax
const labelStart = state.pos + 1
const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true)
// parser failed to find ']', so it's not a valid link
if (labelEnd < 0) { return false }
let pos = labelEnd + 1
if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
//
// Inline link
//
// might have found a valid shortcut link, disable reference parsing
parseReference = false
// [link]( <href> "title" )
// ^^ skipping these spaces
pos++
for (; pos < max; pos++) {
code = state.src.charCodeAt(pos)
if (!isSpace(code) && code !== 0x0A) { break }
}
if (pos >= max) { return false }
// [link]( <href> "title" )
// ^^^^^^ parsing link destination
start = pos
res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)
if (res.ok) {
href = state.md.normalizeLink(res.str)
if (state.md.validateLink(href)) {
pos = res.pos
} else {
href = ''
}
// [link]( <href> "title" )
// ^^ skipping these spaces
start = pos
for (; pos < max; pos++) {
code = state.src.charCodeAt(pos)
if (!isSpace(code) && code !== 0x0A) { break }
}
// [link]( <href> "title" )
// ^^^^^^^ parsing link title
res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)
if (pos < max && start !== pos && res.ok) {
title = res.str
pos = res.pos
// [link]( <href> "title" )
// ^^ skipping these spaces
for (; pos < max; pos++) {
code = state.src.charCodeAt(pos)
if (!isSpace(code) && code !== 0x0A) { break }
}
}
}
if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
// parsing a valid shortcut link failed, fallback to reference
parseReference = true
}
pos++
}
if (parseReference) {
//
// Link reference
//
if (typeof state.env.references === 'undefined') { return false }
if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
start = pos + 1
pos = state.md.helpers.parseLinkLabel(state, pos)
if (pos >= 0) {
label = state.src.slice(start, pos++)
} else {
pos = labelEnd + 1
}
} else {
pos = labelEnd + 1
}
// covers label === '' and label === undefined
// (collapsed reference link and shortcut reference link respectively)
if (!label) { label = state.src.slice(labelStart, labelEnd) }
ref = state.env.references[normalizeReference(label)]
if (!ref) {
state.pos = oldPos
return false
}
href = ref.href
title = ref.title
}
//
// We found the end of the link, and know for a fact it's a valid link;
// so all that's left to do is to call tokenizer.
//
if (!silent) {
state.pos = labelStart
state.posMax = labelEnd
const token_o = state.push('link_open', 'a', 1)
const attrs = [['href', href]]
token_o.attrs = attrs
if (title) {
attrs.push(['title', title])
}
state.linkLevel++
state.md.inline.tokenize(state)
state.linkLevel--
state.push('link_close', 'a', -1)
}
state.pos = pos
state.posMax = max
return true
}

56
node_modules/markdown-it/lib/rules_inline/linkify.mjs generated vendored Normal file
View File

@@ -0,0 +1,56 @@
// Process links like https://example.org/
// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
const SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i
export default function linkify (state, silent) {
if (!state.md.options.linkify) return false
if (state.linkLevel > 0) return false
const pos = state.pos
const max = state.posMax
if (pos + 3 > max) return false
if (state.src.charCodeAt(pos) !== 0x3A/* : */) return false
if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false
if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false
const match = state.pending.match(SCHEME_RE)
if (!match) return false
const proto = match[1]
const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length))
if (!link) return false
let url = link.url
// invalid link, but still detected by linkify somehow;
// need to check to prevent infinite loop below
if (url.length <= proto.length) return false
// disallow '*' at the end of the link (conflicts with emphasis)
url = url.replace(/\*+$/, '')
const fullUrl = state.md.normalizeLink(url)
if (!state.md.validateLink(fullUrl)) return false
if (!silent) {
state.pending = state.pending.slice(0, -proto.length)
const token_o = state.push('link_open', 'a', 1)
token_o.attrs = [['href', fullUrl]]
token_o.markup = 'linkify'
token_o.info = 'auto'
const token_t = state.push('text', '', 0)
token_t.content = state.md.normalizeLinkText(url)
const token_c = state.push('link_close', 'a', -1)
token_c.markup = 'linkify'
token_c.info = 'auto'
}
state.pos += url.length - proto.length
return true
}

42
node_modules/markdown-it/lib/rules_inline/newline.mjs generated vendored Normal file
View File

@@ -0,0 +1,42 @@
// Proceess '\n'
import { isSpace } from '../common/utils.mjs'
export default function newline (state, silent) {
let pos = state.pos
if (state.src.charCodeAt(pos) !== 0x0A/* \n */) { return false }
const pmax = state.pending.length - 1
const max = state.posMax
// ' \n' -> hardbreak
// Lookup in pending chars is bad practice! Don't copy to other rules!
// Pending string is stored in concat mode, indexed lookups will cause
// convertion to flat mode.
if (!silent) {
if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {
if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {
// Find whitespaces tail of pending chars.
let ws = pmax - 1
while (ws >= 1 && state.pending.charCodeAt(ws - 1) === 0x20) ws--
state.pending = state.pending.slice(0, ws)
state.push('hardbreak', 'br', 0)
} else {
state.pending = state.pending.slice(0, -1)
state.push('softbreak', 'br', 0)
}
} else {
state.push('softbreak', 'br', 0)
}
}
pos++
// skip heading spaces for next line
while (pos < max && isSpace(state.src.charCodeAt(pos))) { pos++ }
state.pos = pos
return true
}

123
node_modules/markdown-it/lib/rules_inline/state_inline.mjs generated vendored Normal file
View File

@@ -0,0 +1,123 @@
// Inline parser state
import Token from '../token.mjs'
import { isWhiteSpace, isPunctChar, isMdAsciiPunct } from '../common/utils.mjs'
function StateInline (src, md, env, outTokens) {
this.src = src
this.env = env
this.md = md
this.tokens = outTokens
this.tokens_meta = Array(outTokens.length)
this.pos = 0
this.posMax = this.src.length
this.level = 0
this.pending = ''
this.pendingLevel = 0
// Stores { start: end } pairs. Useful for backtrack
// optimization of pairs parse (emphasis, strikes).
this.cache = {}
// List of emphasis-like delimiters for current tag
this.delimiters = []
// Stack of delimiter lists for upper level tags
this._prev_delimiters = []
// backtick length => last seen position
this.backticks = {}
this.backticksScanned = false
// Counter used to disable inline linkify-it execution
// inside <a> and markdown links
this.linkLevel = 0
}
// Flush pending text
//
StateInline.prototype.pushPending = function () {
const token = new Token('text', '', 0)
token.content = this.pending
token.level = this.pendingLevel
this.tokens.push(token)
this.pending = ''
return token
}
// Push new token to "stream".
// If pending text exists - flush it as text token
//
StateInline.prototype.push = function (type, tag, nesting) {
if (this.pending) {
this.pushPending()
}
const token = new Token(type, tag, nesting)
let token_meta = null
if (nesting < 0) {
// closing tag
this.level--
this.delimiters = this._prev_delimiters.pop()
}
token.level = this.level
if (nesting > 0) {
// opening tag
this.level++
this._prev_delimiters.push(this.delimiters)
this.delimiters = []
token_meta = { delimiters: this.delimiters }
}
this.pendingLevel = this.level
this.tokens.push(token)
this.tokens_meta.push(token_meta)
return token
}
// Scan a sequence of emphasis-like markers, and determine whether
// it can start an emphasis sequence or end an emphasis sequence.
//
// - start - position to scan from (it should point at a valid marker);
// - canSplitWord - determine if these markers can be found inside a word
//
StateInline.prototype.scanDelims = function (start, canSplitWord) {
const max = this.posMax
const marker = this.src.charCodeAt(start)
// treat beginning of the line as a whitespace
const lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20
let pos = start
while (pos < max && this.src.charCodeAt(pos) === marker) { pos++ }
const count = pos - start
// treat end of the line as a whitespace
const nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20
const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar))
const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar))
const isLastWhiteSpace = isWhiteSpace(lastChar)
const isNextWhiteSpace = isWhiteSpace(nextChar)
const left_flanking =
!isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar)
const right_flanking =
!isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar)
const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar)
const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar)
return { can_open, can_close, length: count }
}
// re-export Token class to use in block rules
StateInline.prototype.Token = Token
export default StateInline

127
node_modules/markdown-it/lib/rules_inline/strikethrough.mjs generated vendored Normal file
View File

@@ -0,0 +1,127 @@
// ~~strike through~~
//
// Insert each marker as a separate text token, and add it to delimiter list
//
function strikethrough_tokenize (state, silent) {
const start = state.pos
const marker = state.src.charCodeAt(start)
if (silent) { return false }
if (marker !== 0x7E/* ~ */) { return false }
const scanned = state.scanDelims(state.pos, true)
let len = scanned.length
const ch = String.fromCharCode(marker)
if (len < 2) { return false }
let token
if (len % 2) {
token = state.push('text', '', 0)
token.content = ch
len--
}
for (let i = 0; i < len; i += 2) {
token = state.push('text', '', 0)
token.content = ch + ch
state.delimiters.push({
marker,
length: 0, // disable "rule of 3" length checks meant for emphasis
token: state.tokens.length - 1,
end: -1,
open: scanned.can_open,
close: scanned.can_close
})
}
state.pos += scanned.length
return true
}
function postProcess (state, delimiters) {
let token
const loneMarkers = []
const max = delimiters.length
for (let i = 0; i < max; i++) {
const startDelim = delimiters[i]
if (startDelim.marker !== 0x7E/* ~ */) {
continue
}
if (startDelim.end === -1) {
continue
}
const endDelim = delimiters[startDelim.end]
token = state.tokens[startDelim.token]
token.type = 's_open'
token.tag = 's'
token.nesting = 1
token.markup = '~~'
token.content = ''
token = state.tokens[endDelim.token]
token.type = 's_close'
token.tag = 's'
token.nesting = -1
token.markup = '~~'
token.content = ''
if (state.tokens[endDelim.token - 1].type === 'text' &&
state.tokens[endDelim.token - 1].content === '~') {
loneMarkers.push(endDelim.token - 1)
}
}
// If a marker sequence has an odd number of characters, it's splitted
// like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the
// start of the sequence.
//
// So, we have to move all those markers after subsequent s_close tags.
//
while (loneMarkers.length) {
const i = loneMarkers.pop()
let j = i + 1
while (j < state.tokens.length && state.tokens[j].type === 's_close') {
j++
}
j--
if (i !== j) {
token = state.tokens[j]
state.tokens[j] = state.tokens[i]
state.tokens[i] = token
}
}
}
// Walk through delimiter list and replace text tokens with tags
//
function strikethrough_postProcess (state) {
const tokens_meta = state.tokens_meta
const max = state.tokens_meta.length
postProcess(state, state.delimiters)
for (let curr = 0; curr < max; curr++) {
if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
postProcess(state, tokens_meta[curr].delimiters)
}
}
}
export default {
tokenize: strikethrough_tokenize,
postProcess: strikethrough_postProcess
}

86
node_modules/markdown-it/lib/rules_inline/text.mjs generated vendored Normal file
View File

@@ -0,0 +1,86 @@
// Skip text characters for text token, place those to pending buffer
// and increment current pos
// Rule to skip pure text
// '{}$%@~+=:' reserved for extentions
// !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
// !!!! Don't confuse with "Markdown ASCII Punctuation" chars
// http://spec.commonmark.org/0.15/#ascii-punctuation-character
function isTerminatorChar (ch) {
switch (ch) {
case 0x0A/* \n */:
case 0x21/* ! */:
case 0x23/* # */:
case 0x24/* $ */:
case 0x25/* % */:
case 0x26/* & */:
case 0x2A/* * */:
case 0x2B/* + */:
case 0x2D/* - */:
case 0x3A/* : */:
case 0x3C/* < */:
case 0x3D/* = */:
case 0x3E/* > */:
case 0x40/* @ */:
case 0x5B/* [ */:
case 0x5C/* \ */:
case 0x5D/* ] */:
case 0x5E/* ^ */:
case 0x5F/* _ */:
case 0x60/* ` */:
case 0x7B/* { */:
case 0x7D/* } */:
case 0x7E/* ~ */:
return true
default:
return false
}
}
export default function text (state, silent) {
let pos = state.pos
while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {
pos++
}
if (pos === state.pos) { return false }
if (!silent) { state.pending += state.src.slice(state.pos, pos) }
state.pos = pos
return true
}
// Alternative implementation, for memory.
//
// It costs 10% of performance, but allows extend terminators list, if place it
// to `ParserInline` property. Probably, will switch to it sometime, such
// flexibility required.
/*
var TERMINATOR_RE = /[\n!#$%&*+\-:<=>@[\\\]^_`{}~]/;
module.exports = function text(state, silent) {
var pos = state.pos,
idx = state.src.slice(pos).search(TERMINATOR_RE);
// first char is terminator -> empty text
if (idx === 0) { return false; }
// no terminator -> text till end of string
if (idx < 0) {
if (!silent) { state.pending += state.src.slice(pos); }
state.pos = state.src.length;
return true;
}
if (!silent) { state.pending += state.src.slice(pos, pos + idx); }
state.pos += idx;
return true;
}; */

191
node_modules/markdown-it/lib/token.mjs generated vendored Normal file
View File

@@ -0,0 +1,191 @@
// Token class
/**
* class Token
**/
/**
* new Token(type, tag, nesting)
*
* Create new token and fill passed properties.
**/
function Token (type, tag, nesting) {
/**
* Token#type -> String
*
* Type of the token (string, e.g. "paragraph_open")
**/
this.type = type
/**
* Token#tag -> String
*
* html tag name, e.g. "p"
**/
this.tag = tag
/**
* Token#attrs -> Array
*
* Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
**/
this.attrs = null
/**
* Token#map -> Array
*
* Source map info. Format: `[ line_begin, line_end ]`
**/
this.map = null
/**
* Token#nesting -> Number
*
* Level change (number in {-1, 0, 1} set), where:
*
* - `1` means the tag is opening
* - `0` means the tag is self-closing
* - `-1` means the tag is closing
**/
this.nesting = nesting
/**
* Token#level -> Number
*
* nesting level, the same as `state.level`
**/
this.level = 0
/**
* Token#children -> Array
*
* An array of child nodes (inline and img tokens)
**/
this.children = null
/**
* Token#content -> String
*
* In a case of self-closing tag (code, html, fence, etc.),
* it has contents of this tag.
**/
this.content = ''
/**
* Token#markup -> String
*
* '*' or '_' for emphasis, fence string for fence, etc.
**/
this.markup = ''
/**
* Token#info -> String
*
* Additional information:
*
* - Info string for "fence" tokens
* - The value "auto" for autolink "link_open" and "link_close" tokens
* - The string value of the item marker for ordered-list "list_item_open" tokens
**/
this.info = ''
/**
* Token#meta -> Object
*
* A place for plugins to store an arbitrary data
**/
this.meta = null
/**
* Token#block -> Boolean
*
* True for block-level tokens, false for inline tokens.
* Used in renderer to calculate line breaks
**/
this.block = false
/**
* Token#hidden -> Boolean
*
* If it's true, ignore this element when rendering. Used for tight lists
* to hide paragraphs.
**/
this.hidden = false
}
/**
* Token.attrIndex(name) -> Number
*
* Search attribute index by name.
**/
Token.prototype.attrIndex = function attrIndex (name) {
if (!this.attrs) { return -1 }
const attrs = this.attrs
for (let i = 0, len = attrs.length; i < len; i++) {
if (attrs[i][0] === name) { return i }
}
return -1
}
/**
* Token.attrPush(attrData)
*
* Add `[ name, value ]` attribute to list. Init attrs if necessary
**/
Token.prototype.attrPush = function attrPush (attrData) {
if (this.attrs) {
this.attrs.push(attrData)
} else {
this.attrs = [attrData]
}
}
/**
* Token.attrSet(name, value)
*
* Set `name` attribute to `value`. Override old value if exists.
**/
Token.prototype.attrSet = function attrSet (name, value) {
const idx = this.attrIndex(name)
const attrData = [name, value]
if (idx < 0) {
this.attrPush(attrData)
} else {
this.attrs[idx] = attrData
}
}
/**
* Token.attrGet(name)
*
* Get the value of attribute `name`, or null if it does not exist.
**/
Token.prototype.attrGet = function attrGet (name) {
const idx = this.attrIndex(name)
let value = null
if (idx >= 0) {
value = this.attrs[idx][1]
}
return value
}
/**
* Token.attrJoin(name, value)
*
* Join value to existing attribute via space. Or create new attribute if not
* exists. Useful to operate with token classes.
**/
Token.prototype.attrJoin = function attrJoin (name, value) {
const idx = this.attrIndex(name)
if (idx < 0) {
this.attrPush([name, value])
} else {
this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value
}
}
export default Token