wikiparser-node 0.1.0 → 0.2.2

package/src/converterFlags.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const /** @type {Parser} */ Parser = require('..'),
+	Token = require('.'),
+	AtomToken = require('./atom');
+
+/**
+ * 转换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, false, accum, {AtomToken: ':'});
+		this.append(...flags.map(flag => new AtomToken(flag, 'converter-flag', config, accum)));
+	}
+
+	cloneNode() {
+		const cloned = this.cloneChildren(),
+			token = Parser.run(() => new ConverterFlagsToken([], this.getAttribute('config')));
+		token.append(...cloned);
+		token.afterBuild();
+		return token;
+	}
+
+	/** @complexity `n` */
+	afterBuild() {
+		this.#flags = this.children.map(child => child.text().trim());
+		const that = this,
+			/** @type {AstListener} */ converterFlagsListener = ({prevTarget}) => {
+				if (prevTarget) {
+					that.#flags[that.childNodes.indexOf(prevTarget)] = prevTarget.text().trim();
+				}
+			};
+		this.addEventListener(['remove', 'insert', 'text', 'replace'], converterFlagsListener);
+		return this;
+	}
+
+	/**
+	 * @template {string} T
+	 * @param {T} key
+	 * @returns {TokenAttribute<T>}
+	 */
+	getAttribute(key) {
+		if (key === 'flags') {
+			return Parser.debugging ? this.#flags : [...this.#flags];
+		}
+		return super.getAttribute(key);
+	}
+
+	/**
+	 * @param {number} i
+	 * @complexity `n`
+	 */
+	removeAt(i) {
+		const /** @type {AtomToken} */ token = super.removeAt(i);
+		this.#flags?.splice(i, 1);
+		return token;
+	}
+
+	/**
+	 * @param {AtomToken} token
+	 * @complexity `n`
+	 */
+	insertAt(token, i = this.childNodes.length) {
+		super.insertAt(token, i);
+		this.#flags?.splice(i, 0, token.text());
+		return token;
+	}
+
+	toString() {
+		return super.toString(';');
+	}
+
+	getGaps() {
+		return 1;
+	}
+
+	text() {
+		return super.text(';');
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		return [];
+	}
+
+	/**
+	 * @param {string} flag
+	 * @returns {AtomToken[]}
+	 * @complexity `n`
+	 */
+	getFlagToken(flag) {
+		return this.#flags.includes(flag) ? this.children.filter(child => child.text().trim() === flag) : [];
+	}
+
+	getAllFlags() {
+		return new Set(this.#flags);
+	}
+
+	/** @complexity `n` */
+	getEffectiveFlags() {
+		const {variants} = this.getAttribute('config'),
+			variantFlags = this.#flags.filter(flag => variants.includes(flag)),
+			unknownFlags = this.#flags.filter(flag => /{{.+}}/.test(flag));
+		if (variantFlags.length) {
+			return new Set([...variantFlags, ...unknownFlags]);
+		}
+		const validFlags = ['A', 'T', 'R', 'D', '-', 'H', 'N'],
+			flags = new Set([...this.#flags.filter(flag => validFlags.includes(flag)), ...unknownFlags]);
+		if (flags.size === 0) {
+			return new Set('S');
+		} else if (flags.has('R')) {
+			return new Set('R');
+		} else if (flags.has('N')) {
+			return new Set('N');
+		} else if (flags.has('-')) {
+			return new Set('-');
+		} else if (flags.has('H')) {
+			const hasT = flags.has('T'),
+				hasD = flags.has('D');
+			if (hasT && hasD) {
+				return new Set(['+', 'H', 'T', 'D']);
+			}
+			return new Set(['+', 'H', ...hasT ? ['T'] : [], ...hasD ? ['D'] : [], ...unknownFlags]);
+		}
+		if (flags.size === 1 && flags.has('T')) {
+			flags.add('H');
+		}
+		if (flags.has('A')) {
+			flags.add('+');
+			flags.add('S');
+		}
+		if (flags.has('D')) {
+			flags.delete('S');
+		}
+		return flags;
+	}
+
+	/** @complexity `n` */
+	getUnknownFlags() {
+		return [...this.getFlags()].filter(flag => /{{.+}}/.test(flag));
+	}
+
+	/** @param {string} flag */
+	hasFlag(flag) {
+		if (typeof flag !== 'string') {
+			this.typeError('hasFlag', 'String');
+		}
+		return this.#flags.includes(flag);
+	}
+
+	/**
+	 * @param {string} flag
+	 * @complexity `n`
+	 */
+	hasEffectiveFlag(flag) {
+		if (typeof flag !== 'string') {
+			this.typeError('hasFlag', 'String');
+		}
+		return this.getEffectiveFlags().has(flag);
+	}
+
+	/**
+	 * @param {string} flag
+	 * @complexity `n²`
+	 */
+	removeFlag(flag) {
+		for (const token of this.getFlagToken(flag)) {
+			token.remove();
+		}
+	}
+
+	/**
+	 * @param {string} flag
+	 * @complexity `n`
+	 */
+	#newFlag(flag) {
+		const token = Parser.run(() => new AtomToken(flag, 'converter-flag', this.getAttribute('config')));
+		this.appendChild(token);
+	}
+
+	/**
+	 * @param {string} flag
+	 * @complexity `n`
+	 */
+	setFlag(flag) {
+		if (!this.#flags.includes(flag)) {
+			this.#newFlag(flag);
+		} else if (!this.getEffectiveFlags().has(flag)) {
+			Parser.error('此 flag 不会生效', flag);
+		}
+	}
+
+	/**
+	 * @param {string} flag
+	 * @complexity `n²`
+	 */
+	toggleFlag(flag) {
+		if (!this.#flags.includes(flag)) {
+			this.#newFlag(flag);
+		} else {
+			this.removeFlag(flag);
+		}
+	}
+}
+
+Parser.classes.ConverterFlagsToken = __filename;
+module.exports = ConverterFlagsToken;

package/src/converterRule.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const {undo} = require('../util/debug'),
+	{noWrap} = require('../util/string'),
+	/** @type {Parser} */ Parser = require('..'),
+	Token = require('.'),
+	AtomToken = require('./atom');
+
+/**
+ * 转换规则
+ * @classdesc `{childNodes: ...AtomToken)}`
+ */
+class ConverterRuleToken extends Token {
+	type = 'converter-rule';
+	variant = '';
+	unidirectional = false;
+	bidirectional = false;
+
+	/**
+	 * @param {string} rule
+	 * @param {accum} accum
+	 */
+	constructor(rule, hasColon = true, config = Parser.getConfig(), accum = []) {
+		super(undefined, config, true, accum, {AtomToken: ':'});
+		if (!hasColon) {
+			super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
+		} else {
+			const i = rule.indexOf(':'),
+				j = rule.slice(0, i).indexOf('=>'),
+				v = (j === -1 ? rule.slice(0, i) : rule.slice(j + 2, i)).trim(),
+				{variants} = config;
+			if (!variants.includes(v)) {
+				super.insertAt(new AtomToken(rule, 'converter-rule-noconvert', config, accum));
+			} else {
+				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) {
+					this.bidirectional = true;
+				} else {
+					super.insertAt(new AtomToken(rule.slice(0, j), 'converter-rule-from', config, accum), 0);
+					this.unidirectional = true;
+				}
+			}
+		}
+		this.seal(['variant', 'unidirectional', 'bidirectional']);
+	}
+
+	cloneNode() {
+		const cloned = this.cloneChildren(),
+			placeholders = ['', ':', '=>:'],
+			placeholder = placeholders[cloned.length - 1],
+			token = Parser.run(() => new ConverterRuleToken(placeholder, placeholder, this.getAttribute('config')));
+		for (let i = 0; i < cloned.length; i++) {
+			token.children[i].safeReplaceWith(cloned[i]);
+		}
+		token.afterBuild();
+		return token;
+	}
+
+	afterBuild() {
+		if (this.childNodes.length > 1) {
+			this.setAttribute('variant', this.children.at(-2).text().trim());
+		}
+		const that = this,
+			/** @type {AstListener} */ converterRuleListener = (e, data) => {
+				const {childNodes} = that,
+					{prevTarget} = e;
+				if (childNodes.length > 1 && childNodes.at(-2) === prevTarget) {
+					const v = prevTarget.text().trim(),
+						{variants} = that.getAttribute('config');
+					if (variants.includes(v)) {
+						that.setAttribute('variant', v);
+					} else {
+						undo(e, data);
+						throw new Error(`无效的语言变体：${v}`);
+					}
+				}
+			};
+		this.addEventListener(['remove', 'insert', 'text', 'replace'], converterRuleListener);
+		return this;
+	}
+
+	/**
+	 * @param {number} i
+	 * @returns {AtomToken}
+	 */
+	removeAt(i) {
+		if (i !== 0 && i !== -this.childNodes.length) {
+			throw new RangeError(`${this.constructor.name} 禁止移除第 ${i} 个子节点！`);
+		}
+		return super.removeAt(i);
+	}
+
+	insertAt() {
+		throw new Error('转换规则语法复杂，请勿尝试手动插入子节点！');
+	}
+
+	/** @returns {string} */
+	toString() {
+		if (this.childNodes.length === 3) {
+			const [from, variant, to] = this.children;
+			return `${from.toString()}=>${variant.toString()}:${to.toString()}`;
+		}
+		return super.toString(':');
+	}
+
+	/** @param {number} i */
+	getGaps(i = 0) {
+		const {length} = this.childNodes;
+		i = i < 0 ? i + length : i;
+		return i === 0 && length === 3 ? 2 : 1;
+	}
+
+	/** @returns {string} */
+	text() {
+		if (this.childNodes.length === 3) {
+			const [from, variant, to] = this.children;
+			return `${from.text()}=>${variant.text()}:${to.text()}`;
+		}
+		return super.text(':');
+	}
+
+	/** @returns {[number, string][]} */
+	plain() {
+		const {firstElementChild, lastElementChild, unidirectional} = this;
+		if (unidirectional) {
+			return [...firstElementChild.plain(), ...lastElementChild.plain()];
+		}
+		return lastElementChild.plain();
+	}
+
+	noConvert() {
+		for (let i = this.childNodes.length - 2; i >= 0; i--) {
+			super.removeAt(i);
+		}
+		this.setAttribute('unidirectional', false).setAttribute('bidirectional', false).setAttribute('variant', '');
+	}
+
+	/** @param {string} to */
+	setTo(to) {
+		to = String(to);
+		const config = this.getAttribute('config'),
+			root = Parser.parse(`-{|${config.variants[0]}:${to}}-`, this.getAttribute('include'), undefined, config),
+			{childNodes: {length}, firstElementChild} = root;
+		if (length !== 1 || firstElementChild.type !== 'converter' || firstElementChild.childNodes.length !== 2
+			|| firstElementChild.lastElementChild.childNodes.length !== 2
+		) {
+			throw new SyntaxError(`非法的转换目标：${noWrap(to)}`);
+		}
+		const {lastChild} = firstElementChild.lastElementChild;
+		firstElementChild.lastElementChild.removeAt(0);
+		this.lastElementChild.safeReplaceWith(lastChild);
+	}
+
+	/** @param {string} variant */
+	setVariant(variant) {
+		if (typeof variant !== 'string') {
+			this.typeError('setVariant', 'String');
+		}
+		const config = this.getAttribute('config'),
+			v = variant.trim();
+		if (!config.variants.includes(v)) {
+			throw new RangeError(`无效的语言变体：${v}`);
+		} else if (this.childNodes.length === 1) {
+			super.insertAt(Parser.run(() => new AtomToken(variant, 'converter-rule-variant', config)), 0);
+			this.setAttribute('bidirectional', true);
+		} else {
+			this.children.at(-2).setText(variant);
+		}
+		this.setAttribute('variant', v);
+	}
+
+	/** @param {string} from */
+	setFrom(from) {
+		const {variant} = this;
+		if (!variant) {
+			throw new Error('请先指定语言变体！');
+		}
+		from = String(from);
+		const config = this.getAttribute('config'),
+			root = Parser.parse(`-{|${from}=>${variant}:}-`, this.getAttribute('include'), undefined, config),
+			{childNodes: {length}, firstElementChild} = root;
+		if (length !== 1 || firstElementChild.type !== 'converter' || firstElementChild.childNodes.length !== 2
+			|| firstElementChild.lastElementChild.childNodes.length !== 3
+		) {
+			throw new SyntaxError(`非法的转换原文：${noWrap(from)}`);
+		}
+		if (this.unidirectional) {
+			this.firstElementChild.safeReplaceWith(firstElementChild.lastElementChild.firstChild);
+		} else {
+			super.insertAt(firstElementChild.lastElementChild.firstChild, 0);
+			this.setAttribute('unidirectional', true).setAttribute('bidirectional', false);
+		}
+	}
+
+	/** @param {string} from */
+	makeUnidirectional(from) {
+		this.setFrom(from);
+	}
+
+	makeBidirectional() {
+		if (this.unidirectional) {
+			super.removeAt(0);
+			this.setAttribute('unidirectional', false).setAttribute('bidirectional', true);
+		}
+	}
+}
+
+Parser.classes.ConverterRuleToken = __filename;
+module.exports = ConverterRuleToken;

package/src/extLink.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const {noWrap} = require('../util/string'),
+const {noWrap, normalizeSpace} = require('../util/string'),
 	/** @type {Parser} */ Parser = require('..'),
 	Token = require('.'),
 	MagicLinkToken = require('./magicLink');
@@ -33,9 +33,9 @@ class ExtLinkToken extends Token {
 		this.appendChild(new MagicLinkToken(url, true, config, accum));
 		this.#space = space;
 		if (text) {
-			const inner = new Token(text, config, true, accum);
+			const inner = new Token(text, config, true, accum, {'Stage-7': ':', ConverterToken: ':'});
 			inner.type = 'ext-link-text';
-			this.appendChild(inner.setAttribute('stage', 8));
+			this.appendChild(inner.setAttribute('stage', Parser.MAX_STAGE - 1));
 		}
 		this.protectChildren(0);
 	}
@@ -50,9 +50,9 @@ class ExtLinkToken extends Token {
 	}
 
 	#correct() {
-		if (!this.#space
+		if (!this.#space && this.childNodes.length > 1
 			// 都替换成`<`肯定不对，但无妨
-			&& /^[^[\]<>"\x00-\x20\x7f\p{Zs}\ufffd]/u.test(this.children[1]?.text().replace(/&[lg]t;/, '<'))
+			&& /^[^[\]<>"{\x00-\x20\x7f\p{Zs}\ufffd]/u.test(this.lastElementChild.text().replace(/&[lg]t;/, '<'))
 		) {
 			this.#space = ' ';
 		}
@@ -60,7 +60,7 @@ class ExtLinkToken extends Token {
 
 	toString() {
 		this.#correct();
-		return `[${this.firstElementChild.toString()}${this.#space}${this.children[1]?.toString() ?? ''}]`;
+		return `[${this.firstElementChild.toString()}${this.#space}${normalizeSpace(this.children[1])}]`;
 	}
 
 	getPadding() {
@@ -74,7 +74,7 @@ class ExtLinkToken extends Token {
 	}
 
 	text() {
-		return `[${super.text(' ')}]`;
+		return `[${super.text(' ').replaceAll('\n', ' ')}]`;
 	}
 
 	/**
@@ -82,7 +82,7 @@ class ExtLinkToken extends Token {
 	 * @complexity `n`
 	 */
 	plain() {
-		return this.childElementCount === 1 ? [] : this.lastElementChild.plain();
+		return this.childNodes.length === 1 ? [] : this.lastElementChild.plain();
 	}
 
 	/** @this {ExtLinkToken & {firstElementChild: MagicLinkToken}} */
@@ -95,7 +95,7 @@ class ExtLinkToken extends Token {
 		url = String(url);
 		const root = Parser.parse(`[${url}]`, this.getAttribute('include'), 8, this.getAttribute('config')),
 			{childNodes: {length}, firstElementChild} = root;
-		if (length !== 1 || firstElementChild?.type !== 'ext-link' || firstElementChild.childElementCount !== 1) {
+		if (length !== 1 || firstElementChild?.type !== 'ext-link' || firstElementChild.childNodes.length !== 1) {
 			throw new SyntaxError(`非法的外链目标：${url}`);
 		}
 		const {firstChild} = firstElementChild;
@@ -109,14 +109,14 @@ class ExtLinkToken extends Token {
 		text = String(text);
 		const root = Parser.parse(`[//url ${text}]`, this.getAttribute('include'), 8, this.getAttribute('config')),
 			{childNodes: {length}, firstElementChild} = root;
-		if (length !== 1 || firstElementChild?.type !== 'ext-link' || firstElementChild.childElementCount !== 2) {
+		if (length !== 1 || firstElementChild?.type !== 'ext-link' || firstElementChild.childNodes.length !== 2) {
 			throw new SyntaxError(`非法的外链文字：${noWrap(text)}`);
 		}
 		const {lastChild} = firstElementChild;
-		if (this.childElementCount === 1) {
+		if (this.childNodes.length === 1) {
 			this.appendChild(lastChild);
 		} else {
-			this.lastElementChild.replaceWith(lastChild);
+			this.lastElementChild.safeReplaceWith(lastChild);
 		}
 		this.#space ||= ' ';
 	}

package/src/imageParameter.js

@@ -213,7 +213,7 @@ class ImageParameterToken extends Token {
 			{childNodes: {length}, firstElementChild} = root,
 			param = firstElementChild?.lastElementChild;
 		if (length !== 1 || !firstElementChild?.matches('file#File:F')
-			|| firstElementChild.childElementCount !== 2 || param.name !== this.name
+			|| firstElementChild.childNodes.length !== 2 || param.name !== this.name
 		) {
 			throw new SyntaxError(`非法的 ${this.name} 参数：${noWrap(value)}`);
 		}

package/src/index.js

@@ -38,6 +38,7 @@
  * q: QuoteToken
  * w: ExtLinkToken
  * d: ListToken
+ * v: ConverterToken
  */
 
 const {externalUse} = require('../util/debug'),
@@ -50,11 +51,8 @@ const {externalUse} = require('../util/debug'),
 class Token extends AstElement {
 	type = 'root';
 	/** 解析阶段，参见顶部注释。只对plain Token有意义。 */ #stage = 0;
-	/** @type {ParserConfig} */ #config;
-	/**
-	 * 这个数组起两个作用：1. 数组中的Token会在build时替换`/\x00\d+.\x7f/`标记；2. 数组中的Token会依次执行parseOnce和build方法。
-	 * @type {accum}
-	 */
+	#config;
+	/** 这个数组起两个作用：1. 数组中的Token会在build时替换`/\x00\d+.\x7f/`标记；2. 数组中的Token会依次执行parseOnce和build方法。 */
 	#accum;
 	/** @type {Record<string, Ranges>} */ #acceptable;
 	#protectedChildren = new Ranges();
@@ -70,7 +68,9 @@ class Token extends AstElement {
 		if (typeof wikitext === 'string') {
 			this.appendChild(halfParsed ? wikitext : wikitext.replace(/[\x00\x7f]/g, ''));
 		}
-		this.setAttribute('config', config).setAttribute('accum', accum).setAttribute('acceptable', acceptable);
+		this.#config = config;
+		this.#accum = accum;
+		this.setAttribute('acceptable', acceptable);
 		accum.push(this);
 	}
 
@@ -202,9 +202,13 @@ class Token extends AstElement {
 	 * @complexity `n`
 	 */
 	removeAt(i) {
+		if (typeof i !== 'number') {
+			this.typeError('removeAt', 'Number');
+		}
+		const iPos = i < 0 ? i + this.childNodes.length : i;
 		if (!Parser.running) {
 			const protectedIndices = this.#protectedChildren.applyTo(this.childNodes);
-			if (protectedIndices.includes(i)) {
+			if (protectedIndices.includes(iPos)) {
 				throw new Error(`${this.constructor.name} 的第 ${i} 个子节点不可移除！`);
 			} else if (this.#acceptable) {
 				const acceptableIndices = Object.fromEntries(
@@ -450,6 +454,7 @@ class Token extends AstElement {
 				this.#parseList();
 				break;
 			case 10:
+				this.#parseConverter();
 				// no default
 		}
 		if (this.type === 'root') {
@@ -528,25 +533,21 @@ class Token extends AstElement {
 		return n ? this.build().afterBuild() : this;
 	}
 
-	/** @this {Token & {firstChild: string}} */
 	#parseCommentAndExt(includeOnly = false) {
 		const parseCommentAndExt = require('../parser/commentAndExt');
 		this.setText(parseCommentAndExt(this.firstChild, this.#config, this.#accum, includeOnly));
 	}
 
-	/** @this {Token & {firstChild: string}} */
 	#parseBrackets() {
 		const parseBrackets = require('../parser/brackets');
 		this.setText(parseBrackets(this.firstChild, this.#config, this.#accum));
 	}
 
-	/** @this {Token & {firstChild: string}} */
 	#parseHtml() {
 		const parseHtml = require('../parser/html');
 		this.setText(parseHtml(this.firstChild, this.#config, this.#accum));
 	}
 
-	/** @this {Token & {firstChild: string}} */
 	#parseTable() {
 		const parseTable = require('../parser/table'),
 			TableToken = require('./table');
@@ -565,13 +566,11 @@ class Token extends AstElement {
 		}
 	}
 
-	/** @this {Token & {firstChild: string}} */
 	#parseHrAndDoubleUndescore() {
 		const parseHrAndDoubleUnderscore = require('../parser/hrAndDoubleUnderscore');
 		this.setText(parseHrAndDoubleUnderscore(this.firstChild, this.#config, this.#accum));
 	}
 
-	/** @this {Token & {firstChild: string}} */
 	#parseLinks() {
 		const parseLinks = require('../parser/links');
 		this.setText(parseLinks(this.firstChild, this.#config, this.#accum));
@@ -587,26 +586,30 @@ class Token extends AstElement {
 		this.setText(lines.join('\n'));
 	}
 
-	/** @this {Token & {firstChild: string}} */
 	#parseExternalLinks() {
 		const parseExternalLinks = require('../parser/externalLinks');
 		this.setText(parseExternalLinks(this.firstChild, this.#config, this.#accum));
 	}
 
-	/** @this {Token & {firstChild: string}} */
 	#parseMagicLinks() {
 		const parseMagicLinks = require('../parser/magicLinks');
 		this.setText(parseMagicLinks(this.firstChild, this.#config, this.#accum));
 	}
 
+	/** @this {Token & {firstChild: string}} */
 	#parseList() {
 		const parseList = require('../parser/list'),
 			lines = this.firstChild.split('\n');
-		for (let i = 0; i < lines.length; i++) {
+		for (let i = this.type === 'root' ? 0 : 1; i < lines.length; i++) {
 			lines[i] = parseList(lines[i], this.#config, this.#accum);
 		}
 		this.setText(lines.join('\n'));
 	}
+
+	#parseConverter() {
+		const parseConverter = require('../parser/converter');
+		this.setText(parseConverter(this.firstChild, this.#config, this.#accum));
+	}
 }
 
 Parser.classes.Token = __filename;

package/src/link/category.js

@@ -37,6 +37,7 @@ class CategoryToken extends LinkToken {
 			}
 		};
 		this.addEventListener(['remove', 'insert', 'replace', 'text'], categoryListener);
+		return this;
 	}
 
 	#updateSortkey() {

package/src/link/file.js

@@ -84,7 +84,7 @@ class FileToken extends LinkToken {
 	 * @param {ImageParameterToken} token
 	 * @complexity `n`
 	 */
-	insertAt(token, i = this.childElementCount) {
+	insertAt(token, i = this.childNodes.length) {
 		if (!Parser.running) {
 			this.getArgs(token.name, false, false).add(token);
 			this.#keys.add(token.name);
@@ -221,7 +221,7 @@ class FileToken extends LinkToken {
 			root = Parser.parse(wikitext, this.getAttribute('include'), 6, config),
 			{childNodes: {length}, firstElementChild} = root;
 		if (length !== 1 || !firstElementChild?.matches('file#File:F')
-			|| firstElementChild.childElementCount !== 2 || firstElementChild.lastElementChild.name !== key
+			|| firstElementChild.childNodes.length !== 2 || firstElementChild.lastElementChild.name !== key
 		) {
 			throw new SyntaxError(`非法的 ${key} 参数：${noWrap(value)}`);
 		}