wikiparser-node 0.11.0-b → 0.11.0

package/src/link/index.js

@@ -0,0 +1,388 @@
+'use strict';
+
+const {generateForChild} = require('../../util/lint'),
+	{noWrap} = require('../../util/string'),
+	{undo} = require('../../util/debug'),
+	Parser = require('../..'),
+	AstText = require('../../lib/text'),
+	Token = require('..'),
+	AtomToken = require('../atom');
+
+/**
+ * 内链
+ * @classdesc `{childNodes: [AtomToken, ?Token]}`
+ */
+class LinkToken extends Token {
+	type = 'link';
+	#bracket = true;
+	#delimiter;
+	#fragment;
+	#encoded = false;
+
+	/** 完整链接，和FileToken保持一致 */
+	get link() {
+		return this.#getTitle();
+	}
+
+	set link(link) {
+		this.setTarget(link);
+	}
+
+	/** 是否链接到自身 */
+	get selfLink() {
+		const {title, fragment} = this.#getTitle();
+		return !title && Boolean(fragment);
+	}
+
+	set selfLink(selfLink) {
+		if (selfLink === true) {
+			this.asSelfLink();
+		}
+	}
+
+	/** fragment */
+	get fragment() {
+		return this.#getTitle().fragment;
+	}
+
+	set fragment(fragment) {
+		this.#setFragment(fragment);
+	}
+
+	/** interwiki */
+	get interwiki() {
+		return this.#getTitle().interwiki;
+	}
+
+	set interwiki(interwiki) {
+		if (typeof interwiki !== 'string') {
+			this.typeError('set interwiki', 'String');
+		}
+		const {prefix, main, fragment} = this.#getTitle(),
+			link = `${interwiki}:${prefix}${main}${fragment === undefined ? '' : `#${fragment}`}`;
+		if (interwiki && !this.isInterwiki(link)) {
+			throw new RangeError(`${interwiki} 不是合法的跨维基前缀!`);
+		}
+		this.setTarget(link);
+	}
+
+	/** 链接显示文字 */
+	get innerText() {
+		if (this.type === 'link') {
+			return this.length > 1
+				? this.lastChild.text()
+				: this.firstChild.text().replace(/^\s*:/u, '');
+		}
+		return undefined;
+	}
+
+	/**
+	 * @param {string} link 链接标题
+	 * @param {string|undefined} linkText 链接显示文字
+	 * @param {import('../../typings/token').accum} accum
+	 * @param {string} delimiter `|`
+	 */
+	constructor(link, linkText, config = Parser.getConfig(), accum = [], delimiter = '|') {
+		super(undefined, config, true, accum, {
+			AtomToken: 0, Token: 1,
+		});
+		this.insertAt(new AtomToken(link, 'link-target', config, accum, {
+			'Stage-2': ':', '!ExtToken': '', '!HeadingToken': '',
+		}));
+		if (linkText !== undefined) {
+			const inner = new Token(linkText, config, true, accum, {
+				'Stage-5': ':', ConverterToken: ':',
+			});
+			inner.type = 'link-text';
+			this.insertAt(inner.setAttribute('stage', Parser.MAX_STAGE - 1));
+		}
+		this.#delimiter = delimiter;
+		this.getAttribute('protectChildren')(0);
+	}
+
+	/**
+	 * @override
+	 * @throws `Error` 非法的内链目标
+	 * @throws `Error` 不可更改命名空间
+	 */
+	afterBuild() {
+		const titleObj = this.normalizeTitle(this.firstChild.text(), 0, false, true, true);
+		this.setAttribute('name', titleObj.title);
+		this.#fragment = titleObj.fragment;
+		this.#encoded = titleObj.encoded;
+		if (this.#delimiter?.includes('\0')) {
+			this.#delimiter = this.getAttribute('buildFromStr')(this.#delimiter, 'string');
+		}
+		const /** @type {import('../../typings/event').AstListener} */ linkListener = (e, data) => {
+			const {prevTarget} = e;
+			if (prevTarget?.type === 'link-target') {
+				const name = prevTarget.text(),
+					{title, interwiki, ns, valid, fragment, encoded} = this.normalizeTitle(name, 0, false, true, true);
+				if (!valid) {
+					undo(e, data);
+					throw new Error(`非法的内链目标：${name}`);
+				} else if (this.type === 'category' && (interwiki || ns !== 14)
+					|| this.type === 'file' && (interwiki || ns !== 6)
+				) {
+					undo(e, data);
+					throw new Error(`${this.type === 'file' ? '文件' : '分类'}链接不可更改命名空间：${name}`);
+				} else if (this.type === 'link' && !interwiki && (ns === 6 || ns === 14) && name.trim()[0] !== ':') {
+					const /** @type {{firstChild: AstText}} */ {firstChild} = prevTarget;
+					if (firstChild.type === 'text') {
+						firstChild.insertData(0, ':');
+					} else {
+						prevTarget.prepend(':');
+					}
+				}
+				this.setAttribute('name', title);
+				this.#fragment = fragment;
+				this.#encoded = encoded;
+			}
+		};
+		this.addEventListener(['remove', 'insert', 'replace', 'text'], linkListener);
+	}
+
+	/**
+	 * @override
+	 * @template {string} T
+	 * @param {T} key 属性键
+	 * @param {import('../../typings/node').TokenAttribute<T>} value 属性值
+	 */
+	setAttribute(key, value) {
+		if (key === 'bracket') {
+			this.#bracket = Boolean(value);
+			return this;
+		}
+		return super.setAttribute(key, value);
+	}
+
+	/**
+	 * @override
+	 * @param {string} selector
+	 */
+	toString(selector) {
+		const str = super.toString(selector, this.#delimiter);
+		return this.#bracket && !(selector && this.matches(selector)) ? `[[${str}]]` : str;
+	}
+
+	/** @override */
+	text() {
+		const str = super.text('|');
+		return this.#bracket ? `[[${str}]]` : str;
+	}
+
+	/** @override */
+	getPadding() {
+		return 2;
+	}
+
+	/** @override */
+	getGaps() {
+		return this.#delimiter.length;
+	}
+
+	/** @override */
+	print() {
+		return super.print(this.#bracket ? {pre: '[[', post: ']]', sep: this.#delimiter} : {sep: this.#delimiter});
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = this.getAbsoluteIndex()) {
+		const errors = super.lint(start),
+			{childNodes: [target, linkText], type: linkType} = this;
+		let rect;
+		if (linkType === 'link' && target.childNodes.some(({type}) => type === 'template')) {
+			rect = {start, ...this.getRootNode().posFromIndex(start)};
+			errors.push(generateForChild(target, rect, 'template in an internal link target', 'warning'));
+		}
+		if (this.#encoded) {
+			rect ||= {start, ...this.getRootNode().posFromIndex(start)};
+			errors.push(generateForChild(target, rect, 'unnecessary URL encoding in an internal link'));
+		}
+		if (linkType === 'link' && linkText?.childNodes?.some(
+			/** @param {AstText} */ ({type, data}) => type === 'text' && data.includes('|'),
+		)) {
+			rect ||= {start, ...this.getRootNode().posFromIndex(start)};
+			errors.push(generateForChild(linkText, rect, 'additional "|" in the link text', 'warning'));
+		} else if (linkType !== 'link' && this.#fragment !== undefined) {
+			rect ||= {start, ...this.getRootNode().posFromIndex(start)};
+			errors.push(generateForChild(target, rect, 'useless fragment'));
+		}
+		return errors;
+	}
+
+	/** 生成Title对象 */
+	#getTitle() {
+		return this.normalizeTitle(this.firstChild.text(), 0, false, true, true);
+	}
+
+	/**
+	 * @override
+	 * @this {LinkToken & {constructor: typeof LinkToken}}
+	 */
+	cloneNode() {
+		const [link, ...linkText] = this.cloneChildNodes();
+		return Parser.run(() => {
+			const token = new this.constructor('', undefined, this.#getTitle(), this.getAttribute('config'));
+			token.firstChild.safeReplaceWith(link);
+			token.append(...linkText);
+			token.afterBuild();
+			return token;
+		});
+	}
+
+	/**
+	 * 设置链接目标
+	 * @param {string} link 链接目标
+	 * @throws `SyntaxError` 非法的链接目标
+	 */
+	setTarget(link) {
+		link = String(link);
+		if (this.type === 'link' && !/^\s*[:#]/u.test(link)) {
+			link = `:${link}`;
+		}
+		const root = Parser.parse(`[[${link}]]`, this.getAttribute('include'), 6, this.getAttribute('config')),
+			{length, firstChild: wikiLink} = root,
+			{type, firstChild, length: linkLength} = wikiLink;
+		if (length !== 1 || type !== this.type || linkLength !== 1) {
+			const msgs = {link: '内链', file: '文件链接', category: '分类'};
+			throw new SyntaxError(`非法的${msgs[this.type]}目标：${link}`);
+		}
+		wikiLink.destroy();
+		this.firstChild.safeReplaceWith(firstChild);
+	}
+
+	/**
+	 * 设置跨语言链接
+	 * @param {string} lang 语言前缀
+	 * @param {string} link 页面标题
+	 * @throws `SyntaxError` 非法的跨语言链接
+	 */
+	setLangLink(lang, link) {
+		if (typeof lang !== 'string') {
+			this.typeError('setLangLink', 'String');
+		}
+		link = String(link).trim();
+		const [char] = link;
+		if (char === '#') {
+			throw new SyntaxError('跨语言链接不能仅为fragment！');
+		} else if (char === ':') {
+			link = link.slice(1);
+		}
+		const root = Parser.parse(`[[${lang}:${link}]]`, this.getAttribute('include'), 6, this.getAttribute('config')),
+			/** @type {Token & {firstChild: LinkToken}} */ {length, firstChild: wikiLink} = root,
+			{type, length: linkLength, interwiki, firstChild} = wikiLink;
+		if (length !== 1 || type !== 'link' || linkLength !== 1 || interwiki !== lang.toLowerCase()) {
+			throw new SyntaxError(`非法的跨语言链接目标：${lang}:${link}`);
+		}
+		wikiLink.destroy();
+		this.firstChild.safeReplaceWith(firstChild);
+	}
+
+	/**
+	 * 设置fragment
+	 * @param {string} fragment fragment
+	 * @param {boolean} page 是否是其他页面
+	 * @throws `SyntaxError` 非法的fragment
+	 */
+	#setFragment(fragment, page = true) {
+		fragment &&= String(fragment).replace(/[<>[\]#|=]/gu, p => encodeURIComponent(p));
+		const include = this.getAttribute('include'),
+			config = this.getAttribute('config'),
+			root = Parser.parse(`[[${page ? `:${this.name}` : ''}${
+				fragment === undefined ? '' : `#${fragment}`
+			}]]`, include, 6, config),
+			{length, firstChild: wikiLink} = root,
+			{type, length: linkLength, firstChild} = wikiLink;
+		if (length !== 1 || type !== 'link' || linkLength !== 1) {
+			throw new SyntaxError(`非法的 fragment：${fragment}`);
+		} else if (page) {
+			Parser.warn(`${this.constructor.name}.setFragment 方法会同时规范化页面名！`);
+		}
+		wikiLink.destroy();
+		this.firstChild.safeReplaceWith(firstChild);
+	}
+
+	/**
+	 * 设置fragment
+	 * @param {string} fragment fragment
+	 */
+	setFragment(fragment) {
+		this.#setFragment(fragment);
+	}
+
+	/**
+	 * 修改为到自身的链接
+	 * @param {string} fragment fragment
+	 * @throws `RangeError` 空fragment
+	 */
+	asSelfLink(fragment = this.fragment) {
+		fragment &&= String(fragment);
+		if (!fragment?.trim()) {
+			throw new RangeError(`${this.constructor.name}.asSelfLink 方法必须指定非空的 fragment！`);
+		}
+		this.#setFragment(fragment, false);
+	}
+
+	/**
+	 * 设置链接显示文字
+	 * @param {string} linkText 链接显示文字
+	 * @throws `SyntaxError` 非法的链接显示文字
+	 */
+	setLinkText(linkText = '') {
+		linkText = String(linkText);
+		let lastChild;
+		const config = this.getAttribute('config');
+		if (linkText) {
+			const root = Parser.parse(`[[${
+					this.type === 'category' ? 'Category:' : ''
+				}L|${linkText}]]`, this.getAttribute('include'), 6, config),
+				{length, firstChild: wikiLink} = root;
+			if (length !== 1 || wikiLink.type !== this.type || wikiLink.length !== 2) {
+				throw new SyntaxError(`非法的${this.type === 'link' ? '内链文字' : '分类关键字'}：${noWrap(linkText)}`);
+			}
+			({lastChild} = wikiLink);
+		} else {
+			lastChild = Parser.run(() => new Token('', config));
+			lastChild.setAttribute('stage', 7).type = 'link-text';
+		}
+		if (this.length === 1) {
+			this.insertAt(lastChild);
+		} else {
+			this.lastChild.safeReplaceWith(lastChild);
+		}
+	}
+
+	/**
+	 * 自动生成管道符后的链接文字
+	 * @throws `Error` 带有"#"或"%"时不可用
+	 */
+	pipeTrick() {
+		const linkText = this.firstChild.text();
+		if (linkText.includes('#') || linkText.includes('%')) {
+			throw new Error('Pipe trick 不能用于带有"#"或"%"的场合！');
+		}
+		const m1 = /^:?(?:[ \w\x80-\xFF-]+:)?([^(]+)\(.+\)$/u.exec(linkText);
+		if (m1) {
+			this.setLinkText(m1[1].trim());
+			return;
+		}
+		const m2 = /^:?(?:[ \w\x80-\xFF-]+:)?([^（]+)（.+）$/u.exec(linkText);
+		if (m2) {
+			this.setLinkText(m2[1].trim());
+			return;
+		}
+		const m3 = /^:?(?:[ \w\x80-\xFF-]+:)?(.+?)(?:(?<!\()\(.+\))?(?:, |，|، )./u.exec(linkText);
+		if (m3) {
+			this.setLinkText(m3[1].trim());
+			return;
+		}
+		this.setLinkText(linkText);
+	}
+}
+
+Parser.classes.LinkToken = __filename;
+module.exports = LinkToken;

package/src/magicLink.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const {generateForChild} = require('../util/lint'),
+	Parser = require('..'),
+	Token = require('.');
+
+/**
+ * 自由外链
+ * @classdesc `{childNodes: [...AstText|CommentToken|IncludeToken|NoincludeToken]}`
+ */
+class MagicLinkToken extends Token {
+	type = 'free-ext-link';
+	#protocolRegex;
+
+	/** 协议 */
+	get protocol() {
+		return this.#protocolRegex.exec(this.text())?.[0];
+	}
+
+	set protocol(value) {
+		if (typeof value !== 'string') {
+			this.typeError('protocol', 'String');
+		} else if (!new RegExp(`${this.#protocolRegex.source}$`, 'iu').test(value)) {
+			throw new RangeError(`非法的外链协议：${value}`);
+		}
+		const {link} = this;
+		if (!this.#protocolRegex.test(link)) {
+			throw new Error(`特殊外链无法更改协议！${link}`);
+		}
+		this.replaceChildren(link.replace(this.#protocolRegex, value));
+	}
+
+	/** 和内链保持一致 */
+	get link() {
+		return this.text();
+	}
+
+	set link(url) {
+		this.setTarget(url);
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = this.getAbsoluteIndex()) {
+		const errors = super.lint(start),
+			source = `[，；。：！？（）]+${this.type === 'ext-link-url' ? '|\\|+' : ''}`,
+			regex = new RegExp(source, 'u'),
+			regexGlobal = new RegExp(source, 'gu');
+		let /** @type {{top: number, left: number}} */ rect;
+		for (const child of this.childNodes) {
+			const str = String(child);
+			if (child.type !== 'text' || !regex.test(str)) {
+				continue;
+			}
+			rect ||= {start, ...this.getRootNode().posFromIndex(start)};
+			const refError = generateForChild(child, rect, '', 'warning');
+			errors.push(...[...str.matchAll(regexGlobal)].map(({index, 0: {0: char, length}}) => {
+				const lines = str.slice(0, index).split('\n'),
+					{length: top} = lines,
+					{length: left} = lines.at(-1),
+					startIndex = start + index,
+					startLine = refError.startLine + top - 1,
+					startCol = (top > 1 ? 0 : refError.startCol) + left;
+				return {
+					...refError,
+					message: Parser.msg('$1 in URL', char === '|' ? '"|"' : Parser.msg('full-width punctuation')),
+					startIndex,
+					endIndex: startIndex + length,
+					startLine,
+					endLine: startLine,
+					startCol,
+					endCol: startCol + length,
+					excerpt: str.slice(Math.max(0, index - 25), index + 25),
+				};
+			}));
+		}
+		return errors;
+	}
+
+	/**
+	 * @param {string} url 网址
+	 * @param {boolean} doubleSlash 是否接受"//"作为协议
+	 * @param {import('../typings/token').accum} accum
+	 */
+	constructor(url, doubleSlash, 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 ? '|//' : ''})`, 'iu');
+	}
+
+	/** @override */
+	cloneNode() {
+		const cloned = this.cloneChildNodes();
+		return Parser.run(() => {
+			const token = new MagicLinkToken(undefined, this.type === 'ext-link-url', this.getAttribute('config'));
+			token.append(...cloned);
+			token.afterBuild();
+			return token;
+		});
+	}
+
+	/**
+	 * 获取网址
+	 * @throws `Error` 非标准协议
+	 */
+	getUrl() {
+		let url = this.text();
+		if (url.startsWith('//')) {
+			url = `https:${url}`;
+		}
+		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 含协议的网址
+	 * @throws `SyntaxError` 非法的自由外链目标
+	 */
+	setTarget(url) {
+		url = String(url);
+		const root = Parser.parse(url, this.getAttribute('include'), 9, this.getAttribute('config')),
+			{length, firstChild: freeExtLink} = root;
+		if (length !== 1 || freeExtLink.type !== 'free-ext-link') {
+			throw new SyntaxError(`非法的自由外链目标：${url}`);
+		}
+		this.replaceChildren(...freeExtLink.childNodes);
+	}
+
+	/** 是否是模板或魔术字参数 */
+	isParamValue() {
+		const ParameterToken = require('./parameter');
+		const /** @type {ParameterToken} */ parameter = this.closest('parameter');
+		return parameter?.getValue() === this.text();
+	}
+}
+
+Parser.classes.MagicLinkToken = __filename;
+module.exports = MagicLinkToken;

package/src/nested/choose.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Parser = require('../..'),
+	NestedToken = require('.');
+
+/**
+ * `<choose>`
+ * @classdesc `{childNodes: [...ExtToken|NoincludeToken]}`
+ */
+class ChooseToken extends NestedToken {
+	name = 'choose';
+
+	/**
+	 * @param {string|undefined} wikitext wikitext
+	 * @param {import('../../typings/token').accum} accum
+	 */
+	constructor(wikitext, config = Parser.getConfig(), accum = []) {
+		const regex = /<(option|choicetemplate)(\s[^>]*)?>(.*?)<\/(\1)>/gsu;
+		super(wikitext, regex, ['option', 'choicetemplate'], config, accum);
+	}
+}
+
+Parser.classes.ChooseToken = __filename;
+module.exports = ChooseToken;

package/src/nested/combobox.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Parser = require('../..'),
+	NestedToken = require('.');
+
+/**
+ * `<combobox>`
+ * @classdesc `{childNodes: [...ExtToken|NoincludeToken]}`
+ */
+class ComboboxToken extends NestedToken {
+	name = 'combobox';
+
+	/**
+	 * @param {string|undefined} wikitext wikitext
+	 * @param {import('../../typings/token').accum} accum
+	 */
+	constructor(wikitext, config = Parser.getConfig(), accum = []) {
+		super(wikitext, /<(combooption)(\s[^>]*)?>(.*?)<\/(combooption\s*)>/gisu, ['combooption'], config, accum);
+	}
+}
+
+Parser.classes.ComboboxToken = __filename;
+module.exports = ComboboxToken;

package/src/nested/index.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const {generateForChild} = require('../../util/lint'),
+	Parser = require('../..'),
+	Token = require('..'),
+	ExtToken = require('../tagPair/ext'),
+	NoincludeToken = require('../nowiki/noinclude'),
+	CommentToken = require('../nowiki/comment');
+
+/**
+ * 嵌套式的扩展标签
+ * @classdesc `{childNodes: [...ExtToken|NoincludeToken|CommentToken]}`
+ */
+class NestedToken extends Token {
+	type = 'ext-inner';
+	#tags;
+
+	/**
+	 * @param {string|undefined} wikitext wikitext
+	 * @param {RegExp} regex 内层正则
+	 * @param {string[]} tags 内层标签名
+	 * @param {import('../../typings/token').accum} accum
+	 */
+	constructor(wikitext, regex, tags, config = Parser.getConfig(), accum = []) {
+		const text = wikitext?.replace(
+			regex,
+			/** @type {function(...string): string} */ (comment, name, attr, inner, closing) => {
+				const str = `\0${accum.length + 1}${name ? 'e' : 'c'}\x7F`;
+				if (name) {
+					new ExtToken(name, attr, inner, closing, config, accum);
+				} else {
+					const closed = comment.endsWith('-->');
+					new CommentToken(comment.slice(4, closed ? -3 : undefined), closed, config, accum);
+				}
+				return str;
+			},
+		)?.replace(
+			/(?<=^|\0\d+[ce]\x7F)[^\0]+(?=$|\0\d+[ce]\x7F)/gu,
+			substr => {
+				new NoincludeToken(substr, config, accum);
+				return `\0${accum.length}c\x7F`;
+			},
+		);
+		super(text, config, true, accum, {
+			NoincludeToken: ':', ExtToken: ':',
+		});
+		this.#tags = tags;
+	}
+
+	/**
+	 * @override
+	 * @param {number} start 起始位置
+	 */
+	lint(start = this.getAbsoluteIndex()) {
+		let rect;
+		return [
+			...super.lint(start),
+			...this.childNodes.filter(child => {
+				if (child.type === 'ext' || child.type === 'comment') {
+					return false;
+				}
+				const str = String(child).trim();
+				return str && !/^<!--.*-->$/su.test(str);
+			}).map(child => {
+				rect ||= {start, ...this.getRootNode().posFromIndex(start)};
+				return generateForChild(child, rect, Parser.msg('invalid content in <$1>', this.name));
+			}),
+		];
+	}
+
+	/**
+	 * @override
+	 * @template {string|Token} T
+	 * @param {T} token 待插入的子节点
+	 * @param {number} i 插入位置
+	 */
+	insertAt(token, i = this.length) {
+		return token.type === 'ext' && !this.#tags.includes(token.name)
+			? this.typeError(`${this.constructor.name}只能以${this.#tags.join('或')}标签作为子节点！`)
+			: super.insertAt(token, i);
+	}
+
+	/** @override */
+	cloneNode() {
+		const cloned = this.cloneChildNodes(),
+			config = this.getAttribute('config');
+		return Parser.run(() => {
+			const token = new this.constructor(undefined, config);
+			token.append(...cloned);
+			return token;
+		});
+	}
+}
+
+Parser.classes.NestedToken = __filename;
+module.exports = NestedToken;

package/src/nested/references.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Parser = require('../..'),
+	NestedToken = require('.');
+
+/**
+ * `<references>`
+ * @classdesc `{childNodes: [...ExtToken|NoincludeToken|CommentToken]}`
+ */
+class ReferencesToken extends NestedToken {
+	name = 'references';
+
+	/**
+	 * @param {string|undefined} wikitext wikitext
+	 * @param {import('../../typings/token').accum} accum
+	 */
+	constructor(wikitext, config = Parser.getConfig(), accum = []) {
+		super(wikitext, /<!--.*?(?:-->|$)|<(ref)(\s[^>]*)?>(.*?)<\/(ref\s*)>/gisu, ['ref'], config, accum);
+	}
+}
+
+Parser.classes.ReferencesToken = __filename;
+module.exports = ReferencesToken;