wikiparser-node 0.3.0 → 0.4.0

package/lib/element.js

@@ -4,64 +4,135 @@ const fs = require('fs'),
 	{externalUse} = require('../util/debug'),
 	{toCase, noWrap} = require('../util/string'),
 	{nth} = require('./ranges'),
-	EventEmitter = require('events'),
+	parseSelector = require('../parser/selector'),
+	Parser = require('..'),
 	AstNode = require('./node'),
-	/** @type {Parser} */ Parser = require('..');
-
+	AstText = require('./text');
+
+/**
+ * 检测:lang()伪选择器
+ * @param {AstElement & {attributes: Records<string, string|true>}} node 节点
+ * @param {RegExp} regex 语言正则
+ */
+const matchesLang = ({attributes}, regex) => {
+	const /** @type {string} */ lang = attributes?.lang;
+	return typeof lang === 'string' && regex.test(lang);
+};
+
+/** 类似HTMLElement */
 class AstElement extends AstNode {
-	/** @type {string} */ type;
 	/** @type {string} */ name;
-	#events = new EventEmitter();
 
-	/** @complexity `n` */
+	/**
+	 * 检查是否符合某条属性规则
+	 * @param {string} key 属性键
+	 * @param {string|undefined} equal 属性规则运算符，`equal`存在时`val`和`i`也一定存在
+	 * @param {string|undefined} val 属性值
+	 * @param {string|undefined} i 是否对大小写不敏感
+	 */
+	#matchesAttr = (key, equal, val, i) => {
+		if (!equal) {
+			return this.hasAttribute(key);
+		} else if (!this.hasAttribute(key)) {
+			return equal === '!=';
+		}
+		val = toCase(val, i);
+		if (equal === '~=') {
+			let /** @type {Iterable<string>} */ thisVals = this[key];
+			if (typeof thisVals === 'string') {
+				thisVals = thisVals.split(/\s/u);
+			}
+			return Boolean(thisVals?.[Symbol.iterator]) && [...thisVals].some(v => toCase(v, i) === val);
+		}
+		const thisVal = toCase(this.getAttribute(key), i);
+		switch (equal) {
+			case '|=':
+				return thisVal === val || thisVal.startsWith(`${val}-`);
+			case '^=':
+				return thisVal.startsWith(val);
+			case '$=':
+				return thisVal.endsWith(val);
+			case '*=':
+				return thisVal.includes(val);
+			case '!=':
+				return thisVal !== val;
+			default: // `=`
+				return thisVal === val;
+		}
+	};
+
+	/**
+	 * 全部非文本子节点
+	 * @complexity `n`
+	 */
 	get children() {
-		const /** @type {this[]} */ children = this.childNodes.filter(ele => ele instanceof AstElement);
+		const /** @type {this[]} */ children = this.childNodes.filter(({type}) => type !== 'text');
 		return children;
 	}
-	/** @complexity `n` */
+
+	/**
+	 * 非文本子节点总数
+	 * @complexity `n`
+	 */
 	get childElementCount() {
 		return this.children.length;
 	}
-	/** @returns {this} */
+
+	/**
+	 * 首位非文本子节点
+	 * @returns {this}
+	 */
 	get firstElementChild() {
-		return this.childNodes.find(ele => ele instanceof AstElement);
+		return this.childNodes.find(({type}) => type !== 'text');
 	}
-	/** @complexity `n` */
+
+	/**
+	 * 末位非文本子节点
+	 * @returns {this}
+	 */
 	get lastElementChild() {
-		return this.children.at(-1);
+		return this.childNodes.findLast(({type}) => type !== 'text');
 	}
+
+	/** 父节点 */
 	get parentElement() {
 		return this.parentNode;
 	}
-	get isConnected() {
-		return this.getRootNode().type === 'root';
-	}
-	/** @complexity `n` */
-	get nextElementSibling() {
-		const children = this.parentElement?.children;
-		return children && children[children.indexOf(this) + 1];
-	}
-	/** @complexity `n` */
-	get previousElementSibling() {
-		const children = this.parentElement?.children;
-		return children && children[children.indexOf(this) - 1];
+
+	/**
+	 * AstElement.prototype.text()的getter写法
+	 * @complexity `n`
+	 */
+	get outerText() {
+		return this.text();
 	}
-	/** @complexity `n` */
+
+	/**
+	 * 不可见
+	 */
 	get hidden() {
 		return this.text() === '';
 	}
-	/** @complexity `n` */
+
+	/**
+	 * 后一个可见的兄弟节点
+	 * @complexity `n`
+	 */
 	get nextVisibleSibling() {
 		let {nextSibling} = this;
-		while (nextSibling === '' || nextSibling instanceof AstElement && nextSibling.hidden) {
+		while (nextSibling?.text() === '') {
 			({nextSibling} = nextSibling);
 		}
 		return nextSibling;
 	}
-	/** @complexity `n` */
+
+	/**
+	 * 前一个可见的兄弟节点
+	 * @complexity `n`
+	 */
 	get previousVisibleSibling() {
 		let {previousSibling} = this;
-		while (previousSibling === '' || previousSibling instanceof AstElement && previousSibling.hidden) {
+		while (previousSibling?.text() === '') {
 			({previousSibling} = previousSibling);
 		}
 		return previousSibling;
@@ -72,101 +143,39 @@ class AstElement extends AstNode {
 		this.seal('name');
 	}
 
-	/** @complexity `n` */
-	destroy() {
-		if (this.parentNode) {
-			throw new Error('不能销毁子节点！');
-		}
-		for (const element of this.children) {
-			element.setAttribute('parentNode');
-		}
-		Object.setPrototypeOf(this, null);
-	}
-
 	/**
-	 * @param {string|string[]} types
-	 * @param {AstListener} listener
-	 * @param {{once: boolean}} options
-	 */
-	addEventListener(types, listener, options) {
-		if (Array.isArray(types)) {
-			for (const type of types) {
-				this.addEventListener(type, listener, options);
-			}
-		} else if (typeof types !== 'string' || typeof listener !== 'function') {
-			this.typeError('addEventListener', 'String', 'Function');
-		} else {
-			this.#events[options?.once ? 'once' : 'on'](types, listener);
-		}
-	}
-
-	/**
-	 * @param {string|string[]} types
-	 * @param {AstListener} listener
+	 * 销毁
+	 * @complexity `n`
+	 * @param {boolean} deep 是否从根节点开始销毁
+	 * @throws `Error` 不能销毁子节点
 	 */
-	removeEventListener(types, listener) {
-		if (Array.isArray(types)) {
-			for (const type of types) {
-				this.removeEventListener(type, listener);
-			}
-		} else if (typeof types !== 'string' || typeof listener !== 'function') {
-			this.typeError('removeEventListener', 'String', 'Function');
-		} else {
-			this.#events.off(types, listener);
+	destroy(deep) {
+		if (this.parentNode && !deep) {
+			throw new Error('不能销毁子节点！');
 		}
-	}
-
-	/** @param {string|string[]} types */
-	removeAllEventListeners(types) {
-		if (Array.isArray(types)) {
-			for (const type of types) {
-				this.removeAllEventListeners(type);
-			}
-		} else if (types !== undefined && typeof types !== 'string') {
-			this.typeError('removeAllEventListeners', 'String');
-		} else {
-			this.#events.removeAllListeners(types);
+		this.parentNode?.destroy(deep);
+		for (const child of this.childNodes) {
+			child.setAttribute('parentNode');
 		}
+		Object.setPrototypeOf(this, null);
 	}
 
 	/**
-	 * @param {string} type
-	 * @returns {AstListener[]}
-	 */
-	listEventListeners(type) {
-		if (typeof type !== 'string') {
-			this.typeError('listEventListeners', 'String');
-		}
-		return this.#events.listeners(type);
-	}
-
-	/**
-	 * @param {AstEvent} e
-	 * @param {any} data
+	 * @override
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @returns {TokenAttribute<T>}
 	 */
-	dispatchEvent(e, data) {
-		if (!(e instanceof Event)) {
-			this.typeError('dispatchEvent', 'Event');
-		} else if (!e.target) { // 初始化
-			Object.defineProperty(e, 'target', {value: this, enumerable: true});
-			e.stopPropagation = function() {
-				Object.defineProperty(this, 'bubbles', {value: false});
-			};
-		}
-		Object.defineProperties(e, { // 每次bubble更新
-			prevTarget: {value: e.currentTarget, enumerable: true, configurable: true},
-			currentTarget: {value: this, enumerable: true, configurable: true},
-		});
-		this.#events.emit(e.type, e, data);
-		if (e.bubbles && this.parentElement) {
-			this.parentElement.dispatchEvent(e, data);
-		}
+	getAttribute(key) {
+		return key === 'matchesAttr' ? this.#matchesAttr : super.getAttribute(key);
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
-	 * @param {TokenAttribute<T>} value
+	 * @param {T} key 属性键
+	 * @param {TokenAttribute<T>} value 属性值
+	 * @throws `RangeError` 禁止手动指定的属性
 	 */
 	setAttribute(key, value) {
 		if (key === 'name' && externalUse('setAttribute')) {
@@ -175,36 +184,9 @@ class AstElement extends AstNode {
 		return super.setAttribute(key, value);
 	}
 
-	/** @param {number} i */
-	removeAt(i) {
-		const element = super.removeAt(i),
-			e = new Event('remove', {bubbles: true});
-		this.dispatchEvent(e, {position: i, removed: element});
-		return element;
-	}
-
 	/**
-	 * @template {string|this} T
-	 * @param {T} element
-	 * @complexity `n`
-	 */
-	insertAt(element, i = this.childNodes.length) {
-		super.insertAt(element, i);
-		const e = new Event('insert', {bubbles: true});
-		this.dispatchEvent(e, {position: i < 0 ? i + this.childNodes.length - 1 : i, inserted: element});
-		return element;
-	}
-
-	/** @param {string} str */
-	setText(str, i = 0) {
-		const oldText = super.setText(str, i),
-			e = new Event('text', {bubbles: true});
-		this.dispatchEvent(e, {position: i, oldText, newText: str});
-		return oldText;
-	}
-
-	/**
-	 * @param {...string|this} elements
+	 * 在末尾批量插入子节点
+	 * @param {...this} elements 插入节点
 	 * @complexity `n`
 	 */
 	append(...elements) {
@@ -214,17 +196,19 @@ class AstElement extends AstNode {
 	}
 
 	/**
-	 * @param {...string|this} elements
+	 * 在开头批量插入子节点
+	 * @param {...this} elements 插入节点
 	 * @complexity `n`
 	 */
 	prepend(...elements) {
-		for (const [i, element] of elements.entries()) {
-			this.insertAt(element, i);
+		for (let i = 0; i < elements.length; i++) {
+			this.insertAt(elements[i], i);
 		}
 	}
 
 	/**
-	 * @param {...string|this} elements
+	 * 批量替换子节点
+	 * @param {...this} elements 新的子节点
 	 * @complexity `n`
 	 */
 	replaceChildren(...elements) {
@@ -235,253 +219,211 @@ class AstElement extends AstNode {
 	}
 
 	/**
-	 * @param {(string|this)[]} elements
-	 * @param {number} offset
-	 * @complexity `n`
+	 * 修改文本子节点
+	 * @param {string} str 新文本
+	 * @param {number} i 子节点位置
+	 * @throws `RangeError` 对应位置的子节点不是文本节点
 	 */
-	#insertAdjacent(elements, offset) {
-		const {parentNode} = this;
-		if (!parentNode) {
-			throw new Error('不存在父节点！');
-		}
-		const i = parentNode.childNodes.indexOf(this) + offset;
-		for (const [j, element] of elements.entries()) {
-			parentNode.insertAt(element, i + j);
+	setText(str, i = 0) {
+		this.getAttribute('verifyChild')(i);
+		const /** @type {AstText} */ oldText = this.childNodes.at(i),
+			{type, data, constructor: {name}} = oldText;
+		if (type !== 'text') {
+			throw new RangeError(`第 ${i} 个子节点是 ${name}！`);
 		}
+		oldText.replaceData(str);
+		return data;
 	}
 
-	/**
-	 * @param {...string|this} elements
-	 * @complexity `n`
-	 */
-	after(...elements) {
-		this.#insertAdjacent(elements, 1);
-	}
-
-	/**
-	 * @param {...string|this} elements
-	 * @complexity `n`
-	 */
-	before(...elements) {
-		this.#insertAdjacent(elements, 0);
-	}
-
-	/** @complexity `n` */
-	remove() {
-		const {parentNode} = this;
+	/** 是否受保护。保护条件来自Token，这里仅提前用于:required和:optional伪选择器。 */
+	#isProtected() {
+		const /** @type {{parentNode: AstElement & {constructor: {fixed: boolean}}}} */ {parentNode} = this;
 		if (!parentNode) {
-			throw new Error('不存在父节点！');
+			return undefined;
 		}
-		parentNode.removeChild(this);
-	}
-
-	/**
-	 * @param {...string|this} elements
-	 * @complexity `n`
-	 */
-	replaceWith(...elements) {
-		this.after(...elements);
-		this.remove();
+		const {childNodes, constructor: {fixed}} = parentNode,
+			protectedIndices = parentNode.getAttribute('protectedChildren')?.applyTo(childNodes);
+		return fixed || protectedIndices?.includes(childNodes.indexOf(this));
 	}
 
 	/**
-	 * @param {string} key
-	 * @param {string|undefined} equal - `equal`存在时`val`和`i`也一定存在
-	 * @param {string|undefined} val
-	 * @param {string|undefined} i
+	 * 检查是否符合解析后的选择器，不含节点关系
+	 * @this {AstElement & {link: string, constructor: {fixed: boolean}}}
+	 * @param {SelectorArray} step 解析后的选择器
+	 * @throws `SyntaxError` 未定义的伪选择器
 	 */
-	matchesAttr(key, equal, val, i) {
-		if (externalUse('matchesAttr')) {
-			throw new Error(`禁止外部调用 ${this.constructor.name}.matchesAttr 方法！`);
-		} else if (!equal) {
-			return this.hasAttribute(key);
-		} else if (!this.hasAttribute(key)) {
-			return equal === '!=';
-		}
-		val = toCase(val, i);
-		if (equal === '~=') {
-			let /** @type {Iterable<string>} */ thisVals = this[key];
-			if (typeof thisVals === 'string') {
-				thisVals = thisVals.split(/\s/);
+	#matches(step) {
+		const {parentNode, type, name, childNodes, link, constructor: {fixed, name: tokenName}} = this,
+			children = parentNode?.children,
+			childrenOfType = children?.filter(({type: t}) => t === type),
+			siblingsCount = children?.length ?? 1,
+			siblingsCountOfType = childrenOfType?.length ?? 1,
+			index = (children?.indexOf(this) ?? 0) + 1,
+			indexOfType = (childrenOfType?.indexOf(this) ?? 0) + 1,
+			lastIndex = siblingsCount - index + 1,
+			lastIndexOfType = siblingsCountOfType - indexOfType + 1;
+		return step.every(selector => {
+			if (typeof selector === 'string') {
+				switch (selector) { // 情形1：简单伪选择器、type和name
+					case '*':
+						return true;
+					case ':root':
+						return !parentNode;
+					case ':first-child':
+						return index === 1;
+					case ':first-of-type':
+						return indexOfType === 1;
+					case ':last-child':
+						return lastIndex === 1;
+					case ':last-of-type':
+						return lastIndexOfType === 1;
+					case ':only-child':
+						return siblingsCount === 1;
+					case ':only-of-type':
+						return siblingsCountOfType === 1;
+					case ':empty':
+						return !childNodes.some(child => child instanceof AstElement || String(child));
+					case ':parent':
+						return childNodes.some(child => child instanceof AstElement || String(child));
+					case ':header':
+						return type === 'heading';
+					case ':hidden':
+						return this.text() === '';
+					case ':visible':
+						return this.text() !== '';
+					case ':only-whitespace':
+						return this.text().trim() === '';
+					case ':any-link':
+						return type === 'link' || type === 'free-ext-link' || type === 'ext-link'
+							|| (type === 'file' || type === 'gallery-image' && link);
+					case ':local-link':
+						return (type === 'link' || type === 'file' || type === 'gallery-image')
+							&& link?.startsWith('#');
+					case ':read-only':
+						return fixed;
+					case ':read-write':
+						return !fixed;
+					case ':invalid':
+						return type === 'table-inter' || tokenName === 'HiddenToken';
+					case ':required':
+						return this.#isProtected() === true;
+					case ':optional':
+						return this.#isProtected() === false;
+					default: {
+						const [t, n] = selector.split('#');
+						return (!t || t === type || Boolean(Parser.typeAliases[type]?.includes(t)))
+							&& (!n || n === name);
+					}
+				}
+			} else if (selector.length === 4) { // 情形2：属性选择器
+				return this.getAttribute('matchesAttr')(...selector);
 			}
-			return Boolean(thisVals?.[Symbol.iterator]) && [...thisVals].some(v => toCase(v, i) === val);
-		}
-		const thisVal = toCase(this.getAttribute(key), i);
-		switch (equal) {
-			case '|=':
-				return thisVal === val || thisVal.startsWith(`${val}-`);
-			case '^=':
-				return thisVal.startsWith(val);
-			case '$=':
-				return thisVal.endsWith(val);
-			case '*=':
-				return thisVal.includes(val);
-			case '!=':
-				return thisVal !== val;
-			default: // `=`
-				return thisVal === val;
-		}
+			const [s, pseudo] = selector; // 情形3：复杂伪选择器
+			switch (pseudo) {
+				case 'is':
+					return this.matches(s);
+				case 'not':
+					return !this.matches(s);
+				case 'nth-child':
+					return nth(s, index);
+				case 'nth-of-type':
+					return nth(s, indexOfType);
+				case 'nth-last-child':
+					return nth(s, lastIndex);
+				case 'nth-last-of-type':
+					return nth(s, lastIndexOfType);
+				case 'contains':
+					return this.text().includes(s);
+				case 'has':
+					return Boolean(this.querySelector(s));
+				case 'lang': {
+					const regex = new RegExp(`^${s}(?:-|$)`, 'u');
+					return matchesLang(this, regex)
+						|| this.getAncestors().some(ancestor => matchesLang(ancestor, regex));
+				}
+				default:
+					throw new SyntaxError(`未定义的伪选择器！${pseudo}`);
+			}
+		});
 	}
 
-	/** @type {Record<pseudo, boolean>} */ static #pseudo = {
-		root: false,
-		is: true,
-		not: true,
-		'nth-child': true,
-		'nth-of-type': true,
-		'nth-last-child': true,
-		'nth-last-of-type': true,
-		'first-child': false,
-		'first-of-type': false,
-		'last-child': false,
-		'last-of-type': false,
-		'only-child': false,
-		'only-of-type': false,
-		empty: false,
-		contains: true,
-		has: true,
-		header: false,
-		parent: false,
-		hidden: false,
-		visible: false,
-	};
-	/** @type {pseudo[]} */ static #pseudoKeys = Object.keys(AstElement.#pseudo);
-	static #pseudoRegex = new RegExp(
-		`:(${this.#pseudoKeys.join('|')})(?:\\(\\s*("[^"]*"|'[^']*'|[^()]*?)\\s*\\))?(?=:|\\s*(?:,|$))`,
-		'g',
-	);
-	static #simplePseudoRegex = new RegExp(`:(?:${this.#pseudoKeys.join('|')})(?:\\(.*?\\))?(?=:|\\s*(?:,|$))`, 'g');
-
 	/**
+	 * 检查是否符合选择器
+	 * @param {string|SelectorArray[]} selector
 	 * @returns {boolean}
 	 * @complexity `n`
 	 */
-	matches(selector = '', simple = false) {
-		if (typeof selector !== 'string') {
+	matches(selector = '') {
+		if (typeof selector === 'string') {
+			return Parser.run(() => {
+				const stack = parseSelector(selector),
+					/** @type {Set<string>} */
+					pseudos = new Set(stack.flat(2).filter(step => typeof step === 'string' && step.startsWith(':')));
+				if (pseudos.size > 0) {
+					Parser.warn('检测到伪选择器，请确认是否需要将":"转义成"\\:"。', pseudos);
+				}
+				return stack.some(condition => this.matches(condition));
+			});
+		} else if (!Parser.running) {
 			this.typeError('matches', 'String');
-		} else if (!selector.trim()) {
-			return true;
-		}
-		simple &&= Parser.running;
-		const /** @type {Record<string, string>} */ escapedQuotes = {'"': '&quot;', "'": '&apos;'},
-			escapedSelector = selector.replace(/\\["']/g, m => escapedQuotes[m[1]]);
-		if (simple || !AstElement.#pseudoRegex.test(escapedSelector)) {
-			if (!simple && selector.includes(',')) {
-				return Parser.run(() => selector.split(',').some(str => this.matches(str, true)));
-			}
-			const mt = escapedSelector.match(AstElement.#simplePseudoRegex);
-			if (mt) {
-				Parser.error(
-					'检测到不规范的伪选择器！嵌套伪选择器时请使用引号包裹内层，多层嵌套时请使用"\\"转义引号。',
-					mt.map(s => s.replace(
-						/&(quot|apos);/g,
-						/** @param {string} p1 */ (_, p1) => `\\${p1 === 'quot' ? '"' : "'"}`,
-					)),
-				);
-			}
-			const /** @type {Record<string, string>} */ entities = {comma: ',', ratio: ':'},
-				/** @type {string[][]} */ attributes = [],
-				plainSelector = selector.replace(
-					/&(comma|ratio);/g, /** @param {string} name */ (_, name) => entities[name],
-				).replace(
-					/\[\s*(\w+)\s*(?:([~|^$*!]?=)\s*("[^"]*"|'[^']*'|[^[\]]*?)\s*(\si)?\s*)?]/g,
-					/** @type {function(...string): ''} */ (_, key, equal, val, i) => {
-						if (equal) {
-							const quotes = val.match(/^(["']).*\1$/)?.[1];
-							attributes.push([
-								key,
-								equal,
-								quotes ? val.slice(1, -1).replaceAll(escapedQuotes[quotes], quotes) : val,
-								i,
-							]);
-						} else {
-							attributes.push([key]);
-						}
-						return '';
-					},
-				),
-				[type, ...parts] = plainSelector.trim().split('#'),
-				name = parts.join('#');
-			return (!type || this.type === type || Boolean(Parser.typeAliases[this.type]?.includes(type)))
-				&& (!name || this.name === name)
-				&& attributes.every(args => this.matchesAttr(...args));
 		}
-		/*
-		 * 先将`\\'`转义成`&apos;`，将`\\"`转义成`&quot;`，即escapedSelector
-		 * 在去掉一重`:pseudo()`时，如果使用了`'`，则将内部的`&apos;`解码成`'`；如果使用了`"`，则将内部的`&quot;`解码成`"`
-		 */
-		const /** @type {pseudoCall} */ calls = Object.fromEntries(AstElement.#pseudoKeys.map(f => [f, []])),
-			selectors = escapedSelector.replace(
-				AstElement.#pseudoRegex,
-				/** @type {function(...string): string} */ (m, f, arg) => {
-					if (!arg) {
-						calls[f].push('');
-						return m;
+		selector = structuredClone(selector);
+		const step = selector.pop();
+		if (this.#matches(step)) {
+			const {parentNode, previousElementSibling} = this;
+			switch (selector.at(-1)?.relation) {
+				case undefined:
+					return true;
+				case '>':
+					return parentNode?.matches(selector);
+				case '+':
+					return previousElementSibling?.matches(selector);
+				case '~': {
+					if (!parentNode) {
+						return false;
 					}
-					const quotes = arg.match(/^(["']).*\1$/)?.[1];
-					calls[f].push(quotes ? arg.slice(1, -1).replaceAll(escapedQuotes[quotes], quotes) : arg);
-					return `:${f}(${calls[f].length - 1})`;
-				},
-			).split(','),
-			{parentElement, hidden} = this,
-			childNodes = parentElement?.childNodes,
-			childrenOfType = parentElement?.children?.filter(child => child.type === this.type),
-			index = (childNodes?.indexOf(this) ?? 0) + 1,
-			indexOfType = (childrenOfType?.indexOf(this) ?? 0) + 1,
-			lastIndex = (childNodes?.length ?? 1) - index + 1,
-			lastIndexOfType = (childrenOfType?.length ?? 1) - indexOfType + 1,
-			content = this.toString(),
-			plainPseudo = AstElement.#pseudoKeys.filter(f => !AstElement.#pseudo[f] && calls[f].length);
-		if (plainPseudo.length) {
-			Parser.warn('检测到伪选择器，请确认是否需要将":"转义成"&ratio;"。', plainPseudo);
+					const {children} = parentNode,
+						i = children.indexOf(this);
+					return children.slice(0, i).some(child => child.matches(selector));
+				}
+				default: // ' '
+					return this.getAncestors().some(ancestor => ancestor.matches(selector));
+			}
 		}
-		return selectors.some(str => {
-			const /** @type {pseudoCall} */ curCalls = Object.fromEntries(AstElement.#pseudoKeys.map(f => [f, []]));
-			str = str.replace(AstElement.#pseudoRegex, /** @type {function(...string): ''} */ (_, f, i) => {
-				curCalls[f].push(i ? calls[f][i] : '');
-				return '';
-			});
-			return Parser.run(() => this.matches(str, true))
-				&& (curCalls.root.length === 0 || !parentElement)
-				&& curCalls.is.every(s => this.matches(s))
-				&& !curCalls.not.some(s => this.matches(s))
-				&& curCalls['nth-child'].every(s => nth(s, index))
-				&& curCalls['nth-of-type'].every(s => nth(s, indexOfType))
-				&& curCalls['nth-last-child'].every(s => nth(s, lastIndex))
-				&& curCalls['nth-last-of-type'].every(s => nth(s, lastIndexOfType))
-				&& (curCalls['first-child'].length === 0 || nth('1', index))
-				&& (curCalls['first-of-type'].length === 0 || nth('1', indexOfType))
-				&& (curCalls['last-child'].length === 0 || nth('1', lastIndex))
-				&& (curCalls['last-of-type'].length === 0 || nth('1', lastIndexOfType))
-				&& (curCalls['only-child'].length === 0 || !parentElement || childNodes.length === 1)
-				&& (curCalls['only-of-type'].length === 0 || !parentElement || childrenOfType.length === 1)
-				&& (curCalls.empty.length === 0 || this.childElementCount === 0)
-				&& curCalls.contains.every(s => content.includes(s))
-				&& curCalls.has.every(s => Boolean(this.querySelector(s)))
-				&& (curCalls.header.length === 0 || this.type === 'heading')
-				&& (curCalls.parent.length === 0 || this.childElementCount > 0)
-				&& (curCalls.hidden.length === 0 || hidden)
-				&& (curCalls.visible.length === 0 || !hidden);
-		});
+		return false;
+	}
+
+	/**
+	 * 还原为wikitext
+	 * @param {string} selector
+	 * @param {string} separator 子节点间的连接符
+	 */
+	toString(selector, separator = '') {
+		return selector && this.matches(selector)
+			? ''
+			: this.childNodes.map(child => child.toString(selector)).join(separator);
 	}
 
+	/** 获取所有祖先节点 */
 	getAncestors() {
 		const /** @type {this[]} */ ancestors = [];
-		let {parentElement} = this;
-		while (parentElement) {
-			ancestors.push(parentElement);
-			({parentElement} = parentElement);
+		let {parentNode} = this;
+		while (parentNode) {
+			ancestors.push(parentNode);
+			({parentNode} = parentNode);
 		}
 		return ancestors;
 	}
 
 	/**
-	 * @param {this} other
+	 * 比较和另一个节点的相对位置
+	 * @param {this} other 待比较的节点
 	 * @complexity `n`
+	 * @throws `Error` 不在同一个语法树
 	 */
-	comparePosition(other) {
+	compareDocumentPosition(other) {
 		if (!(other instanceof AstElement)) {
-			this.typeError('comparePosition', 'AstElement');
+			this.typeError('compareDocumentPosition', 'AstElement');
 		} else if (this === other) {
 			return 0;
 		} else if (this.contains(other)) {
@@ -499,17 +441,24 @@ class AstElement extends AstNode {
 		return childNodes.indexOf(aAncestors[depth]) - childNodes.indexOf(bAncestors[depth]);
 	}
 
+	/**
+	 * 最近的祖先节点
+	 * @param {string} selector
+	 */
 	closest(selector = '') {
-		let {parentElement} = this;
-		while (parentElement) {
-			if (parentElement.matches(selector)) {
-				return parentElement;
+		let {parentNode} = this;
+		while (parentNode) {
+			if (parentNode.matches(selector)) {
+				return parentNode;
 			}
-			({parentElement} = parentElement);
+			({parentNode} = parentNode);
 		}
+		return undefined;
 	}
 
 	/**
+	 * 符合选择器的第一个后代节点
+	 * @param {string} selector
 	 * @returns {this|undefined}
 	 * @complexity `n`
 	 */
@@ -523,9 +472,14 @@ class AstElement extends AstNode {
 				return descendant;
 			}
 		}
+		return undefined;
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 符合选择器的所有后代节点
+	 * @param {string} selector
+	 * @complexity `n`
+	 */
 	querySelectorAll(selector = '') {
 		const /** @type {this[]} */ descendants = [];
 		for (const child of this.children) {
@@ -538,59 +492,93 @@ class AstElement extends AstNode {
 	}
 
 	/**
-	 * @param {number} index
+	 * 类选择器
+	 * @param {string} className 类名之一
+	 */
+	getElementsByClassName(className) {
+		return typeof className === 'string'
+			? this.querySelectorAll(`[className~="${className.replaceAll(/(?<!\\)"/gu, '\\"')}"]`)
+			: this.typeError('getElementsByClassName', 'String');
+	}
+
+	/**
+	 * 标签名选择器
+	 * @param {string} name 标签名
+	 */
+	getElementsByTagName(name) {
+		if (typeof name === 'string') {
+			name = name.replaceAll(/(?<!\\)"/gu, '\\"');
+			return this.querySelectorAll(`ext[name="${name}"], html[name="${name}"]`);
+		}
+		return this.typeError('getElementsByTagName', 'String');
+	}
+
+	/**
+	 * 获取某一行的wikitext
+	 * @param {number} n 行号
+	 */
+	getLine(n) {
+		return String(this).split('\n', n + 1).at(-1);
+	}
+
+	/**
+	 * 将字符位置转换为行列号
+	 * @param {number} index 字符位置
 	 * @complexity `n`
 	 */
 	posFromIndex(index) {
 		if (typeof index !== 'number') {
 			this.typeError('posFromIndex', 'Number');
 		}
-		const text = this.toString();
-		if (index < -text.length || index >= text.length || !Number.isInteger(index)) {
-			return;
+		const text = String(this);
+		if (index >= -text.length && index < text.length && Number.isInteger(index)) {
+			const lines = text.slice(0, index).split('\n');
+			return {top: lines.length - 1, left: lines.at(-1).length};
 		}
-		const lines = text.slice(0, index).split('\n');
-		return {top: lines.length - 1, left: lines.at(-1).length};
+		return undefined;
 	}
 
 	/**
-	 * @param {number} top
-	 * @param {number} left
+	 * 将行列号转换为字符位置
+	 * @param {number} top 行号
+	 * @param {number} left 列号
 	 * @complexity `n`
 	 */
 	indexFromPos(top, left) {
 		if (typeof top !== 'number' || typeof left !== 'number') {
 			this.typeError('indexFromPos', 'Number');
-		} else if (top < 0 || left < 0 || !Number.isInteger(top) || !Number.isInteger(left)) {
-			return;
 		}
-		const lines = this.toString().split('\n');
-		if (lines.length < top + 1 || lines[top].length < left) {
-			return;
-		}
-		return lines.slice(0, top).reduce((acc, curLine) => acc + curLine.length + 1, 0) + left;
+		const lines = String(this).split('\n');
+		return top >= 0 && left >= 0 && Number.isInteger(top) && Number.isInteger(left)
+			&& lines.length >= top + 1 && lines[top].length >= left
+			? lines.slice(0, top).reduce((acc, curLine) => acc + curLine.length + 1, 0) + left
+			: undefined;
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取行数和最后一行的列数
+	 * @complexity `n`
+	 */
 	#getDimension() {
-		const lines = this.toString().split('\n');
+		const lines = String(this).split('\n');
 		return {height: lines.length, width: lines.at(-1).length};
 	}
 
 	/**
-	 * 获取当前节点的相对位置，或其第`j`个子节点的相对位置
-	 * @param {number|undefined} j
+	 * 获取当前节点的相对字符位置，或其第`j`个子节点的相对字符位置
+	 * @param {number|undefined} j 子节点序号
 	 * @complexity `n`
 	 */
 	getRelativeIndex(j) {
 		if (j !== undefined && typeof j !== 'number') {
 			this.typeError('getRelativeIndex', 'Number');
 		}
-		let /** @type {(string|this)[]} */ childNodes;
+		let /** @type {this[]} */ childNodes;
+
 		/**
-		 * 使用前需要先给`childNodes`赋值
-		 * @param {number} end
-		 * @param {this} parent
+		 * 获取子节点相对于父节点的字符位置，使用前需要先给`childNodes`赋值
+		 * @param {number} end 子节点序号
+		 * @param {this} parent 父节点
 		 * @returns {number}
 		 */
 		const getIndex = (end, parent) => childNodes.slice(0, end).reduce(
@@ -598,14 +586,14 @@ class AstElement extends AstNode {
 			0,
 		) + parent.getPadding();
 		if (j === undefined) {
-			const {parentElement} = this;
-			if (!parentElement) {
+			const {parentNode} = this;
+			if (!parentNode) {
 				return 0;
 			}
-			({childNodes} = parentElement);
-			return getIndex(childNodes.indexOf(this), parentElement);
+			({childNodes} = parentNode);
+			return getIndex(childNodes.indexOf(this), parentNode);
 		}
-		this.verifyChild(j, 1);
+		this.getAttribute('verifyChild')(j, 1);
 		({childNodes} = this);
 		return getIndex(j, this);
 	}
@@ -616,74 +604,97 @@ class AstElement extends AstNode {
 	 * @complexity `n`
 	 */
 	getAbsoluteIndex() {
-		const {parentElement} = this;
-		return parentElement ? parentElement.getAbsoluteIndex() + this.getRelativeIndex() : 0;
+		const {parentNode} = this;
+		return parentNode ? parentNode.getAbsoluteIndex() + this.getRelativeIndex() : 0;
 	}
 
 	/**
 	 * 获取当前节点的相对位置，或其第`j`个子节点的相对位置
-	 * @param {number|undefined} j
+	 * @param {number|undefined} j 子节点序号
 	 * @complexity `n`
 	 */
 	#getPosition(j) {
-		if (j === undefined) {
-			const {parentElement} = this;
-			if (!parentElement) {
-				return {top: 0, left: 0};
-			}
-			return parentElement.posFromIndex(this.getRelativeIndex());
-		}
-		return this.posFromIndex(this.getRelativeIndex(j));
+		return j === undefined
+			? this.parentNode?.posFromIndex(this.getRelativeIndex()) ?? {top: 0, left: 0}
+			: this.posFromIndex(this.getRelativeIndex(j));
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取当前节点的行列位置和大小
+	 * @complexity `n`
+	 */
 	getBoundingClientRect() {
 		const root = this.getRootNode();
 		return {...this.#getDimension(), ...root.posFromIndex(this.getAbsoluteIndex())};
 	}
 
-	/** @complexity `n` */
+	/** 第一个子节点前的间距 */
+	getPadding() {
+		return 0;
+	}
+
+	/** 子节点间距 */
+	getGaps() {
+		return 0;
+	}
+
+	/**
+	 * 行数
+	 * @complexity `n`
+	 */
 	get offsetHeight() {
 		return this.#getDimension().height;
 	}
-	/** @complexity `n` */
+
+	/**
+	 * 最后一行的列数
+	 * @complexity `n`
+	 */
 	get offsetWidth() {
 		return this.#getDimension().width;
 	}
-	/** @complexity `n` */
+
+	/**
+	 * 行号
+	 * @complexity `n`
+	 */
 	get offsetTop() {
 		return this.#getPosition().top;
 	}
-	/** @complexity `n` */
+
+	/**
+	 * 列号
+	 * @complexity `n`
+	 */
 	get offsetLeft() {
 		return this.#getPosition().left;
 	}
 
-	getPadding() {
-		return 0;
-	}
-
-	getGaps() {
-		return 0;
-	}
-
-	/** @complexity `n` */
+	/**
+	 * 位置、大小和padding
+	 * @complexity `n`
+	 */
 	get style() {
 		return {...this.#getPosition(), ...this.#getDimension(), padding: this.getPadding()};
 	}
 
-	/**
-	 * @returns {boolean}
-	 * @complexity `n`
-	 */
-	get eof() {
-		return this.type === 'root' || !this.nextSibling && this.parentElement.eof;
+	/** 内部高度 */
+	get clientHeight() {
+		const {innerText} = this;
+		return typeof innerText === 'string' ? innerText.split('\n').length : undefined;
+	}
+
+	/** 内部宽度 */
+	get clientWidth() {
+		const {innerText} = this;
+		return typeof innerText === 'string' ? innerText.split('\n').at(-1).length : undefined;
 	}
 
 	/**
+	 * 输出AST
 	 * @template {'markup'|'json'} T
-	 * @param {T} format
-	 * @param {T extends 'markup' ? number : string} depth
+	 * @param {T} format 输出格式
+	 * @param {T extends 'markup' ? number : string} depth 输出深度
 	 * @returns {T extends 'markup' ? void : Record<string, any>}
 	 */
 	print(format = 'markup', depth = 0) {
@@ -691,7 +702,7 @@ class AstElement extends AstNode {
 			const {childNodes, ...prop} = this,
 				json = {
 					...prop,
-					childNodes: childNodes.map(child => typeof child === 'string' ? child : child.print('json')),
+					childNodes: childNodes.map(child => child.type === 'text' ? String(child) : child.print('json')),
 				};
 			if (typeof depth === 'string') {
 				fs.writeFileSync(
@@ -704,25 +715,26 @@ class AstElement extends AstNode {
 			this.typeError('print', 'Number');
 		}
 		const indent = '  '.repeat(depth),
-			str = this.toString(),
+			str = String(this),
 			{childNodes, type, firstChild} = this,
 			{length} = childNodes;
-		if (!str || length === 0 || typeof firstChild === 'string' && firstChild === str) {
-			console.log(`${indent}\x1b[32m<%s>\x1b[0m${noWrap(str)}\x1b[32m</%s>\x1b[0m`, type, type);
-			return;
+		if (!str || length === 0 || firstChild.type === 'text' && String(firstChild) === str) {
+			console.log(`${indent}\x1B[32m<%s>\x1B[0m${noWrap(str)}\x1B[32m</%s>\x1B[0m`, type, type);
+			return undefined;
 		}
 		Parser.info(`${indent}<${type}>`);
 		let i = this.getPadding();
 		if (i) {
 			console.log(`${indent}  ${noWrap(str.slice(0, i))}`);
 		}
-		for (const [j, child] of childNodes.entries()) {
-			const childStr = String(child),
+		for (let j = 0; j < length; j++) {
+			const child = childNodes[j],
+				childStr = String(child),
 				gap = j === length - 1 ? 0 : this.getGaps(j);
 			if (!childStr) {
 				// pass
-			} else if (typeof child === 'string') {
-				console.log(`${indent}  ${noWrap(child)}`);
+			} else if (child.type === 'text') {
+				console.log(`${indent}  ${noWrap(String(child))}`);
 			} else {
 				child.print('markup', depth + 1);
 			}
@@ -735,11 +747,7 @@ class AstElement extends AstNode {
 			console.log(`${indent}  ${noWrap(str.slice(i))}`);
 		}
 		Parser.info(`${indent}</${type}>`);
-	}
-
-	/** @param {number} n */
-	getLine(n) {
-		return this.toString().split('\n', n + 1).at(-1);
+		return undefined;
 	}
 }