wikiparser-node 0.0.0

package/parser/brackets.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const {removeComment} = require('../util/string'),
+	/** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} text
+ * @param {accum} accum
+ */
+const parseBrackets = (text, config = Parser.getConfig(), accum = []) => {
+	const source = '(?<=^(?:\x00\\d+c\x7f)*)={1,6}|\\[\\[|{{2,}|-{(?!{)',
+		/** @type {BracketExecArray[]} */ stack = [],
+		closes = {'=': '\n', '{': '}{2,}|\\|', '-': '}-', '[': ']]'},
+		/** @type {Record<string, string>} */ marks = {'!': '!', '!!': '+', '(!': '{', '!)': '}', '!-': '-', '=': '~'};
+	let regex = new RegExp(source, 'gm'),
+		/** @type {BracketExecArray} */ mt = regex.exec(text),
+		moreBraces = text.includes('}}'),
+		lastIndex;
+	while (mt || lastIndex <= text.length && stack.at(-1)?.[0]?.[0] === '=') {
+		const {0: syntax, index: curIndex} = mt ?? {0: '\n', index: text.length},
+			/** @type {BracketExecArray} */ top = stack.pop() ?? {},
+			{0: open, index, parts} = top,
+			innerEqual = syntax === '=' && top.findEqual;
+		if ([']]', '}-'].includes(syntax)) { // 情形1：闭合内链或转换
+			lastIndex = curIndex + 2;
+		} else if (syntax === '\n') { // 情形2：闭合标题
+			lastIndex = curIndex + 1;
+			const {pos, findEqual} = stack.at(-1) ?? {};
+			if (!pos || findEqual || removeComment(text.slice(pos, index)) !== '') {
+				const rmt = text.slice(index, curIndex).match(/^(={1,6})(.+)\1((?:\s|\x00\d+c\x7f)*)$/);
+				if (rmt) {
+					text = `${text.slice(0, index)}\x00${accum.length}h\x7f${text.slice(curIndex)}`;
+					lastIndex = index + 4 + String(accum.length).length;
+					const HeadingToken = require('../src/heading');
+					new HeadingToken(rmt[1].length, rmt.slice(2), config, accum);
+				}
+			}
+		} else if (syntax === '|' || innerEqual) { // 情形3：模板内部，含行首单个'='
+			lastIndex = curIndex + 1;
+			parts.at(-1).push(text.slice(top.pos, curIndex));
+			if (syntax === '|') {
+				parts.push([]);
+			}
+			top.pos = lastIndex;
+			top.findEqual = syntax === '|';
+			stack.push(top);
+		} else if (syntax.startsWith('}}')) { // 情形4：闭合模板
+			const close = syntax.slice(0, Math.min(open.length, 3)),
+				rest = open.length - close.length,
+				{length} = accum;
+			lastIndex = curIndex + close.length; // 这不是最终的lastIndex
+			parts.at(-1).push(text.slice(top.pos, curIndex));
+			/* 标记{{!}}等 */
+			const ch = close.length === 2 ? marks[removeComment(parts[0][0])] ?? 't' : 't';
+			let skip = false;
+			if (close.length === 3) {
+				const ArgToken = require('../src/arg');
+				new ArgToken(parts.map(part => part.join('=')), config, accum);
+			} else {
+				try {
+					const TranscludeToken = require('../src/transclude');
+					new TranscludeToken(parts[0][0], parts.slice(1), config, accum);
+				} catch (e) {
+					if (e instanceof Error && e.message.startsWith('非法的模板名称：')) {
+						lastIndex = index + open.length;
+						skip = true;
+					} else {
+						throw e;
+					}
+				}
+			}
+			if (!skip) {
+				/* 标记{{!}}结束 */
+				text = `${text.slice(0, index + rest)}\x00${length}${ch}\x7f${text.slice(lastIndex)}`;
+				lastIndex = index + rest + 3 + String(length).length;
+				if (rest > 1) {
+					stack.push({0: open.slice(0, rest), index, pos: index + rest, parts: [[]]});
+				} else if (rest === 1 && text[index - 1] === '-') {
+					stack.push({0: '-{', index: index - 1, pos: index + 1, parts: [[]]});
+				}
+			}
+		} else { // 情形5：开启
+			lastIndex = curIndex + syntax.length;
+			if (syntax[0] === '{') {
+				mt.pos = lastIndex;
+				mt.parts = [[]];
+			}
+			stack.push(...'0' in top ? [top] : [], mt);
+		}
+		moreBraces &&= text.slice(lastIndex).includes('}}');
+		let curTop = stack.at(-1);
+		if (!moreBraces && curTop?.[0]?.[0] === '{') {
+			stack.pop();
+			curTop = stack.at(-1);
+		}
+		regex = new RegExp(source + (curTop
+			? `|${closes[curTop[0][0]]}${curTop.findEqual ? '|=' : ''}`
+			: ''
+		), 'gm');
+		regex.lastIndex = lastIndex;
+		mt = regex.exec(text);
+	}
+	return text;
+};
+
+Parser.parsers.parseBrackets = __filename;
+module.exports = parseBrackets;

package/parser/commentAndExt.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} text
+ * @param {accum} accum
+ */
+const parseCommentAndExt = (text, config = Parser.getConfig(), accum = [], includeOnly = false) => {
+	const onlyinclude = /<onlyinclude>(.*?)<\/onlyinclude>/gs;
+	if (includeOnly && onlyinclude.test(text)) { // `<onlyinclude>`拥有最高优先级
+		return text.replace(onlyinclude, /** @param {string} inner */ (_, inner) => {
+			const str = `\x00${accum.length}e\x7f`,
+				OnlyincludeToken = require('../src/onlyinclude');
+			new OnlyincludeToken(inner, config, accum);
+			return str;
+		}).replace(/(?<=^|\x00\d+e\x7f).*?(?=$|\x00\d+e\x7f)/gs, substr => {
+			if (substr === '') {
+				return '';
+			}
+			const NoincludeToken = require('../src/nowiki/noinclude');
+			new NoincludeToken(substr, config, accum);
+			return `\x00${accum.length - 1}c\x7f`;
+		});
+	}
+	const ext = config.ext.join('|'),
+		includeRegex = includeOnly ? 'includeonly' : '(?:no|only)include',
+		noincludeRegex = includeOnly ? 'noinclude' : 'includeonly',
+		regex = new RegExp(
+			'<!--.*?(?:-->|$)|' // comment
+			+ `<${includeRegex}(?:\\s.*?)?>|</${includeRegex}\\s*>|` // <includeonly>
+			+ `<(${ext})(\\s.*?)?(?:/>|>(.*?)</(\\1\\s*)>)|` // 扩展标签
+			+ `<(${noincludeRegex})(\\s.*?)?(?:/>|>(.*?)(?:</(\\5\\s*)>|$))`, // <noinclude>
+			'gis',
+		);
+	return text.replace(
+		regex,
+		/** @type {function(...string): string} */
+		(substr, name, attr, inner, closing, include, includeAttr, includeInner, includeClosing) => {
+			const str = `\x00${accum.length}${name ? 'e' : 'c'}\x7f`;
+			if (name) {
+				const ExtToken = require('../src/tagPair/ext');
+				new ExtToken(name, attr, inner, closing, config, accum);
+			} else if (substr.startsWith('<!--')) {
+				const CommentToken = require('../src/nowiki/comment'),
+					closed = substr.endsWith('-->');
+				new CommentToken(substr.slice(4, closed ? -3 : undefined), closed, config, accum);
+			} else if (include) {
+				const IncludeToken = require('../src/tagPair/include');
+				new IncludeToken(include, includeAttr, includeInner, includeClosing, config, accum);
+			} else {
+				const NoincludeToken = require('../src/nowiki/noinclude');
+				new NoincludeToken(substr, config, accum);
+			}
+			return str;
+		},
+	);
+};
+
+Parser.parsers.parseCommentAndExt = __filename;
+module.exports = parseCommentAndExt;

package/parser/externalLinks.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const {extUrlChar} = require('../util/string'),
+	/** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} firstChild
+ * @param {accum} accum
+ */
+const parseExternalLinks = (firstChild, config = Parser.getConfig(), accum = []) => {
+	const ExtLinkToken = require('../src/extLink'),
+		regex = new RegExp(
+			`\\[((?:${config.protocol}|//)${extUrlChar})(\\p{Zs}*)([^\\]\\x01-\\x08\\x0a-\\x1f\\ufffd]*)\\]`,
+			'gui',
+		);
+	return firstChild.replace(regex, /** @type {function(...string): string} */ (_, url, space, text) => {
+		const {length} = accum,
+			mt = url.match(/&[lg]t;/);
+		if (mt) {
+			url = url.slice(0, mt.index);
+			space = '';
+			text = `${url.slice(mt.index)}${space}${text}`;
+		}
+		new ExtLinkToken(url, space, text, config, accum);
+		return `\x00${length}w\x7f`;
+	});
+};
+
+Parser.parsers.parseExternalLinks = __filename;
+module.exports = parseExternalLinks;

package/parser/hrAndDoubleUnderscore.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} firstChild
+ * @param {accum} accum
+ */
+const parseHrAndDoubleUnderscore = (firstChild, config = Parser.getConfig(), accum = []) => {
+	const HrToken = require('../src/nowiki/hr'),
+		DoubleUnderscoreToken = require('../src/nowiki/doubleUnderscore'),
+		{doubleUnderscore} = config;
+	return firstChild.replace(/^-{4,}/mg, m => {
+		new HrToken(m.length, config, accum);
+		return `\x00${accum.length - 1}r\x7f`;
+	}).replace(new RegExp(`__(${doubleUnderscore.flat().join('|')})__`, 'ig'), /** @param {string} p1 */(m, p1) => {
+		if (doubleUnderscore[0].includes(p1.toLowerCase()) || doubleUnderscore[1].includes(p1)) {
+			new DoubleUnderscoreToken(p1, config, accum);
+			return `\x00${accum.length - 1}u\x7f`;
+		}
+		return m;
+	});
+};
+
+Parser.parsers.parseHrAndDoubleUnderscore = __filename;
+module.exports = parseHrAndDoubleUnderscore;

package/parser/html.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} firstChild
+ * @param {accum} accum
+ */
+const parseHtml = (firstChild, config = Parser.getConfig(), accum = []) => {
+	const regex = /^(\/?)([a-z][^\s/>]*)([^>]*?)(\/?>)([^<]*)$/i,
+		elements = config.html.flat(),
+		bits = firstChild.split('<');
+	let text = bits.shift();
+	for (const x of bits) {
+		const mt = x.match(regex),
+			t = mt?.[2],
+			name = t?.toLowerCase();
+		if (!mt || !elements.includes(name)) {
+			text += `<${x}`;
+			continue;
+		}
+		const [, slash,, params, brace, rest] = mt,
+			AttributeToken = require('../src/attribute'),
+			attr = new AttributeToken(params, 'html-attr', name, config, accum),
+			itemprop = attr.getAttr('itemprop');
+		if (name === 'meta' && (itemprop === undefined || attr.getAttr('content') === undefined)
+			|| name === 'link' && (itemprop === undefined || attr.getAttr('href') === undefined)
+		) {
+			text += `<${x}`;
+			accum.pop();
+			continue;
+		}
+		text += `\x00${accum.length}x\x7f${rest}`;
+		const HtmlToken = require('../src/html');
+		new HtmlToken(t, attr, slash === '/', brace === '/>', config, accum);
+	}
+	return text;
+};
+
+Parser.parsers.parseHtml = __filename;
+module.exports = parseHtml;

package/parser/links.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..'),
+	Token = require('../src'); // eslint-disable-line no-unused-vars
+
+/**
+ * @param {string} firstChild
+ * @param {accum} accum
+ */
+const parseLinks = (firstChild, config = Parser.getConfig(), accum = []) => {
+	const parseQuotes = require('./quotes.js'),
+		regex = /^([^\n<>[\]{}|]+)(?:\|(.+?))?]](.*)/s,
+		regexImg = /^([^\n<>[\]{}|]+)\|(.*)/s,
+		regexExt = new RegExp(`^\\s*(?:${config.protocol})`, 'i'),
+		bits = firstChild.split('[[');
+	let s = bits.shift();
+	for (let i = 0; i < bits.length; i++) {
+		let mightBeImg, link, text, after;
+		const x = bits[i],
+			m = x.match(regex);
+		if (m) {
+			[, link, text, after] = m;
+			if (after.startsWith(']') && text?.includes('[')) {
+				text += ']';
+				after = after.slice(1);
+			}
+		} else {
+			const m2 = x.match(regexImg);
+			if (m2) {
+				mightBeImg = true;
+				[, link, text] = m2;
+			}
+		}
+		if (link === undefined || regexExt.test(link) || /\x00\d+[exhbru]\x7f/.test(link)) {
+			s += `[[${x}`;
+			continue;
+		}
+		const page = link.includes('%') ? decodeURIComponent(link) : link,
+			force = link.trim().startsWith(':');
+		if (force && mightBeImg) {
+			s += `[[${x}`;
+			continue;
+		}
+		const title = Parser.normalizeTitle(page, 0, false, config, true),
+			{ns, interwiki, valid} = title;
+		if (!valid) {
+			s += `[[${x}`;
+			continue;
+		} else if (mightBeImg) {
+			if (interwiki || ns !== 6) {
+				s += `[[${x}`;
+				continue;
+			}
+			let found;
+			for (i++; i < bits.length; i++) {
+				const next = bits[i],
+					p = next.split(']]');
+				if (p.length > 2) {
+					found = true;
+					text += `[[${p[0]}]]${p[1]}`;
+					after = p.slice(2).join(']]');
+					break;
+				} else if (p.length === 2) {
+					text += `[[${p[0]}]]${p[1]}`;
+				} else {
+					text += `[[${next}`;
+					break;
+				}
+			}
+			text = parseLinks(text, config, accum);
+			if (!found) {
+				s += `[[${link}|${text}`;
+				continue;
+			}
+		}
+		text = text && parseQuotes(text, config, accum);
+		s += `\x00${accum.length}l\x7f${after}`;
+		let LinkToken = require('../src/link');
+		if (!force) {
+			if (!interwiki && ns === 6) {
+				LinkToken = require('../src/link/file');
+			} else if (!interwiki && ns === 14) {
+				LinkToken = require('../src/link/category');
+			}
+		}
+		new LinkToken(link, text, title, config, accum);
+	}
+	return s;
+};
+
+Parser.parsers.parseLinks = __filename;
+module.exports = parseLinks;

package/parser/magicLinks.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const {extUrlChar} = require('../util/string'),
+	/** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} firstChild
+ * @param {accum} accum
+ */
+const parseMagicLinks = (firstChild, config = Parser.getConfig(), accum = []) => {
+	const MagicLinkToken = require('../src/magicLink'),
+		regex = new RegExp(`\\b(?:${config.protocol})(${extUrlChar})`, 'gui');
+	return firstChild.replace(regex, /** @param {string} p1 */ (m, p1) => {
+		let trail = '',
+			url = m;
+		const m2 = url.match(/&(?:lt|gt|nbsp|#x0*(?:3[ce]|a0)|#0*(?:6[02]|160));/i);
+		if (m2) {
+			trail = url.slice(m2.index);
+			url = url.slice(0, m2.index);
+		}
+		const sep = new RegExp(`[,;.:!?${url.includes('(') ? '' : ')'}]+$`),
+			sepChars = url.match(sep);
+		if (sepChars) {
+			let correction = 0;
+			if (sepChars[0].startsWith(';') && /&(?:[a-z]+|#x[\da-f]+|#\d+)$/i.test(url.slice(0, sepChars.index))) {
+				correction = 1;
+			}
+			trail = `${url.slice(sepChars.index + correction)}${trail}`;
+			url = url.slice(0, sepChars.index + correction);
+		}
+		if (trail.length >= p1.length) {
+			return m;
+		}
+		new MagicLinkToken(url, false, config, accum);
+		return `\x00${accum.length - 1}w\x7f${trail}`;
+	});
+};
+
+Parser.parsers.parseMagicLinks = __filename;
+module.exports = parseMagicLinks;

package/parser/quotes.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} text
+ * @param {accum} accum
+ */
+const parseQuotes = (text, config = Parser.getConfig(), accum = []) => {
+	const arr = text.split(/('{2,})/),
+		{length} = arr;
+	if (length === 1) {
+		return text;
+	}
+	let nBold = 0,
+		nItalic = 0,
+		firstSingle, firstMulti, firstSpace;
+	for (let i = 1; i < length; i += 2) {
+		const len = arr[i].length;
+		switch (len) {
+			case 2:
+				nItalic++;
+				break;
+			case 4:
+				arr[i - 1] += "'";
+				arr[i] = "'''";
+				// fall through
+			case 3:
+				nBold++;
+				if (firstSingle) {
+					break;
+				} else if (arr[i - 1].at(-1) === ' ') {
+					if (!firstMulti && !firstSpace) {
+						firstSpace = i;
+					}
+				} else if (arr[i - 1].at(-2) === ' ') {
+					firstSingle = i;
+				} else if (!firstMulti) {
+					firstMulti = i;
+				}
+				break;
+			default:
+				arr[i - 1] += "'".repeat(len - 5);
+				arr[i] = "'''''";
+				nItalic++;
+				nBold++;
+		}
+	}
+	if (nItalic % 2 === 1 && nBold % 2 === 1) {
+		const i = firstSingle ?? firstMulti ?? firstSpace;
+		arr[i] = "''";
+		arr[i - 1] += "'";
+	}
+	const QuoteToken = require('../src/nowiki/quote');
+	for (let i = 1; i < length; i += 2) {
+		new QuoteToken(arr[i].length, config, accum);
+		arr[i] = `\x00${accum.length - 1}q\x7f`;
+	}
+	return arr.join('');
+};
+
+Parser.parsers.parseQuotes = __filename;
+module.exports = parseQuotes;

package/parser/table.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * `tr`和`td`包含开头的换行
+ * @param {{firstChild: string, type: string}}
+ * @param {accum} accum
+ */
+const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = []) => {
+	const TableToken = require('../src/table'),
+		TrToken = require('../src/table/tr'),
+		TdToken = require('../src/table/td'),
+		/** @type {TrToken[]} */ stack = [],
+		lines = firstChild.split('\n');
+	let out = type === 'root' ? '' : `\n${lines.shift()}`;
+	const /** @type {(str: string, top: TrToken & {firstChild: string}) => void} */ push = (str, top) => {
+		if (!top) {
+			out += str;
+			return;
+		}
+		const {lastElementChild, lastChild} = top;
+		if (top instanceof TdToken) {
+			lastElementChild.setText(lastElementChild.firstChild + str, 0);
+		} else if (typeof lastChild === 'string') {
+			top.setText(lastChild + str, 2);
+		} else {
+			top.appendChild(str);
+		}
+	};
+	for (const outLine of lines) {
+		let top = stack.pop();
+		const [spaces] = outLine.match(/^(?:\s|\x00\d+c\x7f)*/);
+		const line = outLine.slice(spaces.length),
+			matchesStart = line.match(/^(:*(?:\s|\x00\d+c\x7f)*)({\||{\x00\d+!\x7f|\x00\d+{\x7f)(.*)/);
+		if (matchesStart) {
+			const [, indent, tableSyntax, attr] = matchesStart;
+			push(`\n${spaces}${indent}\x00${accum.length}b\x7f`, top);
+			const table = new TableToken(tableSyntax, attr, config, accum);
+			stack.push(...top ? [top] : [], table);
+			continue;
+		} else if (!top) {
+			out += `\n${outLine}`;
+			continue;
+		}
+		const matches = line.match(
+			/^(?:(\|}|\x00\d+!\x7f}|\x00\d+}\x7f)|(\|-+|\x00\d+!\x7f-+|\x00\d+-\x7f-*)|(!|(?:\||\x00\d+!\x7f)\+?))(.*)/,
+		);
+		if (!matches) {
+			push(`\n${outLine}`, top);
+			stack.push(...top ? [top] : []);
+			continue;
+		}
+		const [, closing, row, cell, attr] = matches;
+		if (closing) {
+			while (top.type !== 'table') {
+				top = stack.pop();
+			}
+			top.close(`\n${spaces}${closing}`);
+			push(attr, stack.at(-1));
+		} else if (row) {
+			if (top.type === 'td') {
+				top = stack.pop();
+			}
+			if (top.type === 'tr') {
+				top = stack.pop();
+			}
+			const tr = new TrToken(`\n${spaces}${row}`, attr, config, accum);
+			stack.push(top, tr);
+			top.appendChild(tr);
+		} else {
+			if (top.type === 'td') {
+				top = stack.pop();
+			}
+			const regex = cell === '!'
+				? /!!|(?:\||\x00\d+!\x7f){2}|\x00\d+\+\x7f/g
+				: /(?:\||\x00\d+!\x7f){2}|\x00\d+\+\x7f/g;
+			let mt = regex.exec(attr),
+				lastIndex = 0,
+				lastSyntax = `\n${spaces}${cell}`;
+			while (mt) {
+				const td = new TdToken(lastSyntax, attr.slice(lastIndex, mt.index), config, accum);
+				top.appendChild(td);
+				({lastIndex} = regex);
+				[lastSyntax] = mt;
+				mt = regex.exec(attr);
+			}
+			const td = new TdToken(lastSyntax, attr.slice(lastIndex), config, accum);
+			stack.push(top, td);
+			top.appendChild(td);
+		}
+	}
+	return out.slice(1);
+};
+
+Parser.parsers.parseTable = __filename;
+module.exports = parseTable;