wikiparser-node 0.10.0 → 0.11.0-m

package/dist/src/table/td.d.ts

@@ -0,0 +1,39 @@
+export = TdToken;
+/**
+ * `<td>`、`<th>`和`<caption>`
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, Token]}`
+ */
+declare class TdToken extends TrToken {
+    /**
+     * @param {string} syntax 单元格语法
+     * @param {string} inner 内部wikitext
+     * @param {import('../../../typings/token').accum} accum
+     */
+    constructor(syntax: string, inner: string, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum);
+    /**
+     * 单元格类型
+     * @complexity `n`
+     */
+    get subtype(): "caption" | "td" | "th";
+    /**
+     * 获取单元格语法信息
+     * @returns {{subtype: 'td'|'th'|'caption'}}
+     * @complexity `n`
+     */
+    getSyntax(): {
+        subtype: 'td' | 'th' | 'caption';
+    };
+    /**
+     * @override
+     * @returns {string}
+     * @complexity `n`
+     */
+    override toString(selector: any): string;
+    /**
+     * @override
+     * @param {number} i 子节点位置
+     */
+    override getGaps(i?: number): number;
+    #private;
+}
+import TrToken = require("./tr");

package/dist/src/table/tr.d.ts

@@ -0,0 +1,17 @@
+export = TrToken;
+/**
+ * 表格行，含开头的换行，不含结尾的换行
+ * @classdesc `{childNodes: [SyntaxToken, AttributesToken, ?Token, ...TdToken]}`
+ */
+declare class TrToken extends Token {
+    /**
+     * @param {string} syntax 表格语法
+     * @param {string} attr 表格属性
+     * @param {import('../../../typings/token').accum} accum
+     * @param {RegExp} pattern 表格语法正则
+     */
+    constructor(syntax: string, attr?: string, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum, pattern?: RegExp);
+    /** @override */
+    override text(): string;
+}
+import Token = require("..");

package/dist/src/tagPair/ext.d.ts

@@ -0,0 +1,17 @@
+export = ExtToken;
+/**
+ * 扩展标签
+ * @classdesc `{childNodes: [AttributesToken, NowikiToken|Token]}`
+ */
+declare class ExtToken extends TagPairToken {
+    /**
+     * @param {string} name 标签名
+     * @param {string} attr 标签属性
+     * @param {string} inner 内部wikitext
+     * @param {string|undefined} closed 是否封闭
+     * @param {import('../../../typings/token').accum} accum
+     */
+    constructor(name: string, attr?: string, inner?: string, closed?: string | undefined, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum);
+    closed: boolean;
+}
+import TagPairToken = require(".");

package/dist/src/tagPair/include.d.ts

@@ -0,0 +1,16 @@
+export = IncludeToken;
+/**
+ * `<includeonly>`或`<noinclude>`
+ * @classdesc `{childNodes: [AstText, AstText]}`
+ */
+declare class IncludeToken extends TagPairToken {
+    /**
+     * @param {string} name 标签名
+     * @param {string} attr 标签属性
+     * @param {string|undefined} inner 内部wikitext
+     * @param {string|undefined} closed 是否封闭
+     * @param {import('../../../typings/token').accum} accum
+     */
+    constructor(name: string, attr?: string, inner?: string | undefined, closed?: string | undefined, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum);
+}
+import TagPairToken = require(".");

package/dist/src/tagPair/index.d.ts

@@ -0,0 +1,28 @@
+export = TagPairToken;
+/**
+ * 成对标签
+ * @classdesc `{childNodes: [AstText|AttributesToken, AstText|Token]}`
+ */
+declare class TagPairToken extends Token {
+    /**
+     * @param {string} name 标签名
+     * @param {string|Token} attr 标签属性
+     * @param {string|Token} inner 内部wikitext
+     * @param {string|undefined} closed 是否封闭；约定`undefined`表示自闭合，`''`表示未闭合
+     * @param {import('../../../typings/token').accum} accum
+     */
+    constructor(name: string, attr: string | Token, inner: string | Token, closed: string | undefined, config?: import("../../../typings/token").ParserConfig, accum?: import('../../../typings/token').accum);
+    /** getter */
+    get closed(): boolean;
+    /**
+     * @override
+     */
+    override toString(selector: any): string;
+    /**
+     * @override
+     * @returns {string}
+     */
+    override text(): string;
+    #private;
+}
+import Token = require("..");

package/dist/src/transclude.d.ts

@@ -0,0 +1,75 @@
+export = TranscludeToken;
+/**
+ * 模板或魔术字
+ * @classdesc `{childNodes: [AtomToken|SyntaxToken, ...ParameterToken]}`
+ */
+declare class TranscludeToken extends Token {
+    /**
+     * @param {string} title 模板标题或魔术字
+     * @param {[string, string|undefined][]} parts 参数各部分
+     * @param {import('../../typings/token').accum} accum
+     * @complexity `n`
+     * @throws `SyntaxError` 非法的模板名称
+     */
+    constructor(title: string, parts: [string, string | undefined][], config?: import("../../typings/token").ParserConfig, accum?: import('../../typings/token').accum);
+    modifier: string;
+    /**
+     * 设置引用修饰符
+     * @param {string} modifier 引用修饰符
+     * @complexity `n`
+     */
+    setModifier(modifier?: string): boolean;
+    /**
+     * @override
+     */
+    override toString(selector: any): string;
+    /**
+     * @override
+     * @returns {string}
+     * @complexity `n`
+     */
+    override text(): string;
+    /** 是否是模板 */
+    isTemplate(): boolean;
+    /**
+     * @override
+     * @param {ParameterToken} token 待插入的子节点
+     * @param {number} i 插入位置
+     * @complexity `n`
+     */
+    override insertAt(token: ParameterToken, i?: number): ParameterToken;
+    /**
+     * 获取所有参数
+     * @returns {ParameterToken[]}
+     * @complexity `n`
+     */
+    getAllArgs(): ParameterToken[];
+    /**
+     * 获取匿名参数
+     * @complexity `n`
+     */
+    getAnonArgs(): ParameterToken[];
+    /**
+     * 获取指定参数
+     * @param {string|number} key 参数名
+     * @param {boolean} exact 是否匹配匿名性
+     * @param {boolean} copy 是否返回一个备份
+     * @complexity `n`
+     */
+    getArgs(key: string | number, exact: boolean, copy?: boolean): Set<ParameterToken>;
+    /**
+     * 获取重名参数
+     * @complexity `n`
+     * @returns {[string, ParameterToken[]][]}
+     */
+    getDuplicatedArgs(): [string, ParameterToken[]][];
+    /**
+     * 对特定魔术字获取可能的取值
+     * @this {ParameterToken}}
+     * @throws `Error` 不是可接受的魔术字
+     */
+    getPossibleValues(this: ParameterToken): Token[];
+    #private;
+}
+import Token = require(".");
+import ParameterToken = require("./parameter");

package/dist/util/lint.d.ts

@@ -0,0 +1,28 @@
+export type LintError = import('../../typings/token').LintError;
+/**
+ * 生成对于子节点的LintError对象
+ * @param {Token} child 子节点
+ * @param {{top: number, left: number, start: number}} boundingRect 父节点的绝对定位
+ * @param {string} msg 错误信息
+ * @param {'error'|'warning'} severity 严重程度
+ * @returns {LintError}
+ */
+export function generateForChild(child: Token, boundingRect: {
+    top: number;
+    left: number;
+    start: number;
+}, msg: string, severity?: 'error' | 'warning'): LintError;
+/**
+ * 生成对于自己的LintError对象
+ * @param {Token} token 节点
+ * @param {{top: number, left: number, start: number}} boundingRect 绝对定位
+ * @param {string} msg 错误信息
+ * @param {'error'|'warning'} severity 严重程度
+ * @returns {LintError}
+ */
+export function generateForSelf(token: Token, boundingRect: {
+    top: number;
+    left: number;
+    start: number;
+}, msg: string, severity?: 'error' | 'warning'): LintError;
+import Token = require("../src");

package/dist/util/string.d.ts

@@ -0,0 +1,31 @@
+export const extUrlCharFirst: "(?:\\[[\\da-f:.]+\\]|[^[\\]<>\"\\0-\\x1F\\x7F\\p{Zs}\\uFFFD])";
+export const extUrlChar: "(?:[^[\\]<>\"\\0-\\x1F\\x7F\\p{Zs}\\uFFFD]|\\0\\d+c\\x7F)*";
+/**
+ * remove half-parsed comment-like tokens
+ * @param {string} str 原字符串
+ */
+export function removeComment(str: string): string;
+/**
+ * escape special chars for RegExp constructor
+ * @param {string} str RegExp source
+ */
+export function escapeRegExp(str: string): string;
+/**
+ * a more sophisticated string-explode function
+ * @param {string} start start syntax of a nested AST node
+ * @param {string} end end syntax of a nested AST node
+ * @param {string} separator syntax for explosion
+ * @param {string} str string to be exploded
+ */
+export function explode(start: string, end: string, separator: string, str: string): string[];
+/**
+ * extract effective wikitext
+ * @param {(string|AstNode)[]} childNodes a Token's contents
+ * @param {string} separator delimiter between nodes
+ */
+export function text(childNodes: (string | import("../lib/node"))[], separator?: string): string;
+/**
+ * decode HTML entities
+ * @param {string} str 原字符串
+ */
+export function decodeHtml(str: string): string;

package/i18n/zh-hans.json

@@ -42,4 +42,4 @@
 	"unnecessary URL encoding in an internal link": "内链中不必要的URL编码",
 	"useless fragment": "多余的fragment",
 	"vertical-alignment": "垂直对齐"
-}
+}

package/i18n/zh-hant.json

@@ -42,4 +42,4 @@
 	"unnecessary URL encoding in an internal link": "內部連結中不必要的URL編碼",
 	"useless fragment": "多餘的fragment",
 	"vertical-alignment": "垂直對齊"
-}
+}

package/index.js

@@ -1,127 +1,11 @@
 'use strict';
 
-const fs = require('fs'),
-	path = require('path');
-
-const /** @type {Parser} */ Parser = {
+const /** @type {import('./typings')} */ Parser = {
 	config: './config/default',
 	i18n: undefined,
 
 	MAX_STAGE: 11,
 
-	warning: true,
-	debugging: false,
-	running: false,
-
-	classes: {},
-	mixins: {},
-	parsers: {},
-	tool: {},
-
-	aliases: [
-		['AstText'],
-		['CommentToken', 'ExtToken', 'IncludeToken', 'NoincludeToken'],
-		['ArgToken', 'TranscludeToken', 'HeadingToken'],
-		['HtmlToken'],
-		['TableToken'],
-		['HrToken', 'DoubleUnderscoreToken'],
-		['LinkToken', 'FileToken', 'CategoryToken'],
-		['QuoteToken'],
-		['ExtLinkToken'],
-		['MagicLinkToken'],
-		['ListToken', 'DdToken'],
-		['ConverterToken'],
-	],
-	typeAliases: {
-		text: ['string', 'str'],
-		plain: ['regular', 'normal'],
-		// comment and extension
-		onlyinclude: ['only-include'],
-		noinclude: ['no-include'],
-		include: ['includeonly', 'include-only'],
-		comment: undefined,
-		ext: ['extension'],
-		'ext-attrs': ['extension-attrs', 'ext-attributes', 'extension-attributes'],
-		'ext-attr-dirty': ['extension-attr-dirty', 'ext-attribute-dirty', 'extension-attribute-dirty'],
-		'ext-attr': ['extension-attr', 'ext-attribute', 'extension-attribute'],
-		'attr-key': ['attribute-key'],
-		'attr-value': ['attribute-value', 'attr-val', 'attribute-val'],
-		'ext-inner': ['extension-inner'],
-		// triple brackets
-		arg: ['argument'],
-		'arg-name': ['argument-name'],
-		'arg-default': ['argument-default'],
-		hidden: ['arg-redundant'],
-		// double brackets
-		'magic-word': ['parser-function', 'parser-func'],
-		'magic-word-name': ['parser-function-name', 'parser-func-name'],
-		'invoke-function': ['invoke-func', 'lua-function', 'lua-func', 'module-function', 'module-func'],
-		'invoke-module': ['lua-module'],
-		template: undefined,
-		'template-name': undefined,
-		parameter: ['param'],
-		'parameter-key': ['param-key'],
-		'parameter-value': ['parameter-val', 'param-value', 'param-val'],
-		// heading
-		heading: ['header'],
-		'heading-title': ['header-title'],
-		'heading-trail': ['header-trail'],
-		// html
-		html: undefined,
-		'html-attrs': ['html-attributes'],
-		'html-attr-dirty': ['html-attribute-dirty'],
-		'html-attr': ['html-attribute'],
-		// table
-		table: undefined,
-		tr: ['table-row'],
-		td: ['table-cell', 'table-data'],
-		'table-syntax': undefined,
-		'table-attrs': ['tr-attrs', 'td-attrs', 'table-attributes', 'tr-attributes', 'td-attributes'],
-		'table-attr-dirty':
-			['tr-attr-dirty', 'td-attr-dirty', 'table-attribute-dirty', 'tr-attribute-dirty', 'td-attribute-dirty'],
-		'table-attr': ['tr-attr', 'td-attr', 'table-attribute', 'tr-attribute', 'td-attribute'],
-		'table-inter': undefined,
-		'td-inner': ['table-cell-inner', 'table-data-inner'],
-		// hr and double-underscore
-		hr: ['horizontal'],
-		'double-underscore': ['underscore', 'behavior-switch', 'behaviour-switch'],
-		// link
-		link: ['wikilink'],
-		'link-target': ['wikilink-target'],
-		'link-text': ['wikilink-text'],
-		category: ['category-link', 'cat', 'cat-link'],
-		file: ['file-link', 'image', 'image-link', 'img', 'img-link'],
-		'gallery-image': ['gallery-file', 'gallery-img'],
-		'imagemap-image': ['imagemap-file', 'imagemap-img', 'image-map-image', 'image-map-file', 'image-map-img'],
-		'image-parameter': ['img-parameter', 'image-param', 'img-param'],
-		// quotes
-		quote: ['quotes', 'quot', 'apostrophe', 'apostrophes', 'apos'],
-		// external link
-		'ext-link': ['external-link'],
-		'ext-link-text': ['external-link-text'],
-		'ext-link-url': ['external-link-url'],
-		// magic link
-		'free-ext-link': ['free-external-link', 'magic-link'],
-		// list
-		list: ['ol', 'ordered-list', 'ul', 'unordered-list', 'dl', 'description-list'],
-		dd: ['indent', 'indentation'],
-		// converter
-		converter: ['convert', 'conversion'],
-		'converter-flags': ['convert-flags', 'conversion-flags'],
-		'converter-flag': ['convert-flag', 'conversion-flag'],
-		'converter-rule': ['convert-rule', 'conversion-rule'],
-		'converter-rule-noconvert': ['convert-rule-noconvert', 'conversion-rule-noconvert'],
-		'converter-rule-variant': ['convert-rule-variant', 'conversion-rule-variant'],
-		'converter-rule-to': ['convert-rule-to', 'conversion-rule-to'],
-		'converter-rule-from': ['convert-rule-from', 'conversion-rule-from'],
-		// specific extensions
-		'param-line': ['parameter-line'],
-		'charinsert-line': undefined,
-		'imagemap-link': ['image-map-link'],
-	},
-
-	promises: [Promise.resolve()],
-
 	getConfig() {
 		if (typeof this.config === 'string') {
 			this.config = require(this.config);
@@ -159,22 +43,6 @@ const /** @type {Parser} */ Parser = {
 		}
 		const Title = require('./lib/title');
 		const titleObj = new Title(String(title), defaultNs, config, decode, selfLink);
-		if (token) {
-			/**
-			 * 重建部分属性值
-			 * @param {string[]} keys 属性键
-			 */
-			const build = keys => {
-				for (const key of keys) {
-					if (titleObj[key]?.includes('\0')) {
-						titleObj[key] = token.getAttribute('buildFromStr')(titleObj[key], 'text');
-					}
-				}
-			};
-			this.run(() => {
-				build(['title', 'main', 'fragment']);
-			});
-		}
 		return titleObj;
 	},
 
@@ -188,139 +56,19 @@ const /** @type {Parser} */ Parser = {
 			token = new Token(wikitext, config);
 			try {
 				token.parse(maxStage, include);
-			} catch (e) {
-				if (e instanceof Error) {
-					const file = path.join(__dirname, 'errors', new Date().toISOString()),
-						stage = token.getAttribute('stage');
-					fs.writeFileSync(file, stage === this.MAX_STAGE ? wikitext : String(token));
-					fs.writeFileSync(`${file}.err`, e.stack);
-					fs.writeFileSync(`${file}.json`, JSON.stringify({
-						stage, include: token.getAttribute('include'), config: this.config,
-					}, null, '\t'));
-				}
-				throw e;
-			}
+			} catch {}
 		});
-		if (this.debugging) {
-			let restored = String(token),
-				process = '解析';
-			if (restored === wikitext) {
-				const entities = {lt: '<', gt: '>', amp: '&'};
-				restored = token.print().replace(
-					/<[^<]+?>|&([lg]t|amp);/gu,
-					/** @param {string} s */ (_, s) => s ? entities[s] : '',
-				);
-				process = '渲染HTML';
-			}
-			if (restored !== wikitext) {
-				const diff = require('./util/diff');
-				const {promises: {0: cur, length}} = this;
-				this.promises.unshift((async () => {
-					await cur;
-					this.error(`${process}过程中不可逆地修改了原始文本！`);
-					return diff(wikitext, restored, length);
-				})());
-			}
-		}
 		return token;
 	},
 
 	run(callback) {
-		const {running} = this;
-		this.running = true;
-		try {
-			const result = callback();
-			this.running = running;
-			return result;
-		} catch (e) {
-			this.running = running;
-			throw e;
-		}
-	},
-
-	warn(msg, ...args) {
-		if (this.warning) {
-			console.warn('\x1B[33m%s\x1B[0m', msg, ...args);
-		}
-	},
-	debug(msg, ...args) {
-		if (this.debugging) {
-			console.debug('\x1B[34m%s\x1B[0m', msg, ...args);
-		}
-	},
-	error(msg, ...args) {
-		console.error('\x1B[31m%s\x1B[0m', msg, ...args);
-	},
-	info(msg, ...args) {
-		console.info('\x1B[32m%s\x1B[0m', msg, ...args);
-	},
-
-	log(f) {
-		if (typeof f === 'function') {
-			console.log(String(f));
-		}
-	},
-
-	clearCache() {
-		const entries = [
-			...Object.entries(this.classes),
-			...Object.entries(this.mixins),
-			...Object.entries(this.parsers),
-			...Object.entries(this.tool),
-		];
-		for (const [, filePath] of entries) {
-			try {
-				delete require.cache[require.resolve(filePath)];
-			} catch {}
-		}
-		for (const [name, filePath] of entries) {
-			if (name in global) {
-				global[name] = require(filePath);
-			}
-		}
-	},
-
-	isInterwiki(title, {interwiki} = Parser.getConfig()) {
-		title = String(title);
-		return new RegExp(`^(${interwiki.join('|')})\\s*:`, 'iu')
-			.exec(title.replaceAll('_', ' ').replace(/^\s*:?\s*/u, ''));
-	},
-
-	reparse(date) {
-		const main = fs.readdirSync(path.join(__dirname, 'errors'))
-			.find(name => name.startsWith(date) && name.endsWith('Z'));
-		if (!main) {
-			throw new RangeError(`找不到对应时间戳的错误记录：${date}`);
-		}
-		const file = path.join(__dirname, 'errors', main),
-			wikitext = fs.readFileSync(file, 'utf8');
-		const {stage, include, config} = require(`${file}.json`),
-			Token = require('./src');
-		this.config = config;
-		return this.run(() => {
-			const halfParsed = stage < this.MAX_STAGE,
-				token = new Token(wikitext, this.getConfig(), halfParsed);
-			if (halfParsed) {
-				token.setAttribute('stage', stage).getAttribute('parseOnce')(stage, include);
-			} else {
-				token.parse(undefined, include);
-			}
-			fs.unlinkSync(file);
-			fs.unlinkSync(`${file}.err`);
-			fs.unlinkSync(`${file}.json`);
-			return token;
-		});
-	},
-
-	getTool() {
-		delete require.cache[require.resolve('./tool')];
-		return require('./tool');
+		return callback();
 	},
 };
 
 const /** @type {PropertyDescriptorMap} */ def = {},
-	immutable = new Set(['MAX_STAGE', 'aliases', 'typeAliases', 'promises']),
-	enumerable = new Set(['config', 'normalizeTitle', 'parse', 'isInterwiki', 'getTool']);
+	immutable = new Set(['MAX_STAGE']),
+	enumerable = new Set(['config', 'normalizeTitle', 'parse']);
 for (const key in Parser) {
 	if (immutable.has(key)) {
 		def[key] = {enumerable: false, writable: false};