wikiparser-node 0.3.1 → 0.5.0

package/src/table/tr.js

@@ -1,11 +1,30 @@
 'use strict';
 
-const attributeParent = require('../../mixin/attributeParent'),
-	/** @type {Parser} */ Parser = require('../..'),
+const {generateForChild} = require('../../util/lint'),
+	attributeParent = require('../../mixin/attributeParent'),
+	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 templates = {'{|': '(!', '|}': '!)', '||': '!!', '|': '!'},
+		wikitext = syntax.childNodes.map(
+			child => child.type === 'text'
+				? String(child).replaceAll(/\{\||\|\}|\|{2}|\|/gu, p => `{{${templates[p]}}}`)
+				: 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,18 +46,38 @@ class TrToken extends attributeParent(Token, 1) {
 			}),
 			new AttributeToken(attr, 'table-attr', 'tr', config, accum),
 		);
-		this.protectChildren(0, 1);
+		this.getAttribute('protectChildren')(0, 1);
 	}
 
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const errors = super.lint(start),
+			inter = this.childNodes.find(({type}) => type === 'table-inter'),
+			str = String(inter).trim();
+		if (inter && str && !/^<!--.*-->$/u.test(str)) {
+			const error = generateForChild(inter, this.getRootNode().posFromIndex(start), '将被移出表格的内容');
+			error.startLine++;
+			error.startCol = 0;
+			errors.push(error);
+		}
+		return errors;
+	}
+
+	/**
+	 * @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'));
-			token.firstElementChild.safeReplaceWith(syntax);
-			token.children[1].safeReplaceWith(attr);
+			const token = new this.constructor(undefined, undefined, this.getAttribute('config'));
+			token.firstChild.safeReplaceWith(syntax);
+			token.childNodes[1].safeReplaceWith(attr);
 			if (token.type === 'td') { // TdToken
-				token.children[2].safeReplaceWith(inner);
+				token.childNodes[2].safeReplaceWith(inner);
 			} else if (inner !== undefined) {
 				token.appendChild(inner);
 			}
@@ -47,79 +86,84 @@ class TrToken extends attributeParent(Token, 1) {
 		});
 	}
 
+	/** 修复简单的表格语法错误 */
 	#correct() {
-		const [,, child] = this.children;
+		const {childNodes: [,, child]} = this;
 		if (child?.isPlain()) {
-			const {firstChild} = child;
-			if (typeof firstChild !== 'string') {
+			const /** @type {{firstChild: AstText}} */ {firstChild} = child;
+			if (firstChild.type !== 'text') {
 				child.prepend('\n');
-			} else if (!firstChild.startsWith('\n')) {
-				child.setText(`\n${firstChild}`);
+			} else if (firstChild.data[0] !== '\n') {
+				firstChild.insertData(0, '\n');
 			}
 		}
 	}
 
-	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) {
+		for (const child of this.childNodes) {
 			if (child instanceof SyntaxToken) {
-				TrToken.escape(child);
+				escapeTable(child);
 			} else if (child instanceof TrToken) {
 				child.escape();
 			}
 		}
 	}
 
-	/** @param {string} syntax */
-	setSyntax(syntax, esc = false) {
-		const {firstElementChild} = this;
-		firstElementChild.replaceChildren(syntax);
+	/**
+	 * 设置表格语法
+	 * @param {string} syntax 表格语法
+	 * @param {boolean} esc 是否需要转义
+	 */
+	setSyntax(syntax, esc) {
+		const {firstChild} = this;
+		firstChild.replaceChildren(syntax);
 		if (esc) {
-			TrToken.escape(firstElementChild);
+			escapeTable(firstChild);
 		}
 	}
 
 	/**
-	 * @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') {
-				nextElementSibling.independence();
+			const {nextSibling} = child;
+			if (nextSibling?.type === 'td') {
+				nextSibling.independence();
 			}
 		}
 		return super.removeAt(i);
 	}
 
 	/**
-	 * @template {string|Token} T
-	 * @param {T} token
+	 * @override
+	 * @template {AstText|Token} T
+	 * @param {T} token 待插入的子节点
+	 * @param {number} i 插入位置
 	 * @returns {T}
 	 * @complexity `n`
 	 */
@@ -127,8 +171,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,50 +180,62 @@ 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.childNodes.some(
+			child => child instanceof TdToken && child.isIndependent() && child.firstChild.text().at(-1) !== '+',
 		));
 	}
 
 	/**
-	 * @param {(children: Token[], index: number) => Token[]} subset
+	 * 获取相邻行
+	 * @param {(childNodes: 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,
-			index = children.indexOf(this);
-		for (const child of subset(children, index)) {
+		const {childNodes} = parentNode,
+			index = childNodes.indexOf(this);
+		for (const child of subset(childNodes, 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));
+		return this.#getSiblingRow((childNodes, index) => childNodes.slice(index + 1));
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取前一行
+	 * @complexity `n`
+	 */
 	getPreviousRow() {
-		return this.#getSiblingRow((children, index) => children.slice(0, index).reverse());
+		return this.#getSiblingRow((childNodes, index) => childNodes.slice(0, index).reverse());
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取列数
+	 * @complexity `n`
+	 */
 	getColCount() {
 		const TdToken = require('./td');
 		let count = 0,
 			last = 0;
-		for (const child of this.children) {
+		for (const child of this.childNodes) {
 			if (child instanceof TdToken) {
 				last = child.isIndependent() ? Number(child.subtype !== 'caption') : last;
 				count += last;
@@ -189,11 +245,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');
 		}
@@ -204,7 +263,7 @@ class TrToken extends attributeParent(Token, 1) {
 		}
 		const TdToken = require('./td');
 		let last = 0;
-		for (const child of this.children.slice(2)) {
+		for (const child of this.childNodes.slice(2)) {
 			if (child instanceof TdToken) {
 				if (child.isIndependent()) {
 					last = Number(child.subtype !== 'caption');
@@ -213,23 +272,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));
 	}
 }

package/src/tagPair/ext.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const attributeParent = require('../../mixin/attributeParent'),
-	/** @type {Parser} */ Parser = require('../..'),
+	Parser = require('../..'),
 	TagPairToken = require('.');
 
 /**
@@ -11,35 +11,46 @@ const attributeParent = require('../../mixin/attributeParent'),
 class ExtToken extends attributeParent(TagPairToken) {
 	type = 'ext';
 
+	/** @override */
+	get closed() {
+		return super.closed;
+	}
+
 	/**
-	 * @param {string} name
-	 * @param {string|undefined} closing
+	 * @param {string} name 标签名
+	 * @param {string} attr 标签属性
+	 * @param {string} inner 内部wikitext
+	 * @param {string|undefined} closed 是否封闭
 	 * @param {accum} accum
 	 */
-	constructor(name, attr = '', inner = '', closing = undefined, config = Parser.getConfig(), accum = []) {
-		attr = !attr || /^\s/.test(attr) ? attr : ` ${attr}`;
+	constructor(name, attr = '', inner = '', closed = undefined, config = Parser.getConfig(), accum = []) {
+		attr = !attr || attr.trimStart() !== attr ? attr : ` ${attr}`;
+		const AttributeToken = require('../attribute');
 		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, /** @type {Token} */ innerToken;
 		switch (lcName) {
 			case 'choose':
-				ext.add('option');
-				// fall through
-			case 'ref':
 			case 'option':
+			case 'ref':
 			case 'poem':
 			case 'indicator':
 			case 'tab':
 			case 'tabs':
-			case 'pre': {
+			case 'pre':
+			case 'combobox':
+			case 'combooption': {
 				ext.delete(lcName);
-				newConfig.ext = [...ext];
+				newConfig.ext = [
+					...ext,
+					...lcName === 'choose' ? ['option'] : [],
+					...lcName === 'combobox' ? ['combooption'] : [],
+				];
 				const Token = require('..');
 				acceptable = {AttributeToken: 0, Token: 1};
-				innerToken = new Token(inner, newConfig, false, accum);
+				innerToken = new Token(inner, newConfig, true, accum);
 				break;
 			}
 			case 'gallery': {
@@ -50,6 +61,7 @@ class ExtToken extends attributeParent(TagPairToken) {
 				innerToken = new GalleryToken(inner, newConfig, accum);
 				break;
 			}
+
 			/*
 			 * 更多定制扩展的代码示例：
 			 * ```
@@ -69,28 +81,23 @@ class ExtToken extends attributeParent(TagPairToken) {
 				innerToken = new NowikiToken(inner, config);
 			}
 		}
-		innerToken.type = 'ext-inner';
-		innerToken.setAttribute('name', lcName);
+		innerToken.setAttribute('name', lcName).type = 'ext-inner';
 		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});
+		super(name, attrToken, innerToken, closed, config, accum, acceptable);
 	}
 
+	/** @override */
 	cloneNode() {
-		const inner = this.lastElementChild.cloneNode(),
+		const inner = this.lastChild.cloneNode(),
 			tags = this.getAttribute('tags'),
 			config = this.getAttribute('config'),
-			attr = this.firstElementChild.toString(),
+			attr = String(this.firstChild),
 			token = Parser.run(() => new ExtToken(tags[0], attr, '', this.selfClosing ? undefined : tags[1], config));
-		token.lastElementChild.safeReplaceWith(inner);
+		token.lastChild.safeReplaceWith(inner);
 		return token;
 	}
-
-	get innerText() {
-		return this.selfClosing ? '' : this.lastElementChild.text();
-	}
 }
 
 Parser.classes.ExtToken = __filename;

package/src/tagPair/include.js

@@ -1,41 +1,56 @@
 'use strict';
 
 const hidden = require('../../mixin/hidden'),
-	/** @type {Parser} */ Parser = require('../..'),
+	{generateForSelf} = require('../../util/lint'),
+	Parser = require('../..'),
 	TagPairToken = require('.');
 
 /**
  * `<includeonly>`或`<noinclude>`
- * @classdesc `{childNodes: [string, string]}`
+ * @classdesc `{childNodes: [AstText, AstText]}`
  */
 class IncludeToken extends hidden(TagPairToken) {
 	type = 'include';
 
 	/**
-	 * @param {string} name
-	 * @param {string|undefined} inner
-	 * @param {string|undefined} closing
+	 * @param {string} name 标签名
+	 * @param {string} attr 标签属性
+	 * @param {string|undefined} inner 内部wikitext
+	 * @param {string|undefined} closed 是否封闭
 	 * @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]});
+	constructor(name, attr = '', inner = undefined, closed = undefined, config = Parser.getConfig(), accum = []) {
+		super(name, attr, inner ?? '', inner === undefined ? closed : closed ?? '', config, accum, {AstText: [0, 1]});
 	}
 
-	/** @this {IncludeToken & {firstChild: string, lastChild: string}} */
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 * @returns {LintError[]}
+	 */
+	lint(start = 0) {
+		return this.closed ? [] : [generateForSelf(this, this.getRootNode().posFromIndex(start), '未闭合的标签')];
+	}
+
+	/** @override */
 	cloneNode() {
 		const tags = this.getAttribute('tags'),
 			config = this.getAttribute('config'),
-			inner = this.selfClosing ? undefined : this.lastChild,
+			inner = this.selfClosing ? undefined : String(this.lastChild),
 			closing = this.selfClosing || !this.closed ? undefined : tags[1],
-			token = Parser.run(() => new IncludeToken(tags[0], this.firstChild, inner, closing, config));
+			token = Parser.run(() => new IncludeToken(tags[0], String(this.firstChild), inner, closing, config));
 		return token;
 	}
 
-	/** @param {string} str */
+	/**
+	 * @override
+	 * @param {string} str 新文本
+	 */
 	setText(str) {
 		return super.setText(str, 1);
 	}
 
+	/** 清除标签属性 */
 	removeAttr() {
 		super.setText('', 0);
 	}

package/src/tagPair/index.js

@@ -1,30 +1,57 @@
 'use strict';
 
 const fixedToken = require('../../mixin/fixedToken'),
-	/** @type {Parser} */ Parser = require('../..'),
+	Parser = require('../..'),
 	Token = require('..');
 
 /**
  * 成对标签
- * @classdesc `{childNodes: [string|AttributeToken, string|Token]}`
+ * @classdesc `{childNodes: [AstText|AttributeToken, AstText|Token]}`
  */
 class TagPairToken extends fixedToken(Token) {
-	selfClosing;
-	closed;
+	#selfClosing;
+	#closed;
 	#tags;
 
+	/** getter */
+	get selfClosing() {
+		return this.#selfClosing;
+	}
+
+	set selfClosing(value) {
+		value = Boolean(value);
+		if (value !== this.#selfClosing && this.lastChild.text()) {
+			Parser.warn(`<${this.name}>标签内部的${value ? '文本将被隐藏' : '原有文本将再次可见'}！`);
+		}
+		this.#selfClosing = value;
+	}
+
+	/** getter */
+	get closed() {
+		return this.#closed;
+	}
+
+	set closed(value) {
+		this.#closed ||= Boolean(value);
+	}
+
+	/** 内部wikitext */
+	get innerText() {
+		return this.#selfClosing ? undefined : this.lastChild.text();
+	}
+
 	/**
-	 * @param {string} name
-	 * @param {string|Token} attr
-	 * @param {string|Token} inner
-	 * @param {string|undefined} closing - 约定`undefined`表示自闭合，`''`表示未闭合
+	 * @param {string} name 标签名
+	 * @param {string|Token} attr 标签属性
+	 * @param {string|Token} inner 内部wikitext
+	 * @param {string|undefined} closed 是否封闭；约定`undefined`表示自闭合，`''`表示未闭合
 	 * @param {accum} accum
 	 */
-	constructor(name, attr, inner, closing, config = Parser.getConfig(), accum = []) {
+	constructor(name, attr, inner, closed, config = Parser.getConfig(), accum = []) {
 		super(undefined, config, true);
-		this.setAttribute('name', name.toLowerCase()).#tags = [name, closing || name];
-		this.selfClosing = closing === undefined;
-		this.closed = closing !== '';
+		this.setAttribute('name', name.toLowerCase()).#tags = [name, closed || name];
+		this.#selfClosing = closed === undefined;
+		this.#closed = closed !== '';
 		this.append(attr, inner);
 		let index = accum.indexOf(attr);
 		if (index === -1) {
@@ -37,44 +64,60 @@ class TagPairToken extends fixedToken(Token) {
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {TokenAttribute<T>}
 	 */
 	getAttribute(key) {
-		if (key === 'tags') {
-			return [...this.#tags];
-		}
-		return super.getAttribute(key);
+		return key === 'tags' ? [...this.#tags] : super.getAttribute(key);
 	}
 
-	toString() {
-		const {closed, firstChild, lastChild, nextSibling, name, selfClosing} = this,
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		const {firstChild, lastChild, nextSibling, name} = this,
 			[opening, closing] = this.#tags;
-		if (!closed && nextSibling) {
+		if (selector && this.matches(selector)) {
+			return '';
+		} else if (!this.#closed && nextSibling) {
 			Parser.error(`自动闭合 <${name}>`, lastChild);
-			this.closed = true;
+			this.#closed = true;
 		}
-		return selfClosing
+		return this.#selfClosing
 			? `<${opening}${String(firstChild)}/>`
-			: `<${opening}${String(firstChild)}>${String(lastChild)}${this.closed ? `</${closing}>` : ''}`;
+			: `<${opening}${String(firstChild)}>${String(lastChild)}${this.#closed ? `</${closing}>` : ''}`;
 	}
 
+	/** @override */
 	getPadding() {
 		return this.#tags[0].length + 1;
 	}
 
+	/** @override */
 	getGaps() {
 		return 1;
 	}
 
-	/** @returns {string} */
+	/** @override */
+	print() {
+		const [opening, closing] = this.#tags;
+		return super.print(this.#selfClosing
+			? {pre: `&lt;${opening}`, post: '/&gt;'}
+			: {pre: `&lt;${opening}`, sep: '&gt;', post: this.#closed ? `&lt;/${closing}&gt;` : ''});
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
 	text() {
-		const {closed, firstChild, selfClosing} = this,
-			[opening, closing] = this.#tags;
-		return selfClosing
-			? `<${opening}${typeof firstChild === 'string' ? firstChild : firstChild.text()}/>`
-			: `<${opening}${super.text('>')}${closed ? `</${closing}>` : ''}`;
+		const [opening, closing] = this.#tags;
+		return this.#selfClosing
+			? `<${opening}${this.firstChild.text()}/>`
+			: `<${opening}${super.text('>')}${this.#closed ? `</${closing}>` : ''}`;
 	}
 }