wikiparser-node 0.3.0 → 0.4.0

package/parser/table.js

@@ -1,29 +1,36 @@
 'use strict';
 
-const /** @type {Parser} */ Parser = require('..');
+const Parser = require('..'),
+	AstText = require('../lib/text');
 
 /**
- * `tr`和`td`包含开头的换行
- * @param {{firstChild: string, type: string}}
+ * 解析表格，注意`tr`和`td`包含开头的换行
+ * @param {{firstChild: AstText, type: string}} root 根节点
  * @param {accum} accum
  */
-const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = []) => {
+const parseTable = ({firstChild: {data}, type}, config = Parser.getConfig(), accum = []) => {
 	const Token = require('../src'),
 		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');
+		DdToken = require('../src/nowiki/dd');
+	const /** @type {TrToken[]} */ stack = [],
+		lines = data.split('\n');
 	let out = type === 'root' ? '' : `\n${lines.shift()}`;
-	const /** @type {(str: string, top: TrToken & {firstChild: string}) => void} */ push = (str, top) => {
+
+	/**
+	 * 向表格中插入纯文本
+	 * @param {string} str 待插入的文本
+	 * @param {TrToken} top 当前解析的表格或表格行
+	 */
+	const push = (str, top) => {
 		if (!top) {
 			out += str;
 			return;
 		}
 		const {lastElementChild} = top;
 		if (lastElementChild.isPlain()) {
-			lastElementChild.setText(lastElementChild.firstChild + str, 0);
+			lastElementChild.setText(String(lastElementChild) + str);
 		} else {
 			const token = new Token(str, config, true, accum);
 			token.type = 'table-inter';
@@ -32,9 +39,9 @@ const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = [])
 	};
 	for (const outLine of lines) {
 		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)(.*)/);
+		const [spaces] = /^(?:\s|\0\d+c\x7F)*/u.exec(outLine),
+			line = outLine.slice(spaces.length),
+			matchesStart = /^(:*)((?:\s|\0\d+c\x7F)*)(\{\||\{\0\d+!\x7F|\0\d+\{\x7F)(.*)$/u.exec(line);
 		if (matchesStart) {
 			while (top && top.type !== 'td') {
 				top = stack.pop();
@@ -43,7 +50,7 @@ const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = [])
 			if (indent) {
 				new DdToken(indent, config, accum);
 			}
-			push(`\n${spaces}${indent && `\x00${accum.length - 1}d\x7f`}${moreSpaces}\x00${accum.length}b\x7f`, top);
+			push(`\n${spaces}${indent && `\0${accum.length - 1}d\x7F`}${moreSpaces}\0${accum.length}b\x7F`, top);
 			const table = new TableToken(tableSyntax, attr, config, accum);
 			stack.push(...top ? [top] : [], table);
 			continue;
@@ -51,9 +58,9 @@ const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = [])
 			out += `\n${outLine}`;
 			continue;
 		}
-		const matches = line.match(
-			/^(?:(\|}|\x00\d+!\x7f}|\x00\d+}\x7f)|(\|-+|\x00\d+!\x7f-+|\x00\d+-\x7f-*)|(!|(?:\||\x00\d+!\x7f)\+?))(.*)/,
-		);
+		const matches = // eslint-disable-line operator-linebreak
+			/^(?:(\|\}|\0\d+!\x7F\}|\0\d+\}\x7F)|(\|-+|\0\d+!\x7F-+|\0\d+-\x7F-*)(?!-)|(!|(?:\||\0\d+!\x7F)\+?))(.*)$/u
+				.exec(line);
 		if (!matches) {
 			push(`\n${outLine}`, top);
 			stack.push(...top ? [top] : []);
@@ -81,8 +88,8 @@ const parseTable = ({firstChild, type}, config = Parser.getConfig(), accum = [])
 				top = stack.pop();
 			}
 			const regex = cell === '!'
-				? /!!|(?:\||\x00\d+!\x7f){2}|\x00\d+\+\x7f/g
-				: /(?:\||\x00\d+!\x7f){2}|\x00\d+\+\x7f/g;
+				? /!!|(?:\||\0\d+!\x7F){2}|\0\d+\+\x7F/gu
+				: /(?:\||\0\d+!\x7F){2}|\0\d+\+\x7F/gu;
 			let mt = regex.exec(attr),
 				lastIndex = 0,
 				lastSyntax = `\n${spaces}${cell}`;

package/printed/example.json

@@ -0,0 +1,120 @@
+{
+  "type": "root",
+  "childNodes": [
+    {
+      "type": "ext",
+      "name": "ref",
+      "childNodes": [
+        {
+          "type": "ext-attr",
+          "name": "ref",
+          "childNodes": [
+            ""
+          ]
+        },
+        {
+          "type": "ext-inner",
+          "name": "ref",
+          "childNodes": [
+            {
+              "type": "template",
+              "name": "Template:T",
+              "childNodes": [
+                {
+                  "type": "template-name",
+                  "childNodes": [
+                    "T"
+                  ]
+                },
+                {
+                  "type": "parameter",
+                  "name": "1",
+                  "childNodes": [
+                    {
+                      "type": "parameter-key",
+                      "childNodes": []
+                    },
+                    {
+                      "type": "parameter-value",
+                      "childNodes": [
+                        {
+                          "type": "html",
+                          "name": "br",
+                          "childNodes": [
+                            {
+                              "type": "html-attr",
+                              "name": "br",
+                              "childNodes": [
+                                ""
+                              ]
+                            }
+                          ]
+                        },
+                        "\n",
+                        {
+                          "type": "hr",
+                          "childNodes": [
+                            "----"
+                          ]
+                        },
+                        "\n",
+                        {
+                          "type": "file",
+                          "name": "File:F",
+                          "childNodes": [
+                            {
+                              "type": "link-target",
+                              "childNodes": [
+                                "File:F"
+                              ]
+                            },
+                            {
+                              "type": "image-parameter",
+                              "name": "thumbnail",
+                              "childNodes": []
+                            },
+                            {
+                              "type": "image-parameter",
+                              "name": "caption",
+                              "childNodes": [
+                                {
+                                  "type": "quote",
+                                  "name": "2",
+                                  "childNodes": [
+                                    "''"
+                                  ]
+                                },
+                                {
+                                  "type": "ext-link",
+                                  "childNodes": [
+                                    {
+                                      "type": "ext-link-url",
+                                      "childNodes": [
+                                        "//example.net"
+                                      ]
+                                    }
+                                  ]
+                                },
+                                {
+                                  "type": "quote",
+                                  "name": "2",
+                                  "childNodes": [
+                                    "''"
+                                  ]
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/src/arg.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {text, noWrap} = require('../util/string'),
-	/** @type {Parser} */ Parser = require('..'),
+	Parser = require('..'),
 	Token = require('.');
 
 /**
@@ -12,30 +12,31 @@ class ArgToken extends Token {
 	type = 'arg';
 
 	/**
-	 * @param {string[]} parts
+	 * @param {string[]} parts 以'|'分隔的各部分
 	 * @param {accum} accum
 	 * @complexity `n`
 	 */
 	constructor(parts, config = Parser.getConfig(), accum = []) {
 		super(undefined, config, true, accum, {AtomToken: 0, Token: 1, HiddenToken: '2:'});
-		for (const [i, part] of parts.entries()) {
+		for (let i = 0; i < parts.length; i++) {
 			if (i === 0 || i > 1) {
 				const AtomToken = i === 0 ? require('./atom') : require('./atom/hidden'),
-					token = new AtomToken(part, `arg-${i === 0 ? 'name' : 'redundant'}`, config, accum, {
+					token = new AtomToken(parts[i], i === 0 ? 'arg-name' : undefined, config, accum, {
 						'Stage-2': ':', '!HeadingToken': '',
 					});
 				this.appendChild(token);
 			} else {
-				const token = new Token(part, config, true, accum);
+				const token = new Token(parts[i], config, true, accum);
 				token.type = 'arg-default';
 				this.appendChild(token.setAttribute('stage', 2));
 			}
 		}
-		this.protectChildren(0);
+		this.getAttribute('protectChildren')(0);
 	}
 
+	/** @override */
 	cloneNode() {
-		const [name, ...cloned] = this.cloneChildren();
+		const [name, ...cloned] = this.cloneChildNodes();
 		return Parser.run(() => {
 			const token = new ArgToken([''], this.getAttribute('config'));
 			token.firstElementChild.safeReplaceWith(name);
@@ -44,36 +45,48 @@ class ArgToken extends Token {
 		});
 	}
 
+	/** @override */
 	afterBuild() {
 		this.setAttribute('name', this.firstElementChild.text().trim());
-		const that = this,
-			/** @type {AstListener} */ argListener = ({prevTarget}) => {
-				if (prevTarget === that.firstElementChild) {
-					that.setAttribute('name', prevTarget.text().trim());
-				}
-			};
+		const /** @type {AstListener} */ argListener = ({prevTarget}) => {
+			if (prevTarget === this.firstElementChild) {
+				this.setAttribute('name', prevTarget.text().trim());
+			}
+		};
 		this.addEventListener(['remove', 'insert', 'replace', 'text'], argListener);
 		return this;
 	}
 
-	toString() {
-		return `{{{${super.toString('|')}}}}`;
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		return selector && this.matches(selector) ? '' : `{{{${super.toString(selector, '|')}}}}`;
 	}
 
+	/** @override */
 	getPadding() {
 		return 3;
 	}
 
+	/** @override */
 	getGaps() {
 		return 1;
 	}
 
-	/** @returns {string} */
+	/**
+	 * @override
+	 * @returns {string}
+	 */
 	text() {
 		return `{{{${text(this.children.slice(0, 2), '|')}}}}`;
 	}
 
-	/** @complexity `n` */
+	/**
+	 * 移除无效部分
+	 * @complexity `n`
+	 */
 	removeRedundant() {
 		Parser.run(() => {
 			for (let i = this.childNodes.length - 1; i > 1; i--) {
@@ -83,8 +96,8 @@ class ArgToken extends Token {
 	}
 
 	/**
-	 * 删除`arg-default`子节点时自动删除全部`arg-redundant`子节点
-	 * @param {number} i
+	 * 移除子节点，且在移除`arg-default`子节点时自动移除全部多余子节点
+	 * @param {number} i 移除位置
 	 * @returns {Token}
 	 */
 	removeAt(i) {
@@ -94,11 +107,16 @@ class ArgToken extends Token {
 		return super.removeAt(i);
 	}
 
-	/** @param {Token} token */
+	/**
+	 * @override
+	 * @param {Token} token 待插入的子节点
+	 * @param {number} i 插入位置
+	 * @throws `RangeError` 不可插入多余子节点
+	 */
 	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 子节点！`);
+			throw new RangeError(`${this.constructor.name} 不可插入多余的子节点！`);
 		}
 		super.insertAt(token, i);
 		if (j === 1) {
@@ -107,7 +125,11 @@ class ArgToken extends Token {
 		return token;
 	}
 
-	/** @param {string} name */
+	/**
+	 * 设置参数名
+	 * @param {string} name 新参数名
+	 * @throws `SyntaxError` 非法的参数名
+	 */
 	setName(name) {
 		name = String(name);
 		const root = Parser.parse(`{{{${name}}}}`, this.getAttribute('include'), 2, this.getAttribute('config')),
@@ -115,13 +137,16 @@ class ArgToken extends Token {
 		if (length !== 1 || firstElementChild?.type !== 'arg' || firstElementChild.childNodes.length !== 1) {
 			throw new SyntaxError(`非法的参数名称：${noWrap(name)}`);
 		}
-		const newName = firstElementChild.firstElementChild;
-		root.destroy();
-		firstElementChild.destroy();
+		const {firstElementChild: newName} = firstElementChild;
+		firstElementChild.destroy(true);
 		this.firstElementChild.safeReplaceWith(newName);
 	}
 
-	/** @param {string} value */
+	/**
+	 * 设置预设值
+	 * @param {string} value 预设值
+	 * @throws `SyntaxError` 非法的参数预设值
+	 */
 	setDefault(value) {
 		value = String(value);
 		const root = Parser.parse(`{{{|${value}}}}`, this.getAttribute('include'), 2, this.getAttribute('config')),
@@ -129,14 +154,13 @@ class ArgToken extends Token {
 		if (length !== 1 || firstElementChild?.type !== 'arg' || firstElementChild.childNodes.length !== 2) {
 			throw new SyntaxError(`非法的参数预设值：${noWrap(value)}`);
 		}
-		const [, oldDefault] = this.children,
-			newDefault = firstElementChild.lastElementChild;
-		root.destroy();
-		firstElementChild.destroy();
+		const {children: [, oldDefault]} = this,
+			{lastElementChild} = firstElementChild;
+		firstElementChild.destroy(true);
 		if (oldDefault) {
-			oldDefault.safeReplaceWith(newDefault);
+			oldDefault.safeReplaceWith(lastElementChild);
 		} else {
-			this.appendChild(newDefault);
+			this.appendChild(lastElementChild);
 		}
 	}
 }

package/src/atom/hidden.js

@@ -1,10 +1,13 @@
 'use strict';
 
 const hidden = require('../../mixin/hidden'),
-	/** @type {Parser} */ Parser = require('../..'),
+	Parser = require('../..'),
 	AtomToken = require('.');
 
-class HiddenToken extends hidden(AtomToken) {}
+/** 不可见的节点 */
+class HiddenToken extends hidden(AtomToken) {
+	type = 'hidden';
+}
 
 Parser.classes.HiddenToken = __filename;
 module.exports = HiddenToken;

package/src/atom/index.js

@@ -1,29 +1,37 @@
 'use strict';
 
-const /** @type {Parser} */ Parser = require('../..'),
+const Parser = require('../..'),
 	Token = require('..');
 
 /**
  * 不会被继续解析的plain Token
- * @classdesc `{childNodes: (string|Token)[]}`
+ * @classdesc `{childNodes: (AstText|Token)[]}`
  */
 class AtomToken extends Token {
+	type = 'plain';
+
 	/**
-	 * @param {?string} wikitext
+	 * @param {string} wikitext wikitext
+	 * @param {string|undefined} type Token.type
 	 * @param {accum} accum
-	 * @param {acceptable} acceptable
+	 * @param {acceptable} acceptable 可接受的子节点设置
 	 */
-	constructor(wikitext, type = 'plain', config = Parser.getConfig(), accum = [], acceptable = null) {
+	constructor(wikitext, type, config = Parser.getConfig(), accum = [], acceptable = null) {
 		super(wikitext, config, true, accum, acceptable);
-		this.type = type;
+		if (type) {
+			this.type = type;
+		}
 	}
 
+	/**
+	 * @override
+	 * @this {AtomToken & {constructor: typeof AtomToken}}
+	 */
 	cloneNode() {
-		const cloned = this.cloneChildren(),
-			/** @type {typeof AtomToken} */ Constructor = this.constructor,
+		const cloned = this.cloneChildNodes(),
 			config = this.getAttribute('config'),
 			acceptable = this.getAttribute('acceptable'),
-			token = Parser.run(() => new Constructor(undefined, this.type, config, [], acceptable));
+			token = Parser.run(() => new this.constructor(undefined, this.type, config, [], acceptable));
 		token.append(...cloned);
 		return token;
 	}