wikiparser-node 0.9.2-b → 0.10.0

package/src/html.js

@@ -0,0 +1,254 @@
+'use strict';
+
+const {generateForSelf} = require('../util/lint'),
+	{noWrap} = require('../util/string'),
+	fixedToken = require('../mixin/fixedToken'),
+	attributeParent = require('../mixin/attributeParent'),
+	Parser = require('..'),
+	Token = require('.');
+
+const magicWords = new Set(['if', 'ifeq', 'ifexpr', 'ifexist', 'iferror', 'switch']);
+
+/**
+ * HTML标签
+ * @classdesc `{childNodes: [AttributesToken]}`
+ */
+class HtmlToken extends attributeParent(fixedToken(Token)) {
+	type = 'html';
+	#closing;
+	#selfClosing;
+	#tag;
+
+	/** getter */
+	get closing() {
+		return this.#closing;
+	}
+
+	/** @throws `Error` 自闭合标签或空标签 */
+	set closing(value) {
+		if (!value) {
+			this.#closing = false;
+			return;
+		} else if (this.#selfClosing) {
+			throw new Error('这是一个自闭合标签！');
+		}
+		const {html: [,, tags]} = this.getAttribute('config');
+		if (tags.includes(this.name)) {
+			throw new Error('这是一个空标签！');
+		}
+		this.#closing = true;
+	}
+
+	/** getter */
+	get selfClosing() {
+		return this.#selfClosing;
+	}
+
+	/** @throws `Error` 闭合标签或无效自闭合标签 */
+	set selfClosing(value) {
+		if (!value) {
+			this.#selfClosing = false;
+			return;
+		} else if (this.#closing) {
+			throw new Error('这是一个闭合标签！');
+		}
+		const {html: [tags]} = this.getAttribute('config');
+		if (tags.includes(this.name)) {
+			throw new Error(`<${this.name}>标签自闭合无效！`);
+		}
+		this.#selfClosing = true;
+	}
+
+	/**
+	 * @param {string} name 标签名
+	 * @param {AttributesToken} attr 标签属性
+	 * @param {boolean} closing 是否闭合
+	 * @param {boolean} selfClosing 是否自封闭
+	 * @param {accum} accum
+	 */
+	constructor(name, attr, closing, selfClosing, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum);
+		this.insertAt(attr);
+		this.setAttribute('name', name.toLowerCase());
+		this.#closing = closing;
+		this.#selfClosing = selfClosing;
+		this.#tag = name;
+	}
+
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		return selector && this.matches(selector)
+			? ''
+			: `<${this.#closing ? '/' : ''}${this.#tag}${super.toString(selector)}${this.#selfClosing ? '/' : ''}>`;
+	}
+
+	/** @override */
+	text() {
+		return `<${this.#closing ? '/' : ''}${this.#tag}${
+			this.#closing ? '' : super.text()
+		}${this.#selfClosing ? '/' : ''}>`;
+	}
+
+	/** @override */
+	getPadding() {
+		return this.#tag.length + (this.#closing ? 2 : 1);
+	}
+
+	/** @override */
+	print() {
+		return super.print({
+			pre: `&lt;${this.#closing ? '/' : ''}${this.#tag}`,
+			post: `${this.#selfClosing ? '/' : ''}&gt;`,
+		});
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = this.getAbsoluteIndex()) {
+		const errors = super.lint(start);
+		let wikitext, /** @type {LintError} */ refError;
+		if (this.name === 'h1' && !this.#closing) {
+			wikitext = String(this.getRootNode());
+			refError = generateForSelf(this, {start}, '<h1>');
+			errors.push({...refError, excerpt: wikitext.slice(start, start + 50)});
+		}
+		if (this.closest('table-attrs')) {
+			wikitext ||= String(this.getRootNode());
+			refError ||= generateForSelf(this, {start}, '');
+			const excerpt = wikitext.slice(Math.max(0, start - 25), start + 25);
+			errors.push({...refError, message: Parser.msg('HTML tag in table attributes'), excerpt});
+		}
+		try {
+			this.findMatchingTag();
+		} catch ({message: errorMsg}) {
+			wikitext ||= String(this.getRootNode());
+			refError ||= generateForSelf(this, {start}, '');
+			const [msg] = errorMsg.split(':'),
+				error = {...refError, message: Parser.msg(msg)};
+			if (msg === 'unclosed tag') {
+				error.severity = 'warning';
+				error.excerpt = wikitext.slice(start, start + 50);
+			} else if (msg === 'unmatched closing tag') {
+				const end = start + String(this).length;
+				error.excerpt = wikitext.slice(Math.max(0, end - 50), end);
+				if (magicWords.has(this.closest('magic-word')?.name)) {
+					error.severity = 'warning';
+				}
+			}
+			errors.push(error);
+		}
+		return errors;
+	}
+
+	/**
+	 * 搜索匹配的标签
+	 * @complexity `n`
+	 * @throws `SyntaxError` 同时闭合和自封闭的标签
+	 * @throws `SyntaxError` 无效自封闭标签
+	 * @throws `SyntaxError` 未闭合的标签
+	 */
+	findMatchingTag() {
+		const {html} = this.getAttribute('config'),
+			{name: tagName, parentNode} = this,
+			string = noWrap(String(this));
+		if (this.#closing && (this.#selfClosing || html[2].includes(tagName))) {
+			throw new SyntaxError(`tag that is both closing and self-closing: ${string}`);
+		} else if (html[2].includes(tagName) || this.#selfClosing && html[1].includes(tagName)) { // 自封闭标签
+			return this;
+		} else if (this.#selfClosing && html[0].includes(tagName)) {
+			throw new SyntaxError(`invalid self-closing tag: ${string}`);
+		} else if (!parentNode) {
+			return undefined;
+		}
+		const {childNodes} = parentNode,
+			i = childNodes.indexOf(this),
+			siblings = this.#closing
+				? childNodes.slice(0, i).reverse().filter(({type, name}) => type === 'html' && name === tagName)
+				: childNodes.slice(i + 1).filter(({type, name}) => type === 'html' && name === tagName);
+		let imbalance = this.#closing ? -1 : 1;
+		for (const token of siblings) {
+			if (token.closing) {
+				imbalance--;
+			} else {
+				imbalance++;
+			}
+			if (imbalance === 0) {
+				return token;
+			}
+		}
+		throw new SyntaxError(`${this.#closing ? 'unmatched closing' : 'unclosed'} tag: ${string}`);
+	}
+
+	/** @override */
+	cloneNode() {
+		const [attr] = this.cloneChildNodes(),
+			config = this.getAttribute('config');
+		return Parser.run(() => new HtmlToken(this.#tag, attr, this.#closing, this.#selfClosing, config));
+	}
+
+	/**
+	 * @override
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		return key === 'tag' ? this.#tag : super.getAttribute(key);
+	}
+
+	/**
+	 * 更换标签名
+	 * @param {string} tag 标签名
+	 * @throws `RangeError` 非法的HTML标签
+	 */
+	replaceTag(tag) {
+		const name = tag.toLowerCase();
+		if (!this.getAttribute('config').html.flat().includes(name)) {
+			throw new RangeError(`非法的HTML标签：${tag}`);
+		}
+		this.setAttribute('name', name).#tag = tag;
+	}
+
+	/** 局部闭合 */
+	#localMatch() {
+		this.#selfClosing = false;
+		const root = Parser.parse(`</${this.name}>`, false, 3, this.getAttribute('config'));
+		this.after(root.firstChild);
+	}
+
+	/**
+	 * 修复无效自封闭标签
+	 * @complexity `n`
+	 * @throws `Error` 无法修复无效自封闭标签
+	 */
+	fix() {
+		const config = this.getAttribute('config'),
+			{parentNode, name: tagName, firstChild} = this;
+		if (!parentNode || !this.#selfClosing || !config.html[0].includes(tagName)) {
+			return;
+		} else if (firstChild.text().trim()) {
+			this.#localMatch();
+			return;
+		}
+		const {childNodes} = parentNode,
+			i = childNodes.indexOf(this),
+			/** @type {HtmlToken[]} */
+			prevSiblings = childNodes.slice(0, i).filter(({type, name}) => type === 'html' && name === tagName),
+			imbalance = prevSiblings.reduce((acc, {closing}) => acc + (closing ? 1 : -1), 0);
+		if (imbalance < 0) {
+			this.#selfClosing = false;
+			this.#closing = true;
+		} else {
+			Parser.warn('无法修复无效自封闭标签', noWrap(String(this)));
+			throw new Error(`无法修复无效自封闭标签：前文共有 ${imbalance} 个未匹配的闭合标签`);
+		}
+	}
+}
+
+Parser.classes.HtmlToken = __filename;
+module.exports = HtmlToken;

package/src/imageParameter.js

@@ -0,0 +1,303 @@
+'use strict';
+
+const {text, noWrap, print, extUrlChar, extUrlCharFirst} = require('../util/string'),
+	{generateForSelf} = require('../util/lint'),
+	Title = require('../lib/title'),
+	Parser = require('..'),
+	AstText = require('../lib/text'),
+	Token = require('.');
+
+const params = new Set(['alt', 'link', 'lang', 'page', 'caption']);
+
+/**
+ * 检查图片参数是否合法
+ * @template {string} T
+ * @param {T} key 参数名
+ * @param {string} val 参数值
+ * @returns {T extends 'link' ? string|Title : boolean}
+ */
+const validate = (key, val, config = Parser.getConfig(), halfParsed = false) => {
+	val = val.trim();
+	let value = val.replace(/\0\d+t\x7F/gu, '').trim();
+	switch (key) {
+		case 'width':
+			return /^(?:\d+x?|\d*x\d+)$/u.test(value);
+		case 'link': {
+			if (!value) {
+				return val;
+			}
+			const regex = new RegExp(
+				`^(?:(?:${config.protocol}|//)${extUrlCharFirst}|\0\\d+m\x7F)${extUrlChar}$`,
+				'iu',
+			);
+			if (regex.test(value)) {
+				return val;
+			} else if (value.startsWith('[[') && value.endsWith(']]')) {
+				value = value.slice(2, -2);
+			}
+			const title = Parser.normalizeTitle(value, 0, false, config, halfParsed, true, true);
+			return title.valid && title;
+		}
+		case 'lang':
+			return config.variants.includes(value);
+		case 'alt':
+		case 'class':
+		case 'manualthumb':
+			return true;
+		default:
+			return !isNaN(value);
+	}
+};
+
+/**
+ * 图片参数
+ * @classdesc `{childNodes: ...(AstText|Token)}`
+ */
+class ImageParameterToken extends Token {
+	type = 'image-parameter';
+	#syntax = '';
+
+	/** 图片链接 */
+	get link() {
+		return this.name === 'link' ? validate('link', super.text(), this.getAttribute('config')) : undefined;
+	}
+
+	set link(value) {
+		if (this.name === 'link') {
+			this.setValue(value);
+		}
+	}
+
+	/** getValue()的getter */
+	get value() {
+		return this.getValue();
+	}
+
+	set value(value) {
+		this.setValue(value);
+	}
+
+	/** 图片大小 */
+	get size() {
+		if (this.name === 'width') {
+			const /** @type {string} */ size = this.getValue().trim();
+			if (!size.includes('{{')) {
+				const [width, height = ''] = size.split('x');
+				return {width, height};
+			}
+			const /** @type {{childNodes: AstText[]}} */ token = Parser.parse(size, false, 2, this.getAttribute('config')),
+				i = token.childNodes.findIndex(({type, data}) => type === 'text' && data.includes('x')),
+				str = token.childNodes[i];
+			if (i === -1) {
+				return {width: size, height: ''};
+			}
+			str.splitText(str.data.indexOf('x'));
+			str.nextSibling.splitText(1);
+			return {width: text(token.childNodes.slice(0, i + 1)), height: text(token.childNodes.slice(i + 2))};
+		}
+		return undefined;
+	}
+
+	/** 图片宽度 */
+	get width() {
+		return this.size?.width;
+	}
+
+	set width(width) {
+		if (this.name === 'width') {
+			const {height} = this;
+			this.setValue(`${String(width || '')}${height && 'x'}${height}`);
+		}
+	}
+
+	/** 图片高度 */
+	get height() {
+		return this.size?.height;
+	}
+
+	set height(height) {
+		height = String(height || '');
+		if (this.name === 'width') {
+			this.setValue(`${this.width}${height && 'x'}${height}`);
+		}
+	}
+
+	/**
+	 * @param {string} str 图片参数
+	 * @param {accum} accum
+	 */
+	constructor(str, config = Parser.getConfig(), accum = []) {
+		let mt;
+		const regexes = Object.entries(config.img).map(
+				/** @returns {[string, string, RegExp]} */
+				([syntax, param]) => [syntax, param, new RegExp(`^(\\s*)${syntax.replace('$1', '(.*)')}(\\s*)$`, 'u')],
+			),
+			param = regexes.find(([, key, regex]) => {
+				mt = regex.exec(str);
+				return mt && (mt.length !== 4 || validate(key, mt[2], config, true) !== false);
+			});
+		if (param) {
+			if (mt.length === 3) {
+				super(undefined, config, true, accum);
+				this.#syntax = str;
+			} else {
+				super(mt[2], config, true, accum, {
+					'Stage-2': ':', '!HeadingToken': ':',
+				});
+				this.#syntax = `${mt[1]}${param[0]}${mt[3]}`;
+			}
+			this.setAttribute('name', param[1]);
+			return;
+		}
+		super(str, {...config, excludes: [...config.excludes, 'list']}, true, accum);
+		this.setAttribute('name', 'caption').setAttribute('stage', 7);
+	}
+
+	/** @override */
+	afterBuild() {
+		if (this.parentNode.type === 'gallery-image' && !params.has(this.name)) {
+			this.setAttribute('name', 'invalid');
+		}
+	}
+
+	/** @override */
+	isPlain() {
+		return this.name === 'caption';
+	}
+
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		return this.#syntax && !(selector && this.matches(selector))
+			? this.#syntax.replace('$1', super.toString(selector))
+			: super.toString(selector);
+	}
+
+	/** @override */
+	text() {
+		return this.#syntax ? this.#syntax.replace('$1', super.text()).trim() : super.text().trim();
+	}
+
+	/** @override */
+	getPadding() {
+		return Math.max(0, this.#syntax.indexOf('$1'));
+	}
+
+	/**
+	 * @override
+	 * @this {ImageParameterToken & {link: Title}}
+	 * @param {number} start 起始位置
+	 */
+	lint(start = this.getAbsoluteIndex()) {
+		const errors = super.lint(start);
+		if (this.name === 'invalid') {
+			errors.push(generateForSelf(this, {start}, 'invalid gallery image parameter'));
+		} else if (this.link?.encoded) {
+			errors.push(generateForSelf(this, {start}, 'unnecessary URL encoding in an internal link'));
+		}
+		return errors;
+	}
+
+	/** @override */
+	print() {
+		return this.#syntax
+			? `<span class="wpb-image-parameter">${
+				this.#syntax.replace('$1', `<span class="wpb-image-caption">${print(this.childNodes)}</span>`)
+			}</span>`
+			: super.print({class: 'image-caption'});
+	}
+
+	/** @override */
+	cloneNode() {
+		const cloned = this.cloneChildNodes(),
+			config = this.getAttribute('config');
+		return Parser.run(() => {
+			const token = new ImageParameterToken(this.#syntax.replace('$1', ''), config);
+			token.replaceChildren(...cloned);
+			return token;
+		});
+	}
+
+	/**
+	 * @override
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		return key === 'syntax' ? this.#syntax : super.getAttribute(key);
+	}
+
+	/**
+	 * @override
+	 * @param {PropertyKey} key 属性键
+	 */
+	hasAttribute(key) {
+		return key === 'syntax' || super.hasAttribute(key);
+	}
+
+	/** 是否是不可变参数 */
+	#isVoid() {
+		return this.#syntax && !this.#syntax.includes('$1');
+	}
+
+	/**
+	 * @override
+	 * @template {Token} T
+	 * @param {T} token 待插入的子节点
+	 * @param {number} i 插入位置
+	 * @complexity `n`
+	 * @throws `Error` 不接受自定义输入的图片参数
+	 */
+	insertAt(token, i = this.length) {
+		if (!Parser.running && this.#isVoid()) {
+			throw new Error(`图片参数 ${this.name} 不接受自定义输入！`);
+		}
+		return super.insertAt(token, i);
+	}
+
+	/**
+	 * 获取参数值
+	 * @complexity `n`
+	 */
+	getValue() {
+		return this.name === 'invalid' ? this.text() : this.#isVoid() || super.text();
+	}
+
+	/**
+	 * 设置参数值
+	 * @param {string|boolean} value 参数值
+	 * @complexity `n`
+	 * @throws	SyntaxError` 非法的参数值
+	 */
+	setValue(value) {
+		if (this.name === 'invalid') {
+			throw new Error('无效的图片参数！');
+		} else if (this.#isVoid()) {
+			if (typeof value !== 'boolean') {
+				this.typeError('setValue', 'Boolean');
+			} else if (value === false) {
+				this.remove();
+			}
+			return;
+		} else if (typeof value !== 'string') {
+			this.typeError('setValue', 'String');
+		}
+		const root = Parser.parse(`[[File:F|${
+				this.#syntax ? this.#syntax.replace('$1', value) : value
+			}]]`, this.getAttribute('include'), 6, this.getAttribute('config')),
+			{length, firstChild: file} = root,
+			{lastChild: imageParameter, type, name, length: fileLength} = file;
+		if (length !== 1 || type !== 'file' || name !== 'File:F' || fileLength !== 2
+			|| imageParameter.name !== this.name
+		) {
+			throw new SyntaxError(`非法的 ${this.name} 参数：${noWrap(value)}`);
+		}
+		this.replaceChildren(...imageParameter.childNodes);
+	}
+}
+
+Parser.classes.ImageParameterToken = __filename;
+module.exports = ImageParameterToken;