wikiparser-node 0.3.1 → 0.5.0

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,138 +12,192 @@ const {undo} = require('../util/debug'),
  */
 class ConverterRuleToken extends Token {
 	type = 'converter-rule';
-	variant = '';
-	unidirectional = false;
-	bidirectional = false;
+
+	/** 语言变体 */
+	get variant() {
+		return this.childNodes.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')));
 		for (let i = 0; i < cloned.length; i++) {
-			token.children[i].safeReplaceWith(cloned[i]);
+			token.childNodes[i].safeReplaceWith(cloned[i]);
 		}
 		token.afterBuild();
 		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 个子节点！`);
 		}
-		return super.removeAt(i);
+		const removed = super.removeAt(i);
+		if (this.childNodes.length === 1) {
+			this.firstChild.type = 'converter-rule-noconvert';
+		}
+		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 {childNodes: [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 */
+	print() {
+		if (this.childNodes.length === 3) {
+			const {childNodes: [from, variant, to]} = this;
+			return `<span class="wpb-converter-rule">${from.print()}=>${variant.print()}:${to.print()}</span>`;
+		}
+		return super.print({sep: ':'});
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
 	text() {
 		if (this.childNodes.length === 3) {
-			const [from, variant, to] = this.children;
+			const {childNodes: [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'),
 			root = Parser.parse(`-{|${config.variants[0]}:${to}}-`, this.getAttribute('include'), undefined, config),
-			{childNodes: {length}, firstElementChild} = root;
-		if (length !== 1 || firstElementChild.type !== 'converter' || firstElementChild.childNodes.length !== 2
-			|| firstElementChild.lastElementChild.childNodes.length !== 2
-		) {
+			{childNodes: {length}, firstChild: converter} = root,
+			{lastChild: converterRule, type, childNodes: {length: converterLength}} = converter;
+		if (length !== 1 || type !== 'converter' || converterLength !== 2 || converterRule.childNodes.length !== 2) {
 			throw new SyntaxError(`非法的转换目标：${noWrap(to)}`);
 		}
-		const {lastChild} = firstElementChild.lastElementChild;
-		firstElementChild.lastElementChild.removeAt(0);
-		this.lastElementChild.safeReplaceWith(lastChild);
+		const {lastChild} = converterRule;
+		converterRule.destroy(true);
+		this.lastChild.safeReplaceWith(lastChild);
 	}
 
-	/** @param {string} variant */
+	/**
+	 * 设置语言变体
+	 * @param {string} variant 语言变体
+	 * @throws `RangeError` 无效的语言变体
+	 */
 	setVariant(variant) {
 		if (typeof variant !== 'string') {
 			this.typeError('setVariant', 'String');
@@ -154,45 +208,49 @@ 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.childNodes.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('请先指定语言变体！');
 		}
 		from = String(from);
 		const config = this.getAttribute('config'),
 			root = Parser.parse(`-{|${from}=>${variant}:}-`, this.getAttribute('include'), undefined, config),
-			{childNodes: {length}, firstElementChild} = root;
-		if (length !== 1 || firstElementChild.type !== 'converter' || firstElementChild.childNodes.length !== 2
-			|| firstElementChild.lastElementChild.childNodes.length !== 3
-		) {
+			{childNodes: {length}, firstChild: converter} = root,
+			{type, childNodes: {length: converterLength}, lastChild: converterRule} = converter;
+		if (length !== 1 || type !== 'converter' || converterLength !== 2 || converterRule.childNodes.length !== 3) {
 			throw new SyntaxError(`非法的转换原文：${noWrap(from)}`);
 		}
-		if (this.unidirectional) {
-			this.firstElementChild.safeReplaceWith(firstElementChild.lastElementChild.firstChild);
+		if (unidirectional) {
+			this.firstChild.safeReplaceWith(converterRule.firstChild);
 		} else {
-			super.insertAt(firstElementChild.lastElementChild.firstChild, 0);
-			this.setAttribute('unidirectional', true).setAttribute('bidirectional', false);
+			super.insertAt(converterRule.firstChild, 0);
 		}
 	}
 
-	/** @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.lastChild.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,79 +60,110 @@ 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);
+		token.firstChild.safeReplaceWith(url);
 		if (text) {
 			token.appendChild(text);
 		}
 		return token;
 	}
 
+	/** 修正空白字符 */
 	#correct() {
 		if (!this.#space && this.childNodes.length > 1
 			// 都替换成`<`肯定不对，但无妨
-			&& /^[^[\]<>"{\0-\x1f\x7f\p{Zs}\ufffd]/u.test(this.lastElementChild.text().replace(/&[lg]t;/, '<'))
+			&& /^[^[\]<>"{\0-\x1F\x7F\p{Zs}\uFFFD]/u.test(this.lastChild.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.lastChild);
+		return `[${super.toString(selector, this.#space)}]`;
 	}
 
+	/** @override */
 	getPadding() {
-		this.#correct();
 		return 1;
 	}
 
+	/** @override */
 	getGaps() {
 		this.#correct();
 		return this.#space.length;
 	}
 
+	/** @override */
+	print() {
+		const {childNodes: {length}} = this;
+		return super.print(length > 1 ? {pre: '[', sep: this.#space, post: ']'} : {pre: '[', post: `${this.#space}]`});
+	}
+
+	/** @override */
 	text() {
-		return `[${super.text(' ').replaceAll('\n', ' ')}]`;
+		normalizeSpace(this.childNodes[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')),
-			{childNodes: {length}, firstElementChild} = root;
-		if (length !== 1 || firstElementChild?.type !== 'ext-link' || firstElementChild.childNodes.length !== 1) {
+			{childNodes: {length}, firstChild: extLink} = root;
+		if (length !== 1 || extLink.type !== 'ext-link' || extLink.childNodes.length !== 1) {
 			throw new SyntaxError(`非法的外链目标：${url}`);
 		}
-		const {firstChild} = firstElementChild;
-		root.destroy();
-		firstElementChild.destroy();
-		this.firstElementChild.safeReplaceWith(firstChild);
+		const {firstChild} = extLink;
+		extLink.destroy(true);
+		this.firstChild.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')),
-			{childNodes: {length}, firstElementChild} = root;
-		if (length !== 1 || firstElementChild?.type !== 'ext-link' || firstElementChild.childNodes.length !== 2) {
+			{childNodes: {length}, firstChild: extLink} = root;
+		if (length !== 1 || extLink.type !== 'ext-link' || extLink.childNodes.length !== 2) {
 			throw new SyntaxError(`非法的外链文字：${noWrap(text)}`);
 		}
-		const {lastChild} = firstElementChild;
+		const {lastChild} = extLink;
 		if (this.childNodes.length === 1) {
 			this.appendChild(lastChild);
 		} else {
-			this.lastElementChild.safeReplaceWith(lastChild);
+			this.lastChild.safeReplaceWith(lastChild);
 		}
 		this.#space ||= ' ';
 	}

package/src/gallery.js

@@ -1,28 +1,28 @@
 'use strict';
 
-const {text} = require('../util/string'),
-	/** @type {Parser} */ Parser = require('..'),
+const Parser = require('..'),
 	Token = require('.'),
-	GalleryImageToken = require('./link/galleryImage');
+	GalleryImageToken = require('./link/galleryImage'),
+	HiddenToken = require('./atom/hidden');
 
 /**
  * gallery标签
- * @classdesc `{childNodes: (string|FileToken)[]]}`
+ * @classdesc `{childNodes: ...(GalleryImageToken|HiddenToken|AstText)}`
  */
 class GalleryToken extends Token {
 	type = 'ext-inner';
 	name = 'gallery';
 
 	/**
-	 * @param {string} inner
+	 * @param {string} inner 标签内部wikitext
 	 * @param {accum} accum
 	 */
 	constructor(inner, config = Parser.getConfig(), accum = []) {
-		super(undefined, config, true, accum, {String: ':', GalleryImageToken: ':'});
+		super(undefined, config, true, accum, {AstText: ':', GalleryImageToken: ':'});
 		for (const line of inner?.split('\n') ?? []) {
-			const matches = /^([^|]+)(?:\|(.*))?/.exec(line);
+			const matches = /^([^|]+)(?:\|(.*))?/u.exec(line);
 			if (!matches) {
-				this.appendChild(line);
+				this.appendChild(line.trim() ? new HiddenToken(line, undefined, config, [], {AstText: ':'}) : line);
 				continue;
 			}
 			const [, file, alt] = matches;
@@ -32,34 +32,51 @@ class GalleryToken extends Token {
 			} catch {
 				title = this.normalizeTitle(file, 6, true);
 			}
-			if (!title.valid) {
-				this.appendChild(line);
-			} else {
+			if (title.valid) {
 				this.appendChild(new GalleryImageToken(file, alt, title, config, accum));
+			} else {
+				this.appendChild(new HiddenToken(line, undefined, config, [], {AstText: ':'}));
 			}
 		}
 	}
 
+	/** @override */
 	cloneNode() {
-		const cloned = this.cloneChildren(),
+		const cloned = this.cloneChildNodes(),
 			token = Parser.run(() => new GalleryToken(undefined, this.getAttribute('config')));
 		token.append(...cloned);
 		return token;
 	}
 
-	toString() {
-		return super.toString('\n');
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		return super.toString(selector, '\n');
 	}
 
+	/** @override */
 	getGaps() {
 		return 1;
 	}
 
+	/** @override */
+	print() {
+		return super.print({sep: '\n'});
+	}
+
+	/** @override */
 	text() {
-		return text(this.children, '\n');
+		return super.text('\n').replaceAll(/\n\s*\n/gu, '\n');
 	}
 
-	/** @param {string} file */
+	/**
+	 * 插入图片
+	 * @param {string} file 图片文件名
+	 * @param {number} i 插入位置
+	 * @throws `SyntaxError` 非法的文件名
+	 */
 	insertImage(file, i = this.childNodes.length) {
 		let title;
 		try {
@@ -67,11 +84,37 @@ class GalleryToken extends Token {
 		} catch {
 			title = this.normalizeTitle(file, 6, true);
 		}
-		if (!title.valid) {
-			throw new SyntaxError(`非法的文件名：${file}`);
+		if (title.valid) {
+			const token = Parser.run(() => new GalleryImageToken(file, undefined, title, this.getAttribute('config')));
+			return this.insertAt(token, i);
+		}
+		throw new SyntaxError(`非法的文件名：${file}`);
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const {top, left} = this.getRootNode().posFromIndex(start),
+			/** @type {LintError[]} */ errors = [];
+		for (let i = 0, cur = start; i < this.childNodes.length; i++) {
+			const child = this.childNodes[i],
+				str = String(child);
+			if (child.type === 'hidden' && str.trim() && !/^<!--.*-->$/u.test(str)) {
+				errors.push({
+					message: '图库中的无效内容',
+					startLine: top + i,
+					endLine: top + i,
+					startCol: i ? 0 : left,
+					endCol: i ? str.length : left + str.length,
+				});
+			} else if (child.type !== 'hidden' && child.type !== 'text') {
+				errors.push(...child.lint(cur));
+			}
+			cur += str.length + 1;
 		}
-		const token = Parser.run(() => new GalleryImageToken(file, undefined, title, this.getAttribute('config')));
-		return this.insertAt(token, i);
+		return errors;
 	}
 }