wikiparser-node 0.1.0 → 0.2.2

package/config/default.json

@@ -763,5 +763,16 @@
 		"底部": "bottom",
 		"text-bottom": "text-bottom",
 		"文字底部": "text-bottom"
-	}
+	},
+	"variants": [
+		"zh",
+		"zh-hans",
+		"zh-hant",
+		"zh-cn",
+		"zh-tw",
+		"zh-hk",
+		"zh-sg",
+		"zh-my",
+		"zh-mo"
+	]
 }

package/config/llwiki.json

@@ -683,5 +683,16 @@
 		"底部": "bottom",
 		"text-bottom": "text-bottom",
 		"文字底部": "text-bottom"
-	}
+	},
+	"variants": [
+		"zh",
+		"zh-hans",
+		"zh-hant",
+		"zh-cn",
+		"zh-tw",
+		"zh-hk",
+		"zh-sg",
+		"zh-my",
+		"zh-mo"
+	]
 }

package/config/moegirl.json

@@ -718,5 +718,13 @@
 		"底部": "bottom",
 		"text-bottom": "text-bottom",
 		"文字底部": "text-bottom"
-	}
+	},
+	"variants": [
+		"zh",
+		"zh-hans",
+		"zh-hant",
+		"zh-cn",
+		"zh-tw",
+		"zh-hk"
+	]
 }

package/index.js

@@ -77,6 +77,7 @@ const /** @type {Parser} */ Parser = {
 		['ExtLinkToken'],
 		['MagicLinkToken'],
 		['ListToken', 'DdToken'],
+		['ConverterToken'],
 	],
 
 	config: './config/default',
@@ -178,6 +179,47 @@ const /** @type {Parser} */ Parser = {
 		delete require.cache[require.resolve('./tool')];
 		return require('./tool');
 	},
+
+	typeAliases: {
+		ext: ['extension'],
+		'ext-inner': ['extension-inner'],
+		arg: ['argument'],
+		'arg-name': ['argument-name'],
+		'arg-default': ['argument-default'],
+		'arg-redundant': ['argument-redundant'],
+		template: ['tpl'],
+		'template-name': ['tpl-name'],
+		'magic-word': ['parser-function', 'parser-func'],
+		'invoke-function': ['invoke-func'],
+		'invoke-module': ['invoke-mod'],
+		parameter: ['param'],
+		'parameter-key': ['param-key'],
+		'parameter-value': ['parameter-val', 'param-value', 'param-val'],
+		heading: ['header'],
+		'heading-title': ['header-title'],
+		table: ['tbl'],
+		'table-inter': ['tbl-inter'],
+		tr: ['table-row', 'tbl-row'],
+		td: ['table-cell', 'tbl-cell', 'table-data', 'tbl-data'],
+		'double-underscore': ['underscore', 'behavior-switch', 'behaviour-switch'],
+		hr: ['horizontal'],
+		category: ['category-link', 'cat', 'cat-link'],
+		file: ['file-link', 'image', 'image-link', 'img', 'img-link'],
+		'image-parameter': ['img-parameter', 'image-param', 'img-param'],
+		quote: ['quotes', 'quot', 'apostrophe', 'apostrophes', 'apos'],
+		'ext-link': ['external-link'],
+		'ext-link-text': ['external-link-text'],
+		'ext-link-url': ['external-link-url'],
+		'free-ext-link': ['free-external-link', 'magic-link'],
+		dd: ['indent', 'indentation'],
+		converter: ['convert', 'conversion'],
+		'converter-flags': ['convert-flags', 'conversion-flags', 'converter-flag', 'convert-flag', 'conversion-flag'],
+		'converter-rule': ['convert-rule', 'conversion-rule'],
+		'converter-rule-noconvert': ['convert-rule-noconvert', 'conversion-rule-noconvert'],
+		'converter-rule-variant': ['convert-rule-variant', 'conversion-rule-variant'],
+		'converter-rule-to': ['convert-rule-to', 'conversion-rule-to'],
+		'converter-rule-from': ['convert-rule-from', 'conversion-rule-from'],
+	},
 };
 
 const /** @type {PropertyDescriptorMap} */ def = {};

package/lib/element.js

@@ -402,7 +402,8 @@ class AstElement extends AstNode {
 				),
 				[type, ...parts] = plainSelector.trim().split('#'),
 				name = parts.join('#');
-			return (!type || this.type === type) && (!name || this.name === name)
+			return (!type || this.type === type || Boolean(Parser.typeAliases[this.type]?.includes(type)))
+				&& (!name || this.name === name)
 				&& attributes.every(args => this.matchesAttr(...args));
 		}
 		/*

package/mixin/sol.js

@@ -11,14 +11,18 @@ const /** @type {Parser} */ Parser = require('..'),
 const sol = constructor => class extends constructor {
 	/** @this {Token} */
 	prependNewLine() {
-		const {previousVisibleSibling} = this;
-		return previousVisibleSibling && !String(previousVisibleSibling).endsWith('\n') ? '\n' : '';
+		const {previousVisibleSibling = '', parentNode} = this;
+		return (previousVisibleSibling || parentNode?.type !== 'root') && !String(previousVisibleSibling).endsWith('\n')
+			? '\n'
+			: '';
 	}
 
 	/** @this {Token} */
 	appendNewLine() {
-		const {nextVisibleSibling} = this;
-		return nextVisibleSibling && !String(nextVisibleSibling).startsWith('\n') ? '\n' : '';
+		const {nextVisibleSibling = '', parentNode} = this;
+		return (nextVisibleSibling || parentNode?.type !== 'root') && !String(nextVisibleSibling ?? '').startsWith('\n')
+			? '\n'
+			: '';
 	}
 
 	toString(ownLine = false) {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "wikiparser-node",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "A Node.js parser for MediaWiki markup with AST",
   "keywords": [
     "mediawiki",
     "wikitext",
     "parser"
   ],
-  "homepage": "https://github.com/bhsd-harry/wikiparser-node#readme",
+  "homepage": "https://github.com/bhsd-harry/wikiparser-node/wiki",
   "bugs": {
     "url": "https://github.com/bhsd-harry/wikiparser-node/issues"
   },

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/table.js

@@ -12,6 +12,7 @@ const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = [])
 		TableToken = require('../src/table'),
 		TrToken = require('../src/table/tr'),
 		TdToken = require('../src/table/td'),
+		DdToken = require('../src/nowiki/dd'),
 		/** @type {TrToken[]} */ stack = [],
 		lines = firstChild.split('\n');
 	let out = type === 'root' ? '' : `\n${lines.shift()}`;
@@ -33,10 +34,13 @@ const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = [])
 		let top = stack.pop();
 		const [spaces] = outLine.match(/^(?:\s|\x00\d+c\x7f)*/);
 		const line = outLine.slice(spaces.length),
-			matchesStart = line.match(/^(:*(?:\s|\x00\d+c\x7f)*)({\||{\x00\d+!\x7f|\x00\d+{\x7f)(.*)/);
+			matchesStart = line.match(/^(:*)((?:\s|\x00\d+c\x7f)*)({\||{\x00\d+!\x7f|\x00\d+{\x7f)(.*)/);
 		if (matchesStart) {
-			const [, indent, tableSyntax, attr] = matchesStart;
-			push(`\n${spaces}${indent}\x00${accum.length}b\x7f`, top);
+			const [, indent, moreSpaces, tableSyntax, attr] = matchesStart;
+			if (indent) {
+				new DdToken(indent, config, accum);
+			}
+			push(`\n${spaces}${indent && `\x00${accum.length - 1}d\x7f`}${moreSpaces}\x00${accum.length}b\x7f`, top);
 			const table = new TableToken(tableSyntax, attr, config, accum);
 			stack.push(...top ? [top] : [], table);
 			continue;

package/src/arg.js

@@ -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,7 +117,7 @@ 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) {
+		if (length !== 1 || firstElementChild?.type !== 'arg' || firstElementChild.childNodes.length !== 1) {
 			throw new SyntaxError(`非法的参数名称：${noWrap(name)}`);
 		}
 		const newName = firstElementChild.firstElementChild;
@@ -131,7 +131,7 @@ 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) {
+		if (length !== 1 || firstElementChild?.type !== 'arg' || firstElementChild.childNodes.length !== 2) {
 			throw new SyntaxError(`非法的参数预设值：${noWrap(value)}`);
 		}
 		const [, oldDefault] = this.children,

package/src/attribute.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {externalUse} = require('../util/debug'),
-	{toCase, removeComment} = require('../util/string'),
+	{toCase, removeComment, normalizeSpace} = require('../util/string'),
 	/** @type {Parser} */ Parser = require('..'),
 	Token = require('.');
 
@@ -108,31 +108,24 @@ class AttributeToken extends Token {
 		return super.getAttribute(key);
 	}
 
-	/** @complexity `n` */
-	build() {
-		super.build();
-		if (this.type === 'ext-attr') {
-			return this;
-		}
-		for (let [key, text] of this.#attr) {
-			let built = false;
-			if (key.includes('\x00')) {
-				this.#attr.delete(key);
-				key = this.buildFromStr(key).map(String).join('');
-				built = true;
-			}
-			if (typeof text === 'string' && text.includes('\x00')) {
-				text = this.buildFromStr(text).map(String).join('');
-				built = true;
-			}
-			if (built) {
-				this.#attr.set(key, text);
+	afterBuild() {
+		if (this.type !== 'ext-attr') {
+			for (let [key, text] of this.#attr) {
+				let built = false;
+				if (key.includes('\x00')) {
+					this.#attr.delete(key);
+					key = this.buildFromStr(key).map(String).join('');
+					built = true;
+				}
+				if (typeof text === 'string' && text.includes('\x00')) {
+					text = this.buildFromStr(text).map(String).join('');
+					built = true;
+				}
+				if (built) {
+					this.#attr.set(key, text);
+				}
 			}
 		}
-		return this;
-	}
-
-	afterBuild() {
 		const that = this,
 			/** @type {AstListener} */ attributeListener = ({type, target}) => {
 				if (type === 'text' || target !== that) {
@@ -241,13 +234,13 @@ class AttributeToken extends Token {
 	}
 
 	#leadingSpace(str = super.toString()) {
-		return str && !/^\s/.test(str) ? ' ' : '';
+		return this.type !== 'table-attr' && str && !/^\s/.test(str) ? ' ' : '';
 	}
 
+	/** @this {AttributeToken & Token} */
 	toString() {
-		let str = super.toString();
-		str = `${this.#leadingSpace(str)}${str}`;
-		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() {
@@ -257,7 +250,7 @@ class AttributeToken extends Token {
 	text() {
 		let str = this.#updateFromAttr();
 		str = `${this.#leadingSpace(str)}${str}`;
-		return this.type === 'table-attr' ? str.replaceAll('\n', ' ') : 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;