wikiparser-node 0.8.0-b → 0.8.0-m

package/src/nowiki/quote.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const {generateForSelf} = require('../../util/lint'),
+	Parser = require('../..'),
+	AstText = require('../../lib/text'),
+	NowikiToken = require('.');
+
+/**
+ * `<hr>`
+ * @classdesc `{childNodes: [AstText]}`
+ */
+class QuoteToken extends NowikiToken {
+	type = 'quote';
+
+	/**
+	 * @param {number} n 字符串长度
+	 * @param {accum} accum
+	 */
+	constructor(n, config = Parser.getConfig(), accum = []) {
+		super(`'`.repeat(n), config, accum);
+	}
+
+	/**
+	 * @override
+	 * @this {AstText}
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const {previousSibling, nextSibling} = this,
+			message = `孤立的"'"`,
+			/** @type {LintError[]} */ errors = [];
+		let refError, wikitext;
+		if (previousSibling?.type === 'text' && previousSibling.data.endsWith(`'`)) {
+			refError = generateForSelf(this, {start}, message);
+			wikitext = String(this.getRootNode());
+			const {startIndex: endIndex, startLine: endLine, startCol: endCol} = refError,
+				[, {length}] = previousSibling.data.match(/(?:^|[^'])('+)$/u),
+				startIndex = start - length,
+				excerpt = wikitext.slice(startIndex, startIndex + 50);
+			errors.push({...refError, startIndex, endIndex, startCol: endCol - length, endLine, endCol, excerpt});
+		}
+		if (nextSibling?.type === 'text' && nextSibling.data[0] === `'`) {
+			refError ||= generateForSelf(this, {start}, message);
+			wikitext ||= String(this.getRootNode());
+			const {endIndex: startIndex, endLine: startLine, endCol: startCol} = refError,
+				[{length}] = nextSibling.data.match(/^'+/u),
+				endIndex = startIndex + length,
+				excerpt = wikitext.slice(Math.max(0, endIndex - 50), endIndex);
+			errors.push({...refError, startIndex, endIndex, startLine, startCol, endCol: startCol + length, excerpt});
+		}
+		return errors;
+	}
+}
+
+module.exports = QuoteToken;

package/src/onlyinclude.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 嵌入时的`<onlyinclude>`
+ * @classdesc `{childNodes: ...AstText|Token}`
+ */
+class OnlyincludeToken extends Token {
+	type = 'onlyinclude';
+
+	/**
+	 * @param {string} inner 标签内部wikitext
+	 * @param {accum} accum
+	 */
+	constructor(inner, config = Parser.getConfig(), accum = []) {
+		super(inner, config, true, accum);
+	}
+
+	/**
+	 * @override
+	 */
+	toString(selector) {
+		return `<onlyinclude>${super.toString()}</onlyinclude>`;
+	}
+
+	/** @override */
+	getPadding() {
+		return 13;
+	}
+
+	/** @override */
+	isPlain() {
+		return true;
+	}
+}
+
+module.exports = OnlyincludeToken;

package/src/paramTag/index.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const {generateForChild} = require('../../util/lint'),
+	Parser = require('../..'),
+	Token = require('..'),
+	AtomToken = require('../atom');
+
+/**
+ * `<inputbox>`
+ * @classdesc `{childNodes: ...AtomToken}`
+ */
+class ParamTagToken extends Token {
+	type = 'ext-inner';
+
+	/**
+	 * @param {string} wikitext wikitext
+	 * @param {accum} accum
+	 */
+	constructor(wikitext, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {
+		});
+		if (wikitext) {
+			const SingleLineAtomToken = AtomToken;
+			this.append(
+				...wikitext.split('\n').map(line => new SingleLineAtomToken(line, 'param-line', config, accum, {
+				})),
+			);
+		}
+	}
+
+	/**
+	 * @override
+	 */
+	toString(selector) {
+		return super.toString(selector, '\n');
+	}
+
+	/** @override */
+	text() {
+		return super.text('\n');
+	}
+
+	/** @override */
+	getGaps() {
+		return 1;
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		let /** @type {{top: number, left: number}} */ rect;
+		return this.childNodes.filter(child => {
+			const {childNodes} = child,
+				i = childNodes.findIndex(({type}) => type !== 'text'),
+				str = (i >= 0 ? childNodes.slice(0, i).map(String).join('') : String(child)).trim();
+			return str && !(i >= 0 ? /^[a-z]+\s*(?:=|$)/iu : /^[a-z]+\s*=/iu).test(str);
+		}).map(child => {
+			rect ||= {start, ...this.getRootNode().posFromIndex(start)};
+			return generateForChild(child, rect, `${this.name}的无效参数`);
+		});
+	}
+}
+
+module.exports = ParamTagToken;

package/src/paramTag/inputbox.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const parseBrackets = require('../../parser/brackets'),
+	Parser = require('../..'),
+	ParamTagToken = require('.'),
+	AtomToken = require('../atom');
+
+/**
+ * `<inputbox>`
+ * @classdesc `{childNodes: ...SingleLineAtomToken}`
+ */
+class InputboxToken extends ParamTagToken {
+	name = 'inputbox';
+
+	/**
+	 * @param {string} wikitext wikitext
+	 * @param {accum} accum
+	 */
+	constructor(wikitext, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, accum);
+		wikitext = parseBrackets(wikitext, config, accum);
+		accum.splice(accum.indexOf(this), 1);
+		accum.push(this);
+		if (wikitext) {
+			const SingleLineAtomToken = AtomToken;
+			this.append(...wikitext.split('\n').map(line => new SingleLineAtomToken(line, 'param-line', config, accum, {
+			})));
+		}
+	}
+}
+
+module.exports = InputboxToken;

package/src/parameter.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const {extUrlChar, extUrlCharFirst} = require('../util/string'),
+	{generateForChild} = require('../util/lint'),
+	Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 模板或魔术字参数
+ * @classdesc `{childNodes: [Token, Token]}`
+ */
+class ParameterToken extends Token {
+	type = 'parameter';
+
+	/** 是否是匿名参数 */
+	get anon() {
+		return this.firstChild.length === 0;
+	}
+
+	/**
+	 * @param {string|number} key 参数名
+	 * @param {string} value 参数值
+	 * @param {accum} accum
+	 */
+	constructor(key, value, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum);
+		const keyToken = new Token(typeof key === 'number' ? undefined : key, config, true, accum, {
+			}),
+			token = new Token(value, config, true, accum);
+		keyToken.type = 'parameter-key';
+		token.type = 'parameter-value';
+		this.append(keyToken, token.setAttribute('stage', 2));
+	}
+
+	/** @override */
+	afterBuild() {
+		if (!this.anon) {
+			const TranscludeToken = require('./transclude');
+			const name = String(this.firstChild).replace(/<!--.*?-->/gu, '')
+					.replace(/^[ \t\n\0\v]+|([^ \t\n\0\v])[ \t\n\0\v]+$/gu, '$1'),
+				{parentNode} = this;
+			this.setAttribute('name', name);
+			if (parentNode instanceof TranscludeToken) {
+				parentNode.getArgs(name, false, false).add(this);
+			}
+		}
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	toString(selector) {
+		return this.anon
+			? this.lastChild.toString(selector)
+			: super.toString(selector, '=');
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	text() {
+		return this.anon ? this.lastChild.text() : super.text('=');
+	}
+
+	/** @override */
+	getGaps() {
+		return this.anon ? 0 : 1;
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const errors = super.lint(start),
+			{firstChild, lastChild} = this,
+			link = new RegExp(`https?://${extUrlCharFirst}${extUrlChar}$`, 'iu')
+				.exec(String(firstChild).replace(/<!--.*?-->/gu, ''))?.[0];
+		if (link && new URL(link).search) {
+			const e = generateForChild(firstChild, {start}, '匿名参数中未转义的查询参数');
+			errors.push({
+				...e,
+				startIndex: e.endIndex,
+				endIndex: e.endIndex + 1,
+				startLine: e.endLine,
+				startCol: e.endCol,
+				endCol: e.endCol + 1,
+				excerpt: `${String(firstChild).slice(-25)}=${String(lastChild).slice(0, 25)}`,
+			});
+		}
+		return errors;
+	}
+}
+
+module.exports = ParameterToken;

package/src/syntax.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 满足特定语法格式的plain Token
+ * @classdesc `{childNodes: ...AstText|Token}`
+ */
+class SyntaxToken extends Token {
+	/**
+	 * @param {string} wikitext 语法wikitext
+	 * @param {RegExp} pattern 语法正则
+	 * @param {string} type Token.type
+	 * @param {accum} accum
+	 */
+	constructor(wikitext, pattern, type = 'plain', config = Parser.getConfig(), accum = [], acceptable = undefined) {
+		super(wikitext, config, true, accum, acceptable);
+		this.type = type;
+	}
+}
+
+module.exports = SyntaxToken;

package/src/table/index.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const {generateForChild} = require('../../util/lint'),
+	TrToken = require('./tr'),
+	SyntaxToken = require('../syntax');
+
+/**
+ * 表格
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken, ...TrToken, ?SyntaxToken]}`
+ */
+class TableToken extends TrToken {
+	type = 'table';
+
+	/** 表格是否闭合 */
+	get closed() {
+		return this.lastChild.type === 'table-syntax';
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const errors = super.lint(start);
+		if (!this.closed) {
+			const {firstChild, lastChild: tr} = this,
+				{lastChild: td} = tr,
+				error = generateForChild(firstChild, {start}, '未闭合的表格');
+			errors.push({...error, excerpt: String(td?.type === 'td' ? td : tr).slice(0, 50)});
+		}
+		return errors;
+	}
+
+	/**
+	 * 闭合表格语法
+	 * @complexity `n`
+	 * @param {string} syntax 表格结尾语法
+	 */
+	close(syntax = '\n|}', halfParsed = false) {
+		const config = this.getAttribute('config'),
+			accum = this.getAttribute('accum');
+		super.insertAt(new SyntaxToken(syntax, undefined, 'table-syntax', config, accum));
+	}
+}
+
+module.exports = TableToken;

package/src/table/td.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const {generateForChild} = require('../../util/lint'),
+	Parser = require('../..'),
+	Token = require('..'),
+	TrToken = require('./tr');
+
+/**
+ * `<td>`、`<th>`和`<caption>`
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, Token]}`
+ */
+class TdToken extends TrToken {
+	type = 'td';
+	#innerSyntax = '';
+
+	/**
+	 * 单元格类型
+	 * @complexity `n`
+	 */
+	get subtype() {
+		return this.getSyntax().subtype;
+	}
+
+	/**
+	 * 获取单元格语法信息
+	 * @returns {{subtype: 'td'|'th'|'caption'}}
+	 * @complexity `n`
+	 */
+	getSyntax() {
+		const syntax = this.firstChild.text(),
+			char = syntax.at(-1);
+		let subtype = 'td';
+		if (char === '!') {
+			subtype = 'th';
+		} else if (char === '+') {
+			subtype = 'caption';
+		}
+		return {subtype};
+	}
+
+	/**
+	 * @param {string} syntax 单元格语法
+	 * @param {string} inner 内部wikitext
+	 * @param {accum} accum
+	 */
+	constructor(syntax, inner, config = Parser.getConfig(), accum = []) {
+		let innerSyntax = inner?.match(/\||\0\d+!\x7F/u),
+			attr = innerSyntax ? inner.slice(0, innerSyntax.index) : '';
+		if (/\[\[|-\{/u.test(attr)) {
+			innerSyntax = undefined;
+			attr = '';
+		}
+		super(syntax, attr, config, accum);
+		if (innerSyntax) {
+			[this.#innerSyntax] = innerSyntax;
+		}
+		// eslint-disable-next-line no-unsafe-optional-chaining
+		const innerToken = new Token(inner?.slice(innerSyntax?.index + this.#innerSyntax.length), config, true, accum);
+		innerToken.type = 'td-inner';
+		this.insertAt(innerToken.setAttribute('stage', 4));
+	}
+
+	/** @override */
+	afterBuild() {
+		if (this.#innerSyntax.includes('\0')) {
+			this.#innerSyntax = this.getAttribute('buildFromStr')(this.#innerSyntax, 'string');
+		}
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 * @complexity `n`
+	 */
+	toString(selector) {
+		const {childNodes: [syntax, attr, inner]} = this;
+		return `${syntax.toString()}${attr.toString()}${this.#innerSyntax}${inner.toString()}`;
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 * @complexity `n`
+	 */
+	text() {
+		const {childNodes: [syntax, attr, inner]} = this;
+		return `${syntax.text()}${attr.text()}${this.#innerSyntax}${inner.text()}`;
+	}
+
+	/**
+	 * @override
+	 * @param {number} i 子节点位置
+	 */
+	getGaps(i = 0) {
+		i = i < 0 ? i + this.length : i;
+		if (i === 1) {
+			return this.#innerSyntax.length;
+		}
+		return 0;
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const errors = super.lint(start),
+			{lastChild} = this;
+		start += this.getRelativeIndex(-1);
+		for (const child of lastChild.childNodes) {
+			if (child.type === 'text' && child.data.includes('|')) {
+				errors.push(generateForChild(child, {start}, '表格单元格中多余的"|"', 'warning'));
+			}
+		}
+		return errors;
+	}
+}
+
+module.exports = TdToken;

package/src/table/tr.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const {generateForChild} = require('../../util/lint'),
+	Parser = require('../..'),
+	Token = require('..'),
+	SyntaxToken = require('../syntax'),
+	AttributesToken = require('../attributes');
+
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
+ */
+class TrToken extends Token {
+	type = 'tr';
+
+	/**
+	 * @param {string} syntax 表格语法
+	 * @param {string} attr 表格属性
+	 * @param {accum} accum
+	 * @param {RegExp} pattern 表格语法正则
+	 */
+	constructor(syntax, attr = '', config = Parser.getConfig(), accum = [], pattern = undefined) {
+		super(undefined, config, true, accum, {
+		});
+		this.append(
+			new SyntaxToken(syntax, pattern, 'table-syntax', config, accum, {
+			}),
+			new AttributesToken(attr, 'table-attrs', this.type, config, accum),
+		);
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const TranscludeToken = require('../transclude'),
+			ArgToken = require('../arg');
+		const errors = super.lint(start),
+			inter = this.childNodes.find(({type}) => type === 'table-inter');
+		if (!inter) {
+			return errors;
+		}
+		const /** @type {TranscludeToken & ArgToken} */ first = inter.childNodes.find(child => child.text().trim()),
+			tdPattern = /^\s*(?:!|\{\{\s*![!-]?\s*\}\})/u;
+		if (!first || tdPattern.test(String(first)) || first.type === 'arg' && tdPattern.test(first.default || '')) {
+			return errors;
+		} else if (first.type === 'magic-word') {
+			try {
+				const possibleValues = first.getPossibleValues();
+				if (possibleValues.every(token => tdPattern.test(token.text()))) {
+					return errors;
+				}
+			} catch {}
+		}
+		const error = generateForChild(inter, {start}, '将被移出表格的内容');
+		errors.push({
+			...error,
+			startIndex: error.startIndex + 1,
+			startLine: error.startLine + 1,
+			startCol: 0,
+			excerpt: error.excerpt.slice(1),
+		});
+		return errors;
+	}
+
+	/** @override */
+	text() {
+		const str = super.text();
+		return this.type === 'tr' && !str.trim().includes('\n') ? '' : str;
+	}
+}
+
+module.exports = TrToken;

package/src/tagPair/ext.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const {generateForSelf} = require('../../util/lint'),
+	Parser = require('../..'),
+	Token = require('..'),
+	TagPairToken = require('.'),
+	AttributesToken = require('../attributes');
+
+/**
+ * 扩展标签
+ * @classdesc `{childNodes: [AttributesToken, NowikiToken|Token]}`
+ */
+class ExtToken extends TagPairToken {
+	type = 'ext';
+	closed = true;
+
+	/**
+	 * @param {string} name 标签名
+	 * @param {string} attr 标签属性
+	 * @param {string} inner 内部wikitext
+	 * @param {string|undefined} closed 是否封闭
+	 * @param {accum} accum
+	 */
+	constructor(name, attr = '', inner = '', closed = undefined, config = Parser.getConfig(), accum = []) {
+		attr = !attr || /^\s/u.test(attr) ? attr : ` ${attr}`;
+		const lcName = name.toLowerCase(),
+			attrToken = new AttributesToken(attr, 'ext-attrs', lcName, config, accum),
+			/** @type {ParserConfig} */ newConfig = {...config, excludes: [...config.excludes]},
+			ext = new Set(newConfig.ext);
+		let /** @type {Token} */ innerToken;
+		ext.delete(lcName);
+		newConfig.ext = [...ext];
+		switch (lcName) {
+			case 'tab':
+				ext.delete('tabs');
+				newConfig.ext = [...ext];
+				// fall through
+			case 'indicator':
+			case 'poem':
+			case 'ref':
+			case 'option':
+			case 'combooption':
+			case 'tabs':
+			case 'poll':
+			case 'seo':
+				if (lcName === 'poem') {
+					newConfig.excludes.push('heading');
+				}
+				innerToken = new Token(inner, newConfig, true, accum);
+				break;
+			case 'gallery': {
+				const GalleryToken = require('../gallery');
+				innerToken = new GalleryToken(inner, newConfig, accum);
+				break;
+			}
+			case 'pre': {
+				const PreToken = require('../hasNowiki/pre');
+				innerToken = new PreToken(inner, newConfig, accum);
+				break;
+			}
+			case 'references':
+			case 'choose':
+			case 'combobox': {
+				const NestedToken = require('../nested'),
+					/** @type {typeof NestedToken} */ NestedExtToken = require(`../nested/${lcName}`);
+				innerToken = new NestedExtToken(inner, newConfig, accum);
+				break;
+			}
+			case 'imagemap': {
+				const ImagemapToken = require('../imagemap');
+				innerToken = new ImagemapToken(inner, config, accum);
+				break;
+			}
+			case 'dynamicpagelist': {
+				const ParamTagToken = require('../paramTag');
+				innerToken = new ParamTagToken(inner, newConfig, accum);
+				break;
+			}
+			case 'inputbox': {
+				newConfig.excludes.push('heading');
+				const InputboxToken = require('../paramTag/inputbox');
+				innerToken = new InputboxToken(inner, newConfig, accum);
+				break;
+			}
+
+			/*
+			 * 更多定制扩展的代码示例：
+			 * ```
+			 * case 'extensionName': {
+			 * 	const ExtensionToken = require('../extension');
+			 * 	innerToken = new ExtensionToken(inner, newConfig, accum);
+			 * 	break;
+			 * }
+			 * ```
+			 */
+			default: {
+				const NowikiToken = require('../nowiki');
+				innerToken = new NowikiToken(inner, config);
+			}
+		}
+		innerToken.setAttribute('name', lcName).type = 'ext-inner';
+		super(name, attrToken, innerToken, closed, config, accum);
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const errors = super.lint(start);
+		if (this.name !== 'nowiki' && this.closest('html-attrs, table-attrs')) {
+			const root = this.getRootNode(),
+				excerpt = String(root).slice(Math.max(0, start - 25), start + 25),
+				rect = {start, ...root.posFromIndex(start)};
+			errors.push({...generateForSelf(this, rect, 'HTML标签属性中的扩展标签'), excerpt});
+		}
+		return errors;
+	}
+}
+
+module.exports = ExtToken;

package/src/tagPair/include.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const hidden = require('../../mixin/hidden'),
+	Parser = require('../..'),
+	TagPairToken = require('.');
+
+/**
+ * `<includeonly>`或`<noinclude>`
+ * @classdesc `{childNodes: [AstText, AstText]}`
+ */
+class IncludeToken extends hidden(TagPairToken) {
+	type = 'include';
+
+	/**
+	 * @param {string} name 标签名
+	 * @param {string} attr 标签属性
+	 * @param {string|undefined} inner 内部wikitext
+	 * @param {string|undefined} closed 是否封闭
+	 * @param {accum} accum
+	 */
+	constructor(name, attr = '', inner = undefined, closed = undefined, config = Parser.getConfig(), accum = []) {
+		super(name, attr, inner ?? '', inner === undefined ? closed : closed ?? '', config, accum);
+	}
+}
+
+module.exports = IncludeToken;