wikiparser-node 0.8.0 → 0.8.1-m

package/lib/element.js

@@ -2,437 +2,27 @@
 
 const fs = require('fs'),
 	path = require('path'),
-	{toCase, noWrap, print} = require('../util/string'),
-	{nth} = require('./ranges'),
-	parseSelector = require('../parser/selector'),
-	Parser = require('..'),
 	AstNode = require('./node'),
 	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} */ name;
 
-	/**
-	 * 检查是否符合某条属性规则
-	 * @param {string} key 属性键
-	 * @param {string|undefined} equal 属性规则运算符，`equal`存在时`val`和`i`也一定存在
-	 * @param {string|undefined} val 属性值
-	 * @param {string|undefined} i 是否对大小写不敏感
-	 * @throws `RangeError` 复杂属性
-	 */
-	#matchesAttr = (key, equal, val, i) => {
-		if (!equal) {
-			return this.hasAttribute(key);
-		} else if (!this.hasAttribute(key)) {
-			return equal === '!=';
-		}
-		val = toCase(val, i);
-		let thisVal = this.getAttribute(key);
-		if (thisVal instanceof RegExp) {
-			thisVal = thisVal.source;
-		}
-		if (equal === '~=') {
-			const thisVals = typeof thisVal === 'string' ? thisVal.split(/\s/u) : thisVal;
-			return Boolean(thisVals?.[Symbol.iterator]) && [...thisVals].some(v => toCase(v, i) === val);
-		} else if (typeof thisVal !== 'string') {
-			throw new RangeError(`复杂属性 ${key} 不能用于选择器！`);
-		}
-		thisVal = toCase(thisVal, 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;
-		}
-	};
-
 	/** 子节点总数 */
 	get length() {
 		return this.childNodes.length;
 	}
 
-	/**
-	 * 全部非文本子节点
-	 * @complexity `n`
-	 */
-	get children() {
-		const /** @type {this[]} */ children = this.childNodes.filter(({type}) => type !== 'text');
-		return children;
-	}
-
-	/**
-	 * 首位非文本子节点
-	 * @returns {this}
-	 */
-	get firstElementChild() {
-		return this.childNodes.find(({type}) => type !== 'text');
-	}
-
-	/**
-	 * 末位非文本子节点
-	 * @complexity `n`
-	 */
-	get lastElementChild() {
-		return this.children.at(-1);
-	}
-
-	/**
-	 * 非文本子节点总数
-	 * @complexity `n`
-	 */
-	get childElementCount() {
-		return this.children.length;
-	}
-
-	/** 父节点 */
-	get parentElement() {
-		return this.parentNode;
-	}
-
-	/**
-	 * AstElement.prototype.text()的getter写法
-	 * @complexity `n`
-	 */
-	get outerText() {
-		return this.text();
-	}
-
-	/**
-	 * 不可见
-	 */
-	get hidden() {
-		return this.text() === '';
-	}
-
-	/**
-	 * 后一个可见的兄弟节点
-	 * @complexity `n`
-	 */
-	get nextVisibleSibling() {
-		let {nextSibling} = this;
-		while (nextSibling?.text() === '') {
-			({nextSibling} = nextSibling);
-		}
-		return nextSibling;
-	}
-
-	/**
-	 * 前一个可见的兄弟节点
-	 * @complexity `n`
-	 */
-	get previousVisibleSibling() {
-		let {previousSibling} = this;
-		while (previousSibling?.text() === '') {
-			({previousSibling} = previousSibling);
-		}
-		return previousSibling;
-	}
-
-	/** 内部高度 */
-	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;
-	}
-
-	constructor() {
-		super();
-		this.seal('name');
-	}
-
-	/**
-	 * 销毁
-	 * @complexity `n`
-	 * @param {boolean} deep 是否从根节点开始销毁
-	 * @throws `Error` 不能销毁子节点
-	 */
-	destroy(deep) {
-		if (this.parentNode && !deep) {
-			throw new Error('不能销毁子节点！');
-		}
-		this.parentNode?.destroy(deep);
-		for (const child of this.childNodes) {
-			child.setAttribute('parentNode');
-		}
-		Object.setPrototypeOf(this, null);
-	}
-
-	/**
-	 * @override
-	 * @template {string} T
-	 * @param {T} key 属性键
-	 * @returns {TokenAttribute<T>}
-	 */
-	getAttribute(key) {
-		return key === 'matchesAttr' ? this.#matchesAttr : super.getAttribute(key);
-	}
-
-	/** 是否受保护。保护条件来自Token，这里仅提前用于:required和:optional伪选择器。 */
-	#isProtected() {
-		const /** @type {{parentNode: AstElement & {constructor: {fixed: boolean}}}} */ {parentNode} = this;
-		if (!parentNode) {
-			return undefined;
-		}
-		const {childNodes, constructor: {fixed}} = parentNode,
-			protectedIndices = parentNode.getAttribute('protectedChildren')?.applyTo(childNodes);
-		return fixed || protectedIndices?.includes(childNodes.indexOf(this));
-	}
-
-	/**
-	 * 检查是否符合解析后的选择器，不含节点关系
-	 * @this {AstElement & {link: string, constructor: {fixed: boolean}}}
-	 * @param {SelectorArray} step 解析后的选择器
-	 * @throws `SyntaxError` 未定义的伪选择器
-	 */
-	#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?.[0] === '#';
-					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);
-			}
-			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}`);
-			}
-		});
-	}
-
-	/**
-	 * 检查是否符合选择器
-	 * @param {string|SelectorArray[]} selector
-	 * @returns {boolean}
-	 * @complexity `n`
-	 */
-	matches(selector) {
-		if (selector === undefined) {
-			return true;
-		} else if (typeof selector === 'string') {
-			const stack = parseSelector(selector),
-				/** @type {Set<string>} */
-				pseudos = new Set(stack.flat(2).filter(step => typeof step === 'string' && step[0] === ':'));
-			if (pseudos.size > 0) {
-				Parser.warn('检测到伪选择器，请确认是否需要将":"转义成"\\:"。', pseudos);
-			}
-			return Parser.run(() => stack.some(condition => this.matches(condition)));
-		} else if (!Parser.running) {
-			this.typeError('matches', 'String');
-		}
-		selector = [...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 {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 false;
-	}
-
-	/**
-	 * 符合选择器的第一个后代节点
-	 * @param {string} selector
-	 * @returns {this|undefined}
-	 * @complexity `n`
-	 */
-	querySelector(selector) {
-		for (const child of this.children) {
-			if (child.matches(selector)) {
-				return child;
-			}
-			const descendant = child.querySelector(selector);
-			if (descendant) {
-				return descendant;
-			}
-		}
-		return undefined;
-	}
-
-	/**
-	 * 符合选择器的所有后代节点
-	 * @param {string} selector
-	 * @complexity `n`
-	 */
-	querySelectorAll(selector) {
-		const /** @type {this[]} */ descendants = [];
-		for (const child of this.children) {
-			if (child.matches(selector)) {
-				descendants.push(child);
-			}
-			descendants.push(...child.querySelectorAll(selector));
-		}
-		return descendants;
-	}
-
-	/**
-	 * 类选择器
-	 * @param {string} className 类名之一
-	 */
-	getElementsByClassName(className) {
-		return typeof className === 'string'
-			? this.querySelectorAll(`[className~="${className.replace(/(?<!\\)"/gu, '\\"')}"]`)
-			: this.typeError('getElementsByClassName', 'String');
-	}
-
-	/**
-	 * 标签名选择器
-	 * @param {string} name 标签名
-	 */
-	getElementsByTagName(name) {
-		if (typeof name === 'string') {
-			name = name.replace(/(?<!\\)"/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 {...this} elements 插入节点
-	 * @complexity `n`
-	 */
-	prepend(...elements) {
-		for (let i = 0; i < elements.length; i++) {
-			this.insertAt(elements[i], i);
-		}
-	}
-
 	/**
 	 * 最近的祖先节点
 	 * @param {string} selector
 	 */
 	closest(selector) {
+		const types = new Set(selector.split(',').map(type => type.trim()));
 		let {parentNode} = this;
 		while (parentNode) {
-			if (parentNode.matches(selector)) {
+			if (types.has(parentNode.type)) {
 				return parentNode;
 			}
 			({parentNode} = parentNode);
@@ -457,9 +47,7 @@ class AstElement extends AstNode {
 	 * @complexity `n`
 	 */
 	replaceChildren(...elements) {
-		for (let i = this.length - 1; i >= 0; i--) {
-			this.removeAt(i);
-		}
+		this.childNodes.length = 0;
 		this.append(...elements);
 	}
 
@@ -467,29 +55,24 @@ class AstElement extends AstNode {
 	 * 修改文本子节点
 	 * @param {string} str 新文本
 	 * @param {number} i 子节点位置
-	 * @throws `RangeError` 对应位置的子节点不是文本节点
 	 */
 	setText(str, i = 0) {
-		this.getAttribute('verifyChild')(i);
-		const /** @type {AstText} */ oldText = this.childNodes.at(i),
-			{type, data, constructor: {name}} = oldText;
+		const /** @type {AstText} */ oldText = this.childNodes[i],
+			{type, data} = oldText;
 		if (type === 'text') {
 			oldText.replaceData(str);
 			return data;
 		}
-		throw new RangeError(`第 ${i} 个子节点是 ${name}！`);
+		return undefined;
 	}
 
 	/**
 	 * 还原为wikitext
-	 * @param {string} selector
 	 * @param {string} separator 子节点间的连接符
 	 * @returns {string}
 	 */
 	toString(selector, separator = '') {
-		return selector && this.matches(selector)
-			? ''
-			: this.childNodes.map(child => child.toString(selector)).join(separator);
+		return this.childNodes.map(child => child.toString()).join(separator);
 	}
 
 	static lintIgnoredExt = new Set([
@@ -530,17 +113,6 @@ class AstElement extends AstNode {
 		return errors;
 	}
 
-	/**
-	 * 以HTML格式打印
-	 * @param {printOpt} opt 选项
-	 * @returns {string}
-	 */
-	print(opt = {}) {
-		return String(this)
-			? `<span class="wpb-${opt.class || this.type}">${print(this.childNodes, opt)}</span>`
-			: '';
-	}
-
 	/**
 	 * 保存为JSON
 	 * @param {string} file 文件名
@@ -560,52 +132,6 @@ class AstElement extends AstNode {
 		}
 		return json;
 	}
-
-	/**
-	 * 输出AST
-	 * @param {number} depth 当前深度
-	 * @returns {void}
-	 */
-	echo(depth = 0) {
-		if (!Number.isInteger(depth) || depth < 0) {
-			this.typeError('print', 'Number');
-		}
-		const indent = '  '.repeat(depth),
-			str = String(this),
-			{childNodes, type, length} = this;
-		if (childNodes.every(child => child.type === 'text' || !String(child))) {
-			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 (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 (child.type === 'text') {
-				console.log(`${indent}  ${noWrap(String(child))}`);
-			} else {
-				child.echo(depth + 1);
-			}
-			i += childStr.length;
-			if (gap) {
-				console.log(`${indent}  ${noWrap(str.slice(i, i + gap))}`);
-				i += gap;
-			}
-		}
-		if (i < str.length) {
-			console.log(`${indent}  ${noWrap(str.slice(i))}`);
-		}
-		Parser.info(`${indent}</${type}>`);
-		return undefined;
-	}
 }
 
-Parser.classes.AstElement = __filename;
 module.exports = AstElement;