From c2aa7bf38fb30de2d04f87f8e7780e4c768ae6b1 Mon Sep 17 00:00:00 2001 From: Minteck Date: Thu, 20 Jan 2022 13:43:34 +0100 Subject: Initial commit --- node_modules/markdown-it/lib/rules_core/block.js | 16 ++ node_modules/markdown-it/lib/rules_core/inline.js | 13 ++ node_modules/markdown-it/lib/rules_core/linkify.js | 133 ++++++++++++++ .../markdown-it/lib/rules_core/normalize.js | 21 +++ .../markdown-it/lib/rules_core/replacements.js | 107 +++++++++++ .../markdown-it/lib/rules_core/smartquotes.js | 201 +++++++++++++++++++++ .../markdown-it/lib/rules_core/state_core.js | 20 ++ 7 files changed, 511 insertions(+) create mode 100644 node_modules/markdown-it/lib/rules_core/block.js create mode 100644 node_modules/markdown-it/lib/rules_core/inline.js create mode 100644 node_modules/markdown-it/lib/rules_core/linkify.js create mode 100644 node_modules/markdown-it/lib/rules_core/normalize.js create mode 100644 node_modules/markdown-it/lib/rules_core/replacements.js create mode 100644 node_modules/markdown-it/lib/rules_core/smartquotes.js create mode 100644 node_modules/markdown-it/lib/rules_core/state_core.js (limited to 'node_modules/markdown-it/lib/rules_core') diff --git a/node_modules/markdown-it/lib/rules_core/block.js b/node_modules/markdown-it/lib/rules_core/block.js new file mode 100644 index 0000000..2a365fa --- /dev/null +++ b/node_modules/markdown-it/lib/rules_core/block.js @@ -0,0 +1,16 @@ +'use strict'; + + +module.exports = function block(state) { + var 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/node_modules/markdown-it/lib/rules_core/inline.js b/node_modules/markdown-it/lib/rules_core/inline.js new file mode 100644 index 0000000..4c33d0d --- /dev/null +++ b/node_modules/markdown-it/lib/rules_core/inline.js @@ -0,0 +1,13 @@ +'use strict'; + +module.exports = function inline(state) { + var tokens = state.tokens, tok, i, l; + + // Parse inlines + for (i = 0, l = tokens.length; i < l; i++) { + tok = tokens[i]; + if (tok.type === 'inline') { + state.md.inline.parse(tok.content, state.md, state.env, tok.children); + } + } +}; diff --git a/node_modules/markdown-it/lib/rules_core/linkify.js b/node_modules/markdown-it/lib/rules_core/linkify.js new file mode 100644 index 0000000..7c3ffc8 --- /dev/null +++ b/node_modules/markdown-it/lib/rules_core/linkify.js @@ -0,0 +1,133 @@ +// Replace link-like texts with link nodes. +// +// Currently restricted by `md.validateLink()` to http/https/ftp +// +'use strict'; + + +var arrayReplaceAt = require('../common/utils').arrayReplaceAt; + + +function isLinkOpen(str) { + return /^\s]/i.test(str); +} +function isLinkClose(str) { + return /^<\/a\s*>/i.test(str); +} + + +module.exports = function linkify(state) { + var i, j, l, tokens, token, currentToken, nodes, ln, text, pos, lastPos, + level, htmlLinkLevel, url, fullUrl, urlText, + blockTokens = state.tokens, + links; + + if (!state.md.options.linkify) { return; } + + for (j = 0, l = blockTokens.length; j < l; j++) { + if (blockTokens[j].type !== 'inline' || + !state.md.linkify.pretest(blockTokens[j].content)) { + continue; + } + + tokens = blockTokens[j].children; + + htmlLinkLevel = 0; + + // We scan from the end, to keep position when new tags added. + // Use reversed logic in links start/end match + for (i = tokens.length - 1; i >= 0; i--) { + 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)) { + + text = currentToken.content; + links = state.md.linkify.match(text); + + // Now split string to nodes + nodes = []; + level = currentToken.level; + lastPos = 0; + + for (ln = 0; ln < links.length; ln++) { + + url = links[ln].url; + fullUrl = state.md.normalizeLink(url); + if (!state.md.validateLink(fullUrl)) { continue; } + + 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); + } + + pos = links[ln].index; + + if (pos > lastPos) { + token = new state.Token('text', '', 0); + token.content = text.slice(lastPos, pos); + token.level = level; + nodes.push(token); + } + + token = new state.Token('link_open', 'a', 1); + token.attrs = [ [ 'href', fullUrl ] ]; + token.level = level++; + token.markup = 'linkify'; + token.info = 'auto'; + nodes.push(token); + + token = new state.Token('text', '', 0); + token.content = urlText; + token.level = level; + nodes.push(token); + + token = new state.Token('link_close', 'a', -1); + token.level = --level; + token.markup = 'linkify'; + token.info = 'auto'; + nodes.push(token); + + lastPos = links[ln].lastIndex; + } + if (lastPos < text.length) { + 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/node_modules/markdown-it/lib/rules_core/normalize.js b/node_modules/markdown-it/lib/rules_core/normalize.js new file mode 100644 index 0000000..ad196cd --- /dev/null +++ b/node_modules/markdown-it/lib/rules_core/normalize.js @@ -0,0 +1,21 @@ +// Normalize input string + +'use strict'; + + +// https://spec.commonmark.org/0.29/#line-ending +var NEWLINES_RE = /\r\n?|\n/g; +var NULL_RE = /\0/g; + + +module.exports = function normalize(state) { + var 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/node_modules/markdown-it/lib/rules_core/replacements.js b/node_modules/markdown-it/lib/rules_core/replacements.js new file mode 100644 index 0000000..533496f --- /dev/null +++ b/node_modules/markdown-it/lib/rules_core/replacements.js @@ -0,0 +1,107 @@ +// Simple typographic replacements +// +// (c) (C) → © +// (tm) (TM) → ™ +// (r) (R) → ® +// +- → ± +// (p) (P) -> § +// ... → … (also ?.... → ?.., !.... → !..) +// ???????? → ???, !!!!! → !!!, `,,` → `,` +// -- → –, --- → — +// +'use strict'; + +// TODO: +// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾ +// - miltiplication 2 x 4 -> 2 × 4 + +var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/; + +// Workaround for phantomjs - need regex without /g flag, +// or root check will fail every second time +var SCOPED_ABBR_TEST_RE = /\((c|tm|r|p)\)/i; + +var SCOPED_ABBR_RE = /\((c|tm|r|p)\)/ig; +var SCOPED_ABBR = { + c: '©', + r: '®', + p: '§', + tm: '™' +}; + +function replaceFn(match, name) { + return SCOPED_ABBR[name.toLowerCase()]; +} + +function replace_scoped(inlineTokens) { + var i, token, inside_autolink = 0; + + for (i = inlineTokens.length - 1; i >= 0; i--) { + 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) { + var i, token, inside_autolink = 0; + + for (i = inlineTokens.length - 1; i >= 0; i--) { + 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++; + } + } +} + + +module.exports = function replace(state) { + var 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/node_modules/markdown-it/lib/rules_core/smartquotes.js b/node_modules/markdown-it/lib/rules_core/smartquotes.js new file mode 100644 index 0000000..e96fc71 --- /dev/null +++ b/node_modules/markdown-it/lib/rules_core/smartquotes.js @@ -0,0 +1,201 @@ +// Convert straight quotation marks to typographic ones +// +'use strict'; + + +var isWhiteSpace = require('../common/utils').isWhiteSpace; +var isPunctChar = require('../common/utils').isPunctChar; +var isMdAsciiPunct = require('../common/utils').isMdAsciiPunct; + +var QUOTE_TEST_RE = /['"]/; +var QUOTE_RE = /['"]/g; +var APOSTROPHE = '\u2019'; /* ’ */ + + +function replaceAt(str, index, ch) { + return str.substr(0, index) + ch + str.substr(index + 1); +} + +function process_inlines(tokens, state) { + var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar, + isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace, + canOpen, canClose, j, isSingle, stack, openQuote, closeQuote; + + stack = []; + + for (i = 0; i < tokens.length; i++) { + token = tokens[i]; + + 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; } + + text = token.content; + pos = 0; + max = text.length; + + /*eslint no-labels:0,block-scoped-var:0*/ + OUTER: + while (pos < max) { + QUOTE_RE.lastIndex = pos; + t = QUOTE_RE.exec(text); + if (!t) { break; } + + canOpen = canClose = true; + pos = t.index + 1; + isSingle = (t[0] === "'"); + + // Find previous character, + // default to space if it's the beginning of the line + // + 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 + // + 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; + } + } + + isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar)); + isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar)); + + isLastWhiteSpace = isWhiteSpace(lastChar); + 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--) { + item = stack[j]; + if (stack[j].level < thisLevel) { break; } + if (item.single === isSingle && stack[j].level === thisLevel) { + item = stack[j]; + + 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); + } + } + } +} + + +module.exports = function smartquotes(state) { + /*eslint max-depth:0*/ + var blkIdx; + + if (!state.md.options.typographer) { return; } + + for (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/node_modules/markdown-it/lib/rules_core/state_core.js b/node_modules/markdown-it/lib/rules_core/state_core.js new file mode 100644 index 0000000..87cfd85 --- /dev/null +++ b/node_modules/markdown-it/lib/rules_core/state_core.js @@ -0,0 +1,20 @@ +// Core state object +// +'use strict'; + +var Token = require('../token'); + + +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; + + +module.exports = StateCore; -- cgit