wikiparser-node 0.0.0

package/src/table/td.js

@@ -0,0 +1,259 @@
+'use strict';
+
+const fixedToken = require('../../mixin/fixedToken'),
+	{externalUse, typeError} = require('../../util/debug'),
+	/** @type {Parser} */ Parser = require('../..'),
+	Token = require('..'),
+	TrToken = require('./tr');
+
+/**
+ * `<td>`、`<th>`和`<caption>`
+ * @classdesc `{childNodes: [SyntaxToken, AttributeToken, Token]}`
+ */
+class TdToken extends fixedToken(TrToken) {
+	type = 'td';
+	#innerSyntax = '';
+
+	/** @complexity `n` */
+	get subtype() {
+		return this.getSyntax().subtype;
+	}
+	set subtype(subtype) {
+		this.setSyntax(subtype);
+	}
+
+	get rowspan() {
+		return this.getAttr('rowspan');
+	}
+	set rowspan(rowspan) {
+		this.setAttr('rowspan', rowspan);
+	}
+	get colspan() {
+		return this.getAttr('colspan');
+	}
+	set colspan(colspan) {
+		this.setAttr('colspan', colspan);
+	}
+
+	isIndependent() {
+		return this.firstElementChild.text().startsWith('\n');
+	}
+
+	/**
+	 * @returns {{subtype: 'td'|'th'|'caption', escape: boolean, correction: boolean}}
+	 * @complexity `n`
+	 */
+	getSyntax() {
+		const syntax = this.firstElementChild.text(),
+			escape = syntax.includes('{{');
+		let subtype = 'td';
+		if (syntax.endsWith('!')) {
+			subtype = 'th';
+		} else if (syntax.endsWith('+')) {
+			subtype = 'caption';
+		}
+		if (this.isIndependent()) {
+			return {subtype, escape, correction: false};
+		}
+		const {previousElementSibling} = this;
+		if (previousElementSibling?.type !== 'td') {
+			return {subtype, escape, correction: true};
+		}
+		const result = previousElementSibling.getSyntax();
+		result.escape ||= escape;
+		result.correction = previousElementSibling.lastElementChild.offsetHeight > 1;
+		if (subtype === 'th' && result.subtype !== 'th') {
+			result.subtype = 'th';
+			result.correction = true;
+		}
+		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 {accum} accum
+	 */
+	constructor(syntax, inner, config = Parser.getConfig(), accum = []) {
+		let innerSyntax = inner?.match(/\||\x00\d+!\x7f/),
+			attr = innerSyntax ? inner.slice(0, innerSyntax.index) : '';
+		if (/\[\[|-{/.test(attr)) {
+			innerSyntax = null;
+			attr = '';
+		}
+		super(syntax, attr, config, accum, TdToken.openingPattern);
+		if (innerSyntax) {
+			[this.#innerSyntax] = innerSyntax;
+		}
+		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));
+	}
+
+	cloneNode() {
+		const token = super.cloneNode();
+		token.setAttribute('innerSyntax', this.#innerSyntax);
+		return token;
+	}
+
+	/**
+	 * @param {string|Token} inner
+	 * @param {'td'|'th'|'caption'} subtype
+	 * @param {Record<string, string>} attr
+	 */
+	static create(inner, subtype = 'td', attr = {}, include = false, config = Parser.getConfig()) {
+		if (typeof inner !== 'string' && (!(inner instanceof Token) || !inner.isPlain()) || typeof attr !== 'object') {
+			throw new TypeError('TdToken.create 方法仅接受 String、Token、Object 作为输入参数！');
+		} else if (!['td', 'th', 'caption'].includes(subtype)) {
+			throw new RangeError('单元格的子类型只能为 "td"、"th" 或 "caption"！');
+		} else if (typeof inner === 'string') {
+			inner = Parser.parse(inner, include, undefined, config);
+		}
+		const token = Parser.run(() => new TdToken('\n|', undefined, config));
+		token.setSyntax(subtype);
+		token.lastElementChild.safeReplaceWith(inner);
+		for (const [k, v] of Object.entries(attr)) {
+			token.setAttr(k, v);
+		}
+		return token;
+	}
+
+	/**
+	 * @template {string} T
+	 * @param {T} key
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		if (key === 'innerSyntax') {
+			return this.#innerSyntax;
+		}
+		return super.getAttribute(key);
+	}
+
+	/**
+	 * @template {string} T
+	 * @param {T} key
+	 * @param {TokenAttribute<T>} value
+	 */
+	setAttribute(key, value) {
+		if (key !== 'innerSyntax') {
+			return super.setAttribute(key, value);
+		} else if (!Parser.debugging && externalUse('setAttribute')) {
+			throw new RangeError(`使用 ${this.constructor.name}.setAttribute 方法设置私有属性 #${key} 仅用于代码调试！`);
+		}
+		this.#innerSyntax = String(value);
+		return this;
+	}
+
+	build() {
+		if (this.#innerSyntax.includes('\x00')) {
+			this.#innerSyntax = this.buildFromStr(this.#innerSyntax).map(String).join('');
+		}
+		return this;
+	}
+
+	static #aliases = {td: '\n|', th: '\n!', caption: '\n|+'};
+
+	/** @param {string} syntax */
+	setSyntax(syntax, escape = false) {
+		super.setSyntax(TdToken.#aliases[syntax] ?? syntax, escape);
+	}
+
+	/** @complexity `n` */
+	#correct() {
+		if (this.children[1].toString()) {
+			this.#innerSyntax ||= '|';
+		}
+		const {subtype, escape, correction} = this.getSyntax();
+		if (correction) {
+			this.setSyntax(subtype, escape);
+		}
+	}
+
+	/** @complexity `n` */
+	independence() {
+		if (!this.isIndependent()) {
+			const {subtype, escape} = this.getSyntax();
+			this.setSyntax(subtype, escape);
+		}
+	}
+
+	/**
+	 * @returns {string}
+	 * @complexity `n`
+	 */
+	toString() {
+		this.#correct();
+		const [syntax, attr, inner] = this.children;
+		return `${syntax.toString()}${attr.toString()}${this.#innerSyntax}${inner.toString()}`;
+	}
+
+	getGaps(i = 0) {
+		if (i !== 1) {
+			return 0;
+		}
+		this.#correct();
+		return this.#innerSyntax.length;
+	}
+
+	/**
+	 * @returns {string}
+	 * @complexity `n`
+	 */
+	text() {
+		this.#correct();
+		const [syntax, attr, inner] = this.children;
+		return `${syntax.text()}${attr.text()}${this.#innerSyntax}${inner.text()}`;
+	}
+
+	/**
+	 * @template {string} T
+	 * @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;
+	}
+
+	/**
+	 * @template {string} T
+	 * @param {T} key
+	 * @param {T extends 'rowspan'|'colspan' ? number : string|boolean} value
+	 */
+	setAttr(key, value) {
+		if (typeof key !== 'string') {
+			typeError(this, 'setAttr', 'String');
+		}
+		key = key.toLowerCase().trim();
+		if (typeof value === 'number' && ['rowspan', 'colspan'].includes(key)) {
+			value = value === 1 ? false : String(value);
+		}
+		const /** @type {boolean} */ result = super.setAttr(key, value);
+		if (!this.children[1].toString()) {
+			this.#innerSyntax = '';
+		}
+		return result;
+	}
+
+	escape() {
+		super.escape();
+		if (this.children[1].toString()) {
+			this.#innerSyntax ||= '{{!}}';
+		}
+		if (this.#innerSyntax === '|') {
+			this.#innerSyntax = '{{!}}';
+		}
+	}
+}
+
+Parser.classes.TdToken = __filename;
+module.exports = TdToken;

package/src/table/tr.js

@@ -0,0 +1,244 @@
+'use strict';
+
+const attributeParent = require('../../mixin/attributeParent'),
+	{typeError} = require('../../util/debug'),
+	/** @type {Parser} */ Parser = require('../..'),
+	Token = require('..'),
+	SyntaxToken = require('../syntax'),
+	AttributeToken = require('../attribute');
+
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributeToken, ?(string|Token), ...TdToken]}`
+ */
+class TrToken extends attributeParent(Token, 1) {
+	type = 'tr';
+
+	static openingPattern = /^\n[^\S\n]*(?:\|-+|{{\s*!\s*}}-+|{{\s*!-\s*}}-*)$/;
+
+	/**
+	 * @param {string} syntax
+	 * @param {accum} accum
+	 */
+	constructor(syntax, attr = '', config = Parser.getConfig(), accum = [], pattern = TrToken.openingPattern) {
+		super(undefined, config, true, accum, {String: 2, Token: 2, SyntaxToken: 0, AttributeToken: 1, TdToken: '2:'});
+		this.append(
+			new SyntaxToken(syntax, pattern, 'table-syntax', config, accum, {
+				'Stage-1': ':', '!ExtToken': '', TranscludeToken: ':',
+			}),
+			new AttributeToken(attr, 'table-attr', 'tr', config, accum),
+		);
+		this.protectChildren(0, 1);
+	}
+
+	cloneNode() {
+		const [syntax, attr, inner, ...cloned] = this.cloneChildren(),
+			/** @type {typeof TrToken} */ Constructor = this.constructor;
+		return Parser.run(() => {
+			const token = new Constructor(undefined, undefined, this.getAttribute('config'));
+			token.firstElementChild.safeReplaceWith(syntax);
+			token.children[1].safeReplaceWith(attr);
+			if (token.childElementCount > 2) { // TdToken
+				token.children[2].safeReplaceWith(inner);
+			} else if (inner !== undefined) {
+				token.appendChild(inner);
+			}
+			token.append(...cloned);
+			return token;
+		});
+	}
+
+	#correct() {
+		const [,, child] = this.childNodes;
+		if (typeof child === 'string' && !child.startsWith('\n')) {
+			this.setText(`\n${child}`, 2);
+		} else if (typeof child !== 'string' && child?.isPlain()) {
+			const {firstChild} = child;
+			if (typeof firstChild !== 'string') {
+				child.prepend('\n');
+			} else if (!firstChild.startsWith('\n')) {
+				child.setText(`\n${firstChild}`, 0);
+			}
+		}
+	}
+
+	toString() {
+		this.#correct();
+		return super.toString();
+	}
+
+	text() {
+		this.#correct();
+		const str = super.text();
+		return this.type === 'tr' && !str.trim().includes('\n') ? '' : str;
+	}
+
+	/** @param {SyntaxToken} syntax */
+	static escape(syntax) {
+		if (!(syntax instanceof SyntaxToken)) {
+			typeError('SyntaxToken');
+		}
+		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` */
+	escape() {
+		for (const child of this.children) {
+			if (child instanceof SyntaxToken) {
+				TrToken.escape(child);
+			} else if (child instanceof TrToken) {
+				child.escape();
+			}
+		}
+	}
+
+	/** @param {string} syntax */
+	setSyntax(syntax, escape = false) {
+		const {firstElementChild} = this;
+		firstElementChild.replaceChildren(syntax);
+		if (escape) {
+			TrToken.escape(firstElementChild);
+		}
+	}
+
+	/**
+	 * @param {number} i
+	 * @complexity `n`
+	 */
+	removeAt(i) {
+		const TdToken = require('./td'),
+			child = this.childNodes.at(i);
+		if (child instanceof TdToken && child.isIndependent()) {
+			const {nextElementSibling} = child;
+			if (nextElementSibling?.type === 'td') {
+				nextElementSibling.independence();
+			}
+		}
+		return super.removeAt(i);
+	}
+
+	/**
+	 * @template {string|Token} T
+	 * @param {T} token
+	 * @returns {T}
+	 * @complexity `n`
+	 */
+	insertAt(token, i = this.childNodes.length) {
+		if (!Parser.running && !(token instanceof TrToken)) {
+			typeError(this, 'insertAt', 'TrToken');
+		}
+		const TdToken = require('./td'),
+			child = this.childNodes.at(i);
+		if (token instanceof TdToken && token.isIndependent() && child instanceof TdToken) {
+			child.independence();
+		}
+		return super.insertAt(token, i);
+	}
+
+	/**
+	 * @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('+'),
+		));
+	}
+
+	/**
+	 * @param {(children: Token[], index: number) => Token[]} subset
+	 * @complexity `n`
+	 */
+	#getSiblingRow(subset) {
+		const {parentElement} = this;
+		if (!parentElement) {
+			return;
+		}
+		const {children} = parentElement,
+			index = children.indexOf(this);
+		for (const child of subset(children, index)) {
+			if (child instanceof TrToken && child.getRowCount()) {
+				return child;
+			}
+		}
+	}
+
+	/** @complexity `n` */
+	getNextRow() {
+		return this.#getSiblingRow((children, index) => children.slice(index + 1));
+	}
+
+	/** @complexity `n` */
+	getPreviousRow() {
+		return this.#getSiblingRow((children, index) => children.slice(0, index).reverse());
+	}
+
+	/** @complexity `n` */
+	getColCount() {
+		const TdToken = require('./td');
+		let count = 0,
+			last = 0;
+		for (const child of this.children) {
+			if (child instanceof TdToken) {
+				last = child.isIndependent() ? Number(child.subtype !== 'caption') : last;
+				count += last;
+			}
+		}
+		return count;
+	}
+
+	/**
+	 * @param {number} n
+	 * @returns {TdToken}
+	 * @complexity `n`
+	 */
+	getNthCol(n, insert = false) {
+		if (typeof n !== 'number') {
+			typeError(this, 'getNthCol', 'Number');
+		}
+		const nCols = this.getColCount();
+		n = n < 0 ? n + nCols : n;
+		if (n < 0 || n > nCols || n === nCols && !insert) {
+			throw new RangeError(`不存在第 ${n} 个单元格！`);
+		}
+		const TdToken = require('./td'); // eslint-disable-line no-unused-vars
+		let last = 0;
+		for (const child of this.children.slice(2)) {
+			if (child instanceof TdToken) {
+				if (child.isIndependent()) {
+					last = Number(child.subtype !== 'caption');
+				}
+				n -= last;
+				if (n < 0) {
+					return child;
+				}
+			} else if (['tr', 'table-syntax'].includes(child.type)) {
+				return child;
+			}
+		}
+	}
+
+	/**
+	 * @param {string|Token} inner
+	 * @param {TableCoords}
+	 * @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'));
+		return this.insertBefore(token, this.getNthCol(column, true));
+	}
+}
+
+Parser.classes.TrToken = __filename;
+module.exports = TrToken;

package/src/tagPair/ext.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const attributeParent = require('../../mixin/attributeParent'),
+	/** @type {Parser} */ Parser = require('../..'),
+	TagPairToken = require('.');
+
+/**
+ * 扩展标签
+ * @classdesc `{childNodes: [AttributeToken, NowikiToken|Token]}`
+ */
+class ExtToken extends attributeParent(TagPairToken) {
+	type = 'ext';
+
+	/**
+	 * @param {string} name
+	 * @param {string|undefined} closing
+	 * @param {accum} accum
+	 */
+	constructor(name, attr = '', inner = '', closing = undefined, config = Parser.getConfig(), accum = []) {
+		attr = !attr || /^\s/.test(attr) ? attr : ` ${attr}`;
+		const lcName = name.toLowerCase(),
+			AttributeToken = require('../attribute'),
+			attrToken = new AttributeToken(attr, 'ext-attr', lcName, config, accum),
+			newConfig = structuredClone(config),
+			ext = new Set(newConfig.ext);
+		let /** @type {acceptable} */ acceptable, innerToken;
+		switch (lcName) {
+			case 'choose':
+				ext.add('option');
+				// fall through
+			case 'ref':
+			case 'option':
+			case 'poem':
+			case 'indicator':
+			case 'tab':
+			case 'tabs':
+			case 'pre': {
+				ext.delete(lcName);
+				newConfig.ext = [...ext];
+				const Token = require('..');
+				acceptable = {AttributeToken: 0, Token: 1};
+				innerToken = new Token(inner, newConfig, false, accum);
+				break;
+			}
+			/*
+			 * 更多定制扩展的代码示例：
+			 * ```
+			 * case 'extensionName': {
+			 * 	ext.delete(this.name);
+			 * 	newConfig.ext = [...ext];
+			 * 	const ExtensionToken = require('../extension');
+			 * 	acceptable = {AttributeToken: 0, ExtensionToken: 1};
+			 * 	innerToken = new ExtensionToken(extInner, newConfig, false, accum);
+			 * 	break;
+			 * }
+			 * ```
+			 */
+			default: {
+				const NowikiToken = require('../nowiki');
+				acceptable = {AttributeToken: 0, NowikiToken: 1};
+				innerToken = new NowikiToken(inner, config);
+			}
+		}
+		innerToken.type = 'ext-inner';
+		innerToken.setAttribute('name', lcName);
+		if (lcName === 'pre') {
+			innerToken.setAttribute('stage', Parser.MAX_STAGE - 1);
+		}
+		super(name, attrToken, innerToken, closing, config, accum, acceptable);
+		Object.defineProperty(this, 'closed', {value: true, enumerable: false, writable: false, configurable: false});
+	}
+
+	cloneNode() {
+		const inner = this.lastElementChild.cloneNode(),
+			tags = this.getAttribute('tags'),
+			config = this.getAttribute('config'),
+			attr = this.firstElementChild.toString(),
+			token = Parser.run(() => new ExtToken(tags[0], attr, '', this.selfClosing ? undefined : tags[1], config));
+		token.lastElementChild.safeReplaceWith(inner);
+		return token;
+	}
+}
+
+Parser.classes.ExtToken = __filename;
+module.exports = ExtToken;

package/src/tagPair/include.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const hidden = require('../../mixin/hidden'),
+	/** @type {Parser} */ Parser = require('../..'),
+	TagPairToken = require('.');
+
+/**
+ * `<includeonly>`或`<noinclude>`
+ * @classdesc `{childNodes: [string, string]}`
+ */
+class IncludeToken extends hidden(TagPairToken) {
+	type = 'include';
+
+	/**
+	 * @param {string} name
+	 * @param {string|undefined} inner
+	 * @param {string|undefined} closing
+	 * @param {accum} accum
+	 */
+	constructor(name, attr = '', inner = undefined, closing = undefined, config = Parser.getConfig(), accum = []) {
+		super(name, attr, inner ?? '', inner !== undefined ? closing ?? '' : closing, config, accum, {String: [0, 1]});
+	}
+
+	/** @this {IncludeToken & {firstChild: string, lastChild: string}} */
+	cloneNode() {
+		const tags = this.getAttribute('tags'),
+			config = this.getAttribute('config'),
+			inner = this.selfClosing ? undefined : this.lastChild,
+			closing = this.selfClosing || !this.closed ? undefined : tags[1],
+			token = Parser.run(() => new IncludeToken(tags[0], this.firstChild, inner, closing, config));
+		return token;
+	}
+
+	/** @param {string} str */
+	setText(str) {
+		return super.setText(str, 1);
+	}
+
+	removeAttr() {
+		super.setText('', 0);
+	}
+}
+
+Parser.classes.IncludeToken = __filename;
+module.exports = IncludeToken;