wikiparser-node 0.11.0-m → 0.11.0

package/src/attributes.js

@@ -1,17 +1,88 @@
 'use strict';
 
 const {generateForSelf, generateForChild} = require('../util/lint'),
-	{removeComment} = require('../util/string'),
+	{toCase, normalizeSpace, text, removeComment} = require('../util/string'),
 	Parser = require('..'),
 	Token = require('.'),
 	AtomToken = require('./atom'),
 	AttributeToken = require('./attribute');
 
+const stages = {'ext-attrs': 0, 'html-attrs': 2, 'table-attrs': 3};
+
 /**
  * 扩展和HTML标签属性
  * @classdesc `{childNodes: ...AtomToken|AttributeToken}`
  */
 class AttributesToken extends Token {
+	/**
+	 * @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;
+		}
+	};
+
+	/** getAttrs()方法的getter写法 */
+	get attributes() {
+		return this.getAttrs();
+	}
+
+	/** 以字符串表示的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);
+	}
+
+	/** 是否含有无效属性 */
+	get sanitized() {
+		return this.getDirtyAttrs().length === 0;
+	}
+
 	/**
 	 * @param {string} attr 标签属性
 	 * @param {'ext-attrs'|'html-attrs'|'table-attrs'} type 标签类型
@@ -20,6 +91,7 @@ class AttributesToken extends Token {
 	 */
 	constructor(attr, type, name, config = Parser.getConfig(), accum = []) {
 		super(undefined, config, true, accum, {
+			AtomToken: ':', AttributeToken: ':',
 		});
 		this.type = type;
 		this.setAttribute('name', name);
@@ -40,6 +112,7 @@ class AttributesToken extends Token {
 			const insertDirty = /** 插入无效属性 */ () => {
 				if (out) {
 					super.insertAt(new AtomToken(out, `${type.slice(0, -1)}-dirty`, config, accum, {
+						[`Stage-${stages[type]}`]: ':',
 					}));
 					out = '';
 				}
@@ -81,9 +154,11 @@ class AttributesToken extends Token {
 	 * @returns {AttributeToken[]}
 	 */
 	getAttrTokens(key) {
-		return this.childNodes.filter(
-			child => child instanceof AttributeToken && child.name === key.toLowerCase().trim(),
-		);
+		return typeof key === 'string'
+			? this.childNodes.filter(
+				child => child instanceof AttributeToken && child.name === key.toLowerCase().trim(),
+			)
+			: this.typeError('getAttrTokens', 'String');
 	}
 
 	/**
@@ -145,6 +220,234 @@ class AttributesToken extends Token {
 		}
 		return errors;
 	}
+
+	/**
+	 * @override
+	 * @this {AttributesToken & {parentNode: HtmlToken}}
+	 */
+	print() {
+		const HtmlToken = require('./html');
+		return String(this)
+			? `<span class="wpb-${this.type}">${this.childNodes.map(child => child.print({
+				class: child instanceof AtomToken && child.text().trim() && 'hidden',
+			})).join('')}</span>`
+			: '';
+	}
+
+	/** 清理标签属性 */
+	sanitize() {
+		let dirty = false;
+		for (let i = this.length - 1; i >= 0; i--) {
+			const child = this.childNodes[i];
+			if (child instanceof AtomToken && child.text().trim()) {
+				dirty = true;
+				this.removeAt(i);
+			}
+		}
+		if (!Parser.running && dirty) {
+			Parser.warn(`${this.constructor.name}.sanitize 方法将清理无效属性！`);
+		}
+	}
+
+	/** @override */
+	cloneNode() {
+		const cloned = this.cloneChildNodes();
+		return Parser.run(() => {
+			const token = new AttributesToken(undefined, this.type, this.name, this.getAttribute('config'));
+			token.append(...cloned);
+			return token;
+		});
+	}
+
+	/**
+	 * 所有无效属性
+	 * @returns {AtomToken[]}
+	 */
+	getDirtyAttrs() {
+		return this.childNodes.filter(child => child instanceof AtomToken && child.text().trim());
+	}
+
+	/**
+	 * @override
+	 * @param {AttributeToken} token 待插入的子节点
+	 * @param {number} i 插入位置
+	 * @throws `RangeError` 不是AttributeToken或标签不匹配
+	 */
+	insertAt(token, i = this.length) {
+		if (!(token instanceof AttributeToken)) {
+			throw new RangeError(`${this.constructor.name}只能插入AttributeToken！`);
+		} else if (token.type !== this.type.slice(0, -1) || token.tag !== this.name) {
+			throw new RangeError(`待插入的AttributeToken只可用于${token.tag}标签！`);
+		} else if (i === this.length) {
+			const {lastChild} = this;
+			if (lastChild instanceof AttributeToken) {
+				lastChild.close();
+			}
+		} else {
+			token.close();
+		}
+		if (this.closest('parameter')) {
+			token.escape();
+		}
+		super.insertAt(token, i);
+		const {previousVisibleSibling, nextVisibleSibling} = token,
+			type = `${this.type.slice(0, -1)}-dirty`,
+			config = this.getAttribute('config'),
+			acceptable = {[`Stage-${stages[this.type]}`]: ':'};
+		if (nextVisibleSibling && !/^\s/u.test(String(nextVisibleSibling))) {
+			super.insertAt(Parser.run(() => new AtomToken(' ', type, config, [], acceptable)), i + 1);
+		}
+		if (previousVisibleSibling && !/\s$/u.test(String(previousVisibleSibling))) {
+			super.insertAt(Parser.run(() => new AtomToken(' ', type, config, [], acceptable)), i);
+		}
+		return token;
+	}
+
+	/**
+	 * 设置标签属性
+	 * @param {string} key 属性键
+	 * @param {string|boolean} value 属性值
+	 * @throws `RangeError` 扩展标签属性不能包含">"
+	 * @throws `RangeError` 无效的属性名
+	 */
+	setAttr(key, value) {
+		if (typeof key !== 'string' || typeof value !== 'string' && typeof value !== 'boolean') {
+			this.typeError('setAttr', 'String', 'Boolean');
+		} else if (this.type === 'ext-attrs' && typeof value === 'string' && value.includes('>')) {
+			throw new RangeError('扩展标签属性不能包含 ">"！');
+		}
+		key = key.toLowerCase().trim();
+		const attr = this.getAttrToken(key);
+		if (attr) {
+			attr.setValue(value);
+			return;
+		} else if (value === false) {
+			return;
+		}
+		const config = this.getAttribute('config'),
+			include = this.getAttribute('include'),
+			parsedKey = this.type === 'ext-attrs'
+				? 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)) {
+			throw new RangeError(`无效的属性名：${key}！`);
+		}
+		const newAttr = Parser.run(() => new AttributeToken(
+			this.type.slice(0, -1), this.name, key, value === true ? '' : '=', value, ['"', '"'], config,
+		));
+		this.insertAt(newAttr);
+	}
+
+	/**
+	 * @override
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @returns {import('../typings/node').TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		return key === 'matchesAttr' ? this.#matchesAttr : super.getAttribute(key);
+	}
+
+	/**
+	 * 标签是否具有某属性
+	 * @param {string} key 属性键
+	 */
+	hasAttr(key) {
+		return typeof key === 'string'
+			? this.getAttrTokens(key).length > 0
+			: this.typeError('hasAttr', 'String');
+	}
+
+	/** 获取全部的标签属性名 */
+	getAttrNames() {
+		return new Set(this.childNodes.filter(child => child instanceof AttributeToken).map(({name}) => name));
+	}
+
+	/** 标签是否具有任意属性 */
+	hasAttrs() {
+		return this.getAttrNames().size > 0;
+	}
+
+	/** 获取全部标签属性 */
+	getAttrs() {
+		const /** @type {AttributeToken[]} */ attrs = this.childNodes.filter(child => child instanceof AttributeToken);
+		return Object.fromEntries(attrs.map(({name, value}) => [name, value]));
+	}
+
+	/**
+	 * 移除标签属性
+	 * @param {string} key 属性键
+	 */
+	removeAttr(key) {
+		for (const attr of this.getAttrTokens(key)) {
+			attr.remove();
+		}
+	}
+
+	/**
+	 * 开关标签属性
+	 * @param {string} key 属性键
+	 * @param {boolean|undefined} force 强制开启或关闭
+	 * @throws `RangeError` 不为Boolean类型的属性值
+	 */
+	toggleAttr(key, force) {
+		if (typeof key !== 'string') {
+			this.typeError('toggleAttr', 'String');
+		} else if (force !== undefined) {
+			force = Boolean(force);
+		}
+		key = key.toLowerCase().trim();
+		const attr = this.getAttrToken(key);
+		if (attr && attr.getValue() !== true) {
+			throw new RangeError(`${key} 属性的值不为 Boolean！`);
+		} else if (attr) {
+			attr.setValue(force === true);
+		} else if (force !== false) {
+			this.setAttr(key, true);
+		}
+	}
+
+	/**
+	 * 生成引导空格
+	 * @param {string} str 属性字符串
+	 */
+	#leadingSpace(str = super.toString()) {
+		const {type} = this,
+			leadingRegex = {'ext-attrs': /^\s/u, 'html-attrs': /^[/\s]/u};
+		return str && type !== 'table-attrs' && !leadingRegex[type].test(str) ? ' ' : '';
+	}
+
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		if (this.type === 'table-attrs') {
+			normalizeSpace(this);
+		}
+		const str = super.toString(selector);
+		return `${this.#leadingSpace(str)}${str}`;
+	}
+
+	/** @override */
+	getPadding() {
+		return this.#leadingSpace().length;
+	}
+
+	/** @override */
+	text() {
+		if (this.type === 'table-attrs') {
+			normalizeSpace(this);
+		}
+		const str = text(this.childNodes.filter(child => child instanceof AttributeToken), ' ');
+		return `${this.#leadingSpace(str)}${str}`;
+	}
 }
 
+Parser.classes.AttributesToken = __filename;
 module.exports = AttributesToken;

package/src/charinsert.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const Parser = require('..'),
+	singleLine = require('../mixin/singleLine'),
+	Token = require('.'),
+	HasNowikiToken = require('./hasNowiki');
+
+/**
+ * `<charinsert>`
+ * @classdesc `{childNodes: [...HasNowikiToken]}`
+ */
+class CharinsertToken extends Token {
+	type = 'ext-inner';
+	name = 'charinsert';
+
+	/**
+	 * @param {string} wikitext wikitext
+	 * @param {import('../typings/token').accum} accum
+	 */
+	constructor(wikitext, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {
+			SingleLineHasNowikiToken: ':',
+		});
+		const SingleLineHasNowikiToken = singleLine(HasNowikiToken);
+		this.append(
+			...wikitext.split('\n').map(str => new SingleLineHasNowikiToken(str, 'charinsert-line', config, accum)),
+		);
+	}
+
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		return super.toString(selector, '\n');
+	}
+
+	/** @override */
+	getGaps() {
+		return 1;
+	}
+
+	/** @override */
+	print() {
+		return super.print({sep: '\n'});
+	}
+
+	/** @override */
+	cloneNode() {
+		const cloned = this.cloneChildNodes();
+		return Parser.run(() => {
+			const token = new CharinsertToken(undefined, this.getAttribute('config'));
+			token.append(...cloned);
+			return token;
+		});
+	}
+
+	/**
+	 * 获取某一行的插入选项
+	 * @param {number|HasNowikiToken} child 行号或子节点
+	 */
+	getLineItems(child) {
+		if (Number.isInteger(child)) {
+			child = this.childNodes.at(child);
+		}
+		if (!(child instanceof HasNowikiToken)) {
+			this.typeError('getLineItems', 'Number', 'HasNowikiToken');
+		}
+		const entities = {'\t': '&#9;', '\r': '&#12;', ' ': '&#32;'};
+		return String(child).replace(
+			/<nowiki>(.+?)<\/nowiki>/giu,
+			/** @param {string} inner */ (_, inner) => inner.replace(/[\t\r ]/gu, s => entities[s]),
+		).split(/\s/u).filter(Boolean)
+			.map(item => {
+				const parts = item.split('+');
+				if (parts.length === 1) {
+					return parts[0];
+				}
+				return parts[0] ? parts.slice(0, 2) : '+';
+			});
+	}
+
+	/** 获取所有插入选项 */
+	getAllItems() {
+		return this.childNodes.flatMap(child => this.getLineItems(child));
+	}
+
+	/** @override */
+	text() {
+		return this.childNodes.map(
+			child => this.getLineItems(child).map(str => Array.isArray(str) ? str.join('+') : str).join(' '),
+		).join('\n');
+	}
+}
+
+Parser.classes.CharinsertToken = __filename;
+module.exports = CharinsertToken;

package/src/converter.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const {text} = require('../util/string'),
+const {text, print} = require('../util/string'),
 	Parser = require('..'),
 	Token = require('.'),
 	ConverterFlagsToken = require('./converterFlags'),
@@ -13,6 +13,19 @@ const {text} = require('../util/string'),
 class ConverterToken extends Token {
 	type = 'converter';
 
+	/**
+	 * 是否无转换
+	 * @this {ConverterToken & {lastChild: ConverterRuleToken}}
+	 */
+	get noConvert() {
+		return this.hasFlag('R') || this.length === 2 && !this.lastChild.variant;
+	}
+
+	/** flags */
+	get flags() {
+		return this.getAllFlags();
+	}
+
 	/**
 	 * @param {string[]} flags 转换类型标记
 	 * @param {string[]} rules 转换规则
@@ -32,15 +45,19 @@ class ConverterToken extends Token {
 				...rules.slice(1).map(rule => new ConverterRuleToken(rule, true, config, accum)),
 			);
 		}
+		this.getAttribute('protectChildren')(0);
 	}
 
 	/**
 	 * @override
+	 * @param {string} selector
 	 * @returns {string}
 	 */
 	toString(selector) {
 		const {childNodes: [flags, ...rules]} = this;
-		return `-{${flags.toString()}${flags.length > 0 ? '|' : ''}${rules.map(String).join(';')}}-`;
+		return selector && this.matches(selector)
+			? ''
+			: `-{${flags.toString(selector)}${flags.length > 0 ? '|' : ''}${rules.map(String).join(';')}}-`;
 	}
 
 	/**
@@ -65,6 +82,95 @@ class ConverterToken extends Token {
 		i = i < 0 ? i + this.length : i;
 		return i || this.firstChild.length > 0 ? 1 : 0;
 	}
+
+	/** @override */
+	print() {
+		const {childNodes: [flags, ...rules]} = this;
+		return `<span class="wpb-converter">-{${flags.print()}${
+			flags.length > 0 ? '|' : ''
+		}${print(rules, {sep: ';'})}}-</span>`;
+	}
+
+	/** @override */
+	cloneNode() {
+		const [flags, ...rules] = this.cloneChildNodes();
+		return Parser.run(() => {
+			const token = new ConverterToken([], [], this.getAttribute('config'));
+			token.firstChild.safeReplaceWith(flags);
+			token.append(...rules);
+			return token;
+		});
+	}
+
+	/**
+	 * 获取所有转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
+	getAllFlags() {
+		return this.firstChild.getAllFlags();
+	}
+
+	/**
+	 * 获取有效的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
+	getEffectiveFlags() {
+		return this.firstChild.getEffectiveFlags();
+	}
+
+	/**
+	 * 获取未知的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 */
+	getUnknownFlags() {
+		return this.firstChild.getUnknownFlags();
+	}
+
+	/**
+	 * 是否具有某转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
+	 */
+	hasFlag(flag) {
+		return this.firstChild.hasFlag(flag);
+	}
+
+	/**
+	 * 是否具有某有效的转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
+	 */
+	hasEffectiveFlag(flag) {
+		return this.firstChild.hasEffectiveFlag(flag);
+	}
+
+	/**
+	 * 移除转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
+	 */
+	removeFlag(flag) {
+		this.firstChild.removeFlag(flag);
+	}
+
+	/**
+	 * 设置转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
+	 */
+	setFlag(flag) {
+		this.firstChild.setFlag(flag);
+	}
+
+	/**
+	 * 开关某转换类型标记
+	 * @this {{firstChild: ConverterFlagsToken}}
+	 * @param {string} flag 转换类型标记
+	 */
+	toggleFlag(flag) {
+		this.firstChild.toggleFlag(flag);
+	}
 }
 
+Parser.classes.ConverterToken = __filename;
 module.exports = ConverterToken;