wikiparser-node 1.13.1-b → 1.13.1

package/dist/src/index.js

@@ -0,0 +1,790 @@
+"use strict";
+// PHP解析器的步骤：
+// -1. 替换签名和`{{subst:}}`，参见Parser::preSaveTransform；这在revision中不可能保留，可以跳过
+// 0. 移除特定字符`\0`和`\x7F`，参见Parser::parse
+// 1. 注释/扩展标签（'<'相关），参见Preprocessor_Hash::buildDomTreeArrayFromText和Sanitizer::decodeTagAttributes
+// 2. 模板/模板变量/标题，注意rightmost法则，以及`-{`和`[[`可以破坏`{{`或`{{{`语法，
+//    参见Preprocessor_Hash::buildDomTreeArrayFromText
+// 3. HTML标签（允许不匹配），参见Sanitizer::internalRemoveHtmlTags
+// 4. 表格，参见Parser::handleTables
+// 5. 水平线、状态开关和余下的标题，参见Parser::internalParse
+// 6. 内链，含文件和分类，参见Parser::handleInternalLinks2
+// 7. `'`，参见Parser::doQuotes
+// 8. 外链，参见Parser::handleExternalLinks
+// 9. ISBN、RFC（未来将废弃，不予支持）和自由外链，参见Parser::handleMagicLinks
+// 10. 段落和列表，参见BlockLevelPass::execute
+// 11. 转换，参见LanguageConverter::recursiveConvertTopLevel
+// \0\d+.\x7F标记Token：
+// !: `{{!}}`专用
+// {: `{{(!}}`专用
+// }: `{{!)}}`专用
+// -: `{{!-}}`专用
+// +: `{{!!}}`专用
+// ~: `{{=}}`专用
+// a: AttributeToken
+// b: TableToken
+// c: CommentToke
+// d: ListToken
+// e: ExtToken
+// f: MagicLinkToken inside ImageParameterToken
+// h: HeadingToken
+// i: RFC/PMID/ISBN
+// l: LinkToken
+// m: `{{fullurl:}}`、`{{canonicalurl:}}`或`{{filepath:}}`
+// n: NoIncludeToken和IncludeToken
+// o: RedirectToken
+// q: QuoteToken
+// r: HrToken
+// s: `{{{|subst:}}}`
+// t: ArgToken或TranscludeToken
+// u: `__toc__`
+// v: ConverterToken
+// w: ExtLinkToken
+// x: HtmlToken
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+const string_1 = require("../util/string");
+const constants_1 = require("../util/constants");
+const debug_1 = require("../util/debug");
+const lint_1 = require("../util/lint");
+const index_1 = require("../index");
+const element_1 = require("../lib/element");
+const text_1 = require("../lib/text");
+/* NOT FOR BROWSER */
+const assert = require("assert/strict");
+const html_1 = require("../util/html");
+const ranges_1 = require("../lib/ranges");
+const range_1 = require("../lib/range");
+/**
+ * 可接受的Token类型
+ * @param value 可接受的Token类型
+ */
+const getAcceptable = (value) => {
+    const acceptable = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (k.startsWith('Stage-')) {
+            for (let i = 0; i <= Number(k.slice(6)); i++) {
+                for (const type of constants_1.aliases[i]) {
+                    acceptable[type] = new ranges_1.Ranges(v);
+                }
+            }
+        }
+        else if (k.startsWith('!')) { // `!`项必须放在最后
+            delete acceptable[k.slice(1)];
+        }
+        else {
+            acceptable[k] = new ranges_1.Ranges(v);
+        }
+    }
+    return acceptable;
+};
+/* NOT FOR BROWSER END */
+/**
+ * 所有节点的基类
+ * @classdesc `{childNodes: ...(AstText|Token)}`
+ */
+class Token extends element_1.AstElement {
+    #type = 'plain';
+    /** 解析阶段，参见顶部注释。只对plain Token有意义。 */
+    #stage = 0;
+    #config;
+    /** 这个数组起两个作用：1. 数组中的Token会在build时替换`/\0\d+.\x7F/`标记；2. 数组中的Token会依次执行parseOnce和build方法。 */
+    #accum;
+    #include;
+    #built = false;
+    #string;
+    /* NOT FOR BROWSER */
+    #acceptable;
+    #protectedChildren = new ranges_1.Ranges();
+    /* NOT FOR BROWSER END */
+    get type() {
+        return this.#type;
+    }
+    set type(value) {
+        /* NOT FOR BROWSER */
+        const plainTypes = [
+            'plain',
+            'root',
+            'table-inter',
+            'arg-default',
+            'attr-value',
+            'ext-link-text',
+            'heading-title',
+            'parameter-key',
+            'parameter-value',
+            'link-text',
+            'td-inner',
+            'ext-inner',
+            'list-range',
+        ];
+        if (!plainTypes.includes(value)) {
+            throw new RangeError(`"${value}" is not a valid type for ${this.constructor.name}!`);
+        }
+        /* NOT FOR BROWSER END */
+        this.#type = value;
+    }
+    /* NOT FOR BROWSER */
+    /** 所有图片，包括图库 */
+    get images() {
+        return this.querySelectorAll('file,gallery-image,imagemap-image');
+    }
+    /** 所有内链、外链和自由外链 */
+    get links() {
+        return this.querySelectorAll('link,redirect-target,ext-link,free-ext-link,magic-link,image-parameter#link');
+    }
+    /** 所有模板和模块 */
+    get embeds() {
+        return this.querySelectorAll('template,magic-word#invoke');
+    }
+    /* NOT FOR BROWSER END */
+    /** @class */
+    constructor(wikitext, config = index_1.default.getConfig(), accum = [], acceptable) {
+        super();
+        if (typeof wikitext === 'string') {
+            this.insertAt(wikitext);
+        }
+        this.#config = config;
+        this.#accum = accum;
+        accum.push(this);
+        /* NOT FOR BROWSER */
+        this.setAttribute('acceptable', acceptable);
+    }
+    /** @private */
+    parseOnce(n = this.#stage, include = false) {
+        if (n < this.#stage || this.length === 0 || !this.getAttribute('plain')) {
+            return this;
+        }
+        else if (this.#stage >= constants_1.MAX_STAGE) {
+            /* NOt FOR BROWSER */
+            if (this.type === 'root') {
+                index_1.default.error('Fully parsed!');
+            }
+            /* NOT FOR BROWSER END */
+            return this;
+        }
+        switch (n) {
+            case 0:
+                if (this.type === 'root') {
+                    this.#accum.pop();
+                    const isRedirect = this.#parseRedirect();
+                    include &&= !isRedirect;
+                }
+                this.#include = include;
+                this.#parseCommentAndExt(include);
+                break;
+            case 1:
+                this.#parseBraces();
+                break;
+            case 2:
+                this.#parseHtml();
+                break;
+            case 3:
+                this.#parseTable();
+                break;
+            case 4:
+                this.#parseHrAndDoubleUnderscore();
+                break;
+            case 5:
+                this.#parseLinks();
+                break;
+            case 6:
+                this.#parseQuotes();
+                break;
+            case 7:
+                this.#parseExternalLinks();
+                break;
+            case 8:
+                this.#parseMagicLinks();
+                break;
+            case 9:
+                this.#parseList();
+                break;
+            case 10:
+                this.#parseConverter();
+            // no default
+        }
+        if (this.type === 'root') {
+            for (const token of this.#accum) {
+                token?.parseOnce(n, include); // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+            }
+        }
+        this.#stage++;
+        return this;
+    }
+    /** @private */
+    buildFromStr(str, type) {
+        const nodes = str.split(/[\0\x7F]/u).map((s, i) => {
+            if (i % 2 === 0) {
+                return new text_1.AstText(s);
+            }
+            else if (isNaN(s.slice(-1))) {
+                return this.#accum[Number(s.slice(0, -1))];
+            }
+            throw new Error(`Failed to build! Unrecognized token: ${s}`);
+        });
+        if (type === constants_1.BuildMethod.String) {
+            return nodes.map(String).join('');
+        }
+        else if (type === constants_1.BuildMethod.Text) {
+            return (0, string_1.text)(nodes);
+        }
+        return nodes;
+    }
+    /** @private */
+    build() {
+        this.#stage = constants_1.MAX_STAGE;
+        const { length, firstChild } = this, str = firstChild?.toString();
+        if (length === 1 && firstChild.type === 'text' && str.includes('\0')) {
+            this.replaceChildren(...this.buildFromStr(str));
+            this.normalize();
+            if (this.type === 'root') {
+                for (const token of this.#accum) {
+                    token?.build(); // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+                }
+            }
+        }
+    }
+    /** @private */
+    afterBuild() {
+        if (this.type === 'root') {
+            for (const token of this.#accum) {
+                token?.afterBuild(); // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+            }
+        }
+        this.#built = true;
+    }
+    /** @private */
+    parse(n = constants_1.MAX_STAGE, include) {
+        n = Math.min(n, constants_1.MAX_STAGE);
+        while (this.#stage < n) {
+            this.parseOnce(this.#stage, include);
+        }
+        if (n) {
+            this.build();
+            this.afterBuild();
+        }
+        return this;
+    }
+    /** 解析重定向 */
+    #parseRedirect() {
+        const { parseRedirect } = require('../parser/redirect');
+        const wikitext = this.firstChild.toString(), parsed = parseRedirect(wikitext, this.#config, this.#accum);
+        if (parsed) {
+            this.setText(parsed);
+        }
+        return Boolean(parsed);
+    }
+    /**
+     * 解析HTML注释和扩展标签
+     * @param includeOnly 是否嵌入
+     */
+    #parseCommentAndExt(includeOnly) {
+        const { parseCommentAndExt } = require('../parser/commentAndExt');
+        this.setText(parseCommentAndExt(this.firstChild.toString(), this.#config, this.#accum, includeOnly));
+    }
+    /** 解析花括号 */
+    #parseBraces() {
+        const { parseBraces } = require('../parser/braces');
+        const str = this.type === 'root' ? this.firstChild.toString() : `\0${this.firstChild.toString()}`, parsed = parseBraces(str, this.#config, this.#accum);
+        this.setText(this.type === 'root' ? parsed : parsed.slice(1));
+    }
+    /** 解析HTML标签 */
+    #parseHtml() {
+        if (this.#config.excludes?.includes('html')) {
+            return;
+        }
+        const { parseHtml } = require('../parser/html');
+        this.setText(parseHtml(this.firstChild.toString(), this.#config, this.#accum));
+    }
+    /** 解析表格 */
+    #parseTable() {
+        if (this.#config.excludes?.includes('table')) {
+            return;
+        }
+        const { parseTable } = require('../parser/table');
+        this.setText(parseTable(this, this.#config, this.#accum));
+    }
+    /** 解析`<hr>`和状态开关 */
+    #parseHrAndDoubleUnderscore() {
+        if (this.#config.excludes?.includes('hr')) {
+            return;
+        }
+        const { parseHrAndDoubleUnderscore } = require('../parser/hrAndDoubleUnderscore');
+        this.setText(parseHrAndDoubleUnderscore(this, this.#config, this.#accum));
+    }
+    /** 解析内部链接 */
+    #parseLinks() {
+        const { parseLinks } = require('../parser/links');
+        this.setText(parseLinks(this.firstChild.toString(), this.#config, this.#accum));
+    }
+    /** 解析单引号 */
+    #parseQuotes() {
+        if (this.#config.excludes?.includes('quote')) {
+            return;
+        }
+        const { parseQuotes } = require('../parser/quotes');
+        const lines = this.firstChild.toString().split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            lines[i] = parseQuotes(lines[i], this.#config, this.#accum);
+        }
+        this.setText(lines.join('\n'));
+    }
+    /** 解析外部链接 */
+    #parseExternalLinks() {
+        if (this.#config.excludes?.includes('extLink')) {
+            return;
+        }
+        const { parseExternalLinks } = require('../parser/externalLinks');
+        this.setText(parseExternalLinks(this.firstChild.toString(), this.#config, this.#accum));
+    }
+    /** 解析自由外链 */
+    #parseMagicLinks() {
+        if (this.#config.excludes?.includes('magicLink')) {
+            return;
+        }
+        const { parseMagicLinks } = require('../parser/magicLinks');
+        this.setText(parseMagicLinks(this.firstChild.toString(), this.#config, this.#accum));
+    }
+    /** 解析列表 */
+    #parseList() {
+        if (this.#config.excludes?.includes('list')) {
+            return;
+        }
+        const { parseList } = require('../parser/list');
+        const lines = this.firstChild.toString().split('\n'), state = { lastPrefix: '' };
+        let i = this.type === 'root' || this.type === 'ext-inner' && this.name === 'poem' ? 0 : 1;
+        for (; i < lines.length; i++) {
+            lines[i] = parseList(lines[i], state, this.#config, this.#accum);
+        }
+        this.setText(lines.join('\n'));
+    }
+    /** 解析语言变体转换 */
+    #parseConverter() {
+        if (this.#config.variants.length > 0) {
+            const { parseConverter } = require('../parser/converter');
+            this.setText(parseConverter(this.firstChild.toString(), this.#config, this.#accum));
+        }
+    }
+    /** @private */
+    getAttribute(key) {
+        switch (key) {
+            case 'plain':
+                return (this.constructor === Token);
+            case 'config':
+                return this.#config;
+            case 'include':
+                return (this.#include ?? Boolean(this.getRootNode().#include));
+            case 'accum':
+                return this.#accum;
+            case 'built':
+                return this.#built;
+            /* NOT FOR BROWSER */
+            case 'stage':
+                return this.#stage;
+            case 'protectedChildren':
+                return this.#protectedChildren;
+            /* NOT FOR BROWSER END */
+            default:
+                return super.getAttribute(key);
+        }
+    }
+    /** @private */
+    setAttribute(key, value) {
+        switch (key) {
+            case 'stage':
+                if (this.#stage === 0 && this.type === 'root') {
+                    this.#accum.shift();
+                }
+                this.#stage = value;
+                break;
+            /* NOT FOR BROWSER */
+            case 'acceptable':
+                this.#acceptable = value && (() => getAcceptable(value));
+                break;
+            /* NOT FOR BROWSER END */
+            default:
+                super.setAttribute(key, value);
+        }
+    }
+    insertAt(child, i = this.length) {
+        const token = typeof child === 'string' ? new text_1.AstText(child) : child;
+        /* NOT FOR BROWSER */
+        const acceptable = this.getAcceptable();
+        if (!debug_1.Shadow.running && acceptable) {
+            const acceptableIndices = Object.fromEntries(Object.entries(acceptable).map(([str, ranges]) => [str, ranges.applyTo(this.length + 1)])), nodesAfter = this.childNodes.slice(i), insertedName = token.constructor.name;
+            i += i < 0 ? this.length : 0;
+            if (!acceptableIndices[insertedName]?.includes(i)) {
+                this.constructorError(`cannot insert a ${insertedName} at position ${i}`);
+            }
+            else if (nodesAfter.some(({ constructor: { name } }, j) => !acceptableIndices[name]?.includes(i + j + 1))) {
+                this.constructorError(`violates the order of acceptable nodes by inserting a child node at position ${i}`);
+            }
+        }
+        /* NOT FOR BROWSER END */
+        super.insertAt(token, i);
+        /* NOT FOR BROWSER */
+        const e = new Event('insert', { bubbles: true });
+        this.dispatchEvent(e, { type: 'insert', position: i < 0 ? i + this.length - 1 : i });
+        if (token.type !== 'list-range' && token.constructor === Token && this.getAttribute('plain')) {
+            index_1.default.warn('You are inserting a plain token as a child of another plain token. '
+                + 'Consider calling Token.flatten method afterwards.');
+        }
+        /* NOT FOR BROWSER END */
+        if (token.type === 'root') {
+            token.type = 'plain';
+        }
+        return token;
+    }
+    /** @private */
+    normalizeTitle(title, defaultNs = 0, halfParsed, decode, selfLink) {
+        return index_1.default.normalizeTitle(title, defaultNs, this.#include, this.#config, halfParsed, decode, selfLink);
+    }
+    /** @private */
+    lint(start = this.getAbsoluteIndex(), re) {
+        const { viewOnly } = index_1.default;
+        index_1.default.viewOnly = true;
+        let errors = super.lint(start, re);
+        if (this.type === 'root') {
+            const record = {}, selector = 'category,html-attr#id,ext-attr#id,table-attr#id';
+            for (const cat of this.querySelectorAll(selector)) {
+                let key;
+                if (cat.type === 'category') {
+                    key = cat.name;
+                }
+                else {
+                    const value = cat.getValue();
+                    key = `#${value === true ? '' : value}`;
+                }
+                const thisCat = record[key];
+                if (thisCat) {
+                    thisCat.add(cat);
+                }
+                else {
+                    record[key] = new Set([cat]);
+                }
+            }
+            for (const [key, value] of Object.entries(record)) {
+                if (value.size > 1 && !key.startsWith('#mw-customcollapsible-')) {
+                    const isCat = !key.startsWith('#'), msg = `duplicated ${isCat ? 'category' : 'id'}`, severity = isCat ? 'error' : 'warning';
+                    errors.push(...[...value].map(cat => {
+                        const e = (0, lint_1.generateForSelf)(cat, { start: cat.getAbsoluteIndex() }, 'no-duplicate', msg, severity);
+                        if (isCat) {
+                            e.suggestions = [
+                                {
+                                    desc: 'remove',
+                                    range: [e.startIndex, e.endIndex],
+                                    text: '',
+                                },
+                            ];
+                        }
+                        return e;
+                    }));
+                }
+            }
+            const regex = /<!--\s*lint-(disable(?:(?:-next)?-line)?|enable)(\s[\sa-z,-]*)?-->/gu, wikitext = this.toString(), ignores = [];
+            let mt = regex.exec(wikitext), last = 0, curLine = 0;
+            while (mt) {
+                const { 1: type, index } = mt, detail = mt[2]?.trim();
+                curLine += wikitext.slice(last, index).split('\n').length - 1;
+                last = index;
+                ignores.push({
+                    line: curLine + (type === 'disable-line' ? 0 : 1),
+                    from: type === 'disable' ? regex.lastIndex : undefined,
+                    to: type === 'enable' ? regex.lastIndex : undefined,
+                    rules: detail ? new Set(detail.split(',').map(r => r.trim())) : undefined,
+                });
+                mt = regex.exec(wikitext);
+            }
+            errors = errors.filter(({ rule, startLine, startIndex }) => {
+                const nearest = { pos: 0 };
+                for (const { line, from, to, rules } of ignores) {
+                    if (line > startLine + 1) {
+                        break;
+                    }
+                    else if (rules && !rules.has(rule)) {
+                        continue;
+                    }
+                    else if (line === startLine && from === undefined && to === undefined) {
+                        return false;
+                    }
+                    else if (from <= startIndex && from > nearest.pos) {
+                        nearest.pos = from;
+                        nearest.type = 'from';
+                    }
+                    else if (to <= startIndex && to > nearest.pos) {
+                        nearest.pos = to;
+                        nearest.type = 'to';
+                    }
+                }
+                return nearest.type !== 'from';
+            });
+        }
+        index_1.default.viewOnly = viewOnly;
+        return errors;
+    }
+    /** @private */
+    toString(skip, separator) {
+        const { rev } = debug_1.Shadow, root = this.getRootNode();
+        if (this.#string && this.#string[0] !== rev) {
+            this.#string = undefined;
+        }
+        if (!skip
+            && root.type === 'root'
+            && root.#built
+            && index_1.default.viewOnly) {
+            this.#string ??= [rev, super.toString(false, separator)];
+            return this.#string[1];
+        }
+        return super.toString(skip, separator);
+    }
+    /* NOT FOR BROWSER */
+    /** @private */
+    getAcceptable() {
+        if (typeof this.#acceptable === 'function') {
+            this.#acceptable = this.#acceptable();
+        }
+        return this.#acceptable;
+    }
+    /** @private */
+    dispatchEvent(e, data) {
+        if (this.#built) {
+            super.dispatchEvent(e, data);
+        }
+    }
+    /** @private */
+    protectChildren(...args) {
+        this.#protectedChildren.push(...new ranges_1.Ranges(args));
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        i += i < 0 ? this.length : 0;
+        if (!debug_1.Shadow.running) {
+            const protectedIndices = this.#protectedChildren.applyTo(this.childNodes);
+            if (protectedIndices.includes(i)) {
+                this.constructorError(`cannot remove the child node at position ${i}`);
+            }
+            const acceptable = this.getAcceptable();
+            if (acceptable) {
+                const acceptableIndices = Object.fromEntries(Object.entries(acceptable).map(([str, ranges]) => [str, ranges.applyTo(this.length - 1)])), nodesAfter = this.childNodes.slice(i + 1);
+                if (nodesAfter.some(({ constructor: { name } }, j) => !acceptableIndices[name]?.includes(i + j))) {
+                    this.constructorError(`violates the order of acceptable nodes by removing the child node at position ${i}`);
+                }
+            }
+        }
+        const node = super.removeAt(i);
+        const e = new Event('remove', { bubbles: true });
+        this.dispatchEvent(e, { type: 'remove', position: i, removed: node });
+        return node;
+    }
+    /**
+     * 替换为同类节点
+     * @param token 待替换的节点
+     * @throws `Error` 不存在父节点
+     */
+    safeReplaceWith(token) {
+        const { parentNode } = this;
+        if (!parentNode) {
+            throw new Error('The node does not have a parent node!');
+        }
+        else if (token.constructor !== this.constructor) {
+            this.typeError('safeReplaceWith', this.constructor.name);
+        }
+        try {
+            assert.deepEqual(token.getAcceptable(), this.getAcceptable());
+        }
+        catch (e) {
+            if (e instanceof assert.AssertionError) {
+                this.constructorError('has a different #acceptable property');
+            }
+            throw e;
+        }
+        const i = parentNode.childNodes.indexOf(this);
+        super.removeAt.call(parentNode, i);
+        super.insertAt.call(parentNode, token, i);
+        if (token.type === 'root') {
+            token.type = 'plain';
+        }
+        const e = new Event('replace', { bubbles: true });
+        token.dispatchEvent(e, { type: 'replace', position: i, oldToken: this });
+    }
+    /**
+     * 创建HTML注释
+     * @param data 注释内容
+     */
+    createComment(data) {
+        require('../addon/token');
+        return this.createComment(data);
+    }
+    /**
+     * 创建标签
+     * @param tagName 标签名
+     * @param options 选项
+     * @param options.selfClosing 是否自封闭
+     * @param options.closing 是否是闭合标签
+     * @throws `RangeError` 非法的标签名
+     */
+    createElement(tagName, options) {
+        require('../addon/token');
+        return this.createElement(tagName, options);
+    }
+    /**
+     * 创建纯文本节点
+     * @param data 文本内容
+     */
+    createTextNode(data = '') {
+        return new text_1.AstText(data);
+    }
+    /** 创建AstRange对象 */
+    createRange() {
+        return new range_1.AstRange();
+    }
+    /**
+     * 找到给定位置
+     * @param index 位置
+     */
+    caretPositionFromIndex(index) {
+        require('../addon/token');
+        return this.caretPositionFromIndex(index);
+    }
+    /**
+     * 找到给定位置
+     * @param x 列数
+     * @param y 行数
+     */
+    caretPositionFromPoint(x, y) {
+        return this.caretPositionFromIndex(this.indexFromPos(y, x));
+    }
+    /**
+     * 找到给定位置所在的最外层节点
+     * @param index 位置
+     */
+    elementFromIndex(index) {
+        return this.caretPositionFromIndex(index)?.offsetNode;
+    }
+    /**
+     * 找到给定位置所在的最外层节点
+     * @param x 列数
+     * @param y 行数
+     */
+    elementFromPoint(x, y) {
+        return this.elementFromIndex(this.indexFromPos(y, x));
+    }
+    /**
+     * 找到给定位置所在的所有节点
+     * @param index 位置
+     */
+    elementsFromIndex(index) {
+        const offsetNode = this.caretPositionFromIndex(index)?.offsetNode;
+        return offsetNode ? [...offsetNode.getAncestors().reverse(), offsetNode] : [];
+    }
+    /**
+     * 找到给定位置所在的所有节点
+     * @param x 列数
+     * @param y 行数
+     */
+    elementsFromPoint(x, y) {
+        return this.elementsFromIndex(this.indexFromPos(y, x));
+    }
+    /**
+     * 判断标题是否是跨维基链接
+     * @param title 标题
+     */
+    isInterwiki(title) {
+        return index_1.default.isInterwiki(title, this.#config);
+    }
+    /** @private */
+    cloneChildNodes() {
+        return this.childNodes.map(child => child.cloneNode());
+    }
+    /** 深拷贝节点 */
+    cloneNode() {
+        if (this.constructor !== Token) {
+            this.constructorError('does not specify a cloneNode method');
+        }
+        const cloned = this.cloneChildNodes();
+        return debug_1.Shadow.run(() => {
+            const token = new Token(undefined, this.#config, [], this.getAcceptable());
+            token.type = this.type;
+            token.setAttribute('stage', this.#stage);
+            token.setAttribute('name', this.name);
+            token.append(...cloned);
+            token.protectChildren(...this.#protectedChildren);
+            return token;
+        });
+    }
+    /** 获取全部章节 */
+    sections() {
+        require('../addon/token');
+        return this.sections();
+    }
+    /**
+     * 获取指定章节
+     * @param n 章节序号
+     */
+    section(n) {
+        return this.sections()?.[n];
+    }
+    /**
+     * 获取指定的外层HTML标签
+     * @param tag HTML标签名
+     * @throws `RangeError` 非法的标签或空标签
+     */
+    findEnclosingHtml(tag) {
+        require('../addon/token');
+        return this.findEnclosingHtml(tag);
+    }
+    /** 获取全部分类 */
+    getCategories() {
+        const categories = this.querySelectorAll('category');
+        return categories.map(({ name, sortkey }) => [name, sortkey]);
+    }
+    /**
+     * 展开模板
+     * @param context 模板调用环境
+     */
+    expand() {
+        require('../addon/token');
+        return this.expand();
+    }
+    /** 解析部分魔术字 */
+    solveConst() {
+        require('../addon/token');
+        return this.solveConst();
+    }
+    /** 合并普通节点的普通子节点 */
+    flatten() {
+        if (this.getAttribute('plain')) {
+            for (const child of this.childNodes) {
+                if (child.type !== 'text' && child.getAttribute('plain')) {
+                    child.replaceWith(...child.childNodes);
+                }
+            }
+        }
+    }
+    /** 生成HTML */
+    toHtml() {
+        require('../addon/token');
+        return this.toHtml();
+    }
+    /** @private */
+    toHtmlInternal(nowrap, nocc) {
+        for (const child of this.childNodes) {
+            if (child.type === 'text') {
+                child.removeBlankLines();
+            }
+        }
+        for (let i = 0; i < this.length; i++) {
+            const child = this.childNodes[i];
+            if (child.is('list') || child.is('dd')) {
+                child.getRange();
+            }
+        }
+        this.normalize();
+        return (0, html_1.font)(this, (0, html_1.html)(this.childNodes, '', nowrap, nocc));
+    }
+}
+exports.Token = Token;
+constants_1.classes['Token'] = __filename;