wikiparser-node 0.0.0

package/lib/node.js

@@ -0,0 +1,357 @@
+'use strict';
+
+const {typeError, externalUse} = require('../util/debug'),
+	{text} = require('../util/string'),
+	assert = require('assert/strict'),
+	/** @type {Parser} */ Parser = require('..');
+
+class AstNode {
+	/** @type {(string|this)[]} */ childNodes = [];
+	/** @type {this} */ #parentNode;
+	/** @type {string[]} */ #optional = [];
+
+	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?.indexOf(this) + 1];
+	}
+	/** @complexity `n` */
+	get previousSibling() {
+		const childNodes = this.#parentNode?.childNodes;
+		return childNodes?.[childNodes?.indexOf(this) - 1];
+	}
+
+	debugOnly(method = 'debugOnly') {
+		throw new Error(`${this.constructor.name}.${method} 方法仅用于代码调试！`);
+	}
+
+	/** @param {string|string[]} keys */
+	seal(keys) {
+		if (!Parser.running && !Parser.debugging) {
+			this.debugOnly('seal');
+		}
+		keys = Array.isArray(keys) ? keys : [keys];
+		this.#optional.push(...keys);
+		for (const key of keys) {
+			Object.defineProperty(this, key, {writable: false, enumerable: Boolean(this[key])});
+		}
+		return this;
+	}
+
+	constructor() {
+		Object.defineProperty(this, 'childNodes', {writable: false});
+		Object.freeze(this.childNodes);
+	}
+
+	/** @param {this} node */
+	isEqualNode(node) {
+		try {
+			assert.deepStrictEqual(this, node);
+		} catch (e) {
+			if (e instanceof assert.AssertionError) {
+				return false;
+			}
+			throw e;
+		}
+		return true;
+	}
+
+	/** @param {PropertyKey} key */
+	hasAttribute(key) {
+		if (!['string', 'number', 'symbol'].includes(typeof key)) {
+			typeError(this, 'hasAttribute', 'String', 'Number', 'Symbol');
+		}
+		return key in this;
+	}
+
+	/**
+	 * 除非用于私有属性，否则总是返回字符串
+	 * @template {string} T
+	 * @param {T} key
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		if (key === 'optional') {
+			return [...this.#optional];
+		}
+		return this.hasAttribute(key) ? String(this[key]) : undefined;
+	}
+
+	getAttributeNames() {
+		const names = Object.getOwnPropertyNames(this);
+		return names.filter(name => typeof this[name] !== 'function');
+	}
+
+	hasAttributes() {
+		return this.getAttributeNames().length > 0;
+	}
+
+	/**
+	 * @template {string} T
+	 * @param {T} key
+	 * @param {TokenAttribute<T>} value
+	 */
+	setAttribute(key, value) {
+		if (key === 'parentNode') {
+			if (externalUse('setAttribute')) {
+				throw new RangeError(`禁止手动指定 ${key} 属性！`);
+			}
+			this.#parentNode = value;
+		} else if (this.hasAttribute(key)) {
+			const descriptor = Object.getOwnPropertyDescriptor(this, key);
+			if (!descriptor || !descriptor.writable && externalUse('setAttribute')) {
+				throw new RangeError(`禁止手动指定 ${key} 属性！`);
+			} else if (this.#optional.includes(key)) {
+				descriptor.enumerable = Boolean(value);
+			}
+			const oldValue = this[key],
+				frozen = oldValue !== null && typeof oldValue === 'object' && Object.isFrozen(oldValue);
+			Object.defineProperty(this, key, {...descriptor, value});
+			if (frozen && value !== null && typeof value === 'object') {
+				Object.freeze(value);
+			}
+		} else {
+			this[key] = value;
+		}
+		return this;
+	}
+
+	/** @param {PropertyKey} key */
+	removeAttribute(key) {
+		if (this.hasAttribute(key)) {
+			const descriptor = Object.getOwnPropertyDescriptor(this, key);
+			if (!descriptor || !descriptor.writable) {
+				throw new RangeError(`属性 ${key} 不可删除！`);
+			}
+			delete this[key];
+		}
+	}
+
+	/**
+	 * @param {PropertyKey} name
+	 * @param {boolean|undefined} force
+	 */
+	toggleAttribute(key, force) {
+		if (force !== undefined && typeof force !== 'boolean') {
+			typeError(this, 'toggleAttribute', 'Boolean');
+		} else if (this.hasAttribute(key) && typeof this[key] !== 'boolean') {
+			throw new RangeError(`${key} 属性的值不为 Boolean！`);
+		}
+		this.setAttribute(key, force === true || force === undefined && !this[key]);
+	}
+
+	/** @complexity `n` */
+	toString(separator = '') {
+		return this.childNodes.map(String).join(separator);
+	}
+
+	/**
+	 * 可见部分
+	 * @returns {string}
+	 * @complexity `n`
+	 */
+	text(separator = '') {
+		return text(this.childNodes, separator);
+	}
+
+	hasChildNodes() {
+		return this.childNodes.length > 0;
+	}
+
+	/**
+	 * 是自身或子孙节点
+	 * @param {this} node
+	 * @returns {boolean}
+	 * @complexity `n`
+	 */
+	contains(node) {
+		if (!(node instanceof AstNode)) {
+			typeError(this, 'contains', 'Token');
+		}
+		return node === this || this.childNodes.some(child => child instanceof AstNode && child.contains(node));
+	}
+
+	/** @param {number} i */
+	verifyChild(i, addition = 0) {
+		if (!Parser.debugging && externalUse('verifyChild')) {
+			this.debugOnly('verifyChild');
+		} else if (typeof i !== 'number') {
+			typeError(this, 'verifyChild', 'Number');
+		}
+		const {length} = this.childNodes;
+		if (i < -length || i >= length + addition || !Number.isInteger(i)) {
+			throw new RangeError(`不存在第 ${i} 个子节点！`);
+		}
+	}
+
+	/** @param {number} i */
+	removeAt(i) {
+		this.verifyChild(i);
+		const childNodes = [...this.childNodes],
+			[node] = childNodes.splice(i, 1);
+		if (node instanceof AstNode) {
+			node.setAttribute('parentNode');
+		}
+		this.setAttribute('childNodes', childNodes);
+		return node;
+	}
+
+	/**
+	 * @param {string|this} node
+	 * @complexity `n`
+	 */
+	#getChildIndex(node) {
+		const {childNodes} = this,
+			i = childNodes.indexOf(node);
+		if (i === -1) {
+			Parser.error('找不到子节点！', node);
+			throw new RangeError('找不到子节点！');
+		} else if (typeof node === 'string' && childNodes.lastIndexOf(node) > i) {
+			throw new RangeError(`重复的纯文本节点 ${node.replaceAll('\n', '\\n')}！`);
+		}
+		return i;
+	}
+
+	/**
+	 * @template {string|this} T
+	 * @param {T} node
+	 * @complexity `n`
+	 */
+	removeChild(node) {
+		this.removeAt(this.#getChildIndex(node));
+		return node;
+	}
+
+	/**
+	 * @template {string|this} T
+	 * @param {T} node
+	 * @complexity `n`
+	 */
+	insertAt(node, i = this.childNodes.length) {
+		if (typeof node !== 'string' && !(node instanceof AstNode)) {
+			typeError(this, 'insertAt', 'String', 'Token');
+		} else if (node instanceof AstNode && node.contains(this)) {
+			Parser.error('不能插入祖先节点！', node);
+			throw new RangeError('不能插入祖先节点！');
+		}
+		this.verifyChild(i, 1);
+		const childNodes = [...this.childNodes];
+		if (node instanceof AstNode) {
+			const j = Parser.running ? -1 : childNodes.indexOf(node);
+			if (j !== -1) {
+				childNodes.splice(j, 1);
+			} else {
+				node.parentNode?.removeChild(node);
+				node.setAttribute('parentNode', this);
+			}
+		}
+		childNodes.splice(i, 0, node);
+		this.setAttribute('childNodes', childNodes);
+		return node;
+	}
+
+	/**
+	 * @template {string|this} T
+	 * @param {T} node
+	 * @complexity `n`
+	 */
+	appendChild(node) {
+		return this.insertAt(node);
+	}
+
+	/**
+	 * @template {string|this} T
+	 * @param {T} child
+	 * @param {string|this} reference
+	 * @complexity `n`
+	 */
+	insertBefore(child, reference) {
+		if (reference === undefined) {
+			return this.appendChild(child);
+		}
+		return this.insertAt(child, this.#getChildIndex(reference));
+	}
+
+	/**
+	 * @template {string|this} T
+	 * @param {string|this} newChild
+	 * @param {T} oldChild
+	 * @complexity `n`
+	 */
+	replaceChild(newChild, oldChild) {
+		const i = this.#getChildIndex(oldChild);
+		this.removeAt(i);
+		this.insertAt(newChild, i);
+		return oldChild;
+	}
+
+	/** @param {string} str */
+	setText(str, i = 0) {
+		if (typeof str !== 'string') {
+			typeError(this, 'setText', 'String');
+		}
+		this.verifyChild(i);
+		const oldText = this.childNodes.at(i);
+		if (typeof oldText !== 'string') {
+			throw new RangeError(`第 ${i} 个子节点是 ${oldText.constructor.name}！`);
+		}
+		const childNodes = [...this.childNodes];
+		childNodes.splice(i, 1, str);
+		this.setAttribute('childNodes', childNodes);
+		return oldText;
+	}
+
+	/**
+	 * @param {number} i
+	 * @param {number} offset
+	 */
+	splitText(i, offset) {
+		if (typeof offset !== 'number') {
+			typeError(this, 'splitText', 'Number');
+		}
+		this.verifyChild(i);
+		const oldText = this.childNodes.at(i);
+		if (typeof oldText !== 'string') {
+			throw new RangeError(`第 ${i} 个子节点是 ${oldText.constructor.name}！`);
+		}
+		const newText = oldText.slice(offset);
+		this.insertAt(newText, i + 1);
+		this.setText(oldText.slice(0, offset), i);
+		return newText;
+	}
+
+	/** @complexity `n` */
+	normalize() {
+		const childNodes = [...this.childNodes];
+		for (let i = childNodes.length - 1; i >= 0; i--) {
+			const str = childNodes[i];
+			if (str === '') {
+				childNodes.splice(i, 1);
+			} else if (typeof str === 'string' && typeof childNodes[i - 1] === 'string') {
+				childNodes[i - 1] += str;
+				childNodes.splice(i, 1);
+			}
+		}
+		this.setAttribute('childNodes', childNodes);
+	}
+
+	getRootNode() {
+		let {parentNode} = this;
+		while (parentNode?.parentNode) {
+			({parentNode} = parentNode);
+		}
+		return parentNode ?? this;
+	}
+}
+
+Parser.classes.AstNode = __filename;
+module.exports = AstNode;

package/lib/ranges.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/** 模拟Python的Range对象。除`step`至少为`1`外，允许负数、小数或`end < start`的情形。 */
+class Range {
+	start;
+	end;
+	step;
+
+	/** @param {string|Range} str */
+	constructor(str) {
+		if (str instanceof Range) {
+			Object.assign(this, str);
+			return;
+		}
+		str = str.trim();
+		if (str === 'odd') {
+			Object.assign(this, {start: 1, end: Infinity, step: 2});
+		} else if (str === 'even') {
+			Object.assign(this, {start: 0, end: Infinity, step: 2});
+		} else if (str.includes(':')) {
+			const [start, end, step = '1'] = str.split(':', 3);
+			this.start = Number(start);
+			this.end = Number(end || Infinity);
+			this.step = Math.max(Number(step), 1);
+			if (!Number.isInteger(this.start)) {
+				throw new RangeError(`起点 ${this.start} 应为整数！`);
+			} else if (this.end !== Infinity && !Number.isInteger(this.end)) {
+				throw new RangeError(`终点 ${this.end} 应为整数！`);
+			} else if (!Number.isInteger(this.step)) {
+				throw new RangeError(`步长 ${this.step} 应为整数！`);
+			}
+		} else {
+			const mt = str.match(/^([+-])?(\d+)?n(?:([+-])(\d+))?$/);
+			if (mt) {
+				const [, sgnA = '+', a = 1, sgnB = '+'] = mt,
+					b = Number(mt[4] ?? 0);
+				this.step = Number(a);
+				if (this.step === 0) {
+					throw new RangeError(`参数 ${str} 中 "n" 的系数不允许为 0！`);
+				} else if (sgnA === '+') {
+					this.start = sgnB === '+' || b === 0 ? b : this.step - 1 - (b - 1) % this.step;
+					this.end = Infinity;
+				} else if (sgnB === '-') {
+					this.start = 0;
+					this.end = b > 0 ? 0 : this.step;
+				} else {
+					this.start = b % this.step;
+					this.end = this.step + b;
+				}
+			} else {
+				throw new RangeError(`参数 ${str} 应写作CSS选择器的 "an+b" 形式或Python切片！`);
+			}
+		}
+	}
+
+	/**
+	 * 将Range转换为针对特定Array的下标集
+	 * @param {number|any[]} arr
+	 * @complexity `n`
+	 */
+	applyTo(arr) {
+		return new Array(typeof arr === 'number' ? arr : arr.length).fill().map((_, i) => i)
+			.slice(this.start, this.end).filter((_, j) => j % this.step === 0);
+	}
+}
+
+/** @extends {Array<number|Range>} */
+class Ranges extends Array {
+	/** @param {number|string|Range|(number|string|Range)[]} arr */
+	constructor(arr) {
+		super();
+		if (arr === undefined) {
+			return;
+		}
+		arr = Array.isArray(arr) ? arr : [arr];
+		for (const ele of arr) {
+			if (ele instanceof Range) {
+				this.push(new Range(ele));
+				continue;
+			}
+			const number = Number(ele);
+			if (Number.isInteger(number)) {
+				this.push(number);
+			} else if (typeof ele === 'string' && Number.isNaN(number)) {
+				try {
+					const range = new Range(ele);
+					this.push(range);
+				} catch {}
+			}
+		}
+	}
+
+	/**
+	 * 将Ranges转换为针对特定Array的下标集
+	 * @param {number|any[]} arr
+	 * @complexity `n`
+	 */
+	applyTo(arr) {
+		const length = typeof arr === 'number' ? arr : arr.length;
+		return [...new Set(
+			Array.from(this).flatMap(ele => {
+				if (typeof ele === 'number') {
+					return ele < 0 ? ele + length : ele;
+				}
+				return ele.applyTo(length);
+			}),
+		)].filter(i => i >= 0 && i < length).sort();
+	}
+
+	/**
+	 * @param {string} str
+	 * @param {number} i
+	 */
+	static nth(str, i) {
+		return new Ranges(str.split(',')).applyTo(i + 1).includes(i);
+	}
+}
+
+Parser.classes.Ranges = __filename;
+module.exports = Ranges;

package/lib/title.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const {ucfirst} = require('../util/string'),
+	/** @type {Parser} */ Parser = require('..');
+
+class Title {
+	title = '';
+	ns = 0;
+	interwiki = '';
+	fragment = '';
+	valid = true;
+
+	/** @param {string} title */
+	constructor(title, defaultNs = 0, config = Parser.getConfig()) {
+		const {namespaces, nsid} = config;
+		let namespace = namespaces[defaultNs];
+		title = title.replaceAll('_', ' ').trim();
+		if (title[0] === ':') {
+			namespace = '';
+			title = title.slice(1).trim();
+		}
+		const iw = 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('#');
+		if (i !== -1) {
+			const fragment = title.slice(i + 1).trimEnd();
+			if (fragment.includes('%')) {
+				try {
+					this.fragment = decodeURIComponent(fragment);
+				} catch {}
+			} else if (fragment.includes('.')) {
+				try {
+					this.fragment = decodeURIComponent(fragment.replaceAll('.', '%'));
+				} catch {}
+			}
+			this.fragment ||= fragment;
+			title = title.slice(0, i).trim();
+		}
+		this.title = `${iw ? `${this.interwiki}:` : ''}${namespace}${namespace && ':'}${ucfirst(title)}`;
+		this.valid = !/\x00\d+[eh!+-]\x7f|[<>[\]{}|]/.test(this.title);
+	}
+}
+
+Parser.classes.Title = __filename;
+module.exports = Title;

package/mixin/attributeParent.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..'),
+	AttributeToken = require('../src/attribute'); // eslint-disable-line no-unused-vars
+
+/**
+ * @template T
+ * @param {T} constructor
+ * @returns {T}
+ */
+const attributeParent = (constructor, i = 0) => class extends constructor {
+	/**
+	 * @this {{children: AttributeToken[]}}
+	 * @param {string} key
+	 */
+	hasAttr(key) {
+		return this.children.at(i).hasAttr(key);
+	}
+
+	/**
+	 * @this {{children: AttributeToken[]}}
+	 * @template {string|undefined} T
+	 * @param {T} key
+	 */
+	getAttr(key) {
+		return this.children.at(i).getAttr(key);
+	}
+
+	/** @this {{children: AttributeToken[]}} */
+	getAttrNames() {
+		return this.children.at(i).getAttrNames();
+	}
+
+	/** @this {{children: AttributeToken[]}} */
+	hasAttrs() {
+		return this.children.at(i).hasAttrs();
+	}
+
+	/**
+	 * @this {{children: AttributeToken[]}}
+	 * @param {string} key
+	 * @param {string|boolean} value
+	 */
+	setAttr(key, value) {
+		return this.children.at(i).setAttr(key, value);
+	}
+
+	/**
+	 * @this {{children: AttributeToken[]}}
+	 * @param {string} key
+	 */
+	removeAttr(key) {
+		this.children.at(i).removeAttr(key);
+	}
+
+	/**
+	 * @this {{children: AttributeToken[]}}
+	 * @param {string} key
+	 * @param {boolean|undefined} force
+	 */
+	toggleAttr(key, force) {
+		this.children.at(i).toggleAttr(key, force);
+	}
+};
+
+Parser.mixins.attributeParent = __filename;
+module.exports = attributeParent;

package/mixin/fixedToken.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * @template T
+ * @param {T} constructor
+ * @returns {T}
+ */
+const fixedToken = constructor => class extends constructor {
+	static fixed = true;
+
+	removeAt() {
+		throw new Error(`${this.constructor.name} 不可删除元素！`);
+	}
+
+	/**
+	 * @template {string|Token} T
+	 * @param {T} token
+	 * @param {number} i
+	 */
+	insertAt(token, i = this.childNodes.length) {
+		if (!Parser.running) {
+			throw new Error(`${this.constructor.name} 不可插入元素！`);
+		}
+		super.insertAt(token, i);
+		return token;
+	}
+};
+
+Parser.mixins.fixedToken = __filename;
+module.exports = fixedToken;

package/mixin/hidden.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..');
+
+/**
+ * @template T
+ * @param {T} constructor
+ * @returns {T}
+ */
+const hidden = constructor => class extends constructor {
+	text() {
+		return '';
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return [];
+	}
+};
+
+Parser.mixins.hidden = __filename;
+module.exports = hidden;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "wikiparser-node",
+  "version": "0.0.0",
+  "description": "A Node.js parser for MediaWiki markup with AST",
+  "keywords": [
+    "mediawiki",
+    "wikitext",
+    "parser"
+  ],
+  "homepage": "https://github.com/bhsd-harry/wikiparser-node#readme",
+  "bugs": {
+    "url": "https://github.com/bhsd-harry/wikiparser-node/issues"
+  },
+  "license": "GPL-3.0",
+  "author": "Bhsd",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bhsd-harry/wikiparser-node.git"
+  },
+  "scripts": {
+    "test": "echo 'Error: no test specified' && exit 1"
+  },
+  "devDependencies": {
+    "eslint": "^8.8.0",
+    "@types/node": "^17.0.23"
+  },
+  "engines": {
+    "node": "^18.4.0"
+  }
+}