wikiparser-node 0.7.1-b → 0.8.0-m

package/src/converter.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const {text} = require('../util/string'),
+	Parser = require('..'),
+	Token = require('.'),
+	ConverterFlagsToken = require('./converterFlags'),
+	ConverterRuleToken = require('./converterRule');
+
+/**
+ * 转换
+ * @classdesc `{childNodes: [ConverterFlagsToken, ...ConverterRuleToken]}`
+ */
+class ConverterToken extends Token {
+	type = 'converter';
+
+	/**
+	 * @param {string[]} flags 转换类型标记
+	 * @param {string[]} rules 转换规则
+	 * @param {accum} accum
+	 */
+	constructor(flags, rules, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum);
+		this.append(new ConverterFlagsToken(flags, config, accum));
+		const [firstRule] = rules,
+			hasColon = firstRule.includes(':'),
+			firstRuleToken = new ConverterRuleToken(firstRule, hasColon, config, accum);
+		if (hasColon && firstRuleToken.length === 1) {
+			this.insertAt(new ConverterRuleToken(rules.join(';'), false, config, accum));
+		} else {
+			this.append(
+				firstRuleToken,
+				...rules.slice(1).map(rule => new ConverterRuleToken(rule, true, config, accum)),
+			);
+		}
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	toString(selector) {
+		const {childNodes: [flags, ...rules]} = this;
+		return `-{${flags.toString()}${flags.length > 0 ? '|' : ''}${rules.map(String).join(';')}}-`;
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	text() {
+		const {childNodes: [flags, ...rules]} = this;
+		return `-{${flags.text()}|${text(rules, ';')}}-`;
+	}
+
+	/** @override */
+	getPadding() {
+		return 2;
+	}
+
+	/**
+	 * @override
+	 * @param {number} i 子节点位置
+	 */
+	getGaps(i = 0) {
+		i = i < 0 ? i + this.length : i;
+		return i || this.firstChild.length > 0 ? 1 : 0;
+	}
+}
+
+module.exports = ConverterToken;

package/src/converterFlags.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const {generateForChild} = require('../util/lint'),
+	Parser = require('..'),
+	Token = require('.'),
+	AtomToken = require('./atom');
+
+const definedFlags = new Set(['A', 'T', 'R', 'D', '-', 'H', 'N']);
+
+/**
+ * 转换flags
+ * @classdesc `{childNodes: ...AtomToken}`
+ */
+class ConverterFlagsToken extends Token {
+	type = 'converter-flags';
+	/** @type {string[]} */ #flags;
+
+	/**
+	 * @param {string[]} flags 转换类型标记
+	 * @param {accum} accum
+	 */
+	constructor(flags, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {
+		});
+		this.append(...flags.map(flag => new AtomToken(flag, 'converter-flag', config, accum)));
+	}
+
+	/**
+	 * @override
+	 * @complexity `n`
+	 */
+	afterBuild() {
+		this.#flags = this.childNodes.map(child => child.text().trim());
+	}
+
+	/**
+	 * @override
+	 */
+	toString(selector) {
+		return super.toString(selector, ';');
+	}
+
+	/** @override */
+	text() {
+		return super.text(';');
+	}
+
+	/** @override */
+	getGaps() {
+		return 1;
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const variantFlags = this.getVariantFlags(),
+			unknownFlags = this.getUnknownFlags(),
+			validFlags = new Set(this.#flags.filter(flag => definedFlags.has(flag))),
+			{length: emptyFlagCount} = this.#flags.filter(flag => !flag),
+			knownFlagCount = this.#flags.length - unknownFlags.size - emptyFlagCount,
+			errors = super.lint(start);
+		if (variantFlags.size === knownFlagCount || validFlags.size === knownFlagCount) {
+			return errors;
+		}
+		const rect = {start, ...this.getRootNode().posFromIndex(start)},
+			{childNodes, length} = this;
+		for (let i = 0; i < length; i++) {
+			const child = childNodes[i],
+				flag = child.text().trim();
+			if (flag && !variantFlags.has(flag) && !unknownFlags.has(flag)
+				&& (variantFlags.size > 0 || !validFlags.has(flag))
+			) {
+				const error = generateForChild(child, rect, '无效的转换标记');
+				errors.push({...error, excerpt: childNodes.slice(0, i + 1).map(String).join(';').slice(-50)});
+			}
+		}
+		return errors;
+	}
+
+	/**
+	 * 获取未知转换类型标记
+	 * @complexity `n`
+	 */
+	getUnknownFlags() {
+		return new Set(this.#flags.filter(flag => /\{\{[^{}]+\}\}/u.test(flag)));
+	}
+
+	/** 获取指定语言变体的转换标记 */
+	getVariantFlags() {
+		const variants = new Set(this.getAttribute('config').variants);
+		return new Set(this.#flags.filter(flag => variants.has(flag)));
+	}
+}
+
+module.exports = ConverterFlagsToken;

package/src/converterRule.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const Parser = require('..'),
+	Token = require('.'),
+	AtomToken = require('./atom');
+
+/**
+ * 转换规则
+ * @classdesc `{childNodes: ...AtomToken)}`
+ */
+class ConverterRuleToken extends Token {
+	type = 'converter-rule';
+
+	/**
+	 * @param {string} rule 转换规则
+	 * @param {boolean} hasColon 是否带有":"
+	 * @param {accum} accum
+	 */
+	constructor(rule, hasColon = true, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum);
+		if (hasColon) {
+			const i = rule.indexOf(':'),
+				j = rule.slice(0, i).indexOf('=>'),
+				v = j === -1 ? rule.slice(0, i) : rule.slice(j + 2, i),
+				{variants} = config;
+			if (variants.includes(v.trim())) {
+				super.insertAt(new AtomToken(v, 'converter-rule-variant', config, accum));
+				super.insertAt(new AtomToken(rule.slice(i + 1), 'converter-rule-to', config, accum));
+				if (j !== -1) {
+					super.insertAt(new AtomToken(rule.slice(0, j), 'converter-rule-from', config, accum), 0);
+				}
+			} else {
+				super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
+			}
+		} else {
+			super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
+		}
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	toString(selector) {
+		if (this.length === 3) {
+			const {childNodes: [from, variant, to]} = this;
+			return `${from.toString(selector)}=>${variant.toString(selector)}:${to.toString(selector)}`;
+		}
+		return super.toString(selector, ':');
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	text() {
+		if (this.length === 3) {
+			const {childNodes: [from, variant, to]} = this;
+			return `${from.text()}=>${variant.text()}:${to.text()}`;
+		}
+		return super.text(':');
+	}
+
+	/**
+	 * @override
+	 * @param {number} i 子节点序号
+	 */
+	getGaps(i = 0) {
+		const {length} = this;
+		i = i < 0 ? i + length : i;
+		return i === 0 && length === 3 ? 2 : 1;
+	}
+}
+
+module.exports = ConverterRuleToken;

package/src/extLink.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const Parser = require('..'),
+	Token = require('.'),
+	MagicLinkToken = require('./magicLink');
+
+/**
+ * 外链
+ * @classdesc `{childNodes: [MagicLinkToken, ?Token]}`
+ */
+class ExtLinkToken extends Token {
+	type = 'ext-link';
+	#space;
+
+	/**
+	 * @param {string} url 网址
+	 * @param {string} space 空白字符
+	 * @param {string} text 链接文字
+	 * @param {accum} accum
+	 */
+	constructor(url, space, text, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {
+		});
+		this.insertAt(new MagicLinkToken(url, true, config, accum));
+		this.#space = space;
+		if (text) {
+			const inner = new Token(text, config, true, accum, {
+			});
+			inner.type = 'ext-link-text';
+			this.insertAt(inner.setAttribute('stage', Parser.MAX_STAGE - 1));
+		}
+	}
+
+	/**
+	 * @override
+	 */
+	toString(selector) {
+		if (this.length === 1) {
+			return `[${super.toString(selector)}${this.#space}]`;
+		}
+		return `[${super.toString(selector, this.#space)}]`;
+	}
+
+	/** @override */
+	text() {
+		return `[${super.text(' ')}]`;
+	}
+
+	/** @override */
+	getPadding() {
+		return 1;
+	}
+
+	/** @override */
+	getGaps() {
+		return this.#space.length;
+	}
+}
+
+module.exports = ExtLinkToken;

package/src/gallery.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const Parser = require('..'),
+	Token = require('.'),
+	GalleryImageToken = require('./link/galleryImage'),
+	HiddenToken = require('./atom/hidden');
+
+/**
+ * gallery标签
+ * @classdesc `{childNodes: ...(GalleryImageToken|HiddenToken|AstText)}`
+ */
+class GalleryToken extends Token {
+	type = 'ext-inner';
+	name = 'gallery';
+
+	/**
+	 * @param {string} inner 标签内部wikitext
+	 * @param {accum} accum
+	 */
+	constructor(inner, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {
+		});
+		const /** @type {ParserConfig} */ newConfig = {...config, img: {...config.img}};
+		for (const [k, v] of Object.entries(config.img)) {
+			if (v === 'width') {
+				delete newConfig.img[k];
+			}
+		}
+		for (const line of inner?.split('\n') ?? []) {
+			const matches = /^([^|]+)(?:\|(.*))?/u.exec(line);
+			if (!matches) {
+				super.insertAt(line.trim()
+					? new HiddenToken(line, undefined, newConfig, [], {
+					})
+					: line);
+				continue;
+			}
+			const [, file, alt] = matches,
+				title = this.normalizeTitle(file, 6, true, true);
+			if (title.valid) {
+				super.insertAt(new GalleryImageToken(file, alt, title, newConfig, accum));
+			} else {
+				super.insertAt(new HiddenToken(line, undefined, newConfig, [], {
+				}));
+			}
+		}
+	}
+
+	/**
+	 * @override
+	 */
+	toString(selector) {
+		return super.toString(selector, '\n');
+	}
+
+	/** @override */
+	text() {
+		return super.text('\n').replace(/\n\s*\n/gu, '\n');
+	}
+
+	/** @override */
+	getGaps() {
+		return 1;
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const {top, left} = this.getRootNode().posFromIndex(start),
+			/** @type {LintError[]} */ errors = [];
+		for (let i = 0, startIndex = start; i < this.length; i++) {
+			const child = this.childNodes[i],
+				str = String(child),
+				{length} = str,
+				trimmed = str.trim(),
+				startLine = top + i,
+				startCol = i ? 0 : left;
+			if (child.type === 'hidden' && trimmed && !/^<!--.*-->$/u.test(trimmed)) {
+				errors.push({
+					message: '图库中的无效内容',
+					severity: 'error',
+					startIndex,
+					endIndex: startIndex + length,
+					startLine,
+					endLine: startLine,
+					startCol,
+					endCol: startCol + length,
+					excerpt: String(child).slice(0, 50),
+				});
+			} else if (child.type !== 'hidden' && child.type !== 'text') {
+				errors.push(...child.lint(startIndex));
+			}
+			startIndex += length + 1;
+		}
+		return errors;
+	}
+}
+
+module.exports = GalleryToken;

package/src/hasNowiki/index.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Parser = require('../..'),
+	Token = require('..'),
+	NoincludeToken = require('../nowiki/noinclude');
+
+/**
+ * `<pre>`
+ * @classdesc `{childNodes: [...AstText|NoincludeToken]}`
+ */
+class HasNowikiToken extends Token {
+	/**
+	 * @param {string} wikitext wikitext
+	 * @param {string} type type
+	 * @param {accum} accum
+	 */
+	constructor(wikitext, type, config = Parser.getConfig(), accum = []) {
+		wikitext = wikitext.replace(
+			/(<nowiki>)(.*?)(<\/nowiki>)/giu,
+			/** @type {function(...string): string} */ (_, opening, inner, closing) => {
+				new NoincludeToken(opening, config, accum);
+				new NoincludeToken(closing, config, accum);
+				return `\0${accum.length - 1}c\x7F${inner}\0${accum.length}c\x7F`;
+			},
+		);
+		super(wikitext, config, true, accum, {
+		});
+		this.type = type;
+	}
+}
+
+module.exports = HasNowikiToken;

package/src/hasNowiki/pre.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Parser = require('../..'),
+	HasNowikiToken = require('.');
+
+/**
+ * `<pre>`
+ * @classdesc `{childNodes: [...AstText|NoincludeToken|ConverterToken]}`
+ */
+class PreToken extends HasNowikiToken {
+	name = 'pre';
+
+	/**
+	 * @param {string} wikitext wikitext
+	 * @param {accum} accum
+	 */
+	constructor(wikitext, config = Parser.getConfig(), accum = []) {
+		super(wikitext, 'ext-inner', config, accum);
+		this.setAttribute('stage', Parser.MAX_STAGE - 1);
+	}
+
+	/** @override */
+	isPlain() {
+		return true;
+	}
+}
+
+module.exports = PreToken;

package/src/heading.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const {generateForSelf} = require('../util/lint'),
+	Parser = require('..'),
+	Token = require('.'),
+	SyntaxToken = require('./syntax');
+
+/**
+ * 章节标题
+ * @classdesc `{childNodes: [Token, SyntaxToken]}`
+ */
+class HeadingToken extends 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('stage', 2);
+		const trail = new SyntaxToken(input[1], /^[^\S\n]*$/u, 'heading-trail', config, accum, {
+		});
+		this.append(token, trail);
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	toString(selector) {
+		const equals = '='.repeat(Number(this.name));
+		return `${equals}${this.firstChild.toString()}${equals}${this.lastChild.toString()}`;
+	}
+
+	/**
+	 * @override
+	 * @returns {string}
+	 */
+	text() {
+		const equals = '='.repeat(Number(this.name));
+		return `${equals}${this.firstChild.text()}${equals}`;
+	}
+
+	/** @override */
+	getPadding() {
+		return super.getPadding() + Number(this.name);
+	}
+
+	/** @override */
+	getGaps() {
+		return Number(this.name);
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const errors = super.lint(start),
+			innerText = String(this.firstChild);
+		let refError;
+		if (this.name === '1') {
+			refError = generateForSelf(this, {start}, '<h1>');
+			errors.push(refError);
+		}
+		if (innerText[0] === '=' || innerText.endsWith('=')) {
+			refError ||= generateForSelf(this, {start}, '');
+			errors.push({...refError, message: '段落标题中不平衡的"="'});
+		}
+		if (this.closest('html-attrs, table-attrs')) {
+			refError ||= generateForSelf(this, {start}, '');
+			errors.push({...refError, message: 'HTML标签属性中的段落标题'});
+		}
+		return errors;
+	}
+}
+
+module.exports = HeadingToken;

package/src/html.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const {generateForSelf} = require('../util/lint'),
+	Parser = require('..'),
+	Token = require('.');
+
+/**
+ * HTML标签
+ * @classdesc `{childNodes: [AttributesToken]}`
+ */
+class HtmlToken extends Token {
+	type = 'html';
+	#closing;
+	#selfClosing;
+	#tag;
+
+	/** getter */
+	get closing() {
+		return this.#closing;
+	}
+
+	/**
+	 * @param {string} name 标签名
+	 * @param {AttributesToken} 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.insertAt(attr);
+		this.setAttribute('name', name.toLowerCase());
+		this.#closing = closing;
+		this.#selfClosing = selfClosing;
+		this.#tag = name;
+	}
+
+	/**
+	 * @override
+	 */
+	toString(selector) {
+		return `<${this.#closing ? '/' : ''}${this.#tag}${super.toString()}${this.#selfClosing ? '/' : ''}>`;
+	}
+
+	/** @override */
+	text() {
+		return `<${this.#closing ? '/' : ''}${this.#tag}${
+			this.#closing ? '' : super.text()
+		}${this.#selfClosing ? '/' : ''}>`;
+	}
+
+	/** @override */
+	getPadding() {
+		return this.#tag.length + (this.#closing ? 2 : 1);
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = 0) {
+		const errors = super.lint(start);
+		let wikitext, /** @type {LintError} */ refError;
+		if (this.name === 'h1' && !this.#closing) {
+			wikitext = String(this.getRootNode());
+			refError = generateForSelf(this, {start}, '<h1>');
+			errors.push({...refError, excerpt: wikitext.slice(start, start + 50)});
+		}
+		if (this.closest('table-attrs')) {
+			wikitext ||= String(this.getRootNode());
+			refError ||= generateForSelf(this, {start}, '');
+			const excerpt = wikitext.slice(Math.max(0, start - 25), start + 25);
+			errors.push({...refError, message: '表格属性中的HTML标签', excerpt});
+		}
+		try {
+			this.findMatchingTag();
+		} catch ({message: errorMsg}) {
+			wikitext ||= String(this.getRootNode());
+			refError ||= generateForSelf(this, {start}, '');
+			const [message] = errorMsg.split('：'),
+				error = {...refError, message, severity: message === '未闭合的标签' ? 'warning' : 'error'};
+			if (message === '未闭合的标签') {
+				error.excerpt = wikitext.slice(start, start + 50);
+			} else if (message === '未匹配的闭合标签') {
+				const end = start + String(this).length;
+				error.excerpt = wikitext.slice(Math.max(0, end - 50), end);
+			}
+			errors.push(error);
+		}
+		return errors;
+	}
+
+	/**
+	 * 搜索匹配的标签
+	 * @complexity `n`
+	 * @throws `SyntaxError` 同时闭合和自封闭的标签
+	 * @throws `SyntaxError` 无效自封闭标签
+	 * @throws `SyntaxError` 未闭合的标签
+	 */
+	findMatchingTag() {
+		const {html} = this.getAttribute('config'),
+			{name: tagName, parentNode} = this,
+			string = String(this);
+		if (this.#closing && (this.#selfClosing || html[2].includes(tagName))) {
+			throw new SyntaxError(`同时闭合和自封闭的标签：${string}`);
+		} else if (html[2].includes(tagName) || this.#selfClosing && html[1].includes(tagName)) { // 自封闭标签
+			return this;
+		} else if (this.#selfClosing && html[0].includes(tagName)) {
+			throw new SyntaxError(`无效自封闭标签：${string}`);
+		} else if (!parentNode) {
+			return undefined;
+		}
+		const {childNodes} = parentNode,
+			i = childNodes.indexOf(this),
+			siblings = this.#closing
+				? childNodes.slice(0, i).reverse().filter(({type, name}) => type === 'html' && name === tagName)
+				: childNodes.slice(i + 1).filter(({type, name}) => type === 'html' && name === tagName);
+		let imbalance = this.#closing ? -1 : 1;
+		for (const token of siblings) {
+			if (token.closing) {
+				imbalance--;
+			} else {
+				imbalance++;
+			}
+			if (imbalance === 0) {
+				return token;
+			}
+		}
+		throw new SyntaxError(`未${this.#closing ? '匹配的闭合' : '闭合的'}标签：${string}`);
+	}
+}
+
+module.exports = HtmlToken;