wikiparser-node 1.4.2-b → 1.4.2

package/dist/src/index.js

@@ -0,0 +1,804 @@
+"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: CommentToken、NoIncludeToken和IncludeToken
+// d: ListToken
+// e: ExtToken
+// h: HeadingToken
+// l: LinkToken
+// m: `{{fullurl:}}`、`{{canonicalurl:}}`或`{{filepath:}}`
+// q: QuoteToken
+// r: HrToken
+// s: `{{{|subst:}}}`
+// t: ArgToken或TranscludeToken
+// u: DoubleUnderscoreToken
+// v: ConverterToken
+// w: ExtLinkToken
+// x: HtmlToken
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+const assert = require("assert/strict");
+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 ranges_1 = require("../lib/ranges");
+const range_1 = require("../lib/range");
+const index_1 = require("../index");
+const element_1 = require("../lib/element");
+const text_1 = require("../lib/text");
+/* NOT FOR BROWSER END */
+/**
+ * 所有节点的基类
+ * @classdesc `{childNodes: ...(AstText|Token)}`
+ */
+class Token extends element_1.AstElement {
+    type = 'root';
+    /** 解析阶段，参见顶部注释。只对plain Token有意义。 */
+    #stage = 0;
+    #config;
+    /** 这个数组起两个作用：1. 数组中的Token会在build时替换`/\0\d+.\x7F/`标记；2. 数组中的Token会依次执行parseOnce和build方法。 */
+    #accum;
+    #include;
+    /* NOT FOR BROWSER */
+    #acceptable;
+    #protectedChildren = new ranges_1.Ranges();
+    /** 所有图片，包括图库 */
+    get images() {
+        return this.querySelectorAll('file, gallery-image, imagemap-image');
+    }
+    /** 所有内链、外链和自由外链 */
+    get links() {
+        return this.querySelectorAll('link, ext-link, free-ext-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;
+        /* NOT FOR BROWSER */
+        this.setAttribute('acceptable', acceptable);
+        /* NOT FOR BROWSER END */
+        accum.push(this);
+    }
+    /** @private */
+    parseOnce(n = this.#stage, include = false) {
+        if (n < this.#stage || !this.getAttribute('plain') || this.length === 0) {
+            return this;
+        }
+        else if (this.#stage >= constants_1.MAX_STAGE) {
+            /* NOt FOR BROWSER */
+            if (this.type === 'root') {
+                index_1.default.error('已完全解析！');
+            }
+            /* NOT FOR BROWSER END */
+            return this;
+        }
+        switch (n) {
+            case 0:
+                if (this.type === 'root') {
+                    this.#accum.shift();
+                }
+                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);
+            }
+        }
+        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 (Number.isNaN(Number(s.slice(-1)))) {
+                return this.#accum[Number(s.slice(0, -1))];
+            }
+            throw new Error(`解析错误！未正确标记的 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;
+    }
+    /** 将占位符替换为子Token */
+    #build() {
+        this.#stage = constants_1.MAX_STAGE;
+        const { length, firstChild } = this, str = String(firstChild);
+        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();
+                }
+            }
+        }
+    }
+    /** @private */
+    afterBuild() {
+        if (this.type === 'root') {
+            for (const token of this.#accum) {
+                token.afterBuild();
+            }
+        }
+    }
+    /** @private */
+    parse(n = constants_1.MAX_STAGE, include = false) {
+        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;
+    }
+    /**
+     * 解析HTML注释和扩展标签
+     * @param includeOnly 是否嵌入
+     */
+    #parseCommentAndExt(includeOnly) {
+        const { parseCommentAndExt } = require('../parser/commentAndExt');
+        this.setText(parseCommentAndExt(String(this.firstChild), this.#config, this.#accum, includeOnly));
+    }
+    /** 解析花括号 */
+    #parseBraces() {
+        const { parseBraces } = require('../parser/braces');
+        const str = this.type === 'root' ? String(this.firstChild) : `\0${String(this.firstChild)}`, 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(String(this.firstChild), 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(String(this.firstChild), this.#config, this.#accum));
+    }
+    /** 解析单引号 */
+    #parseQuotes() {
+        if (this.#config.excludes?.includes('quote')) {
+            return;
+        }
+        const { parseQuotes } = require('../parser/quotes');
+        const lines = String(this.firstChild).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(String(this.firstChild), this.#config, this.#accum));
+    }
+    /** 解析自由外链 */
+    #parseMagicLinks() {
+        if (this.#config.excludes?.includes('magicLink')) {
+            return;
+        }
+        const { parseMagicLinks } = require('../parser/magicLinks');
+        this.setText(parseMagicLinks(String(this.firstChild), this.#config, this.#accum));
+    }
+    /** 解析列表 */
+    #parseList() {
+        if (this.#config.excludes?.includes('list')) {
+            return;
+        }
+        const { parseList } = require('../parser/list');
+        const lines = String(this.firstChild).split('\n');
+        let i = this.type === 'root' || this.type === 'ext-inner' && this.name === 'poem' ? 0 : 1;
+        for (; i < lines.length; i++) {
+            lines[i] = parseList(lines[i], this.#config, this.#accum);
+        }
+        this.setText(lines.join('\n'));
+    }
+    /** 解析语言变体转换 */
+    #parseConverter() {
+        if (this.#config.variants.length > 0) {
+            const { parseConverter } = require('../parser/converter');
+            this.setText(parseConverter(String(this.firstChild), this.#config, this.#accum));
+        }
+    }
+    /** @private */
+    getAttribute(key) {
+        switch (key) {
+            case 'plain':
+                return (this.constructor === Token);
+            case 'config':
+                return structuredClone(this.#config);
+            case 'accum':
+                return this.#accum;
+            case 'include': {
+                if (this.#include !== undefined) {
+                    return this.#include;
+                }
+                const root = this.getRootNode();
+                return (root !== this && root.getAttribute('include'));
+            }
+            /* NOT FOR BROWSER */
+            case 'stage':
+                return this.#stage;
+            case 'acceptable':
+                return (this.#acceptable ? { ...this.#acceptable } : undefined);
+            case 'protectedChildren':
+                return new ranges_1.Ranges(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': {
+                const acceptable = {};
+                if (value) {
+                    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);
+                        }
+                    }
+                }
+                this.#acceptable = value && acceptable;
+                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 */
+        if (!debug_1.Shadow.running && this.#acceptable) {
+            const acceptableIndices = Object.fromEntries(Object.entries(this.#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(`的第 ${i} 个子节点不能为 ${insertedName}`);
+            }
+            else if (nodesAfter.some(({ constructor: { name } }, j) => !acceptableIndices[name]?.includes(i + j + 1))) {
+                this.constructorError(`插入新的第 ${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.constructor === Token && this.getAttribute('plain')) {
+            index_1.default.warn('您正将一个普通节点作为另一个普通节点的子节点，请考虑要不要执行 flatten 方法。');
+        }
+        /* NOT FOR BROWSER END */
+        if (token.type === 'root') {
+            token.type = 'plain';
+        }
+        return token;
+    }
+    /**
+     * 规范化页面标题
+     * @param title 标题（含或不含命名空间前缀）
+     * @param defaultNs 命名空间
+     * @param halfParsed 仅供内部使用
+     * @param decode 是否需要解码
+     * @param selfLink 是否允许selfLink
+     */
+    normalizeTitle(title, defaultNs = 0, halfParsed = false, decode = false, selfLink = false) {
+        return index_1.default.normalizeTitle(title, defaultNs, this.#include, this.#config, halfParsed, decode, selfLink);
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    lint(start = this.getAbsoluteIndex()) {
+        const errors = super.lint(start);
+        if (this.type === 'root') {
+            const record = {};
+            for (const cat of this.querySelectorAll('category')) {
+                const thisCat = record[cat.name];
+                if (thisCat) {
+                    thisCat.add(cat);
+                }
+                else {
+                    record[cat.name] = new Set([cat]);
+                }
+            }
+            for (const value of Object.values(record)) {
+                if (value.size > 1) {
+                    errors.push(...[...value].map(cat => (0, lint_1.generateForSelf)(cat, { start: cat.getAbsoluteIndex() }, 'duplicated category')));
+                }
+            }
+        }
+        return errors;
+    }
+    /** @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(`的第 ${i} 个子节点不可移除`);
+            }
+            else if (this.#acceptable) {
+                const acceptableIndices = Object.fromEntries(Object.entries(this.#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(`移除第 ${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('不存在父节点！');
+        }
+        else if (token.constructor !== this.constructor) {
+            this.typeError('safeReplaceWith', this.constructor.name);
+        }
+        try {
+            assert.deepEqual(token.getAttribute('acceptable'), this.#acceptable);
+        }
+        catch (e) {
+            if (e instanceof assert.AssertionError) {
+                this.constructorError('带有不同的 #acceptable 属性');
+            }
+            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 = '') {
+        const { CommentToken } = require('./nowiki/comment');
+        const config = this.getAttribute('config');
+        // @ts-expect-error abstract class
+        return debug_1.Shadow.run(() => new CommentToken(data.replace(/-->/gu, '--&gt;'), true, config));
+    }
+    /**
+     * 创建标签
+     * @param tagName 标签名
+     * @param options 选项
+     * @param options.selfClosing 是否自封闭
+     * @param options.closing 是否是闭合标签
+     * @throws `RangeError` 非法的标签名
+     */
+    createElement(tagName, { selfClosing, closing } = {}) {
+        const config = this.getAttribute('config'), include = this.getAttribute('include');
+        if (tagName === (include ? 'noinclude' : 'includeonly')) {
+            const { IncludeToken } = require('./tagPair/include');
+            return debug_1.Shadow.run(
+            // @ts-expect-error abstract class
+            () => new IncludeToken(tagName, '', undefined, selfClosing ? undefined : tagName, config));
+        }
+        else if (config.ext.includes(tagName)) {
+            const { ExtToken } = require('./tagPair/ext');
+            // @ts-expect-error abstract class
+            return debug_1.Shadow.run(() => new ExtToken(tagName, '', undefined, selfClosing ? undefined : '', config));
+        }
+        else if (config.html.flat().includes(tagName)) {
+            const { HtmlToken } = require('./html'), { AttributesToken } = require('./attributes');
+            return debug_1.Shadow.run(() => {
+                // @ts-expect-error abstract class
+                const attr = new AttributesToken(undefined, 'html-attrs', tagName, config);
+                // @ts-expect-error abstract class
+                return new HtmlToken(tagName, attr, Boolean(closing), Boolean(selfClosing), config);
+            });
+        }
+        throw new RangeError(`非法的标签名：${tagName}`);
+    }
+    /**
+     * 创建纯文本节点
+     * @param data 文本内容
+     */
+    createTextNode(data = '') {
+        return new text_1.AstText(data);
+    }
+    /** 创建AstRange对象 */
+    createRange() {
+        return new range_1.AstRange();
+    }
+    /**
+     * 找到给定位置
+     * @param index 位置
+     */
+    caretPositionFromIndex(index) {
+        if (index === undefined) {
+            return undefined;
+        }
+        const { length } = String(this);
+        if (index >= length || index < -length) {
+            return undefined;
+        }
+        index += index < 0 ? length : 0;
+        let self = this, acc = 0, start = 0;
+        while (self.type !== 'text') {
+            const { childNodes } = self;
+            acc += self.getAttribute('padding');
+            for (let i = 0; acc <= index && i < childNodes.length; i++) {
+                const cur = childNodes[i], l = String(cur).length;
+                acc += l;
+                if (acc > index) {
+                    self = cur;
+                    acc -= l;
+                    start = acc;
+                    break;
+                }
+                acc += self.getGaps(i);
+            }
+            if (self.childNodes === childNodes) {
+                return { offsetNode: self, offset: index - start };
+            }
+        }
+        return { offsetNode: self, offset: index - start };
+    }
+    /**
+     * 找到给定位置
+     * @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('未定义复制方法');
+        }
+        const cloned = this.cloneChildNodes();
+        return debug_1.Shadow.run(() => {
+            const token = new Token(undefined, this.#config, [], this.#acceptable);
+            token.type = this.type;
+            token.setAttribute('name', this.name);
+            token.append(...cloned);
+            token.protectChildren(...this.#protectedChildren);
+            return token;
+        });
+    }
+    /** 获取全部章节 */
+    sections() {
+        if (this.type !== 'root') {
+            return undefined;
+        }
+        const { childNodes } = this, headings = [...childNodes.entries()]
+            .filter((entry) => entry[1].type === 'heading')
+            .map(([i, { level }]) => [i, level]), lastHeading = [-1, -1, -1, -1, -1, -1], sections = new Array(headings.length);
+        for (let i = 0; i < headings.length; i++) {
+            const [index, level] = headings[i];
+            for (let j = level; j < 6; j++) {
+                const last = lastHeading[j];
+                if (last >= 0) {
+                    sections[last] = childNodes.slice(headings[last][0], index);
+                }
+                lastHeading[j] = j === level ? i : -1;
+            }
+        }
+        for (const last of lastHeading) {
+            if (last >= 0) {
+                sections[last] = childNodes.slice(headings[last][0]);
+            }
+        }
+        sections.unshift(childNodes.slice(0, headings[0]?.[0]));
+        return sections;
+    }
+    /**
+     * 获取指定章节
+     * @param n 章节序号
+     */
+    section(n) {
+        return this.sections()?.[n];
+    }
+    /**
+     * 获取指定的外层HTML标签
+     * @param tag HTML标签名
+     * @throws `RangeError` 非法的标签或空标签
+     */
+    findEnclosingHtml(tag) {
+        tag = tag?.toLowerCase();
+        if (tag !== undefined && !this.#config.html.slice(0, 2).flat().includes(tag)) {
+            throw new RangeError(`非法的标签或空标签：${tag}`);
+        }
+        const { parentNode } = this;
+        if (!parentNode) {
+            return undefined;
+        }
+        const isHtml = (0, debug_1.isToken)('html'), { childNodes, length } = parentNode, index = childNodes.indexOf(this);
+        let i;
+        for (i = index - 1; i >= 0; i--) {
+            const child = childNodes[i];
+            if (isHtml(child) && (!tag || child.name === tag) && !child.selfClosing && !child.closing) {
+                break;
+            }
+        }
+        if (i === -1) {
+            return parentNode.findEnclosingHtml(tag);
+        }
+        const opening = childNodes[i];
+        for (i = index + 1; i < length; i++) {
+            const child = childNodes[i];
+            if (isHtml(child) && child.name === opening.name && !child.selfClosing && child.closing) {
+                break;
+            }
+        }
+        if (i === length) {
+            return parentNode.findEnclosingHtml(tag);
+        }
+        const range = this.createRange();
+        range.setStartBefore(opening);
+        range.setEnd(parentNode, i + 1);
+        return range;
+    }
+    /** 获取全部分类 */
+    getCategories() {
+        const categories = this.querySelectorAll('category');
+        return categories.map(({ name, sortkey }) => [name, sortkey]);
+    }
+    /** 重新解析单引号 */
+    redoQuotes() {
+        const acceptable = this.getAttribute('acceptable');
+        if (acceptable && !('QuoteToken' in acceptable)) {
+            return;
+        }
+        const accum = [];
+        for (const child of this.childNodes) {
+            if (child.type !== 'quote' && child.type !== 'text') {
+                child.replaceWith(`\0${accum.length}e\x7F`);
+                accum.push(child);
+            }
+        }
+        const token = debug_1.Shadow.run(() => {
+            const node = new Token(String(this), this.getAttribute('config'), accum);
+            node.type = 'plain';
+            node.setAttribute('stage', 6);
+            return node.parse(7);
+        });
+        this.setAttribute('childNodes', [...token.childNodes]);
+    }
+    /** 解析部分魔术字 */
+    solveConst() {
+        const targets = this.querySelectorAll('magic-word, arg'), magicWords = new Set(['if', 'ifeq', 'switch']);
+        for (let i = targets.length - 1; i >= 0; i--) {
+            const target = targets[i], { type, name, childNodes, length } = target, [, var1, var2] = childNodes;
+            if (type === 'arg' || type === 'magic-word' && magicWords.has(name)) {
+                let replace = '';
+                if (type === 'arg') {
+                    replace = target.default === false ? String(target) : target.default;
+                }
+                else if (name === 'if' && !var1?.getElementByTypes('magic-word, template')) {
+                    replace = String(childNodes[String(var1 ?? '').trim() ? 2 : 3] ?? '').trim();
+                }
+                else if (name === 'ifeq'
+                    && !childNodes.slice(1, 3).some(child => child.getElementByTypes('magic-word, template'))) {
+                    replace = String(childNodes[String(var1 ?? '').trim() === String(var2 ?? '').trim() ? 3 : 4] ?? '').trim();
+                }
+                else if (name === 'switch' && !var1?.getElementByTypes('magic-word, template')) {
+                    const key = String(var1 ?? '').trim();
+                    let defaultVal = '', found = false, transclusion = false;
+                    for (let j = 2; j < length; j++) {
+                        const { anon, name: option, value, firstChild } = childNodes[j];
+                        transclusion = Boolean(firstChild.getElementByTypes('magic-word, template'));
+                        if (anon) {
+                            if (j === length - 1) {
+                                defaultVal = value;
+                            }
+                            else if (transclusion) {
+                                break;
+                            }
+                            else {
+                                found ||= key === value;
+                            }
+                        }
+                        else if (transclusion) {
+                            break;
+                        }
+                        else if (found || option === key) {
+                            replace = value;
+                            break;
+                        }
+                        else if (option.toLowerCase() === '#default') {
+                            defaultVal = value;
+                        }
+                        if (j === length - 1) {
+                            replace = defaultVal;
+                        }
+                    }
+                    if (transclusion) {
+                        continue;
+                    }
+                }
+                else {
+                    continue;
+                }
+                target.replaceWith(replace);
+            }
+        }
+    }
+    /** 合并普通节点的普通子节点 */
+    flatten() {
+        if (this.getAttribute('plain')) {
+            for (const child of this.childNodes) {
+                if (child.type !== 'text' && child.getAttribute('plain')) {
+                    child.replaceWith(...child.childNodes);
+                }
+            }
+        }
+    }
+}
+exports.Token = Token;
+constants_1.classes['Token'] = __filename;