wikiparser-node 0.11.0-m → 0.11.0

package/parser/selector.js

@@ -0,0 +1,180 @@
+'use strict';
+
+/** @typedef {import('../typings/parser').SelectorArray} SelectorArray */
+/** @typedef {import('../typings/parser').pseudo} pseudo */
+
+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

@@ -110,4 +110,5 @@ const parseTable = ({firstChild: {data}, type, name}, config = Parser.getConfig(
 	return out.slice(1);
 };
 
+Parser.parsers.parseTable = __filename;
 module.exports = parseTable;

package/src/arg.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const {text} = require('../util/string'),
+const {text, noWrap} = require('../util/string'),
 	{generateForSelf, generateForChild} = require('../util/lint'),
 	Parser = require('..'),
 	Token = require('.');
@@ -24,11 +24,13 @@ class ArgToken extends Token {
 	 */
 	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 {
@@ -37,13 +39,15 @@ class ArgToken extends Token {
 				super.insertAt(token.setAttribute('stage', 2));
 			}
 		}
+		this.getAttribute('protectChildren')(0);
 	}
 
 	/**
 	 * @override
+	 * @param {string} selector
 	 */
 	toString(selector) {
-		return `{{{${super.toString(selector, '|')}}}}`;
+		return selector && this.matches(selector) ? '' : `{{{${super.toString(selector, '|')}}}}`;
 	}
 
 	/**
@@ -64,6 +68,11 @@ class ArgToken extends Token {
 		return 1;
 	}
 
+	/** @override */
+	print() {
+		return super.print({pre: '{{{', post: '}}}', sep: '|'});
+	}
+
 	/**
 	 * @override
 	 * @param {number} start 起始位置
@@ -88,6 +97,111 @@ class ArgToken extends Token {
 		}
 		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 {import('../typings/event').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();
+		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();
+		if (oldDefault) {
+			oldDefault.safeReplaceWith(lastChild);
+		} else {
+			this.insertAt(lastChild);
+		}
+	}
 }
 
+Parser.classes.ArgToken = __filename;
 module.exports = ArgToken;

package/src/atom/hidden.js

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

package/src/atom/index.js

@@ -14,6 +14,7 @@ class AtomToken extends Token {
 	 * @param {string} wikitext wikitext
 	 * @param {string|undefined} type Token.type
 	 * @param {import('../../typings/token').accum} accum
+	 * @param {import('../../typings/token').acceptable} acceptable 可接受的子节点设置
 	 */
 	constructor(wikitext, type, config = Parser.getConfig(), accum = [], acceptable = undefined) {
 		super(wikitext, config, true, accum, acceptable);
@@ -21,6 +22,22 @@ class AtomToken extends Token {
 			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;

package/src/attribute.js

@@ -3,12 +3,16 @@
 /** @typedef {import('../typings/token').ParserConfig} ParserConfig */
 
 const {generateForChild} = require('../util/lint'),
-	{removeComment} = require('../util/string'),
+	{noWrap, removeComment} = require('../util/string'),
+	fixedToken = require('../mixin/fixedToken'),
 	Parser = require('..'),
 	Token = require('.'),
 	AtomToken = require('./atom');
 
-const commonHtmlAttrs = new Set([
+const stages = {'ext-attr': 0, 'html-attr': 2, 'table-attr': 3},
+	pre = {'ext-attr': '<pre ', 'html-attr': '<p ', 'table-attr': '{|'},
+	post = {'ext-attr': '/>', 'html-attr': '>', 'table-attr': ''},
+	commonHtmlAttrs = new Set([
 		'id',
 		'class',
 		'style',
@@ -107,6 +111,37 @@ const commonHtmlAttrs = new Set([
 		poll: new Set(['id', 'show-results-before-voting']),
 		sm2: typeAttrs,
 		flashmp3: typeAttrs,
+		score: new Set([
+			'line_width_inches',
+			'lang',
+			'override_midi',
+			'raw',
+			'note-language',
+			'override_audio',
+			'override_ogg',
+			'sound',
+			'vorbis',
+		]),
+		seo: new Set([
+			'title',
+			'title_mode',
+			'title_separator',
+			'keywords',
+			'description',
+			'robots',
+			'google_bot',
+			'image',
+			'image_width',
+			'image_height',
+			'image_alt',
+			'type',
+			'site_name',
+			'locale',
+			'section',
+			'author',
+			'published_time',
+			'twitter_site',
+		]),
 		tab: new Set([
 			'nested',
 			'name',
@@ -144,7 +179,7 @@ const commonHtmlAttrs = new Set([
  * 扩展和HTML标签属性
  * @classdesc `{childNodes: [AtomToken, Token|AtomToken]}`
  */
-class AttributeToken extends Token {
+class AttributeToken extends fixedToken(Token) {
 	#equal;
 	#quotes;
 	#tag;
@@ -159,6 +194,10 @@ class AttributeToken extends Token {
 		return this.getValue();
 	}
 
+	set value(value) {
+		this.setValue(value);
+	}
+
 	/** 标签名 */
 	get tag() {
 		return this.#tag;
@@ -175,23 +214,36 @@ class AttributeToken extends Token {
 	 */
 	constructor(type, tag, key, equal = '', value = '', quotes = [], config = Parser.getConfig(), accum = []) {
 		const keyToken = new AtomToken(key, 'attr-key', config, accum, {
+			[type === 'ext-attr' ? 'AstText' : 'Stage-1']: ':', ArgToken: ':', TranscludeToken: ':',
 		});
 		let valueToken;
 		if (key === 'title') {
 			valueToken = new Token(value, config, true, accum, {
+				[`Stage-${stages[type]}`]: ':', ConverterToken: ':',
 			}).setAttribute('type', 'attr-value').setAttribute('stage', Parser.MAX_STAGE - 1);
 		} else if (tag === 'gallery' && key === 'caption') {
 			/** @type {ParserConfig} */
 			const newConfig = {...config, excludes: [...config.excludes, 'quote', 'extLink', 'magicLink', 'list']};
 			valueToken = new Token(value, newConfig, true, accum, {
+				AstText: ':', LinkToken: ':', FileToken: ':', CategoryToken: ':', ConverterToken: ':',
 			}).setAttribute('type', 'attr-value').setAttribute('stage', 5);
 		} else if (tag === 'choose' && (key === 'before' || key === 'after')) {
 			/** @type {ParserConfig} */
 			const newConfig = {...config, excludes: [...config.excludes, 'heading', 'html', 'table', 'hr', 'list']};
 			valueToken = new Token(value, newConfig, true, accum, {
+				ArgToken: ':',
+				TranscludeToken: ':',
+				LinkToken: ':',
+				FileToken: ':',
+				CategoryToken: ':',
+				QuoteToken: ':',
+				ExtLinkToken: ':',
+				MagicLinkToken: ':',
+				ConverterToken: ':',
 			}).setAttribute('type', 'attr-value').setAttribute('stage', 1);
 		} else {
 			valueToken = new AtomToken(value, 'attr-value', config, accum, {
+				[`Stage-${stages[type]}`]: ':',
 			});
 		}
 		super(undefined, config, true, accum);
@@ -216,9 +268,13 @@ class AttributeToken extends Token {
 
 	/**
 	 * @override
+	 * @param {string} selector
 	 * @returns {string}
 	 */
 	toString(selector) {
+		if (selector && this.matches(selector)) {
+			return '';
+		}
 		const [quoteStart = '', quoteEnd = ''] = this.#quotes;
 		return this.#equal
 			? `${super.toString(selector, `${this.#equal}${quoteStart}`)}${quoteEnd}`
@@ -238,6 +294,12 @@ class AttributeToken extends Token {
 		return this.#equal ? this.#equal.length + (this.#quotes[0]?.length ?? 0) : 0;
 	}
 
+	/** @override */
+	print() {
+		const [quoteStart = '', quoteEnd = ''] = this.#quotes;
+		return this.#equal ? super.print({sep: `${this.#equal}${quoteStart}`, post: quoteEnd}) : super.print();
+	}
+
 	/**
 	 * @override
 	 * @param {number} start 起始位置
@@ -281,6 +343,130 @@ class AttributeToken extends Token {
 		}
 		return true;
 	}
+
+	/**
+	 * @override
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @returns {import('../typings/node').TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		if (key === 'equal') {
+			return this.#equal;
+		}
+		return key === 'quotes' ? this.#quotes : super.getAttribute(key);
+	}
+
+	/**
+	 * @override
+	 * @param {PropertyKey} key 属性键
+	 */
+	hasAttribute(key) {
+		return key === 'equal' || key === 'quotes' || super.hasAttribute(key);
+	}
+
+	/** @override */
+	cloneNode() {
+		const [key, value] = this.cloneChildNodes(),
+			config = this.getAttribute('config');
+		return Parser.run(() => {
+			const token = new AttributeToken(this.type, this.#tag, '', this.#equal, '', this.#quotes, config);
+			token.firstChild.safeReplaceWith(key);
+			token.lastChild.safeReplaceWith(value);
+			token.afterBuild();
+			return token;
+		});
+	}
+
+	/** 转义等号 */
+	escape() {
+		this.#equal = '{{=}}';
+	}
+
+	/** 闭合引号 */
+	close() {
+		[this.#quotes[1]] = this.#quotes;
+	}
+
+	/**
+	 * 设置属性值
+	 * @param {string|boolean} value 参数值
+	 * @throws `SyntaxError` 非法的标签属性
+	 */
+	setValue(value) {
+		if (value === false) {
+			this.remove();
+			return;
+		} else if (value === true) {
+			this.#equal = '';
+			return;
+		}
+		value = String(value);
+		const {type} = this,
+			key = this.name === 'title' ? 'title' : 'data',
+			wikitext = `${pre[type]}${key}="${value}"${post[type]}`,
+			root = Parser.parse(wikitext, this.getAttribute('include'), stages[type] + 1, this.getAttribute('config')),
+			{length, firstChild: tag} = root;
+		let attrs;
+		if (length !== 1 || tag.type !== type.slice(0, -5)) {
+			throw new SyntaxError(`非法的标签属性：${noWrap(value)}`);
+		} else if (type === 'table-attr') {
+			if (tag.length !== 2) {
+				throw new SyntaxError(`非法的标签属性：${noWrap(value)}`);
+			}
+			attrs = tag.lastChild;
+		} else {
+			attrs = tag.firstChild;
+		}
+		const {length: attrsLength, firstChild} = attrs;
+		if (attrsLength !== 1 || firstChild.type !== this.type || firstChild.name !== key) {
+			throw new SyntaxError(`非法的标签属性：${noWrap(value)}`);
+		}
+		const {lastChild} = firstChild;
+		firstChild.destroy();
+		this.lastChild.safeReplaceWith(lastChild);
+		if (this.#quotes[0]) {
+			this.close();
+		} else {
+			this.#quotes = ['"', '"'];
+		}
+	}
+
+	/**
+	 * 修改属性名
+	 * @param {string} key 新属性名
+	 * @throws `Error` title属性不能更名
+	 * @throws `SyntaxError` 非法的模板参数名
+	 */
+	rename(key) {
+		if (this.name === 'title') {
+			throw new Error('title 属性不能更名！');
+		}
+		key = String(key);
+		const {type} = this,
+			wikitext = `${pre[type]}${key}${post[type]}`,
+			root = Parser.parse(wikitext, this.getAttribute('include'), stages[type] + 1, this.getAttribute('config')),
+			{length, firstChild: tag} = root;
+		let attrs;
+		if (length !== 1 || tag.type !== type.slice(0, -5)) {
+			throw new SyntaxError(`非法的标签属性名：${noWrap(key)}`);
+		} else if (type === 'table-attr') {
+			if (tag.length !== 2) {
+				throw new SyntaxError(`非法的标签属性名：${noWrap(key)}`);
+			}
+			attrs = tag.lastChild;
+		} else {
+			attrs = tag.firstChild;
+		}
+		const {length: attrsLength, firstChild: attr} = attrs;
+		if (attrsLength !== 1 || attr.type !== this.type || attr.value !== true) {
+			throw new SyntaxError(`非法的标签属性名：${noWrap(key)}`);
+		}
+		const {firstChild} = attr;
+		attr.destroy();
+		this.firstChild.safeReplaceWith(firstChild);
+	}
 }
 
+Parser.classes.AttributeToken = __filename;
 module.exports = AttributeToken;