wikiparser-node 0.3.0 → 0.4.0

package/src/attribute.js

@@ -2,27 +2,94 @@
 
 const {externalUse} = require('../util/debug'),
 	{toCase, removeComment, normalizeSpace} = require('../util/string'),
-	/** @type {Parser} */ Parser = require('..'),
+	Parser = require('..'),
 	Token = require('.');
 
 const stages = {'ext-attr': 0, 'html-attr': 2, 'table-attr': 3};
 
 /**
  * 扩展和HTML标签属性
- * @classdesc `{childNodes: [string]|(string|ArgToken|TranscludeToken)[]}`
+ * @classdesc `{childNodes: [AstText]|(AstText|ArgToken|TranscludeToken)[]}`
  */
 class AttributeToken extends Token {
 	/** @type {Map<string, string|true>} */ #attr = new Map();
 	#sanitized = true;
 
+	/**
+	 * @override
+	 * @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.hasAttr(key);
+		} else if (!this.hasAttr(key)) {
+			return equal === '!=';
+		}
+		val = toCase(val, i);
+		const attr = this.getAttr(key),
+			thisVal = toCase(attr === true ? '' : attr, i);
+		switch (equal) {
+			case '~=':
+				return attr !== true && thisVal.split(/\s/u).includes(val);
+			case '|=': // 允许`val === ''`
+				return thisVal === val || thisVal.startsWith(`${val}-`);
+			case '^=':
+				return attr !== true && thisVal.startsWith(val);
+			case '$=':
+				return attr !== true && thisVal.endsWith(val);
+			case '*=':
+				return attr !== true && thisVal.includes(val);
+			case '!=':
+				return thisVal !== val;
+			default: // `=`
+				return thisVal === val;
+		}
+	};
+
+	/**
+	 * getAttr()方法的getter写法
+	 * @returns {Record<string, string|true>}
+	 */
+	get attributes() {
+		return this.getAttr();
+	}
+
+	/** 以字符串表示的class属性 */
+	get className() {
+		const attr = this.getAttr('class');
+		return typeof attr === 'string' ? attr : '';
+	}
+
+	set className(className) {
+		this.setAttr('class', className);
+	}
+
+	/** 以Set表示的class属性 */
+	get classList() {
+		return new Set(this.className.split(/\s/u));
+	}
+
+	/** id属性 */
+	get id() {
+		const attr = this.getAttr('id');
+		return typeof attr === 'string' ? attr : '';
+	}
+
+	set id(id) {
+		this.setAttr('id', id);
+	}
+
 	/**
 	 * 从`this.#attr`更新`childNodes`
 	 * @complexity `n`
 	 */
 	#updateFromAttr() {
 		let equal = '=';
-		const ParameterToken = require('./parameter'),
-			parent = this.closest('ext, parameter');
+		const ParameterToken = require('./parameter');
+		const parent = this.closest('ext, parameter');
 		if (parent instanceof ParameterToken && parent.anon
 			&& parent.parentNode?.matches('template, magic-word#invoke')
 		) {
@@ -37,7 +104,10 @@ class AttributeToken extends Token {
 		}).join(' ');
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 清理标签属性
+	 * @complexity `n`
+	 */
 	sanitize() {
 		if (!Parser.running && !this.#sanitized) {
 			Parser.warn(`${this.constructor.name}.sanitize 方法将清理无效属性！`);
@@ -55,19 +125,29 @@ class AttributeToken extends Token {
 	 */
 	#parseAttr() {
 		this.#attr.clear();
-		let string = this.toString(),
-			/** @type {Token & {firstChild: string}} */ token;
+		let string = this.toString('comment, include, noinclude, heading, html'),
+			token;
 		if (this.type !== 'ext-attr' && !Parser.running) {
 			const config = this.getAttribute('config'),
 				include = this.getAttribute('include');
-			token = Parser.run(() => new Token(string, config).parseOnce(0, include).parseOnce());
-			string = token.firstChild;
+			token = Parser.run(() => {
+				const newToken = new Token(string, config),
+					parseOnce = newToken.getAttribute('parseOnce');
+				parseOnce(0, include);
+				return parseOnce();
+			});
+			string = String(token);
 		}
-		string = removeComment(string).replace(/\x00\d+~\x7f/g, '=');
-		const build = /** @param {string|boolean} str */ str =>
-			typeof str === 'boolean' || !token ? str : token.buildFromStr(str).map(String).join('');
+		string = removeComment(string).replaceAll(/\0\d+~\x7F/gu, '=');
+
+		/**
+		 * 解析并重建标签属性
+		 * @param {string|boolean} str 半解析的标签属性文本
+		 */
+		const build = str =>
+			typeof str === 'boolean' || !token ? str : token.getAttribute('buildFromStr')(str).map(String).join('');
 		for (const [, key,, quoted, unquoted] of string
-			.matchAll(/([^\s/][^\s/=]*)(?:\s*=\s*(?:(["'])(.*?)(?:\2|$)|(\S*)))?/sg)
+			.matchAll(/([^\s/][^\s/=]*)(?:\s*=\s*(?:(["'])(.*?)(?:\2|$)|(\S*)))?/gsu)
 		) {
 			if (!this.setAttr(build(key), build(quoted ?? unquoted ?? true), true)) {
 				this.#sanitized = false;
@@ -76,9 +156,9 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @param {string} attr
-	 * @param {'ext-attr'|'html-attr'|'table-attr'} type
-	 * @param {string} name
+	 * @param {string} attr 标签属性
+	 * @param {'ext-attr'|'html-attr'|'table-attr'} type 标签类型
+	 * @param {string} name 标签名
 	 * @param {accum} accum
 	 */
 	constructor(attr, type, name, config = Parser.getConfig(), accum = []) {
@@ -87,8 +167,9 @@ class AttributeToken extends Token {
 		this.setAttribute('name', name).#parseAttr();
 	}
 
+	/** @override */
 	cloneNode() {
-		const cloned = this.cloneChildren();
+		const cloned = this.cloneChildNodes();
 		return Parser.run(() => {
 			const token = new AttributeToken(undefined, this.type, this.name, this.getAttribute('config'));
 			token.append(...cloned);
@@ -97,28 +178,31 @@ class AttributeToken extends Token {
 	}
 
 	/**
+	 * @override
 	 * @template {string} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {TokenAttribute<T>}
 	 */
 	getAttribute(key) {
-		if (key === 'attr') {
-			return new Map(this.#attr);
+		if (key === 'matchesAttr') {
+			return this.#matchesAttr;
 		}
-		return super.getAttribute(key);
+		return key === 'attr' ? new Map(this.#attr) : super.getAttribute(key);
 	}
 
+	/** @override */
 	afterBuild() {
 		if (this.type !== 'ext-attr') {
+			const buildFromStr = this.getAttribute('buildFromStr');
 			for (let [key, text] of this.#attr) {
 				let built = false;
-				if (key.includes('\x00')) {
+				if (key.includes('\0')) {
 					this.#attr.delete(key);
-					key = this.buildFromStr(key).map(String).join('');
+					key = buildFromStr(key).map(String).join('');
 					built = true;
 				}
-				if (typeof text === 'string' && text.includes('\x00')) {
-					text = this.buildFromStr(text).map(String).join('');
+				if (typeof text === 'string' && text.includes('\0')) {
+					text = buildFromStr(text).map(String).join('');
 					built = true;
 				}
 				if (built) {
@@ -126,65 +210,74 @@ class AttributeToken extends Token {
 				}
 			}
 		}
-		const that = this,
-			/** @type {AstListener} */ attributeListener = ({type, target}) => {
-				if (type === 'text' || target !== that) {
-					that.#parseAttr();
-				}
-			};
+		const /** @type {AstListener} */ attributeListener = ({type, target}) => {
+			if (type === 'text' || target !== this) {
+				this.#parseAttr();
+			}
+		};
 		this.addEventListener(['remove', 'insert', 'replace', 'text'], attributeListener);
 		return this;
 	}
 
-	/** @param {string} key */
+	/**
+	 * 标签是否具有某属性
+	 * @param {string} key 属性键
+	 */
 	hasAttr(key) {
-		if (typeof key !== 'string') {
-			this.typeError('hasAttr', 'String');
-		}
-		return this.#attr.has(key.toLowerCase().trim());
+		return typeof key === 'string' ? this.#attr.has(key.toLowerCase().trim()) : this.typeError('hasAttr', 'String');
 	}
 
 	/**
+	 * 获取标签属性
 	 * @template {string|undefined} T
-	 * @param {T} key
+	 * @param {T} key 属性键
 	 * @returns {T extends string ? string|true : Record<string, string|true>}
 	 */
 	getAttr(key) {
 		if (key === undefined) {
 			return Object.fromEntries(this.#attr);
-		} else if (typeof key !== 'string') {
-			this.typeError('getAttr', 'String');
 		}
-		return this.#attr.get(key.toLowerCase().trim());
+		return typeof key === 'string' ? this.#attr.get(key.toLowerCase().trim()) : this.typeError('getAttr', 'String');
 	}
 
+	/** 获取全部的标签属性名 */
 	getAttrNames() {
 		return [...this.#attr.keys()];
 	}
 
+	/** 标签是否具有任意属性 */
 	hasAttrs() {
 		return this.getAttrNames().length > 0;
 	}
 
 	/**
-	 * @param {string} key
-	 * @param {string|boolean} value
+	 * 设置标签属性
+	 * @param {string} key 属性键
+	 * @param {string|boolean} value 属性值
+	 * @param {boolean} init 是否是初次解析
 	 * @complexity `n`
+	 * @throws `RangeError` 扩展标签属性不能包含">"
+	 * @throws `RangeError` 无效的属性名
 	 */
-	setAttr(key, value, init = false) {
+	setAttr(key, value, init) {
 		init &&= !externalUse('setAttr');
-		if (typeof key !== 'string' || !['string', 'boolean'].includes(typeof value)) {
-			this.typeError('setValue', 'String', 'Boolean');
+		if (typeof key !== 'string' || typeof value !== 'string' && typeof value !== 'boolean') {
+			this.typeError('setAttr', 'String', 'Boolean');
 		} else if (!init && this.type === 'ext-attr' && typeof value === 'string' && value.includes('>')) {
 			throw new RangeError('扩展标签属性不能包含 ">"！');
 		}
 		key = key.toLowerCase().trim();
 		const config = this.getAttribute('config'),
 			include = this.getAttribute('include'),
-			parsedKey = this.type !== 'ext-attr' && !init
-				? Parser.run(() => new Token(key, config).parseOnce(0, include).parseOnce().firstChild)
-				: key;
-		if (!/^(?:[\w:]|\x00\d+[t!~{}+-]\x7f)(?:[\w:.-]|\x00\d+[t!~{}+-]\x7f)*$/.test(parsedKey)) {
+			parsedKey = this.type === 'ext-attr' || init
+				? key
+				: Parser.run(() => {
+					const token = new Token(key, config),
+						parseOnce = token.getAttribute('parseOnce');
+					parseOnce(0, include);
+					return String(parseOnce());
+				});
+		if (!/^(?:[\w:]|\0\d+[t!~{}+-]\x7F)(?:[\w:.-]|\0\d+[t!~{}+-]\x7F)*$/u.test(parsedKey)) {
 			if (init) {
 				return false;
 			}
@@ -192,7 +285,7 @@ class AttributeToken extends Token {
 		} else if (value === false) {
 			this.#attr.delete(key);
 		} else {
-			this.#attr.set(key, value === true ? true : value.replace(/\s/g, ' ').trim());
+			this.#attr.set(key, value === true ? true : value.replaceAll(/\s/gu, ' ').trim());
 		}
 		if (!init) {
 			this.sanitize();
@@ -201,7 +294,8 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @param {string} key
+	 * 移除标签属性
+	 * @param {string} key 属性键
 	 * @complexity `n`
 	 */
 	removeAttr(key) {
@@ -215,9 +309,11 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @param {string} key
-	 * @param {boolean|undefined} force
+	 * 开关标签属性
+	 * @param {string} key 属性键
+	 * @param {boolean|undefined} force 强制开启或关闭
 	 * @complexity `n`
+	 * @throws `RangeError` 不为Boolean类型的属性值
 	 */
 	toggleAttr(key, force) {
 		if (typeof key !== 'string') {
@@ -233,31 +329,48 @@ class AttributeToken extends Token {
 		this.setAttr(key, force === true || force === undefined && value === false);
 	}
 
+	/**
+	 * 生成引导空格
+	 * @param {string} str 属性字符串
+	 */
 	#leadingSpace(str = super.toString()) {
-		return this.type !== 'table-attr' && str && !/^\s/.test(str) ? ' ' : '';
+		return this.type !== 'table-attr' && str && str.trimStart() === str ? ' ' : '';
 	}
 
-	/** @this {AttributeToken & Token} */
-	toString() {
-		const str = this.type === 'table-attr' ? normalizeSpace(this) : super.toString();
+	/**
+	 * @override
+	 * @this {AttributeToken & Token}
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		if (this.type === 'table-attr') {
+			normalizeSpace(this);
+		}
+		const str = super.toString(selector);
 		return `${this.#leadingSpace(str)}${str}`;
 	}
 
+	/** @override */
 	getPadding() {
 		return this.#leadingSpace().length;
 	}
 
+	/** @override */
 	text() {
-		let str = this.#updateFromAttr();
-		str = `${this.#leadingSpace(str)}${str}`;
-		return this.type === 'table-attr' ? normalizeSpace(str) : str;
+		if (this.type === 'table-attr') {
+			normalizeSpace(this);
+		}
+		const str = this.#updateFromAttr();
+		return `${this.#leadingSpace(str)}${str}`;
 	}
 
 	/**
-	 * @param {number} i
+	 * @override
+	 * @param {number} i 移除位置
+	 * @param {boolean} done 是否已解析过改变后的标签属性
 	 * @complexity `n`
 	 */
-	removeAt(i, done = false) {
+	removeAt(i, done) {
 		done &&= !externalUse('removeAt');
 		done ||= Parser.running;
 		const token = super.removeAt(i);
@@ -268,8 +381,11 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @template {string|Token} T
-	 * @param {T} token
+	 * @override
+	 * @template {Token} T
+	 * @param {T} token 待插入的节点
+	 * @param {number} i 插入位置
+	 * @param {boolean} done 是否已解析过改变后的标签属性
 	 * @complexity `n`
 	 */
 	insertAt(token, i = this.childNodes.length, done = false) {
@@ -283,7 +399,8 @@ class AttributeToken extends Token {
 	}
 
 	/**
-	 * @param {...string|Token} elements
+	 * @override
+	 * @param {...Token} elements 待替换的子节点
 	 * @complexity `n²`
 	 */
 	replaceChildren(...elements) {
@@ -299,41 +416,6 @@ class AttributeToken extends Token {
 			this.insertAt(element, undefined, done);
 		}
 	}
-
-	/**
-	 * @param {string} key
-	 * @param {string|undefined} equal - `equal`存在时`val`和`i`也一定存在
-	 * @param {string|undefined} val
-	 * @param {string|undefined} i
-	 */
-	matchesAttr(key, equal, val, i) {
-		if (externalUse('matchesAttr')) {
-			throw new Error(`禁止外部调用 ${this.constructor.name}.matchesAttr 方法！`);
-		} else if (!equal) {
-			return this.hasAttr(key);
-		} else if (!this.hasAttr(key)) {
-			return equal === '!=';
-		}
-		val = toCase(val, i);
-		const attr = this.getAttr(key),
-			thisVal = toCase(attr === true ? '' : attr, i);
-		switch (equal) {
-			case '~=':
-				return attr !== true && thisVal.split(/\s/).some(v => v === val);
-			case '|=': // 允许`val === ''`
-				return thisVal === val || thisVal.startsWith(`${val}-`);
-			case '^=':
-				return attr !== true && thisVal.startsWith(val);
-			case '$=':
-				return attr !== true && thisVal.endsWith(val);
-			case '*=':
-				return attr !== true && thisVal.includes(val);
-			case '!=':
-				return thisVal !== val;
-			default: // `=`
-				return thisVal === val;
-		}
-	}
 }
 
 Parser.classes.AttributeToken = __filename;

package/src/converter.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {text} = require('../util/string'),
-	/** @type {Parser} */ Parser = require('..'),
+	Parser = require('..'),
 	Token = require('.'),
 	ConverterFlagsToken = require('./converterFlags'),
 	ConverterRuleToken = require('./converterRule');
@@ -14,116 +14,143 @@ class ConverterToken extends Token {
 	type = 'converter';
 
 	/**
-	 * @param {string[]} flags
-	 * @param {string[]} rules
+	 * 是否无转换
+	 * @this {ConverterToken & {lastChild: ConverterRuleToken}}
+	 */
+	get noConvert() {
+		return this.hasFlag('R') || this.childNodes.length === 2 && !this.lastChild.variant;
+	}
+
+	/**
+	 * @param {string[]} flags 转换类型标记
+	 * @param {string[]} rules 转换规则
 	 * @param {accum} accum
 	 */
 	constructor(flags, rules, config = Parser.getConfig(), accum = []) {
 		super(undefined, config, true, accum);
 		this.append(new ConverterFlagsToken(flags, config, accum));
-		if (rules.length) {
-			const [firstRule] = rules,
-				hasColon = firstRule.includes(':'),
-				firstRuleToken = new ConverterRuleToken(firstRule, hasColon, config, accum);
-			if (hasColon && firstRuleToken.childNodes.length === 1) {
-				this.appendChild(new ConverterRuleToken(rules.join(';'), false, config, accum));
-			} else {
-				this.append(
-					firstRuleToken,
-					...rules.slice(1).map(rule => new ConverterRuleToken(rule, true, config, accum)),
-				);
-			}
+		const [firstRule] = rules,
+			hasColon = firstRule.includes(':'),
+			firstRuleToken = new ConverterRuleToken(firstRule, hasColon, config, accum);
+		if (hasColon && firstRuleToken.childNodes.length === 1) {
+			this.appendChild(new ConverterRuleToken(rules.join(';'), false, config, accum));
+		} else {
+			this.append(
+				firstRuleToken,
+				...rules.slice(1).map(rule => new ConverterRuleToken(rule, true, config, accum)),
+			);
 		}
-		this.protectChildren(0);
+		this.getAttribute('protectChildren')(0);
 	}
 
+	/** @override */
 	cloneNode() {
-		const [flags, ...rules] = this.cloneChildren(),
+		const [flags, ...rules] = this.cloneChildNodes(),
 			token = Parser.run(() => new ConverterToken([], [], this.getAttribute('config')));
 		token.firstElementChild.safeReplaceWith(flags);
 		token.append(...rules);
 		return token;
 	}
 
-	toString() {
-		const [flags, ...rules] = this.children;
-		return `-{${flags.toString()}${flags.childNodes.length ? '|' : ''}${rules.map(String).join(';')}}-`;
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		const {children: [flags, ...rules]} = this;
+		return selector && this.matches(selector)
+			? ''
+			: `-{${flags.toString(selector)}${flags.childNodes.length > 0 ? '|' : ''}${rules.map(String).join(';')}}-`;
 	}
 
+	/** @override */
 	getPadding() {
 		return 2;
 	}
 
-	/** @param {number} i */
+	/**
+	 * /** @override
+	 * @param {number} i 子节点位置
+	 */
 	getGaps(i = 0) {
 		i = i < 0 ? i + this.childNodes.length : i;
-		return i || this.firstElementChild.childNodes.length ? 1 : 0;
+		return i || this.firstElementChild.childNodes.length > 0 ? 1 : 0;
 	}
 
+	/** @override */
 	text() {
-		const [flags, ...rules] = this.children;
+		const {children: [flags, ...rules]} = this;
 		return `-{${flags.text()}|${text(rules, ';')}}-`;
 	}
 
-	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	/**
+	 * 获取所有转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
 	getAllFlags() {
 		return this.firstChild.getAllFlags();
 	}
 
-	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	/**
+	 * 获取有效的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
 	getEffectiveFlags() {
 		return this.firstChild.getEffectiveFlags();
 	}
 
-	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	/**
+	 * 获取未知的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
 	getUnknownFlags() {
 		return this.firstChild.getUnknownFlags();
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 是否具有某转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	hasFlag(flag) {
 		return this.firstChild.hasFlag(flag);
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 是否具有某有效的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	hasEffectiveFlag(flag) {
 		return this.firstChild.hasEffectiveFlag(flag);
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 移除转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	removeFlag(flag) {
 		this.firstChild.removeFlag(flag);
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 设置转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	setFlag(flag) {
 		this.firstChild.setFlag(flag);
 	}
 
 	/**
-	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
-	 * @param {string} flag
+	 * 开关某转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
 	 */
 	toggleFlag(flag) {
 		this.firstChild.toggleFlag(flag);
 	}
-
-	/** @this {ConverterToken & {children: [ConverterFlagsToken, ConverterRuleToken]}} */
-	get noConvert() {
-		return this.childNodes.length < 3 && !this.children[1]?.variant;
-	}
 }
 
 Parser.classes.ConverterToken = __filename;