wikiparser-node 0.0.0

package/src/link/file.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const {explode} = require('../../util/string'),
+	{typeError, externalUse} = require('../../util/debug'),
+	/** @type {Parser} */ Parser = require('../..'),
+	LinkToken = require('.'),
+	ImageParameterToken = require('../imageParameter');
+
+/**
+ * 图片
+ * @classdesc `{childNodes: [AtomToken, ...ImageParameterToken]}`
+ */
+class FileToken extends LinkToken {
+	type = 'file';
+	/** @type {Set<string>} */ #keys = new Set();
+	/** @type {Record<string, Set<ImageParameterToken>>} */ #args = {};
+
+	setFragment = undefined;
+	asSelfLink = undefined;
+	setLinkText = undefined;
+	pipeTrick = undefined;
+
+	/**
+	 * @param {string} link
+	 * @param {string|undefined} text
+	 * @param {Title} title
+	 * @param {accum} accum
+	 * @complexity `n`
+	 */
+	constructor(link, text, title, config = Parser.getConfig(), accum = []) {
+		super(link, undefined, title, config, accum);
+		this.setAttribute('acceptable', {AtomToken: 0, ImageParameterToken: '1:'});
+		this.append(...explode('-{', '}-', '|', text).map(part => new ImageParameterToken(part, config, accum)));
+		this.seal(['setFragment', 'asSelfLink', 'setLinkText', 'pipeTrick']);
+	}
+
+	/**
+	 * @param {number} i
+	 * @complexity `n`
+	 */
+	removeAt(i) {
+		const /** @type {ImageParameterToken} */ token = super.removeAt(i),
+			args = this.getArgs(token.name, false, false);
+		args.delete(token);
+		if (args.size === 0) {
+			this.#keys.delete(token.name);
+		}
+		return token;
+	}
+
+	/**
+	 * @param {ImageParameterToken} token
+	 * @complexity `n`
+	 */
+	insertAt(token, i = this.childElementCount) {
+		if (!Parser.running) {
+			this.getArgs(token.name, false, false).add(token);
+			this.#keys.add(token.name);
+		}
+		return super.insertAt(token, i);
+	}
+
+	/** @returns {ImageParameterToken[]} */
+	getAllArgs() {
+		return this.childNodes.slice(1);
+	}
+
+	/** @complexity `n` */
+	getFrameArgs() {
+		const args = this.getAllArgs()
+			.filter(({name}) => ['manualthumb', 'frameless', 'framed', 'thumbnail'].includes(name));
+		if (args.length > 1) {
+			Parser.error(`警告：图片 ${this.name} 带有 ${args.length} 个框架参数，只有第 1 个 ${args[0].name} 会生效！`);
+		}
+		return args;
+	}
+
+	/**
+	 * @param {string} key
+	 * @complexity `n`
+	 */
+	getArgs(key, copy = true) {
+		if (typeof key !== 'string') {
+			typeError(this, 'getArgs', 'String');
+		} else if (!copy && !Parser.debugging && externalUse('getArgs')) {
+			this.debugOnly('getArgs');
+		}
+		let args = this.#args[key];
+		if (!args) {
+			args = new Set(this.getAllArgs().filter(({name}) => key === name));
+			this.#args[key] = args;
+		}
+		return copy ? new Set(args) : args;
+	}
+
+	/**
+	 * @param {string} key
+	 * @complexity `n`
+	 */
+	hasArg(key) {
+		return this.getArgs(key, false).size > 0;
+	}
+
+	/**
+	 * @param {string} key
+	 * @complexity `n`
+	 */
+	getArg(key) {
+		return [...this.getArgs(key, false)].sort((a, b) => a.comparePosition(b)).at(-1);
+	}
+
+	/**
+	 * @param {string} key
+	 * @complexity `n`
+	 */
+	removeArg(key) {
+		for (const token of this.getArgs(key, false)) {
+			this.removeChild(token);
+		}
+	}
+
+	/** @complexity `n` */
+	getKeys() {
+		const args = this.getAllArgs();
+		if (this.#keys.size === 0 && args.length) {
+			for (const {name} of args) {
+				this.#keys.add(name);
+			}
+		}
+		return [...this.#keys];
+	}
+
+	/**
+	 * @param {string} key
+	 * @complexity `n`
+	 */
+	getValues(key) {
+		return [...this.getArgs(key, false)].map(token => token.getValue());
+	}
+
+	/**
+	 * @template {string|undefined} T
+	 * @param {T} key
+	 * @returns {T extends undefined ? Object<string, string> : string|true}
+	 * @complexity `n`
+	 */
+	getValue(key) {
+		if (key !== undefined) {
+			return this.getArg(key)?.getValue();
+		}
+		return Object.fromEntries(this.getKeys().map(k => [k, this.getValue(k)]));
+	}
+
+	/**
+	 * @param {string} key
+	 * @param {string|boolean} value
+	 * @complexity `n`
+	 */
+	setValue(key, value) {
+		if (typeof key !== 'string') {
+			typeError(this, 'setValue', 'String');
+		} else if (value === false) {
+			this.removeArg(key);
+			return;
+		}
+		const token = this.getArg(key);
+		value = value === true ? value : String(value);
+		if (token) {
+			token.setValue(value);
+			return;
+		}
+		let syntax = '';
+		const config = this.getAttribute('config');
+		if (key !== 'caption') {
+			syntax = Object.entries(config.img).find(([, name]) => name === key)?.[0];
+			if (!syntax) {
+				throw new RangeError(`未定义的图片参数： ${key}`);
+			}
+		}
+		if (value === true) {
+			if (syntax.includes('$1')) {
+				typeError(this, 'setValue', 'Boolean');
+			}
+			const newArg = Parser.run(() => new ImageParameterToken(syntax, config));
+			this.appendChild(newArg);
+			return;
+		}
+		const wikitext = `[[File:F|${syntax ? syntax.replace('$1', value) : value}]]`,
+			root = Parser.parse(wikitext, this.getAttribute('include'), 6, config),
+			{childNodes: {length}, firstElementChild} = root;
+		if (length !== 1 || !firstElementChild?.matches('file#File:F')
+			|| firstElementChild.childElementCount !== 2 || firstElementChild.lastElementChild.name !== key
+		) {
+			throw new SyntaxError(`非法的 ${key} 参数：${value.replaceAll('\n', '\\n')}`);
+		}
+		this.appendChild(firstElementChild.lastChild);
+	}
+}
+
+Parser.classes.FileToken = __filename;
+module.exports = FileToken;

package/src/link/index.js

@@ -0,0 +1,214 @@
+'use strict';
+
+const Title = require('../../lib/title'), // eslint-disable-line no-unused-vars
+	{text} = require('../../util/string'),
+	{undo} = require('../../util/debug'),
+	/** @type {Parser} */ Parser = require('../..'),
+	Token = require('..');
+
+/**
+ * 内链
+ * @classdesc `{childNodes: [AtomToken, ?Token]}`
+ */
+class LinkToken extends Token {
+	type = 'link';
+	selfLink;
+	fragment;
+	interwiki;
+
+	/**
+	 * @param {string} link
+	 * @param {string|undefined} linkText
+	 * @param {Title} title
+	 * @param {accum} accum
+	 */
+	constructor(link, linkText, title, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {AtomToken: 0, Token: 1});
+		const AtomToken = require('../atom');
+		this.appendChild(new AtomToken(link, 'link-target', config, accum, {
+			'Stage-2': ':', '!ExtToken': '', '!HeadingToken': '',
+		}));
+		if (linkText !== undefined) {
+			const inner = new Token(linkText, config, true, accum);
+			inner.type = 'link-text';
+			this.appendChild(inner.setAttribute('stage', 7));
+		}
+		this.selfLink = !title.title;
+		this.fragment = title.fragment;
+		this.interwiki = title.interwiki;
+		this.setAttribute('name', title.title).seal(['selfLink', 'fragment', 'interwiki']).protectChildren(0);
+	}
+
+	cloneNode() {
+		const [link, ...linkText] = this.cloneChildren();
+		return Parser.run(() => {
+			const /** @type {typeof LinkToken} */ Constructor = this.constructor,
+				token = new Constructor('', undefined, {
+					title: this.name, interwiki: this.interwiki, fragment: this.fragment,
+				}, this.getAttribute('config'));
+			token.firstElementChild.safeReplaceWith(link);
+			token.appendChild(...linkText);
+			return token.afterBuild();
+		});
+	}
+
+	afterBuild() {
+		if (this.name.includes('\x00')) {
+			this.setAttribute('name', text(this.buildFromStr(this.name)));
+		}
+		if (this.fragment.includes('\x00')) {
+			this.setAttribute('fragment', text(this.buildFromStr(this.fragment)));
+		}
+		const that = this;
+		const /** @type {AstListener} */ linkListener = (e, data) => {
+			const {prevTarget} = e;
+			if (prevTarget?.type === 'link-target') {
+				const name = prevTarget.text(),
+					{title, interwiki, fragment, ns, valid} = that.normalizeTitle(name);
+				if (!valid) {
+					undo(e, data);
+					throw new Error(`非法的内链目标：${name}`);
+				} else if (that.type === 'category' && (interwiki || ns !== 14)
+					|| that.type === 'file' && (interwiki || ns !== 6)
+				) {
+					undo(e, data);
+					throw new Error(`${that.type === 'file' ? '文件' : '分类'}链接不可更改命名空间：${name}`);
+				} else if (that.type === 'link' && !interwiki && [6, 14].includes(ns) && !name.trim().startsWith(':')) {
+					const {firstChild} = prevTarget;
+					if (typeof firstChild === 'string') {
+						prevTarget.setText(`:${firstChild}`);
+					} else {
+						prevTarget.prepend(':');
+					}
+				}
+				that.setAttribute('selfLink', !title).setAttribute('interwiki', interwiki)
+					.setAttribute('name', title).setAttribute('fragment', fragment);
+			}
+		};
+		this.addEventListener(['remove', 'insert', 'replace', 'text'], linkListener);
+		return this;
+	}
+
+	toString() {
+		return `[[${super.toString('|')}]]`;
+	}
+
+	getPadding() {
+		return 2;
+	}
+
+	getGaps() {
+		return 1;
+	}
+
+	text() {
+		return `[[${super.text('|')}]]`;
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return this.childElementCount === 1 ? [] : this.lastElementChild.plain();
+	}
+
+	/** @param {string} link */
+	setTarget(link) {
+		link = String(link);
+		if (!/^\s*[:#]/.test(link)) {
+			link = `:${link}`;
+		}
+		const root = Parser.parse(`[[${link}]]`, this.getAttribute('include'), 6, this.getAttribute('config')),
+			{childNodes: {length}, firstElementChild} = root;
+		if (length !== 1 || firstElementChild?.type !== this.type || firstElementChild.childElementCount !== 1) {
+			const msgs = {link: '内链', file: '文件链接', category: '分类'};
+			throw new SyntaxError(`非法的${msgs[this.type]}目标：${link}`);
+		}
+		const {firstChild} = firstElementChild;
+		root.destroy();
+		firstElementChild.destroy();
+		this.firstElementChild.safeReplaceWith(firstChild);
+	}
+
+	/** @param {string} fragment */
+	#setFragment(fragment, page = true) {
+		fragment = String(fragment).replace(/[<>[]#|=!]/g, p => encodeURIComponent(p));
+		const include = this.getAttribute('include'),
+			config = this.getAttribute('config'),
+			root = Parser.parse(`[[${page ? `:${this.name}` : ''}#${fragment}]]`, include, 6, config),
+			{childNodes: {length}, firstElementChild} = root;
+		if (length !== 1 || firstElementChild?.type !== 'link' || firstElementChild.childElementCount !== 1) {
+			throw new SyntaxError(`非法的 fragment：${fragment}`);
+		}
+		if (page) {
+			Parser.warn(`${this.constructor.name}.setFragment 方法会同时规范化页面名！`);
+		}
+		const {firstChild} = firstElementChild;
+		root.destroy();
+		firstElementChild.destroy();
+		this.firstElementChild.safeReplaceWith(firstChild);
+	}
+
+	/** @param {string} fragment */
+	setFragment(fragment) {
+		this.#setFragment(fragment);
+	}
+
+	asSelfLink(fragment = this.fragment) {
+		fragment = String(fragment);
+		if (!fragment.trim()) {
+			throw new RangeError(`${this.constructor.name}.asSelfLink 方法必须指定非空的 fragment！`);
+		}
+		this.#setFragment(fragment, false);
+	}
+
+	setLinkText(linkText = '') {
+		linkText = String(linkText);
+		let lastElementChild;
+		const config = this.getAttribute('config');
+		if (linkText) {
+			const root = Parser.parse(`[[${
+					this.type === 'category' ? 'Category:' : ''
+				}L|${linkText}]]`, this.getAttribute('include'), 6, config),
+				{childNodes: {length}, firstElementChild} = root;
+			if (length !== 1 || firstElementChild?.type !== this.type || firstElementChild.childElementCount !== 2) {
+				throw new SyntaxError(`非法的${this.type === 'link' ? '内链文字' : '分类关键字'}：${
+					linkText.replaceAll('\n', '\\n')
+				}`);
+			}
+			({lastElementChild} = firstElementChild);
+		} else {
+			lastElementChild = Parser.run(() => new Token('', config));
+			lastElementChild.setAttribute('stage', 7).type = 'link-text';
+		}
+		if (this.childElementCount === 1) {
+			this.appendChild(lastElementChild);
+		} else {
+			this.lastElementChild.safeReplaceWith(lastElementChild);
+		}
+	}
+
+	pipeTrick() {
+		const linkText = this.firstElementChild.text();
+		if (/[#%]/.test(linkText)) {
+			throw new Error('Pipe trick 不能用于带有"#"或"%"的场合！');
+		}
+		const m1 = linkText.match(/^:?(?:[ \w\x80-\xff-]+:)?(.+?) ?\(.+\)$/);
+		if (m1) {
+			this.setLinkText(m1[1]);
+			return;
+		}
+		const m2 = linkText.match(/^:?(?:[ \w\x80-\xff-]+:)?(.+?) ?（.+）$/);
+		if (m2) {
+			this.setLinkText(m2[1]);
+			return;
+		}
+		const m3 = linkText.match(/^:?(?:[ \w\x80-\xff-]+:)?(.+?)(?: ?\(.+\))?(?:, |，|، ).+/);
+		if (m3) {
+			this.setLinkText(m3[1]);
+			return;
+		}
+		this.setLinkText(linkText);
+	}
+}
+
+Parser.classes.LinkToken = __filename;
+module.exports = LinkToken;

package/src/listToken.js

@@ -0,0 +1,47 @@
+'use strict';
+const Token = require('.'),
+	AtomToken = require('./atom'),
+	{fixToken} = require('./util');
+
+class ListToken extends fixToken(Token) {
+	type = 'list';
+
+	/**
+	 * @param {string} syntax
+	 * @param {?string|number|Token|(string|Token)[]} content
+	 * @param {Object<string, any>} config
+	 * @param {Token} parent
+	 * @param {Token[]} accum
+	 */
+	constructor(syntax, content, config = require(Token.config), parent = null, accum = [], isTable = false) {
+		if (/[^:;#*]/.test(syntax)) {
+			throw new RangeError('List语法只接受":"、";"、"#"或"*"！');
+		}
+		super(new AtomToken(syntax, 'list-syntax'), config, true, parent, accum, ['AtomToken', 'Token']);
+		const inner = new Token(content, config, true, this, accum);
+		inner.type = 'list-inner';
+		inner.set('stage', isTable ? 4 : 10);
+		this.lists = new Set(syntax.split(''));
+		this.seal();
+	}
+
+	isDt() {
+		return this.$children[0].contains(';');
+	}
+
+	idDd() {
+		return this.$children[0].contains(':');
+	}
+
+	isOl() {
+		return this.$children[0].contains('#');
+	}
+
+	isUl() {
+		return this.$children[0].contains('*');
+	}
+}
+
+Token.classes.ListToken = ListToken;
+
+module.exports = ListToken;

package/src/magicLink.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const {typeError} = require('../util/debug'),
+	/** @type {Parser} */ Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 自由外链
+ * @classdesc `{childNodes: [...string|CommentToken|IncludeToken|NoincludeToken]}`
+ */
+class MagicLinkToken extends Token {
+	type = 'free-ext-link';
+	#protocolRegex;
+
+	get protocol() {
+		return this.text().match(this.#protocolRegex)?.[0];
+	}
+	/** @param {string} value */
+	set protocol(value) {
+		if (typeof value !== 'string') {
+			typeError(this, 'protocol', 'String');
+		}
+		if (!new RegExp(`${this.#protocolRegex.source}$`, 'i').test(value)) {
+			throw new RangeError(`非法的外链协议：${value}`);
+		}
+		this.replaceChildren(this.text().replace(this.#protocolRegex, value));
+	}
+
+	/**
+	 * @param {string} url
+	 * @param {accum} accum
+	 */
+	constructor(url, doubleSlash = false, config = Parser.getConfig(), accum = []) {
+		super(url, config, true, accum, {'Stage-1': ':', '!ExtToken': ''});
+		if (doubleSlash) {
+			this.type = 'ext-link-url';
+		}
+		this.#protocolRegex = new RegExp(`^(?:${config.protocol}${doubleSlash ? '|//' : ''})`, 'i');
+	}
+
+	getUrl() {
+		const url = this.text();
+		try {
+			return new URL(url);
+		} catch (e) {
+			if (e instanceof TypeError && e.message === 'Invalid URL') {
+				throw new Error(`非标准协议的外部链接：${url}`);
+			}
+			throw e;
+		}
+	}
+
+	/** @param {string|URL} url */
+	setTarget(url) {
+		url = String(url);
+		const root = Parser.parse(url, this.getAttribute('include'), 9, this.getAttribute('config')),
+			{childNodes: {length}, firstElementChild} = root;
+		if (length !== 1 || firstElementChild?.type !== 'free-ext-link') {
+			throw new SyntaxError(`非法的自由外链目标：${url}`);
+		}
+		this.replaceChildren(...firstElementChild.childNodes);
+	}
+}
+
+Parser.classes.MagicLinkToken = __filename;
+module.exports = MagicLinkToken;

package/src/nowiki/comment.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const hidden = require('../../mixin/hidden'),
+	/** @type {Parser} */ Parser = require('../..'),
+	NowikiToken = require('.');
+
+/**
+ * HTML注释，不可见
+ * @classdesc `{childNodes: [string]}`
+ */
+class CommentToken extends hidden(NowikiToken) {
+	type = 'comment';
+	closed;
+
+	/**
+	 * @param {string} wikitext
+	 * @param {accum} accum
+	 */
+	constructor(wikitext, closed = true, config = Parser.getConfig(), accum = []) {
+		super(wikitext, config, accum);
+		this.closed = closed;
+	}
+
+	/** @this {CommentToken & {firstChild: string}} */
+	cloneNode() {
+		return Parser.run(() => new CommentToken(this.firstChild, this.closed, this.getAttribute('config')));
+	}
+
+	/** @this {CommentToken & {firstChild: string}} */
+	toString() {
+		const {firstChild, closed, nextSibling} = this;
+		if (!closed && nextSibling) {
+			Parser.error('自动闭合HTML注释', firstChild.replaceAll('\n', '\\n'));
+			this.closed = true;
+		}
+		return `<!--${firstChild}${this.closed ? '-->' : ''}`;
+	}
+
+	getPadding() {
+		return 4;
+	}
+}
+
+Parser.classes.CommentToken = __filename;
+module.exports = CommentToken;

package/src/nowiki/doubleUnderscore.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const hidden = require('../../mixin/hidden'),
+	/** @type {Parser} */ Parser = require('../..'),
+	NowikiToken = require('.');
+
+/**
+ * 状态开关
+ * @classdesc `{childNodes: [string]}`
+ */
+class DoubleUnderscoreToken extends hidden(NowikiToken) {
+	type = 'double-underscore';
+
+	/**
+	 * @param {string} word
+	 * @param {accum} accum
+	 */
+	constructor(word, config = Parser.getConfig(), accum = []) {
+		super(word, config, accum);
+		this.setAttribute('name', word.toLowerCase());
+	}
+
+	cloneNode() {
+		return Parser.run(() => new DoubleUnderscoreToken(this.firstChild, this.getAttribute('config')));
+	}
+
+	/** @this {DoubleUnderscoreToken & {firstChild: string}} */
+	toString() {
+		return `__${this.firstChild}__`;
+	}
+
+	getPadding() {
+		return 2;
+	}
+
+	setText() {
+		throw new Error(`禁止修改 ${this.constructor.name}！`);
+	}
+}
+
+Parser.classes.DoubleUnderscoreToken = __filename;
+module.exports = DoubleUnderscoreToken;

package/src/nowiki/hr.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('../..'),
+	NowikiToken = require('.');
+
+/**
+ * `<hr>`
+ * @classdesc `{childNodes: [string]}`
+ */
+class HrToken extends NowikiToken {
+	type = 'hr';
+
+	/**
+	 * @param {number} n
+	 * @param {accum} accum
+	 */
+	constructor(n, config = Parser.getConfig(), accum = []) {
+		super('-'.repeat(n), config, accum);
+	}
+
+	/** @this {HrToken & {firstChild: string}} */
+	cloneNode() {
+		return Parser.run(() => new HrToken(this.firstChild.length, this.getAttribute('config')));
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return [];
+	}
+
+	/** @param {string} str */
+	setText(str) {
+		if (!/^-{4,}$/.test(str)) {
+			throw new RangeError('<hr>总是写作不少于4个的连续"-"！');
+		}
+		return super.setText(str);
+	}
+}
+
+Parser.classes.HrToken = __filename;
+module.exports = HrToken;

package/src/nowiki/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const fixedToken = require('../../mixin/fixedToken'),
+	/** @type {Parser} */ Parser = require('../..'),
+	Token = require('..');
+
+/**
+ * 纯文字Token，不会被解析
+ * @classdesc `{childNodes: [string]}`
+ */
+class NowikiToken extends fixedToken(Token) {
+	type = 'ext-inner';
+
+	/**
+	 * @param {string} wikitext
+	 * @param {accum} accum
+	 */
+	constructor(wikitext, config = Parser.getConfig(), accum = []) {
+		super(wikitext, config, false, accum);
+	}
+
+	/** @this {NowikiToken & {firstChild: string}} */
+	cloneNode() {
+		const /** @type {typeof NowikiToken} */ Constructor = this.constructor,
+			token = Parser.run(() => new Constructor(this.firstChild, this.getAttribute('config')));
+		token.type = this.type;
+		return token;
+	}
+
+	/** @param {string} str */
+	setText(str) {
+		return super.setText(str, 0);
+	}
+}
+
+Parser.classes.NowikiToken = __filename;
+module.exports = NowikiToken;