wikiparser-node 0.0.2 → 0.2.0

package/lib/node.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {typeError, externalUse} = require('../util/debug'),
-	{text} = require('../util/string'),
+	{text, noWrap} = require('../util/string'),
 	assert = require('assert/strict'),
 	/** @type {Parser} */ Parser = require('..');
 
@@ -34,6 +34,14 @@ class AstNode {
 		throw new Error(`${this.constructor.name}.${method} 方法仅用于代码调试！`);
 	}
 
+	/**
+	 * @param {string} method
+	 * @param  {...string} types
+	 */
+	typeError(method, ...types) {
+		return typeError(this.constructor, method, ...types);
+	}
+
 	/** @param {string|string[]} keys */
 	seal(keys) {
 		if (!Parser.running && !Parser.debugging) {
@@ -68,7 +76,7 @@ class AstNode {
 	/** @param {PropertyKey} key */
 	hasAttribute(key) {
 		if (!['string', 'number', 'symbol'].includes(typeof key)) {
-			typeError(this, 'hasAttribute', 'String', 'Number', 'Symbol');
+			this.typeError('hasAttribute', 'String', 'Number', 'Symbol');
 		}
 		return key in this;
 	}
@@ -142,7 +150,7 @@ class AstNode {
 	 */
 	toggleAttribute(key, force) {
 		if (force !== undefined && typeof force !== 'boolean') {
-			typeError(this, 'toggleAttribute', 'Boolean');
+			this.typeError('toggleAttribute', 'Boolean');
 		} else if (this.hasAttribute(key) && typeof this[key] !== 'boolean') {
 			throw new RangeError(`${key} 属性的值不为 Boolean！`);
 		}
@@ -175,7 +183,7 @@ class AstNode {
 	 */
 	contains(node) {
 		if (!(node instanceof AstNode)) {
-			typeError(this, 'contains', 'Token');
+			this.typeError('contains', 'Token');
 		}
 		return node === this || this.childNodes.some(child => child instanceof AstNode && child.contains(node));
 	}
@@ -185,7 +193,7 @@ class AstNode {
 		if (!Parser.debugging && externalUse('verifyChild')) {
 			this.debugOnly('verifyChild');
 		} else if (typeof i !== 'number') {
-			typeError(this, 'verifyChild', 'Number');
+			this.typeError('verifyChild', 'Number');
 		}
 		const {length} = this.childNodes;
 		if (i < -length || i >= length + addition || !Number.isInteger(i)) {
@@ -216,7 +224,7 @@ class AstNode {
 			Parser.error('找不到子节点！', node);
 			throw new RangeError('找不到子节点！');
 		} else if (typeof node === 'string' && childNodes.lastIndexOf(node) > i) {
-			throw new RangeError(`重复的纯文本节点 ${node.replaceAll('\n', '\\n')}！`);
+			throw new RangeError(`重复的纯文本节点 ${noWrap(node)}！`);
 		}
 		return i;
 	}
@@ -238,7 +246,7 @@ class AstNode {
 	 */
 	insertAt(node, i = this.childNodes.length) {
 		if (typeof node !== 'string' && !(node instanceof AstNode)) {
-			typeError(this, 'insertAt', 'String', 'Token');
+			this.typeError('insertAt', 'String', 'Token');
 		} else if (node instanceof AstNode && node.contains(this)) {
 			Parser.error('不能插入祖先节点！', node);
 			throw new RangeError('不能插入祖先节点！');
@@ -297,7 +305,7 @@ class AstNode {
 	/** @param {string} str */
 	setText(str, i = 0) {
 		if (typeof str !== 'string') {
-			typeError(this, 'setText', 'String');
+			this.typeError('setText', 'String');
 		}
 		this.verifyChild(i);
 		const oldText = this.childNodes.at(i);
@@ -316,7 +324,7 @@ class AstNode {
 	 */
 	splitText(i, offset) {
 		if (typeof offset !== 'number') {
-			typeError(this, 'splitText', 'Number');
+			this.typeError('splitText', 'Number');
 		}
 		this.verifyChild(i);
 		const oldText = this.childNodes.at(i);

package/mixin/sol.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..'),
+	Token = require('../src'); // eslint-disable-line no-unused-vars
+
+/**
+ * @template T
+ * @param {T} constructor
+ * @returns {T}
+ */
+const sol = constructor => class extends constructor {
+	/** @this {Token} */
+	prependNewLine() {
+		const {previousVisibleSibling = '', parentNode} = this;
+		return (previousVisibleSibling || parentNode?.type !== 'root') && !String(previousVisibleSibling).endsWith('\n')
+			? '\n'
+			: '';
+	}
+
+	/** @this {Token} */
+	appendNewLine() {
+		const {nextVisibleSibling = '', parentNode} = this;
+		return (nextVisibleSibling || parentNode?.type !== 'root') && !String(nextVisibleSibling ?? '').startsWith('\n')
+			? '\n'
+			: '';
+	}
+
+	toString(ownLine = false) {
+		return `${this.prependNewLine()}${super.toString()}${ownLine ? this.appendNewLine() : ''}`;
+	}
+
+	getPadding() {
+		return this.prependNewLine().length;
+	}
+
+	text(ownLine = false) {
+		return `${this.prependNewLine()}${super.text()}${ownLine ? this.appendNewLine() : ''}`;
+	}
+};
+
+Parser.mixins.sol = __filename;
+module.exports = sol;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wikiparser-node",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "description": "A Node.js parser for MediaWiki markup with AST",
   "keywords": [
     "mediawiki",

package/parser/converter.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} firstChild
+ * @param {accum} accum
+ */
+const parseConverter = (firstChild, config = Parser.getConfig(), accum = []) => {
+	const ConverterToken = require('../src/converter'),
+		regex1 = /-{/g,
+		regex2 = /-{|}-/g,
+		/** @type {RegExpExecArray[]} */ stack = [];
+	let regex = regex1,
+		mt = regex.exec(firstChild);
+	while (mt) {
+		const {0: syntax, index} = mt;
+		if (syntax === '}-') {
+			const top = stack.pop(),
+				{length} = accum,
+				str = firstChild.slice(top.index + 2, index),
+				i = str.indexOf('|'),
+				[flags, text] = i === -1 ? [[], str] : [str.slice(0, i).split(';'), str.slice(i + 1)],
+				temp = text.replace(/(?<=&[#a-z0-9]+);/i, '\x01'),
+				variants = `(?:${config.variants.join('|')})`,
+				rules = temp.split(new RegExp(`;(?=\\s*(?:${variants}|[^;]*?=>\\s*${variants})\\s*:)`))
+					.map(rule => rule.replaceAll('\x01', ';'));
+			new ConverterToken(flags, rules, config, accum);
+			firstChild = `${firstChild.slice(0, top.index)}\x00${length}v\x7f${firstChild.slice(index + 2)}`;
+			if (stack.length === 0) {
+				regex = regex1;
+			}
+			regex.lastIndex = top.index + 3 + String(length).length;
+		} else {
+			stack.push(mt);
+			regex = regex2;
+		}
+		mt = regex.exec(firstChild);
+	}
+	return firstChild;
+};
+
+Parser.parsers.parseConverter = __filename;
+module.exports = parseConverter;

package/parser/externalLinks.js

@@ -10,7 +10,7 @@ const {extUrlChar} = require('../util/string'),
 const parseExternalLinks = (firstChild, config = Parser.getConfig(), accum = []) => {
 	const ExtLinkToken = require('../src/extLink'),
 		regex = new RegExp(
-			`\\[((?:${config.protocol}|//)${extUrlChar})(\\p{Zs}*)([^\\]\\x01-\\x08\\x0a-\\x1f\\ufffd]*)\\]`,
+			`\\[((?:${config.protocol}|//)${extUrlChar})(\\p{Zs}*)([^\\]\x01-\x08\x0a-\x1f\ufffd]*)\\]`,
 			'gui',
 		);
 	return firstChild.replace(regex, /** @type {function(...string): string} */ (_, url, space, text) => {

package/parser/list.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * @param {string} text
+ * @param {accum} accum
+ */
+const parseList = (text, config = Parser.getConfig(), accum = []) => {
+	const mt = text.match(/^(?:[;:*#]|\x00\d+c\x7f)*[;:*#]/);
+	if (!mt) {
+		return text;
+	}
+	const ListToken = require('../src/nowiki/list'),
+		[prefix] = mt;
+	text = `\x00${accum.length}d\x7f${text.slice(prefix.length)}`;
+	new ListToken(prefix, config, accum);
+	let dt = prefix.split(';').length - 1;
+	if (!dt) {
+		return text;
+	}
+	const DdToken = require('../src/nowiki/dd');
+	let regex = /:+|-{/g,
+		ex = regex.exec(text),
+		lc = 0;
+	while (ex && dt) {
+		const {0: syntax, index} = ex;
+		if (syntax[0] === ':') {
+			if (syntax.length >= dt) {
+				new DdToken(':'.repeat(dt), config, accum);
+				return `${text.slice(0, index)}\x00${accum.length - 1}d\x7f${text.slice(index + dt)}`;
+			}
+			text = `${text.slice(0, index)}\x00${accum.length}d\x7f${text.slice(regex.lastIndex)}`;
+			dt -= syntax.length;
+			regex.lastIndex = index + 4 + String(accum.length).length;
+			new DdToken(syntax, config, accum);
+		} else if (syntax === '-{') {
+			if (!lc) {
+				const {lastIndex} = regex;
+				regex = /-{|}-/g;
+				regex.lastIndex = lastIndex;
+			}
+			lc++;
+		} else {
+			lc--;
+			if (!lc) {
+				const {lastIndex} = regex;
+				regex = /:+|-{/g;
+				regex.lastIndex = lastIndex;
+			}
+		}
+		ex = regex.exec(text);
+	}
+	return text;
+};
+
+Parser.parsers.parseList = __filename;
+module.exports = parseList;

package/parser/table.js

@@ -54,10 +54,10 @@ const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = [])
 		}
 		const [, closing, row, cell, attr] = matches;
 		if (closing) {
-			while (top.type !== 'table') {
+			while (!(top instanceof TableToken)) {
 				top = stack.pop();
 			}
-			top.close(`\n${spaces}${closing}`);
+			top.close(`\n${spaces}${closing}`, true);
 			push(attr, stack.at(-1));
 		} else if (row) {
 			if (top.type === 'td') {

package/printed/README

@@ -0,0 +1 @@
+这里存放以 JSON 格式打印的 AST。

package/src/arg.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const {text} = require('../util/string'),
+const {text, noWrap} = require('../util/string'),
 	/** @type {Parser} */ Parser = require('..'),
 	Token = require('.');
 
@@ -75,13 +75,13 @@ class ArgToken extends Token {
 
 	/** @returns {[number, string][]} */
 	plain() {
-		return this.childElementCount > 1 ? this.children[1].plain() : [];
+		return this.childNodes.length > 1 ? this.children[1].plain() : [];
 	}
 
 	/** @complexity `n` */
 	removeRedundant() {
 		Parser.run(() => {
-			for (let i = this.childElementCount - 1; i > 1; i--) {
+			for (let i = this.childNodes.length - 1; i > 1; i--) {
 				super.removeAt(i);
 			}
 		});
@@ -100,8 +100,8 @@ class ArgToken extends Token {
 	}
 
 	/** @param {Token} token */
-	insertAt(token, i = this.childElementCount) {
-		const j = i < 0 ? i + this.childElementCount : i;
+	insertAt(token, i = this.childNodes.length) {
+		const j = i < 0 ? i + this.childNodes.length : i;
 		if (j > 1 && !Parser.running) {
 			throw new RangeError(`${this.constructor.name} 不可插入 arg-redundant 子节点！`);
 		}
@@ -117,8 +117,8 @@ class ArgToken extends Token {
 		name = String(name);
 		const root = Parser.parse(`{{{${name}}}}`, this.getAttribute('include'), 2, this.getAttribute('config')),
 			{childNodes: {length}, firstElementChild} = root;
-		if (length !== 1 || firstElementChild?.type !== 'arg' || firstElementChild.childElementCount !== 1) {
-			throw new SyntaxError(`非法的参数名称：${name.replaceAll('\n', '\\n')}`);
+		if (length !== 1 || firstElementChild?.type !== 'arg' || firstElementChild.childNodes.length !== 1) {
+			throw new SyntaxError(`非法的参数名称：${noWrap(name)}`);
 		}
 		const newName = firstElementChild.firstElementChild;
 		root.destroy();
@@ -131,8 +131,8 @@ class ArgToken extends Token {
 		value = String(value);
 		const root = Parser.parse(`{{{|${value}}}}`, this.getAttribute('include'), 2, this.getAttribute('config')),
 			{childNodes: {length}, firstElementChild} = root;
-		if (length !== 1 || firstElementChild?.type !== 'arg' || firstElementChild.childElementCount !== 2) {
-			throw new SyntaxError(`非法的参数预设值：${value.replaceAll('\n', '\\n')}`);
+		if (length !== 1 || firstElementChild?.type !== 'arg' || firstElementChild.childNodes.length !== 2) {
+			throw new SyntaxError(`非法的参数预设值：${noWrap(value)}`);
 		}
 		const [, oldDefault] = this.children,
 			newDefault = firstElementChild.lastElementChild;

package/src/attribute.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const {typeError, externalUse} = require('../util/debug'),
-	{toCase, removeComment} = require('../util/string'),
+const {externalUse} = require('../util/debug'),
+	{toCase, removeComment, normalizeSpace} = require('../util/string'),
 	/** @type {Parser} */ Parser = require('..'),
 	Token = require('.');
 
@@ -28,14 +28,13 @@ class AttributeToken extends Token {
 		) {
 			equal = '{{=}}';
 		}
-		const str = [...this.#attr].map(([k, v]) => {
+		return [...this.#attr].map(([k, v]) => {
 			if (v === true) {
 				return k;
 			}
 			const quote = v.includes('"') ? "'" : '"';
 			return `${k}${equal}${quote}${v}${quote}`;
 		}).join(' ');
-		return str && ` ${str}`;
 	}
 
 	/** @complexity `n` */
@@ -56,17 +55,17 @@ class AttributeToken extends Token {
 	 */
 	#parseAttr() {
 		this.#attr.clear();
-		const config = this.getAttribute('config'),
-			include = this.getAttribute('include'),
-			/** @type {Token & {firstChild: string}} */ token = this.type !== 'ext-attr' && !Parser.running
-				? Parser.run(() => new Token(string, config).parseOnce(0, include).parseOnce())
-				: undefined,
-			string = removeComment(token?.firstChild ?? this.toString()).replace(/\x00\d+~\x7f/g, '=');
-		const build = /** @param {string|boolean} str */ str => {
-			return typeof str === 'boolean' || !(token instanceof Token)
-				? str
-				: token.buildFromStr(str).map(String).join('');
-		};
+		let string = this.toString(),
+			/** @type {Token & {firstChild: string}} */ 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;
+		}
+		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('');
 		for (const [, key,, quoted, unquoted] of string
 			.matchAll(/([^\s/][^\s/=]*)(?:\s*=\s*(?:(["'])(.*?)(?:\2|$)|(\S*)))?/sg)
 		) {
@@ -147,7 +146,7 @@ class AttributeToken extends Token {
 	/** @param {string} key */
 	hasAttr(key) {
 		if (typeof key !== 'string') {
-			typeError(this, 'hasAttr', 'String');
+			this.typeError('hasAttr', 'String');
 		}
 		return this.#attr.has(key.toLowerCase().trim());
 	}
@@ -161,7 +160,7 @@ class AttributeToken extends Token {
 		if (key === undefined) {
 			return Object.fromEntries(this.#attr);
 		} else if (typeof key !== 'string') {
-			typeError(this, 'getAttr', 'String');
+			this.typeError('getAttr', 'String');
 		}
 		return this.#attr.get(key.toLowerCase().trim());
 	}
@@ -182,7 +181,7 @@ class AttributeToken extends Token {
 	setAttr(key, value, init = false) {
 		init &&= !externalUse('setAttr');
 		if (typeof key !== 'string' || !['string', 'boolean'].includes(typeof value)) {
-			typeError(this, 'setValue', 'String', 'Boolean');
+			this.typeError('setValue', 'String', 'Boolean');
 		} else if (!init && this.type === 'ext-attr' && typeof value === 'string' && value.includes('>')) {
 			throw new RangeError('扩展标签属性不能包含 ">"！');
 		}
@@ -214,7 +213,7 @@ class AttributeToken extends Token {
 	 */
 	removeAttr(key) {
 		if (typeof key !== 'string') {
-			typeError(this, 'removeAttr', 'String');
+			this.typeError('removeAttr', 'String');
 		}
 		key = key.toLowerCase().trim();
 		if (this.#attr.delete(key)) {
@@ -229,7 +228,7 @@ class AttributeToken extends Token {
 	 */
 	toggleAttr(key, force) {
 		if (typeof key !== 'string') {
-			typeError(this, 'toggleAttr', 'String');
+			this.typeError('toggleAttr', 'String');
 		} else if (force !== undefined) {
 			force = Boolean(force);
 		}
@@ -241,13 +240,24 @@ class AttributeToken extends Token {
 		this.setAttr(key, force === true || force === undefined && value === false);
 	}
 
+	#leadingSpace(str = super.toString()) {
+		return this.type !== 'table-attr' && str && !/^\s/.test(str) ? ' ' : '';
+	}
+
+	/** @this {AttributeToken & Token} */
 	toString() {
-		const str = super.toString();
-		return this.type === 'table-attr' ? str.replaceAll('\n', ' ') : str;
+		const str = this.type === 'table-attr' ? normalizeSpace(this) : super.toString();
+		return `${this.#leadingSpace(str)}${str}`;
+	}
+
+	getPadding() {
+		return this.#leadingSpace().length;
 	}
 
 	text() {
-		return this.#updateFromAttr();
+		let str = this.#updateFromAttr();
+		str = `${this.#leadingSpace(str)}${str}`;
+		return this.type === 'table-attr' ? normalizeSpace(str) : str;
 	}
 
 	/** @returns {[number, string][]} */

package/src/converter.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const {text} = require('../util/string'),
+	/** @type {Parser} */ Parser = require('..'),
+	Token = require('.'),
+	ConverterFlagsToken = require('./converterFlags'),
+	ConverterRuleToken = require('./converterRule');
+
+/**
+ * 转换
+ * @classdesc `{childNodes: [ConverterFlagsToken, ...ConverterRuleToken]}`
+ */
+class ConverterToken extends Token {
+	type = 'converter';
+
+	/**
+	 * @param {string[]} flags
+	 * @param {string[]} rules
+	 * @param {accum} accum
+	 */
+	constructor(flags, rules, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, false, 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)),
+				);
+			}
+		}
+		this.protectChildren(0);
+	}
+
+	cloneNode() {
+		const [flags, ...rules] = this.cloneChildren(),
+			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(';')}}-`;
+	}
+
+	getPadding() {
+		return 2;
+	}
+
+	/** @param {number} i */
+	getGaps(i = 0) {
+		i = i < 0 ? i + this.childNodes.length : i;
+		return i || this.firstElementChild.childNodes.length ? 1 : 0;
+	}
+
+	text() {
+		const [flags, ...rules] = this.children;
+		return `-{${flags.text()}|${text(rules, ';')}}-`;
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return this.children.slice(1).flatMap(child => child.plain());
+	}
+
+	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	getAllFlags() {
+		return this.firstChild.getAllFlags();
+	}
+
+	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	getEffectiveFlags() {
+		return this.firstChild.getEffectiveFlags();
+	}
+
+	/** @this {ConverterToken & {firstChild: ConverterFlagsToken}} */
+	getUnknownFlags() {
+		return this.firstChild.getUnknownFlags();
+	}
+
+	/**
+	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
+	 * @param {string} flag
+	 */
+	hasFlag(flag) {
+		return this.firstChild.hasFlag(flag);
+	}
+
+	/**
+	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
+	 * @param {string} flag
+	 */
+	hasEffectiveFlag(flag) {
+		return this.firstChild.hasEffectiveFlag(flag);
+	}
+
+	/**
+	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
+	 * @param {string} flag
+	 */
+	removeFlag(flag) {
+		this.firstChild.removeFlag(flag);
+	}
+
+	/**
+	 * @this {ConverterToken & {firstChild: ConverterFlagsToken}}
+	 * @param {string} flag
+	 */
+	setFlag(flag) {
+		this.firstChild.setFlag(flag);
+	}
+
+	/**
+	 * @this {ConverterToken & {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;
+module.exports = ConverterToken;