wikiparser-node 0.9.2-b → 0.10.0

package/parser/magicLinks.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const {extUrlChar, extUrlCharFirst} = require('../util/string'),
+	Parser = require('..'),
+	MagicLinkToken = require('../src/magicLink');
+
+/**
+ * 解析自由外链
+ * @param {string} wikitext wikitext
+ * @param {accum} accum
+ */
+const parseMagicLinks = (wikitext, config = Parser.getConfig(), accum = []) => {
+	const regex = new RegExp(`(?<![\\p{L}\\d_])(?:${config.protocol})(${extUrlCharFirst}${extUrlChar})`, 'giu');
+	return wikitext.replace(regex, /** @param {string} p1 */ (m, p1) => {
+		let trail = '',
+			url = m;
+		const m2 = /&(?:lt|gt|nbsp|#x0*(?:3[ce]|a0)|#0*(?:6[02]|160));/iu.exec(url);
+		if (m2) {
+			trail = url.slice(m2.index);
+			url = url.slice(0, m2.index);
+		}
+		const sep = new RegExp(`[,;.:!?${url.includes('(') ? '' : ')'}]+$`, 'u'),
+			sepChars = sep.exec(url);
+		if (sepChars) {
+			let correction = 0;
+			if (sepChars[0][0] === ';' && /&(?:[a-z]+|#x[\da-f]+|#\d+)$/iu.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 `\0${accum.length - 1}w\x7F${trail}`;
+	});
+};
+
+Parser.parsers.parseMagicLinks = __filename;
+module.exports = parseMagicLinks;

package/parser/quotes.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const Parser = require('..'),
+	QuoteToken = require('../src/nowiki/quote');
+
+/**
+ * 解析单引号
+ * @param {string} text wikitext
+ * @param {accum} accum
+ */
+const parseQuotes = (text, config = Parser.getConfig(), accum = []) => {
+	const arr = text.split(/('{2,})/u),
+		{length} = arr;
+	if (length === 1) {
+		return text;
+	}
+	let nBold = 0,
+		nItalic = 0,
+		firstSingle, firstMulti, firstSpace;
+	for (let i = 1; i < length; i += 2) {
+		const {length: len} = arr[i];
+		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].endsWith(' ')) {
+					if (!firstMulti && !firstSpace) {
+						firstSpace = i;
+					}
+				} else if (arr[i - 1].at(-2) === ' ') {
+					firstSingle = i;
+				} else {
+					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] += `'`;
+	}
+	for (let i = 1; i < length; i += 2) {
+		new QuoteToken(arr[i].length, config, accum);
+		arr[i] = `\0${accum.length - 1}q\x7F`;
+	}
+	return arr.join('');
+};
+
+Parser.parsers.parseQuotes = __filename;
+module.exports = parseQuotes;

package/parser/selector.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const Parser = require('..');
+
+const /** @type {Set<pseudo>} */ simplePseudos = new Set([
+		'root',
+		'first-child',
+		'first-of-type',
+		'last-child',
+		'last-of-type',
+		'only-child',
+		'only-of-type',
+		'empty',
+		'parent',
+		'header',
+		'hidden',
+		'visible',
+		'only-whitespace',
+		'local-link',
+		'read-only',
+		'read-write',
+		'invalid',
+		'required',
+		'optional',
+	]),
+	/** @type {pseudo[]} */ complexPseudos = [
+		'is',
+		'not',
+		'nth-child',
+		'nth-of-type',
+		'nth-last-child',
+		'nth-last-of-type',
+		'contains',
+		'has',
+		'lang',
+	],
+	specialChars = [
+		['[', '&lbrack;'],
+		[']', '&rbrack;'],
+		['(', '&lpar;'],
+		[')', '&rpar;'],
+		['"', '&quot;'],
+		[`'`, '&apos;'],
+		[':', '&colon;'],
+		['\\', '&bsol;'],
+		['&', '&amp;'],
+	],
+	pseudoRegex = new RegExp(`:(${complexPseudos.join('|')})$`, 'u'),
+	regularRegex = /[[(,>+~]|\s+/u,
+	attributeRegex = /^\s*(\w+)\s*(?:([~|^$*!]?=)\s*("[^"]*"|'[^']*'|[^\s[\]]+)(?:\s+(i))?\s*)?\]/u,
+	functionRegex = /^(\s*"[^"]*"\s*|\s*'[^']*'\s*|[^()]*)\)/u,
+	grouping = new Set([',', '>', '+', '~']),
+	combinator = new Set(['>', '+', '~', '']);
+
+/**
+ * 清理转义符号
+ * @param {string} selector
+ */
+const sanitize = selector => {
+	for (const [c, escaped] of specialChars) {
+		selector = selector.replaceAll(`\\${c}`, escaped);
+	}
+	return selector;
+};
+
+/**
+ * 还原转义符号
+ * @param {string|undefined} selector
+ */
+const desanitize = selector => {
+	if (selector === undefined) {
+		return undefined;
+	}
+	for (const [c, escaped] of specialChars) {
+		selector = selector.replaceAll(escaped, c);
+	}
+	return selector.trim();
+};
+
+/**
+ * 去除首尾的引号
+ * @param {string|undefined} val 属性值或伪选择器函数的参数
+ */
+const deQuote = val => {
+	if (val === undefined) {
+		return undefined;
+	}
+	const quotes = /^(["']).*\1$/u.exec(val)?.[1];
+	return quotes ? val.slice(1, -1) : val;
+};
+
+/**
+ * 解析简单伪选择器
+ * @param {SelectorArray} step 当前顶部
+ * @param {string} str 不含属性和复杂伪选择器的语句
+ * @throws `SyntaxError` 非法的选择器
+ */
+const pushSimple = (step, str) => {
+	const pieces = str.trim().split(':'),
+		// eslint-disable-next-line unicorn/explicit-length-check
+		i = pieces.slice(1).findIndex(pseudo => simplePseudos.has(pseudo)) + 1 || pieces.length;
+	if (pieces.slice(i).some(pseudo => !simplePseudos.has(pseudo))) {
+		throw new SyntaxError(`非法的选择器！\n${str}\n可能需要将':'转义为'\\:'。`);
+	}
+	step.push(desanitize(pieces.slice(0, i).join(':')), ...pieces.slice(i).map(piece => `:${piece}`));
+};
+
+/**
+ * 解析选择器
+ * @param {string} selector
+ * @throws `SyntaxError` 非法的选择器
+ */
+const parseSelector = selector => {
+	selector = selector.trim();
+	const /** @type {SelectorArray[][]} */ stack = [[[]]];
+	let sanitized = sanitize(selector),
+		regex = regularRegex,
+		mt = regex.exec(sanitized),
+		[condition] = stack,
+		[step] = condition;
+	while (mt) {
+		let {0: syntax, index} = mt;
+		if (syntax.trim() === '') {
+			index += syntax.length;
+			const char = sanitized[index];
+			syntax = grouping.has(char) ? char : '';
+		}
+		if (syntax === ',') { // 情形1：并列
+			pushSimple(step, sanitized.slice(0, index));
+			condition = [[]];
+			[step] = condition;
+			stack.push(condition);
+		} else if (combinator.has(syntax)) { // 情形2：关系
+			pushSimple(step, sanitized.slice(0, index));
+			if (!step.some(Boolean)) {
+				throw new SyntaxError(`非法的选择器！\n${selector}\n可能需要通用选择器'*'。`);
+			}
+			step.relation = syntax;
+			step = [];
+			condition.push(step);
+		} else if (syntax === '[') { // 情形3：属性开启
+			pushSimple(step, sanitized.slice(0, index));
+			regex = attributeRegex;
+		} else if (syntax.endsWith(']')) { // 情形4：属性闭合
+			mt[3] = desanitize(deQuote(mt[3]));
+			step.push(mt.slice(1));
+			regex = regularRegex;
+		} else if (syntax === '(') { // 情形5：伪选择器开启
+			const pseudoExec = pseudoRegex.exec(sanitized.slice(0, index));
+			if (!pseudoExec) {
+				throw new SyntaxError(`非法的选择器！\n${desanitize(sanitized)}\n请检查伪选择器是否存在。`);
+			}
+			pushSimple(step, sanitized.slice(0, pseudoExec.index));
+			step.push(pseudoExec[1]); // 临时存放复杂伪选择器
+			regex = functionRegex;
+		} else { // 情形6：伪选择器闭合
+			const /** @type {pseudo} */ pseudo = step.pop();
+			mt.push(pseudo);
+			mt[1] = deQuote(mt[1]);
+			step.push(mt.slice(1));
+			regex = regularRegex;
+		}
+		sanitized = sanitized.slice(index + syntax.length);
+		if (grouping.has(syntax)) {
+			sanitized = sanitized.trim();
+		}
+		mt = regex.exec(sanitized);
+	}
+	if (regex === regularRegex) {
+		pushSimple(step, sanitized);
+		return stack;
+	}
+	throw new SyntaxError(`非法的选择器！\n${selector}\n检测到未闭合的'${regex === attributeRegex ? '[' : '('}'`);
+};
+
+Parser.parsers.parseSelector = __filename;
+module.exports = parseSelector;

package/parser/table.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const Parser = require('..'),
+	AstText = require('../lib/text'),
+	Token = require('../src'),
+	TableToken = require('../src/table'),
+	TrToken = require('../src/table/tr'),
+	TdToken = require('../src/table/td'),
+	DdToken = require('../src/nowiki/dd');
+
+/**
+ * 解析表格，注意`tr`和`td`包含开头的换行
+ * @param {Token & {firstChild: AstText}} root 根节点
+ * @param {accum} accum
+ */
+const parseTable = ({firstChild: {data}, type, name}, config = Parser.getConfig(), accum = []) => {
+	const /** @type {TrToken[]} */ stack = [],
+		lines = data.split('\n');
+	let out = type === 'root' || type === 'parameter-value' || type === 'ext-inner' && name === 'poem'
+		? ''
+		: `\n${lines.shift()}`;
+
+	/**
+	 * 向表格中插入纯文本
+	 * @param {string} str 待插入的文本
+	 * @param {TrToken} top 当前解析的表格或表格行
+	 */
+	const push = (str, top) => {
+		if (!top) {
+			out += str;
+			return;
+		}
+		const /** @type {Token}} */ {lastChild} = top;
+		if (lastChild.constructor === Token) {
+			lastChild.setText(String(lastChild) + str);
+		} else {
+			const token = new Token(str, config, true, accum);
+			token.type = 'table-inter';
+			top.insertAt(token.setAttribute('stage', 3));
+		}
+	};
+	for (const outLine of lines) {
+		let top = stack.pop();
+		const [spaces] = /^(?:\s|\0\d+c\x7F)*/u.exec(outLine),
+			line = outLine.slice(spaces.length),
+			matchesStart = /^(:*)((?:\s|\0\d+c\x7F)*)(\{\||\{(?:\0\d+c\x7F)*\0\d+!\x7F|\0\d+\{\x7F)(.*)$/u.exec(line);
+		if (matchesStart) {
+			while (top && top.type !== 'td') {
+				top = stack.pop();
+			}
+			const [, indent, moreSpaces, tableSyntax, attr] = matchesStart;
+			if (indent) {
+				new DdToken(indent, config, accum);
+			}
+			push(`\n${spaces}${indent && `\0${accum.length - 1}d\x7F`}${moreSpaces}\0${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 = // eslint-disable-line operator-linebreak
+			/^(?:(\|\}|\0\d+!\x7F\}|\0\d+\}\x7F)|(\|-+|\0\d+!\x7F-+|\0\d+-\x7F-*)(?!-)|(!|(?:\||\0\d+!\x7F)\+?))(.*)$/u
+				.exec(line);
+		if (!matches) {
+			push(`\n${outLine}`, top);
+			stack.push(...top ? [top] : []);
+			continue;
+		}
+		const [, closing, row, cell, attr] = matches;
+		if (closing) {
+			while (!(top instanceof TableToken)) {
+				top = stack.pop();
+			}
+			top.close(`\n${spaces}${closing}`, true);
+			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.insertAt(tr);
+		} else {
+			if (top.type === 'td') {
+				top = stack.pop();
+			}
+			const regex = cell === '!'
+				? /!!|(?:\||\0\d+!\x7F){2}|\0\d+\+\x7F/gu
+				: /(?:\||\0\d+!\x7F){2}|\0\d+\+\x7F/gu;
+			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.insertAt(td);
+				({lastIndex} = regex);
+				[lastSyntax] = mt;
+				mt = regex.exec(attr);
+			}
+			const td = new TdToken(lastSyntax, attr.slice(lastIndex), config, accum);
+			stack.push(top, td);
+			top.insertAt(td);
+		}
+	}
+	return out.slice(1);
+};
+
+Parser.parsers.parseTable = __filename;
+module.exports = parseTable;

package/src/arg.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const {text, noWrap} = require('../util/string'),
+	{generateForSelf, generateForChild} = require('../util/lint'),
+	Parser = require('..'),
+	Token = require('.');
+
+/**
+ * `{{{}}}`包裹的参数
+ * @classdesc `{childNodes: [AtomToken, ?Token, ...HiddenToken]}`
+ */
+class ArgToken extends Token {
+	type = 'arg';
+
+	/** default */
+	get default() {
+		return this.childNodes[1]?.text() ?? false;
+	}
+
+	/**
+	 * @param {string[]} parts 以'|'分隔的各部分
+	 * @param {accum} accum
+	 * @complexity `n`
+	 */
+	constructor(parts, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {
+			AtomToken: 0, Token: 1, HiddenToken: '2:',
+		});
+		for (let i = 0; i < parts.length; i++) {
+			if (i === 0 || i > 1) {
+				const AtomToken = i === 0 ? require('./atom') : require('./atom/hidden');
+				const token = new AtomToken(parts[i], i === 0 ? 'arg-name' : undefined, config, accum, {
+					'Stage-2': ':', '!HeadingToken': '',
+				});
+				super.insertAt(token);
+			} else {
+				const token = new Token(parts[i], config, true, accum);
+				token.type = 'arg-default';
+				super.insertAt(token.setAttribute('stage', 2));
+			}
+		}
+		this.getAttribute('protectChildren')(0);
+	}
+
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		return selector && this.matches(selector) ? '' : `{{{${super.toString(selector, '|')}}}}`;
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	text() {
+		return `{{{${text(this.childNodes.slice(0, 2), '|')}}}}`;
+	}
+
+	/** @override */
+	getPadding() {
+		return 3;
+	}
+
+	/** @override */
+	getGaps() {
+		return 1;
+	}
+
+	/** @override */
+	print() {
+		return super.print({pre: '{{{', post: '}}}', sep: '|'});
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 * @returns {LintError[]}
+	 */
+	lint(start = this.getAbsoluteIndex()) {
+		if (!this.getAttribute('include')) {
+			return [generateForSelf(this, {start}, 'unexpected template argument')];
+		}
+		const {childNodes: [argName, argDefault, ...rest]} = this,
+			errors = argName.lint(start + 3);
+		if (argDefault) {
+			errors.push(...argDefault.lint(start + 4 + String(argName).length));
+		}
+		if (rest.length > 0) {
+			const rect = {start, ...this.getRootNode().posFromIndex(start)};
+			errors.push(...rest.map(child => {
+				const error = generateForChild(child, rect, 'invisible content inside triple brackets'),
+					{startIndex, startCol, excerpt} = error;
+				return {...error, startIndex: startIndex - 1, startCol: startCol - 1, excerpt: `|${excerpt}`};
+			}));
+		}
+		return errors;
+	}
+
+	/** @override */
+	cloneNode() {
+		const [name, ...cloned] = this.cloneChildNodes();
+		return Parser.run(() => {
+			const token = new ArgToken([''], this.getAttribute('config'));
+			token.firstChild.safeReplaceWith(name);
+			token.append(...cloned);
+			token.afterBuild();
+			return token;
+		});
+	}
+
+	/** @override */
+	afterBuild() {
+		this.setAttribute('name', this.firstChild.text().trim());
+		const /** @type {AstListener} */ argListener = ({prevTarget}) => {
+			if (prevTarget === this.firstChild) {
+				this.setAttribute('name', prevTarget.text().trim());
+			}
+		};
+		this.addEventListener(['remove', 'insert', 'replace', 'text'], argListener);
+	}
+
+	/**
+	 * 移除无效部分
+	 * @complexity `n`
+	 */
+	removeRedundant() {
+		Parser.run(() => {
+			for (let i = this.length - 1; i > 1; i--) {
+				super.removeAt(i);
+			}
+		});
+	}
+
+	/**
+	 * 移除子节点，且在移除`arg-default`子节点时自动移除全部多余子节点
+	 * @param {number} i 移除位置
+	 * @returns {Token}
+	 */
+	removeAt(i) {
+		if (i === 1) {
+			this.removeRedundant();
+		}
+		return super.removeAt(i);
+	}
+
+	/**
+	 * @override
+	 * @param {Token} token 待插入的子节点
+	 * @param {number} i 插入位置
+	 * @throws `RangeError` 不可插入多余子节点
+	 */
+	insertAt(token, i = this.length) {
+		const j = i < 0 ? i + this.length : i;
+		if (j > 1) {
+			throw new RangeError(`${this.constructor.name} 不可插入多余的子节点！`);
+		}
+		super.insertAt(token, i);
+		if (j === 1) {
+			token.type = 'arg-default';
+		}
+		return token;
+	}
+
+	/**
+	 * 设置参数名
+	 * @param {string} name 新参数名
+	 * @throws `SyntaxError` 非法的参数名
+	 */
+	setName(name) {
+		name = String(name);
+		const root = Parser.parse(`{{{${name}}}}`, this.getAttribute('include'), 2, this.getAttribute('config')),
+			{length, firstChild: arg} = root;
+		if (length !== 1 || arg.type !== 'arg' || arg.length !== 1) {
+			throw new SyntaxError(`非法的参数名称：${noWrap(name)}`);
+		}
+		const {firstChild} = arg;
+		arg.destroy(true);
+		this.firstChild.safeReplaceWith(firstChild);
+	}
+
+	/**
+	 * 设置预设值
+	 * @param {string} value 预设值
+	 * @throws `SyntaxError` 非法的参数预设值
+	 */
+	setDefault(value) {
+		value = String(value);
+		const root = Parser.parse(`{{{|${value}}}}`, this.getAttribute('include'), 2, this.getAttribute('config')),
+			{length, firstChild: arg} = root;
+		if (length !== 1 || arg.type !== 'arg' || arg.length !== 2) {
+			throw new SyntaxError(`非法的参数预设值：${noWrap(value)}`);
+		}
+		const {childNodes: [, oldDefault]} = this,
+			{lastChild} = arg;
+		arg.destroy(true);
+		if (oldDefault) {
+			oldDefault.safeReplaceWith(lastChild);
+		} else {
+			this.insertAt(lastChild);
+		}
+	}
+}
+
+Parser.classes.ArgToken = __filename;
+module.exports = ArgToken;

package/src/atom/hidden.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const hidden = require('../../mixin/hidden'),
+	Parser = require('../..'),
+	AtomToken = require('.');
+
+/** 不可见的节点 */
+class HiddenToken extends hidden(AtomToken) {
+	type = 'hidden';
+}
+
+Parser.classes.HiddenToken = __filename;
+module.exports = HiddenToken;

package/src/atom/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const Parser = require('../..'),
+	Token = require('..');
+
+/**
+ * 不会被继续解析的plain Token
+ * @classdesc `{childNodes: ...AstText|Token}`
+ */
+class AtomToken extends Token {
+	type = 'plain';
+
+	/**
+	 * @param {string} wikitext wikitext
+	 * @param {string|undefined} type Token.type
+	 * @param {accum} accum
+	 * @param {acceptable} acceptable 可接受的子节点设置
+	 */
+	constructor(wikitext, type, config = Parser.getConfig(), accum = [], acceptable = undefined) {
+		super(wikitext, config, true, accum, acceptable);
+		if (type) {
+			this.type = type;
+		}
+	}
+
+	/**
+	 * @override
+	 * @this {AtomToken & {constructor: typeof AtomToken}}
+	 */
+	cloneNode() {
+		const cloned = this.cloneChildNodes(),
+			config = this.getAttribute('config'),
+			acceptable = this.getAttribute('acceptable');
+		return Parser.run(() => {
+			const token = new this.constructor(undefined, this.type, config, [], acceptable);
+			token.append(...cloned);
+			return token;
+		});
+	}
+}
+
+Parser.classes.AtomToken = __filename;
+module.exports = AtomToken;