wikiparser-node 0.7.1-b → 0.8.0-m

package/index.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = {
+	config: undefined,
+	minConfig: require('./config/minimum'),
+
+	MAX_STAGE: 11,
+
+	getConfig(path) {
+		if (path) {
+			this.config = require(path);
+		}
+		return {...this.minConfig, ...this.config, excludes: []};
+	},
+
+	normalizeTitle(
+		title,
+		defaultNs = 0,
+		include = false,
+		config = Parser.getConfig(),
+		halfParsed = false,
+		decode = false,
+		selfLink = false,
+	) {
+		let /** @type {Token} */ token;
+		if (!halfParsed) {
+			const Token = require('./src');
+			token = this.run(() => {
+				const newToken = new Token(String(title), config),
+					parseOnce = newToken.getAttribute('parseOnce');
+				parseOnce(0, include);
+				return parseOnce();
+			});
+			title = token.firstChild;
+		}
+		const Title = require('./lib/title');
+		const titleObj = new Title(String(title), defaultNs, config, decode, selfLink);
+		return titleObj;
+	},
+
+	parse(wikitext, include, maxStage = Parser.MAX_STAGE, config = Parser.getConfig()) {
+		if (typeof wikitext !== 'string') {
+			throw new TypeError('待解析的内容应为 String！');
+		}
+		const Token = require('./src');
+		let /** @type {Token} */ token;
+		this.run(() => {
+			token = new Token(wikitext, config);
+			try {
+				token.parse(maxStage, include);
+			} catch {}
+		});
+		return token;
+	},
+
+	run(callback) {
+		return callback();
+	},
+
+	isInterwiki(title, {interwiki} = Parser.getConfig()) {
+		title = String(title);
+		return new RegExp(`^(${interwiki.join('|')})\\s*:`, 'iu')
+			.exec(title.replaceAll('_', ' ').replace(/^\s*:?\s*/u, ''));
+	},
+};
+
+const /** @type {PropertyDescriptorMap} */ def = {},
+	immutable = new Set(['MAX_STAGE', 'minConfig']),
+	enumerable = new Set(['config', 'normalizeTitle', 'parse', 'isInterwiki']);
+for (const key in Parser) {
+	if (immutable.has(key)) {
+		def[key] = {enumerable: false, writable: false};
+	} else if (!enumerable.has(key)) {
+		def[key] = {enumerable: false};
+	}
+}
+Object.defineProperties(Parser, def);
+
+module.exports = Parser;

package/lib/element.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs'),
+	path = require('path'),
+	AstNode = require('./node'),
+	AstText = require('./text');
+
+/** 类似HTMLElement */
+class AstElement extends AstNode {
+	/** @type {string} */ name;
+
+	/** 子节点总数 */
+	get length() {
+		return this.childNodes.length;
+	}
+
+	/**
+	 * 最近的祖先节点
+	 * @param {string} selector
+	 */
+	closest(selector) {
+		const types = new Set(selector.split(',').map(type => type.trim()));
+		let {parentNode} = this;
+		while (parentNode) {
+			if (types.has(parentNode.type)) {
+				return parentNode;
+			}
+			({parentNode} = parentNode);
+		}
+		return undefined;
+	}
+
+	/**
+	 * 在末尾批量插入子节点
+	 * @param {...this} elements 插入节点
+	 * @complexity `n`
+	 */
+	append(...elements) {
+		for (const element of elements) {
+			this.insertAt(element);
+		}
+	}
+
+	/**
+	 * 批量替换子节点
+	 * @param {...this} elements 新的子节点
+	 * @complexity `n`
+	 */
+	replaceChildren(...elements) {
+		this.childNodes.length = 0;
+		this.append(...elements);
+	}
+
+	/**
+	 * 修改文本子节点
+	 * @param {string} str 新文本
+	 * @param {number} i 子节点位置
+	 */
+	setText(str, i = 0) {
+		const /** @type {AstText} */ oldText = this.childNodes[i],
+			{type, data} = oldText;
+		if (type === 'text') {
+			oldText.replaceData(str);
+			return data;
+		}
+		return undefined;
+	}
+
+	/**
+	 * 还原为wikitext
+	 * @param {string} separator 子节点间的连接符
+	 * @returns {string}
+	 */
+	toString(selector, separator = '') {
+		return this.childNodes.map(child => child.toString()).join(separator);
+	}
+
+	static lintIgnoredExt = new Set([
+		'nowiki',
+		'pre',
+		'charinsert',
+		'score',
+		'syntaxhighlight',
+		'source',
+		'math',
+		'chem',
+		'ce',
+		'graph',
+		'mapframe',
+		'maplink',
+		'quiz',
+		'templatedata',
+		'timeline',
+	]);
+
+	/**
+	 * Linter
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const SyntaxToken = require('../src/syntax');
+		if (this instanceof SyntaxToken || this.constructor.hidden
+			|| this.type === 'ext-inner' && AstElement.lintIgnoredExt.has(this.name)
+		) {
+			return [];
+		}
+		const /** @type {LintError[]} */ errors = [];
+		for (let i = 0, cur = start + this.getPadding(); i < this.length; i++) {
+			const child = this.childNodes[i];
+			errors.push(...child.lint(cur));
+			cur += String(child).length + this.getGaps(i);
+		}
+		return errors;
+	}
+
+	/**
+	 * 保存为JSON
+	 * @param {string} file 文件名
+	 * @returns {Record<string, *>}
+	 */
+	json(file) {
+		const {childNodes, ...prop} = this,
+			json = {
+				...prop,
+				childNodes: childNodes.map(child => child.type === 'text' ? String(child) : child.json()),
+			};
+		if (typeof file === 'string') {
+			fs.writeFileSync(
+				path.join(__dirname.slice(0, -4), 'printed', `${file}${file.endsWith('.json') ? '' : '.json'}`),
+				JSON.stringify(json, null, 2),
+			);
+		}
+		return json;
+	}
+}
+
+module.exports = AstElement;

package/lib/node.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const {text} = require('../util/string');
+
+/** 类似Node */
+class AstNode {
+	/** @type {string} */ type;
+	/** @type {this[]} */ childNodes = [];
+	/** @type {this} */ #parentNode;
+
+	/** 首位子节点 */
+	get firstChild() {
+		return this.childNodes[0];
+	}
+
+	/** 末位子节点 */
+	get lastChild() {
+		return this.childNodes.at(-1);
+	}
+
+	/** 父节点 */
+	get parentNode() {
+		return this.#parentNode;
+	}
+
+	/**
+	 * 后一个兄弟节点
+	 * @complexity `n`
+	 */
+	get nextSibling() {
+		const childNodes = this.#parentNode?.childNodes;
+		return childNodes && childNodes[childNodes.indexOf(this) + 1];
+	}
+
+	/**
+	 * 前一个兄弟节点
+	 * @complexity `n`
+	 */
+	get previousSibling() {
+		const childNodes = this.#parentNode?.childNodes;
+		return childNodes && childNodes[childNodes.indexOf(this) - 1];
+	}
+
+	/**
+	 * 是否具有某属性
+	 * @param {PropertyKey} key 属性键
+	 */
+	hasAttribute(key) {
+		const type = typeof key;
+		return type === 'string' || type === 'number' || type === 'symbol'
+			? key in this
+			: false;
+	}
+
+	/**
+	 * 获取属性值。除非用于私有属性，否则总是返回字符串。
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		return this.hasAttribute(key) ? String(this[key]) : undefined;
+	}
+
+	/**
+	 * 设置属性
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @param {TokenAttribute<T>} value 属性值
+	 */
+	setAttribute(key, value) {
+		if (key === 'parentNode') {
+			this.#parentNode = value;
+		} else {
+			this[key] = value;
+		}
+		return this;
+	}
+
+	/**
+	 * 可见部分
+	 * @param {string} separator 子节点间的连接符
+	 * @returns {string}
+	 * @complexity `n`
+	 */
+	text(separator = '') {
+		return text(this.childNodes, separator);
+	}
+
+	/**
+	 * 移除子节点
+	 * @param {number} i 移除位置
+	 */
+	removeAt(i) {
+		const {childNodes} = this,
+			[node] = childNodes.splice(i, 1);
+		return node;
+	}
+
+	/**
+	 * 插入子节点
+	 * @template {this} T
+	 * @param {T} node 待插入的子节点
+	 * @param {number} i 插入位置
+	 * @complexity `n`
+	 */
+	insertAt(node, i = this.childNodes.length) {
+		const {childNodes} = this,
+			j = -1;
+		if (j === -1) {
+			node.setAttribute('parentNode', this);
+		}
+		childNodes.splice(i, 0, node);
+		return node;
+	}
+
+	/**
+	 * 合并相邻的文本子节点
+	 * @complexity `n`
+	 */
+	normalize() {
+		const AstText = require('./text');
+		const /** @type {{childNodes: AstText[]}} */ {childNodes} = this;
+		for (let i = childNodes.length - 1; i >= 0; i--) {
+			const {type, data} = childNodes[i];
+			if (this.getGaps(i - 1)) {
+				//
+			} else if (data === '') {
+				childNodes.splice(i, 1);
+			} else if (type === 'text' && childNodes[i - 1]?.type === 'text') {
+				childNodes[i - 1].setAttribute('data', childNodes[i - 1].data + data);
+				childNodes.splice(i, 1);
+			}
+		}
+	}
+
+	/** 获取根节点 */
+	getRootNode() {
+		let {parentNode} = this;
+		while (parentNode?.parentNode) {
+			({parentNode} = parentNode);
+		}
+		return parentNode ?? this;
+	}
+
+	/**
+	 * 将字符位置转换为行列号
+	 * @param {number} index 字符位置
+	 * @complexity `n`
+	 */
+	posFromIndex(index) {
+		const str = String(this);
+		if (index >= -str.length && index <= str.length) {
+			const lines = str.slice(0, index).split('\n');
+			return {top: lines.length - 1, left: lines.at(-1).length};
+		}
+		return undefined;
+	}
+
+	/**
+	 * 获取行数和最后一行的列数
+	 * @complexity `n`
+	 */
+	#getDimension() {
+		const lines = String(this).split('\n');
+		return {height: lines.length, width: lines.at(-1).length};
+	}
+
+	/** 第一个子节点前的间距 */
+	getPadding() {
+		return 0;
+	}
+
+	/** 子节点间距 */
+	getGaps() {
+		return 0;
+	}
+
+	/**
+	 * 获取当前节点的相对字符位置，或其第`j`个子节点的相对字符位置
+	 * @param {number|undefined} j 子节点序号
+	 * @complexity `n`
+	 */
+	getRelativeIndex(j) {
+		let /** @type {this[]} */ childNodes;
+
+		/**
+		 * 获取子节点相对于父节点的字符位置，使用前需要先给`childNodes`赋值
+		 * @param {number} end 子节点序号
+		 * @param {this} parent 父节点
+		 * @returns {number}
+		 */
+		const getIndex = (end, parent) => childNodes.slice(0, end).reduce(
+			(acc, cur, i) => acc + String(cur).length + parent.getGaps(i),
+			0,
+		) + parent.getPadding();
+		if (j === undefined) {
+			const {parentNode} = this;
+			if (parentNode) {
+				({childNodes} = parentNode);
+				return getIndex(childNodes.indexOf(this), parentNode);
+			}
+			return 0;
+		}
+		({childNodes} = this);
+		return getIndex(j, this);
+	}
+
+	/**
+	 * 行数
+	 * @complexity `n`
+	 */
+	get offsetHeight() {
+		return this.#getDimension().height;
+	}
+
+	/**
+	 * 最后一行的列数
+	 * @complexity `n`
+	 */
+	get offsetWidth() {
+		return this.#getDimension().width;
+	}
+}
+
+module.exports = AstNode;

package/lib/text.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const Parser = require('..'),
+	AstNode = require('./node'),
+	AstElement = require('./element');
+
+const errorSyntax = /https?:|\{+|\}+|\[{2,}|\[(?![^[]*\])|((?:^|\])[^[]*?)\]+|<\s*\/?([a-z]\w*)(?=[\s/>])/giu,
+	errorSyntaxUrl = /\{+|\}+|\[{2,}|\[(?![^[]*\])|((?:^|\])[^[]*?)\]+|<\s*\/?([a-z]\w*)(?=[\s/>])/giu;
+
+/** 文本节点 */
+class AstText extends AstNode {
+	#config;
+	type = 'text';
+	/** @type {string} */ data;
+
+	/** @param {string} text 包含文本 */
+	constructor(text = '', config = Parser.getConfig()) {
+		super();
+		this.#config = config;
+		this.data = text;
+	}
+
+	/** 输出字符串 */
+	toString() {
+		return this.data;
+	}
+
+	/** @override */
+	text() {
+		return this.data;
+	}
+
+	/**
+	 * Linter
+	 * @this {AstText & {parentNode: AstElement}}
+	 * @param {number} start 起始位置
+	 * @returns {LintError[]}
+	 */
+	lint(start = 0) {
+		const {data, parentNode} = this,
+			type = parentNode?.type,
+			name = parentNode?.name,
+			urlAttr = ['itemtype', 'src', 'srcset'].includes(parentNode?.parentNode?.name),
+			errorRegex
+			= type === 'free-ext-link' || type === 'ext-link-url' || type === 'image-parameter' && name === 'link'
+				? errorSyntaxUrl
+				: errorSyntax,
+			errors = [];
+		if (data.search(errorRegex) !== -1) {
+			errorRegex.lastIndex = 0;
+			const root = this.getRootNode(),
+				{top, left} = root.posFromIndex(start),
+				allowedTags = new Set([this.#config.ext, this.#config.html].flat(2));
+			for (let mt = errorRegex.exec(data); mt; mt = errorRegex.exec(data)) {
+				const [, prefix, tag] = mt;
+				let {0: error, index} = mt;
+				if (prefix) {
+					index += prefix.length;
+					error = error.slice(prefix.length);
+				}
+				const startIndex = start + index,
+					lines = data.slice(0, index).split('\n'),
+					startLine = lines.length + top - 1,
+					line = lines.at(-1),
+					startCol = lines.length > 1 ? line.length : left + line.length,
+					{0: char, length} = error,
+					endIndex = startIndex + length,
+					end = char === '}' || char === ']' ? endIndex : startIndex + (char === 'h' ? 49 : 50);
+				let severity = length > 1 ? 'error' : 'warning';
+				if (char === 'h') {
+					switch (type) {
+						case 'ext-link-text':
+							severity = 'warning';
+							break;
+						case 'attr-value':
+							if (urlAttr) {
+								continue;
+							}
+							break;
+						case 'ext-inner':
+							if (name === 'sm2' || name === 'flashmp3') {
+								continue;
+							}
+						// no default
+					}
+				} else if (char === '<' && !allowedTags.has(tag.toLowerCase())) {
+					continue;
+				}
+				errors.push({
+					message: `孤立的"${char === 'h' ? error : char}"`,
+					severity,
+					startIndex,
+					endIndex,
+					startLine,
+					endLine: startLine,
+					startCol,
+					endCol: startCol + length,
+					excerpt: String(root).slice(Math.max(0, end - 50), end),
+				});
+			}
+		}
+		return errors;
+	}
+
+	/**
+	 * 修改内容
+	 * @param {string} text 新内容
+	 */
+	#setData(text) {
+		text = String(text);
+		this.setAttribute('data', text);
+	}
+
+	/**
+	 * 替换字符串
+	 * @param {string} text 替换的字符串
+	 */
+	replaceData(text = '') {
+		this.#setData(text);
+	}
+}
+
+module.exports = AstText;

package/lib/title.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const Parser = require('..');
+
+/** MediaWiki页面标题对象 */
+class Title {
+	valid = true;
+	ns = 0;
+	fragment = '';
+	encoded = false;
+	interwiki = '';
+
+	/**
+	 * @param {string} title 标题（含或不含命名空间前缀）
+	 * @param {number} defaultNs 命名空间
+	 * @param {boolean} decode 是否需要解码
+	 * @param {boolean} selfLink 是否允许selfLink
+	 */
+	constructor(title, defaultNs = 0, config = Parser.getConfig(), decode = false, selfLink = false) {
+		const {namespaces, nsid} = config;
+		let namespace = namespaces[defaultNs];
+		if (decode && title.includes('%')) {
+			try {
+				const encoded = /%(?!5[bd]|7[b-d])[\da-f]{2}/iu.test(title);
+				title = decodeURIComponent(title);
+				this.encoded = encoded;
+			} catch {}
+		}
+		title = title.replaceAll('_', ' ').trim();
+		if (title[0] === ':') {
+			namespace = '';
+			title = title.slice(1).trim();
+		}
+		const iw = defaultNs ? undefined : Parser.isInterwiki(title, config);
+		if (iw) {
+			this.interwiki = iw[1].toLowerCase();
+			title = title.slice(iw[0].length);
+		}
+		const m = title.split(':');
+		if (m.length > 1) {
+			const id = namespaces[nsid[m[0].trim().toLowerCase()]];
+			if (id !== undefined) {
+				namespace = id;
+				title = m.slice(1).join(':').trim();
+			}
+		}
+		this.ns = nsid[namespace.toLowerCase()];
+		const i = title.indexOf('#');
+		let fragment = '';
+		if (i !== -1) {
+			fragment = title.slice(i + 1).trimEnd();
+			title = title.slice(0, i).trim();
+		}
+		this.valid = Boolean(title || selfLink && fragment || this.interwiki)
+			&& !/\0\d+[eh!+-]\x7F|[<>[\]{}|]|%[\da-f]{2}/iu.test(title);
+		this.fragment = fragment;
+	}
+}
+
+module.exports = Title;

package/mixin/hidden.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * 解析后不可见的类
+ * @template T
+ * @param {T} Constructor 基类
+ * @returns {T}
+ */
+const hidden = Constructor => class extends Constructor {
+	static hidden = true;
+
+	/** 没有可见部分 */
+	text() { // eslint-disable-line class-methods-use-this
+		return '';
+	}
+};
+
+module.exports = hidden;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wikiparser-node",
-  "version": "0.7.1-b",
+  "version": "0.8.0-m",
   "description": "A Node.js parser for MediaWiki markup with AST",
   "keywords": [
     "mediawiki",
@@ -14,29 +14,27 @@
   "license": "GPL-3.0",
   "author": "Bhsd",
   "files": [
-    "/bundle/bundle.min.js",
-    "/extensions/",
-    "!/extensions/gh-page.*",
-    "!/extensions/.eslintrc.json"
+    "/index.js",
+    "/parser/",
+    "/util/",
+    "/lib/",
+    "/src/",
+    "/config/",
+    "/mixin/"
   ],
-  "browser": "/bundle/bundle.min.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bhsd-harry/wikiparser-node.git"
   },
   "scripts": {
-    "test": "rm bundle/*.js; webpack && eslint .",
+    "test": "eslint .",
     "real": "node test/real.js",
     "single": "node test/single.js"
   },
   "devDependencies": {
     "@types/node": "^17.0.23",
-    "webpack-cli": "^4.10.0",
-    "webpack": "^5.73.0",
-    "esbuild-loader": "^2.20.0",
     "eslint": "^8.30.0",
     "eslint-plugin-n": "^15.6.0",
-    "eslint-plugin-es-x": "^5.4.0",
     "eslint-plugin-regexp": "^1.11.0",
     "eslint-plugin-unicorn": "^45.0.2",
     "eslint-plugin-jsdoc": "^1.0.0",