wikiparser-node 1.4.2-b → 1.4.2

package/dist/src/transclude.js

@@ -0,0 +1,715 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranscludeToken = void 0;
+const string_1 = require("../util/string");
+const lint_1 = require("../util/lint");
+const debug_1 = require("../util/debug");
+const constants_1 = require("../util/constants");
+const index_1 = require("../index");
+const index_2 = require("./index");
+const parameter_1 = require("./parameter");
+const atom_1 = require("./atom");
+const syntax_1 = require("./syntax");
+const insensitiveVars = new Set([
+    'pageid',
+    'articlepath',
+    'server',
+    'servername',
+    'scriptpath',
+    'stylepath',
+]);
+/**
+ * 模板或魔术字
+ * @classdesc `{childNodes: [AtomToken|SyntaxToken, ...AtomToken, ...ParameterToken]}`
+ */
+class TranscludeToken extends index_2.Token {
+    type = 'template';
+    /* NOT FOR BROWSER END */
+    modifier = '';
+    #raw = false;
+    #args = new Map();
+    /* NOT FOR BROWSER */
+    #keys = new Set();
+    /* NOT FOR BROWSER */
+    /** 是否存在重复参数 */
+    get duplication() {
+        return this.isTemplate() && Boolean(this.hasDuplicatedArgs());
+    }
+    set duplication(duplication) {
+        if (this.duplication && !duplication) {
+            this.fixDuplication();
+        }
+    }
+    /* NOT FOR BROWSER END */
+    /**
+     * @param title 模板标题或魔术字
+     * @param parts 参数各部分
+     * @throws `SyntaxError` 非法的模板名称
+     */
+    constructor(title, parts, config = index_1.default.getConfig(), accum = []) {
+        super(undefined, config, accum, {
+            AtomToken: 0, SyntaxToken: 0, ParameterToken: '1:',
+        });
+        /* NOT FOR BROWSER */
+        this.seal('modifier');
+        /* NOT FOR BROWSER END */
+        const { parserFunction: [insensitive, sensitive] } = config, argSubst = /^(?:\s|\0\d+c\x7F)*\0\d+s\x7F/u.exec(title)?.[0];
+        if (argSubst) {
+            this.setAttribute('modifier', argSubst);
+            title = title.slice(argSubst.length);
+        }
+        else if (title.includes(':')) {
+            const [modifier, ...arg] = title.split(':'), [mt] = /^(?:\s|\0\d+c\x7F)*/u.exec(arg[0] ?? '');
+            if (this.setModifier(`${modifier}:${mt}`)) {
+                title = arg.join(':').slice(mt.length);
+            }
+        }
+        const isFunction = title.includes(':');
+        if (isFunction || parts.length === 0 && !this.#raw) {
+            const [magicWord, ...arg] = title.split(':'), cleaned = (0, string_1.removeComment)(magicWord), name = cleaned[arg.length > 0 ? 'trimStart' : 'trim'](), lcName = name.toLowerCase(), canonicalName = insensitive[lcName], isSensitive = sensitive.includes(name), isVar = isSensitive || insensitiveVars.has(canonicalName);
+            if (isVar || isFunction && canonicalName) {
+                this.setAttribute('name', canonicalName ?? lcName);
+                this.type = 'magic-word';
+                const pattern = new RegExp(`^\\s*${name}\\s*$`, isSensitive ? 'u' : 'iu'), token = new syntax_1.SyntaxToken(magicWord, pattern, 'magic-word-name', config, accum, {
+                    'Stage-1': ':', '!ExtToken': '',
+                });
+                super.insertAt(token);
+                if (arg.length > 0) {
+                    parts.unshift([arg.join(':')]);
+                }
+                if (this.name === 'invoke') {
+                    /* NOT FOR BROWSER */
+                    this.setAttribute('acceptable', { SyntaxToken: 0, AtomToken: '1:3', ParameterToken: '3:' });
+                    /* NOT FOR BROWSER END */
+                    for (let i = 0; i < 2; i++) {
+                        const part = parts.shift();
+                        if (!part) {
+                            break;
+                        }
+                        const invoke = new atom_1.AtomToken(part.join('='), `invoke-${i ? 'function' : 'module'}`, config, accum, { 'Stage-1': ':', '!ExtToken': '' });
+                        super.insertAt(invoke);
+                    }
+                    /* NOT FOR BROWSER */
+                    this.protectChildren('1:3');
+                }
+            }
+        }
+        if (this.type === 'template') {
+            const name = (0, string_1.removeComment)((0, string_1.decodeHtml)(title)).split('#')[0].trim();
+            if (!name || /^:[\s_]*:|\0\d+[eh!+-]\x7F|[<>[\]{}\n]|%[\da-f]{2}/iu.test(name)) {
+                accum.pop();
+                /* NOT FOR BROWSER */
+                index_1.default.debug(`非法的模板名称：${(0, string_1.noWrap)(name)}`);
+                /* NOT FOR BROWSER END */
+                throw new SyntaxError('非法的模板名称');
+            }
+            const token = new atom_1.AtomToken(title, 'template-name', config, accum, {
+                'Stage-2': ':', '!HeadingToken': '',
+            });
+            super.insertAt(token);
+        }
+        const templateLike = this.isTemplate();
+        let i = 1;
+        for (let j = 0; j < parts.length; j++) {
+            const part = parts[j];
+            if (!templateLike && !(this.name === 'switch' && j > 0)) {
+                part[0] = part.join('=');
+                part.length = 1;
+            }
+            if (part.length === 1) {
+                part.unshift(i);
+                i++;
+            }
+            // @ts-expect-error abstract class
+            this.insertAt(new parameter_1.ParameterToken(...part, config, accum));
+        }
+        /* NOT FOR BROWSER */
+        this.protectChildren(0);
+    }
+    /**
+     * 设置引用修饰符
+     * @param modifier 引用修饰符
+     */
+    setModifier(modifier) {
+        const { parserFunction: [, , raw, subst] } = this.getAttribute('config'), lcModifier = (0, string_1.removeComment)(modifier).trim();
+        if (modifier && !lcModifier.endsWith(':')) {
+            return false;
+        }
+        const magicWord = lcModifier.slice(0, -1).toLowerCase(), isRaw = raw.includes(magicWord), isSubst = subst.includes(magicWord);
+        if (this.#raw && isRaw
+            || !this.#raw && (isSubst || modifier === '')
+            || (debug_1.Shadow.running || this.length > 1) && (isRaw || isSubst || modifier === '')) {
+            this.setAttribute('modifier', modifier);
+            this.#raw = isRaw;
+            return Boolean(modifier);
+        }
+        return false;
+    }
+    /** 是否是模板或模块 */
+    isTemplate() {
+        return this.type === 'template' || this.name === 'invoke';
+    }
+    /** 获取模板或模块名 */
+    #getTitle() {
+        const isTemplate = this.type === 'template', child = this.childNodes[isTemplate ? 0 : 1];
+        return this.normalizeTitle(child.text(), isTemplate ? 10 : 828);
+    }
+    /** @private */
+    afterBuild() {
+        if (this.modifier.includes('\0')) {
+            this.setAttribute('modifier', this.buildFromStr(this.modifier, constants_1.BuildMethod.String));
+        }
+        /* NOT FOR BROWSER */
+        if (this.isTemplate()) {
+            const isTemplate = this.type === 'template';
+            if (isTemplate || this.length > 1) {
+                this.setAttribute(isTemplate ? 'name' : 'module', this.#getTitle().title);
+            }
+            /**
+             * 当事件bubble到`parameter`时，将`oldKey`和`newKey`保存进AstEventData。
+             * 当继续bubble到`template`时，处理并删除`oldKey`和`newKey`。
+             * @implements
+             */
+            const transcludeListener = (e, data) => {
+                const { prevTarget } = e, { oldKey, newKey } = data;
+                if (typeof oldKey === 'string') {
+                    delete data.oldKey;
+                    delete data.newKey;
+                }
+                if (prevTarget === this.firstChild && isTemplate
+                    || prevTarget === this.childNodes[1] && !isTemplate && this.name === 'invoke') {
+                    this.setAttribute(isTemplate ? 'name' : 'module', this.#getTitle().title);
+                }
+                else if (oldKey !== newKey && prevTarget instanceof parameter_1.ParameterToken) {
+                    const oldArgs = this.getArgs(oldKey, false, false);
+                    oldArgs.delete(prevTarget);
+                    this.getArgs(newKey, false, false).add(prevTarget);
+                    this.#keys.add(newKey);
+                    if (oldArgs.size === 0) {
+                        this.#keys.delete(oldKey);
+                    }
+                }
+            };
+            this.addEventListener(['remove', 'insert', 'replace', 'text'], transcludeListener);
+        }
+    }
+    /** @private */
+    toString() {
+        return `{{${this.modifier}${this.type === 'magic-word'
+            ? `${String(this.firstChild)}${this.length === 1 ? '' : ':'}${this.childNodes.slice(1).map(String).join('|')}`
+            : super.toString('|')}}}`;
+    }
+    /** @override */
+    text() {
+        const { childNodes, length, firstChild, modifier, type, name } = this;
+        return type === 'magic-word' && name === 'vardefine'
+            ? ''
+            : `{{${modifier}${type === 'magic-word'
+                ? `${firstChild.text()}${length === 1 ? '' : ':'}${(0, string_1.text)(childNodes.slice(1), '|')}`
+                : super.text('|')}}}`;
+    }
+    /** @private */
+    getAttribute(key) {
+        switch (key) {
+            case 'padding':
+                return this.modifier.length + 2;
+            /* NOT FOR BROWSER */
+            case 'args':
+                return new Map(this.#args);
+            case 'keys':
+                return this.#keys;
+            /* NOT FOR BROWSER END */
+            default:
+                return super.getAttribute(key);
+        }
+    }
+    /** @private */
+    getGaps() {
+        return 1;
+    }
+    /** @override */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start), { type, childNodes, length } = this;
+        let rect;
+        if (!this.isTemplate()) {
+            return errors;
+        }
+        const title = this.#getTitle();
+        if (title.fragment !== undefined) {
+            rect = { start, ...this.getRootNode().posFromIndex(start) };
+            errors.push((0, lint_1.generateForChild)(childNodes[type === 'template' ? 0 : 1], rect, 'useless fragment'));
+        }
+        if (!title.valid) {
+            rect ??= { start, ...this.getRootNode().posFromIndex(start) };
+            errors.push((0, lint_1.generateForChild)(childNodes[1], rect, 'illegal module name'));
+        }
+        if (type === 'magic-word' && length === 2) {
+            rect ??= { start, ...this.getRootNode().posFromIndex(start) };
+            errors.push((0, lint_1.generateForSelf)(this, rect, 'missing module function'));
+            return errors;
+        }
+        const duplicatedArgs = this.getDuplicatedArgs();
+        if (duplicatedArgs.length > 0) {
+            rect ??= { start, ...this.getRootNode().posFromIndex(start) };
+            errors.push(...duplicatedArgs.flatMap(([, args]) => args).map(arg => (0, lint_1.generateForChild)(arg, rect, 'duplicated parameter')));
+        }
+        return errors;
+    }
+    /**
+     * 处理匿名参数更改
+     * @param addedToken 新增的参数
+     */
+    #handleAnonArgChange(addedToken) {
+        const args = this.getAnonArgs(), added = typeof addedToken !== 'number';
+        /* NOT FOR BROWSER */
+        const maxAnon = String(args.length + (added ? 0 : 1));
+        if (added) {
+            this.#keys.add(maxAnon);
+        }
+        else if (!this.hasArg(maxAnon, true)) {
+            this.#keys.delete(maxAnon);
+        }
+        /* NOT FOR BROWSER END */
+        for (let i = added ? args.indexOf(addedToken) : addedToken - 1; i < args.length; i++) {
+            const token = args[i], { name } = token, newName = String(i + 1);
+            if (name !== newName) {
+                token.setAttribute('name', newName);
+                this.getArgs(newName, false, false).add(token);
+                /* NOT FOR BROWSER */
+                if (name) {
+                    this.getArgs(name, false, false).delete(token);
+                }
+            }
+        }
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     */
+    insertAt(token, i = this.length) {
+        super.insertAt(token, i);
+        if (token.anon) {
+            this.#handleAnonArgChange(token);
+        }
+        else if (token.name) {
+            this.getArgs(token.name, false, false).add(token);
+            /* NOT FOR BROWSER */
+            this.#keys.add(token.name);
+        }
+        return token;
+    }
+    /** 获取所有参数 */
+    getAllArgs() {
+        return this.childNodes.filter((0, debug_1.isToken)('parameter'));
+    }
+    /** 获取所有匿名参数 */
+    getAnonArgs() {
+        return this.getAllArgs().filter(({ anon }) => anon);
+    }
+    /**
+     * 获取指定参数
+     * @param key 参数名
+     * @param exact 是否匹配匿名性
+     * @param copy 是否返回一个备份
+     */
+    getArgs(key, exact = false, copy = true) {
+        const keyStr = String(key).replace(/^[ \t\n\0\v]+|([^ \t\n\0\v])[ \t\n\0\v]+$/gu, '$1');
+        let args;
+        if (this.#args.has(keyStr)) {
+            args = this.#args.get(keyStr);
+        }
+        else {
+            args = new Set(this.getAllArgs().filter(({ name }) => keyStr === name));
+            this.#args.set(keyStr, args);
+        }
+        /* NOT FOR BROWSER */
+        if (exact && !Number.isNaN(Number(keyStr))) {
+            args = new Set([...args].filter(({ anon }) => typeof key === 'number' === anon));
+        }
+        else if (copy) {
+            args = new Set(args);
+        }
+        /* NOT FOR BROWSER END */
+        return args;
+    }
+    /**
+     * 获取重名参数
+     * @throws `Error` 仅用于模板
+     */
+    getDuplicatedArgs() {
+        if (this.isTemplate()) {
+            return [...this.#args].filter(([, { size }]) => size > 1).map(([key, args]) => [key, [...args]]);
+        }
+        throw new Error('getDuplicatedArgs 方法仅供模板使用！');
+    }
+    /**
+     * 对特定魔术字获取可能的取值
+     * @throws `Error` 不是可接受的魔术字
+     */
+    getPossibleValues() {
+        const { type, name, childNodes, constructor: { name: cName } } = this;
+        if (type === 'template') {
+            throw new Error(`${cName}.getPossibleValues 方法仅供特定魔术字使用！`);
+        }
+        let start;
+        switch (name) {
+            case 'if':
+            case 'ifexist':
+            case 'ifexpr':
+            case 'iferror':
+                start = 2;
+                break;
+            case 'ifeq':
+                start = 3;
+                break;
+            default:
+                throw new Error(`${cName}.getPossibleValues 方法仅供特定魔术字使用！`);
+        }
+        const queue = childNodes.slice(start, start + 2).map(({ childNodes: [, value] }) => value);
+        for (let i = 0; i < queue.length;) {
+            const { length, 0: first } = queue[i].childNodes.filter(child => child.text().trim());
+            if (length === 0) {
+                queue.splice(i, 1);
+            }
+            else if (length > 1 || first.type !== 'magic-word') {
+                i++;
+            }
+            else {
+                try {
+                    const possibleValues = first.getPossibleValues();
+                    queue.splice(i, 1, ...possibleValues);
+                    i += possibleValues.length;
+                }
+                catch {
+                    i++;
+                }
+            }
+        }
+        return queue;
+    }
+    /** @override */
+    print() {
+        const { childNodes, length, firstChild, modifier, type } = this;
+        return `<span class="wpb-${type}">{{${modifier}${type === 'magic-word'
+            ? `${firstChild.print()}${length === 1 ? '' : ':'}${(0, string_1.print)(childNodes.slice(1), { sep: '|' })}`
+            : (0, string_1.print)(childNodes, { sep: '|' })}}}</span>`;
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    cloneNode() {
+        const [first, ...cloned] = this.cloneChildNodes(), config = this.getAttribute('config');
+        return debug_1.Shadow.run(() => {
+            // @ts-expect-error abstract class
+            const token = new TranscludeToken(this.type === 'template' ? 'T' : first.text(), [], config);
+            if (this.#raw) {
+                token.setModifier(this.modifier);
+            }
+            else {
+                token.setAttribute('modifier', this.modifier);
+            }
+            token.firstChild.safeReplaceWith(first);
+            token.afterBuild();
+            token.append(...cloned);
+            return token;
+        });
+    }
+    /** 替换引用 */
+    subst() {
+        this.setModifier('subst:');
+    }
+    /** 安全的替换引用 */
+    safesubst() {
+        this.setModifier('safesubst:');
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        const token = super.removeAt(i);
+        if (token.anon) {
+            this.#handleAnonArgChange(Number(token.name));
+        }
+        else {
+            const args = this.getArgs(token.name, false, false);
+            args.delete(token);
+            if (args.size === 0) {
+                this.#keys.delete(token.name);
+            }
+        }
+        return token;
+    }
+    /**
+     * 是否具有某参数
+     * @param key 参数名
+     * @param exact 是否匹配匿名性
+     */
+    hasArg(key, exact = false) {
+        return this.getArgs(key, exact, false).size > 0;
+    }
+    /**
+     * 获取生效的指定参数
+     * @param key 参数名
+     * @param exact 是否匹配匿名性
+     */
+    getArg(key, exact = false) {
+        const args = [...this.getArgs(key, exact, false)].sort((a, b) => a.compareDocumentPosition(b));
+        return args[args.length - 1];
+    }
+    /**
+     * 移除指定参数
+     * @param key 参数名
+     * @param exact 是否匹配匿名性
+     */
+    removeArg(key, exact = false) {
+        debug_1.Shadow.run(() => {
+            for (const token of this.getArgs(key, exact, false)) {
+                this.removeChild(token);
+            }
+        });
+    }
+    /** 获取所有参数名 */
+    getKeys() {
+        const args = this.getAllArgs();
+        if (this.#keys.size === 0 && args.length > 0) {
+            for (const { name } of args) {
+                this.#keys.add(name);
+            }
+        }
+        return [...this.#keys];
+    }
+    /**
+     * 获取参数值
+     * @param key 参数名
+     */
+    getValues(key) {
+        return [...this.getArgs(key, false, false)].map(token => token.getValue());
+    }
+    /**
+     * 获取生效的参数值
+     * @param key 参数名
+     */
+    getValue(key) {
+        return key === undefined
+            ? Object.fromEntries(this.getKeys().map(k => [k, this.getValue(k)]))
+            : this.getArg(key)?.getValue();
+    }
+    /**
+     * 插入匿名参数
+     * @param val 参数值
+     */
+    newAnonArg(val) {
+        const config = this.getAttribute('config'), { childNodes } = index_1.default.parse(val, this.getAttribute('include'), undefined, config), 
+        // @ts-expect-error abstract class
+        token = debug_1.Shadow.run(() => new parameter_1.ParameterToken(undefined, undefined, config));
+        token.lastChild.append(...childNodes);
+        token.afterBuild();
+        return this.insertAt(token);
+    }
+    /**
+     * 设置参数值
+     * @param key 参数名
+     * @param value 参数值
+     * @throws `Error` 仅用于模板
+     */
+    setValue(key, value) {
+        if (!this.isTemplate()) {
+            throw new Error('setValue 方法仅供模板使用！');
+        }
+        const arg = this.getArg(key);
+        if (arg) {
+            arg.setValue(value);
+            return;
+        }
+        const include = this.getAttribute('include'), config = this.getAttribute('config'), k = index_1.default.parse(key, include, undefined, config), v = index_1.default.parse(value, include, undefined, config), 
+        // @ts-expect-error abstract class
+        token = debug_1.Shadow.run(() => new parameter_1.ParameterToken(undefined, undefined, config));
+        token.firstChild.append(...k.childNodes);
+        token.lastChild.append(...v.childNodes);
+        token.afterBuild();
+        this.insertAt(token);
+    }
+    /**
+     * 将匿名参数改写为命名参数
+     * @throws `Error` 仅用于模板
+     */
+    anonToNamed() {
+        if (!this.isTemplate()) {
+            throw new Error('anonToNamed 方法仅供模板使用！');
+        }
+        for (const token of this.getAnonArgs()) {
+            token.firstChild.replaceChildren(token.name);
+        }
+    }
+    /**
+     * 替换模板名
+     * @param title 模板名
+     * @throws `Error` 仅用于模板
+     */
+    replaceTemplate(title) {
+        if (this.type === 'magic-word') {
+            throw new Error('replaceTemplate 方法仅用于更换模板！');
+        }
+        const { childNodes } = index_1.default.parse(title, this.getAttribute('include'), 2, this.getAttribute('config'));
+        this.firstChild.replaceChildren(...childNodes);
+    }
+    /**
+     * 替换模块名
+     * @param title 模块名
+     * @throws `Error` 仅用于模块
+     */
+    replaceModule(title) {
+        if (this.type !== 'magic-word' || this.name !== 'invoke') {
+            throw new Error('replaceModule 方法仅用于更换模块！');
+        }
+        const config = this.getAttribute('config');
+        if (this.length === 1) {
+            super.insertAt(new atom_1.AtomToken(undefined, 'invoke-module', config, [], {
+                'Stage-1': ':', '!ExtToken': '',
+            }));
+            return;
+        }
+        const { childNodes } = index_1.default.parse(title, this.getAttribute('include'), 2, config);
+        this.childNodes[1].replaceChildren(...childNodes);
+    }
+    /**
+     * 替换模块函数
+     * @param func 模块函数名
+     * @throws `Error` 仅用于模块
+     * @throws `Error` 尚未指定模块名称
+     */
+    replaceFunction(func) {
+        if (this.type !== 'magic-word' || this.name !== 'invoke') {
+            throw new Error('replaceModule 方法仅用于更换模块！');
+        }
+        else if (this.length < 2) {
+            throw new Error('尚未指定模块名称！');
+        }
+        const config = this.getAttribute('config');
+        if (this.length === 2) {
+            super.insertAt(new atom_1.AtomToken(undefined, 'invoke-function', config, [], {
+                'Stage-1': ':', '!ExtToken': '',
+            }));
+            return;
+        }
+        const { childNodes } = index_1.default.parse(func, this.getAttribute('include'), 2, config);
+        this.childNodes[2].replaceChildren(...childNodes);
+    }
+    /**
+     * 重复参数计数
+     * @throws `Error` 仅用于模板
+     */
+    hasDuplicatedArgs() {
+        if (this.isTemplate()) {
+            return this.getAllArgs().length - this.getKeys().length;
+        }
+        throw new Error('hasDuplicatedArgs 方法仅供模板使用！');
+    }
+    /**
+     * 修复重名参数：
+     * `aggressive = false`时只移除空参数和全同参数，优先保留匿名参数，否则将所有匿名参数更改为命名。
+     * `aggressive = true`时还会尝试处理连续的以数字编号的参数。
+     * @param aggressive 是否使用有更大风险的修复手段
+     */
+    fixDuplication(aggressive = false) {
+        if (!this.hasDuplicatedArgs()) {
+            return [];
+        }
+        const duplicatedKeys = [];
+        let anonCount = this.getAnonArgs().length;
+        for (const [key, args] of this.getDuplicatedArgs()) {
+            if (args.length <= 1) {
+                continue;
+            }
+            const values = new Map();
+            for (const arg of args) {
+                const val = arg.getValue().trim();
+                if (values.has(val)) {
+                    values.get(val).push(arg);
+                }
+                else {
+                    values.set(val, [arg]);
+                }
+            }
+            let noMoreAnon = anonCount === 0 || Number.isNaN(Number(key));
+            const emptyArgs = values.get('') ?? [], duplicatedArgs = [...values].filter(([val, { length }]) => val && length > 1).flatMap(([, curArgs]) => {
+                const anonIndex = noMoreAnon ? -1 : curArgs.findIndex(({ anon }) => anon);
+                if (anonIndex !== -1) {
+                    noMoreAnon = true;
+                }
+                curArgs.splice(anonIndex, 1);
+                return curArgs;
+            }), badArgs = [...emptyArgs, ...duplicatedArgs], index = noMoreAnon ? -1 : emptyArgs.findIndex(({ anon }) => anon);
+            if (badArgs.length === args.length) {
+                badArgs.splice(index, 1);
+            }
+            else if (index !== -1) {
+                this.anonToNamed();
+                anonCount = 0;
+            }
+            for (const arg of badArgs) {
+                arg.remove();
+            }
+            let remaining = args.length - badArgs.length;
+            if (remaining === 1) {
+                continue;
+            }
+            else if (aggressive && (anonCount ? /\D\d+$/u : /(?:^|\D)\d+$/u).test(key)) {
+                let last;
+                // eslint-disable-next-line es-x/no-regexp-lookbehind-assertions
+                const str = key.slice(0, -/(?<!\d)\d+$/u.exec(key)[0].length), regex = new RegExp(`^${(0, string_1.escapeRegExp)(str)}\\d+$`, 'u'), series = this.getAllArgs().filter(({ name }) => regex.test(name)), ordered = series.every(({ name }, i) => {
+                    const j = Number(name.slice(str.length)), cmp = j <= i + 1 && (i === 0 || j >= last || name === key);
+                    last = j;
+                    return cmp;
+                });
+                if (ordered) {
+                    for (let i = 0; i < series.length; i++) {
+                        const name = `${str}${i + 1}`, arg = series[i];
+                        if (arg.name !== name) {
+                            if (arg.name === key) {
+                                remaining--;
+                            }
+                            arg.rename(name, true);
+                        }
+                    }
+                }
+            }
+            if (remaining > 1) {
+                index_1.default.error(`${this.type === 'template'
+                    ? this.name
+                    : this.normalizeTitle(this.childNodes[1].text(), 828)
+                        .title} 还留有 ${remaining} 个重复的 ${key} 参数：${[...this.getArgs(key)].map(arg => {
+                    const { top, left } = arg.getBoundingClientRect();
+                    return `第 ${String(top)} 行第 ${String(left)} 列`;
+                }).join('、')}`);
+                duplicatedKeys.push(key);
+                continue;
+            }
+        }
+        return duplicatedKeys;
+    }
+    /**
+     * 转义模板内的表格
+     * @throws `Error` 转义失败
+     */
+    escapeTables() {
+        if (!/\n[^\S\n]*(?::+[^\S\n]*)?\{\|/u.test(this.text())) {
+            return this;
+        }
+        const stripped = String(this).slice(2, -2), include = this.getAttribute('include'), config = this.getAttribute('config'), parsed = index_1.default.parse(stripped, include, 4, config), isTable = (0, debug_1.isToken)('table');
+        for (const table of parsed.childNodes) {
+            if (isTable(table)) {
+                table.escape();
+            }
+        }
+        const { firstChild, length } = index_1.default.parse(`{{${String(parsed)}}}`, include, undefined, config);
+        if (length !== 1 || !(firstChild instanceof TranscludeToken)) {
+            throw new Error('转义表格失败！');
+        }
+        this.safeReplaceWith(firstChild);
+        return firstChild;
+    }
+}
+exports.TranscludeToken = TranscludeToken;
+constants_1.classes['TranscludeToken'] = __filename;