wikiparser-node 0.3.0 → 0.4.0

package/src/table/td.js

@@ -2,10 +2,13 @@
 
 const fixedToken = require('../../mixin/fixedToken'),
 	{externalUse, typeError} = require('../../util/debug'),
-	/** @type {Parser} */ Parser = require('../..'),
+	Parser = require('../..'),
 	Token = require('..'),
 	TrToken = require('./tr');
 
+const aliases = {td: '\n|', th: '\n!', caption: '\n|+'},
+	openingPattern = /^(?:\n[\S\n]*(?:[|!]|\|\+|\{\{\s*!\s*\}\}\+?)|(?:\||\{\{\s*!\s*\}\}){2}|!!|\{\{\s*!!\s*\}\})$/u;
+
 /**
  * `<td>`、`<th>`和`<caption>`
  * @classdesc `{childNodes: [SyntaxToken, AttributeToken, Token]}`
@@ -14,42 +17,59 @@ class TdToken extends fixedToken(TrToken) {
 	type = 'td';
 	#innerSyntax = '';
 
-	/** @complexity `n` */
+	/**
+	 * 单元格类型
+	 * @complexity `n`
+	 */
 	get subtype() {
 		return this.getSyntax().subtype;
 	}
+
 	set subtype(subtype) {
 		this.setSyntax(subtype);
 	}
 
+	/** rowspan */
 	get rowspan() {
 		return this.getAttr('rowspan');
 	}
+
 	set rowspan(rowspan) {
 		this.setAttr('rowspan', rowspan);
 	}
+
+	/** colspan */
 	get colspan() {
 		return this.getAttr('colspan');
 	}
+
 	set colspan(colspan) {
 		this.setAttr('colspan', colspan);
 	}
 
+	/** 内部wikitext */
+	get innerText() {
+		return this.lastElementChild.text();
+	}
+
+	/** 是否位于行首 */
 	isIndependent() {
-		return this.firstElementChild.text().startsWith('\n');
+		return this.firstElementChild.text()[0] === '\n';
 	}
 
 	/**
+	 * 获取单元格语法信息
 	 * @returns {{subtype: 'td'|'th'|'caption', escape: boolean, correction: boolean}}
 	 * @complexity `n`
 	 */
 	getSyntax() {
 		const syntax = this.firstElementChild.text(),
-			esc = syntax.includes('{{');
+			esc = syntax.includes('{{'),
+			char = syntax.at(-1);
 		let subtype = 'td';
-		if (syntax.endsWith('!')) {
+		if (char === '!') {
 			subtype = 'th';
-		} else if (syntax.endsWith('+')) {
+		} else if (char === '+') {
 			subtype = 'caption';
 		}
 		if (this.isIndependent()) {
@@ -61,7 +81,9 @@ class TdToken extends fixedToken(TrToken) {
 		}
 		const result = previousElementSibling.getSyntax();
 		result.escape ||= esc;
-		result.correction = previousElementSibling.lastElementChild.offsetHeight > 1;
+		result.correction = previousElementSibling.lastElementChild
+			.toString('comment, ext, include, noinclude, arg, template, magic-word, html')
+			.includes('\n');
 		if (subtype === 'th' && result.subtype !== 'th') {
 			result.subtype = 'th';
 			result.correction = true;
@@ -69,25 +91,23 @@ class TdToken extends fixedToken(TrToken) {
 		return result;
 	}
 
-	static openingPattern = /^(?:\n[\S\n]*(?:[|!]|\|\+|{{\s*!\s*}}\+?)|(?:\||{{\s*!\s*}}){2}|!!|{{\s*!!\s*}})$/;
-
 	getRowCount = undefined;
 	getNthCol = undefined;
 	insertTableCell = undefined;
 
 	/**
-	 * @param {string} syntax
-	 * @param {string} inner
+	 * @param {string} syntax 单元格语法
+	 * @param {string} inner 内部wikitext
 	 * @param {accum} accum
 	 */
 	constructor(syntax, inner, config = Parser.getConfig(), accum = []) {
-		let innerSyntax = inner?.match(/\||\x00\d+!\x7f/),
+		let innerSyntax = inner?.match(/\||\0\d+!\x7F/u),
 			attr = innerSyntax ? inner.slice(0, innerSyntax.index) : '';
-		if (/\[\[|-{/.test(attr)) {
+		if (/\[\[|-\{/u.test(attr)) {
 			innerSyntax = null;
 			attr = '';
 		}
-		super(syntax, attr, config, accum, TdToken.openingPattern);
+		super(syntax, attr, config, accum, openingPattern);
 		if (innerSyntax) {
 			[this.#innerSyntax] = innerSyntax;
 		}
@@ -95,9 +115,11 @@ class TdToken extends fixedToken(TrToken) {
 		const innerToken = new Token(inner?.slice(innerSyntax?.index + this.#innerSyntax.length), config, true, accum);
 		innerToken.type = 'td-inner';
 		this.setAttribute('acceptable', {SyntaxToken: 0, AttributeToken: 1, Token: 2})
-			.seal(['getRowCount', 'getNthCol', 'insertTableCell']).appendChild(innerToken.setAttribute('stage', 4));
+			.seal(['getRowCount', 'getNthCol', 'insertTableCell'], true)
+			.appendChild(innerToken.setAttribute('stage', 4));
 	}
 
+	/** @override */
 	cloneNode() {
 		const /** @type {TdToken} */ token = super.cloneNode();
 		token.setAttribute('innerSyntax', this.#innerSyntax);
@@ -105,14 +127,17 @@ class TdToken extends fixedToken(TrToken) {
 	}
 
 	/**
-	 * @param {string|Token} inner
-	 * @param {'td'|'th'|'caption'} subtype
-	 * @param {Record<string, string>} attr
+	 * 创建新的单元格
+	 * @param {string|Token} inner 内部wikitext
+	 * @param {'td'|'th'|'caption'} subtype 单元格类型
+	 * @param {Record<string, string>} attr 单元格属性
+	 * @param {boolean} include 是否嵌入
+	 * @throws `RangeError` 非法的单元格类型
 	 */
 	static create(inner, subtype = 'td', attr = {}, include = false, config = Parser.getConfig()) {
 		if (typeof inner !== 'string' && (!(inner instanceof Token) || !inner.isPlain()) || typeof attr !== 'object') {
 			typeError(this, 'create', 'String', 'Token', 'Object');
-		} else if (!['td', 'th', 'caption'].includes(subtype)) {
+		} else if (subtype !== 'td' && subtype !== 'th' && subtype !== 'caption') {
 			throw new RangeError('单元格的子类型只能为 "td"、"th" 或 "caption"！');
 		} else if (typeof inner === 'string') {
 			inner = Parser.parse(inner, include, undefined, config);
@@ -127,22 +152,22 @@ class TdToken extends fixedToken(TrToken) {
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {TokenAttribute<T>}
 	 */
 	getAttribute(key) {
-		if (key === 'innerSyntax') {
-			return this.#innerSyntax;
-		}
-		return super.getAttribute(key);
+		return key === 'innerSyntax' ? this.#innerSyntax : super.getAttribute(key);
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
-	 * @param {TokenAttribute<T>} value
-	 * @return {this}
+	 * @param {T} key 属性键
+	 * @param {TokenAttribute<T>} value 属性值
+	 * @returns {this}
+	 * @throws `RangeError` 仅用于代码调试
 	 */
 	setAttribute(key, value) {
 		if (key !== 'innerSyntax') {
@@ -154,49 +179,66 @@ class TdToken extends fixedToken(TrToken) {
 		return this;
 	}
 
+	/** @override */
 	afterBuild() {
-		if (this.#innerSyntax.includes('\x00')) {
-			this.#innerSyntax = this.buildFromStr(this.#innerSyntax).map(String).join('');
+		if (this.#innerSyntax.includes('\0')) {
+			this.#innerSyntax = this.getAttribute('buildFromStr')(this.#innerSyntax).map(String).join('');
 		}
 		return this;
 	}
 
-	static #aliases = {td: '\n|', th: '\n!', caption: '\n|+'};
-
-	/** @param {string} syntax */
-	setSyntax(syntax, esc = false) {
-		super.setSyntax(TdToken.#aliases[syntax] ?? syntax, esc);
+	/**
+	 * @override
+	 * @param {string} syntax 表格语法
+	 * @param {boolean} esc 是否需要转义
+	 */
+	setSyntax(syntax, esc) {
+		super.setSyntax(aliases[syntax] ?? syntax, esc);
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 修复\<td\>语法
+	 * @complexity `n`
+	 */
 	#correct() {
-		if (this.children[1].toString()) {
+		if (String(this.children[1])) {
 			this.#innerSyntax ||= '|';
 		}
-		const {subtype, escape: esc, correction} = this.getSyntax();
+		const {subtype, escape, correction} = this.getSyntax();
 		if (correction) {
-			this.setSyntax(subtype, esc);
+			this.setSyntax(subtype, escape);
 		}
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 改为独占一行
+	 * @complexity `n`
+	 */
 	independence() {
 		if (!this.isIndependent()) {
-			const {subtype, escape: esc} = this.getSyntax();
-			this.setSyntax(subtype, esc);
+			const {subtype, escape} = this.getSyntax();
+			this.setSyntax(subtype, escape);
 		}
 	}
 
 	/**
+	 * @override
+	 * @param {string} selector
 	 * @returns {string}
 	 * @complexity `n`
 	 */
-	toString() {
+	toString(selector) {
 		this.#correct();
-		const [syntax, attr, inner] = this.children;
-		return `${syntax.toString()}${attr.toString()}${this.#innerSyntax}${inner.toString()}`;
+		const {children: [syntax, attr, inner]} = this;
+		return selector && this.matches(selector)
+			? ''
+			: `${syntax.toString(selector)}${attr.toString(selector)}${this.#innerSyntax}${inner.toString(selector)}`;
 	}
 
+	/**
+	 * @override
+	 * @param {number} i 子节点位置
+	 */
 	getGaps(i = 0) {
 		i = i < 0 ? i + this.childNodes.length : i;
 		if (i !== 1) {
@@ -207,49 +249,53 @@ class TdToken extends fixedToken(TrToken) {
 	}
 
 	/**
+	 * @override
 	 * @returns {string}
 	 * @complexity `n`
 	 */
 	text() {
 		this.#correct();
-		const [syntax, attr, inner] = this.children;
+		const {children: [syntax, attr, inner]} = this;
 		return `${syntax.text()}${attr.text()}${this.#innerSyntax}${inner.text()}`;
 	}
 
 	/**
+	 * 获取单元格属性
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {T extends 'rowspan'|'colspan' ? number : Record<string, string|true>}
 	 */
 	getAttr(key) {
 		const /** @type {string|true} */ value = super.getAttr(key);
 		key = key?.toLowerCase()?.trim();
-		return ['rowspan', 'colspan'].includes(key) ? Number(value) || 1 : value;
+		return key === 'rowspan' || key === 'colspan' ? Number(value) || 1 : value;
 	}
 
 	/**
+	 * 设置单元格属性
 	 * @template {string} T
-	 * @param {T} key
-	 * @param {T extends 'rowspan'|'colspan' ? number : string|boolean} value
+	 * @param {T} key 属性键
+	 * @param {T extends 'rowspan'|'colspan' ? number : string|boolean} value 属性值
 	 */
 	setAttr(key, value) {
 		if (typeof key !== 'string') {
 			this.typeError('setAttr', 'String');
 		}
 		key = key.toLowerCase().trim();
-		if (typeof value === 'number' && ['rowspan', 'colspan'].includes(key)) {
+		if (typeof value === 'number' && (key === 'rowspan' || key === 'colspan')) {
 			value = value === 1 ? false : String(value);
 		}
 		const /** @type {boolean} */ result = super.setAttr(key, value);
-		if (!this.children[1].toString()) {
+		if (!String(this.children[1])) {
 			this.#innerSyntax = '';
 		}
 		return result;
 	}
 
+	/** @override */
 	escape() {
 		super.escape();
-		if (this.children[1].toString()) {
+		if (String(this.children[1])) {
 			this.#innerSyntax ||= '{{!}}';
 		}
 		if (this.#innerSyntax === '|') {

package/src/table/tr.js

@@ -1,11 +1,30 @@
 'use strict';
 
 const attributeParent = require('../../mixin/attributeParent'),
-	/** @type {Parser} */ Parser = require('../..'),
+	Parser = require('../..'),
+	AstText = require('../../lib/text'),
 	Token = require('..'),
 	SyntaxToken = require('../syntax'),
 	AttributeToken = require('../attribute');
 
+const openingPattern = /^\n[^\S\n]*(?:\|-+|\{\{\s*!\s*\}\}-+|\{\{\s*!-\s*\}\}-*)$/u;
+
+/**
+ * 转义表格语法
+ * @param {SyntaxToken} syntax 表格语法节点
+ */
+const escapeTable = syntax => {
+	const wikitext = syntax.childNodes.map(
+			child => child.type === 'text'
+				? String(child).replaceAll('{|', '{{(!}}').replaceAll('|}', '{{!)}}')
+					.replaceAll('||', '{{!!}}')
+					.replaceAll('|', '{{!}}')
+				: String(child),
+		).join(''),
+		token = Parser.parse(wikitext, syntax.getAttribute('include'), 2, syntax.getAttribute('config'));
+	syntax.replaceChildren(...token.childNodes);
+};
+
 /**
  * 表格行，含开头的换行，不含结尾的换行
  * @classdesc `{childNodes: [SyntaxToken, AttributeToken, ?Token, ...TdToken]}`
@@ -13,13 +32,13 @@ const attributeParent = require('../../mixin/attributeParent'),
 class TrToken extends attributeParent(Token, 1) {
 	type = 'tr';
 
-	static openingPattern = /^\n[^\S\n]*(?:\|-+|{{\s*!\s*}}-+|{{\s*!-\s*}}-*)$/;
-
 	/**
-	 * @param {string} syntax
+	 * @param {string} syntax 表格语法
+	 * @param {string} attr 表格属性
 	 * @param {accum} accum
+	 * @param {RegExp} pattern 表格语法正则
 	 */
-	constructor(syntax, attr = '', config = Parser.getConfig(), accum = [], pattern = TrToken.openingPattern) {
+	constructor(syntax, attr = '', config = Parser.getConfig(), accum = [], pattern = openingPattern) {
 		super(undefined, config, true, accum, {Token: 2, SyntaxToken: 0, AttributeToken: 1, TdToken: '2:'});
 		this.append(
 			new SyntaxToken(syntax, pattern, 'table-syntax', config, accum, {
@@ -27,14 +46,17 @@ class TrToken extends attributeParent(Token, 1) {
 			}),
 			new AttributeToken(attr, 'table-attr', 'tr', config, accum),
 		);
-		this.protectChildren(0, 1);
+		this.getAttribute('protectChildren')(0, 1);
 	}
 
+	/**
+	 * @override
+	 * @this {TrToken & {constructor: typeof TrToken}}
+	 */
 	cloneNode() {
-		const [syntax, attr, inner, ...cloned] = this.cloneChildren(),
-			/** @type {typeof TrToken} */ Constructor = this.constructor;
+		const [syntax, attr, inner, ...cloned] = this.cloneChildNodes();
 		return Parser.run(() => {
-			const token = new Constructor(undefined, undefined, this.getAttribute('config'));
+			const token = new this.constructor(undefined, undefined, this.getAttribute('config'));
 			token.firstElementChild.safeReplaceWith(syntax);
 			token.children[1].safeReplaceWith(attr);
 			if (token.type === 'td') { // TdToken
@@ -47,67 +69,70 @@ class TrToken extends attributeParent(Token, 1) {
 		});
 	}
 
+	/** 修复简单的表格语法错误 */
 	#correct() {
-		const [,, child] = this.children;
+		const {children: [,, child]} = this;
 		if (child?.isPlain()) {
-			const {firstChild} = child;
-			if (typeof firstChild !== 'string') {
+			const /** @type {{firstChild: AstText}} */ {firstChild: {type, data}} = child;
+			if (type !== 'text') {
 				child.prepend('\n');
-			} else if (!firstChild.startsWith('\n')) {
-				child.setText(`\n${firstChild}`);
+			} else if (data[0] !== '\n') {
+				child.setText(`\n${data}`);
 			}
 		}
 	}
 
-	toString() {
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
 		this.#correct();
-		return super.toString();
+		return super.toString(selector);
 	}
 
+	/** @override */
 	text() {
 		this.#correct();
 		const str = super.text();
 		return this.type === 'tr' && !str.trim().includes('\n') ? '' : str;
 	}
 
-	/** @param {SyntaxToken} syntax */
-	static escape(syntax) {
-		const wikitext = syntax.childNodes.map(child => typeof child === 'string'
-				? child.replaceAll('{|', '{{(!}}').replaceAll('|}', '{{!)}}').replaceAll('||', '{{!!}}')
-					.replaceAll('|', '{{!}}')
-				: child.toString(),
-			).join(''),
-			token = Parser.parse(wikitext, syntax.getAttribute('include'), 2, syntax.getAttribute('config'));
-		syntax.replaceChildren(...token.childNodes);
-	}
-
-	/** @complexity `n` */
+	/**
+	 * 转义表格语法
+	 * @complexity `n`
+	 */
 	escape() {
 		for (const child of this.children) {
 			if (child instanceof SyntaxToken) {
-				TrToken.escape(child);
+				escapeTable(child);
 			} else if (child instanceof TrToken) {
 				child.escape();
 			}
 		}
 	}
 
-	/** @param {string} syntax */
-	setSyntax(syntax, esc = false) {
+	/**
+	 * 设置表格语法
+	 * @param {string} syntax 表格语法
+	 * @param {boolean} esc 是否需要转义
+	 */
+	setSyntax(syntax, esc) {
 		const {firstElementChild} = this;
 		firstElementChild.replaceChildren(syntax);
 		if (esc) {
-			TrToken.escape(firstElementChild);
+			escapeTable(firstElementChild);
 		}
 	}
 
 	/**
-	 * @param {number} i
+	 * @override
+	 * @param {number} i 移除位置
 	 * @complexity `n`
 	 */
 	removeAt(i) {
-		const TdToken = require('./td'),
-			child = this.childNodes.at(i);
+		const TdToken = require('./td');
+		const child = this.childNodes.at(i);
 		if (child instanceof TdToken && child.isIndependent()) {
 			const {nextElementSibling} = child;
 			if (nextElementSibling?.type === 'td') {
@@ -118,8 +143,10 @@ class TrToken extends attributeParent(Token, 1) {
 	}
 
 	/**
-	 * @template {string|Token} T
-	 * @param {T} token
+	 * @override
+	 * @template {AstText|Token} T
+	 * @param {T} token 待插入的子节点
+	 * @param {number} i 插入位置
 	 * @returns {T}
 	 * @complexity `n`
 	 */
@@ -127,8 +154,8 @@ class TrToken extends attributeParent(Token, 1) {
 		if (!Parser.running && !(token instanceof TrToken)) {
 			this.typeError('insertAt', 'TrToken');
 		}
-		const TdToken = require('./td'),
-			child = this.childNodes.at(i);
+		const TdToken = require('./td');
+		const child = this.childNodes.at(i);
 		if (token instanceof TdToken && token.isIndependent() && child instanceof TdToken) {
 			child.independence();
 		}
@@ -136,45 +163,57 @@ class TrToken extends attributeParent(Token, 1) {
 	}
 
 	/**
+	 * 获取行数
 	 * @returns {0|1}
 	 * @complexity `n`
 	 */
 	getRowCount() {
 		const TdToken = require('./td');
-		return Number(this.children.some(child =>
-			child instanceof TdToken && child.isIndependent() && !child.firstElementChild.text().endsWith('+'),
+		return Number(this.children.some(
+			child => child instanceof TdToken && child.isIndependent() && child.firstElementChild.text().at(-1) !== '+',
 		));
 	}
 
 	/**
-	 * @param {(children: Token[], index: number) => Token[]} subset
+	 * 获取相邻行
+	 * @param {(children: Token[], index: number) => Token[]} subset 筛选兄弟节点的方法
 	 * @complexity `n`
 	 */
 	#getSiblingRow(subset) {
-		const {parentElement} = this;
-		if (!parentElement) {
-			return;
+		const {parentNode} = this;
+		if (!parentNode) {
+			return undefined;
 		}
-		const {children} = parentElement,
+		const {children} = parentNode,
 			index = children.indexOf(this);
 		for (const child of subset(children, index)) {
 			if (child instanceof TrToken && child.getRowCount()) {
 				return child;
 			}
 		}
+		return undefined;
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取下一行
+	 * @complexity `n`
+	 */
 	getNextRow() {
 		return this.#getSiblingRow((children, index) => children.slice(index + 1));
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取前一行
+	 * @complexity `n`
+	 */
 	getPreviousRow() {
 		return this.#getSiblingRow((children, index) => children.slice(0, index).reverse());
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取列数
+	 * @complexity `n`
+	 */
 	getColCount() {
 		const TdToken = require('./td');
 		let count = 0,
@@ -189,11 +228,14 @@ class TrToken extends attributeParent(Token, 1) {
 	}
 
 	/**
-	 * @param {number} n
+	 * 获取第n列
+	 * @param {number} n 列号
+	 * @param {boolean} insert 是否用于判断插入新列的位置
 	 * @returns {TdToken}
 	 * @complexity `n`
+	 * @throws `RangeError` 不存在对应单元格
 	 */
-	getNthCol(n, insert = false) {
+	getNthCol(n, insert) {
 		if (typeof n !== 'number') {
 			this.typeError('getNthCol', 'Number');
 		}
@@ -213,23 +255,25 @@ class TrToken extends attributeParent(Token, 1) {
 				if (n < 0) {
 					return child;
 				}
-			} else if (['tr', 'table-syntax'].includes(child.type)) {
+			} else if (child.type === 'tr' || child.type === 'table-syntax') {
 				return child;
 			}
 		}
+		return undefined;
 	}
 
 	/**
-	 * @param {string|Token} inner
-	 * @param {TableCoords}
-	 * @param {'td'|'th'|'caption'} subtype
-	 * @param {Record<string, string|boolean>} attr
+	 * 插入新的单元格
+	 * @param {string|Token} inner 单元格内部wikitext
+	 * @param {TableCoords} coord 单元格坐标
+	 * @param {'td'|'th'|'caption'} subtype 单元格类型
+	 * @param {Record<string, string|boolean>} attr 单元格属性
 	 * @returns {TdToken}
 	 * @complexity `n`
 	 */
 	insertTableCell(inner, {column}, subtype = 'td', attr = {}) {
-		const TdToken = require('./td'),
-			token = TdToken.create(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
+		const TdToken = require('./td');
+		const token = TdToken.create(inner, subtype, attr, this.getAttribute('include'), this.getAttribute('config'));
 		return this.insertBefore(token, this.getNthCol(column, true));
 	}
 }