wikiparser-node 0.3.0 → 0.4.0

package/src/converterFlags.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const /** @type {Parser} */ Parser = require('..'),
+const Parser = require('..'),
 	Token = require('.'),
 	AtomToken = require('./atom');
 
@@ -13,7 +13,7 @@ class ConverterFlagsToken extends Token {
 	/** @type {string[]} */ #flags;
 
 	/**
-	 * @param {string[]} flags
+	 * @param {string[]} flags 转换类型标记
 	 * @param {accum} accum
 	 */
 	constructor(flags, config = Parser.getConfig(), accum = []) {
@@ -21,30 +21,34 @@ class ConverterFlagsToken extends Token {
 		this.append(...flags.map(flag => new AtomToken(flag, 'converter-flag', config, accum)));
 	}
 
+	/** @override */
 	cloneNode() {
-		const cloned = this.cloneChildren(),
+		const cloned = this.cloneChildNodes(),
 			token = Parser.run(() => new ConverterFlagsToken([], this.getAttribute('config')));
 		token.append(...cloned);
 		token.afterBuild();
 		return token;
 	}
 
-	/** @complexity `n` */
+	/**
+	 * @override
+	 * @complexity `n`
+	 */
 	afterBuild() {
 		this.#flags = this.children.map(child => child.text().trim());
-		const that = this,
-			/** @type {AstListener} */ converterFlagsListener = ({prevTarget}) => {
-				if (prevTarget) {
-					that.#flags[that.childNodes.indexOf(prevTarget)] = prevTarget.text().trim();
-				}
-			};
+		const /** @type {AstListener} */ converterFlagsListener = ({prevTarget}) => {
+			if (prevTarget) {
+				this.#flags[this.childNodes.indexOf(prevTarget)] = prevTarget.text().trim();
+			}
+		};
 		this.addEventListener(['remove', 'insert', 'text', 'replace'], converterFlagsListener);
 		return this;
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {TokenAttribute<T>}
 	 */
 	getAttribute(key) {
@@ -55,7 +59,8 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {number} i
+	 * @override
+	 * @param {number} i 移除位置
 	 * @complexity `n`
 	 */
 	removeAt(i) {
@@ -65,7 +70,9 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {AtomToken} token
+	 * @override
+	 * @param {AtomToken} token 待插入的子节点
+	 * @param {number} i 插入位置
 	 * @complexity `n`
 	 */
 	insertAt(token, i = this.childNodes.length) {
@@ -74,20 +81,27 @@ class ConverterFlagsToken extends Token {
 		return token;
 	}
 
-	toString() {
-		return super.toString(';');
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		return super.toString(selector, ';');
 	}
 
+	/** @override */
 	getGaps() {
 		return 1;
 	}
 
+	/** @override */
 	text() {
 		return super.text(';');
 	}
 
 	/**
-	 * @param {string} flag
+	 * 获取转换类型标记节点
+	 * @param {string} flag 转换类型标记
 	 * @returns {AtomToken[]}
 	 * @complexity `n`
 	 */
@@ -95,16 +109,28 @@ class ConverterFlagsToken extends Token {
 		return this.#flags.includes(flag) ? this.children.filter(child => child.text().trim() === flag) : [];
 	}
 
+	/** 获取所有转换类型标记 */
 	getAllFlags() {
 		return new Set(this.#flags);
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 获取未知转换类型标记
+	 * @complexity `n`
+	 */
+	getUnknownFlags() {
+		return this.#flags.filter(flag => /\{\{[^{}]+\}\}/u.test(flag));
+	}
+
+	/**
+	 * 获取有效转换类型标记
+	 * @complexity `n`
+	 */
 	getEffectiveFlags() {
 		const {variants} = this.getAttribute('config'),
 			variantFlags = this.#flags.filter(flag => variants.includes(flag)),
-			unknownFlags = this.#flags.filter(flag => /{{.+}}/.test(flag));
-		if (variantFlags.length) {
+			unknownFlags = this.getUnknownFlags();
+		if (variantFlags.length > 0) {
 			return new Set([...variantFlags, ...unknownFlags]);
 		}
 		const validFlags = ['A', 'T', 'R', 'D', '-', 'H', 'N'],
@@ -120,10 +146,9 @@ class ConverterFlagsToken extends Token {
 		} else if (flags.has('H')) {
 			const hasT = flags.has('T'),
 				hasD = flags.has('D');
-			if (hasT && hasD) {
-				return new Set(['+', 'H', 'T', 'D']);
-			}
-			return new Set(['+', 'H', ...hasT ? ['T'] : [], ...hasD ? ['D'] : [], ...unknownFlags]);
+			return hasT && hasD
+				? new Set(['+', 'H', 'T', 'D'])
+				: new Set(['+', 'H', ...hasT ? ['T'] : [], ...hasD ? ['D'] : [], ...unknownFlags]);
 		}
 		if (flags.size === 1 && flags.has('T')) {
 			flags.add('H');
@@ -138,32 +163,26 @@ class ConverterFlagsToken extends Token {
 		return flags;
 	}
 
-	/** @complexity `n` */
-	getUnknownFlags() {
-		return [...this.getFlags()].filter(flag => /{{.+}}/.test(flag));
-	}
-
-	/** @param {string} flag */
+	/**
+	 * 是否具有某转换类型标记
+	 * @param {string} flag 转换类型标记
+	 */
 	hasFlag(flag) {
-		if (typeof flag !== 'string') {
-			this.typeError('hasFlag', 'String');
-		}
-		return this.#flags.includes(flag);
+		return typeof flag === 'string' ? this.#flags.includes(flag) : this.typeError('hasFlag', 'String');
 	}
 
 	/**
-	 * @param {string} flag
+	 * 是否具有某有效转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n`
 	 */
 	hasEffectiveFlag(flag) {
-		if (typeof flag !== 'string') {
-			this.typeError('hasFlag', 'String');
-		}
-		return this.getEffectiveFlags().has(flag);
+		return typeof flag === 'string' ? this.getEffectiveFlags().has(flag) : this.typeError('hasFlag', 'String');
 	}
 
 	/**
-	 * @param {string} flag
+	 * 移除某转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n²`
 	 */
 	removeFlag(flag) {
@@ -173,7 +192,8 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {string} flag
+	 * 添加转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n`
 	 */
 	#newFlag(flag) {
@@ -182,7 +202,8 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {string} flag
+	 * 设置转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n`
 	 */
 	setFlag(flag) {
@@ -194,14 +215,15 @@ class ConverterFlagsToken extends Token {
 	}
 
 	/**
-	 * @param {string} flag
+	 * 开关转换类型标记
+	 * @param {string} flag 转换类型标记
 	 * @complexity `n²`
 	 */
 	toggleFlag(flag) {
-		if (!this.#flags.includes(flag)) {
-			this.#newFlag(flag);
-		} else {
+		if (this.#flags.includes(flag)) {
 			this.removeFlag(flag);
+		} else {
+			this.#newFlag(flag);
 		}
 	}
 }

package/src/converterRule.js

@@ -2,7 +2,7 @@
 
 const {undo} = require('../util/debug'),
 	{noWrap} = require('../util/string'),
-	/** @type {Parser} */ Parser = require('..'),
+	Parser = require('..'),
 	Token = require('.'),
 	AtomToken = require('./atom');
 
@@ -12,41 +12,62 @@ const {undo} = require('../util/debug'),
  */
 class ConverterRuleToken extends Token {
 	type = 'converter-rule';
-	variant = '';
-	unidirectional = false;
-	bidirectional = false;
+
+	/** 语言变体 */
+	get variant() {
+		return this.children.at(-2)?.text()?.trim() ?? '';
+	}
+
+	set variant(variant) {
+		this.setVariant(variant);
+	}
+
+	/** 是否是单向转换 */
+	get unidirectional() {
+		return this.childNodes.length === 3;
+	}
+
+	set unidirectional(unidirectional) {
+		if (unidirectional === false) {
+			this.makeBidirectional();
+		}
+	}
+
+	/** 是否是双向转换 */
+	get bidirectional() {
+		return this.childNodes.length === 2;
+	}
 
 	/**
-	 * @param {string} rule
+	 * @param {string} rule 转换规则
+	 * @param {boolean} hasColon 是否带有":"
 	 * @param {accum} accum
 	 */
 	constructor(rule, hasColon = true, config = Parser.getConfig(), accum = []) {
 		super(undefined, config, true, accum, {AtomToken: ':'});
-		if (!hasColon) {
-			super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
-		} else {
+		if (hasColon) {
 			const i = rule.indexOf(':'),
 				j = rule.slice(0, i).indexOf('=>'),
-				v = (j === -1 ? rule.slice(0, i) : rule.slice(j + 2, i)).trim(),
+				v = j === -1 ? rule.slice(0, i) : rule.slice(j + 2, i),
 				{variants} = config;
-			if (!variants.includes(v)) {
-				super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
-			} else {
+			if (variants.includes(v.trim())) {
 				super.insertAt(new AtomToken(v, 'converter-rule-variant', config, accum));
 				super.insertAt(new AtomToken(rule.slice(i + 1), 'converter-rule-to', config, accum));
-				if (j === -1) {
-					this.bidirectional = true;
-				} else {
+				if (j !== -1) {
 					super.insertAt(new AtomToken(rule.slice(0, j), 'converter-rule-from', config, accum), 0);
-					this.unidirectional = true;
 				}
+			} else {
+				super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
 			}
+		} else {
+			super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
 		}
-		this.seal(['variant', 'unidirectional', 'bidirectional']);
+		this.getAttribute('protectChildren')('1:');
 	}
 
+	/** @override */
 	cloneNode() {
-		const cloned = this.cloneChildren(),
+		const cloned = this.cloneChildNodes(),
 			placeholders = ['', 'zh:', '=>zh:'],
 			placeholder = placeholders[cloned.length - 1],
 			token = Parser.run(() => new ConverterRuleToken(placeholder, placeholder, this.getAttribute('config')));
@@ -57,77 +78,98 @@ class ConverterRuleToken extends Token {
 		return token;
 	}
 
+	/** @override */
 	afterBuild() {
-		if (this.childNodes.length > 1) {
-			this.setAttribute('variant', this.children.at(-2).text().trim());
-		}
-		const that = this,
-			/** @type {AstListener} */ converterRuleListener = (e, data) => {
-				const {childNodes} = that,
-					{prevTarget} = e;
-				if (childNodes.length > 1 && childNodes.at(-2) === prevTarget) {
-					const v = prevTarget.text().trim(),
-						{variants} = that.getAttribute('config');
-					if (variants.includes(v)) {
-						that.setAttribute('variant', v);
-					} else {
-						undo(e, data);
-						throw new Error(`无效的语言变体：${v}`);
-					}
+		const /** @type {AstListener} */ converterRuleListener = (e, data) => {
+			const {childNodes} = this,
+				{prevTarget} = e;
+			if (childNodes.length > 1 && childNodes.at(-2) === prevTarget) {
+				const v = prevTarget.text().trim(),
+					{variants} = this.getAttribute('config');
+				if (!variants.includes(v)) {
+					undo(e, data);
+					throw new Error(`无效的语言变体：${v}`);
 				}
-			};
+			}
+		};
 		this.addEventListener(['remove', 'insert', 'text', 'replace'], converterRuleListener);
 		return this;
 	}
 
 	/**
-	 * @param {number} i
+	 * @override
+	 * @param {number} i 移除位置
 	 * @returns {AtomToken}
+	 * @throws `Error` 至少保留1个子节点
 	 */
 	removeAt(i) {
-		if (i !== 0 && i !== -this.childNodes.length) {
-			throw new RangeError(`${this.constructor.name} 禁止移除第 ${i} 个子节点！`);
+		if (this.childNodes.length === 1) {
+			throw new Error(`${this.constructor.name} 需至少保留 1 个子节点！`);
+		}
+		const removed = super.removeAt(i);
+		if (this.childNodes.length === 1) {
+			this.firstChild.type = 'converter-rule-noconvert';
 		}
-		return super.removeAt(i);
+		return removed;
 	}
 
+	/**
+	 * @override
+	 * @throws `Error` 请勿手动插入子节点
+	 */
 	insertAt() {
-		throw new Error('转换规则语法复杂，请勿尝试手动插入子节点！');
+		throw new Error(`转换规则语法复杂，请勿尝试对 ${this.constructor.name} 手动插入子节点！`);
 	}
 
-	/** @returns {string} */
-	toString() {
-		if (this.childNodes.length === 3) {
-			const [from, variant, to] = this.children;
-			return `${from.toString()}=>${variant.toString()}:${to.toString()}`;
+	/**
+	 * @override
+	 * @param {string} selector
+	 * @returns {string}
+	 */
+	toString(selector) {
+		if (this.childNodes.length === 3 && !(selector && this.matches(selector))) {
+			const {children: [from, variant, to]} = this;
+			return `${from.toString(selector)}=>${variant.toString(selector)}:${to.toString(selector)}`;
 		}
-		return super.toString(':');
+		return super.toString(selector, ':');
 	}
 
-	/** @param {number} i */
+	/**
+	 * @override
+	 * @param {number} i 子节点序号
+	 */
 	getGaps(i = 0) {
-		const {length} = this.childNodes;
+		const {childNodes: {length}} = this;
 		i = i < 0 ? i + length : i;
 		return i === 0 && length === 3 ? 2 : 1;
 	}
 
-	/** @returns {string} */
+	/**
+	 * @override
+	 * @returns {string}
+	 */
 	text() {
 		if (this.childNodes.length === 3) {
-			const [from, variant, to] = this.children;
+			const {children: [from, variant, to]} = this;
 			return `${from.text()}=>${variant.text()}:${to.text()}`;
 		}
 		return super.text(':');
 	}
 
+	/** 修改为不转换 */
 	noConvert() {
-		for (let i = this.childNodes.length - 2; i >= 0; i--) {
-			super.removeAt(i);
+		const {childNodes: {length}, lastChild} = this;
+		for (let i = 0; i < length - 1; i++) { // ConverterRuleToken只能从前往后删除子节点
+			this.removeAt(0);
 		}
-		this.setAttribute('unidirectional', false).setAttribute('bidirectional', false).setAttribute('variant', '');
+		lastChild.type = 'converter-rule-noconvert';
 	}
 
-	/** @param {string} to */
+	/**
+	 * 设置转换目标
+	 * @param {string} to 转换目标
+	 * @throws `SyntaxError` 非法的转换目标
+	 */
 	setTo(to) {
 		to = String(to);
 		const config = this.getAttribute('config'),
@@ -138,12 +180,17 @@ class ConverterRuleToken extends Token {
 		) {
 			throw new SyntaxError(`非法的转换目标：${noWrap(to)}`);
 		}
-		const {lastChild} = firstElementChild.lastElementChild;
-		firstElementChild.lastElementChild.removeAt(0);
+		const {lastElementChild} = firstElementChild,
+			{lastChild} = lastElementChild;
+		lastElementChild.destroy(true);
 		this.lastElementChild.safeReplaceWith(lastChild);
 	}
 
-	/** @param {string} variant */
+	/**
+	 * 设置语言变体
+	 * @param {string} variant 语言变体
+	 * @throws `RangeError` 无效的语言变体
+	 */
 	setVariant(variant) {
 		if (typeof variant !== 'string') {
 			this.typeError('setVariant', 'String');
@@ -154,16 +201,19 @@ class ConverterRuleToken extends Token {
 			throw new RangeError(`无效的语言变体：${v}`);
 		} else if (this.childNodes.length === 1) {
 			super.insertAt(Parser.run(() => new AtomToken(variant, 'converter-rule-variant', config)), 0);
-			this.setAttribute('bidirectional', true);
 		} else {
 			this.children.at(-2).setText(variant);
 		}
-		this.setAttribute('variant', v);
 	}
 
-	/** @param {string} from */
+	/**
+	 * 设置转换原文
+	 * @param {string} from 转换原文
+	 * @throws `Error` 尚未指定语言变体
+	 * @throws `SyntaxError` 非法的转换原文
+	 */
 	setFrom(from) {
-		const {variant} = this;
+		const {variant, unidirectional} = this;
 		if (!variant) {
 			throw new Error('请先指定语言变体！');
 		}
@@ -176,23 +226,25 @@ class ConverterRuleToken extends Token {
 		) {
 			throw new SyntaxError(`非法的转换原文：${noWrap(from)}`);
 		}
-		if (this.unidirectional) {
+		if (unidirectional) {
 			this.firstElementChild.safeReplaceWith(firstElementChild.lastElementChild.firstChild);
 		} else {
 			super.insertAt(firstElementChild.lastElementChild.firstChild, 0);
-			this.setAttribute('unidirectional', true).setAttribute('bidirectional', false);
 		}
 	}
 
-	/** @param {string} from */
+	/**
+	 * 修改为单向转换
+	 * @param {string} from 转换来源
+	 */
 	makeUnidirectional(from) {
 		this.setFrom(from);
 	}
 
+	/** 修改为双向转换 */
 	makeBidirectional() {
 		if (this.unidirectional) {
 			super.removeAt(0);
-			this.setAttribute('unidirectional', false).setAttribute('bidirectional', true);
 		}
 	}
 }

package/src/extLink.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {noWrap, normalizeSpace} = require('../util/string'),
-	/** @type {Parser} */ Parser = require('..'),
+	Parser = require('..'),
 	Token = require('.'),
 	MagicLinkToken = require('./magicLink');
 
@@ -13,19 +13,42 @@ class ExtLinkToken extends Token {
 	type = 'ext-link';
 	#space;
 
-	/** @this {{firstChild: MagicLinkToken}} */
+	/**
+	 * 协议
+	 * @this {{firstChild: MagicLinkToken}}
+	 */
 	get protocol() {
 		return this.firstChild.protocol;
 	}
+
 	/** @this {{firstChild: MagicLinkToken}} */
 	set protocol(value) {
 		this.firstChild.protocol = value;
 	}
 
 	/**
-	 * @param {string} url
-	 * @param {string} space
-	 * @param {string} text
+	 * 和内链保持一致
+	 * @this {{firstChild: MagicLinkToken}}
+	 */
+	get link() {
+		return this.firstChild.link;
+	}
+
+	set link(url) {
+		this.setTarget(url);
+	}
+
+	/** 链接显示文字 */
+	get innerText() {
+		return this.childNodes.length > 1
+			? this.lastElementChild.text()
+			: `[${this.getRootNode().querySelectorAll('ext-link[childElementCount=1]').indexOf(this) + 1}]`;
+	}
+
+	/**
+	 * @param {string} url 网址
+	 * @param {string} space 空白字符
+	 * @param {string} text 链接文字
 	 * @param {accum} accum
 	 */
 	constructor(url, space, text, config = Parser.getConfig(), accum = []) {
@@ -37,11 +60,12 @@ class ExtLinkToken extends Token {
 			inner.type = 'ext-link-text';
 			this.appendChild(inner.setAttribute('stage', Parser.MAX_STAGE - 1));
 		}
-		this.protectChildren(0);
+		this.getAttribute('protectChildren')(0);
 	}
 
+	/** @override */
 	cloneNode() {
-		const [url, text] = this.cloneChildren(),
+		const [url, text] = this.cloneChildNodes(),
 			token = Parser.run(() => new ExtLinkToken(undefined, '', '', this.getAttribute('config')));
 		token.firstElementChild.safeReplaceWith(url);
 		if (text) {
@@ -50,40 +74,61 @@ class ExtLinkToken extends Token {
 		return token;
 	}
 
+	/** 修正空白字符 */
 	#correct() {
 		if (!this.#space && this.childNodes.length > 1
 			// 都替换成`<`肯定不对，但无妨
-			&& /^[^[\]<>"{\x00-\x20\x7f\p{Zs}\ufffd]/u.test(this.lastElementChild.text().replace(/&[lg]t;/, '<'))
+			&& /^[^[\]<>"{\0-\x1F\x7F\p{Zs}\uFFFD]/u.test(this.lastElementChild.text().replace(/&[lg]t;/u, '<'))
 		) {
 			this.#space = ' ';
 		}
 	}
 
-	toString() {
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		if (selector && this.matches(selector)) {
+			return '';
+		} else if (this.childNodes.length === 1) {
+			return `[${super.toString(selector)}${this.#space}]`;
+		}
 		this.#correct();
-		return `[${this.firstElementChild.toString()}${this.#space}${normalizeSpace(this.children[1])}]`;
+		normalizeSpace(this.lastElementChild);
+		return `[${super.toString(selector, this.#space)}]`;
 	}
 
+	/** @override */
 	getPadding() {
-		this.#correct();
 		return 1;
 	}
 
+	/** @override */
 	getGaps() {
 		this.#correct();
 		return this.#space.length;
 	}
 
+	/** @override */
 	text() {
-		return `[${super.text(' ').replaceAll('\n', ' ')}]`;
+		normalizeSpace(this.children[1]);
+		return `[${super.text(' ')}]`;
 	}
 
-	/** @this {ExtLinkToken & {firstElementChild: MagicLinkToken}} */
+	/**
+	 * 获取网址
+	 * @this {{firstChild: MagicLinkToken}}
+	 */
 	getUrl() {
-		return this.firstElementChild.getUrl();
+		return this.firstChild.getUrl();
 	}
 
-	/** @param {string|URL} url */
+	/**
+	 * 设置链接目标
+	 * @param {string|URL} url 网址
+	 * @throws `SyntaxError` 非法的外链目标
+	 */
 	setTarget(url) {
 		url = String(url);
 		const root = Parser.parse(`[${url}]`, this.getAttribute('include'), 8, this.getAttribute('config')),
@@ -92,12 +137,15 @@ class ExtLinkToken extends Token {
 			throw new SyntaxError(`非法的外链目标：${url}`);
 		}
 		const {firstChild} = firstElementChild;
-		root.destroy();
-		firstElementChild.destroy();
+		firstElementChild.destroy(true);
 		this.firstElementChild.safeReplaceWith(firstChild);
 	}
 
-	/** @param {string} text  */
+	/**
+	 * 设置链接显示文字
+	 * @param {string} text 链接显示文字
+	 * @throws `SyntaxError` 非法的链接显示文字
+	 */
 	setLinkText(text) {
 		text = String(text);
 		const root = Parser.parse(`[//url ${text}]`, this.getAttribute('include'), 8, this.getAttribute('config')),