wikiparser-node 0.0.0

package/src/heading.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const {typeError} = require('../util/debug'),
+	fixedToken = require('../mixin/fixedToken'),
+	/** @type {Parser} */ Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 章节标题
+ * @classdesc `{childNodes: [Token, HiddenToken]}`
+ */
+class HeadingToken extends fixedToken(Token) {
+	type = 'heading';
+
+	/**
+	 * @param {number} level
+	 * @param {string[]} input
+	 * @param {accum} accum
+	 */
+	constructor(level, input, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum);
+		this.setAttribute('name', String(level));
+		const token = new Token(input[0], config, true, accum);
+		token.type = 'heading-title';
+		token.setAttribute('name', this.name).setAttribute('stage', 2);
+		const SyntaxToken = require('./syntax'),
+			trail = new SyntaxToken(input[1], /^[^\S\n]*$/, 'heading-trail', config, accum, {
+				'Stage-1': ':', '!ExtToken': '',
+			});
+		this.append(token, trail);
+	}
+
+	cloneNode() {
+		const [title, trail] = this.cloneChildren(),
+			token = Parser.run(() => new HeadingToken(Number(this.name), [], this.getAttribute('config')));
+		token.firstElementChild.safeReplaceWith(title);
+		token.lastElementChild.safeReplaceWith(trail);
+		return token;
+	}
+
+	toString() {
+		const equals = '='.repeat(Number(this.name)),
+			{previousVisibleSibling, nextVisibleSibling} = this;
+		return `${
+			typeof previousVisibleSibling === 'string' && !previousVisibleSibling.endsWith('\n')
+			|| previousVisibleSibling instanceof Token
+				? '\n'
+				: ''
+		}${equals}${super.toString(equals)}${
+			typeof nextVisibleSibling === 'string' && !nextVisibleSibling.startsWith('\n')
+			|| nextVisibleSibling instanceof Token
+				? '\n'
+				: ''
+		}`;
+	}
+
+	getPadding() {
+		return Number(this.name);
+	}
+
+	getGaps() {
+		return Number(this.name);
+	}
+
+	/** @returns {string} */
+	text() {
+		const equals = '='.repeat(Number(this.name));
+		return `${equals}${this.firstElementChild.text()}${equals}`;
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return this.firstElementChild.plain();
+	}
+
+	/** @param {number} n */
+	setLevel(n) {
+		if (typeof n !== 'number') {
+			typeError(this, 'setLevel', 'Number');
+		}
+		n = Math.min(Math.max(n, 1), 6);
+		this.setAttribute('name', String(n)).firstElementChild.setAttribute('name', this.name);
+	}
+
+	removeTrail() {
+		this.lastElementChild.replaceChildren();
+	}
+}
+
+Parser.classes.HeadingToken = __filename;
+module.exports = HeadingToken;

package/src/html.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const fixedToken = require('../mixin/fixedToken'),
+	attributeParent = require('../mixin/attributeParent'),
+	/** @type {Parser} */ Parser = require('..'),
+	Token = require('.');
+
+/**
+ * HTML标签
+ * @classdesc `{childNodes: [AttributeToken]}`
+ */
+class HtmlToken extends attributeParent(fixedToken(Token)) {
+	type = 'html';
+	closing;
+	selfClosing;
+	#tag;
+
+	/**
+	 * @param {string} name
+	 * @param {AttributeToken} attr
+	 * @param {boolean} closing
+	 * @param {boolean} selfClosing
+	 * @param {accum} accum
+	 */
+	constructor(name, attr, closing, selfClosing, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum);
+		this.appendChild(attr);
+		this.setAttribute('name', name.toLowerCase());
+		this.closing = closing;
+		this.selfClosing = selfClosing;
+		this.#tag = name;
+	}
+
+	cloneNode() {
+		const [attr] = this.cloneChildren(),
+			config = this.getAttribute('config');
+		return Parser.run(() => new HtmlToken(this.#tag, attr, this.closing, this.selfClosing, config));
+	}
+
+	/**
+	 * @template {string} T
+	 * @param {T} key
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		if (key === 'tag') {
+			return this.#tag;
+		}
+		return super.getAttribute(key);
+	}
+
+	toString() {
+		return `<${this.closing ? '/' : ''}${this.#tag}${super.toString()}${this.selfClosing ? '/' : ''}>`;
+	}
+
+	getPadding() {
+		return this.#tag.length + (this.closing ? 2 : 1);
+	}
+
+	text() {
+		return `<${this.closing ? '/' : ''}${this.#tag}${super.text()}${this.selfClosing ? '/' : ''}>`;
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return [];
+	}
+
+	/** @param {string} tag */
+	replaceTag(tag) {
+		const name = tag.toLowerCase();
+		if (!this.getAttribute('config').html.flat().includes(name)) {
+			throw new RangeError(`非法的HTML标签：${tag}`);
+		}
+		this.setAttribute('name', name).#tag = tag;
+	}
+
+	/** @complexity `n` */
+	findMatchingTag() {
+		const {html} = this.getAttribute('config'),
+			{name, parentElement, closing, selfClosing} = this,
+			string = this.toString().replaceAll('\n', '\\n');
+		if (closing && selfClosing) {
+			throw new SyntaxError(`同时闭合和自封闭的标签：${string}`);
+		} else if (html[2].includes(name) || selfClosing && html[1].includes(name)) { // 自封闭标签
+			return this;
+		} else if (selfClosing && html[0].includes(name)) {
+			throw new SyntaxError(`无效自封闭标签：${string}`);
+		} else if (!parentElement) {
+			return;
+		}
+		const {children} = parentElement,
+			i = children.indexOf(this),
+			selector = `html#${name}`,
+			siblings = closing
+				? children.slice(0, i).reverse().filter(child => child.matches(selector))
+				: children.slice(i + 1).filter(child => child.matches(selector));
+		let imbalance = closing ? -1 : 1;
+		for (const token of siblings) {
+			if (token.closing) {
+				imbalance--;
+			} else {
+				imbalance++;
+			}
+			if (imbalance === 0) {
+				return token;
+			}
+		}
+		throw new SyntaxError(`未${closing ? '匹配的闭合' : '闭合的'}标签：${string}`);
+	}
+
+	#localMatch() {
+		this.selfClosing = false;
+		const root = Parser.parse(`</${this.name}>`, false, 3, this.getAttribute('config'));
+		this.after(root.firstChild);
+	}
+
+	/** @complexity `n` */
+	fix() {
+		const config = this.getAttribute('config'),
+			{parentElement, selfClosing, name, firstElementChild} = this;
+		if (!parentElement || !selfClosing || !config.html[0].includes(name)) {
+			return;
+		} else if (firstElementChild.text().trim()) {
+			this.#localMatch();
+			return;
+		}
+		const {children} = parentElement,
+			i = children.indexOf(this),
+			/** @type {HtmlToken[]} */
+			prevSiblings = children.slice(0, i).filter(child => child.matches(`html#${name}`)),
+			imbalance = prevSiblings.reduce((acc, {closing}) => acc + (closing ? 1 : -1), 0);
+		if (imbalance < 0) {
+			this.selfClosing = false;
+			this.closing = true;
+		} else {
+			Parser.warn('无法修复无效自封闭标签', this.toString().replaceAll('\n', '\\n'));
+			throw new Error(`无法修复无效自封闭标签：前文共有 ${imbalance} 个未匹配的闭合标签`);
+		}
+	}
+}
+
+Parser.classes.HtmlToken = __filename;
+module.exports = HtmlToken;

package/src/imageParameter.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const {typeError} = require('../util/debug'),
+	{extUrlChar} = require('../util/string'),
+	Title = require('../lib/title'),
+	/** @type {Parser} */ Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 图片参数
+ * @classdesc `{childNodes: ...(string|Token)}`
+ */
+class ImageParameterToken extends Token {
+	type = 'image-parameter';
+	#syntax = '';
+
+	/**
+	 * @param {string} key
+	 * @param {string} value
+	 */
+	static #validate(key, value, config = Parser.getConfig()) {
+		value = value.trim();
+		if (key === 'width') {
+			const mt = value.match(/^(\d*)(?:x(\d*))?$/);
+			return Number(mt?.[1]) > 0 || Number(mt?.[2]) > 0;
+		} else if (['alt', 'class', 'manualthumb', 'frameless', 'framed', 'thumbnail'].includes(key)) {
+			return true;
+		} else if (key === 'link') {
+			if (!value) {
+				return true;
+			}
+			const regex = new RegExp(`(?:${config.protocol}|//)${extUrlChar}`, 'ui');
+			if (regex.test(value)) {
+				return true;
+			}
+			if (/^\[\[.+]]$/.test(value)) {
+				value = value.slice(2, -2);
+			}
+			if (value.includes('%')) {
+				try {
+					value = decodeURIComponent(value);
+				} catch {}
+			}
+			return new Title(value, 0, config).valid;
+		}
+		return !isNaN(value);
+	}
+
+	/**
+	 * @param {string} str
+	 * @param {accum} accum
+	 */
+	constructor(str, config = Parser.getConfig(), accum = []) {
+		const regexes = Object.entries(config.img).map(
+				/** @returns {[string, string, RegExp]} */
+				([syntax, param]) => [syntax, param, new RegExp(`^(\\s*)${syntax.replace('$1', '(.*)')}(\\s*)$`)],
+			),
+			param = regexes.find(([,, regex]) => regex.test(str));
+		if (param) {
+			const mt = str.match(param[2]);
+			if (mt.length === 4 && !ImageParameterToken.#validate(param[1], mt[2], config)) {
+				// pass
+			} else {
+				if (mt.length === 3) {
+					super(undefined, config, true, accum);
+					this.#syntax = str;
+				} else {
+					super(mt[2], config, true, accum, {'Stage-2': ':', '!HeadingToken': ':'});
+					this.#syntax = `${mt[1]}${param[0]}${mt[3]}`;
+				}
+				this.setAttribute('name', param[1]).setAttribute('stage', 7);
+				return;
+			}
+		}
+		super(str, config, true, accum);
+		this.setAttribute('name', 'caption').setAttribute('stage', 7);
+	}
+
+	cloneNode() {
+		const cloned = this.cloneChildren(),
+			config = this.getAttribute('config'),
+			token = Parser.run(() => new ImageParameterToken(this.#syntax.replace('$1', ''), config));
+		token.replaceChildren(...cloned);
+		return token;
+	}
+
+	/**
+	 * @template {string} T
+	 * @param {T} key
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		if (key === 'syntax') {
+			return this.#syntax;
+		}
+		return super.getAttribute(key);
+	}
+
+	isPlain() {
+		return true;
+	}
+
+	#isVoid() {
+		return this.#syntax && !this.#syntax.includes('$1');
+	}
+
+	toString() {
+		if (!this.#syntax) {
+			return super.toString();
+		}
+		return this.#syntax.replace('$1', super.toString());
+	}
+
+	getPadding() {
+		return Math.max(0, this.#syntax.indexOf('$1'));
+	}
+
+	text() {
+		if (!this.#syntax) {
+			return super.text().trim();
+		}
+		return this.#syntax.replace('$1', super.text()).trim();
+	}
+
+	/**
+	 * @template {string|Token} T
+	 * @param {T} token
+	 * @complexity `n`
+	 */
+	insertAt(token, i = this.childNodes.length) {
+		if (!Parser.running && this.#isVoid()) {
+			throw new Error(`图片参数 ${this.name} 不接受自定义输入！`);
+		}
+		return super.insertAt(token, i);
+	}
+
+	/** @complexity `n` */
+	getValue() {
+		return this.#isVoid() || super.text();
+	}
+
+	/**
+	 * @param {string|boolean} value
+	 * @complexity `n`
+	 */
+	setValue(value) {
+		if (this.#isVoid()) {
+			if (typeof value !== 'boolean') {
+				typeError(this, 'setValue', 'Boolean');
+			} else if (value === false) {
+				this.remove();
+			}
+			return;
+		} else if (typeof value !== 'string') {
+			typeError(this, 'setValue', 'String');
+		}
+		const root = Parser.parse(`[[File:F|${
+				this.#syntax ? this.#syntax.replace('$1', value) : value
+			}]]`, this.getAttribute('include'), 6, this.getAttribute('config')),
+			{childNodes: {length}, firstElementChild} = root,
+			param = firstElementChild?.lastElementChild;
+		if (length !== 1 || !firstElementChild?.matches('file#File:F')
+			|| firstElementChild.childElementCount !== 2 || param.name !== this.name
+		) {
+			throw new SyntaxError(`非法的 ${this.name} 参数：${value.replaceAll('\n', '\\n')}`);
+		}
+		this.replaceChildren(...param.childNodes);
+	}
+}
+
+Parser.classes.ImageParameterToken = __filename;
+module.exports = ImageParameterToken;