wikiparser-node 0.0.0

package/typings/element.d.ts

@@ -0,0 +1,28 @@
+import Token from '../src';
+
+declare global {
+	interface AstEvent extends Event {
+		readonly target: Token;
+		currentTarget: Token;
+		prevTarget: ?Token;
+	};
+	interface AstEventData {
+		position: number;
+		removed: string|Token;
+		inserted: string|Token;
+		oldToken: Token;
+		newToken: Token;
+		oldText: string;
+		newText: string;
+		oldKey: string;
+		newKey: string;
+	}
+	type AstListener = (e: AstEvent, data: AstEventData) => any;
+
+	type pseudo = 'root'|'is'|'not'|'nth-child'|'nth-of-type'|'nth-last-child'|'nth-last-of-type'
+		|'first-child'|'first-of-type'|'last-child'|'last-of-type'|'only-child'|'only-of-type'|'empty'
+		|'contains'|'has'|'header'|'parent'|'hidden'|'visible';
+	type pseudoCall = Record<pseudo, string[]>;
+}
+
+export {};

package/typings/index.d.ts

@@ -0,0 +1,49 @@
+import Token from '../src';
+import $ from '../tool';
+import Title from '../lib/title';
+
+declare global {
+	interface Parser {
+		warning: boolean;
+		debugging: boolean;
+
+		/** 默认输出到console.warn */
+		warn(msg: string, ...args: any[]): void;
+		/** 默认不输出到console.debug */
+		debug(msg: string, ...args: any[]): void;
+		/** 总是输出到console.error */
+		error(msg: string, ...args: any[]): void;
+		/** 总是输出到console.info */
+		info(msg: string, ...args: any[]): void;
+
+		running: boolean;
+
+		run<T>(callback: () => T): T;
+
+		/** 只储存导出各个Class的文件路径 */
+		classes: Record<string, string>;
+		mixins: Record<string, string>;
+		parsers: Record<string, string>;
+		/** 清除各模块的缓存 */
+		clearCache(): void;
+
+		log(f: Function): void;
+
+		readonly aliases: string[][];
+
+		config: string;
+		getConfig(): ParserConfig;
+
+		isInterwiki(title: string, config?: ParserConfig): RegExpMatchArray;
+		normalizeTitle(
+			title: string, defaultNs?: number, include?: boolean, config?: ParserConfig, halfParsed?: boolean
+		): Title;
+
+		readonly MAX_STAGE: number;
+		parse(wikitext: string|Token, include?: boolean, maxStage?: number, config?: ParserConfig): Token;
+
+		getTool(): typeof $;
+	}
+}
+
+export {};

package/typings/node.d.ts

@@ -0,0 +1,23 @@
+import Ranges from '../lib/ranges';
+import Token from '../src';
+import ParameterToken from '../src/parameter';
+
+declare global {
+	type TokenAttribute<T> =
+		T extends 'childNodes' ? (string|Token)[] :
+		T extends 'parentNode' ? Token|undefined :
+		T extends 'optional'|'tags' ? string[] :
+		T extends 'stage' ? number :
+		T extends 'config' ? ParserConfig :
+		T extends 'accum' ? accum :
+		T extends 'acceptable' ? Record<string, Ranges> :
+		T extends 'protectedChildren' ? Ranges :
+		T extends 'keys' ? Set<string> :
+		T extends 'args' ? Record<string, Set<ParameterToken>> :
+		T extends 'attr' ? Map<string, string|true> :
+		T extends 'include'|'selfLink' ? boolean :
+		T extends 'pattern' ? RegExp :
+		string;
+}
+
+export {};

package/typings/parser.d.ts

@@ -0,0 +1,9 @@
+declare global {
+	interface BracketExecArray extends RegExpExecArray {
+		parts: string[][];
+		findEqual: boolean;
+		pos: number;
+	}
+}
+
+export {};

package/typings/table.d.ts

@@ -0,0 +1,14 @@
+declare global {
+	interface TableCoords {
+		row: number;
+		column: number;
+		start: boolean;
+	}
+
+	interface TableRenderedCoords {
+		x: number;
+		y: number;
+	}
+}
+
+export {};

package/typings/token.d.ts

@@ -0,0 +1,21 @@
+import Token from '../src';
+import Ranges from '../lib/ranges';
+
+declare global {
+	interface ParserConfig {
+		ext: string[];
+		html: [string[], string[], string[]];
+		namespaces: Record<string, string>;
+		nsid: Record<string, number>;
+		parserFunction: [string[], string[], string[], string[]];
+		doubleUnderscore: [string[], string[]];
+		protocol: string;
+		interwiki: string[];
+		img: Record<string, string>;
+	}
+
+	type accum = Token[];
+	type acceptable = Record<string, number|string|Ranges|(number|string)[]>;
+}
+
+export {};

package/typings/tool.d.ts

@@ -0,0 +1,10 @@
+import Token from '../src';
+
+declare global {
+	interface CollectionCallback<T, S> extends Function {
+		call: (thisArg: string|Token, i: number, ele: S) => T;
+	}
+	type CollectionMap = (arr: Token[]) => (string|Token)[];
+}
+
+export {};

package/util/debug.js

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * @param {ObjectConstructor} constructor
+ * @param {string} method
+ * @param {...string} args
+ */
+const typeError = ({constructor}, method, ...args) => {
+	throw new TypeError(`${constructor.name}.${method} 方法仅接受 ${args.join('、')} 作为输入参数！`);
+};
+
+/**
+ * 不是被构造器或原型方法调用
+ * @param {string} name
+ */
+const externalUse = (name, proxy = false) => {
+	if (!proxy && require('..').running) {
+		return false;
+	}
+	const regex = new RegExp(`^${
+		proxy ? 'Proxy' : 'new \\w*Token$|^(?:AstNode|AstElement|\\w*Token)'
+	}\\.(?!${name}$)`);
+	try {
+		throw new Error();
+	} catch (e) {
+		if (e instanceof Error) {
+			const mt = e.stack.match(/(?<=^\s+at )(?:new )?[\w.]+(?= \(\/)/gm);
+			return !mt.slice(2).some(func => regex.test(func));
+		}
+	}
+};
+
+/**
+ * @param {AstEvent} e
+ * @param {AstEventData} data
+ */
+const undo = (e, data) => {
+	const {target, type} = e;
+	switch (type) {
+		case 'remove': {
+			const childNodes = [...target.childNodes];
+			childNodes.splice(data.position, 0, data.removed);
+			target.setAttribute('childNodes', childNodes);
+			break;
+		}
+		case 'insert': {
+			const childNodes = [...target.childNodes];
+			childNodes.splice(data.position, 1);
+			target.setAttribute('childNodes', childNodes);
+			break;
+		}
+		case 'replace': {
+			const {parentNode} = target,
+				childNodes = [...parentNode.childNodes];
+			childNodes.splice(data.position, 1, data.oldToken);
+			parentNode.setAttribute('childNodes', childNodes);
+			break;
+		}
+		case 'text': {
+			const childNodes = [...target.childNodes];
+			childNodes[data.position] = data.oldText;
+			target.setAttribute('childNodes', childNodes);
+			break;
+		}
+		default:
+			throw new RangeError(`无法撤销未知类型的事件：${type}`);
+	}
+};
+
+module.exports = {typeError, externalUse, undo};

package/util/string.js

@@ -0,0 +1,60 @@
+'use strict';
+
+/**
+ * optionally convert to lower cases
+ * @param {string} val
+ * @param {boolean} i
+ */
+const toCase = (val, i) => i ? val.toLowerCase() : val;
+
+/**
+ * remove half-parsed comment-like tokens
+ * @param {string} str
+ */
+const removeComment = str => str.replace(/\x00\d+c\x7f/g, '');
+
+/** @param {string} str */
+const ucfirst = str => str && `${str[0].toUpperCase()}${str.slice(1)}`;
+
+/** @param {string} str */
+const escapeRegExp = str => str.replace(/[\\{}()|.?*+\-^$[\]]/g, '\\$&');
+
+/** @param {(string|AstNode)[]} childNodes */
+const text = (childNodes, separator = '') => {
+	const AstNode = require('../lib/node'); // eslint-disable-line no-unused-vars
+	return childNodes.map(child => typeof child === 'string' ? child : child.text()).join(separator);
+};
+
+/**
+ * @param {string} start
+ * @param {string} end
+ * @param {string} separator
+ * @param {string} str
+ */
+const explode = (start, end, separator, str) => {
+	if (str === undefined) {
+		return [];
+	}
+	const regex = new RegExp(`${[start, end, separator].map(escapeRegExp).join('|')}`, 'g'),
+		/** @type {string[]} */ exploded = [];
+	let mt = regex.exec(str),
+		depth = 0,
+		lastIndex = 0;
+	while (mt) {
+		const {0: match, index} = mt;
+		if (match !== separator) {
+			depth += match === start ? 1 : -1;
+		} else if (depth === 0) {
+			exploded.push(str.slice(lastIndex, index));
+			({lastIndex} = regex);
+		}
+		mt = regex.exec(str);
+	}
+	exploded.push(str.slice(lastIndex));
+	return exploded;
+};
+
+const extUrlChar = '(?:[\\d.]+|\\[[\\da-f:.]+\\]|[^[\\]<>"\\x00-\\x20\\x7f\\p{Zs}\\ufffd])'
+	+ '[^[\\]<>"\\x00-\\x20\\x7f\\p{Zs}\\ufffd]*';
+
+module.exports = {toCase, removeComment, ucfirst, escapeRegExp, text, explode, extUrlChar};