diff options
Diffstat (limited to 'packages/markdown-it-14.1.0/lib')
52 files changed, 0 insertions, 6054 deletions
diff --git a/packages/markdown-it-14.1.0/lib/common/html_blocks.mjs b/packages/markdown-it-14.1.0/lib/common/html_blocks.mjs deleted file mode 100644 index 1e27a7f..0000000 --- a/packages/markdown-it-14.1.0/lib/common/html_blocks.mjs +++ /dev/null @@ -1,67 +0,0 @@ -// 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' -] diff --git a/packages/markdown-it-14.1.0/lib/common/html_re.mjs b/packages/markdown-it-14.1.0/lib/common/html_re.mjs deleted file mode 100644 index ccfbf87..0000000 --- a/packages/markdown-it-14.1.0/lib/common/html_re.mjs +++ /dev/null @@ -1,25 +0,0 @@ -// 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 } diff --git a/packages/markdown-it-14.1.0/lib/common/utils.mjs b/packages/markdown-it-14.1.0/lib/common/utils.mjs deleted file mode 100644 index b78c9b0..0000000 --- a/packages/markdown-it-14.1.0/lib/common/utils.mjs +++ /dev/null @@ -1,304 +0,0 @@ -// 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 = { - '&': '&', - '<': '<', - '>': '>', - '"': '"' -} - -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 -} diff --git a/packages/markdown-it-14.1.0/lib/helpers/index.mjs b/packages/markdown-it-14.1.0/lib/helpers/index.mjs deleted file mode 100644 index 7ea30af..0000000 --- a/packages/markdown-it-14.1.0/lib/helpers/index.mjs +++ /dev/null @@ -1,11 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/helpers/parse_link_destination.mjs b/packages/markdown-it-14.1.0/lib/helpers/parse_link_destination.mjs deleted file mode 100644 index 6a723a6..0000000 --- a/packages/markdown-it-14.1.0/lib/helpers/parse_link_destination.mjs +++ /dev/null @@ -1,77 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/helpers/parse_link_label.mjs b/packages/markdown-it-14.1.0/lib/helpers/parse_link_label.mjs deleted file mode 100644 index f1a53fa..0000000 --- a/packages/markdown-it-14.1.0/lib/helpers/parse_link_label.mjs +++ /dev/null @@ -1,49 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/helpers/parse_link_title.mjs b/packages/markdown-it-14.1.0/lib/helpers/parse_link_title.mjs deleted file mode 100644 index 4605647..0000000 --- a/packages/markdown-it-14.1.0/lib/helpers/parse_link_title.mjs +++ /dev/null @@ -1,66 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/index.mjs b/packages/markdown-it-14.1.0/lib/index.mjs deleted file mode 100644 index 8a8af9d..0000000 --- a/packages/markdown-it-14.1.0/lib/index.mjs +++ /dev/null @@ -1,565 +0,0 @@ -// 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 diff --git a/packages/markdown-it-14.1.0/lib/parser_block.mjs b/packages/markdown-it-14.1.0/lib/parser_block.mjs deleted file mode 100644 index 486d68f..0000000 --- a/packages/markdown-it-14.1.0/lib/parser_block.mjs +++ /dev/null @@ -1,134 +0,0 @@ -/** 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 diff --git a/packages/markdown-it-14.1.0/lib/parser_core.mjs b/packages/markdown-it-14.1.0/lib/parser_core.mjs deleted file mode 100644 index df61d67..0000000 --- a/packages/markdown-it-14.1.0/lib/parser_core.mjs +++ /dev/null @@ -1,62 +0,0 @@ -/** 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 diff --git a/packages/markdown-it-14.1.0/lib/parser_inline.mjs b/packages/markdown-it-14.1.0/lib/parser_inline.mjs deleted file mode 100644 index c2cc6a1..0000000 --- a/packages/markdown-it-14.1.0/lib/parser_inline.mjs +++ /dev/null @@ -1,197 +0,0 @@ -/** 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 diff --git a/packages/markdown-it-14.1.0/lib/presets/commonmark.mjs b/packages/markdown-it-14.1.0/lib/presets/commonmark.mjs deleted file mode 100644 index 7e705ad..0000000 --- a/packages/markdown-it-14.1.0/lib/presets/commonmark.mjs +++ /dev/null @@ -1,88 +0,0 @@ -// 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' - ] - } - } -} diff --git a/packages/markdown-it-14.1.0/lib/presets/default.mjs b/packages/markdown-it-14.1.0/lib/presets/default.mjs deleted file mode 100644 index 2540207..0000000 --- a/packages/markdown-it-14.1.0/lib/presets/default.mjs +++ /dev/null @@ -1,47 +0,0 @@ -// 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: {} - } -} diff --git a/packages/markdown-it-14.1.0/lib/presets/zero.mjs b/packages/markdown-it-14.1.0/lib/presets/zero.mjs deleted file mode 100644 index c83a48e..0000000 --- a/packages/markdown-it-14.1.0/lib/presets/zero.mjs +++ /dev/null @@ -1,70 +0,0 @@ -// "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' - ] - } - } -} diff --git a/packages/markdown-it-14.1.0/lib/renderer.mjs b/packages/markdown-it-14.1.0/lib/renderer.mjs deleted file mode 100644 index a58914c..0000000 --- a/packages/markdown-it-14.1.0/lib/renderer.mjs +++ /dev/null @@ -1,322 +0,0 @@ -/** - * 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 diff --git a/packages/markdown-it-14.1.0/lib/ruler.mjs b/packages/markdown-it-14.1.0/lib/ruler.mjs deleted file mode 100644 index 92c98e9..0000000 --- a/packages/markdown-it-14.1.0/lib/ruler.mjs +++ /dev/null @@ -1,340 +0,0 @@ -/** - * 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 diff --git a/packages/markdown-it-14.1.0/lib/rules_block/blockquote.mjs b/packages/markdown-it-14.1.0/lib/rules_block/blockquote.mjs deleted file mode 100644 index b61da02..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/blockquote.mjs +++ /dev/null @@ -1,209 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/code.mjs b/packages/markdown-it-14.1.0/lib/rules_block/code.mjs deleted file mode 100644 index e45e6f9..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/code.mjs +++ /dev/null @@ -1,30 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/fence.mjs b/packages/markdown-it-14.1.0/lib/rules_block/fence.mjs deleted file mode 100644 index 930f7b3..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/fence.mjs +++ /dev/null @@ -1,94 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/heading.mjs b/packages/markdown-it-14.1.0/lib/rules_block/heading.mjs deleted file mode 100644 index d2f7b79..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/heading.mjs +++ /dev/null @@ -1,51 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/hr.mjs b/packages/markdown-it-14.1.0/lib/rules_block/hr.mjs deleted file mode 100644 index d467b21..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/hr.mjs +++ /dev/null @@ -1,40 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/html_block.mjs b/packages/markdown-it-14.1.0/lib/rules_block/html_block.mjs deleted file mode 100644 index 197520f..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/html_block.mjs +++ /dev/null @@ -1,69 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/lheading.mjs b/packages/markdown-it-14.1.0/lib/rules_block/lheading.mjs deleted file mode 100644 index ee3b9a3..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/lheading.mjs +++ /dev/null @@ -1,82 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/list.mjs b/packages/markdown-it-14.1.0/lib/rules_block/list.mjs deleted file mode 100644 index fb53abd..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/list.mjs +++ /dev/null @@ -1,331 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/paragraph.mjs b/packages/markdown-it-14.1.0/lib/rules_block/paragraph.mjs deleted file mode 100644 index 6ecdcef..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/paragraph.mjs +++ /dev/null @@ -1,46 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/reference.mjs b/packages/markdown-it-14.1.0/lib/rules_block/reference.mjs deleted file mode 100644 index 4166286..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/reference.mjs +++ /dev/null @@ -1,212 +0,0 @@ -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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_block/state_block.mjs b/packages/markdown-it-14.1.0/lib/rules_block/state_block.mjs deleted file mode 100644 index 3c2a876..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/state_block.mjs +++ /dev/null @@ -1,220 +0,0 @@ -// 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 diff --git a/packages/markdown-it-14.1.0/lib/rules_block/table.mjs b/packages/markdown-it-14.1.0/lib/rules_block/table.mjs deleted file mode 100644 index be0ba0a..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_block/table.mjs +++ /dev/null @@ -1,228 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_core/block.mjs b/packages/markdown-it-14.1.0/lib/rules_core/block.mjs deleted file mode 100644 index 526cb48..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_core/block.mjs +++ /dev/null @@ -1,13 +0,0 @@ -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) - } -} diff --git a/packages/markdown-it-14.1.0/lib/rules_core/inline.mjs b/packages/markdown-it-14.1.0/lib/rules_core/inline.mjs deleted file mode 100644 index efd6c07..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_core/inline.mjs +++ /dev/null @@ -1,11 +0,0 @@ -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) - } - } -} diff --git a/packages/markdown-it-14.1.0/lib/rules_core/linkify.mjs b/packages/markdown-it-14.1.0/lib/rules_core/linkify.mjs deleted file mode 100644 index a225280..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_core/linkify.mjs +++ /dev/null @@ -1,134 +0,0 @@ -// 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) - } - } - } -} diff --git a/packages/markdown-it-14.1.0/lib/rules_core/normalize.mjs b/packages/markdown-it-14.1.0/lib/rules_core/normalize.mjs deleted file mode 100644 index dfb67ef..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_core/normalize.mjs +++ /dev/null @@ -1,17 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_core/replacements.mjs b/packages/markdown-it-14.1.0/lib/rules_core/replacements.mjs deleted file mode 100644 index b18ecd9..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_core/replacements.mjs +++ /dev/null @@ -1,101 +0,0 @@ -// Simple typographic replacements -// -// (c) (C) → © -// (tm) (TM) → ™ -// (r) (R) → ® -// +- → ± -// ... → … (also ?.... → ?.., !.... → !..) -// ???????? → ???, !!!!! → !!!, `,,` → `,` -// -- → –, --- → — -// - -// 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) - } - } -} diff --git a/packages/markdown-it-14.1.0/lib/rules_core/smartquotes.mjs b/packages/markdown-it-14.1.0/lib/rules_core/smartquotes.mjs deleted file mode 100644 index 3b990ed..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_core/smartquotes.mjs +++ /dev/null @@ -1,193 +0,0 @@ -// 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) - } -} diff --git a/packages/markdown-it-14.1.0/lib/rules_core/state_core.mjs b/packages/markdown-it-14.1.0/lib/rules_core/state_core.mjs deleted file mode 100644 index a96c8fb..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_core/state_core.mjs +++ /dev/null @@ -1,17 +0,0 @@ -// 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 diff --git a/packages/markdown-it-14.1.0/lib/rules_core/text_join.mjs b/packages/markdown-it-14.1.0/lib/rules_core/text_join.mjs deleted file mode 100644 index ee8f872..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_core/text_join.mjs +++ /dev/null @@ -1,43 +0,0 @@ -// 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 - } - } -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/autolink.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/autolink.mjs deleted file mode 100644 index e71e66f..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/autolink.mjs +++ /dev/null @@ -1,72 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/backticks.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/backticks.mjs deleted file mode 100644 index 5b926d0..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/backticks.mjs +++ /dev/null @@ -1,60 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/balance_pairs.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/balance_pairs.mjs deleted file mode 100644 index 8638d21..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/balance_pairs.mjs +++ /dev/null @@ -1,124 +0,0 @@ -// 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) - } - } -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/emphasis.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/emphasis.mjs deleted file mode 100644 index 4e3b273..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/emphasis.mjs +++ /dev/null @@ -1,123 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/entity.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/entity.mjs deleted file mode 100644 index e65191d..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/entity.mjs +++ /dev/null @@ -1,51 +0,0 @@ -// Process html entity - {, ¯, ", ... - -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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/escape.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/escape.mjs deleted file mode 100644 index aa3728e..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/escape.mjs +++ /dev/null @@ -1,69 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/fragments_join.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/fragments_join.mjs deleted file mode 100644 index e89ef9e..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/fragments_join.mjs +++ /dev/null @@ -1,38 +0,0 @@ -// 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 - } -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/html_inline.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/html_inline.mjs deleted file mode 100644 index 256efad..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/html_inline.mjs +++ /dev/null @@ -1,50 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/image.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/image.mjs deleted file mode 100644 index 32cbb31..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/image.mjs +++ /dev/null @@ -1,138 +0,0 @@ -// Process  - -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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/link.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/link.mjs deleted file mode 100644 index b145173..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/link.mjs +++ /dev/null @@ -1,139 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/linkify.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/linkify.mjs deleted file mode 100644 index fdc817a..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/linkify.mjs +++ /dev/null @@ -1,56 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/newline.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/newline.mjs deleted file mode 100644 index 2c0e3ae..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/newline.mjs +++ /dev/null @@ -1,42 +0,0 @@ -// 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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/state_inline.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/state_inline.mjs deleted file mode 100644 index 80cb3c5..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/state_inline.mjs +++ /dev/null @@ -1,123 +0,0 @@ -// 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 diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/strikethrough.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/strikethrough.mjs deleted file mode 100644 index 45f3c1b..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/strikethrough.mjs +++ /dev/null @@ -1,127 +0,0 @@ -// ~~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 -} diff --git a/packages/markdown-it-14.1.0/lib/rules_inline/text.mjs b/packages/markdown-it-14.1.0/lib/rules_inline/text.mjs deleted file mode 100644 index 9be4227..0000000 --- a/packages/markdown-it-14.1.0/lib/rules_inline/text.mjs +++ /dev/null @@ -1,86 +0,0 @@ -// 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; -}; */ diff --git a/packages/markdown-it-14.1.0/lib/token.mjs b/packages/markdown-it-14.1.0/lib/token.mjs deleted file mode 100644 index 706ae1d..0000000 --- a/packages/markdown-it-14.1.0/lib/token.mjs +++ /dev/null @@ -1,191 +0,0 @@ -// 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 |