wikiparser-node 0.4.0 → 0.6.1

package/lib/element.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const fs = require('fs'),
-	{externalUse} = require('../util/debug'),
-	{toCase, noWrap} = require('../util/string'),
+	path = require('path'),
+	{toCase, noWrap, print} = require('../util/string'),
 	{nth} = require('./ranges'),
 	parseSelector = require('../parser/selector'),
 	Parser = require('..'),
@@ -29,6 +29,7 @@ class AstElement extends AstNode {
 	 * @param {string|undefined} equal 属性规则运算符，`equal`存在时`val`和`i`也一定存在
 	 * @param {string|undefined} val 属性值
 	 * @param {string|undefined} i 是否对大小写不敏感
+	 * @throws `RangeError` 复杂属性
 	 */
 	#matchesAttr = (key, equal, val, i) => {
 		if (!equal) {
@@ -37,14 +38,17 @@ class AstElement extends AstNode {
 			return equal === '!=';
 		}
 		val = toCase(val, i);
+		let thisVal = this.getAttribute(key);
+		if (thisVal instanceof RegExp) {
+			thisVal = thisVal.source;
+		}
 		if (equal === '~=') {
-			let /** @type {Iterable<string>} */ thisVals = this[key];
-			if (typeof thisVals === 'string') {
-				thisVals = thisVals.split(/\s/u);
-			}
+			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} 不能用于选择器！`);
 		}
-		const thisVal = toCase(this.getAttribute(key), i);
+		thisVal = toCase(thisVal, i);
 		switch (equal) {
 			case '|=':
 				return thisVal === val || thisVal.startsWith(`${val}-`);
@@ -61,6 +65,11 @@ class AstElement extends AstNode {
 		}
 	};
 
+	/** 子节点总数 */
+	get length() {
+		return this.childNodes.length;
+	}
+
 	/**
 	 * 全部非文本子节点
 	 * @complexity `n`
@@ -70,14 +79,6 @@ class AstElement extends AstNode {
 		return children;
 	}
 
-	/**
-	 * 非文本子节点总数
-	 * @complexity `n`
-	 */
-	get childElementCount() {
-		return this.children.length;
-	}
-
 	/**
 	 * 首位非文本子节点
 	 * @returns {this}
@@ -88,10 +89,18 @@ class AstElement extends AstNode {
 
 	/**
 	 * 末位非文本子节点
-	 * @returns {this}
+	 * @complexity `n`
 	 */
 	get lastElementChild() {
-		return this.childNodes.findLast(({type}) => type !== 'text');
+		return this.children.at(-1);
+	}
+
+	/**
+	 * 非文本子节点总数
+	 * @complexity `n`
+	 */
+	get childElementCount() {
+		return this.children.length;
 	}
 
 	/** 父节点 */
@@ -138,6 +147,18 @@ class AstElement extends AstNode {
 		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');
@@ -170,71 +191,6 @@ class AstElement extends AstNode {
 		return key === 'matchesAttr' ? this.#matchesAttr : super.getAttribute(key);
 	}
 
-	/**
-	 * @override
-	 * @template {string} T
-	 * @param {T} key 属性键
-	 * @param {TokenAttribute<T>} value 属性值
-	 * @throws `RangeError` 禁止手动指定的属性
-	 */
-	setAttribute(key, value) {
-		if (key === 'name' && externalUse('setAttribute')) {
-			throw new RangeError(`禁止手动指定 ${key} 属性！`);
-		}
-		return super.setAttribute(key, value);
-	}
-
-	/**
-	 * 在末尾批量插入子节点
-	 * @param {...this} elements 插入节点
-	 * @complexity `n`
-	 */
-	append(...elements) {
-		for (const element of elements) {
-			this.appendChild(element);
-		}
-	}
-
-	/**
-	 * 在开头批量插入子节点
-	 * @param {...this} elements 插入节点
-	 * @complexity `n`
-	 */
-	prepend(...elements) {
-		for (let i = 0; i < elements.length; i++) {
-			this.insertAt(elements[i], i);
-		}
-	}
-
-	/**
-	 * 批量替换子节点
-	 * @param {...this} elements 新的子节点
-	 * @complexity `n`
-	 */
-	replaceChildren(...elements) {
-		for (let i = this.childNodes.length - 1; i >= 0; i--) {
-			this.removeAt(i);
-		}
-		this.append(...elements);
-	}
-
-	/**
-	 * 修改文本子节点
-	 * @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;
-		if (type !== 'text') {
-			throw new RangeError(`第 ${i} 个子节点是 ${name}！`);
-		}
-		oldText.replaceData(str);
-		return data;
-	}
-
 	/** 是否受保护。保护条件来自Token，这里仅提前用于:required和:optional伪选择器。 */
 	#isProtected() {
 		const /** @type {{parentNode: AstElement & {constructor: {fixed: boolean}}}} */ {parentNode} = this;
@@ -298,7 +254,7 @@ class AstElement extends AstNode {
 							|| (type === 'file' || type === 'gallery-image' && link);
 					case ':local-link':
 						return (type === 'link' || type === 'file' || type === 'gallery-image')
-							&& link?.startsWith('#');
+							&& link?.[0] === '#';
 					case ':read-only':
 						return fixed;
 					case ':read-write':
@@ -353,17 +309,17 @@ class AstElement extends AstNode {
 	 * @returns {boolean}
 	 * @complexity `n`
 	 */
-	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));
-			});
+	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');
 		}
@@ -393,59 +349,11 @@ class AstElement extends AstNode {
 		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 {parentNode} = this;
-		while (parentNode) {
-			ancestors.push(parentNode);
-			({parentNode} = parentNode);
-		}
-		return ancestors;
-	}
-
-	/**
-	 * 比较和另一个节点的相对位置
-	 * @param {this} other 待比较的节点
-	 * @complexity `n`
-	 * @throws `Error` 不在同一个语法树
-	 */
-	compareDocumentPosition(other) {
-		if (!(other instanceof AstElement)) {
-			this.typeError('compareDocumentPosition', 'AstElement');
-		} else if (this === other) {
-			return 0;
-		} else if (this.contains(other)) {
-			return -1;
-		} else if (other.contains(this)) {
-			return 1;
-		} else if (this.getRootNode() !== other.getRootNode()) {
-			throw new Error('不在同一个语法树！');
-		}
-		const aAncestors = [...this.getAncestors().reverse(), this],
-			bAncestors = [...other.getAncestors().reverse(), other],
-			depth = aAncestors.findIndex((ancestor, i) => bAncestors[i] !== ancestor),
-			commonAncestor = aAncestors[depth - 1],
-			{childNodes} = commonAncestor;
-		return childNodes.indexOf(aAncestors[depth]) - childNodes.indexOf(bAncestors[depth]);
-	}
-
 	/**
 	 * 最近的祖先节点
 	 * @param {string} selector
 	 */
-	closest(selector = '') {
+	closest(selector) {
 		let {parentNode} = this;
 		while (parentNode) {
 			if (parentNode.matches(selector)) {
@@ -462,7 +370,7 @@ class AstElement extends AstNode {
 	 * @returns {this|undefined}
 	 * @complexity `n`
 	 */
-	querySelector(selector = '') {
+	querySelector(selector) {
 		for (const child of this.children) {
 			if (child.matches(selector)) {
 				return child;
@@ -480,7 +388,7 @@ class AstElement extends AstNode {
 	 * @param {string} selector
 	 * @complexity `n`
 	 */
-	querySelectorAll(selector = '') {
+	querySelectorAll(selector) {
 		const /** @type {this[]} */ descendants = [];
 		for (const child of this.children) {
 			if (child.matches(selector)) {
@@ -522,203 +430,151 @@ class AstElement extends AstNode {
 	}
 
 	/**
-	 * 将字符位置转换为行列号
-	 * @param {number} index 字符位置
+	 * 在开头批量插入子节点
+	 * @param {...this} elements 插入节点
 	 * @complexity `n`
 	 */
-	posFromIndex(index) {
-		if (typeof index !== 'number') {
-			this.typeError('posFromIndex', 'Number');
-		}
-		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};
+	prepend(...elements) {
+		for (let i = 0; i < elements.length; i++) {
+			this.insertAt(elements[i], i);
 		}
-		return undefined;
 	}
 
 	/**
-	 * 将行列号转换为字符位置
-	 * @param {number} top 行号
-	 * @param {number} left 列号
+	 * 在末尾批量插入子节点
+	 * @param {...this} elements 插入节点
 	 * @complexity `n`
 	 */
-	indexFromPos(top, left) {
-		if (typeof top !== 'number' || typeof left !== 'number') {
-			this.typeError('indexFromPos', 'Number');
+	append(...elements) {
+		for (const element of elements) {
+			this.insertAt(element);
 		}
-		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`
-	 */
-	#getDimension() {
-		const lines = String(this).split('\n');
-		return {height: lines.length, width: lines.at(-1).length};
 	}
 
 	/**
-	 * 获取当前节点的相对字符位置，或其第`j`个子节点的相对字符位置
-	 * @param {number|undefined} j 子节点序号
+	 * 批量替换子节点
+	 * @param {...this} elements 新的子节点
 	 * @complexity `n`
 	 */
-	getRelativeIndex(j) {
-		if (j !== undefined && typeof j !== 'number') {
-			this.typeError('getRelativeIndex', 'Number');
-		}
-		let /** @type {this[]} */ childNodes;
-
-		/**
-		 * 获取子节点相对于父节点的字符位置，使用前需要先给`childNodes`赋值
-		 * @param {number} end 子节点序号
-		 * @param {this} parent 父节点
-		 * @returns {number}
-		 */
-		const getIndex = (end, parent) => childNodes.slice(0, end).reduce(
-			(acc, cur, i) => acc + String(cur).length + parent.getGaps(i),
-			0,
-		) + parent.getPadding();
-		if (j === undefined) {
-			const {parentNode} = this;
-			if (!parentNode) {
-				return 0;
-			}
-			({childNodes} = parentNode);
-			return getIndex(childNodes.indexOf(this), parentNode);
+	replaceChildren(...elements) {
+		for (let i = this.childNodes.length - 1; i >= 0; i--) {
+			this.removeAt(i);
 		}
-		this.getAttribute('verifyChild')(j, 1);
-		({childNodes} = this);
-		return getIndex(j, this);
-	}
-
-	/**
-	 * 获取当前节点的绝对位置
-	 * @returns {number}
-	 * @complexity `n`
-	 */
-	getAbsoluteIndex() {
-		const {parentNode} = this;
-		return parentNode ? parentNode.getAbsoluteIndex() + this.getRelativeIndex() : 0;
-	}
-
-	/**
-	 * 获取当前节点的相对位置，或其第`j`个子节点的相对位置
-	 * @param {number|undefined} j 子节点序号
-	 * @complexity `n`
-	 */
-	#getPosition(j) {
-		return j === undefined
-			? this.parentNode?.posFromIndex(this.getRelativeIndex()) ?? {top: 0, left: 0}
-			: this.posFromIndex(this.getRelativeIndex(j));
-	}
-
-	/**
-	 * 获取当前节点的行列位置和大小
-	 * @complexity `n`
-	 */
-	getBoundingClientRect() {
-		const root = this.getRootNode();
-		return {...this.#getDimension(), ...root.posFromIndex(this.getAbsoluteIndex())};
-	}
-
-	/** 第一个子节点前的间距 */
-	getPadding() {
-		return 0;
-	}
-
-	/** 子节点间距 */
-	getGaps() {
-		return 0;
+		this.append(...elements);
 	}
 
 	/**
-	 * 行数
-	 * @complexity `n`
+	 * 修改文本子节点
+	 * @param {string} str 新文本
+	 * @param {number} i 子节点位置
+	 * @throws `RangeError` 对应位置的子节点不是文本节点
 	 */
-	get offsetHeight() {
-		return this.#getDimension().height;
+	setText(str, i = 0) {
+		this.getAttribute('verifyChild')(i);
+		const /** @type {AstText} */ oldText = this.childNodes.at(i),
+			{type, data, constructor: {name}} = oldText;
+		if (type === 'text') {
+			oldText.replaceData(str);
+			return data;
+		}
+		throw new RangeError(`第 ${i} 个子节点是 ${name}！`);
 	}
 
 	/**
-	 * 最后一行的列数
-	 * @complexity `n`
+	 * 还原为wikitext
+	 * @param {string} selector
+	 * @param {string} separator 子节点间的连接符
+	 * @returns {string}
 	 */
-	get offsetWidth() {
-		return this.#getDimension().width;
+	toString(selector, separator = '') {
+		return selector && this.matches(selector)
+			? ''
+			: this.childNodes.map(child => child.toString(selector)).join(separator);
 	}
 
-	/**
-	 * 行号
-	 * @complexity `n`
-	 */
-	get offsetTop() {
-		return this.#getPosition().top;
+	static lintIgnoredExt = new Set([
+		'nowiki',
+		'pre',
+		'charinsert',
+		'score',
+		'syntaxhighlight',
+		'source',
+		'math',
+		'chem',
+		'ce',
+		'graph',
+		'mapframe',
+		'maplink',
+		'quiz',
+		'templatedata',
+		'timeline',
+	]);
+
+	/**
+	 * Linter
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const SyntaxToken = require('../src/syntax');
+		if (this instanceof SyntaxToken || this.constructor.hidden
+			|| this.type === 'ext-inner' && AstElement.lintIgnoredExt.has(this.name)
+		) {
+			return [];
+		}
+		const /** @type {LintError[]} */ errors = [];
+		for (let i = 0, cur = start + this.getPadding(); i < this.childNodes.length; i++) {
+			const child = this.childNodes[i];
+			errors.push(...child.lint(cur));
+			cur += String(child).length + this.getGaps(i);
+		}
+		return errors;
 	}
 
 	/**
-	 * 列号
-	 * @complexity `n`
+	 * 以HTML格式打印
+	 * @param {printOpt} opt 选项
+	 * @returns {string}
 	 */
-	get offsetLeft() {
-		return this.#getPosition().left;
+	print(opt = {}) {
+		return String(this)
+			? `<span class="wpb-${opt.class ?? this.type}">${print(this.childNodes, opt)}</span>`
+			: '';
 	}
 
 	/**
-	 * 位置、大小和padding
-	 * @complexity `n`
+	 * 保存为JSON
+	 * @param {string} file 文件名
+	 * @returns {Record<string, *>}
 	 */
-	get style() {
-		return {...this.#getPosition(), ...this.#getDimension(), padding: this.getPadding()};
-	}
-
-	/** 内部高度 */
-	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;
+	json(file) {
+		const {childNodes, ...prop} = this,
+			json = {
+				...prop,
+				childNodes: childNodes.map(child => child.type === 'text' ? String(child) : child.json()),
+			};
+		if (typeof file === 'string') {
+			fs.writeFileSync(
+				path.join(__dirname.slice(0, -4), 'printed', `${file}${file.endsWith('.json') ? '' : '.json'}`),
+				JSON.stringify(json, null, 2),
+			);
+		}
+		return json;
 	}
 
 	/**
 	 * 输出AST
-	 * @template {'markup'|'json'} T
-	 * @param {T} format 输出格式
-	 * @param {T extends 'markup' ? number : string} depth 输出深度
-	 * @returns {T extends 'markup' ? void : Record<string, any>}
+	 * @param {number} depth 当前深度
+	 * @returns {void}
 	 */
-	print(format = 'markup', depth = 0) {
-		if (format === 'json') {
-			const {childNodes, ...prop} = this,
-				json = {
-					...prop,
-					childNodes: childNodes.map(child => child.type === 'text' ? String(child) : child.print('json')),
-				};
-			if (typeof depth === 'string') {
-				fs.writeFileSync(
-					`${__dirname.slice(0, -3)}printed/${depth}${depth.endsWith('.json') ? '' : '.json'}`,
-					JSON.stringify(json, null, 2),
-				);
-			}
-			return json;
-		} else if (typeof depth !== 'number') {
+	echo(depth = 0) {
+		if (!Number.isInteger(depth) || depth < 0) {
 			this.typeError('print', 'Number');
 		}
 		const indent = '  '.repeat(depth),
 			str = String(this),
-			{childNodes, type, firstChild} = this,
+			{childNodes, type} = this,
 			{length} = childNodes;
-		if (!str || length === 0 || firstChild.type === 'text' && String(firstChild) === str) {
+		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;
 		}
@@ -736,11 +592,12 @@ class AstElement extends AstNode {
 			} else if (child.type === 'text') {
 				console.log(`${indent}  ${noWrap(String(child))}`);
 			} else {
-				child.print('markup', depth + 1);
+				child.echo(depth + 1);
 			}
-			i += childStr.length + gap;
+			i += childStr.length;
 			if (gap) {
-				console.log(`${indent}  ${noWrap(str.slice(i - gap, i))}`);
+				console.log(`${indent}  ${noWrap(str.slice(i, i + gap))}`);
+				i += gap;
 			}
 		}
 		if (i < str.length) {